LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: ATOMIC-LICHESS[P]ATOMKRAFT/./move.h
// Function: void sort_moves<MoveStack>(MoveStack*, MoveStack*, MoveStack**)
inline void sort_moves(T* firstMove, T* lastMove, T** lastPositive)
{
    T tmp;
    T *p, *d;

    d = lastMove;
    p = firstMove - 1;

    d->score = -1; // right guard

    // Split positives vs non-positives
    do {
        while ((++p)->score > 0) {}

        if (p != d)
        {
            while (--d != p && d->score <= 0) {}

            tmp = *p;
            *p = *d;
            *d = tmp;
        }

    } while (p != d);

    // Sort just positive scored moves, remaining only when we get there
    insertion_sort<T, T*>(firstMove, p);
    *lastPositive = p;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
addq $-0x8, %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rax
movl $0xffffffff, 0x4(%rax)  # imm = 0xFFFFFFFF
jmp 0x34729
movq 0x10(%rsp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, 0x10(%rsp)
cmpl $0x0, 0xc(%rax)
jle 0x34742
jmp 0x34729
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
je 0x347b1
jmp 0x34750
movq 0x8(%rsp), %rcx
addq $-0x8, %rcx
movq %rcx, 0x8(%rsp)
xorl %eax, %eax
cmpq 0x10(%rsp), %rcx
movb %al, 0x7(%rsp)
je 0x3477b
movq 0x8(%rsp), %rax
cmpl $0x0, 0x4(%rax)
setle %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x34785
jmp 0x34787
jmp 0x34750
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq (%rcx), %rcx
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, (%rax)
jmp 0x347b3
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
jne 0x34727
movq 0x30(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x348d0
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: ATOMIC-LICHESS[P]ATOMKRAFT/./move.h
// Function: MoveStack pick_best<MoveStack>(MoveStack*, MoveStack*)
inline T pick_best(T* curMove, T* lastMove)
{
    T bestMove, tmp;

    bestMove = *curMove;
    while (++curMove != lastMove)
    {
        if (bestMove < *curMove)
        {
            tmp = *curMove;
            *curMove = bestMove;
            bestMove = tmp;
        }
    }
    return bestMove;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x18(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x18(%rsp)
cmpq 0x10(%rsp), %rax
je 0x348bb
movq 0x18(%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0x13870
testb $0x1, %al
jne 0x34895
jmp 0x348b9
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x3486b
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: ATOMIC-LICHESS[P]ATOMKRAFT/position.cpp
// Function: (anonymous namespace)::PieceLetters::PieceLetters()
PieceLetters() {

      operator[]('K') = WK; operator[]('k') = BK;
      operator[]('Q') = WQ; operator[]('q') = BQ;
      operator[]('R') = WR; operator[]('r') = BR;
      operator[]('B') = WB; operator[]('b') = BB;
      operator[]('N') = WN; operator[]('n') = BN;
      operator[]('P') = WP; operator[]('p') = BP;
      operator[](' ') = PIECE_NONE;
      operator[]('.') = PIECE_NONE_DARK_SQ;
    }

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq 0xa0(%rsp), %rdi
movq %rdi, 0x68(%rsp)
callq 0x3ec70
movq 0x68(%rsp), %rdi
movb $0x4b, 0x9f(%rsp)
leaq 0x9f(%rsp), %rsi
callq 0x3ec80
movq %rax, 0x70(%rsp)
jmp 0x36032
movq 0x68(%rsp), %rdi
movq 0x70(%rsp), %rax
movl $0x6, (%rax)
movb $0x6b, 0x8b(%rsp)
leaq 0x8b(%rsp), %rsi
callq 0x3ec80
movq %rax, 0x60(%rsp)
jmp 0x3605e
movq 0x68(%rsp), %rdi
movq 0x60(%rsp), %rax
movl $0xe, (%rax)
movb $0x51, 0x8a(%rsp)
leaq 0x8a(%rsp), %rsi
callq 0x3ec80
movq %rax, 0x58(%rsp)
jmp 0x3608a
movq 0x68(%rsp), %rdi
movq 0x58(%rsp), %rax
movl $0x5, (%rax)
movb $0x71, 0x89(%rsp)
leaq 0x89(%rsp), %rsi
callq 0x3ec80
movq %rax, 0x50(%rsp)
jmp 0x360b6
movq 0x68(%rsp), %rdi
movq 0x50(%rsp), %rax
movl $0xd, (%rax)
movb $0x52, 0x88(%rsp)
leaq 0x88(%rsp), %rsi
callq 0x3ec80
movq %rax, 0x48(%rsp)
jmp 0x360e2
movq 0x68(%rsp), %rdi
movq 0x48(%rsp), %rax
movl $0x4, (%rax)
movb $0x72, 0x87(%rsp)
leaq 0x87(%rsp), %rsi
callq 0x3ec80
movq %rax, 0x40(%rsp)
jmp 0x3610e
movq 0x68(%rsp), %rdi
movq 0x40(%rsp), %rax
movl $0xc, (%rax)
movb $0x42, 0x86(%rsp)
leaq 0x86(%rsp), %rsi
callq 0x3ec80
movq %rax, 0x38(%rsp)
jmp 0x3613a
movq 0x68(%rsp), %rdi
movq 0x38(%rsp), %rax
movl $0x3, (%rax)
movb $0x62, 0x85(%rsp)
leaq 0x85(%rsp), %rsi
callq 0x3ec80
movq %rax, 0x30(%rsp)
jmp 0x36166
movq 0x68(%rsp), %rdi
movq 0x30(%rsp), %rax
movl $0xb, (%rax)
movb $0x4e, 0x84(%rsp)
leaq 0x84(%rsp), %rsi
callq 0x3ec80
movq %rax, 0x28(%rsp)
jmp 0x36192
movq 0x68(%rsp), %rdi
movq 0x28(%rsp), %rax
movl $0x2, (%rax)
movb $0x6e, 0x83(%rsp)
leaq 0x83(%rsp), %rsi
callq 0x3ec80
movq %rax, 0x20(%rsp)
jmp 0x361be
movq 0x68(%rsp), %rdi
movq 0x20(%rsp), %rax
movl $0xa, (%rax)
movb $0x50, 0x82(%rsp)
leaq 0x82(%rsp), %rsi
callq 0x3ec80
movq %rax, 0x18(%rsp)
jmp 0x361ea
movq 0x68(%rsp), %rdi
movq 0x18(%rsp), %rax
movl $0x1, (%rax)
movb $0x70, 0x81(%rsp)
leaq 0x81(%rsp), %rsi
callq 0x3ec80
movq %rax, 0x10(%rsp)
jmp 0x36216
movq 0x68(%rsp), %rdi
movq 0x10(%rsp), %rax
movl $0x9, (%rax)
movb $0x20, 0x80(%rsp)
leaq 0x80(%rsp), %rsi
callq 0x3ec80
movq %rax, 0x8(%rsp)
jmp 0x36242
movq 0x68(%rsp), %rdi
movq 0x8(%rsp), %rax
movl $0x10, (%rax)
movb $0x2e, 0x7f(%rsp)
leaq 0x7f(%rsp), %rsi
callq 0x3ec80
movq %rax, (%rsp)
jmp 0x36267
movq (%rsp), %rax
movl $0x0, (%rax)
addq $0xa8, %rsp
retq
movq 0x68(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
callq 0x3ed70
movq 0x90(%rsp), %rdi
callq 0x6970
nopw %cs:(%rax,%rax)
// File: ATOMIC-LICHESS[P]ATOMKRAFT/position.cpp
// Function: CheckInfo::CheckInfo(Position const&)
CheckInfo::CheckInfo(const Position& pos) {

  Color us = pos.side_to_move();
  Color them = opposite_color(us);
  
  STARTNEW
  // FIXME: this cuts the possibility of detecting errors
  // but seems to be the easiest way to handle calls in qsearch and search
  if (pos.piece_count(them, KING) == 0 || pos.piece_count(us, KING) == 0) {
	  return;
  }
  ENDNEW
  
  NEW assert(pos.piece_count(them, KING));
  NEW assert(pos.piece_count(us, KING));
  NEW Square us_ksq = pos.king_square(us);
  ksq = pos.king_square(them);
  dcCandidates = pos.discovered_check_candidates(us);
  
  STARTNEW if (squares_touch[ksq][us_ksq]) {
	  checkSq[PAWN] 	= EmptyBoardBB;
	  checkSq[KNIGHT] 	= EmptyBoardBB;
	  checkSq[BISHOP] 	= EmptyBoardBB;
	  checkSq[ROOK] 	= EmptyBoardBB;
	  checkSq[QUEEN] 	= EmptyBoardBB;
	  checkSq[KING] 	= EmptyBoardBB;
  ENDNEW } else {
	  checkSq[PAWN] 	= pos.attacks_from<PAWN>(ksq, them);
	  checkSq[KNIGHT] 	= pos.attacks_from<KNIGHT>(ksq);
	  checkSq[BISHOP] 	= pos.attacks_from<BISHOP>(ksq);
	  checkSq[ROOK] 	= pos.attacks_from<ROOK>(ksq);
	  checkSq[QUEEN] 	= checkSq[BISHOP] | checkSq[ROOK];
	  checkSq[KING] 	= EmptyBoardBB;
  NEW }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
callq 0xf5d0
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %edi
callq 0x122b0
movl %eax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movl 0x10(%rsp), %esi
movl $0x6, %edx
callq 0x164c0
cmpl $0x0, %eax
je 0x36322
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl $0x6, %edx
callq 0x164c0
cmpl $0x0, %eax
jne 0x36327
jmp 0x36437
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x1b250
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rdi
movl 0x10(%rsp), %esi
callq 0x1b250
movl %eax, %ecx
movq (%rsp), %rax
movl %ecx, 0x48(%rax)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x36440
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movslq 0x48(%rax), %rcx
leaq 0x3752d(%rip), %rax     # 0x6d8a0
shlq $0x6, %rcx
addq %rcx, %rax
movslq 0xc(%rsp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x363bb
movq (%rsp), %rax
movq $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
movq $0x0, 0x20(%rax)
movq $0x0, 0x28(%rax)
movq $0x0, 0x30(%rax)
movq $0x0, 0x38(%rax)
jmp 0x36437
movq (%rsp), %rax
movq 0x18(%rsp), %rdi
movl 0x48(%rax), %esi
movl 0x10(%rsp), %edx
callq 0x1b460
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rdi
movl 0x48(%rax), %esi
callq 0x29aa0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x18(%rsp), %rdi
movl 0x48(%rax), %esi
callq 0x1b550
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x18(%rsp), %rdi
movl 0x48(%rax), %esi
callq 0x29d40
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x20(%rax), %rcx
orq 0x28(%rax), %rcx
movq %rcx, 0x30(%rax)
movq $0x0, 0x38(%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: ATOMIC-LICHESS[P]ATOMKRAFT/position.cpp
// Function: Position::Position(Position const&, int)
Position::Position(const Position& pos, int th) {

  memcpy(this, &pos, sizeof(Position));
  detach(); // Always detach() in copy c'tor to avoid surprises
  threadID = th;
  nodes = 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x18(%rsp), %rsi
movl $0x1940, %edx           # imm = 0x1940
callq 0x63f0
movq 0x8(%rsp), %rdi
callq 0x364c0
movq 0x8(%rsp), %rax
movl 0x14(%rsp), %ecx
movl %ecx, 0x192c(%rax)
movq $0x0, 0x1930(%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: ATOMIC-LICHESS[P]ATOMKRAFT/position.cpp
// Function: Position::clear()
void Position::clear() {

  st = &startState;
  memset(st, 0, sizeof(StateInfo));
  st->epSquare = SQ_NONE;
  startPosPlyCounter = 0;
  nodes = 0;

  memset(byColorBB,  0, sizeof(Bitboard) * 2);
  memset(byTypeBB,   0, sizeof(Bitboard) * 8);
  memset(pieceCount, 0, sizeof(int) * 2 * 8);
  memset(index,      0, sizeof(int) * 64);

  for (int i = 0; i < 64; i++)
      board[i] = PIECE_NONE;

  for (int i = 0; i < 8; i++)
      for (int j = 0; j < 16; j++)
          pieceList[0][i][j] = pieceList[1][i][j] = SQ_NONE;

  for (Square sq = SQ_A1; sq <= SQ_H8; sq++)
      castleRightsMask[sq] = ALL_CASTLES;

  sideToMove = WHITE;
  initialKFile = FILE_E;
  initialKRFile = FILE_H;
  initialQRFile = FILE_A;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %rax, %rcx
addq $0x1878, %rcx           # imm = 0x1878
movq %rcx, 0x1938(%rax)
movq 0x1938(%rax), %rdi
xorl %esi, %esi
movl $0xa0, %edx
callq 0x6280
movq 0x8(%rsp), %rdi
movq 0x1938(%rdi), %rax
movl $0x40, 0x20(%rax)
movl $0x0, 0x1928(%rdi)
movq $0x0, 0x1930(%rdi)
addq $0x140, %rdi            # imm = 0x140
xorl %esi, %esi
movl $0x10, %edx
callq 0x6280
movq 0x8(%rsp), %rdi
addq $0x100, %rdi            # imm = 0x100
xorl %esi, %esi
movl $0x40, %edx
callq 0x6280
movq 0x8(%rsp), %rdi
addq $0x150, %rdi            # imm = 0x150
xorl %esi, %esi
movl $0x40, %edx
callq 0x6280
movq 0x8(%rsp), %rdi
addq $0x590, %rdi            # imm = 0x590
xorl %esi, %esi
movl $0x100, %edx            # imm = 0x100
callq 0x6280
movl $0x0, 0x1c(%rsp)
cmpl $0x40, 0x1c(%rsp)
jge 0x36ff7
movq 0x8(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movl $0x10, (%rax,%rcx,4)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x36fd2
movl $0x0, 0x18(%rsp)
cmpl $0x8, 0x18(%rsp)
jge 0x3707d
movl $0x0, 0x14(%rsp)
cmpl $0x10, 0x14(%rsp)
jge 0x3706e
movq 0x8(%rsp), %rax
movq %rax, %rcx
addq $0x190, %rcx            # imm = 0x190
addq $0x200, %rcx            # imm = 0x200
movslq 0x18(%rsp), %rdx
shlq $0x6, %rdx
addq %rdx, %rcx
movslq 0x14(%rsp), %rdx
movl $0x40, (%rcx,%rdx,4)
addq $0x190, %rax            # imm = 0x190
movslq 0x18(%rsp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movslq 0x14(%rsp), %rcx
movl $0x40, (%rax,%rcx,4)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x3700e
jmp 0x37070
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x36fff
movl $0x0, 0x10(%rsp)
cmpl $0x3f, 0x10(%rsp)
jg 0x370af
movq 0x8(%rsp), %rax
movslq 0x10(%rsp), %rcx
movl $0xf, 0x1778(%rax,%rcx,4)
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0xe5c0
jmp 0x37085
movq 0x8(%rsp), %rax
movl $0x0, 0x1090(%rax)
movl $0x4, 0x1918(%rax)
movl $0x7, 0x191c(%rax)
movl $0x0, 0x1920(%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: ATOMIC-LICHESS[P]ATOMKRAFT/position.cpp
// Function: Position::put_piece(Piece, Square)
void Position::put_piece(Piece p, Square s) {

  Color c = color_of_piece(p);
  PieceType pt = type_of_piece(p);

  board[s] = p;
  index[s] = pieceCount[c][pt]++;
  pieceList[c][pt][index[s]] = s;

  set_bit(&(byTypeBB[pt]), s);
  set_bit(&(byColorBB[c]), s);
  set_bit(&(byTypeBB[0]), s); // HACK: byTypeBB[0] contains all occupied squares.
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x1c(%rsp), %edi
callq 0x3e730
movl %eax, 0x14(%rsp)
movl 0x1c(%rsp), %edi
callq 0x12990
movq 0x8(%rsp), %rdi
movl %eax, 0x10(%rsp)
movl 0x1c(%rsp), %ecx
movslq 0x18(%rsp), %rax
movl %ecx, (%rdi,%rax,4)
movq %rdi, %rax
addq $0x150, %rax            # imm = 0x150
movl 0x14(%rsp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movl 0x10(%rsp), %ecx
movl %ecx, %edx
movl (%rax,%rdx,4), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, (%rax,%rdx,4)
movslq 0x18(%rsp), %rax
movl %ecx, 0x590(%rdi,%rax,4)
movl 0x18(%rsp), %edx
movq %rdi, %rax
addq $0x190, %rax            # imm = 0x190
movl 0x14(%rsp), %ecx
shlq $0x9, %rcx
addq %rcx, %rax
movl 0x10(%rsp), %ecx
shlq $0x6, %rcx
addq %rcx, %rax
movslq 0x18(%rsp), %rcx
movslq 0x590(%rdi,%rcx,4), %rcx
movl %edx, (%rax,%rcx,4)
addq $0x100, %rdi            # imm = 0x100
movl 0x10(%rsp), %eax
shlq $0x3, %rax
addq %rax, %rdi
movl 0x18(%rsp), %esi
callq 0xe7c0
movq 0x8(%rsp), %rdi
addq $0x140, %rdi            # imm = 0x140
movl 0x14(%rsp), %eax
shlq $0x3, %rax
addq %rax, %rdi
movl 0x18(%rsp), %esi
callq 0xe7c0
movq 0x8(%rsp), %rdi
addq $0x100, %rdi            # imm = 0x100
movl 0x18(%rsp), %esi
callq 0xe7c0
addq $0x28, %rsp
retq
nop
// File: ATOMIC-LICHESS[P]ATOMKRAFT/position.cpp
// Function: Position::compute_key() const
Key Position::compute_key() const {

  Key result = zobCastle[st->castleRights];

  for (Square s = SQ_A1; s <= SQ_H8; s++)
      if (square_is_occupied(s))
          result ^= zobrist[color_of_piece_on(s)][type_of_piece_on(s)][s];

  if (ep_square() != SQ_NONE)
      result ^= zobEp[ep_square()];

  if (side_to_move() == BLACK)
      result ^= zobSideToMove;

  return result;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x1938(%rax), %rax
movslq 0x10(%rax), %rcx
leaq 0x3b2ceb(%rip), %rax    # 0x3ea340
movq (%rax,%rcx,8), %rax
movq %rax, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
cmpl $0x3f, 0x14(%rsp)
jg 0x376e5
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x33ac0
testb $0x1, %al
jne 0x37681
jmp 0x376d5
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x3df80
movq 0x8(%rsp), %rdi
movl %eax, %eax
movl %eax, %ecx
leaq 0x3b0aa1(%rip), %rax    # 0x3e8140
shlq $0xc, %rcx
addq %rcx, %rax
movq %rax, (%rsp)
movl 0x14(%rsp), %esi
callq 0x11f10
movl %eax, %ecx
movq (%rsp), %rax
movl %ecx, %ecx
shlq $0x9, %rcx
addq %rcx, %rax
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
xorq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
jmp 0x376d7
leaq 0x14(%rsp), %rdi
xorl %esi, %esi
callq 0xe5c0
jmp 0x37666
movq 0x8(%rsp), %rdi
callq 0xf5b0
cmpl $0x40, %eax
je 0x37716
movq 0x8(%rsp), %rdi
callq 0xf5b0
movslq %eax, %rcx
leaq 0x3b2a38(%rip), %rax    # 0x3ea140
movq (%rax,%rcx,8), %rax
xorq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x8(%rsp), %rdi
callq 0xf5d0
cmpl $0x1, %eax
jne 0x37736
movq 0x3b2c94(%rip), %rax    # 0x3ea3c0
xorq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
addq $0x28, %rsp
retq
// File: ATOMIC-LICHESS[P]ATOMKRAFT/position.cpp
// Function: Position::compute_pawn_key() const
Key Position::compute_pawn_key() const {

  Bitboard b;
  Key result = 0;

  for (Color c = WHITE; c <= BLACK; c++)
  {
      b = pieces(PAWN, c);
      while (b)
          result ^= zobrist[c][PAWN][pop_1st_bit(&b)];
  }
  return result;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
cmpl $0x1, 0x1c(%rsp)
jg 0x377dc
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %edx
movl $0x1, %esi
callq 0x16530
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x377cc
movl 0x1c(%rsp), %eax
movl %eax, %ecx
leaq 0x3b09a8(%rip), %rax    # 0x3e8140
shlq $0xc, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xd940
movl %eax, %ecx
movq 0x8(%rsp), %rax
movslq %ecx, %rcx
movq 0x200(%rax,%rcx,8), %rax
xorq 0x20(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x37783
jmp 0x377ce
leaq 0x1c(%rsp), %rdi
xorl %esi, %esi
callq 0xe6a0
jmp 0x37764
movq 0x20(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: ATOMIC-LICHESS[P]ATOMKRAFT/position.cpp
// Function: Position::compute_material_key() const
Key Position::compute_material_key() const {

  int count;
  Key result = 0;

  for (Color c = WHITE; c <= BLACK; c++)
      for (PieceType pt = PAWN; pt <= QUEEN; pt++)
      {
          count = piece_count(c, pt);
          for (int i = 0; i < count; i++)
              result ^= zobrist[c][pt][i];
      }
  return result;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq $0x0, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
cmpl $0x1, 0x1c(%rsp)
jg 0x378b8
movl $0x1, 0x18(%rsp)
cmpl $0x5, 0x18(%rsp)
jg 0x378a5
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %esi
movl 0x18(%rsp), %edx
callq 0x164c0
movl %eax, 0x2c(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jge 0x37895
movl 0x1c(%rsp), %eax
movl %eax, %ecx
leaq 0x3b08dd(%rip), %rax    # 0x3e8140
shlq $0xc, %rcx
addq %rcx, %rax
movl 0x18(%rsp), %ecx
shlq $0x9, %rcx
addq %rcx, %rax
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
xorq 0x20(%rsp), %rax
movq %rax, 0x20(%rsp)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x3784c
jmp 0x37897
leaq 0x18(%rsp), %rdi
xorl %esi, %esi
callq 0x3e870
jmp 0x37827
jmp 0x378a7
leaq 0x1c(%rsp), %rdi
xorl %esi, %esi
callq 0xe6a0
jmp 0x37814
movq 0x20(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: ATOMIC-LICHESS[P]ATOMKRAFT/position.cpp
// Function: Position::compute_value() const
Score Position::compute_value() const {

  Bitboard b;
  Score result = SCORE_ZERO;

  for (Color c = WHITE; c <= BLACK; c++)
      for (PieceType pt = PAWN; pt <= KING; pt++)
      {
          b = pieces(pt, c);
          while (b)
              result += pst(c, pt, pop_1st_bit(&b));
      }

  result += (side_to_move() == WHITE ? TempoValue / 2 : -TempoValue / 2);
  return result;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x24(%rsp)
movl $0x0, 0x20(%rsp)
cmpl $0x1, 0x20(%rsp)
jg 0x37986
movl $0x1, 0x1c(%rsp)
cmpl $0x6, 0x1c(%rsp)
jg 0x37973
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %esi
movl 0x20(%rsp), %edx
callq 0x16530
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x37963
movl 0x20(%rsp), %eax
movl %eax, 0x8(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0xc(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xd940
movl 0x8(%rsp), %edi
movl 0xc(%rsp), %esi
movl %eax, %edx
callq 0x3e770
movl %eax, %esi
leaq 0x24(%rsp), %rdi
callq 0x29810
jmp 0x37924
jmp 0x37965
leaq 0x1c(%rsp), %rdi
xorl %esi, %esi
callq 0x3e870
jmp 0x37906
jmp 0x37975
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0xe6a0
jmp 0x378f3
movq 0x10(%rsp), %rdi
callq 0xf5d0
cmpl $0x0, %eax
jne 0x379ab
movl 0x3b3af5(%rip), %edi    # 0x3eb490
movl $0x2, %esi
callq 0x28070
movl %eax, 0x4(%rsp)
jmp 0x379c6
movl 0x3b3adf(%rip), %edi    # 0x3eb490
callq 0x29f10
movl %eax, %edi
movl $0x2, %esi
callq 0x28070
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %esi
leaq 0x24(%rsp), %rdi
callq 0x29810
movl 0x24(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: ATOMIC-LICHESS[P]ATOMKRAFT/position.cpp
// Function: Position::compute_non_pawn_material(Color) const
Value Position::compute_non_pawn_material(Color c) const {

  Value result = VALUE_ZERO;

  for (PieceType pt = KNIGHT; pt <= QUEEN; pt++)
      result += piece_count(c, pt) * PieceValueMidgame[pt];

  return result;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x18(%rsp)
movl $0x2, 0x14(%rsp)
cmpl $0x5, 0x14(%rsp)
jg 0x37a51
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %esi
movl 0x14(%rsp), %edx
callq 0x164c0
movl %eax, %edi
movl 0x14(%rsp), %eax
movl %eax, %ecx
leaq 0x3b39a1(%rip), %rax    # 0x3eb3d0
movl (%rax,%rcx,4), %esi
callq 0x295b0
movl %eax, %esi
leaq 0x18(%rsp), %rdi
callq 0x29dd0
leaq 0x14(%rsp), %rdi
xorl %esi, %esi
callq 0x3e870
jmp 0x37a07
movl 0x18(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: ATOMIC-LICHESS[P]ATOMKRAFT/position.cpp
// Function: Position::neigh_is_ok()
bool Position::neigh_is_ok() {
	
	Square noSquares[64][9];
	Value neValue[64];
	
	write_neigh_arrays(noSquares, neValue);
	
	for (Square s = SQ_A1; s < SQ_NONE; ++s) {
		cout << s << endl;
		
		if (neValue[s] != neigh_expl_value(s)) {
			
#ifndef NDEBUG
			cout << "neValue - Square: " << s 
				 << ", neValue: " << neValue[s] 
				 << ", neigh_expl_value: " << neigh_expl_value(s) << endl;
#endif
			
			return false;
		}
		
		
		Bitboard b1 = EmptyBoardBB;
		Bitboard b2 = EmptyBoardBB;
		
		for (int k = 1; k <= noSquares[s][0]; ++k) {
			set_bit(&b1, noSquares[s][k]);
		}
		for (int k = 1; k <= neighOccSquares[s][0]; ++k) {
			set_bit(&b2, neighOccSquares[s][k]);
		}
		
		if (b1 != b2) {
			return false;
		}
	}
	
	return true;
}

// Assembly:
subq $0xa48, %rsp            # imm = 0xA48
movq %rdi, 0xa38(%rsp)
movq 0xa38(%rsp), %rdi
movq %rdi, 0x8(%rsp)
leaq 0x130(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x37a60
movl $0x0, 0x2c(%rsp)
cmpl $0x40, 0x2c(%rsp)
jge 0x37f50
movl 0x2c(%rsp), %esi
movq 0x3419c(%rip), %rdi     # 0x6bfb8
callq 0x6940
movq %rax, %rdi
movq 0x34165(%rip), %rsi     # 0x6bf90
callq 0x6520
movq 0x8(%rsp), %rdi
movslq 0x2c(%rsp), %rax
movl 0x30(%rsp,%rax,4), %eax
movl %eax, 0x4(%rsp)
movl 0x2c(%rsp), %esi
callq 0x3dfd0
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
je 0x37e62
movb $0x0, 0xa47(%rsp)
jmp 0x37f58
movq $0x0, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
movslq 0x2c(%rsp), %rdx
leaq 0x130(%rsp), %rcx
imulq $0x24, %rdx, %rdx
addq %rdx, %rcx
cmpl (%rcx), %eax
jg 0x37ecb
movslq 0x2c(%rsp), %rcx
leaq 0x130(%rsp), %rax
imulq $0x24, %rcx, %rcx
addq %rcx, %rax
movslq 0x14(%rsp), %rcx
movl (%rax,%rcx,4), %esi
leaq 0x20(%rsp), %rdi
callq 0xe7c0
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x37e7c
movl $0x1, 0x10(%rsp)
movq 0x8(%rsp), %rcx
movl 0x10(%rsp), %eax
addq $0x690, %rcx            # imm = 0x690
movslq 0x2c(%rsp), %rdx
imulq $0x24, %rdx, %rdx
addq %rdx, %rcx
cmpl (%rcx), %eax
jg 0x37f29
movq 0x8(%rsp), %rax
addq $0x690, %rax            # imm = 0x690
movslq 0x2c(%rsp), %rcx
imulq $0x24, %rcx, %rcx
addq %rcx, %rax
movslq 0x10(%rsp), %rcx
movl (%rax,%rcx,4), %esi
leaq 0x18(%rsp), %rdi
callq 0xe7c0
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x37ed3
movq 0x20(%rsp), %rax
cmpq 0x18(%rsp), %rax
je 0x37f3f
movb $0x0, 0xa47(%rsp)
jmp 0x37f58
jmp 0x37f41
leaq 0x2c(%rsp), %rdi
callq 0x3dfb0
jmp 0x37e06
movb $0x1, 0xa47(%rsp)
movb 0xa47(%rsp), %al
andb $0x1, %al
addq $0xa48, %rsp            # imm = 0xA48
retq
nopl (%rax)
// File: ATOMIC-LICHESS[P]ATOMKRAFT/position.cpp
// Function: (anonymous namespace)::PieceLetters::from_piece(Piece) const
char from_piece(Piece p) const {

      std::map<char, Piece>::const_iterator it;
      for (it = begin(); it != end(); ++it)
          if (it->second == p)
              return it->first;

      assert(false);
      return 0;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
leaq 0x18(%rsp), %rdi
callq 0x40010
movq (%rsp), %rdi
callq 0x40030
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x18(%rsp)
movq (%rsp), %rdi
callq 0x40080
movq %rax, 0x8(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x40060
testb $0x1, %al
jne 0x3854b
jmp 0x3857e
leaq 0x18(%rsp), %rdi
callq 0x400b0
movl 0x4(%rax), %eax
cmpl 0x24(%rsp), %eax
jne 0x38570
leaq 0x18(%rsp), %rdi
callq 0x400b0
movb (%rax), %al
movb %al, 0x37(%rsp)
jmp 0x38583
jmp 0x38572
leaq 0x18(%rsp), %rdi
callq 0x400d0
jmp 0x38528
movb $0x0, 0x37(%rsp)
movb 0x37(%rsp), %al
addq $0x38, %rsp
retq
nopl (%rax)
// File: ATOMIC-LICHESS[P]ATOMKRAFT/position.cpp
// Function: Position::attackers_to(Square) const
Bitboard Position::attackers_to(Square s) const {

  return  (attacks_from<PAWN>(s, BLACK) & pieces(PAWN, WHITE))
        | (attacks_from<PAWN>(s, WHITE) & pieces(PAWN, BLACK))
        | (attacks_from<KNIGHT>(s)      & pieces(KNIGHT))
        | (attacks_from<ROOK>(s)        & pieces(ROOK, QUEEN))
        | (attacks_from<BISHOP>(s)      & pieces(BISHOP, QUEEN))
        | (attacks_from<KING>(s)        & pieces(KING));
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movl %esi, 0x6c(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x50(%rsp)
movl 0x6c(%rsp), %esi
movl $0x1, %edx
callq 0x1b460
movq 0x50(%rsp), %rdi
movq %rax, 0x8(%rsp)
movl $0x1, %esi
xorl %edx, %edx
callq 0x16530
movq 0x50(%rsp), %rdi
movq %rax, %rcx
movq 0x8(%rsp), %rax
andq %rcx, %rax
movq %rax, 0x18(%rsp)
movl 0x6c(%rsp), %esi
xorl %edx, %edx
callq 0x1b460
movq 0x50(%rsp), %rdi
movq %rax, 0x10(%rsp)
movl $0x1, %edx
movl %edx, %esi
callq 0x16530
movq 0x10(%rsp), %rcx
movq 0x50(%rsp), %rdi
movq %rax, %rdx
movq 0x18(%rsp), %rax
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, 0x28(%rsp)
movl 0x6c(%rsp), %esi
callq 0x29aa0
movq 0x50(%rsp), %rdi
movq %rax, 0x20(%rsp)
movl $0x2, %esi
callq 0x33a70
movq 0x20(%rsp), %rcx
movq 0x50(%rsp), %rdi
movq %rax, %rdx
movq 0x28(%rsp), %rax
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, 0x38(%rsp)
movl 0x6c(%rsp), %esi
callq 0x29d40
movq 0x50(%rsp), %rdi
movq %rax, 0x30(%rsp)
movl $0x4, %esi
movl $0x5, %edx
callq 0x33a90
movq 0x30(%rsp), %rcx
movq 0x50(%rsp), %rdi
movq %rax, %rdx
movq 0x38(%rsp), %rax
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, 0x48(%rsp)
movl 0x6c(%rsp), %esi
callq 0x1b550
movq 0x50(%rsp), %rdi
movq %rax, 0x40(%rsp)
movl $0x3, %esi
movl $0x5, %edx
callq 0x33a90
movq 0x40(%rsp), %rcx
movq 0x50(%rsp), %rdi
movq %rax, %rdx
movq 0x48(%rsp), %rax
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, 0x60(%rsp)
movl 0x6c(%rsp), %esi
callq 0x1b440
movq 0x50(%rsp), %rdi
movq %rax, 0x58(%rsp)
movl $0x6, %esi
callq 0x33a70
movq 0x58(%rsp), %rcx
movq %rax, %rdx
movq 0x60(%rsp), %rax
andq %rdx, %rcx
orq %rcx, %rax
addq $0x78, %rsp
retq
nopl (%rax,%rax)
// File: ATOMIC-LICHESS[P]ATOMKRAFT/position.cpp
// Function: Position::attacks_from(Piece, Square) const
Bitboard Position::attacks_from(Piece p, Square s) const {

  assert(square_is_ok(s));

  switch (p)
  {
  case WB: case BB: return attacks_from<BISHOP>(s);
  case WR: case BR: return attacks_from<ROOK>(s);
  case WQ: case BQ: return attacks_from<QUEEN>(s);
  default: return StepAttacksBB[p][s];
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movl %edx, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movl 0x14(%rsp), %eax
movl %eax, 0xc(%rsp)
subl $0x3, %eax
je 0x38b90
jmp 0x38b59
movl 0xc(%rsp), %eax
subl $0x4, %eax
je 0x38ba4
jmp 0x38b64
movl 0xc(%rsp), %eax
subl $0x5, %eax
je 0x38bb8
jmp 0x38b6f
movl 0xc(%rsp), %eax
subl $0xb, %eax
je 0x38b90
jmp 0x38b7a
movl 0xc(%rsp), %eax
subl $0xc, %eax
je 0x38ba4
jmp 0x38b85
movl 0xc(%rsp), %eax
subl $0xd, %eax
je 0x38bb8
jmp 0x38bcc
movq (%rsp), %rdi
movl 0x10(%rsp), %esi
callq 0x1b550
movq %rax, 0x20(%rsp)
jmp 0x38bee
movq (%rsp), %rdi
movl 0x10(%rsp), %esi
callq 0x29d40
movq %rax, 0x20(%rsp)
jmp 0x38bee
movq (%rsp), %rdi
movl 0x10(%rsp), %esi
callq 0x29cf0
movq %rax, 0x20(%rsp)
jmp 0x38bee
movl 0x14(%rsp), %eax
movl %eax, %ecx
leaq 0x10fc87(%rip), %rax    # 0x148860
shlq $0x9, %rcx
addq %rcx, %rax
movslq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: ATOMIC-LICHESS[P]ATOMKRAFT/position.cpp
// Function: Position::attacks_from(Piece, Square, unsigned long)
Bitboard Position::attacks_from(Piece p, Square s, Bitboard occ) {

  assert(square_is_ok(s));

  switch (p)
  {
  case WB: case BB: return bishop_attacks_bb(s, occ);
  case WR: case BR: return rook_attacks_bb(s, occ);
  case WQ: case BQ: return bishop_attacks_bb(s, occ) | rook_attacks_bb(s, occ);
  default: return StepAttacksBB[p][s];
  }
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x1c(%rsp)
movl %esi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0xc(%rsp)
subl $0x3, %eax
je 0x38c57
jmp 0x38c20
movl 0xc(%rsp), %eax
subl $0x4, %eax
je 0x38c6c
jmp 0x38c2b
movl 0xc(%rsp), %eax
subl $0x5, %eax
je 0x38c81
jmp 0x38c36
movl 0xc(%rsp), %eax
subl $0xb, %eax
je 0x38c57
jmp 0x38c41
movl 0xc(%rsp), %eax
subl $0xc, %eax
je 0x38c6c
jmp 0x38c4c
movl 0xc(%rsp), %eax
subl $0xd, %eax
je 0x38c81
jmp 0x38cb2
movl 0x18(%rsp), %edi
movq 0x10(%rsp), %rsi
callq 0xe820
movq %rax, 0x20(%rsp)
jmp 0x38cd4
movl 0x18(%rsp), %edi
movq 0x10(%rsp), %rsi
callq 0xe8c0
movq %rax, 0x20(%rsp)
jmp 0x38cd4
movl 0x18(%rsp), %edi
movq 0x10(%rsp), %rsi
callq 0xe820
movq %rax, (%rsp)
movl 0x18(%rsp), %edi
movq 0x10(%rsp), %rsi
callq 0xe8c0
movq %rax, %rcx
movq (%rsp), %rax
orq %rcx, %rax
movq %rax, 0x20(%rsp)
jmp 0x38cd4
movl 0x1c(%rsp), %eax
movl %eax, %ecx
leaq 0x10fba1(%rip), %rax    # 0x148860
shlq $0x9, %rcx
addq %rcx, %rax
movslq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: ATOMIC-LICHESS[P]ATOMKRAFT/position.cpp
// Function: Position::move_attacks_square(Move, Square) const
bool Position::move_attacks_square(Move m, Square s) const {

  assert(move_is_ok(m));
  assert(square_is_ok(s));

  Bitboard occ, xray;
  Square f = move_from(m), t = move_to(m);

  assert(square_is_occupied(f));

  if (bit_is_set(attacks_from(piece_on(f), t), s))
      return true;

  // Move the piece and scan for X-ray attacks behind it
  occ = occupied_squares();
  do_move_bb(&occ, make_move_bb(f, t));
  xray = ( (rook_attacks_bb(s, occ)   & pieces(ROOK, QUEEN))
          |(bishop_attacks_bb(s, occ) & pieces(BISHOP, QUEEN)))
         & pieces_of_color(color_of_piece_on(f));

  // If we have attacks we need to verify that are caused by our move
  // and are not already existent ones.
  return xray && (xray ^ (xray & attacks_from<QUEEN>(s)));
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movl %esi, 0x64(%rsp)
movl %edx, 0x60(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x40(%rsp)
movl 0x64(%rsp), %edi
callq 0xf680
movl %eax, 0x4c(%rsp)
movl 0x64(%rsp), %edi
callq 0xf690
movq 0x40(%rsp), %rdi
movl %eax, 0x48(%rsp)
movl 0x4c(%rsp), %esi
callq 0xf530
movq 0x40(%rsp), %rdi
movl %eax, %esi
movl 0x48(%rsp), %edx
callq 0x38b30
movq %rax, %rdi
movl 0x60(%rsp), %esi
callq 0xd760
cmpq $0x0, %rax
je 0x38d4f
movb $0x1, 0x77(%rsp)
jmp 0x38e70
movq 0x40(%rsp), %rdi
callq 0xf510
movq %rax, 0x58(%rsp)
movl 0x4c(%rsp), %edi
movl 0x48(%rsp), %esi
callq 0x3e630
movq %rax, %rsi
leaq 0x58(%rsp), %rdi
callq 0x3e610
movl 0x60(%rsp), %edi
movq 0x58(%rsp), %rsi
callq 0xe8c0
movq 0x40(%rsp), %rdi
movq %rax, 0x18(%rsp)
movl $0x4, %esi
movl $0x5, %edx
callq 0x33a90
movq %rax, %rcx
movq 0x18(%rsp), %rax
andq %rcx, %rax
movq %rax, 0x28(%rsp)
movl 0x60(%rsp), %edi
movq 0x58(%rsp), %rsi
callq 0xe820
movq 0x40(%rsp), %rdi
movq %rax, 0x20(%rsp)
movl $0x3, %esi
movl $0x5, %edx
callq 0x33a90
movq 0x20(%rsp), %rcx
movq 0x40(%rsp), %rdi
movq %rax, %rdx
movq 0x28(%rsp), %rax
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, 0x30(%rsp)
movl 0x4c(%rsp), %esi
callq 0x3df80
movq 0x40(%rsp), %rdi
movl %eax, %esi
callq 0x298c0
movq %rax, %rcx
movq 0x30(%rsp), %rax
andq %rcx, %rax
movq %rax, 0x50(%rsp)
xorl %eax, %eax
cmpq $0x0, 0x50(%rsp)
movb %al, 0x3f(%rsp)
je 0x38e66
movq 0x40(%rsp), %rdi
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x60(%rsp), %esi
callq 0x29cf0
movq 0x8(%rsp), %rcx
movq %rax, %rdx
movq 0x10(%rsp), %rax
andq %rdx, %rcx
xorq %rcx, %rax
cmpq $0x0, %rax
setne %al
movb %al, 0x3f(%rsp)
movb 0x3f(%rsp), %al
andb $0x1, %al
movb %al, 0x77(%rsp)
movb 0x77(%rsp), %al
andb $0x1, %al
addq $0x78, %rsp
retq
nopl (%rax,%rax)
// File: ATOMIC-LICHESS[P]ATOMKRAFT/position.cpp
// Function: Position::pl_move_is_evasion(Move, unsigned long) const
bool Position::pl_move_is_evasion(Move m, Bitboard pinned) const
{
  assert(in_check());

  NEW assert(color_of_piece_on(move_from(m)) == side_to_move());
  
  Color us = side_to_move();
  Square from = move_from(m);
  Square to = move_to(m);

  // King moves and en-passant captures are verified in pl_move_is_legal()
  if (type_of_piece_on(from) == KING || move_is_ep(m))
      return pl_move_is_legal(m, pinned);

  Bitboard target = checkers();
  Square checksq = pop_1st_bit(&target);

  if (target) // double check ?
      return false;

  // Our move must be a blocking evasion or a capture of the checking piece
  NEW assert(piece_count(us, KING));
  target = squares_between(checksq, king_square(us)) | checkers();
  return bit_is_set(target, to) && pl_move_is_legal(m, pinned);
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movl %esi, 0x54(%rsp)
movq %rdx, 0x48(%rsp)
movq 0x58(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0xf5d0
movl %eax, 0x44(%rsp)
movl 0x54(%rsp), %edi
callq 0xf680
movl %eax, 0x40(%rsp)
movl 0x54(%rsp), %edi
callq 0xf690
movq 0x20(%rsp), %rdi
movl %eax, 0x3c(%rsp)
movl 0x40(%rsp), %esi
callq 0x11f10
cmpl $0x6, %eax
je 0x395a0
movl 0x54(%rsp), %edi
callq 0x2e360
cmpl $0x0, %eax
je 0x395be
movq 0x20(%rsp), %rdi
movl 0x54(%rsp), %esi
movq 0x48(%rsp), %rdx
callq 0x38e80
andb $0x1, %al
movb %al, 0x67(%rsp)
jmp 0x39668
movq 0x20(%rsp), %rdi
callq 0x339b0
movq %rax, 0x30(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xd940
movl %eax, 0x2c(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x395ea
movb $0x0, 0x67(%rsp)
jmp 0x39668
movq 0x20(%rsp), %rdi
movl 0x2c(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0x44(%rsp), %esi
callq 0x1b250
movl 0xc(%rsp), %edi
movl %eax, %esi
callq 0x339d0
movq 0x20(%rsp), %rdi
movq %rax, 0x10(%rsp)
callq 0x339b0
movq %rax, %rcx
movq 0x10(%rsp), %rax
orq %rcx, %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movl 0x3c(%rsp), %esi
callq 0xd760
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, 0x1f(%rsp)
je 0x3965e
movq 0x20(%rsp), %rdi
movl 0x54(%rsp), %esi
movq 0x48(%rsp), %rdx
callq 0x38e80
movb %al, 0x1f(%rsp)
movb 0x1f(%rsp), %al
andb $0x1, %al
movb %al, 0x67(%rsp)
movb 0x67(%rsp), %al
andb $0x1, %al
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: ATOMIC-LICHESS[P]ATOMKRAFT/position.cpp
// Function: Position::move_is_legal(Move) const
bool Position::move_is_legal(const Move m) const {
	
	NEW // don't test that since it might be a tested tt
	//NEW assert(color_of_piece_on(move_from(m)) == side_to_move());
	
  MoveStack mlist[MAX_MOVES];
  MoveStack *cur, *last = generate<MV_PSEUDO_LEGAL>(*this, mlist);

   for (cur = mlist; cur != last; cur++)
      if (cur->move == m)
          return pl_move_is_legal(m, pinned_pieces(sideToMove));

  return false;
}

// Assembly:
subq $0x838, %rsp            # imm = 0x838
movq %rdi, 0x828(%rsp)
movl %esi, 0x824(%rsp)
movq 0x828(%rsp), %rdi
movq %rdi, 0x8(%rsp)
leaq 0x20(%rsp), %rsi
callq 0x30380
movq %rax, 0x10(%rsp)
leaq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
je 0x39721
movq 0x18(%rsp), %rax
movl (%rax), %eax
cmpl 0x824(%rsp), %eax
jne 0x3970f
movq 0x8(%rsp), %rdi
movl 0x824(%rsp), %eax
movl %eax, 0x4(%rsp)
movl 0x1090(%rdi), %esi
callq 0x38990
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %esi
movq %rax, %rdx
callq 0x38e80
andb $0x1, %al
movb %al, 0x837(%rsp)
jmp 0x39729
jmp 0x39711
movq 0x18(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x18(%rsp)
jmp 0x396bc
movb $0x0, 0x837(%rsp)
movb 0x837(%rsp), %al
andb $0x1, %al
addq $0x838, %rsp            # imm = 0x838
retq
nopw (%rax,%rax)
// File: ATOMIC-LICHESS[P]ATOMKRAFT/position.cpp
// Function: Position::do_setup_move(Move)
void Position::do_setup_move(Move m) {

  StateInfo newSt;

  do_move(m, newSt);

  // Reset "game ply" in case we made a non-reversible move.
  // "game ply" is used for repetition detection.
  if (st->rule50 == 0)
      st->gamePly = 0;

  // Update the number of plies played from the starting position
  startPosPlyCounter++;

  // Our StateInfo newSt is about going out of scope so copy
  // its content before it disappears.
  detach();
}

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movl %esi, 0xac(%rsp)
movq 0xb0(%rsp), %rdi
movq %rdi, (%rsp)
movl 0xac(%rsp), %esi
leaq 0x8(%rsp), %rdx
callq 0x3a390
movq (%rsp), %rax
movq 0x1938(%rax), %rax
cmpl $0x0, 0x14(%rax)
jne 0x3a366
movq (%rsp), %rax
movq 0x1938(%rax), %rax
movl $0x0, 0x18(%rax)
movq (%rsp), %rdi
movl 0x1928(%rdi), %eax
addl $0x1, %eax
movl %eax, 0x1928(%rdi)
callq 0x364c0
addq $0xb8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: ATOMIC-LICHESS[P]ATOMKRAFT/position.cpp
// Function: Position::restore_piece(Color, Square, PieceType)
void Position::restore_piece(Color color, Square square, PieceType type) {
	// Restore the attacking piece 
	set_bit(&(byColorBB[color]), square);
	set_bit(&(byTypeBB[type]), square);
	set_bit(&(byTypeBB[0]), square); 

	board[square] = make_piece(color, type);

	// Update piece count
	pieceCount[color][type]++;

	// Update piece list, add a new captured piece in capsq square
	index[square] = pieceCount[color][type] - 1;
	pieceList[color][type][index[square]] = square;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x140, %rdi            # imm = 0x140
movl 0x1c(%rsp), %eax
shlq $0x3, %rax
addq %rax, %rdi
movl 0x18(%rsp), %esi
callq 0xe7c0
movq 0x8(%rsp), %rdi
addq $0x100, %rdi            # imm = 0x100
movl 0x14(%rsp), %eax
shlq $0x3, %rax
addq %rax, %rdi
movl 0x18(%rsp), %esi
callq 0xe7c0
movq 0x8(%rsp), %rdi
addq $0x100, %rdi            # imm = 0x100
movl 0x18(%rsp), %esi
callq 0xe7c0
movl 0x1c(%rsp), %edi
movl 0x14(%rsp), %esi
callq 0x1bce0
movq 0x8(%rsp), %rcx
movl %eax, %edx
movslq 0x18(%rsp), %rax
movl %edx, (%rcx,%rax,4)
movq %rcx, %rax
addq $0x150, %rax            # imm = 0x150
movl 0x1c(%rsp), %edx
shlq $0x5, %rdx
addq %rdx, %rax
movl 0x14(%rsp), %edx
movl (%rax,%rdx,4), %esi
addl $0x1, %esi
movl %esi, (%rax,%rdx,4)
movq %rcx, %rax
addq $0x150, %rax            # imm = 0x150
movl 0x1c(%rsp), %edx
shlq $0x5, %rdx
addq %rdx, %rax
movl 0x14(%rsp), %edx
movl (%rax,%rdx,4), %edx
subl $0x1, %edx
movslq 0x18(%rsp), %rax
movl %edx, 0x590(%rcx,%rax,4)
movl 0x18(%rsp), %edx
movq %rcx, %rax
addq $0x190, %rax            # imm = 0x190
movl 0x1c(%rsp), %esi
shlq $0x9, %rsi
addq %rsi, %rax
movl 0x14(%rsp), %esi
shlq $0x6, %rsi
addq %rsi, %rax
movslq 0x18(%rsp), %rsi
movslq 0x590(%rcx,%rsi,4), %rcx
movl %edx, (%rax,%rcx,4)
addq $0x28, %rsp
retq
nop
// File: ATOMIC-LICHESS[P]ATOMKRAFT/position.cpp
// Function: Position::do_null_move(StateInfo&)
void Position::do_null_move(StateInfo& backupSt) {

  assert(is_ok());
  assert(!in_check());

  // Back up the information necessary to undo the null move to the supplied
  // StateInfo object.
  // Note that differently from normal case here backupSt is actually used as
  // a backup storage not as a new state to be used.
  backupSt.key      = st->key;
  backupSt.epSquare = st->epSquare;
  backupSt.value    = st->value;
  backupSt.previous = st->previous;
  backupSt.pliesFromNull = st->pliesFromNull;
  st->previous = &backupSt;

  // Save the current key to the history[] array, in order to be able to
  // detect repetition draws.
  history[st->gamePly++] = st->key;

  // Update the necessary information
  if (st->epSquare != SQ_NONE)
      st->key ^= zobEp[st->epSquare];

  st->key ^= zobSideToMove;
  
  // TODO: PREFETCH
  prefetch((char*)TT.first_entry(st->key));

  sideToMove = opposite_color(sideToMove);
  st->epSquare = SQ_NONE;
  st->rule50++;
  st->pliesFromNull = 0;
  st->value += (sideToMove == WHITE) ?  TempoValue : -TempoValue;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x1938(%rax), %rcx
movq 0x38(%rcx), %rdx
movq 0x18(%rsp), %rcx
movq %rdx, 0x38(%rcx)
movq 0x1938(%rax), %rcx
movl 0x20(%rcx), %edx
movq 0x18(%rsp), %rcx
movl %edx, 0x20(%rcx)
movq 0x1938(%rax), %rcx
movl 0x24(%rcx), %edx
movq 0x18(%rsp), %rcx
movl %edx, 0x24(%rcx)
movq 0x1938(%rax), %rcx
movq 0x98(%rcx), %rdx
movq 0x18(%rsp), %rcx
movq %rdx, 0x98(%rcx)
movq 0x1938(%rax), %rcx
movl 0x1c(%rcx), %edx
movq 0x18(%rsp), %rcx
movl %edx, 0x1c(%rcx)
movq 0x18(%rsp), %rdx
movq 0x1938(%rax), %rcx
movq %rdx, 0x98(%rcx)
movq 0x1938(%rax), %rcx
movq 0x38(%rcx), %rdx
movq 0x1938(%rax), %rsi
movl 0x18(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x18(%rsi)
movslq %ecx, %rcx
movq %rdx, 0x1098(%rax,%rcx,8)
movq 0x1938(%rax), %rax
cmpl $0x40, 0x20(%rax)
je 0x3cf8e
movq 0x10(%rsp), %rax
movq 0x1938(%rax), %rcx
movslq 0x20(%rcx), %rdx
leaq 0x3ad1c5(%rip), %rcx    # 0x3ea140
movq (%rcx,%rdx,8), %rcx
movq 0x1938(%rax), %rax
xorq 0x38(%rax), %rcx
movq %rcx, 0x38(%rax)
movq 0x10(%rsp), %rax
movq 0x3ad426(%rip), %rdx    # 0x3ea3c0
movq 0x1938(%rax), %rcx
xorq 0x38(%rcx), %rdx
movq %rdx, 0x38(%rcx)
movq 0x1938(%rax), %rax
movq 0x38(%rax), %rsi
leaq 0x3be8d5(%rip), %rdi    # 0x3fb890
callq 0x3e740
movq %rax, %rdi
callq 0x2c330
movq 0x10(%rsp), %rax
movl 0x1090(%rax), %edi
callq 0x122b0
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x1090(%rax)
movq 0x1938(%rax), %rcx
movl $0x40, 0x20(%rcx)
movq 0x1938(%rax), %rcx
movl 0x14(%rcx), %edx
addl $0x1, %edx
movl %edx, 0x14(%rcx)
movq 0x1938(%rax), %rcx
movl $0x0, 0x1c(%rcx)
cmpl $0x0, 0x1090(%rax)
jne 0x3d026
movl 0x3ae470(%rip), %eax    # 0x3eb490
movl %eax, 0xc(%rsp)
jmp 0x3d035
movl 0x3ae464(%rip), %edi    # 0x3eb490
callq 0x29f10
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %esi
movq 0x1938(%rax), %rdi
addq $0x24, %rdi
callq 0x29810
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: ATOMIC-LICHESS[P]ATOMKRAFT/position.cpp
// Function: Position::undo_null_move()
void Position::undo_null_move() {

  assert(is_ok());
  assert(!in_check());

  // Restore information from the our backup StateInfo object
  StateInfo* backupSt = st->previous;
  st->key      = backupSt->key;
  st->epSquare = backupSt->epSquare;
  st->value    = backupSt->value;
  st->previous = backupSt->previous;
  st->pliesFromNull = backupSt->pliesFromNull;

  // Update the necessary information
  sideToMove = opposite_color(sideToMove);
  st->rule50--;
  st->gamePly--;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x1938(%rax), %rcx
movq 0x98(%rcx), %rcx
movq %rcx, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movq 0x38(%rcx), %rdx
movq 0x1938(%rax), %rcx
movq %rdx, 0x38(%rcx)
movq 0x8(%rsp), %rcx
movl 0x20(%rcx), %edx
movq 0x1938(%rax), %rcx
movl %edx, 0x20(%rcx)
movq 0x8(%rsp), %rcx
movl 0x24(%rcx), %edx
movq 0x1938(%rax), %rcx
movl %edx, 0x24(%rcx)
movq 0x8(%rsp), %rcx
movq 0x98(%rcx), %rdx
movq 0x1938(%rax), %rcx
movq %rdx, 0x98(%rcx)
movq 0x8(%rsp), %rcx
movl 0x1c(%rcx), %edx
movq 0x1938(%rax), %rcx
movl %edx, 0x1c(%rcx)
movl 0x1090(%rax), %edi
callq 0x122b0
movl %eax, %ecx
movq (%rsp), %rax
movl %ecx, 0x1090(%rax)
movq 0x1938(%rax), %rcx
movl 0x14(%rcx), %edx
addl $-0x1, %edx
movl %edx, 0x14(%rcx)
movq 0x1938(%rax), %rax
movl 0x18(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x18(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: ATOMIC-LICHESS[P]ATOMKRAFT/position.cpp
// Function: Position::see_sign(Move) const
int Position::see_sign(Move m) const {

  assert(move_is_ok(m));

  Square from = move_from(m);
  Square to = move_to(m);
  
  NEW // this has not to be true
  STARTOLD
  // Early return if SEE cannot be negative because captured piece value
  // is not less then capturing one. Note that king moves always return
  // here because king midgame value is set to 0.
  if (midgame_value_of_piece_on(to) >= midgame_value_of_piece_on(from))
      return 1;
  ENDOLD
  
  
  return see(from, to);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x1c(%rsp), %edi
callq 0xf680
movl %eax, 0x18(%rsp)
movl 0x1c(%rsp), %edi
callq 0xf690
movq 0x8(%rsp), %rdi
movl %eax, 0x14(%rsp)
movl 0x18(%rsp), %esi
movl 0x14(%rsp), %edx
callq 0x3d170
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: ATOMIC-LICHESS[P]ATOMKRAFT/position.cpp
// Function: Position::is_mate() const
bool Position::is_mate() const {
  STARTNEW
  if (piece_count(side_to_move(), KING) == 0) {
	  return true;
  }
  ENDNEW
  MoveStack moves[MAX_MOVES];
  return in_check() && generate<MV_LEGAL>(*this, moves) == moves;
}

// Assembly:
subq $0x828, %rsp            # imm = 0x828
movq %rdi, 0x818(%rsp)
movq 0x818(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xf5d0
movq 0x8(%rsp), %rdi
movl %eax, %esi
movl $0x6, %edx
callq 0x164c0
cmpl $0x0, %eax
jne 0x3d501
movb $0x1, 0x827(%rsp)
jmp 0x3d545
movq 0x8(%rsp), %rdi
callq 0x2e600
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x7(%rsp)
jne 0x3d51a
jmp 0x3d538
movq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x30420
leaq 0x10(%rsp), %rcx
cmpq %rcx, %rax
sete %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
andb $0x1, %al
movb %al, 0x827(%rsp)
movb 0x827(%rsp), %al
andb $0x1, %al
addq $0x828, %rsp            # imm = 0x828
retq
nopw %cs:(%rax,%rax)
// File: ATOMIC-LICHESS[P]ATOMKRAFT/position.cpp
// Function: Position::init_zobrist()
void Position::init_zobrist() {

  int i,j, k;
  RKISS rk;

  for (i = 0; i < 2; i++) for (j = 0; j < 8; j++) for (k = 0; k < 64; k++)
      zobrist[i][j][k] = rk.rand<Key>();

  for (i = 0; i < 64; i++)
      zobEp[i] = rk.rand<Key>();

  for (i = 0; i < 16; i++)
      zobCastle[i] = rk.rand<Key>();

  zobSideToMove = rk.rand<Key>();
  zobExclusion  = rk.rand<Key>();
}

// Assembly:
subq $0x38, %rsp
leaq 0x8(%rsp), %rdi
callq 0xf5f0
movl $0x0, 0x34(%rsp)
cmpl $0x2, 0x34(%rsp)
jge 0x3d602
movl $0x0, 0x30(%rsp)
cmpl $0x8, 0x30(%rsp)
jge 0x3d5f0
movl $0x0, 0x2c(%rsp)
cmpl $0x40, 0x2c(%rsp)
jge 0x3d5e1
leaq 0x8(%rsp), %rdi
callq 0x3ec00
movq %rax, %rdx
movslq 0x34(%rsp), %rcx
leaq 0x3aab88(%rip), %rax    # 0x3e8140
shlq $0xc, %rcx
addq %rcx, %rax
movslq 0x30(%rsp), %rcx
shlq $0x9, %rcx
addq %rcx, %rax
movslq 0x2c(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x3d598
jmp 0x3d5e3
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0x3d589
jmp 0x3d5f2
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x3d576
movl $0x0, 0x34(%rsp)
cmpl $0x40, 0x34(%rsp)
jge 0x3d63b
leaq 0x8(%rsp), %rdi
callq 0x3ec00
movq %rax, %rdx
movslq 0x34(%rsp), %rcx
leaq 0x3acb16(%rip), %rax    # 0x3ea140
movq %rdx, (%rax,%rcx,8)
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x3d60a
movl $0x0, 0x34(%rsp)
cmpl $0x10, 0x34(%rsp)
jge 0x3d674
leaq 0x8(%rsp), %rdi
callq 0x3ec00
movq %rax, %rdx
movslq 0x34(%rsp), %rcx
leaq 0x3accdd(%rip), %rax    # 0x3ea340
movq %rdx, (%rax,%rcx,8)
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x3d643
leaq 0x8(%rsp), %rdi
callq 0x3ec00
movq %rax, 0x3acd3b(%rip)    # 0x3ea3c0
leaq 0x8(%rsp), %rdi
callq 0x3ec00
movq %rax, 0x3acd32(%rip)    # 0x3ea3c8
addq $0x38, %rsp
retq
nopl (%rax,%rax)