FastState.o.c++

typedef unsigned char   undefined;

typedef unsigned char    bool;
typedef unsigned char    byte;
typedef unsigned char    dwfenc;
typedef unsigned int    dword;
typedef unsigned long    qword;
typedef unsigned int    uint;
typedef unsigned long    ulong;
typedef unsigned char    undefined1;
typedef unsigned int    undefined4;
typedef unsigned long    undefined8;
typedef unsigned short    ushort;
typedef unsigned short    word;
typedef struct pair<int,int> pair<int,int>, *Ppair<int,int>;

struct pair<int,int> { // PlaceHolder Class Structure
};

typedef ulong size_t;

typedef struct array<std::pair<int,int>,24ul> array<std::pair<int,int>,24ul>, *Parray<std::pair<int,int>,24ul>;

struct array<std::pair<int,int>,24ul> { // PlaceHolder Class Structure
};

typedef struct array<unsigned_short,441ul> array<unsigned_short,441ul>, *Parray<unsigned_short,441ul>;

struct array<unsigned_short,441ul> { // PlaceHolder Class Structure
};

typedef struct array<int,24ul> array<int,24ul>, *Parray<int,24ul>;

struct array<int,24ul> { // PlaceHolder Class Structure
};

typedef struct array<int,9ul> array<int,9ul>, *Parray<int,9ul>;

struct array<int,9ul> { // PlaceHolder Class Structure
};

typedef struct array<unsigned_long_long,5ul> array<unsigned_long_long,5ul>, *Parray<unsigned_long_long,5ul>;

struct array<unsigned_long_long,5ul> { // PlaceHolder Class Structure
};

typedef struct FastBoard FastBoard, *PFastBoard;

struct FastBoard { // PlaceHolder Structure
};

typedef struct FullBoard FullBoard, *PFullBoard;

struct FullBoard { // PlaceHolder Structure
};

typedef struct Playout Playout, *PPlayout;

struct Playout { // PlaceHolder Structure
};

typedef struct FastState FastState, *PFastState;

struct FastState { // PlaceHolder Structure
};

typedef struct allocator<int> allocator<int>, *Pallocator<int>;

struct allocator<int> { // PlaceHolder Structure
};

typedef struct allocator<unsigned_long> allocator<unsigned_long>, *Pallocator<unsigned_long>;

struct allocator<unsigned_long> { // PlaceHolder Structure
};

typedef struct vector<int,std::allocator<int>> vector<int,std::allocator<int>>, *Pvector<int,std::allocator<int>>;

struct vector<int,std::allocator<int>> { // PlaceHolder Structure
};

typedef struct vector vector, *Pvector;

struct vector { // PlaceHolder Structure
};

typedef struct vector<bool,std::allocator<bool>> vector<bool,std::allocator<bool>>, *Pvector<bool,std::allocator<bool>>;

struct vector<bool,std::allocator<bool>> { // PlaceHolder Structure
};

typedef dword pair;

typedef struct allocator<bool> allocator<bool>, *Pallocator<bool>;

struct allocator<bool> { // PlaceHolder Structure
};

typedef dword random_access_iterator_tag;

typedef struct _Bit_iterator_base _Bit_iterator_base, *P_Bit_iterator_base;

struct _Bit_iterator_base { // PlaceHolder Structure
};

typedef struct allocator allocator, *Pallocator;

struct allocator { // PlaceHolder Structure
};

typedef struct _Bit_reference _Bit_reference, *P_Bit_reference;

struct _Bit_reference { // PlaceHolder Structure
};

typedef struct _Vector_base<int,std::allocator<int>> _Vector_base<int,std::allocator<int>>, *P_Vector_base<int,std::allocator<int>>;

struct _Vector_base<int,std::allocator<int>> { // PlaceHolder Structure
};

typedef struct _Bit_iterator _Bit_iterator, *P_Bit_iterator;

struct _Bit_iterator { // PlaceHolder Structure
};

typedef struct _Bvector_base<std::allocator<bool>> _Bvector_base<std::allocator<bool>>, *P_Bvector_base<std::allocator<bool>>;

struct _Bvector_base<std::allocator<bool>> { // PlaceHolder Structure
};

typedef struct _Bvector_impl _Bvector_impl, *P_Bvector_impl;

struct _Bvector_impl { // PlaceHolder Structure
};

typedef struct _Bvector_impl_data _Bvector_impl_data, *P_Bvector_impl_data;

struct _Bvector_impl_data { // PlaceHolder Structure
};

typedef dword iterator_category;

typedef struct basic_string<char,std::char_traits<char>,std::allocator<char>> basic_string<char,std::char_traits<char>,std::allocator<char>>, *Pbasic_string<char,std::char_traits<char>,std::allocator<char>>;

struct basic_string<char,std::char_traits<char>,std::allocator<char>> { // PlaceHolder Structure
};

typedef struct _Vector_impl _Vector_impl, *P_Vector_impl;

struct _Vector_impl { // PlaceHolder Structure
};

typedef struct _Vector_impl_data _Vector_impl_data, *P_Vector_impl_data;

struct _Vector_impl_data { // PlaceHolder Structure
};

typedef struct array array, *Parray;

struct array { // PlaceHolder Structure
};

typedef struct new_allocator new_allocator, *Pnew_allocator;

struct new_allocator { // PlaceHolder Structure
};

typedef struct new_allocator<unsigned_long> new_allocator<unsigned_long>, *Pnew_allocator<unsigned_long>;

struct new_allocator<unsigned_long> { // PlaceHolder Structure
};

typedef dword __normal_iterator;

typedef struct new_allocator<bool> new_allocator<bool>, *Pnew_allocator<bool>;

struct new_allocator<bool> { // PlaceHolder Structure
};

typedef struct new_allocator<int> new_allocator<int>, *Pnew_allocator<int>;

struct new_allocator<int> { // PlaceHolder Structure
};

typedef dword __type;

typedef dword difference_type;

typedef struct square_t square_t, *Psquare_t;

struct square_t { // PlaceHolder Structure
};

typedef struct __normal_iterator<int*,std::vector<int,std::allocator<int>>> __normal_iterator<int*,std::vector<int,std::allocator<int>>>, *P__normal_iterator<int*,std::vector<int,std::allocator<int>>>;

struct __normal_iterator<int*,std::vector<int,std::allocator<int>>> { // PlaceHolder Class Structure
};

typedef struct __normal_iterator<int_const*,std::vector<int,std::allocator<int>>> __normal_iterator<int_const*,std::vector<int,std::allocator<int>>>, *P__normal_iterator<int_const*,std::vector<int,std::allocator<int>>>;

struct __normal_iterator<int_const*,std::vector<int,std::allocator<int>>> { // PlaceHolder Class Structure
};

typedef struct Elf64_Shdr Elf64_Shdr, *PElf64_Shdr;

typedef enum Elf_SectionHeaderType {
    SHT_NULL=0,
    SHT_PROGBITS=1,
    SHT_SYMTAB=2,
    SHT_STRTAB=3,
    SHT_RELA=4,
    SHT_HASH=5,
    SHT_DYNAMIC=6,
    SHT_NOTE=7,
    SHT_NOBITS=8,
    SHT_REL=9,
    SHT_SHLIB=10,
    SHT_DYNSYM=11,
    SHT_INIT_ARRAY=14,
    SHT_FINI_ARRAY=15,
    SHT_PREINIT_ARRAY=16,
    SHT_GROUP=17,
    SHT_SYMTAB_SHNDX=18,
    SHT_ANDROID_REL=1610612737,
    SHT_ANDROID_RELA=1610612738,
    SHT_GNU_ATTRIBUTES=1879048181,
    SHT_GNU_HASH=1879048182,
    SHT_GNU_LIBLIST=1879048183,
    SHT_CHECKSUM=1879048184,
    SHT_SUNW_move=1879048186,
    SHT_SUNW_COMDAT=1879048187,
    SHT_SUNW_syminfo=1879048188,
    SHT_GNU_verdef=1879048189,
    SHT_GNU_verneed=1879048190,
    SHT_GNU_versym=1879048191
} Elf_SectionHeaderType;

struct Elf64_Shdr {
    dword sh_name;
    enum Elf_SectionHeaderType sh_type;
    qword sh_flags;
    qword sh_addr;
    qword sh_offset;
    qword sh_size;
    dword sh_link;
    dword sh_info;
    qword sh_addralign;
    qword sh_entsize;
};

typedef struct Elf64_Rela Elf64_Rela, *PElf64_Rela;

struct Elf64_Rela {
    qword r_offset; // location to apply the relocation action
    qword r_info; // the symbol table index and the type of relocation
    qword r_addend; // a constant addend used to compute the relocatable field value
};

typedef struct Elf64_Ehdr Elf64_Ehdr, *PElf64_Ehdr;

struct Elf64_Ehdr {
    byte e_ident_magic_num;
    char e_ident_magic_str[3];
    byte e_ident_class;
    byte e_ident_data;
    byte e_ident_version;
    byte e_ident_osabi;
    byte e_ident_abiversion;
    byte e_ident_pad[7];
    word e_type;
    word e_machine;
    dword e_version;
    qword e_entry;
    qword e_phoff;
    qword e_shoff;
    dword e_flags;
    word e_ehsize;
    word e_phentsize;
    word e_phnum;
    word e_shentsize;
    word e_shnum;
    word e_shstrndx;
};

typedef struct Elf64_Sym Elf64_Sym, *PElf64_Sym;

struct Elf64_Sym {
    dword st_name;
    byte st_info;
    byte st_other;
    word st_shndx;
    qword st_value;
    qword st_size;
};




// FastState::init_game(int, float)

void FastState::init_game(int param_1,float param_2)

{
  undefined4 in_register_0000003c;
  long lVar1;
  
  lVar1 = CONCAT44(in_register_0000003c,param_1);
  FullBoard::reset_board(param_1);
  *(undefined4 *)(lVar1 + 0x1f98) = 0;
  *(undefined4 *)(lVar1 + 0x1f94) = 0;
  *(undefined4 *)(lVar1 + 0x1f9c) = 0;
  *(undefined4 *)(lVar1 + 0x1fa0) = *(undefined4 *)(lVar1 + 0x1f9c);
  *(float *)(lVar1 + 0x1f88) = param_2;
  *(undefined4 *)(lVar1 + 0x1f8c) = 0;
  *(undefined4 *)(lVar1 + 0x1f90) = 0;
  return;
}



// FastState::set_komi(float)

void __thiscall FastState::set_komi(FastState *this,float param_1)

{
  *(float *)(this + 0x1f88) = param_1;
  return;
}



// FastState::reset_game()

void __thiscall FastState::reset_game(FastState *this)

{
  reset_board(this);
  *(undefined4 *)(this + 0x1f98) = 0;
  *(undefined4 *)(this + 0x1f90) = 0;
  *(undefined4 *)(this + 0x1f8c) = 0;
  *(undefined4 *)(this + 0x1f94) = 0;
  *(undefined4 *)(this + 0x1f9c) = 0x1b9;
  *(undefined4 *)(this + 0x1fa0) = *(undefined4 *)(this + 0x1f9c);
  return;
}



// FastState::reset_board()

void __thiscall FastState::reset_board(FastState *this)

{
  FastBoard::get_boardsize();
  FullBoard::reset_board((int)this);
  return;
}



// FastState::play_random_move()

void __thiscall FastState::play_random_move(FastState *this)

{
  play_random_move(this,*(int *)(this + 0x6e8));
  return;
}



// FastState::generate_moves(int)

FastState * __thiscall FastState::generate_moves(FastState *this,int param_1)

{
  bool bVar1;
  char cVar2;
  ushort *puVar3;
  undefined4 in_register_00000034;
  array_unsigned_short_441ul_ *this_00;
  uint local_24;
  int local_20;
  int local_1c;
  
  this_00 = (array_unsigned_short_441ul_ *)CONCAT44(in_register_00000034,param_1);
  std::vector<int,std::allocator<int>>::vector((vector_int_std__allocator_int__ *)this);
  std::vector<int,std::allocator<int>>::reserve
            ((vector_int_std__allocator_int__ *)this,(long)*(int *)(this_00 + 0x6e4));
  local_1c = 0;
  do {
    if (*(int *)(this_00 + 0x6e4) <= local_1c) {
      local_20 = -1;
      std::vector<int,std::allocator<int>>::push_back
                ((vector_int_std__allocator_int__ *)this,&local_20);
      return this;
    }
    puVar3 = (ushort *)boost::array<unsigned_short,441ul>::operator__(this_00,(long)local_1c);
    local_24 = (uint)*puVar3;
    if (*(uint *)(this_00 + 0x1f94) == local_24) {
LAB_0010021e:
      bVar1 = false;
    }
    else {
      cVar2 = FastBoard::is_suicide(param_1,local_24);
      if (cVar2 == '\x01') goto LAB_0010021e;
      bVar1 = true;
    }
    if (bVar1) {
      std::vector<int,std::allocator<int>>::push_back
                ((vector_int_std__allocator_int__ *)this,(int *)&local_24);
    }
    local_1c = local_1c + 1;
  } while( true );
}



// FastState::try_move(int, int, bool)

undefined8 __thiscall FastState::try_move(FastState *this,int param_1,int param_2,bool param_3)

{
  bool bVar1;
  char cVar2;
  int iVar3;
  int iVar4;
  
  iVar4 = (int)this;
  if ((param_2 == *(int *)(this + 0x1f94)) || (cVar2 = FastBoard::no_eye_fill(iVar4), cVar2 == '\0')
     ) {
    bVar1 = false;
  }
  else {
    bVar1 = true;
  }
  if ((bVar1) && (iVar3 = FastBoard::fast_ss_suicide(iVar4,param_1), iVar3 == 0)) {
    if ((param_3 == false) && (cVar2 = FastBoard::self_atari(iVar4,param_1), cVar2 == '\x01')) {
      bVar1 = false;
    }
    else {
      bVar1 = true;
    }
    if (bVar1) {
      return 1;
    }
  }
  return 0;
}



// FastState::walk_empty_list(int, int, bool)

uint __thiscall FastState::walk_empty_list(FastState *this,int param_1,int param_2,bool param_3)

{
  char cVar1;
  ushort uVar2;
  int iVar3;
  uint uVar4;
  ushort *puVar5;
  int local_18;
  int local_14;
  int local_10;
  int local_c;
  
  uVar2 = Random::get_Rng();
  iVar3 = Random::randint(uVar2);
  local_14 = param_2;
  local_c = param_2;
  if (iVar3 == 0) {
    for (; local_c < *(int *)(this + 0x6e4); local_c = local_c + 1) {
      puVar5 = (ushort *)
               boost::array<unsigned_short,441ul>::operator__
                         ((array_unsigned_short_441ul_ *)this,(long)local_c);
      uVar2 = *puVar5;
      cVar1 = try_move(this,param_1,(uint)uVar2,param_3);
      if (cVar1 != '\0') {
        return (uint)uVar2;
      }
    }
    for (local_10 = 0; local_10 < param_2; local_10 = local_10 + 1) {
      puVar5 = (ushort *)
               boost::array<unsigned_short,441ul>::operator__
                         ((array_unsigned_short_441ul_ *)this,(long)local_10);
      uVar2 = *puVar5;
      cVar1 = try_move(this,param_1,(uint)uVar2,param_3);
      if (cVar1 != '\0') {
        return (uint)uVar2;
      }
    }
LAB_001004e3:
    uVar4 = 0xffffffff;
  }
  else {
    for (; -1 < local_14; local_14 = local_14 + -1) {
      puVar5 = (ushort *)
               boost::array<unsigned_short,441ul>::operator__
                         ((array_unsigned_short_441ul_ *)this,(long)local_14);
      uVar2 = *puVar5;
      cVar1 = try_move(this,param_1,(uint)uVar2,param_3);
      if (cVar1 != '\0') {
        return (uint)uVar2;
      }
    }
    local_18 = *(int *)(this + 0x6e4);
    do {
      local_18 = local_18 + -1;
      if (local_18 <= param_2) goto LAB_001004e3;
      puVar5 = (ushort *)
               boost::array<unsigned_short,441ul>::operator__
                         ((array_unsigned_short_441ul_ *)this,(long)local_18);
      uVar4 = (uint)*puVar5;
      cVar1 = try_move(this,param_1,uVar4,param_3);
    } while (cVar1 == '\0');
  }
  return uVar4;
}



// FastState::play_random_move(int)

void __thiscall FastState::play_random_move(FastState *this,int param_1)

{
  int iVar1;
  bool bVar2;
  char cVar3;
  ushort uVar4;
  uint uVar5;
  int iVar6;
  int iVar7;
  int iVar8;
  pair pVar9;
  int iVar10;
  undefined8 uVar11;
  undefined4 extraout_var;
  undefined8 *puVar12;
  undefined4 extraout_var_00;
  long lVar13;
  int *piVar14;
  int local_8c;
  int iStack136;
  int local_4c;
  int local_48;
  int local_44;
  int local_40;
  int local_3c;
  int local_38;
  int local_30;
  int local_2c;
  int local_28;
  int local_24;
  int local_20;
  int local_1c;
  
  *(int *)(this + 0x6e8) = param_1;
  local_1c = 0;
  local_20 = 0;
  iVar10 = (int)this;
  if (((0 < *(int *)(this + 0x1f9c)) && (*(int *)(this + 0x1f9c) < *(int *)(this + 0x6ec))) &&
     (uVar5 = FastBoard::get_square(iVar10), uVar5 == (param_1 == 0))) {
    FastBoard::add_global_captures(iVar10,(array *)(ulong)(uint)param_1,(int *)(this + 0x1fa4));
    FastBoard::save_critical_neighbours
              (iVar10,param_1,(array *)(ulong)*(uint *)(this + 0x1f9c),(int *)(this + 0x1fa4));
    FastBoard::add_pattern_moves
              (iVar10,param_1,(array *)(ulong)*(uint *)(this + 0x1f9c),(int *)(this + 0x1fa4));
    local_1c = 0;
    for (local_24 = 0; local_24 < 0; local_24 = local_24 + 1) {
      piVar14 = (int *)boost::array<int,24ul>::operator__
                                 ((array_int_24ul_ *)(this + 0x1fa4),(long)local_24);
      if (*piVar14 == *(int *)(this + 0x1f94)) {
        local_1c = local_1c + -1;
      }
    }
  }
  iVar6 = Matcher::get_Matcher();
  if (0 < local_1c) {
    local_28 = 0;
    for (local_2c = 0; local_2c < 0; local_2c = local_2c + 1) {
      piVar14 = (int *)boost::array<int,24ul>::operator__
                                 ((array_int_24ul_ *)(this + 0x1fa4),(long)local_2c);
      iVar8 = *piVar14;
      if (iVar8 != *(int *)(this + 0x1f94)) {
        FastBoard::get_pattern_fast_augment(iVar10);
        iVar7 = Matcher::matches(iVar6,param_1);
        uVar11 = FastBoard::nbr_criticality(iVar10,param_1);
        local_8c = (int)uVar11;
        piVar14 = (int *)boost::array<int,9ul>::operator__
                                   ((array_int_9ul_ *)play_random_move(int)::crit_mine,
                                    (long)local_8c);
        iVar1 = *piVar14;
        iStack136 = (int)((ulong)uVar11 >> 0x20);
        piVar14 = (int *)boost::array<int,9ul>::operator__
                                   ((array_int_9ul_ *)play_random_move(int)::crit_enemy,
                                    (long)iStack136);
        local_30 = *piVar14 * iVar1 * iVar7;
        bVar2 = false;
        for (local_38 = 0; local_38 < 8; local_38 = local_38 + 1) {
          iVar1 = *(int *)(this + 0x1f9c);
          iVar7 = FastBoard::get_extra_dir(iVar10);
          if (iVar7 + iVar1 == iVar8) {
            bVar2 = true;
            break;
          }
        }
        if (!bVar2) {
          local_30 = local_30 * 0x14;
        }
        if (0x27 < local_30) {
          local_28 = local_28 + local_30;
          puVar12 = (undefined8 *)
                    boost::array<std::pair<int,int>,24ul>::operator__
                              ((array_std__pair_int_int__24ul_ *)(this + 0x2004),(long)local_20);
          pVar9 = std::make_pair_int_int_(iVar8,local_28);
          *puVar12 = CONCAT44(extraout_var,pVar9);
          local_20 = local_20 + 1;
        }
      }
    }
    uVar4 = Random::get_Rng();
    iVar8 = Random::randint(uVar4);
    for (local_3c = 0; local_3c < local_20; local_3c = local_3c + 1) {
      lVar13 = boost::array<std::pair<int,int>,24ul>::operator__
                         ((array_std__pair_int_int__24ul_ *)(this + 0x2004),(long)local_3c);
      if (iVar8 < *(int *)(lVar13 + 4)) {
        piVar14 = (int *)boost::array<std::pair<int,int>,24ul>::operator__
                                   ((array_std__pair_int_int__24ul_ *)(this + 0x2004),(long)local_3c
                                   );
        play_move_fast(this,*piVar14);
        return;
      }
    }
  }
  local_40 = 4;
  local_44 = 0;
  do {
    uVar4 = Random::get_Rng();
    iVar8 = Random::randint(uVar4);
    iVar8 = walk_empty_list(this,*(int *)(this + 0x6e8),iVar8,true);
    if (iVar8 == -1) {
      play_move_fast(this,-1);
      return;
    }
    FastBoard::get_pattern_fast_augment(iVar10);
    local_48 = Matcher::matches(iVar6,param_1);
    cVar3 = FastBoard::self_atari(iVar10,param_1);
    if (cVar3 != '\x01') {
      local_48 = local_48 << 6;
    }
    local_44 = local_44 + local_48;
    iVar1 = local_20 + 1;
    puVar12 = (undefined8 *)
              boost::array<std::pair<int,int>,24ul>::operator__
                        ((array_std__pair_int_int__24ul_ *)(this + 0x2004),(long)local_20);
    pVar9 = std::make_pair_int_int_(iVar8,local_44);
    *puVar12 = CONCAT44(extraout_var_00,pVar9);
    local_40 = local_40 + -1;
    local_20 = iVar1;
  } while (0 < local_40);
  uVar4 = Random::get_Rng();
  iVar10 = Random::randint(uVar4);
  local_4c = 0;
  while( true ) {
    if (iVar1 <= local_4c) {
      play_move_fast(this,-1);
      return;
    }
    lVar13 = boost::array<std::pair<int,int>,24ul>::operator__
                       ((array_std__pair_int_int__24ul_ *)(this + 0x2004),(long)local_4c);
    if (iVar10 < *(int *)(lVar13 + 4)) break;
    local_4c = local_4c + 1;
  }
  piVar14 = (int *)boost::array<std::pair<int,int>,24ul>::operator__
                             ((array_std__pair_int_int__24ul_ *)(this + 0x2004),(long)local_4c);
  play_move_fast(this,*piVar14);
  return;
}



// FastState::play_move_fast(int)

int __thiscall FastState::play_move_fast(FastState *this,int param_1)

{
  undefined4 uVar1;
  
  if (param_1 == -1) {
    increment_passes(this);
  }
  else {
    uVar1 = FastBoard::update_board_fast((int)this,*(int *)(this + 0x6e8));
    *(undefined4 *)(this + 0x1f94) = uVar1;
    set_passes(this,0);
  }
  *(undefined4 *)(this + 0x1fa0) = *(undefined4 *)(this + 0x1f9c);
  *(int *)(this + 0x1f9c) = param_1;
  *(uint *)(this + 0x6e8) = (uint)(*(int *)(this + 0x6e8) == 0);
  *(int *)(this + 0x1f98) = *(int *)(this + 0x1f98) + 1;
  return param_1;
}



// FastState::play_pass()

void __thiscall FastState::play_pass(FastState *this)

{
  int iVar1;
  ulong *puVar2;
  
  *(int *)(this + 0x1f98) = *(int *)(this + 0x1f98) + 1;
  *(undefined4 *)(this + 0x1fa0) = *(undefined4 *)(this + 0x1f9c);
  *(undefined4 *)(this + 0x1f9c) = 0xffffffff;
  *(ulong *)(this + 0x1f78) = *(ulong *)(this + 0x1f78) ^ 0xabcdabcdabcdabcd;
  *(uint *)(this + 0x6e8) = (uint)(*(int *)(this + 0x6e8) == 0);
  iVar1 = get_passes(this);
  puVar2 = (ulong *)boost::array<unsigned_long_long,5ul>::operator__
                              ((array_unsigned_long_long_5ul_ *)&Zobrist::zobrist_pass,(long)iVar1);
  *(ulong *)(this + 0x1f78) = *puVar2 ^ *(ulong *)(this + 0x1f78);
  increment_passes(this);
  iVar1 = get_passes(this);
  puVar2 = (ulong *)boost::array<unsigned_long_long,5ul>::operator__
                              ((array_unsigned_long_long_5ul_ *)&Zobrist::zobrist_pass,(long)iVar1);
  *(ulong *)(this + 0x1f78) = *puVar2 ^ *(ulong *)(this + 0x1f78);
  return;
}



// FastState::play_move(int)

void __thiscall FastState::play_move(FastState *this,int param_1)

{
  play_move(this,*(int *)(this + 0x6e8),param_1);
  return;
}



// FastState::play_move(int, int)

void __thiscall FastState::play_move(FastState *this,int param_1,int param_2)

{
  undefined4 uVar1;
  int iVar2;
  ulong *puVar3;
  
  if ((param_2 == -1) || (param_2 == -2)) {
    play_pass(this);
  }
  else {
    uVar1 = FullBoard::update_board((int)this,param_1);
    *(undefined4 *)(this + 0x1f94) = uVar1;
    *(undefined4 *)(this + 0x1fa0) = *(undefined4 *)(this + 0x1f9c);
    *(int *)(this + 0x1f9c) = param_2;
    *(int *)(this + 0x1f98) = *(int *)(this + 0x1f98) + 1;
    if (param_1 == *(int *)(this + 0x6e8)) {
      *(ulong *)(this + 0x1f78) = *(ulong *)(this + 0x1f78) ^ 0xabcdabcdabcdabcd;
    }
    *(uint *)(this + 0x6e8) = (uint)(param_1 == 0);
    iVar2 = get_passes(this);
    if (0 < iVar2) {
      iVar2 = get_passes(this);
      puVar3 = (ulong *)boost::array<unsigned_long_long,5ul>::operator__
                                  ((array_unsigned_long_long_5ul_ *)&Zobrist::zobrist_pass,
                                   (long)iVar2);
      *(ulong *)(this + 0x1f78) = *puVar3 ^ *(ulong *)(this + 0x1f78);
      set_passes(this,0);
      puVar3 = (ulong *)boost::array<unsigned_long_long,5ul>::operator__
                                  ((array_unsigned_long_long_5ul_ *)&Zobrist::zobrist_pass,0);
      *(ulong *)(this + 0x1f78) = *puVar3 ^ *(ulong *)(this + 0x1f78);
    }
  }
  return;
}



// FastState::get_movenum()

undefined4 __thiscall FastState::get_movenum(FastState *this)

{
  return *(undefined4 *)(this + 0x1f98);
}



// FastState::estimate_mc_score()

void __thiscall FastState::estimate_mc_score(FastState *this)

{
  FastBoard::estimate_mc_score(*(float *)(this + 0x1f88) + (float)*(int *)(this + 0x1f8c));
  return;
}



// FastState::calculate_mc_score()

void __thiscall FastState::calculate_mc_score(FastState *this)

{
  FastBoard::final_mc_score(*(float *)(this + 0x1f88) + (float)*(int *)(this + 0x1f8c));
  return;
}



// FastState::percentual_area_score()

void __thiscall FastState::percentual_area_score(FastState *this)

{
  FastBoard::percentual_area_score(*(float *)(this + 0x1f88) + (float)*(int *)(this + 0x1f8c));
  return;
}



// FastState::get_last_move()

undefined4 __thiscall FastState::get_last_move(FastState *this)

{
  return *(undefined4 *)(this + 0x1f9c);
}



// FastState::get_prevlast_move()

undefined4 __thiscall FastState::get_prevlast_move(FastState *this)

{
  return *(undefined4 *)(this + 0x1fa0);
}



// FastState::get_passes()

undefined4 __thiscall FastState::get_passes(FastState *this)

{
  return *(undefined4 *)(this + 0x1f90);
}



// FastState::set_passes(int)

void __thiscall FastState::set_passes(FastState *this,int param_1)

{
  *(int *)(this + 0x1f90) = param_1;
  return;
}



// FastState::increment_passes()

void __thiscall FastState::increment_passes(FastState *this)

{
  *(int *)(this + 0x1f90) = *(int *)(this + 0x1f90) + 1;
  if (4 < *(int *)(this + 0x1f90)) {
    *(undefined4 *)(this + 0x1f90) = 4;
  }
  return;
}



// FastState::get_to_move()

undefined4 __thiscall FastState::get_to_move(FastState *this)

{
  return *(undefined4 *)(this + 0x6e8);
}



// FastState::set_to_move(int)

void __thiscall FastState::set_to_move(FastState *this,int param_1)

{
  *(int *)(this + 0x6e8) = param_1;
  return;
}



// FastState::display_state()

void __thiscall FastState::display_state(FastState *this)

{
  char cVar1;
  uint uVar2;
  int iVar3;
  
  iVar3 = (int)this;
  uVar2 = FastBoard::get_prisoners(iVar3);
  Utils::myprintf("\nPasses: %d            Black (X) Prisoners: %d\n",
                  (ulong)*(uint *)(this + 0x1f90),(ulong)uVar2);
  cVar1 = FastBoard::black_to_move();
  if (cVar1 == '\0') {
    Utils::myprintf("White (O) to move");
  }
  else {
    Utils::myprintf("Black (X) to move");
  }
  uVar2 = FastBoard::get_prisoners(iVar3);
  Utils::myprintf("    White (O) Prisoners: %d\n",(ulong)uVar2);
  FullBoard::display_board(iVar3);
  return;
}



// FastState::move_to_text[abi:cxx11](int)

undefined8 FastState::move_to_text_abi_cxx11_(int param_1)

{
  undefined4 in_register_0000003c;
  
  FastBoard::move_to_text_abi_cxx11_(param_1);
  return CONCAT44(in_register_0000003c,param_1);
}



// WARNING: Could not reconcile some variable overlaps
// FastState::mark_dead()

vector_bool_std__allocator_bool__ * FastState::mark_dead(void)

{
  __normal_iterator _Var1;
  __normal_iterator _Var2;
  int iVar3;
  int *piVar4;
  FastState *in_RSI;
  int iVar5;
  vector_bool_std__allocator_bool__ *in_RDI;
  undefined auVar6 [16];
  Playout local_21f8 [128];
  FastState local_2178 [8400];
  vector_int_std__allocator_int__ local_a8 [31];
  allocator local_89;
  int local_88;
  allocator_bool_ local_82;
  allocator local_81;
  int local_80;
  undefined local_79;
  undefined local_78 [16];
  undefined local_68 [16];
  undefined local_58 [24];
  int local_40;
  int local_3c;
  int local_38;
  int local_34;
  undefined4 local_30;
  int local_2c;
  int local_28;
  int local_24;
  int local_20;
  int local_1c;
  
  std::allocator<int>::allocator();
  local_88 = 0;
  std::vector<int,std::allocator<int>>::vector(local_a8,0x1b9,&local_88,&local_89);
  std::allocator<int>::_allocator((allocator_int_ *)&local_89);
  std::allocator<bool>::allocator();
  local_81 = (allocator)0x0;
  std::vector<bool,std::allocator<bool>>::vector((ulong)in_RDI,(bool *)0x1b9,&local_81);
  std::allocator<bool>::_allocator(&local_82);
  local_80 = 0;
  _Var1 = std::vector<int,std::allocator<int>>::end(local_a8);
  _Var2 = std::vector<int,std::allocator<int>>::begin(local_a8);
  std::fill___gnu_cxx____normal_iterator_int__std__vector_int_std__allocator_int____int_
            (_Var2,_Var1,&local_80);
  local_79 = 0;
  local_78 = std::vector<bool,std::allocator<bool>>::end(in_RDI);
  local_68 = std::vector<bool,std::allocator<bool>>::begin(in_RDI);
  std::fill_std___Bit_iterator_bool_(SUB161(local_68,0),SUB161(local_68 >> 0x40,0),local_78._0_8_);
  for (local_1c = 0; iVar5 = (int)in_RSI, local_1c < 0x100; local_1c = local_1c + 1) {
    FastState(local_2178,in_RSI);
    Playout::Playout(local_21f8);
    Playout::run((FastState *)local_21f8,true);
    local_20 = 0;
    while( true ) {
      iVar3 = FastBoard::get_boardsize();
      if (iVar3 <= local_20) break;
      local_24 = 0;
      while( true ) {
        iVar3 = FastBoard::get_boardsize();
        if (iVar3 <= local_24) break;
        local_38 = FastBoard::get_vertex(iVar5,local_20);
        local_3c = FastBoard::get_square(iVar5);
        local_40 = FastBoard::get_square((int)register0x00000020 + -0x2178);
        if (local_3c == local_40) {
          piVar4 = (int *)std::vector<int,std::allocator<int>>::operator__(local_a8,(long)local_38);
          *piVar4 = *piVar4 + 1;
        }
        local_24 = local_24 + 1;
      }
      local_20 = local_20 + 1;
    }
    _FastState(local_2178);
  }
  local_30 = 0x33;
  local_28 = 0;
  while( true ) {
    iVar3 = FastBoard::get_boardsize();
    if (iVar3 <= local_28) break;
    local_2c = 0;
    while( true ) {
      iVar3 = FastBoard::get_boardsize();
      if (iVar3 <= local_2c) break;
      local_34 = FastBoard::get_vertex(iVar5,local_28);
      piVar4 = (int *)std::vector<int,std::allocator<int>>::operator__(local_a8,(long)local_34);
      if (*piVar4 < 0x33) {
        auVar6 = std::vector<bool,std::allocator<bool>>::operator__(in_RDI,(long)local_34);
        local_58._0_16_ = auVar6;
        std::_Bit_reference::operator_((_Bit_reference *)local_58,true);
      }
      local_2c = local_2c + 1;
    }
    local_28 = local_28 + 1;
  }
  std::vector<int,std::allocator<int>>::_vector(local_a8);
  return in_RDI;
}



// WARNING: Could not reconcile some variable overlaps
// FastState::final_score_map()

vector_int_std__allocator_int__ * FastState::final_score_map(void)

{
  int iVar1;
  bool bVar2;
  int iVar3;
  __normal_iterator _Var4;
  __normal_iterator _Var5;
  undefined4 *puVar6;
  FastState *in_RSI;
  vector_int_std__allocator_int__ *in_RDI;
  undefined auVar7 [16];
  vector_bool_std__allocator_bool__ local_21f8 [48];
  vector_bool_std__allocator_bool__ local_21c8 [48];
  vector_bool_std__allocator_bool__ local_2198 [48];
  FastState local_2168 [8400];
  undefined local_98 [28];
  undefined4 local_7c;
  undefined local_78 [16];
  undefined local_68 [16];
  undefined local_58 [16];
  undefined local_48 [24];
  int local_30;
  int local_2c;
  int local_28;
  int local_24;
  int local_20;
  int local_1c;
  
  FastState(local_2168,in_RSI);
  mark_dead();
  local_1c = 0;
  while( true ) {
    iVar3 = FastBoard::get_boardsize();
    iVar1 = (int)register0x00000020;
    if (iVar3 <= local_1c) break;
    local_20 = 0;
    while( true ) {
      iVar3 = FastBoard::get_boardsize();
      if (iVar3 <= local_20) break;
      local_30 = FastBoard::get_vertex(iVar1 + -0x2168,local_1c);
      auVar7 = std::vector<bool,std::allocator<bool>>::operator__(local_2198,(long)local_30);
      local_98._0_16_ = auVar7;
      bVar2 = std::_Bit_reference::operator_cast_to_bool((_Bit_reference *)local_98);
      if (bVar2 != false) {
        FastBoard::set_square(iVar1 + -0x2168,SUB41(local_30,0));
      }
      local_20 = local_20 + 1;
    }
    local_1c = local_1c + 1;
  }
  FastBoard::calc_reach_color(iVar1 + -0x21c8);
  FastBoard::calc_reach_color(iVar1 + -0x21f8);
  std::vector<int,std::allocator<int>>::vector(in_RDI);
  std::vector<int,std::allocator<int>>::resize(in_RDI,0x1b9,0);
  local_7c = 2;
  _Var4 = std::vector<int,std::allocator<int>>::end(in_RDI);
  _Var5 = std::vector<int,std::allocator<int>>::begin(in_RDI);
  std::
  fill___gnu_cxx____normal_iterator_int__std__vector_int_std__allocator_int____FastBoard__square_t_
            (_Var5,_Var4,(square_t *)&local_7c);
  local_24 = 0;
  do {
    iVar3 = FastBoard::get_boardsize();
    if (iVar3 <= local_24) {
      std::vector<bool,std::allocator<bool>>::_vector(local_21f8);
      std::vector<bool,std::allocator<bool>>::_vector(local_21c8);
      std::vector<bool,std::allocator<bool>>::_vector(local_2198);
      _FastState(local_2168);
      return in_RDI;
    }
    local_28 = 0;
    while( true ) {
      iVar3 = FastBoard::get_boardsize();
      if (iVar3 <= local_28) break;
      local_2c = FastBoard::get_vertex(iVar1 + -0x2168,local_24);
      auVar7 = std::vector<bool,std::allocator<bool>>::operator__(local_21c8,(long)local_2c);
      local_78 = auVar7;
      bVar2 = std::_Bit_reference::operator_cast_to_bool((_Bit_reference *)local_78);
      if (bVar2 == false) {
LAB_001016bc:
        bVar2 = false;
      }
      else {
        auVar7 = std::vector<bool,std::allocator<bool>>::operator__(local_21f8,(long)local_2c);
        local_68 = auVar7;
        bVar2 = std::_Bit_reference::operator_cast_to_bool((_Bit_reference *)local_68);
        if (bVar2 == true) goto LAB_001016bc;
        bVar2 = true;
      }
      if (bVar2) {
        puVar6 = (undefined4 *)
                 std::vector<int,std::allocator<int>>::operator__(in_RDI,(long)local_2c);
        *puVar6 = 1;
      }
      else {
        auVar7 = std::vector<bool,std::allocator<bool>>::operator__(local_21f8,(long)local_2c);
        local_58 = auVar7;
        bVar2 = std::_Bit_reference::operator_cast_to_bool((_Bit_reference *)local_58);
        if (bVar2 == false) {
LAB_00101752:
          bVar2 = false;
        }
        else {
          auVar7 = std::vector<bool,std::allocator<bool>>::operator__(local_21c8,(long)local_2c);
          local_48._0_16_ = auVar7;
          bVar2 = std::_Bit_reference::operator_cast_to_bool((_Bit_reference *)local_48);
          if (bVar2 == true) goto LAB_00101752;
          bVar2 = true;
        }
        if (bVar2) {
          puVar6 = (undefined4 *)
                   std::vector<int,std::allocator<int>>::operator__(in_RDI,(long)local_2c);
          *puVar6 = 0;
        }
      }
      local_28 = local_28 + 1;
    }
    local_24 = local_24 + 1;
  } while( true );
}



// WARNING: Could not reconcile some variable overlaps
// FastState::final_score()

void __thiscall FastState::final_score(FastState *this)

{
  bool bVar1;
  int iVar2;
  float extraout_XMM0_Da;
  undefined auVar3 [16];
  vector_bool_std__allocator_bool__ local_2138 [48];
  FastState local_2108 [8400];
  undefined local_38 [20];
  int local_24;
  int local_20;
  int local_1c;
  
  FastState(local_2108,this);
  mark_dead();
  local_1c = 0;
  while( true ) {
    iVar2 = FastBoard::get_boardsize();
    if (iVar2 <= local_1c) break;
    local_20 = 0;
    while( true ) {
      iVar2 = FastBoard::get_boardsize();
      if (iVar2 <= local_20) break;
      local_24 = FastBoard::get_vertex((int)register0x00000020 + -0x2108,local_1c);
      auVar3 = std::vector<bool,std::allocator<bool>>::operator__(local_2138,(long)local_24);
      local_38._0_16_ = auVar3;
      bVar1 = std::_Bit_reference::operator_cast_to_bool((_Bit_reference *)local_38);
      if (bVar1 != false) {
        FastBoard::set_square((int)register0x00000020 + -0x2108,SUB41(local_24,0));
      }
      local_20 = local_20 + 1;
    }
    local_1c = local_1c + 1;
  }
  get_komi(this);
  iVar2 = get_handicap(this);
  FastBoard::area_score((float)iVar2 + extraout_XMM0_Da);
  std::vector<bool,std::allocator<bool>>::_vector(local_2138);
  _FastState(local_2108);
  return;
}



// FastState::get_komi()

undefined4 __thiscall FastState::get_komi(FastState *this)

{
  return *(undefined4 *)(this + 0x1f88);
}



// FastState::set_handicap(int)

void __thiscall FastState::set_handicap(FastState *this,int param_1)

{
  *(int *)(this + 0x1f8c) = param_1;
  return;
}



// FastState::get_handicap()

undefined4 __thiscall FastState::get_handicap(FastState *this)

{
  return *(undefined4 *)(this + 0x1f8c);
}



// FastState::get_komove()

undefined4 __thiscall FastState::get_komove(FastState *this)

{
  return *(undefined4 *)(this + 0x1f94);
}



// WARNING: Unknown calling convention yet parameter storage is locked
// std::__size_to_integer(unsigned long)

ulong std::__size_to_integer(ulong param_1)

{
  return param_1;
}



// operator new(unsigned long, void*)

void * operator_new(ulong param_1,void *param_2)

{
  return param_2;
}



// std::_Bit_reference::_Bit_reference(unsigned long*, unsigned long)

void __thiscall
std::_Bit_reference::_Bit_reference(_Bit_reference *this,ulong *param_1,ulong param_2)

{
  *(ulong **)this = param_1;
  *(ulong *)(this + 8) = param_2;
  return;
}



// std::_Bit_reference::operator bool() const

bool __thiscall std::_Bit_reference::operator_cast_to_bool(_Bit_reference *this)

{
  return (*(ulong *)(this + 8) & **(ulong **)this) != 0;
}



// std::_Bit_reference::TEMPNAMEPLACEHOLDERVALUE(bool)

_Bit_reference * __thiscall std::_Bit_reference::operator_(_Bit_reference *this,bool param_1)

{
  if (param_1 == false) {
    **(ulong **)this = **(ulong **)this & ~*(ulong *)(this + 8);
  }
  else {
    **(ulong **)this = *(ulong *)(this + 8) | **(ulong **)this;
  }
  return this;
}



// std::_Bit_iterator_base::_Bit_iterator_base(unsigned long*, unsigned int)

void __thiscall
std::_Bit_iterator_base::_Bit_iterator_base(_Bit_iterator_base *this,ulong *param_1,uint param_2)

{
  *(ulong **)this = param_1;
  *(uint *)(this + 8) = param_2;
  return;
}



// std::_Bit_iterator_base::_M_incr(long)

void __thiscall std::_Bit_iterator_base::_M_incr(_Bit_iterator_base *this,long param_1)

{
  long lVar1;
  long lVar2;
  long local_10;
  
  lVar1 = param_1 + (ulong)*(uint *)(this + 8);
  lVar2 = lVar1;
  if (lVar1 < 0) {
    lVar2 = lVar1 + 0x3f;
  }
  *(long *)this = *(long *)this + (lVar2 >> 6) * 8;
  local_10 = (ulong)((int)lVar1 + ((uint)(lVar1 >> 0x5f) >> 0x1a) & 0x3f) -
             ((ulong)(lVar1 >> 0x3f) >> 0x3a);
  if (local_10 < 0) {
    local_10 = local_10 + 0x40;
    *(long *)this = *(long *)this + -8;
  }
  *(int *)(this + 8) = (int)local_10;
  return;
}



// std::_Bit_iterator::_Bit_iterator()

void __thiscall std::_Bit_iterator::_Bit_iterator(_Bit_iterator *this)

{
  _Bit_iterator_base::_Bit_iterator_base((_Bit_iterator_base *)this,(ulong *)0x0,0);
  return;
}



// std::_Bit_iterator::_Bit_iterator(unsigned long*, unsigned int)

void __thiscall std::_Bit_iterator::_Bit_iterator(_Bit_iterator *this,ulong *param_1,uint param_2)

{
  _Bit_iterator_base::_Bit_iterator_base((_Bit_iterator_base *)this,param_1,param_2);
  return;
}



// std::_Bit_iterator::TEMPNAMEPLACEHOLDERVALUE() const

undefined  [16] __thiscall std::_Bit_iterator::operator_(_Bit_iterator *this)

{
  undefined local_18 [16];
  
  _Bit_reference::_Bit_reference
            ((_Bit_reference *)local_18,*(ulong **)this,
             1 << ((byte)*(undefined4 *)(this + 8) & 0x3f));
  return local_18;
}



// std::_Bit_iterator::TEMPNAMEPLACEHOLDERVALUE(long)

_Bit_iterator * __thiscall std::_Bit_iterator::operator__(_Bit_iterator *this,long param_1)

{
  _Bit_iterator_base::_M_incr((_Bit_iterator_base *)this,param_1);
  return this;
}



// WARNING: Could not reconcile some variable overlaps
// std::_Bit_iterator::operator[](long) const

void __thiscall std::_Bit_iterator::operator__(_Bit_iterator *this,long param_1)

{
  undefined local_18 [16];
  
  local_18 = operator_(this,param_1);
  operator_((_Bit_iterator *)local_18);
  return;
}



// WARNING: Unknown calling convention yet parameter storage is locked
// std::TEMPNAMEPLACEHOLDERVALUE(std::_Bit_iterator const&, long)

undefined  [16] std::operator_(_Bit_iterator *param_1,long param_2)

{
  undefined8 local_28;
  undefined8 local_20;
  
  local_20 = *(undefined8 *)(param_1 + 8);
  local_28 = *(undefined8 *)param_1;
  _Bit_iterator::operator__((_Bit_iterator *)&local_28,param_2);
  return CONCAT88(local_20,local_28);
}



// WARNING: Unknown calling convention yet parameter storage is locked
// std::__fill_bvector(unsigned long*, unsigned int, unsigned int, bool)

void std::__fill_bvector(ulong *param_1,uint param_2,uint param_3,bool param_4)

{
  ulong uVar1;
  
  uVar1 = -1 << ((byte)param_2 & 0x3f) & 0xffffffffffffffffU >> (0x40U - (char)param_3 & 0x3f);
  if (param_4 == false) {
    *param_1 = *param_1 & ~uVar1;
  }
  else {
    *param_1 = *param_1 | uVar1;
  }
  return;
}



// WARNING: Unknown calling convention yet parameter storage is locked
// std::__fill_a1(std::_Bit_iterator, std::_Bit_iterator, bool const&)

void std::__fill_a1(_Bit_iterator param_1,_Bit_iterator param_2,bool *param_3)

{
  uint in_ECX;
  int __c;
  undefined7 in_register_00000031;
  undefined7 in_register_00000039;
  ulong *puVar1;
  char *in_R8;
  uint local_20;
  ulong *local_10;
  
  puVar1 = (ulong *)CONCAT71(in_register_00000039,param_1);
  local_20 = (uint)CONCAT71(in_register_00000031,param_2);
  if (puVar1 == (ulong *)param_3) {
    if (local_20 != in_ECX) {
      __fill_bvector(puVar1,local_20,in_ECX,(bool)*in_R8);
    }
  }
  else {
    local_10 = puVar1;
    if (local_20 != 0) {
      local_10 = puVar1 + 1;
      __fill_bvector(puVar1,local_20,0x40,(bool)*in_R8);
    }
    if (*in_R8 == '\0') {
      __c = 0;
    }
    else {
      __c = -1;
    }
    memset(local_10,__c,(long)param_3 - (long)local_10);
    if (in_ECX != 0) {
      __fill_bvector((ulong *)param_3,0,in_ECX,(bool)*in_R8);
    }
  }
  return;
}



// FastBoard::FastBoard(FastBoard const&)

void __thiscall FastBoard::FastBoard(FastBoard *this,FastBoard *param_1)

{
  undefined8 uVar1;
  long lVar2;
  ulong uVar3;
  undefined8 *puVar4;
  undefined8 *puVar5;
  
  puVar4 = (undefined8 *)param_1;
  puVar5 = (undefined8 *)this;
  for (lVar2 = 0x6e; lVar2 != 0; lVar2 = lVar2 + -1) {
    *puVar5 = *puVar4;
    puVar4 = puVar4 + 1;
    puVar5 = puVar5 + 1;
  }
  *(undefined2 *)puVar5 = *(undefined2 *)puVar4;
  *(undefined8 *)(this + 0x372) = *(undefined8 *)(param_1 + 0x372);
  *(undefined8 *)(this + 0x6dc) = *(undefined8 *)(param_1 + 0x6dc);
  lVar2 = (long)(this + 0x372) - (long)(undefined8 *)((ulong)(this + 0x37a) & 0xfffffffffffffff8);
  puVar4 = (undefined8 *)((long)(param_1 + 0x372) - lVar2);
  puVar5 = (undefined8 *)((ulong)(this + 0x37a) & 0xfffffffffffffff8);
  for (uVar3 = (ulong)((int)lVar2 + 0x372U >> 3); uVar3 != 0; uVar3 = uVar3 - 1) {
    *puVar5 = *puVar4;
    puVar4 = puVar4 + 1;
    puVar5 = puVar5 + 1;
  }
  *(undefined4 *)(this + 0x6e4) = *(undefined4 *)(param_1 + 0x6e4);
  *(undefined4 *)(this + 0x6e8) = *(undefined4 *)(param_1 + 0x6e8);
  *(undefined4 *)(this + 0x6ec) = *(undefined4 *)(param_1 + 0x6ec);
  puVar4 = (undefined8 *)(param_1 + 0x6f0);
  puVar5 = (undefined8 *)(this + 0x6f0);
  for (lVar2 = 0xdc; lVar2 != 0; lVar2 = lVar2 + -1) {
    *puVar5 = *puVar4;
    puVar4 = puVar4 + 1;
    puVar5 = puVar5 + 1;
  }
  *(undefined4 *)puVar5 = *(undefined4 *)puVar4;
  *(undefined8 *)(this + 0xdd4) = *(undefined8 *)(param_1 + 0xdd4);
  *(undefined8 *)(this + 0x1140) = *(undefined8 *)(param_1 + 0x1140);
  lVar2 = (long)(this + 0xdd4) - (long)(undefined8 *)((ulong)(this + 0xddc) & 0xfffffffffffffff8);
  puVar4 = (undefined8 *)((long)(param_1 + 0xdd4) - lVar2);
  puVar5 = (undefined8 *)((ulong)(this + 0xddc) & 0xfffffffffffffff8);
  for (uVar3 = (ulong)((int)lVar2 + 0x374U >> 3); uVar3 != 0; uVar3 = uVar3 - 1) {
    *puVar5 = *puVar4;
    puVar4 = puVar4 + 1;
    puVar5 = puVar5 + 1;
  }
  puVar4 = (undefined8 *)(param_1 + 0x1148);
  puVar5 = (undefined8 *)(this + 0x1148);
  for (lVar2 = 0x6e; lVar2 != 0; lVar2 = lVar2 + -1) {
    *puVar5 = *puVar4;
    puVar4 = puVar4 + 1;
    puVar5 = puVar5 + 1;
  }
  *(undefined4 *)puVar5 = *(undefined4 *)puVar4;
  *(undefined8 *)(this + 0x14bc) = *(undefined8 *)(param_1 + 0x14bc);
  *(undefined8 *)(this + 0x1828) = *(undefined8 *)(param_1 + 0x1828);
  lVar2 = (long)(this + 0x14bc) - (long)(undefined8 *)((ulong)(this + 0x14c4) & 0xfffffffffffffff8);
  puVar4 = (undefined8 *)((long)(param_1 + 0x14bc) - lVar2);
  puVar5 = (undefined8 *)((ulong)(this + 0x14c4) & 0xfffffffffffffff8);
  for (uVar3 = (ulong)((int)lVar2 + 0x374U >> 3); uVar3 != 0; uVar3 = uVar3 - 1) {
    *puVar5 = *puVar4;
    puVar4 = puVar4 + 1;
    puVar5 = puVar5 + 1;
  }
  puVar4 = (undefined8 *)(param_1 + 0x1830);
  puVar5 = (undefined8 *)(this + 0x1830);
  for (lVar2 = 0x6e; lVar2 != 0; lVar2 = lVar2 + -1) {
    *puVar5 = *puVar4;
    puVar4 = puVar4 + 1;
    puVar5 = puVar5 + 1;
  }
  *(undefined4 *)puVar5 = *(undefined4 *)puVar4;
  *(undefined8 *)(this + 0x1ba4) = *(undefined8 *)(param_1 + 0x1ba4);
  *(undefined8 *)(this + 0x1f0e) = *(undefined8 *)(param_1 + 0x1f0e);
  lVar2 = (long)(this + 0x1ba4) - (long)(undefined8 *)((ulong)(this + 0x1bac) & 0xfffffffffffffff8);
  puVar4 = (undefined8 *)((long)(param_1 + 0x1ba4) - lVar2);
  puVar5 = (undefined8 *)((ulong)(this + 0x1bac) & 0xfffffffffffffff8);
  for (uVar3 = (ulong)((int)lVar2 + 0x372U >> 3); uVar3 != 0; uVar3 = uVar3 - 1) {
    *puVar5 = *puVar4;
    puVar4 = puVar4 + 1;
    puVar5 = puVar5 + 1;
  }
  uVar1 = *(undefined8 *)(param_1 + 0x1f20);
  *(undefined8 *)(this + 0x1f18) = *(undefined8 *)(param_1 + 0x1f18);
  *(undefined8 *)(this + 0x1f20) = uVar1;
  uVar1 = *(undefined8 *)(param_1 + 0x1f30);
  *(undefined8 *)(this + 0x1f28) = *(undefined8 *)(param_1 + 0x1f28);
  *(undefined8 *)(this + 0x1f30) = uVar1;
  uVar1 = *(undefined8 *)(param_1 + 8000);
  *(undefined8 *)(this + 0x1f38) = *(undefined8 *)(param_1 + 0x1f38);
  *(undefined8 *)(this + 8000) = uVar1;
  *(undefined8 *)(this + 0x1f48) = *(undefined8 *)(param_1 + 0x1f48);
  *(undefined8 *)(this + 0x1f50) = *(undefined8 *)(param_1 + 0x1f50);
  std::vector<int,std::allocator<int>>::vector
            ((vector_int_std__allocator_int__ *)(this + 0x1f58),(vector *)(param_1 + 0x1f58));
  *(undefined4 *)(this + 0x1f70) = *(undefined4 *)(param_1 + 0x1f70);
  return;
}



// FastBoard::~FastBoard()

void __thiscall FastBoard::_FastBoard(FastBoard *this)

{
  std::vector<int,std::allocator<int>>::_vector((vector_int_std__allocator_int__ *)(this + 0x1f58));
  return;
}



// FullBoard::FullBoard(FullBoard const&)

void __thiscall FullBoard::FullBoard(FullBoard *this,FullBoard *param_1)

{
  FastBoard::FastBoard((FastBoard *)this,(FastBoard *)param_1);
  *(undefined8 *)(this + 0x1f78) = *(undefined8 *)(param_1 + 0x1f78);
  *(undefined8 *)(this + 0x1f80) = *(undefined8 *)(param_1 + 0x1f80);
  return;
}



// FullBoard::~FullBoard()

void __thiscall FullBoard::_FullBoard(FullBoard *this)

{
  FastBoard::_FastBoard((FastBoard *)this);
  return;
}



// FastState::FastState(FastState const&)

void __thiscall FastState::FastState(FastState *this,FastState *param_1)

{
  undefined8 uVar1;
  
  FullBoard::FullBoard((FullBoard *)this,(FullBoard *)param_1);
  *(undefined4 *)(this + 0x1f88) = *(undefined4 *)(param_1 + 0x1f88);
  *(undefined4 *)(this + 0x1f8c) = *(undefined4 *)(param_1 + 0x1f8c);
  *(undefined4 *)(this + 0x1f90) = *(undefined4 *)(param_1 + 0x1f90);
  *(undefined4 *)(this + 0x1f94) = *(undefined4 *)(param_1 + 0x1f94);
  *(undefined4 *)(this + 0x1f98) = *(undefined4 *)(param_1 + 0x1f98);
  *(undefined4 *)(this + 0x1f9c) = *(undefined4 *)(param_1 + 0x1f9c);
  *(undefined4 *)(this + 0x1fa0) = *(undefined4 *)(param_1 + 0x1fa0);
  uVar1 = *(undefined8 *)(param_1 + 0x1fac);
  *(undefined8 *)(this + 0x1fa4) = *(undefined8 *)(param_1 + 0x1fa4);
  *(undefined8 *)(this + 0x1fac) = uVar1;
  uVar1 = *(undefined8 *)(param_1 + 0x1fbc);
  *(undefined8 *)(this + 0x1fb4) = *(undefined8 *)(param_1 + 0x1fb4);
  *(undefined8 *)(this + 0x1fbc) = uVar1;
  uVar1 = *(undefined8 *)(param_1 + 0x1fcc);
  *(undefined8 *)(this + 0x1fc4) = *(undefined8 *)(param_1 + 0x1fc4);
  *(undefined8 *)(this + 0x1fcc) = uVar1;
  uVar1 = *(undefined8 *)(param_1 + 0x1fdc);
  *(undefined8 *)(this + 0x1fd4) = *(undefined8 *)(param_1 + 0x1fd4);
  *(undefined8 *)(this + 0x1fdc) = uVar1;
  uVar1 = *(undefined8 *)(param_1 + 0x1fec);
  *(undefined8 *)(this + 0x1fe4) = *(undefined8 *)(param_1 + 0x1fe4);
  *(undefined8 *)(this + 0x1fec) = uVar1;
  uVar1 = *(undefined8 *)(param_1 + 0x1ffc);
  *(undefined8 *)(this + 0x1ff4) = *(undefined8 *)(param_1 + 0x1ff4);
  *(undefined8 *)(this + 0x1ffc) = uVar1;
  uVar1 = *(undefined8 *)(param_1 + 0x200c);
  *(undefined8 *)(this + 0x2004) = *(undefined8 *)(param_1 + 0x2004);
  *(undefined8 *)(this + 0x200c) = uVar1;
  uVar1 = *(undefined8 *)(param_1 + 0x201c);
  *(undefined8 *)(this + 0x2014) = *(undefined8 *)(param_1 + 0x2014);
  *(undefined8 *)(this + 0x201c) = uVar1;
  uVar1 = *(undefined8 *)(param_1 + 0x202c);
  *(undefined8 *)(this + 0x2024) = *(undefined8 *)(param_1 + 0x2024);
  *(undefined8 *)(this + 0x202c) = uVar1;
  uVar1 = *(undefined8 *)(param_1 + 0x203c);
  *(undefined8 *)(this + 0x2034) = *(undefined8 *)(param_1 + 0x2034);
  *(undefined8 *)(this + 0x203c) = uVar1;
  uVar1 = *(undefined8 *)(param_1 + 0x204c);
  *(undefined8 *)(this + 0x2044) = *(undefined8 *)(param_1 + 0x2044);
  *(undefined8 *)(this + 0x204c) = uVar1;
  uVar1 = *(undefined8 *)(param_1 + 0x205c);
  *(undefined8 *)(this + 0x2054) = *(undefined8 *)(param_1 + 0x2054);
  *(undefined8 *)(this + 0x205c) = uVar1;
  uVar1 = *(undefined8 *)(param_1 + 0x206c);
  *(undefined8 *)(this + 0x2064) = *(undefined8 *)(param_1 + 0x2064);
  *(undefined8 *)(this + 0x206c) = uVar1;
  uVar1 = *(undefined8 *)(param_1 + 0x207c);
  *(undefined8 *)(this + 0x2074) = *(undefined8 *)(param_1 + 0x2074);
  *(undefined8 *)(this + 0x207c) = uVar1;
  uVar1 = *(undefined8 *)(param_1 + 0x208c);
  *(undefined8 *)(this + 0x2084) = *(undefined8 *)(param_1 + 0x2084);
  *(undefined8 *)(this + 0x208c) = uVar1;
  uVar1 = *(undefined8 *)(param_1 + 0x209c);
  *(undefined8 *)(this + 0x2094) = *(undefined8 *)(param_1 + 0x2094);
  *(undefined8 *)(this + 0x209c) = uVar1;
  uVar1 = *(undefined8 *)(param_1 + 0x20ac);
  *(undefined8 *)(this + 0x20a4) = *(undefined8 *)(param_1 + 0x20a4);
  *(undefined8 *)(this + 0x20ac) = uVar1;
  uVar1 = *(undefined8 *)(param_1 + 0x20bc);
  *(undefined8 *)(this + 0x20b4) = *(undefined8 *)(param_1 + 0x20b4);
  *(undefined8 *)(this + 0x20bc) = uVar1;
  return;
}



// FastState::~FastState()

void __thiscall FastState::_FastState(FastState *this)

{
  FullBoard::_FullBoard((FullBoard *)this);
  return;
}



// std::vector<int, std::allocator<int>>::vector()

void __thiscall std::vector<int,std::allocator<int>>::vector(vector_int_std__allocator_int__ *this)

{
  _Vector_base<int,std::allocator<int>>::_Vector_base((_Vector_base_int_std__allocator_int__ *)this)
  ;
  return;
}



// std::vector<int, std::allocator<int>>::~vector()

void __thiscall std::vector<int,std::allocator<int>>::_vector(vector_int_std__allocator_int__ *this)

{
  allocator *paVar1;
  
  paVar1 = (allocator *)
           _Vector_base<int,std::allocator<int>>::_M_get_Tp_allocator
                     ((_Vector_base_int_std__allocator_int__ *)this);
  _Destroy_int__int_(*(int **)this,*(int **)(this + 8),paVar1);
  _Vector_base<int,std::allocator<int>>::__Vector_base
            ((_Vector_base_int_std__allocator_int__ *)this);
  return;
}



// std::vector<int, std::allocator<int>>::reserve(unsigned long)

void __thiscall
std::vector<int,std::allocator<int>>::reserve(vector_int_std__allocator_int__ *this,ulong param_1)

{
  ulong uVar1;
  long lVar2;
  int *piVar3;
  allocator *paVar4;
  
  uVar1 = max_size(this);
  if (uVar1 < param_1) {
    std::__throw_length_error("vector::reserve");
  }
  uVar1 = capacity(this);
  if (uVar1 < param_1) {
    lVar2 = size(this);
    piVar3 = _M_allocate_and_copy_int__(this,param_1,*(int **)this,*(int **)(this + 8));
    paVar4 = (allocator *)
             _Vector_base<int,std::allocator<int>>::_M_get_Tp_allocator
                       ((_Vector_base_int_std__allocator_int__ *)this);
    _Destroy_int__int_(*(int **)this,*(int **)(this + 8),paVar4);
    _Vector_base<int,std::allocator<int>>::_M_deallocate
              ((_Vector_base_int_std__allocator_int__ *)this,*(int **)this,
               *(long *)(this + 0x10) - *(long *)this >> 2);
    *(int **)this = piVar3;
    *(int **)(this + 8) = piVar3 + lVar2;
    *(ulong *)(this + 0x10) = *(long *)this + param_1 * 4;
  }
  return;
}



// boost::array<unsigned short, 441ul>::operator[](unsigned long)

array_unsigned_short_441ul_ * __thiscall
boost::array<unsigned_short,441ul>::operator__(array_unsigned_short_441ul_ *this,ulong param_1)

{
  return this + param_1 * 2;
}



// std::vector<int, std::allocator<int>>::push_back(int const&)

void __thiscall
std::vector<int,std::allocator<int>>::push_back(vector_int_std__allocator_int__ *this,int *param_1)

{
  __normal_iterator _Var1;
  
  if (*(long *)(this + 8) == *(long *)(this + 0x10)) {
    _Var1 = end(this);
    _M_realloc_insert(this,_Var1,param_1);
  }
  else {
    __gnu_cxx::__alloc_traits<std::allocator<int>,int>::construct_int_
              ((allocator *)this,*(int **)(this + 8),param_1);
    *(long *)(this + 8) = *(long *)(this + 8) + 4;
  }
  return;
}



// std::vector<int, std::allocator<int>>::vector(std::vector<int, std::allocator<int>> const&)

void __thiscall
std::vector<int,std::allocator<int>>::vector(vector_int_std__allocator_int__ *this,vector *param_1)

{
  __normal_iterator _Var1;
  __normal_iterator _Var2;
  allocator *paVar3;
  ulong uVar4;
  int *piVar5;
  
  paVar3 = (allocator *)
           _Vector_base<int,std::allocator<int>>::_M_get_Tp_allocator
                     ((_Vector_base_int_std__allocator_int__ *)param_1);
  paVar3 = (allocator *)
           __gnu_cxx::__alloc_traits<std::allocator<int>,int>::_S_select_on_copy(paVar3);
  uVar4 = size((vector_int_std__allocator_int__ *)param_1);
  _Vector_base<int,std::allocator<int>>::_Vector_base
            ((_Vector_base_int_std__allocator_int__ *)this,uVar4,paVar3);
  paVar3 = (allocator *)
           _Vector_base<int,std::allocator<int>>::_M_get_Tp_allocator
                     ((_Vector_base_int_std__allocator_int__ *)this);
  piVar5 = *(int **)this;
  _Var1 = end((vector_int_std__allocator_int__ *)param_1);
  _Var2 = begin((vector_int_std__allocator_int__ *)param_1);
  piVar5 = __uninitialized_copy_a___gnu_cxx____normal_iterator_int_const__std__vector_int_std__allocator_int____int__int_
                     (_Var2,_Var1,piVar5,paVar3);
  *(int **)(this + 8) = piVar5;
  return;
}



// boost::array<int, 24ul>::operator[](unsigned long)

array_int_24ul_ * __thiscall boost::array<int,24ul>::operator__(array_int_24ul_ *this,ulong param_1)

{
  return this + param_1 * 4;
}



// boost::array<int, 9ul>::operator[](unsigned long) const

array_int_9ul_ * __thiscall boost::array<int,9ul>::operator__(array_int_9ul_ *this,ulong param_1)

{
  return this + param_1 * 4;
}



// boost::array<std::pair<int, int>, 24ul>::operator[](unsigned long)

array_std__pair_int_int__24ul_ * __thiscall
boost::array<std::pair<int,int>,24ul>::operator__
          (array_std__pair_int_int__24ul_ *this,ulong param_1)

{
  return this + param_1 * 8;
}



// WARNING: Unknown calling convention yet parameter storage is locked
// std::pair<int, int> std::make_pair<int, int>(int, int)

pair std::make_pair_int_int_(int param_1,int param_2)

{
  int local_20;
  int local_1c [3];
  pair local_10 [2];
  
  local_20 = param_2;
  local_1c[0] = param_1;
  pair<int,int>::pair((pair_int_int_ *)local_10,local_1c,&local_20);
  return local_10[0];
}



// boost::array<unsigned long long, 5ul>::operator[](unsigned long)

array_unsigned_long_long_5ul_ * __thiscall
boost::array<unsigned_long_long,5ul>::operator__(array_unsigned_long_long_5ul_ *this,ulong param_1)

{
  return this + param_1 * 8;
}



// std::allocator<int>::allocator()

void std::allocator<int>::allocator(void)

{
  __gnu_cxx::new_allocator<int>::new_allocator();
  return;
}



// std::allocator<int>::~allocator()

void __thiscall std::allocator<int>::_allocator(allocator_int_ *this)

{
  __gnu_cxx::new_allocator<int>::_new_allocator((new_allocator_int_ *)this);
  return;
}



// std::vector<int, std::allocator<int>>::vector(unsigned long, int const&, std::allocator<int>
// const&)

void __thiscall
std::vector<int,std::allocator<int>>::vector
          (vector_int_std__allocator_int__ *this,ulong param_1,int *param_2,allocator *param_3)

{
  ulong uVar1;
  
  uVar1 = _S_check_init_len(param_1,param_3);
  _Vector_base<int,std::allocator<int>>::_Vector_base
            ((_Vector_base_int_std__allocator_int__ *)this,uVar1,param_3);
  _M_fill_initialize(this,param_1,param_2);
  return;
}



// std::allocator<bool>::allocator()

void std::allocator<bool>::allocator(void)

{
  __gnu_cxx::new_allocator<bool>::new_allocator();
  return;
}



// std::allocator<bool>::~allocator()

void __thiscall std::allocator<bool>::_allocator(allocator_bool_ *this)

{
  __gnu_cxx::new_allocator<bool>::_new_allocator((new_allocator_bool_ *)this);
  return;
}



// std::vector<bool, std::allocator<bool>>::vector(unsigned long, bool const&, std::allocator<bool>
// const&)

void std::vector<bool,std::allocator<bool>>::vector(ulong param_1,bool *param_2,allocator *param_3)

{
  _Bvector_base<std::allocator<bool>>::_Bvector_base((allocator *)param_1);
  _M_initialize((vector_bool_std__allocator_bool__ *)param_1,(ulong)param_2);
  _M_initialize_value((vector_bool_std__allocator_bool__ *)param_1,(bool)*param_3);
  return;
}



// std::vector<bool, std::allocator<bool>>::~vector()

void __thiscall
std::vector<bool,std::allocator<bool>>::_vector(vector_bool_std__allocator_bool__ *this)

{
  _Bvector_base<std::allocator<bool>>::__Bvector_base((_Bvector_base_std__allocator_bool__ *)this);
  return;
}



// std::vector<int, std::allocator<int>>::begin()

undefined8 __thiscall
std::vector<int,std::allocator<int>>::begin(vector_int_std__allocator_int__ *this)

{
  undefined8 local_10;
  
  __gnu_cxx::__normal_iterator<int*,std::vector<int,std::allocator<int>>>::__normal_iterator
            ((__normal_iterator_int__std__vector_int_std__allocator_int___ *)&local_10,(int **)this)
  ;
  return local_10;
}



// std::vector<int, std::allocator<int>>::end()

undefined8 __thiscall
std::vector<int,std::allocator<int>>::end(vector_int_std__allocator_int__ *this)

{
  undefined8 local_10;
  
  __gnu_cxx::__normal_iterator<int*,std::vector<int,std::allocator<int>>>::__normal_iterator
            ((__normal_iterator_int__std__vector_int_std__allocator_int___ *)&local_10,
             (int **)(this + 8));
  return local_10;
}



// WARNING: Unknown calling convention yet parameter storage is locked
// void std::fill<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>,
// int>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>,
// __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>, int const&)

void std::fill___gnu_cxx____normal_iterator_int__std__vector_int_std__allocator_int____int_
               (__normal_iterator param_1,__normal_iterator param_2,int *param_3)

{
  __fill_a___gnu_cxx____normal_iterator_int__std__vector_int_std__allocator_int____int_
            (param_1,param_2,param_3);
  return;
}



// std::vector<bool, std::allocator<bool>>::begin()

undefined  [16] __thiscall
std::vector<bool,std::allocator<bool>>::begin(vector_bool_std__allocator_bool__ *this)

{
  undefined8 local_18;
  undefined8 local_10;
  
  _Bit_iterator::_Bit_iterator((_Bit_iterator *)&local_18,*(ulong **)this,0);
  return CONCAT88(local_10,local_18);
}



// std::vector<bool, std::allocator<bool>>::end()

undefined  [16] __thiscall
std::vector<bool,std::allocator<bool>>::end(vector_bool_std__allocator_bool__ *this)

{
  return *(undefined (*) [16])(this + 0x10);
}



// WARNING: Unknown calling convention yet parameter storage is locked
// void std::fill<std::_Bit_iterator, bool>(std::_Bit_iterator, std::_Bit_iterator, bool const&)

void std::fill_std___Bit_iterator_bool_(_Bit_iterator param_1,_Bit_iterator param_2,bool *param_3)

{
  __fill_a_std___Bit_iterator_bool_(param_1,param_2,param_3);
  return;
}



// std::vector<int, std::allocator<int>>::operator[](unsigned long)

long __thiscall
std::vector<int,std::allocator<int>>::operator__
          (vector_int_std__allocator_int__ *this,ulong param_1)

{
  return param_1 * 4 + *(long *)this;
}



// WARNING: Could not reconcile some variable overlaps
// std::vector<bool, std::allocator<bool>>::operator[](unsigned long)

void __thiscall
std::vector<bool,std::allocator<bool>>::operator__
          (vector_bool_std__allocator_bool__ *this,ulong param_1)

{
  undefined local_28 [24];
  
  local_28._0_16_ = begin(this);
  _Bit_iterator::operator__((_Bit_iterator *)local_28,param_1);
  return;
}



// std::vector<int, std::allocator<int>>::resize(unsigned long, int)

void __thiscall
std::vector<int,std::allocator<int>>::resize
          (vector_int_std__allocator_int__ *this,ulong param_1,int param_2)

{
  __normal_iterator _Var1;
  ulong uVar2;
  long lVar3;
  int local_2c;
  ulong local_28;
  long *local_20;
  
  local_2c = param_2;
  local_28 = param_1;
  local_20 = (long *)this;
  uVar2 = size(this);
  if (uVar2 < local_28) {
    lVar3 = size((vector_int_std__allocator_int__ *)local_20);
    uVar2 = local_28 - lVar3;
    _Var1 = end((vector_int_std__allocator_int__ *)local_20);
    _M_fill_insert((vector_int_std__allocator_int__ *)local_20,_Var1,uVar2,&local_2c);
  }
  else {
    uVar2 = size((vector_int_std__allocator_int__ *)local_20);
    if (local_28 < uVar2) {
      _M_erase_at_end((vector_int_std__allocator_int__ *)local_20,(int *)(*local_20 + local_28 * 4))
      ;
    }
  }
  return;
}



// WARNING: Unknown calling convention yet parameter storage is locked
// void std::fill<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>,
// FastBoard::square_t>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>,
// __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>, FastBoard::square_t
// const&)

void std::
     fill___gnu_cxx____normal_iterator_int__std__vector_int_std__allocator_int____FastBoard__square_t_
               (__normal_iterator param_1,__normal_iterator param_2,square_t *param_3)

{
  __fill_a___gnu_cxx____normal_iterator_int__std__vector_int_std__allocator_int____FastBoard__square_t_
            (param_1,param_2,param_3);
  return;
}



// std::_Vector_base<int, std::allocator<int>>::_Vector_impl::~_Vector_impl()

void __thiscall
std::_Vector_base<int,std::allocator<int>>::_Vector_impl::__Vector_impl(_Vector_impl *this)

{
  allocator<int>::_allocator((allocator_int_ *)this);
  return;
}



// std::_Vector_base<int, std::allocator<int>>::_Vector_base()

void __thiscall
std::_Vector_base<int,std::allocator<int>>::_Vector_base
          (_Vector_base_int_std__allocator_int__ *this)

{
  _Vector_impl::_Vector_impl((_Vector_impl *)this);
  return;
}



// std::_Vector_base<int, std::allocator<int>>::~_Vector_base()

void __thiscall
std::_Vector_base<int,std::allocator<int>>::__Vector_base
          (_Vector_base_int_std__allocator_int__ *this)

{
  _M_deallocate(this,*(int **)this,*(long *)(this + 0x10) - *(long *)this >> 2);
  _Vector_impl::__Vector_impl((_Vector_impl *)this);
  return;
}



// std::_Vector_base<int, std::allocator<int>>::_M_get_Tp_allocator()

_Vector_base_int_std__allocator_int__ * __thiscall
std::_Vector_base<int,std::allocator<int>>::_M_get_Tp_allocator
          (_Vector_base_int_std__allocator_int__ *this)

{
  return this;
}



// WARNING: Unknown calling convention yet parameter storage is locked
// void std::_Destroy<int*, int>(int*, int*, std::allocator<int>&)

void std::_Destroy_int__int_(int *param_1,int *param_2,allocator *param_3)

{
  _Destroy_int__(param_1,param_2);
  return;
}



// std::vector<int, std::allocator<int>>::max_size() const

void __thiscall
std::vector<int,std::allocator<int>>::max_size(vector_int_std__allocator_int__ *this)

{
  allocator *paVar1;
  
  paVar1 = (allocator *)
           _Vector_base<int,std::allocator<int>>::_M_get_Tp_allocator
                     ((_Vector_base_int_std__allocator_int__ *)this);
  _S_max_size(paVar1);
  return;
}



// std::vector<int, std::allocator<int>>::capacity() const

long __thiscall
std::vector<int,std::allocator<int>>::capacity(vector_int_std__allocator_int__ *this)

{
  return *(long *)(this + 0x10) - *(long *)this >> 2;
}



// std::vector<int, std::allocator<int>>::size() const

long __thiscall std::vector<int,std::allocator<int>>::size(vector_int_std__allocator_int__ *this)

{
  return *(long *)(this + 8) - *(long *)this >> 2;
}



// int* std::vector<int, std::allocator<int>>::_M_allocate_and_copy<int*>(unsigned long, int*, int*)

int * __thiscall
std::vector<int,std::allocator<int>>::_M_allocate_and_copy_int__
          (vector_int_std__allocator_int__ *this,ulong param_1,int *param_2,int *param_3)

{
  int *piVar1;
  allocator *paVar2;
  
  piVar1 = (int *)_Vector_base<int,std::allocator<int>>::_M_allocate
                            ((_Vector_base_int_std__allocator_int__ *)this,param_1);
  paVar2 = (allocator *)
           _Vector_base<int,std::allocator<int>>::_M_get_Tp_allocator
                     ((_Vector_base_int_std__allocator_int__ *)this);
  __uninitialized_copy_a_int__int__int_(param_2,param_3,piVar1,paVar2);
  return piVar1;
}



// std::_Vector_base<int, std::allocator<int>>::_M_deallocate(int*, unsigned long)

void __thiscall
std::_Vector_base<int,std::allocator<int>>::_M_deallocate
          (_Vector_base_int_std__allocator_int__ *this,int *param_1,ulong param_2)

{
  if (param_1 != (int *)0x0) {
    __gnu_cxx::__alloc_traits<std::allocator<int>,int>::deallocate
              ((allocator *)this,param_1,param_2);
  }
  return;
}



// void __gnu_cxx::__alloc_traits<std::allocator<int>, int>::construct<int>(std::allocator<int>&,
// int*, int const&)

void __gnu_cxx::__alloc_traits<std::allocator<int>,int>::construct_int_
               (allocator *param_1,int *param_2,int *param_3)

{
  new_allocator<int>::construct((new_allocator_int_ *)param_1,param_2,param_3);
  return;
}



// std::vector<int, std::allocator<int>>::_M_realloc_insert(__gnu_cxx::__normal_iterator<int*,
// std::vector<int, std::allocator<int>>>, int const&)

void __thiscall
std::vector<int,std::allocator<int>>::_M_realloc_insert
          (vector_int_std__allocator_int__ *this,__normal_iterator param_1,int *param_2)

{
  difference_type dVar1;
  undefined4 extraout_var;
  allocator *paVar2;
  int **ppiVar3;
  undefined4 in_register_00000034;
  undefined8 local_68;
  int **local_60;
  undefined8 local_50;
  int *local_48;
  long local_40;
  int *local_38;
  int *local_30;
  ulong local_28;
  int *local_20;
  
  local_68 = CONCAT44(in_register_00000034,param_1);
  local_60 = (int **)this;
  local_28 = _M_check_len(this,1,"vector::_M_realloc_insert");
  local_30 = *local_60;
  local_38 = local_60[1];
  local_50 = begin((vector_int_std__allocator_int__ *)local_60);
  dVar1 = __gnu_cxx::operator_((__normal_iterator *)&local_68,(__normal_iterator *)&local_50);
  local_40 = CONCAT44(extraout_var,dVar1);
  local_48 = (int *)_Vector_base<int,std::allocator<int>>::_M_allocate
                              ((_Vector_base_int_std__allocator_int__ *)local_60,local_28);
  local_20 = local_48;
  __gnu_cxx::__alloc_traits<std::allocator<int>,int>::construct_int_
            ((allocator *)local_60,local_48 + local_40,param_2);
  local_20 = (int *)0x0;
  paVar2 = (allocator *)
           _Vector_base<int,std::allocator<int>>::_M_get_Tp_allocator
                     ((_Vector_base_int_std__allocator_int__ *)local_60);
  ppiVar3 = (int **)__gnu_cxx::__normal_iterator<int*,std::vector<int,std::allocator<int>>>::base
                              ((__normal_iterator_int__std__vector_int_std__allocator_int___ *)
                               &local_68);
  local_20 = __uninitialized_move_if_noexcept_a_int__int__std__allocator_int__
                       (local_30,*ppiVar3,local_48,paVar2);
  local_20 = local_20 + 1;
  paVar2 = (allocator *)
           _Vector_base<int,std::allocator<int>>::_M_get_Tp_allocator
                     ((_Vector_base_int_std__allocator_int__ *)local_60);
  ppiVar3 = (int **)__gnu_cxx::__normal_iterator<int*,std::vector<int,std::allocator<int>>>::base
                              ((__normal_iterator_int__std__vector_int_std__allocator_int___ *)
                               &local_68);
  local_20 = __uninitialized_move_if_noexcept_a_int__int__std__allocator_int__
                       (*ppiVar3,local_38,local_20,paVar2);
  paVar2 = (allocator *)
           _Vector_base<int,std::allocator<int>>::_M_get_Tp_allocator
                     ((_Vector_base_int_std__allocator_int__ *)local_60);
  _Destroy_int__int_(local_30,local_38,paVar2);
  _Vector_base<int,std::allocator<int>>::_M_deallocate
            ((_Vector_base_int_std__allocator_int__ *)local_60,local_30,
             (long)local_60[2] - (long)local_30 >> 2);
  *local_60 = local_48;
  local_60[1] = local_20;
  local_60[2] = local_48 + local_28;
  return;
}



// __gnu_cxx::__alloc_traits<std::allocator<int>, int>::_S_select_on_copy(std::allocator<int>
// const&)

allocator *
__gnu_cxx::__alloc_traits<std::allocator<int>,int>::_S_select_on_copy(allocator *param_1)

{
  return param_1;
}



// std::_Vector_base<int, std::allocator<int>>::_M_get_Tp_allocator() const

_Vector_base_int_std__allocator_int__ * __thiscall
std::_Vector_base<int,std::allocator<int>>::_M_get_Tp_allocator
          (_Vector_base_int_std__allocator_int__ *this)

{
  return this;
}



// std::_Vector_base<int, std::allocator<int>>::_Vector_base(unsigned long, std::allocator<int>
// const&)

void __thiscall
std::_Vector_base<int,std::allocator<int>>::_Vector_base
          (_Vector_base_int_std__allocator_int__ *this,ulong param_1,allocator *param_2)

{
  _Vector_impl::_Vector_impl((_Vector_impl *)this,param_2);
  _M_create_storage(this,param_1);
  return;
}



// std::vector<int, std::allocator<int>>::begin() const

undefined8 __thiscall
std::vector<int,std::allocator<int>>::begin(vector_int_std__allocator_int__ *this)

{
  undefined8 local_10;
  
  __gnu_cxx::__normal_iterator<int_const*,std::vector<int,std::allocator<int>>>::__normal_iterator
            ((__normal_iterator_int_const__std__vector_int_std__allocator_int___ *)&local_10,
             (int **)this);
  return local_10;
}



// std::vector<int, std::allocator<int>>::end() const

undefined8 __thiscall
std::vector<int,std::allocator<int>>::end(vector_int_std__allocator_int__ *this)

{
  undefined8 local_10;
  
  __gnu_cxx::__normal_iterator<int_const*,std::vector<int,std::allocator<int>>>::__normal_iterator
            ((__normal_iterator_int_const__std__vector_int_std__allocator_int___ *)&local_10,
             (int **)(this + 8));
  return local_10;
}



// WARNING: Unknown calling convention yet parameter storage is locked
// int* std::__uninitialized_copy_a<__gnu_cxx::__normal_iterator<int const*, std::vector<int,
// std::allocator<int>>>, int*, int>(__gnu_cxx::__normal_iterator<int const*, std::vector<int,
// std::allocator<int>>>, __gnu_cxx::__normal_iterator<int const*, std::vector<int,
// std::allocator<int>>>, int*, std::allocator<int>&)

int * std::
      __uninitialized_copy_a___gnu_cxx____normal_iterator_int_const__std__vector_int_std__allocator_int____int__int_
                (__normal_iterator param_1,__normal_iterator param_2,int *param_3,allocator *param_4
                )

{
  int *piVar1;
  
  piVar1 = uninitialized_copy___gnu_cxx____normal_iterator_int_const__std__vector_int_std__allocator_int____int__
                     (param_1,param_2,param_3);
  return piVar1;
}



// std::pair<int, int>::pair(int const&, int const&)

void __thiscall std::pair<int,int>::pair(pair_int_int_ *this,int *param_1,int *param_2)

{
  *(int *)this = *param_1;
  *(int *)(this + 4) = *param_2;
  return;
}



// __gnu_cxx::new_allocator<int>::new_allocator()

void __gnu_cxx::new_allocator<int>::new_allocator(void)

{
  return;
}



// __gnu_cxx::new_allocator<int>::~new_allocator()

void __thiscall __gnu_cxx::new_allocator<int>::_new_allocator(new_allocator_int_ *this)

{
  return;
}



// std::vector<int, std::allocator<int>>::_S_check_init_len(unsigned long, std::allocator<int>
// const&)

ulong std::vector<int,std::allocator<int>>::_S_check_init_len(ulong param_1,allocator *param_2)

{
  ulong uVar1;
  allocator local_19 [9];
  
  allocator<int>::allocator(local_19);
  uVar1 = _S_max_size(local_19);
  allocator<int>::_allocator((allocator_int_ *)local_19);
  if (uVar1 < param_1) {
    std::__throw_length_error("cannot create std::vector larger than max_size()");
  }
  return param_1;
}



// std::vector<int, std::allocator<int>>::_M_fill_initialize(unsigned long, int const&)

void __thiscall
std::vector<int,std::allocator<int>>::_M_fill_initialize
          (vector_int_std__allocator_int__ *this,ulong param_1,int *param_2)

{
  allocator *paVar1;
  int *piVar2;
  
  paVar1 = (allocator *)
           _Vector_base<int,std::allocator<int>>::_M_get_Tp_allocator
                     ((_Vector_base_int_std__allocator_int__ *)this);
  piVar2 = __uninitialized_fill_n_a_int__unsigned_long_int_int_
                     (*(int **)this,param_1,param_2,paVar1);
  *(int **)(this + 8) = piVar2;
  return;
}



// __gnu_cxx::new_allocator<bool>::new_allocator()

void __gnu_cxx::new_allocator<bool>::new_allocator(void)

{
  return;
}



// __gnu_cxx::new_allocator<bool>::~new_allocator()

void __thiscall __gnu_cxx::new_allocator<bool>::_new_allocator(new_allocator_bool_ *this)

{
  return;
}



// std::_Bvector_base<std::allocator<bool>>::_Bvector_impl::~_Bvector_impl()

void __thiscall
std::_Bvector_base<std::allocator<bool>>::_Bvector_impl::__Bvector_impl(_Bvector_impl *this)

{
  allocator<unsigned_long>::_allocator((allocator_unsigned_long_ *)this);
  return;
}



// std::_Bvector_base<std::allocator<bool>>::_Bvector_base(std::allocator<bool> const&)

void std::_Bvector_base<std::allocator<bool>>::_Bvector_base(allocator *param_1)

{
  allocator local_19 [9];
  
  allocator<unsigned_long>::allocator_bool_(local_19);
  _Bvector_impl::_Bvector_impl((_Bvector_impl *)param_1,local_19);
  allocator<unsigned_long>::_allocator((allocator_unsigned_long_ *)local_19);
  return;
}



// std::_Bvector_base<std::allocator<bool>>::~_Bvector_base()

void __thiscall
std::_Bvector_base<std::allocator<bool>>::__Bvector_base(_Bvector_base_std__allocator_bool__ *this)

{
  _M_deallocate(this);
  _Bvector_impl::__Bvector_impl((_Bvector_impl *)this);
  return;
}



// std::vector<bool, std::allocator<bool>>::_M_initialize(unsigned long)

void __thiscall
std::vector<bool,std::allocator<bool>>::_M_initialize
          (vector_bool_std__allocator_bool__ *this,ulong param_1)

{
  long lVar1;
  ulong *puVar2;
  undefined auVar3 [12];
  undefined8 local_38;
  undefined4 local_30;
  ulong *local_10;
  
  if (param_1 != 0) {
    local_10 = (ulong *)_Bvector_base<std::allocator<bool>>::_M_allocate
                                  ((_Bvector_base_std__allocator_bool__ *)this,param_1);
    lVar1 = _Bvector_base<std::allocator<bool>>::_S_nword(param_1);
    *(ulong **)(this + 0x20) = local_10 + lVar1;
    puVar2 = __addressof_unsigned_long_(local_10);
    _Bit_iterator::_Bit_iterator((_Bit_iterator *)&local_38,puVar2,0);
    *(undefined8 *)this = local_38;
    *(undefined4 *)(this + 8) = local_30;
    auVar3 = operator_((_Bit_iterator *)&local_38,param_1);
    *(long *)(this + 0x10) = SUB128(auVar3,0);
    *(int *)(this + 0x18) = SUB124(auVar3 >> 0x40,0);
  }
  return;
}



// std::vector<bool, std::allocator<bool>>::_M_initialize_value(bool)

void __thiscall
std::vector<bool,std::allocator<bool>>::_M_initialize_value
          (vector_bool_std__allocator_bool__ *this,bool param_1)

{
  void *__s;
  long lVar1;
  int __c;
  
  __s = *(void **)this;
  if (__s != (void *)0x0) {
    lVar1 = _Bvector_base<std::allocator<bool>>::_Bvector_impl::_M_end_addr((_Bvector_impl *)this);
    if (param_1 == false) {
      __c = 0;
    }
    else {
      __c = -1;
    }
    memset(__s,__c,lVar1 - (long)__s);
  }
  return;
}



// __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>::__normal_iterator(int*
// const&)

void __thiscall
__gnu_cxx::__normal_iterator<int*,std::vector<int,std::allocator<int>>>::__normal_iterator
          (__normal_iterator_int__std__vector_int_std__allocator_int___ *this,int **param_1)

{
  *(int **)this = *param_1;
  return;
}



// WARNING: Unknown calling convention yet parameter storage is locked
// void std::__fill_a<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>,
// int>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>,
// __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>, int const&)

void std::__fill_a___gnu_cxx____normal_iterator_int__std__vector_int_std__allocator_int____int_
               (__normal_iterator param_1,__normal_iterator param_2,int *param_3)

{
  __fill_a1_int__std__vector_int_std__allocator_int___int_(param_1,param_2,param_3);
  return;
}



// WARNING: Unknown calling convention yet parameter storage is locked
// void std::__fill_a<std::_Bit_iterator, bool>(std::_Bit_iterator, std::_Bit_iterator, bool const&)

void std::__fill_a_std___Bit_iterator_bool_
               (_Bit_iterator param_1,_Bit_iterator param_2,bool *param_3)

{
  __fill_a1(param_1,param_2,param_3);
  return;
}



// std::vector<int, std::allocator<int>>::_M_fill_insert(__gnu_cxx::__normal_iterator<int*,
// std::vector<int, std::allocator<int>>>, unsigned long, int const&)

void __thiscall
std::vector<int,std::allocator<int>>::_M_fill_insert
          (vector_int_std__allocator_int__ *this,__normal_iterator param_1,ulong param_2,
          int *param_3)

{
  long lVar1;
  difference_type dVar2;
  undefined4 extraout_var;
  allocator *paVar3;
  int **ppiVar4;
  long *plVar5;
  int *piVar6;
  undefined4 extraout_var_00;
  undefined4 in_register_00000034;
  undefined8 local_78;
  int **local_70;
  int local_5c;
  undefined8 local_58;
  undefined8 local_50;
  int *local_48;
  ulong local_40;
  int *local_38;
  long local_30;
  ulong local_28;
  int *local_20;
  
  local_78 = CONCAT44(in_register_00000034,param_1);
  if (param_2 != 0) {
    local_70 = (int **)this;
    if ((ulong)(*(long *)(this + 0x10) - *(long *)(this + 8) >> 2) < param_2) {
      local_28 = _M_check_len(this,param_2,"vector::_M_fill_insert");
      local_50 = begin((vector_int_std__allocator_int__ *)local_70);
      dVar2 = __gnu_cxx::operator_((__normal_iterator *)&local_78,(__normal_iterator *)&local_50);
      local_30 = CONCAT44(extraout_var_00,dVar2);
      local_38 = (int *)_Vector_base<int,std::allocator<int>>::_M_allocate
                                  ((_Vector_base_int_std__allocator_int__ *)local_70,local_28);
      local_20 = local_38;
      paVar3 = (allocator *)
               _Vector_base<int,std::allocator<int>>::_M_get_Tp_allocator
                         ((_Vector_base_int_std__allocator_int__ *)local_70);
      __uninitialized_fill_n_a_int__unsigned_long_int_int_
                (local_38 + local_30,param_2,param_3,paVar3);
      local_20 = (int *)0x0;
      paVar3 = (allocator *)
               _Vector_base<int,std::allocator<int>>::_M_get_Tp_allocator
                         ((_Vector_base_int_std__allocator_int__ *)local_70);
      ppiVar4 = (int **)__gnu_cxx::__normal_iterator<int*,std::vector<int,std::allocator<int>>>::
                        base((__normal_iterator_int__std__vector_int_std__allocator_int___ *)
                             &local_78);
      local_20 = __uninitialized_move_if_noexcept_a_int__int__std__allocator_int__
                           (*local_70,*ppiVar4,local_38,paVar3);
      local_20 = local_20 + param_2;
      paVar3 = (allocator *)
               _Vector_base<int,std::allocator<int>>::_M_get_Tp_allocator
                         ((_Vector_base_int_std__allocator_int__ *)local_70);
      piVar6 = local_70[1];
      ppiVar4 = (int **)__gnu_cxx::__normal_iterator<int*,std::vector<int,std::allocator<int>>>::
                        base((__normal_iterator_int__std__vector_int_std__allocator_int___ *)
                             &local_78);
      local_20 = __uninitialized_move_if_noexcept_a_int__int__std__allocator_int__
                           (*ppiVar4,piVar6,local_20,paVar3);
      paVar3 = (allocator *)
               _Vector_base<int,std::allocator<int>>::_M_get_Tp_allocator
                         ((_Vector_base_int_std__allocator_int__ *)local_70);
      _Destroy_int__int_(*local_70,local_70[1],paVar3);
      _Vector_base<int,std::allocator<int>>::_M_deallocate
                ((_Vector_base_int_std__allocator_int__ *)local_70,*local_70,
                 (long)local_70[2] - (long)*local_70 >> 2);
      *local_70 = local_38;
      local_70[1] = local_20;
      local_70[2] = local_38 + local_28;
    }
    else {
      local_5c = *param_3;
      local_58 = end(this);
      dVar2 = __gnu_cxx::operator_((__normal_iterator *)&local_58,(__normal_iterator *)&local_78);
      local_40 = CONCAT44(extraout_var,dVar2);
      local_48 = *(int **)((long)local_70 + 8);
      if (param_2 < local_40) {
        paVar3 = (allocator *)
                 _Vector_base<int,std::allocator<int>>::_M_get_Tp_allocator
                           ((_Vector_base_int_std__allocator_int__ *)local_70);
        __uninitialized_move_a_int__int__std__allocator_int__
                  ((int *)(*(long *)((long)local_70 + 8) + param_2 * -4),
                   *(int **)((long)local_70 + 8),*(int **)((long)local_70 + 8),paVar3);
        *(ulong *)((long)local_70 + 8) = *(long *)((long)local_70 + 8) + param_2 * 4;
        piVar6 = local_48 + -param_2;
        ppiVar4 = (int **)__gnu_cxx::__normal_iterator<int*,std::vector<int,std::allocator<int>>>::
                          base((__normal_iterator_int__std__vector_int_std__allocator_int___ *)
                               &local_78);
        copy_backward_int__int__(*ppiVar4,piVar6,local_48);
        plVar5 = (long *)__gnu_cxx::__normal_iterator<int*,std::vector<int,std::allocator<int>>>::
                         base((__normal_iterator_int__std__vector_int_std__allocator_int___ *)
                              &local_78);
        lVar1 = *plVar5;
        ppiVar4 = (int **)__gnu_cxx::__normal_iterator<int*,std::vector<int,std::allocator<int>>>::
                          base((__normal_iterator_int__std__vector_int_std__allocator_int___ *)
                               &local_78);
        fill_int__int_(*ppiVar4,(int *)(lVar1 + param_2 * 4),&local_5c);
      }
      else {
        paVar3 = (allocator *)
                 _Vector_base<int,std::allocator<int>>::_M_get_Tp_allocator
                           ((_Vector_base_int_std__allocator_int__ *)local_70);
        piVar6 = __uninitialized_fill_n_a_int__unsigned_long_int_int_
                           (*(int **)((long)local_70 + 8),param_2 - local_40,&local_5c,paVar3);
        *(int **)((long)local_70 + 8) = piVar6;
        paVar3 = (allocator *)
                 _Vector_base<int,std::allocator<int>>::_M_get_Tp_allocator
                           ((_Vector_base_int_std__allocator_int__ *)local_70);
        piVar6 = *(int **)((long)local_70 + 8);
        ppiVar4 = (int **)__gnu_cxx::__normal_iterator<int*,std::vector<int,std::allocator<int>>>::
                          base((__normal_iterator_int__std__vector_int_std__allocator_int___ *)
                               &local_78);
        __uninitialized_move_a_int__int__std__allocator_int__(*ppiVar4,local_48,piVar6,paVar3);
        *(ulong *)((long)local_70 + 8) = *(long *)((long)local_70 + 8) + local_40 * 4;
        ppiVar4 = (int **)__gnu_cxx::__normal_iterator<int*,std::vector<int,std::allocator<int>>>::
                          base((__normal_iterator_int__std__vector_int_std__allocator_int___ *)
                               &local_78);
        fill_int__int_(*ppiVar4,local_48,&local_5c);
      }
    }
  }
  return;
}



// std::vector<int, std::allocator<int>>::_M_erase_at_end(int*)

void __thiscall
std::vector<int,std::allocator<int>>::_M_erase_at_end
          (vector_int_std__allocator_int__ *this,int *param_1)

{
  allocator *paVar1;
  
  if (*(long *)(this + 8) - (long)param_1 >> 2 != 0) {
    paVar1 = (allocator *)
             _Vector_base<int,std::allocator<int>>::_M_get_Tp_allocator
                       ((_Vector_base_int_std__allocator_int__ *)this);
    _Destroy_int__int_(param_1,*(int **)(this + 8),paVar1);
    *(int **)(this + 8) = param_1;
  }
  return;
}



// WARNING: Unknown calling convention yet parameter storage is locked
// void std::__fill_a<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>,
// FastBoard::square_t>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>,
// __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>, FastBoard::square_t
// const&)

void std::
     __fill_a___gnu_cxx____normal_iterator_int__std__vector_int_std__allocator_int____FastBoard__square_t_
               (__normal_iterator param_1,__normal_iterator param_2,square_t *param_3)

{
  __fill_a1_int__std__vector_int_std__allocator_int___FastBoard__square_t_(param_1,param_2,param_3);
  return;
}



// std::_Vector_base<int, std::allocator<int>>::_Vector_impl::_Vector_impl()

void __thiscall
std::_Vector_base<int,std::allocator<int>>::_Vector_impl::_Vector_impl(_Vector_impl *this)

{
  allocator<int>::allocator();
  _Vector_impl_data::_Vector_impl_data((_Vector_impl_data *)this);
  return;
}



// WARNING: Unknown calling convention yet parameter storage is locked
// void std::_Destroy<int*>(int*, int*)

void std::_Destroy_int__(int *param_1,int *param_2)

{
  _Destroy_aux<true>::__destroy_int__(param_1,param_2);
  return;
}



// std::vector<int, std::allocator<int>>::_S_max_size(std::allocator<int> const&)

ulong std::vector<int,std::allocator<int>>::_S_max_size(allocator *param_1)

{
  ulong *puVar1;
  ulong local_18;
  ulong local_10;
  
  local_10 = 0x1fffffffffffffff;
  local_18 = __gnu_cxx::__alloc_traits<std::allocator<int>,int>::max_size(param_1);
  puVar1 = min_unsigned_long_(&local_10,&local_18);
  return *puVar1;
}



// std::_Vector_base<int, std::allocator<int>>::_M_allocate(unsigned long)

undefined8 __thiscall
std::_Vector_base<int,std::allocator<int>>::_M_allocate
          (_Vector_base_int_std__allocator_int__ *this,ulong param_1)

{
  undefined8 uVar1;
  
  if (param_1 == 0) {
    uVar1 = 0;
  }
  else {
    uVar1 = __gnu_cxx::__alloc_traits<std::allocator<int>,int>::allocate((allocator *)this,param_1);
  }
  return uVar1;
}



// WARNING: Unknown calling convention yet parameter storage is locked
// int* std::__uninitialized_copy_a<int*, int*, int>(int*, int*, int*, std::allocator<int>&)

int * std::__uninitialized_copy_a_int__int__int_
                (int *param_1,int *param_2,int *param_3,allocator *param_4)

{
  int *piVar1;
  
  piVar1 = uninitialized_copy_int__int__(param_1,param_2,param_3);
  return piVar1;
}



// __gnu_cxx::__alloc_traits<std::allocator<int>, int>::deallocate(std::allocator<int>&, int*,
// unsigned long)

void __gnu_cxx::__alloc_traits<std::allocator<int>,int>::deallocate
               (allocator *param_1,int *param_2,ulong param_3)

{
  new_allocator<int>::deallocate((int *)param_1,(ulong)param_2);
  return;
}



// __gnu_cxx::new_allocator<int>::construct(int*, int const&)

void __thiscall
__gnu_cxx::new_allocator<int>::construct(new_allocator_int_ *this,int *param_1,int *param_2)

{
  int *piVar1;
  
  piVar1 = (int *)operator_new(4,param_1);
  *piVar1 = *param_2;
  return;
}



// std::vector<int, std::allocator<int>>::_M_check_len(unsigned long, char const*) const

ulong __thiscall
std::vector<int,std::allocator<int>>::_M_check_len
          (vector_int_std__allocator_int__ *this,ulong param_1,char *param_2)

{
  long lVar1;
  long lVar2;
  ulong *puVar3;
  ulong uVar4;
  ulong local_38;
  vector_int_std__allocator_int__ *local_30;
  ulong local_28;
  ulong local_20;
  
  local_38 = param_1;
  local_30 = this;
  lVar1 = max_size(this);
  lVar2 = size(local_30);
  if ((ulong)(lVar1 - lVar2) < local_38) {
    std::__throw_length_error(param_2);
  }
  lVar1 = size(local_30);
  local_28 = size(local_30);
  puVar3 = max_unsigned_long_(&local_28,&local_38);
  local_20 = *puVar3 + lVar1;
  uVar4 = size(local_30);
  if ((local_20 < uVar4) || (uVar4 = max_size(local_30), uVar4 < local_20)) {
    local_20 = max_size(local_30);
  }
  return local_20;
}



// __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>::difference_type
// __gnu_cxx::TEMPNAMEPLACEHOLDERVALUE(__gnu_cxx::__normal_iterator<int*, std::vector<int,
// std::allocator<int>>> const&, __gnu_cxx::__normal_iterator<int*, std::vector<int,
// std::allocator<int>>> const&)

difference_type __gnu_cxx::operator_(__normal_iterator *param_1,__normal_iterator *param_2)

{
  long lVar1;
  long *plVar2;
  
  plVar2 = (long *)__normal_iterator<int*,std::vector<int,std::allocator<int>>>::base
                             ((__normal_iterator_int__std__vector_int_std__allocator_int___ *)
                              param_1);
  lVar1 = *plVar2;
  plVar2 = (long *)__normal_iterator<int*,std::vector<int,std::allocator<int>>>::base
                             ((__normal_iterator_int__std__vector_int_std__allocator_int___ *)
                              param_2);
  return (difference_type)(lVar1 - *plVar2 >> 2);
}



// __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>::base() const

__normal_iterator_int__std__vector_int_std__allocator_int___ * __thiscall
__gnu_cxx::__normal_iterator<int*,std::vector<int,std::allocator<int>>>::base
          (__normal_iterator_int__std__vector_int_std__allocator_int___ *this)

{
  return this;
}



// WARNING: Unknown calling convention yet parameter storage is locked
// int* std::__uninitialized_move_if_noexcept_a<int*, int*, std::allocator<int>>(int*, int*, int*,
// std::allocator<int>&)

int * std::__uninitialized_move_if_noexcept_a_int__int__std__allocator_int__
                (int *param_1,int *param_2,int *param_3,allocator *param_4)

{
  int *piVar1;
  
  piVar1 = __uninitialized_copy_a_int__int__int_(param_1,param_2,param_3,param_4);
  return piVar1;
}



// __gnu_cxx::__alloc_traits<std::allocator<int>, int>::destroy(std::allocator<int>&, int*)

void __gnu_cxx::__alloc_traits<std::allocator<int>,int>::destroy(allocator *param_1,int *param_2)

{
  new_allocator<int>::destroy((int *)param_1);
  return;
}



// std::_Vector_base<int, std::allocator<int>>::_Vector_impl::_Vector_impl(std::allocator<int>
// const&)

void __thiscall
std::_Vector_base<int,std::allocator<int>>::_Vector_impl::_Vector_impl
          (_Vector_impl *this,allocator *param_1)

{
  allocator<int>::allocator((allocator *)this);
  _Vector_impl_data::_Vector_impl_data((_Vector_impl_data *)this);
  return;
}



// std::_Vector_base<int, std::allocator<int>>::_M_create_storage(unsigned long)

void __thiscall
std::_Vector_base<int,std::allocator<int>>::_M_create_storage
          (_Vector_base_int_std__allocator_int__ *this,ulong param_1)

{
  undefined8 uVar1;
  
  uVar1 = _M_allocate(this,param_1);
  *(undefined8 *)this = uVar1;
  *(undefined8 *)(this + 8) = *(undefined8 *)this;
  *(ulong *)(this + 0x10) = *(long *)this + param_1 * 4;
  return;
}



// __gnu_cxx::__normal_iterator<int const*, std::vector<int,
// std::allocator<int>>>::__normal_iterator(int const* const&)

void __thiscall
__gnu_cxx::__normal_iterator<int_const*,std::vector<int,std::allocator<int>>>::__normal_iterator
          (__normal_iterator_int_const__std__vector_int_std__allocator_int___ *this,int **param_1)

{
  *(int **)this = *param_1;
  return;
}



// WARNING: Unknown calling convention yet parameter storage is locked
// int* std::uninitialized_copy<__gnu_cxx::__normal_iterator<int const*, std::vector<int,
// std::allocator<int>>>, int*>(__gnu_cxx::__normal_iterator<int const*, std::vector<int,
// std::allocator<int>>>, __gnu_cxx::__normal_iterator<int const*, std::vector<int,
// std::allocator<int>>>, int*)

int * std::
      uninitialized_copy___gnu_cxx____normal_iterator_int_const__std__vector_int_std__allocator_int____int__
                (__normal_iterator param_1,__normal_iterator param_2,int *param_3)

{
  int *piVar1;
  
  piVar1 = __uninitialized_copy<true>::
           __uninit_copy___gnu_cxx____normal_iterator_int_const__std__vector_int_std__allocator_int____int__
                     (param_1,param_2,param_3);
  return piVar1;
}



// std::allocator<int>::allocator(std::allocator<int> const&)

void std::allocator<int>::allocator(allocator *param_1)

{
  __gnu_cxx::new_allocator<int>::new_allocator((new_allocator *)param_1);
  return;
}



// WARNING: Unknown calling convention yet parameter storage is locked
// int* std::__uninitialized_fill_n_a<int*, unsigned long, int, int>(int*, unsigned long, int
// const&, std::allocator<int>&)

int * std::__uninitialized_fill_n_a_int__unsigned_long_int_int_
                (int *param_1,ulong param_2,int *param_3,allocator *param_4)

{
  int *piVar1;
  
  piVar1 = uninitialized_fill_n_int__unsigned_long_int_(param_1,param_2,param_3);
  return piVar1;
}



// std::allocator<unsigned long>::allocator<bool>(std::allocator<bool> const&)

void std::allocator<unsigned_long>::allocator_bool_(allocator *param_1)

{
  __gnu_cxx::new_allocator<unsigned_long>::new_allocator();
  return;
}



// std::allocator<unsigned long>::~allocator()

void __thiscall std::allocator<unsigned_long>::_allocator(allocator_unsigned_long_ *this)

{
  __gnu_cxx::new_allocator<unsigned_long>::_new_allocator((new_allocator_unsigned_long_ *)this);
  return;
}



// std::_Bvector_base<std::allocator<bool>>::_Bvector_impl::_Bvector_impl(std::allocator<unsigned
// long> const&)

void __thiscall
std::_Bvector_base<std::allocator<bool>>::_Bvector_impl::_Bvector_impl
          (_Bvector_impl *this,allocator *param_1)

{
  allocator<unsigned_long>::allocator((allocator *)this);
  _Bvector_impl_data::_Bvector_impl_data((_Bvector_impl_data *)this);
  return;
}



// std::_Bvector_base<std::allocator<bool>>::_M_deallocate()

void __thiscall
std::_Bvector_base<std::allocator<bool>>::_M_deallocate(_Bvector_base_std__allocator_bool__ *this)

{
  long lVar1;
  ulong uVar2;
  
  if (*(long *)this != 0) {
    lVar1 = _Bvector_impl::_M_end_addr((_Bvector_impl *)this);
    uVar2 = lVar1 - *(long *)this >> 3;
    __gnu_cxx::__alloc_traits<std::allocator<unsigned_long>,unsigned_long>::deallocate
              ((allocator *)this,(ulong *)(*(long *)(this + 0x20) + uVar2 * -8),uVar2);
    _Bvector_impl_data::_M_reset((_Bvector_impl_data *)this);
  }
  return;
}



// std::_Bvector_base<std::allocator<bool>>::_M_allocate(unsigned long)

void __thiscall
std::_Bvector_base<std::allocator<bool>>::_M_allocate
          (_Bvector_base_std__allocator_bool__ *this,ulong param_1)

{
  ulong uVar1;
  
  uVar1 = _S_nword(param_1);
  __gnu_cxx::__alloc_traits<std::allocator<unsigned_long>,unsigned_long>::allocate
            ((allocator *)this,uVar1);
  return;
}



// std::_Bvector_base<std::allocator<bool>>::_S_nword(unsigned long)

ulong std::_Bvector_base<std::allocator<bool>>::_S_nword(ulong param_1)

{
  return param_1 + 0x3f >> 6;
}



// WARNING: Unknown calling convention yet parameter storage is locked
// unsigned long* std::__addressof<unsigned long>(unsigned long&)

ulong * std::__addressof_unsigned_long_(ulong *param_1)

{
  return param_1;
}



// std::_Bvector_base<std::allocator<bool>>::_Bvector_impl::_M_end_addr() const

ulong * __thiscall
std::_Bvector_base<std::allocator<bool>>::_Bvector_impl::_M_end_addr(_Bvector_impl *this)

{
  ulong *puVar1;
  
  if (*(long *)(this + 0x20) == 0) {
    puVar1 = (ulong *)0x0;
  }
  else {
    puVar1 = __addressof_unsigned_long_((ulong *)(*(long *)(this + 0x20) + -8));
    puVar1 = puVar1 + 1;
  }
  return puVar1;
}



// WARNING: Unknown calling convention yet parameter storage is locked
// void std::__fill_a1<int*, std::vector<int, std::allocator<int>>,
// int>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>,
// __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>, int const&)

void std::__fill_a1_int__std__vector_int_std__allocator_int___int_
               (__normal_iterator param_1,__normal_iterator param_2,int *param_3)

{
  int *piVar1;
  int **ppiVar2;
  undefined4 in_register_00000034;
  undefined4 in_register_0000003c;
  undefined8 local_28;
  undefined8 local_20 [2];
  
  local_20[0] = CONCAT44(in_register_0000003c,param_1);
  local_28 = CONCAT44(in_register_00000034,param_2);
  ppiVar2 = (int **)__gnu_cxx::__normal_iterator<int*,std::vector<int,std::allocator<int>>>::base
                              ((__normal_iterator_int__std__vector_int_std__allocator_int___ *)
                               &local_28);
  piVar1 = *ppiVar2;
  ppiVar2 = (int **)__gnu_cxx::__normal_iterator<int*,std::vector<int,std::allocator<int>>>::base
                              ((__normal_iterator_int__std__vector_int_std__allocator_int___ *)
                               local_20);
  __fill_a1_int__int_(*ppiVar2,piVar1,param_3);
  return;
}



// WARNING: Unknown calling convention yet parameter storage is locked
// int* std::__uninitialized_move_a<int*, int*, std::allocator<int>>(int*, int*, int*,
// std::allocator<int>&)

int * std::__uninitialized_move_a_int__int__std__allocator_int__
                (int *param_1,int *param_2,int *param_3,allocator *param_4)

{
  int *piVar1;
  
  piVar1 = __uninitialized_copy_a_int__int__int_(param_1,param_2,param_3,param_4);
  return piVar1;
}



// WARNING: Unknown calling convention yet parameter storage is locked
// int* std::copy_backward<int*, int*>(int*, int*, int*)

int * std::copy_backward_int__int__(int *param_1,int *param_2,int *param_3)

{
  int *piVar1;
  int *piVar2;
  
  piVar1 = __miter_base_int__(param_2);
  piVar2 = __miter_base_int__(param_1);
  piVar1 = __copy_move_backward_a_false_int__int__(piVar2,piVar1,param_3);
  return piVar1;
}



// WARNING: Unknown calling convention yet parameter storage is locked
// void std::fill<int*, int>(int*, int*, int const&)

void std::fill_int__int_(int *param_1,int *param_2,int *param_3)

{
  __fill_a_int__int_(param_1,param_2,param_3);
  return;
}



// WARNING: Unknown calling convention yet parameter storage is locked
// void std::__fill_a1<int*, std::vector<int, std::allocator<int>>,
// FastBoard::square_t>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>,
// __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>, FastBoard::square_t
// const&)

void std::__fill_a1_int__std__vector_int_std__allocator_int___FastBoard__square_t_
               (__normal_iterator param_1,__normal_iterator param_2,square_t *param_3)

{
  int *piVar1;
  int **ppiVar2;
  undefined4 in_register_00000034;
  undefined4 in_register_0000003c;
  undefined8 local_28;
  undefined8 local_20 [2];
  
  local_20[0] = CONCAT44(in_register_0000003c,param_1);
  local_28 = CONCAT44(in_register_00000034,param_2);
  ppiVar2 = (int **)__gnu_cxx::__normal_iterator<int*,std::vector<int,std::allocator<int>>>::base
                              ((__normal_iterator_int__std__vector_int_std__allocator_int___ *)
                               &local_28);
  piVar1 = *ppiVar2;
  ppiVar2 = (int **)__gnu_cxx::__normal_iterator<int*,std::vector<int,std::allocator<int>>>::base
                              ((__normal_iterator_int__std__vector_int_std__allocator_int___ *)
                               local_20);
  __fill_a1_int__FastBoard__square_t_(*ppiVar2,piVar1,param_3);
  return;
}



// std::_Vector_base<int, std::allocator<int>>::_Vector_impl_data::_Vector_impl_data()

void __thiscall
std::_Vector_base<int,std::allocator<int>>::_Vector_impl_data::_Vector_impl_data
          (_Vector_impl_data *this)

{
  *(undefined8 *)this = 0;
  *(undefined8 *)(this + 8) = 0;
  *(undefined8 *)(this + 0x10) = 0;
  return;
}



// void std::_Destroy_aux<true>::__destroy<int*>(int*, int*)

void std::_Destroy_aux<true>::__destroy_int__(int *param_1,int *param_2)

{
  return;
}



// __gnu_cxx::__alloc_traits<std::allocator<int>, int>::max_size(std::allocator<int> const&)

void __gnu_cxx::__alloc_traits<std::allocator<int>,int>::max_size(allocator *param_1)

{
  new_allocator<int>::max_size();
  return;
}



// WARNING: Unknown calling convention yet parameter storage is locked
// unsigned long const& std::min<unsigned long>(unsigned long const&, unsigned long const&)

ulong * std::min_unsigned_long_(ulong *param_1,ulong *param_2)

{
  if (*param_2 < *param_1) {
    param_1 = param_2;
  }
  return param_1;
}



// __gnu_cxx::__alloc_traits<std::allocator<int>, int>::allocate(std::allocator<int>&, unsigned
// long)

void __gnu_cxx::__alloc_traits<std::allocator<int>,int>::allocate(allocator *param_1,ulong param_2)

{
  new_allocator<int>::allocate((ulong)param_1,(void *)param_2);
  return;
}



// WARNING: Unknown calling convention yet parameter storage is locked
// int* std::uninitialized_copy<int*, int*>(int*, int*, int*)

int * std::uninitialized_copy_int__int__(int *param_1,int *param_2,int *param_3)

{
  int *piVar1;
  
  piVar1 = __uninitialized_copy<true>::__uninit_copy_int__int__(param_1,param_2,param_3);
  return piVar1;
}



// __gnu_cxx::new_allocator<int>::deallocate(int*, unsigned long)

void __gnu_cxx::new_allocator<int>::deallocate(int *param_1,ulong param_2)

{
  operator_delete((void *)param_2);
  return;
}



// WARNING: Unknown calling convention yet parameter storage is locked
// unsigned long const& std::max<unsigned long>(unsigned long const&, unsigned long const&)

ulong * std::max_unsigned_long_(ulong *param_1,ulong *param_2)

{
  if (*param_1 < *param_2) {
    param_1 = param_2;
  }
  return param_1;
}



// __gnu_cxx::new_allocator<int>::destroy(int*)

void __gnu_cxx::new_allocator<int>::destroy(int *param_1)

{
  return;
}



// int* std::__uninitialized_copy<true>::__uninit_copy<__gnu_cxx::__normal_iterator<int const*,
// std::vector<int, std::allocator<int>>>, int*>(__gnu_cxx::__normal_iterator<int const*,
// std::vector<int, std::allocator<int>>>, __gnu_cxx::__normal_iterator<int const*, std::vector<int,
// std::allocator<int>>>, int*)

int * std::__uninitialized_copy<true>::
      __uninit_copy___gnu_cxx____normal_iterator_int_const__std__vector_int_std__allocator_int____int__
                (__normal_iterator param_1,__normal_iterator param_2,int *param_3)

{
  int *piVar1;
  
  piVar1 = copy___gnu_cxx____normal_iterator_int_const__std__vector_int_std__allocator_int____int__
                     (param_1,param_2,param_3);
  return piVar1;
}



// __gnu_cxx::new_allocator<int>::new_allocator(__gnu_cxx::new_allocator<int> const&)

void __gnu_cxx::new_allocator<int>::new_allocator(new_allocator *param_1)

{
  return;
}



// WARNING: Unknown calling convention yet parameter storage is locked
// int* std::uninitialized_fill_n<int*, unsigned long, int>(int*, unsigned long, int const&)

int * std::uninitialized_fill_n_int__unsigned_long_int_(int *param_1,ulong param_2,int *param_3)

{
  int *piVar1;
  
  piVar1 = __uninitialized_fill_n<true>::__uninit_fill_n_int__unsigned_long_int_
                     (param_1,param_2,param_3);
  return piVar1;
}



// __gnu_cxx::new_allocator<unsigned long>::new_allocator()

void __gnu_cxx::new_allocator<unsigned_long>::new_allocator(void)

{
  return;
}



// __gnu_cxx::new_allocator<unsigned long>::~new_allocator()

void __thiscall
__gnu_cxx::new_allocator<unsigned_long>::_new_allocator(new_allocator_unsigned_long_ *this)

{
  return;
}



// std::allocator<unsigned long>::allocator(std::allocator<unsigned long> const&)

void std::allocator<unsigned_long>::allocator(allocator *param_1)

{
  __gnu_cxx::new_allocator<unsigned_long>::new_allocator((new_allocator *)param_1);
  return;
}



// std::_Bvector_base<std::allocator<bool>>::_Bvector_impl_data::_Bvector_impl_data()

void __thiscall
std::_Bvector_base<std::allocator<bool>>::_Bvector_impl_data::_Bvector_impl_data
          (_Bvector_impl_data *this)

{
  _Bit_iterator::_Bit_iterator((_Bit_iterator *)this);
  _Bit_iterator::_Bit_iterator((_Bit_iterator *)(this + 0x10));
  *(undefined8 *)(this + 0x20) = 0;
  return;
}



// __gnu_cxx::__alloc_traits<std::allocator<unsigned long>, unsigned
// long>::deallocate(std::allocator<unsigned long>&, unsigned long*, unsigned long)

void __gnu_cxx::__alloc_traits<std::allocator<unsigned_long>,unsigned_long>::deallocate
               (allocator *param_1,ulong *param_2,ulong param_3)

{
  new_allocator<unsigned_long>::deallocate((ulong *)param_1,(ulong)param_2);
  return;
}



// std::_Bvector_base<std::allocator<bool>>::_Bvector_impl_data::_M_reset()

void __thiscall
std::_Bvector_base<std::allocator<bool>>::_Bvector_impl_data::_M_reset(_Bvector_impl_data *this)

{
  undefined8 local_48;
  undefined8 local_40;
  undefined8 local_38;
  undefined8 local_30;
  undefined8 local_28;
  
  _Bvector_impl_data((_Bvector_impl_data *)&local_48);
  *(undefined8 *)this = local_48;
  *(undefined8 *)(this + 8) = local_40;
  *(undefined8 *)(this + 0x10) = local_38;
  *(undefined8 *)(this + 0x18) = local_30;
  *(undefined8 *)(this + 0x20) = local_28;
  return;
}



// __gnu_cxx::__alloc_traits<std::allocator<unsigned long>, unsigned
// long>::allocate(std::allocator<unsigned long>&, unsigned long)

void __gnu_cxx::__alloc_traits<std::allocator<unsigned_long>,unsigned_long>::allocate
               (allocator *param_1,ulong param_2)

{
  new_allocator<unsigned_long>::allocate((ulong)param_1,(void *)param_2);
  return;
}



// WARNING: Unknown calling convention yet parameter storage is locked
// __gnu_cxx::__enable_if<std::__is_scalar<int>::__value, void>::__type std::__fill_a1<int*,
// int>(int*, int*, int const&)

__type std::__fill_a1_int__int_(int *param_1,int *param_2,int *param_3)

{
  int iVar1;
  int *local_20;
  
  iVar1 = *param_3;
  for (local_20 = param_1; local_20 != param_2; local_20 = local_20 + 1) {
    *local_20 = iVar1;
  }
  return (__type)local_20;
}



// WARNING: Unknown calling convention yet parameter storage is locked
// int* std::__miter_base<int*>(int*)

int * std::__miter_base_int__(int *param_1)

{
  return param_1;
}



// WARNING: Unknown calling convention yet parameter storage is locked
// int* std::__copy_move_backward_a<false, int*, int*>(int*, int*, int*)

int * std::__copy_move_backward_a_false_int__int__(int *param_1,int *param_2,int *param_3)

{
  int *piVar1;
  int *piVar2;
  int *piVar3;
  int *local_30;
  int *local_28;
  int *local_20;
  
  local_30 = param_3;
  local_28 = param_2;
  local_20 = param_1;
  piVar1 = __niter_base_int__(param_3);
  piVar2 = __niter_base_int__(local_28);
  piVar3 = __niter_base_int__(local_20);
  piVar1 = __copy_move_backward_a1_false_int__int__(piVar3,piVar2,piVar1);
  piVar1 = __niter_wrap_int__(&local_30,piVar1);
  return piVar1;
}



// WARNING: Unknown calling convention yet parameter storage is locked
// void std::__fill_a<int*, int>(int*, int*, int const&)

void std::__fill_a_int__int_(int *param_1,int *param_2,int *param_3)

{
  __fill_a1_int__int_(param_1,param_2,param_3);
  return;
}



// WARNING: Unknown calling convention yet parameter storage is locked
// __gnu_cxx::__enable_if<!std::__is_scalar<FastBoard::square_t>::__value, void>::__type
// std::__fill_a1<int*, FastBoard::square_t>(int*, int*, FastBoard::square_t const&)

__type std::__fill_a1_int__FastBoard__square_t_(int *param_1,int *param_2,square_t *param_3)

{
  int *local_10;
  
  for (local_10 = param_1; local_10 != param_2; local_10 = local_10 + 1) {
    *local_10 = *(int *)param_3;
  }
  return (__type)local_10;
}



// __gnu_cxx::new_allocator<int>::max_size() const

void __gnu_cxx::new_allocator<int>::max_size(void)

{
  _M_max_size();
  return;
}



// __gnu_cxx::new_allocator<int>::allocate(unsigned long, void const*)

void __gnu_cxx::new_allocator<int>::allocate(ulong param_1,void *param_2)

{
  void *pvVar1;
  
  pvVar1 = (void *)_M_max_size();
  if (pvVar1 < param_2) {
    if ((void *)0x3fffffffffffffff < param_2) {
      std::__throw_bad_array_new_length();
    }
    std::__throw_bad_alloc();
  }
  operator_new((long)param_2 << 2);
  return;
}



// int* std::__uninitialized_copy<true>::__uninit_copy<int*, int*>(int*, int*, int*)

int * std::__uninitialized_copy<true>::__uninit_copy_int__int__
                (int *param_1,int *param_2,int *param_3)

{
  int *piVar1;
  
  piVar1 = copy_int__int__(param_1,param_2,param_3);
  return piVar1;
}



// WARNING: Unknown calling convention yet parameter storage is locked
// int* std::copy<__gnu_cxx::__normal_iterator<int const*, std::vector<int, std::allocator<int>>>,
// int*>(__gnu_cxx::__normal_iterator<int const*, std::vector<int, std::allocator<int>>>,
// __gnu_cxx::__normal_iterator<int const*, std::vector<int, std::allocator<int>>>, int*)

int * std::copy___gnu_cxx____normal_iterator_int_const__std__vector_int_std__allocator_int____int__
                (__normal_iterator param_1,__normal_iterator param_2,int *param_3)

{
  __normal_iterator _Var1;
  __normal_iterator _Var2;
  int *piVar3;
  
  _Var1 = __miter_base___gnu_cxx____normal_iterator_int_const__std__vector_int_std__allocator_int____
                    (param_2);
  _Var2 = __miter_base___gnu_cxx____normal_iterator_int_const__std__vector_int_std__allocator_int____
                    (param_1);
  piVar3 = __copy_move_a_false___gnu_cxx____normal_iterator_int_const__std__vector_int_std__allocator_int____int__
                     (_Var2,_Var1,param_3);
  return piVar3;
}



// int* std::__uninitialized_fill_n<true>::__uninit_fill_n<int*, unsigned long, int>(int*, unsigned
// long, int const&)

int * std::__uninitialized_fill_n<true>::__uninit_fill_n_int__unsigned_long_int_
                (int *param_1,ulong param_2,int *param_3)

{
  int *piVar1;
  
  piVar1 = fill_n_int__unsigned_long_int_(param_1,param_2,param_3);
  return piVar1;
}



// __gnu_cxx::new_allocator<unsigned long>::new_allocator(__gnu_cxx::new_allocator<unsigned long>
// const&)

void __gnu_cxx::new_allocator<unsigned_long>::new_allocator(new_allocator *param_1)

{
  return;
}



// __gnu_cxx::new_allocator<unsigned long>::deallocate(unsigned long*, unsigned long)

void __gnu_cxx::new_allocator<unsigned_long>::deallocate(ulong *param_1,ulong param_2)

{
  operator_delete((void *)param_2);
  return;
}



// __gnu_cxx::new_allocator<unsigned long>::allocate(unsigned long, void const*)

void __gnu_cxx::new_allocator<unsigned_long>::allocate(ulong param_1,void *param_2)

{
  void *pvVar1;
  
  pvVar1 = (void *)_M_max_size();
  if (pvVar1 < param_2) {
    if ((void *)0x1fffffffffffffff < param_2) {
      std::__throw_bad_array_new_length();
    }
    std::__throw_bad_alloc();
  }
  operator_new((long)param_2 << 3);
  return;
}



// WARNING: Unknown calling convention yet parameter storage is locked
// int* std::__niter_base<int*>(int*)

int * std::__niter_base_int__(int *param_1)

{
  return param_1;
}



// WARNING: Unknown calling convention yet parameter storage is locked
// int* std::__copy_move_backward_a1<false, int*, int*>(int*, int*, int*)

int * std::__copy_move_backward_a1_false_int__int__(int *param_1,int *param_2,int *param_3)

{
  int *piVar1;
  
  piVar1 = __copy_move_backward_a2_false_int__int__(param_1,param_2,param_3);
  return piVar1;
}



// WARNING: Unknown calling convention yet parameter storage is locked
// int* std::__niter_wrap<int*>(int* const&, int*)

int * std::__niter_wrap_int__(int **param_1,int *param_2)

{
  return param_2;
}



// __gnu_cxx::new_allocator<int>::_M_max_size() const

undefined8 __gnu_cxx::new_allocator<int>::_M_max_size(void)

{
  return 0x1fffffffffffffff;
}



// WARNING: Unknown calling convention yet parameter storage is locked
// int* std::copy<int*, int*>(int*, int*, int*)

int * std::copy_int__int__(int *param_1,int *param_2,int *param_3)

{
  int *piVar1;
  int *piVar2;
  
  piVar1 = __miter_base_int__(param_2);
  piVar2 = __miter_base_int__(param_1);
  piVar1 = __copy_move_a_false_int__int__(piVar2,piVar1,param_3);
  return piVar1;
}



// WARNING: Unknown calling convention yet parameter storage is locked
// __gnu_cxx::__normal_iterator<int const*, std::vector<int, std::allocator<int>>>
// std::__miter_base<__gnu_cxx::__normal_iterator<int const*, std::vector<int,
// std::allocator<int>>>>(__gnu_cxx::__normal_iterator<int const*, std::vector<int,
// std::allocator<int>>>)

__normal_iterator
std::__miter_base___gnu_cxx____normal_iterator_int_const__std__vector_int_std__allocator_int____
          (__normal_iterator param_1)

{
  return param_1;
}



// WARNING: Unknown calling convention yet parameter storage is locked
// int* std::__copy_move_a<false, __gnu_cxx::__normal_iterator<int const*, std::vector<int,
// std::allocator<int>>>, int*>(__gnu_cxx::__normal_iterator<int const*, std::vector<int,
// std::allocator<int>>>, __gnu_cxx::__normal_iterator<int const*, std::vector<int,
// std::allocator<int>>>, int*)

int * std::
      __copy_move_a_false___gnu_cxx____normal_iterator_int_const__std__vector_int_std__allocator_int____int__
                (__normal_iterator param_1,__normal_iterator param_2,int *param_3)

{
  int *piVar1;
  int *piVar2;
  int *piVar3;
  undefined4 in_register_00000034;
  undefined4 in_register_0000003c;
  int *local_30;
  undefined8 local_28;
  undefined8 local_20;
  
  local_20 = CONCAT44(in_register_0000003c,param_1);
  local_28 = CONCAT44(in_register_00000034,param_2);
  local_30 = param_3;
  piVar1 = __niter_base_int__(param_3);
  piVar2 = __niter_base_int_const__std__vector_int_std__allocator_int___
                     ((__normal_iterator)local_28);
  piVar3 = __niter_base_int_const__std__vector_int_std__allocator_int___
                     ((__normal_iterator)local_20);
  piVar1 = __copy_move_a1_false_int_const__int__(piVar3,piVar2,piVar1);
  piVar1 = __niter_wrap_int__(&local_30,piVar1);
  return piVar1;
}



// WARNING: Unknown calling convention yet parameter storage is locked
// int* std::fill_n<int*, unsigned long, int>(int*, unsigned long, int const&)

int * std::fill_n_int__unsigned_long_int_(int *param_1,ulong param_2,int *param_3)

{
  ulong uVar1;
  int *piVar2;
  int *local_10;
  
  local_10 = param_1;
  __iterator_category_int__(&local_10);
  uVar1 = __size_to_integer(param_2);
  piVar2 = __fill_n_a_int__unsigned_long_int_
                     (local_10,uVar1,param_3,(random_access_iterator_tag)uVar1);
  return piVar2;
}



// __gnu_cxx::new_allocator<unsigned long>::_M_max_size() const

undefined8 __gnu_cxx::new_allocator<unsigned_long>::_M_max_size(void)

{
  return 0xfffffffffffffff;
}



// WARNING: Unknown calling convention yet parameter storage is locked
// int* std::__copy_move_backward_a2<false, int*, int*>(int*, int*, int*)

int * std::__copy_move_backward_a2_false_int__int__(int *param_1,int *param_2,int *param_3)

{
  int *piVar1;
  
  piVar1 = __copy_move_backward<false,true,std::random_access_iterator_tag>::__copy_move_b_int_
                     (param_1,param_2,param_3);
  return piVar1;
}



// WARNING: Unknown calling convention yet parameter storage is locked
// int* std::__copy_move_a<false, int*, int*>(int*, int*, int*)

int * std::__copy_move_a_false_int__int__(int *param_1,int *param_2,int *param_3)

{
  int *piVar1;
  int *piVar2;
  int *piVar3;
  int *local_30;
  int *local_28;
  int *local_20;
  
  local_30 = param_3;
  local_28 = param_2;
  local_20 = param_1;
  piVar1 = __niter_base_int__(param_3);
  piVar2 = __niter_base_int__(local_28);
  piVar3 = __niter_base_int__(local_20);
  piVar1 = __copy_move_a1_false_int__int__(piVar3,piVar2,piVar1);
  piVar1 = __niter_wrap_int__(&local_30,piVar1);
  return piVar1;
}



// WARNING: Unknown calling convention yet parameter storage is locked
// int const* std::__niter_base<int const*, std::vector<int,
// std::allocator<int>>>(__gnu_cxx::__normal_iterator<int const*, std::vector<int,
// std::allocator<int>>>)

int * std::__niter_base_int_const__std__vector_int_std__allocator_int___(__normal_iterator param_1)

{
  int **ppiVar1;
  undefined4 in_register_0000003c;
  undefined8 local_10;
  
  local_10 = CONCAT44(in_register_0000003c,param_1);
  ppiVar1 = (int **)__gnu_cxx::__normal_iterator<int_const*,std::vector<int,std::allocator<int>>>::
                    base((__normal_iterator_int_const__std__vector_int_std__allocator_int___ *)
                         &local_10);
  return *ppiVar1;
}



// WARNING: Unknown calling convention yet parameter storage is locked
// int* std::__copy_move_a1<false, int const*, int*>(int const*, int const*, int*)

int * std::__copy_move_a1_false_int_const__int__(int *param_1,int *param_2,int *param_3)

{
  int *piVar1;
  
  piVar1 = __copy_move_a2_false_int_const__int__(param_1,param_2,param_3);
  return piVar1;
}



// WARNING: Unknown calling convention yet parameter storage is locked
// std::iterator_traits<int*>::iterator_category std::__iterator_category<int*>(int* const&)

iterator_category std::__iterator_category_int__(int **param_1)

{
  iterator_category in_EAX;
  
  return in_EAX;
}



// WARNING: Unknown calling convention yet parameter storage is locked
// int* std::__fill_n_a<int*, unsigned long, int>(int*, unsigned long, int const&,
// std::random_access_iterator_tag)

int * std::__fill_n_a_int__unsigned_long_int_
                (int *param_1,ulong param_2,int *param_3,random_access_iterator_tag param_4)

{
  if (param_2 != 0) {
    __fill_a_int__int_(param_1,param_1 + param_2,param_3);
    param_1 = param_1 + param_2;
  }
  return param_1;
}



// int* std::__copy_move_backward<false, true,
// std::random_access_iterator_tag>::__copy_move_b<int>(int const*, int const*, int*)

int * std::__copy_move_backward<false,true,std::random_access_iterator_tag>::__copy_move_b_int_
                (int *param_1,int *param_2,int *param_3)

{
  long lVar1;
  
  lVar1 = (long)param_2 - (long)param_1 >> 2;
  if (lVar1 != 0) {
    memmove(param_3 + -lVar1,param_1,lVar1 * 4);
  }
  return param_3 + -lVar1;
}



// WARNING: Unknown calling convention yet parameter storage is locked
// int* std::__copy_move_a1<false, int*, int*>(int*, int*, int*)

int * std::__copy_move_a1_false_int__int__(int *param_1,int *param_2,int *param_3)

{
  int *piVar1;
  
  piVar1 = __copy_move_a2_false_int__int__(param_1,param_2,param_3);
  return piVar1;
}



// __gnu_cxx::__normal_iterator<int const*, std::vector<int, std::allocator<int>>>::base() const

__normal_iterator_int_const__std__vector_int_std__allocator_int___ * __thiscall
__gnu_cxx::__normal_iterator<int_const*,std::vector<int,std::allocator<int>>>::base
          (__normal_iterator_int_const__std__vector_int_std__allocator_int___ *this)

{
  return this;
}



// WARNING: Unknown calling convention yet parameter storage is locked
// int* std::__copy_move_a2<false, int const*, int*>(int const*, int const*, int*)

int * std::__copy_move_a2_false_int_const__int__(int *param_1,int *param_2,int *param_3)

{
  int *piVar1;
  
  piVar1 = __copy_move<false,true,std::random_access_iterator_tag>::__copy_m_int_
                     (param_1,param_2,param_3);
  return piVar1;
}



// WARNING: Unknown calling convention yet parameter storage is locked
// int* std::__copy_move_a2<false, int*, int*>(int*, int*, int*)

int * std::__copy_move_a2_false_int__int__(int *param_1,int *param_2,int *param_3)

{
  int *piVar1;
  
  piVar1 = __copy_move<false,true,std::random_access_iterator_tag>::__copy_m_int_
                     (param_1,param_2,param_3);
  return piVar1;
}



// int* std::__copy_move<false, true, std::random_access_iterator_tag>::__copy_m<int>(int const*,
// int const*, int*)

int * std::__copy_move<false,true,std::random_access_iterator_tag>::__copy_m_int_
                (int *param_1,int *param_2,int *param_3)

{
  long lVar1;
  
  lVar1 = (long)param_2 - (long)param_1 >> 2;
  if (lVar1 != 0) {
    memmove(param_3,param_1,lVar1 * 4);
  }
  return param_3 + lVar1;
}