LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: ATOMIC-LICHESS[P]ATOMKRAFT/evaluate.cpp
// Function: Score (anonymous namespace)::evaluate_pieces_of_color<(Color)0, false, false>(Position const&, (anonymous namespace)::EvalInfo&, Score&)
Score evaluate_pieces_of_color(const Position& pos, EvalInfo& ei, Score& mobility) {

    // OLD const Color Them = (Us == WHITE ? BLACK : WHITE);

    Score score = mobility = SCORE_ZERO;

    // Do not include in mobility squares protected by enemy pawns or occupied by our pieces
    //OLD const Bitboard mobilityArea = ~(ei.attackedBy[Them][PAWN] | pos.pieces_of_color(Us));
    STARTNEW 
    // it is common in atomic chess to move a piece where a pawn might attack
    const Bitboard mobilityArea = ~pos.pieces_of_color(Us);
    ENDNEW
    
    score += evaluate_pieces<KNIGHT, Us, HasPopCnt, Trace>(pos, ei, mobility, mobilityArea);
    score += evaluate_pieces<BISHOP, Us, HasPopCnt, Trace>(pos, ei, mobility, mobilityArea);
    score += evaluate_pieces<ROOK,   Us, HasPopCnt, Trace>(pos, ei, mobility, mobilityArea);
    score += evaluate_pieces<QUEEN,  Us, HasPopCnt, Trace>(pos, ei, mobility, mobilityArea);

    // Sum up all attacked squares
    ei.attackedBy[Us][0] =   ei.attackedBy[Us][PAWN]   | ei.attackedBy[Us][KNIGHT]
                           | ei.attackedBy[Us][BISHOP] | ei.attackedBy[Us][ROOK]
                           | ei.attackedBy[Us][QUEEN]  | ei.attackedBy[Us][KING];
    return score;
  }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x10(%rsp), %rax
movl $0x0, (%rax)
movl $0x0, 0xc(%rsp)
movq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x298c0
xorq $-0x1, %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq (%rsp), %rcx
callq 0x22f40
movl %eax, %esi
leaq 0xc(%rsp), %rdi
callq 0x29810
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq (%rsp), %rcx
callq 0x230f0
movl %eax, %esi
leaq 0xc(%rsp), %rdi
callq 0x29810
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq (%rsp), %rcx
callq 0x234e0
movl %eax, %esi
leaq 0xc(%rsp), %rdi
callq 0x29810
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq (%rsp), %rcx
callq 0x23ac0
movl %eax, %esi
leaq 0xc(%rsp), %rdi
callq 0x29810
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rcx
movq 0x18(%rsp), %rax
orq 0x20(%rax), %rcx
movq 0x18(%rsp), %rax
orq 0x28(%rax), %rcx
movq 0x18(%rsp), %rax
orq 0x30(%rax), %rcx
movq 0x18(%rsp), %rax
orq 0x38(%rax), %rcx
movq 0x18(%rsp), %rax
orq 0x40(%rax), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x10(%rax)
movl 0xc(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: ATOMIC-LICHESS[P]ATOMKRAFT/evaluate.cpp
// Function: (anonymous namespace)::scale_by_game_phase(Score const&, Phase, ScaleFactor)
Value scale_by_game_phase(const Score& v, Phase ph, ScaleFactor sf) {

    assert(mg_value(v) > -VALUE_INFINITE && mg_value(v) < VALUE_INFINITE);
    assert(eg_value(v) > -VALUE_INFINITE && eg_value(v) < VALUE_INFINITE);
    assert(ph >= PHASE_ENDGAME && ph <= PHASE_MIDGAME);

    int ev = (eg_value(v) * int(sf)) / SCALE_FACTOR_NORMAL;
    int result = (mg_value(v) * int(ph) + ev * int(128 - ph)) / 128;
    return Value((result + GrainSize / 2) & ~(GrainSize - 1));
  }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
movq 0x10(%rsp), %rax
movl (%rax), %edi
callq 0x281f0
movl %eax, %edi
movl 0x8(%rsp), %esi
callq 0x29f20
movl %eax, %edi
movl $0x40, %esi
callq 0x281b0
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rax
movl (%rax), %edi
callq 0x281d0
movl %eax, %edi
movl 0xc(%rsp), %esi
callq 0x29f20
movl %eax, %edi
movl 0x4(%rsp), %esi
movl $0x80, %eax
subl 0xc(%rsp), %eax
imull %eax, %esi
callq 0x1b340
movl %eax, %edi
movl $0x80, %esi
callq 0x281b0
movl %eax, (%rsp)
movl (%rsp), %eax
addl $0x4, %eax
andl $-0x8, %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: ATOMIC-LICHESS[P]ATOMKRAFT/./material.h
// Function: MaterialInfo::scale_factor(Position const&, Color) const
inline ScaleFactor MaterialInfo::scale_factor(const Position& pos, Color c) const {

  if (!scalingFunction[c])
      return ScaleFactor(factor[c]);

  ScaleFactor sf = scalingFunction[c]->apply(pos);
  return sf == SCALE_FACTOR_NONE ? ScaleFactor(factor[c]) : sf;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x1c(%rsp), %ecx
cmpq $0x0, 0x18(%rax,%rcx,8)
jne 0x2994c
movq 0x10(%rsp), %rax
movl 0x1c(%rsp), %ecx
movzbl 0xa(%rax,%rcx), %eax
movl %eax, 0x34(%rsp)
jmp 0x29997
movq 0x10(%rsp), %rax
movl 0x1c(%rsp), %ecx
movq 0x18(%rax,%rcx,8), %rdi
movq 0x20(%rsp), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, 0x18(%rsp)
cmpl $0xff, 0x18(%rsp)
jne 0x29987
movq 0x10(%rsp), %rax
movl 0x1c(%rsp), %ecx
movzbl 0xa(%rax,%rcx), %eax
movl %eax, 0xc(%rsp)
jmp 0x2998f
movl 0x18(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
// File: ATOMIC-LICHESS[P]ATOMKRAFT/./bitcount.h
// Function: int count_1s<(BitCountType)3>(unsigned long)
inline int count_1s<CNT32_MAX15>(Bitboard b) {
  unsigned w = unsigned(b >> 32), v = unsigned(b);
  v -= (v >> 1) & 0x55555555; // 0-2 in 2 bits
  w -= (w >> 1) & 0x55555555;
  v = ((v >> 2) & 0x33333333) + (v & 0x33333333); // 0-4 in 4 bits
  w = ((w >> 2) & 0x33333333) + (w & 0x33333333);
  v += w; // 0-8 in 4 bits
  v *= 0x11111111;
  return int(v >> 28);
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
shrq $0x20, %rax
movl %eax, -0xc(%rsp)
movq -0x8(%rsp), %rax
movl %eax, -0x10(%rsp)
movl -0x10(%rsp), %ecx
shrl %ecx
andl $0x55555555, %ecx       # imm = 0x55555555
movl -0x10(%rsp), %eax
subl %ecx, %eax
movl %eax, -0x10(%rsp)
movl -0xc(%rsp), %ecx
shrl %ecx
andl $0x55555555, %ecx       # imm = 0x55555555
movl -0xc(%rsp), %eax
subl %ecx, %eax
movl %eax, -0xc(%rsp)
movl -0x10(%rsp), %eax
shrl $0x2, %eax
andl $0x33333333, %eax       # imm = 0x33333333
movl -0x10(%rsp), %ecx
andl $0x33333333, %ecx       # imm = 0x33333333
addl %ecx, %eax
movl %eax, -0x10(%rsp)
movl -0xc(%rsp), %eax
shrl $0x2, %eax
andl $0x33333333, %eax       # imm = 0x33333333
movl -0xc(%rsp), %ecx
andl $0x33333333, %ecx       # imm = 0x33333333
addl %ecx, %eax
movl %eax, -0xc(%rsp)
movl -0xc(%rsp), %eax
addl -0x10(%rsp), %eax
movl %eax, -0x10(%rsp)
imull $0x11111111, -0x10(%rsp), %eax # imm = 0x11111111
movl %eax, -0x10(%rsp)
movl -0x10(%rsp), %eax
shrl $0x1c, %eax
retq
nop
// File: ATOMIC-LICHESS[P]ATOMKRAFT/main_uci.cpp
// Function: main_uci(int)
void main_uci(int argc) {

	if (argc < 2)
	{
		// Print copyright notice
		//cout << engine_name() << " by " << engine_authors() << endl;

		//if (CpuHasPOPCNT)
		//	cout << "Good! CPU has hardware POPCNT." << endl;

		// Wait for a command from the user, and passes this command to
		// execute_uci_command() and also intercepts EOF from stdin to
		// ensure that we exit gracefully if the GUI dies unexpectedly.
		string cmd;
		while (getline(cin, cmd) && execute_uci_command(cmd)) {}
	}

	Threads.exit();
}

// Assembly:
subq $0x48, %rsp
movl %edi, 0x44(%rsp)
cmpl $0x2, 0x44(%rsp)
jge 0x2a73a
leaq 0x20(%rsp), %rdi
callq 0x6730
movq 0x41924(%rip), %rdi     # 0x6bfd8
leaq 0x20(%rsp), %rsi
callq 0x6100
movq %rax, 0x8(%rsp)
jmp 0x2a6c5
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x6670
movb %al, 0x7(%rsp)
jmp 0x2a6df
movb 0x7(%rsp), %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x6(%rsp)
jne 0x2a6f0
jmp 0x2a70a
leaq 0x20(%rsp), %rdi
callq 0x524a0
movb %al, 0x5(%rsp)
jmp 0x2a700
movb 0x5(%rsp), %al
movb %al, 0x6(%rsp)
jmp 0x2a70a
movb 0x6(%rsp), %al
testb $0x1, %al
jne 0x2a714
jmp 0x2a730
jmp 0x2a6ad
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x6a78
jmp 0x2a74b
leaq 0x20(%rsp), %rdi
callq 0x6a78
leaq 0x3c64ff(%rip), %rdi    # 0x3f0c40
callq 0x4fbb0
addq $0x48, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x6970
nopw %cs:(%rax,%rax)
nop
// File: ATOMIC-LICHESS[P]ATOMKRAFT/material.cpp
// Function: MaterialInfoTable::game_phase(Position const&)
Phase MaterialInfoTable::game_phase(const Position& pos) {

  Value npm = pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK);
  
  STARTOLD
  return  npm >= MidgameLimit ? PHASE_MIDGAME
        : npm <= EndgameLimit ? PHASE_ENDGAME
        : Phase(((npm - EndgameLimit) * 128) / (MidgameLimit - EndgameLimit));
  ENDOLD
  
  STARTNEW
//  if (useImprovements) {
	  return  npm >= MidgameLimit/3 ? PHASE_MIDGAME
			: npm <= EndgameLimit/3 ? PHASE_ENDGAME
			: Phase(((npm - EndgameLimit/3) * 128) / (MidgameLimit/3 - EndgameLimit/3));
//  } else {
//	  return  npm >= MidgameLimit ? PHASE_MIDGAME
//			: npm <= EndgameLimit ? PHASE_ENDGAME
//			: Phase(((npm - EndgameLimit) * 128) / (MidgameLimit - EndgameLimit));
//  }
  ENDNEW
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
xorl %esi, %esi
callq 0x298e0
movl %eax, 0x24(%rsp)
movq 0x30(%rsp), %rdi
movl $0x1, %esi
callq 0x298e0
movl 0x24(%rsp), %edi
movl %eax, %esi
callq 0x1b320
movl %eax, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
movl %eax, 0x28(%rsp)
movl $0x3cdd, %edi           # imm = 0x3CDD
movl $0x3, %esi
callq 0x281b0
movl %eax, %ecx
movl 0x28(%rsp), %eax
cmpl %ecx, %eax
jl 0x2ae26
movl $0x80, %eax
movl %eax, 0x20(%rsp)
jmp 0x2aec5
movl 0x2c(%rsp), %eax
movl %eax, 0x1c(%rsp)
movl $0xf9e, %edi            # imm = 0xF9E
movl $0x3, %esi
callq 0x281b0
movl %eax, %ecx
movl 0x1c(%rsp), %eax
cmpl %ecx, %eax
jg 0x2ae4f
xorl %eax, %eax
movl %eax, 0x18(%rsp)
jmp 0x2aebd
movl 0x2c(%rsp), %eax
movl %eax, 0xc(%rsp)
movl $0xf9e, %edi            # imm = 0xF9E
movl $0x3, %esi
callq 0x281b0
movl 0xc(%rsp), %edi
movl %eax, %esi
callq 0x1b300
movl %eax, %edi
movl $0x80, %esi
callq 0x29f20
movl %eax, 0x14(%rsp)
movl $0x3cdd, %edi           # imm = 0x3CDD
movl $0x3, %esi
callq 0x281b0
movl %eax, 0x10(%rsp)
movl $0xf9e, %edi            # imm = 0xF9E
movl $0x3, %esi
callq 0x281b0
movl 0x10(%rsp), %edi
movl %eax, %esi
callq 0x1b300
movl 0x14(%rsp), %edi
movl %eax, %esi
callq 0x281b0
movl %eax, 0x18(%rsp)
movl 0x18(%rsp), %eax
movl %eax, 0x20(%rsp)
movl 0x20(%rsp), %eax
addq $0x38, %rsp
retq
nop
// File: ATOMIC-LICHESS[P]ATOMKRAFT/material.cpp
// Function: bool (anonymous namespace)::is_KXK<(Color)0>(Position const&)
bool is_KXK(const Position& pos) {
    const Color Them = (Us == WHITE ? BLACK : WHITE);
    
    return   pos.non_pawn_material(Them) == VALUE_ZERO
              && pos.piece_count(Them, PAWN) == 0;
    
    OLD return   pos.non_pawn_material(Them) == VALUE_ZERO
          && pos.piece_count(Them, PAWN) == 0
          && pos.non_pawn_material(Us)   >= RookValueMidgame;
  }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x1, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x298e0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0xb(%rsp)
jne 0x2af18
movq 0x10(%rsp), %rdi
movl $0x1, %edx
movl %edx, %esi
callq 0x164c0
cmpl $0x0, %eax
sete %al
movb %al, 0xb(%rsp)
movb 0xb(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: ATOMIC-LICHESS[P]ATOMKRAFT/./tt.h
// Function: SimpleHash<MaterialInfo, 8192>::init()
void init() {

    if (entries)
        return;

    entries = new (std::nothrow) Entry[HashSize];
    if (!entries)
    {
        std::cerr << "Failed to allocate " << HashSize * sizeof(Entry)
                  << " bytes for hash table." << std::endl;
        exit(EXIT_FAILURE);
    }
    memset(entries, 0, HashSize * sizeof(Entry));
  }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x8(%rax)
je 0x2b20f
jmp 0x2b2c0
movl $0x60000, %edi          # imm = 0x60000
movq 0x40d65(%rip), %rsi     # 0x6bf80
callq 0x68a0
movq %rax, %rcx
movq %rcx, 0x8(%rsp)
movb $0x0, 0x27(%rsp)
xorl %eax, %eax
cmpq $0x0, %rcx
movq %rax, 0x10(%rsp)
je 0x2b24e
movq 0x8(%rsp), %rax
movq %rax, 0x28(%rsp)
movb $0x1, 0x27(%rsp)
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0x8(%rax)
cmpq $0x0, 0x8(%rax)
jne 0x2b2ab
movq 0x40d86(%rip), %rdi     # 0x6bff0
leaq 0x2f4d6(%rip), %rsi     # 0x5a747
callq 0x64b0
movq %rax, %rdi
movl $0x60000, %esi          # imm = 0x60000
callq 0x6120
movq %rax, %rdi
leaq 0x2f4ce(%rip), %rsi     # 0x5a75b
callq 0x64b0
movq %rax, %rdi
movq 0x40cf4(%rip), %rsi     # 0x6bf90
callq 0x6520
movl $0x1, %edi
callq 0x6630
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdi
xorl %esi, %esi
movl $0x60000, %edx          # imm = 0x60000
callq 0x6280
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: ATOMIC-LICHESS[P]ATOMKRAFT/material.cpp
// Function: int MaterialInfoTable::imbalance<(Color)0>(int const (*) [8])
int MaterialInfoTable::imbalance(const int pieceCount[][8]) {

  const Color Them = (Us == WHITE ? BLACK : WHITE);

  int pt1, pt2, pc, v;
  int value = 0;

  // Redundancy of major pieces, formula based on Kaufman's paper
  // "The Evaluation of Material Imbalances in Chess"
  if (pieceCount[Us][ROOK] > 0)
      value -=  RedundantRookPenalty * (pieceCount[Us][ROOK] - 1)
              + RedundantQueenPenalty * pieceCount[Us][QUEEN];

  // Second-degree polynomial material imbalance by Tord Romstad
  for (pt1 = PIECE_TYPE_NONE; pt1 <= QUEEN; pt1++)
  {
      pc = pieceCount[Us][pt1];
      if (!pc)
          continue;

      v = LinearCoefficients[pt1];

      for (pt2 = PIECE_TYPE_NONE; pt2 <= pt1; pt2++)
          v +=  QuadraticCoefficientsSameColor[pt1][pt2] * pieceCount[Us][pt2]
              + QuadraticCoefficientsOppositeColor[pt1][pt2] * pieceCount[Them][pt2];

      value += pc * v;
  }
  return value;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl $0x1, 0x1c(%rsp)
movl $0x0, 0x8(%rsp)
movq 0x20(%rsp), %rax
cmpl $0x0, 0x10(%rax)
jle 0x2b366
movq 0x20(%rsp), %rax
movl 0x10(%rax), %esi
subl $0x1, %esi
movl $0x22a, %edi            # imm = 0x22A
callq 0x29f20
movl %eax, 0x4(%rsp)
movq 0x20(%rsp), %rax
movl 0x14(%rax), %esi
movl $0x140, %edi            # imm = 0x140
callq 0x29f20
movl 0x4(%rsp), %edi
movl %eax, %esi
callq 0x1b320
movl %eax, %ecx
movl 0x8(%rsp), %eax
subl %ecx, %eax
movl %eax, 0x8(%rsp)
movl $0x0, 0x18(%rsp)
cmpl $0x5, 0x18(%rsp)
jg 0x2b446
movq 0x20(%rsp), %rax
movslq 0x18(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0x10(%rsp)
cmpl $0x0, 0x10(%rsp)
jne 0x2b396
jmp 0x2b436
movslq 0x18(%rsp), %rcx
leaq 0x2f0de(%rip), %rax     # 0x5a480
movl (%rax,%rcx,4), %eax
movl %eax, 0xc(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x18(%rsp), %eax
jg 0x2b425
movslq 0x18(%rsp), %rcx
leaq 0x2f0d9(%rip), %rax     # 0x5a4a0
shlq $0x5, %rcx
addq %rcx, %rax
movslq 0x14(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movq 0x20(%rsp), %rcx
movslq 0x14(%rsp), %rdx
imull (%rcx,%rdx,4), %eax
movslq 0x18(%rsp), %rdx
leaq 0x2f170(%rip), %rcx     # 0x5a560
shlq $0x5, %rdx
addq %rdx, %rcx
movslq 0x14(%rsp), %rdx
movl (%rcx,%rdx,4), %ecx
movq 0x20(%rsp), %rdx
movslq 0x14(%rsp), %rsi
imull 0x20(%rdx,%rsi,4), %ecx
addl %ecx, %eax
addl 0xc(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x2b3b1
movl 0x10(%rsp), %eax
imull 0xc(%rsp), %eax
addl 0x8(%rsp), %eax
movl %eax, 0x8(%rsp)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x2b36e
movl 0x8(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: ATOMIC-LICHESS[P]ATOMKRAFT/misc.cpp
// Function: input_available()
int input_available() {

  fd_set readfds;
  struct timeval  timeout;

  FD_ZERO(&readfds);
  FD_SET(fileno(stdin), &readfds);
  timeout.tv_sec = 0; // Set to timeout immediately
  timeout.tv_usec = 0;
  select(16, &readfds, 0, 0, &timeout);

  return (FD_ISSET(fileno(stdin), &readfds));
}

// Assembly:
subq $0xb8, %rsp
leaq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
cmpq $0x10, %rax
jae 0x2c241
movq 0x18(%rsp), %rax
movl 0x24(%rsp), %ecx
movq $0x0, (%rax,%rcx,8)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x2c219
jmp 0x2c243
movq 0x3fd66(%rip), %rax     # 0x6bfb0
movq (%rax), %rdi
callq 0x6540
movl $0x40, %ecx
cltd
idivl %ecx
movl %edx, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, 0x8(%rsp)
movq 0x3fd3e(%rip), %rax     # 0x6bfb0
movq (%rax), %rdi
callq 0x6540
movq 0x8(%rsp), %rcx
movl $0x40, %esi
cltd
idivl %esi
cltq
orq 0x38(%rsp,%rax,8), %rcx
movq %rcx, 0x38(%rsp,%rax,8)
movq $0x0, 0x28(%rsp)
movq $0x0, 0x30(%rsp)
movl $0x10, %edi
leaq 0x38(%rsp), %rsi
xorl %eax, %eax
movl %eax, %ecx
leaq 0x28(%rsp), %r8
movq %rcx, %rdx
callq 0x6470
movq 0x3fce9(%rip), %rax     # 0x6bfb0
movq (%rax), %rdi
callq 0x6540
movl $0x40, %ecx
cltd
idivl %ecx
cltq
movq 0x38(%rsp,%rax,8), %rax
movq %rax, 0x10(%rsp)
movq 0x3fcc6(%rip), %rax     # 0x6bfb0
movq (%rax), %rdi
callq 0x6540
movl $0x40, %ecx
cltd
idivl %ecx
movq 0x10(%rsp), %rax
movl %edx, %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
addq $0xb8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: ATOMIC-LICHESS[P]ATOMKRAFT/move.cpp
// Function: move_from_uci(Position const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Move move_from_uci(const Position& pos, const string& str) {
	
	
  MoveStack mlist[MAX_MOVES];
  MoveStack* last = generate<MV_LEGAL>(pos, mlist);
  
  for (MoveStack* cur = mlist; cur != last; cur++)
      if (str == move_to_uci(cur->move, pos.is_chess960()))
          return cur->move;

  return MOVE_NONE;
}

// Assembly:
subq $0x868, %rsp            # imm = 0x868
movq %rdi, 0x858(%rsp)
movq %rsi, 0x850(%rsp)
movq 0x858(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x30420
movq %rax, 0x48(%rsp)
leaq 0x50(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
cmpq 0x48(%rsp), %rax
je 0x2cebd
movq 0x850(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rax
movl (%rax), %eax
movl %eax, 0xc(%rsp)
movq 0x858(%rsp), %rdi
callq 0x29b10
movl 0xc(%rsp), %esi
movzbl %al, %edx
andl $0x1, %edx
leaq 0x20(%rsp), %rdi
callq 0x2c960
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x2e4b0
movb %al, 0x1f(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x6a78
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0x2ce98
jmp 0x2cea8
movq 0x40(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x864(%rsp)
jmp 0x2cec8
jmp 0x2ceaa
movq 0x40(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x40(%rsp)
jmp 0x2ce28
movl $0x0, 0x864(%rsp)
movl 0x864(%rsp), %eax
addq $0x868, %rsp            # imm = 0x868
retq
nopw (%rax,%rax)
// File: ATOMIC-LICHESS[P]ATOMKRAFT/move.cpp
// Function: (anonymous namespace)::score_string[abi:cxx11](Value)
const string score_string(Value v) {

    std::stringstream s;

    if (v >= VALUE_MATE - 200)
        s << "#" << (VALUE_MATE - v + 1) / 2;
    else if (v <= -VALUE_MATE + 200)
        s << "-#" << (VALUE_MATE + v) / 2;
    else
        s << std::setprecision(2) << std::fixed << std::showpos << float(v) / PawnValueMidgame;

    return s.str();
  }

// Assembly:
subq $0x218, %rsp            # imm = 0x218
movq %rdi, 0x58(%rsp)
movq %rdi, %rax
movq %rax, 0x60(%rsp)
movq %rdi, 0x210(%rsp)
movl %esi, 0x20c(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x6340
movl 0x20c(%rsp), %eax
movl %eax, 0x68(%rsp)
movl $0x7530, %edi           # imm = 0x7530
movl $0xc8, %esi
callq 0x29ca0
movl %eax, 0x6c(%rsp)
jmp 0x2df50
movl 0x68(%rsp), %eax
movl 0x6c(%rsp), %ecx
cmpl %ecx, %eax
jl 0x2dfef
leaq 0x90(%rsp), %rdi
leaq 0x2c8fe(%rip), %rsi     # 0x5a86d
callq 0x64b0
movq %rax, 0x50(%rsp)
jmp 0x2df7b
movl 0x20c(%rsp), %esi
movl $0x7530, %edi           # imm = 0x7530
callq 0x1b300
movl %eax, 0x4c(%rsp)
jmp 0x2df92
movl 0x4c(%rsp), %edi
movl $0x1, %esi
callq 0x1b340
movl %eax, 0x48(%rsp)
jmp 0x2dfa6
movl 0x48(%rsp), %edi
movl $0x2, %esi
callq 0x281b0
movl %eax, 0x44(%rsp)
jmp 0x2dfba
movl 0x44(%rsp), %esi
movq 0x50(%rsp), %rdi
callq 0x6940
jmp 0x2dfca
jmp 0x2e115
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x6a80
jmp 0x2e143
movl 0x20c(%rsp), %eax
movl %eax, 0x3c(%rsp)
movl $0x7530, %edi           # imm = 0x7530
callq 0x1b2b0
movl %eax, 0x40(%rsp)
jmp 0x2e00a
movl 0x40(%rsp), %edi
movl $0xc8, %esi
callq 0x1b340
movl %eax, 0x38(%rsp)
jmp 0x2e01e
movl 0x3c(%rsp), %eax
movl 0x38(%rsp), %ecx
cmpl %ecx, %eax
jg 0x2e085
leaq 0x90(%rsp), %rdi
leaq 0x2c833(%rip), %rsi     # 0x5a86c
callq 0x64b0
movq %rax, 0x30(%rsp)
jmp 0x2e045
movl 0x20c(%rsp), %esi
movl $0x7530, %edi           # imm = 0x7530
callq 0x1b320
movl %eax, 0x2c(%rsp)
jmp 0x2e05c
movl 0x2c(%rsp), %edi
movl $0x2, %esi
callq 0x281b0
movl %eax, 0x28(%rsp)
jmp 0x2e070
movl 0x28(%rsp), %esi
movq 0x30(%rsp), %rdi
callq 0x6940
jmp 0x2e080
jmp 0x2e113
leaq 0x90(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x2, %edi
callq 0x28140
movl %eax, 0x24(%rsp)
jmp 0x2e0a2
movq 0x18(%rsp), %rdi
movl 0x24(%rsp), %eax
movl %eax, 0x70(%rsp)
movl 0x70(%rsp), %esi
callq 0x6830
movq %rax, 0x10(%rsp)
jmp 0x2e0bf
movq 0x10(%rsp), %rdi
leaq -0x5fab(%rip), %rsi     # 0x28120
callq 0x6170
movq %rax, 0x8(%rsp)
jmp 0x2e0d7
movq 0x8(%rsp), %rdi
leaq -0x5fe3(%rip), %rsi     # 0x28100
callq 0x6170
movq %rax, (%rsp)
jmp 0x2e0ee
movq (%rsp), %rdi
cvtsi2ssl 0x20c(%rsp), %xmm0
leaq 0x3e456(%rip), %rax     # 0x6c558
cvtsi2ssl (%rax), %xmm1
divss %xmm1, %xmm0
callq 0x6380
jmp 0x2e111
jmp 0x2e113
jmp 0x2e115
movq 0x58(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x64a0
jmp 0x2e129
leaq 0x80(%rsp), %rdi
callq 0x6a80
movq 0x60(%rsp), %rax
addq $0x218, %rsp            # imm = 0x218
retq
movq 0x78(%rsp), %rdi
callq 0x6970
nopl (%rax)
// File: ATOMIC-LICHESS[P]ATOMKRAFT/move.cpp
// Function: (anonymous namespace)::time_string[abi:cxx11](int)
const string time_string(int millisecs) {

    const int MSecMinute = 1000 * 60;
    const int MSecHour   = 1000 * 60 * 60;

    int hours = millisecs / MSecHour;
    int minutes =  (millisecs % MSecHour) / MSecMinute;
    int seconds = ((millisecs % MSecHour) % MSecMinute) / 1000;

    std::stringstream s;

    if (hours)
        s << hours << ':';

    s << std::setfill('0') << std::setw(2) << minutes << ':' << std::setw(2) << seconds;
    return s.str();
  }

// Assembly:
subq $0x218, %rsp            # imm = 0x218
movq %rdi, 0x48(%rsp)
movq %rdi, %rax
movq %rax, 0x50(%rsp)
movq %rdi, 0x210(%rsp)
movl %esi, 0x20c(%rsp)
movl $0xea60, 0x208(%rsp) # imm = 0xEA60
movl $0x36ee80, 0x204(%rsp) # imm = 0x36EE80
movl 0x20c(%rsp), %eax
movl $0x36ee80, %ecx         # imm = 0x36EE80
cltd
idivl %ecx
movl %eax, 0x200(%rsp)
movl 0x20c(%rsp), %eax
movl $0x36ee80, %ecx         # imm = 0x36EE80
cltd
idivl %ecx
movl %edx, %eax
movl $0xea60, %ecx           # imm = 0xEA60
cltd
idivl %ecx
movl %eax, 0x1fc(%rsp)
movl 0x20c(%rsp), %eax
movl $0x36ee80, %ecx         # imm = 0x36EE80
cltd
idivl %ecx
movl %edx, %eax
movl $0xea60, %ecx           # imm = 0xEA60
cltd
idivl %ecx
movl %edx, %eax
movl $0x3e8, %ecx            # imm = 0x3E8
cltd
idivl %ecx
movl %eax, 0x1f8(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x6340
cmpl $0x0, 0x200(%rsp)
je 0x2e248
leaq 0x80(%rsp), %rdi
movl 0x200(%rsp), %esi
callq 0x6940
movq %rax, 0x40(%rsp)
jmp 0x2e218
movq 0x40(%rsp), %rdi
movl $0x3a, %esi
callq 0x65d0
jmp 0x2e229
jmp 0x2e248
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x6a80
jmp 0x2e332
leaq 0x80(%rsp), %rax
movq %rax, 0x30(%rsp)
movl $0x30, %edi
callq 0x2c430
movb %al, 0x3f(%rsp)
jmp 0x2e265
movq 0x30(%rsp), %rdi
movb 0x3f(%rsp), %al
movb %al, 0x63(%rsp)
movzbl 0x63(%rsp), %esi
callq 0x6810
movq %rax, 0x28(%rsp)
jmp 0x2e283
movl $0x2, %edi
callq 0x28160
movq 0x28(%rsp), %rdi
movl %eax, 0x5c(%rsp)
movl 0x5c(%rsp), %esi
callq 0x65a0
movq %rax, 0x20(%rsp)
jmp 0x2e2a6
movq 0x20(%rsp), %rdi
movl 0x1fc(%rsp), %esi
callq 0x6940
movq %rax, 0x18(%rsp)
jmp 0x2e2be
movq 0x18(%rsp), %rdi
movl $0x3a, %esi
callq 0x65d0
movq %rax, 0x10(%rsp)
jmp 0x2e2d4
movl $0x2, %edi
callq 0x28160
movq 0x10(%rsp), %rdi
movl %eax, 0x58(%rsp)
movl 0x58(%rsp), %esi
callq 0x65a0
movq %rax, 0x8(%rsp)
jmp 0x2e2f7
movq 0x8(%rsp), %rdi
movl 0x1f8(%rsp), %esi
callq 0x6940
jmp 0x2e30a
movq 0x48(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x64a0
jmp 0x2e31b
leaq 0x70(%rsp), %rdi
callq 0x6a80
movq 0x50(%rsp), %rax
addq $0x218, %rsp            # imm = 0x218
retq
movq 0x68(%rsp), %rdi
callq 0x6970
nopl (%rax)
// File: ATOMIC-LICHESS[P]ATOMKRAFT/movegen.cpp
// Function: MoveStack* (anonymous namespace)::generate_discovered_checks<(PieceType)6>(Position const&, MoveStack*, Square)
inline MoveStack* generate_discovered_checks(const Position& pos, MoveStack* mlist, Square from) {
	NEW assert(pos.piece_count(WHITE, KING) && pos.piece_count(BLACK, KING));
    assert(Pt != QUEEN);

    Bitboard b = pos.attacks_from<Pt>(from) & pos.empty_squares();
    if (Pt == KING)
    {
    	STARTNEW
#ifndef NDEBUG
    	if (!pos.piece_count(opposite_color(pos.side_to_move()), KING)) {
    		cout << "from: " << from << endl;
    		print_debuginfo(pos);
    	}
#endif
    	ENDNEW
    	
    	NEW assert(pos.piece_count(opposite_color(pos.side_to_move()), KING));
        Square ksq = pos.king_square(opposite_color(pos.side_to_move()));
        b &= ~QueenPseudoAttacks[ksq];
    }
    SERIALIZE_MOVES(b);
    return mlist;
  }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movq 0x40(%rsp), %rdi
movl 0x34(%rsp), %esi
callq 0x1b440
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rdi
callq 0x33220
movq %rax, %rcx
movq 0x10(%rsp), %rax
andq %rcx, %rax
movq %rax, 0x28(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rdi
callq 0xf5d0
movl %eax, %edi
callq 0x122b0
movq 0x18(%rsp), %rdi
movl %eax, %esi
callq 0x1b250
movl %eax, 0x24(%rsp)
movslq 0x24(%rsp), %rcx
leaq 0x1243da(%rip), %rax    # 0x153860
movq (%rax,%rcx,8), %rax
xorq $-0x1, %rax
andq 0x28(%rsp), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x2f4d4
movl 0x34(%rsp), %eax
movl %eax, 0xc(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xd940
movl 0xc(%rsp), %edi
movl %eax, %esi
callq 0xf810
movl %eax, %ecx
movq 0x38(%rsp), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x38(%rsp)
movl %ecx, (%rax)
jmp 0x2f498
movq 0x38(%rsp), %rax
addq $0x48, %rsp
retq
nop
// File: ATOMIC-LICHESS[P]ATOMKRAFT/movegen.cpp
// Function: MoveStack* (anonymous namespace)::generate_direct_checks<(PieceType)3>(Position const&, MoveStack*, Color, unsigned long, Square)
inline MoveStack* generate_direct_checks(const Position& pos, MoveStack* mlist, Color us,
                                           Bitboard dc, Square ksq) {
	NEW assert(pos.piece_count(WHITE, KING) && pos.piece_count(BLACK, KING));
    assert(Pt != KING);

    Bitboard checkSqs, b;
    Square from;
    const Square* ptr = pos.piece_list_begin(us, Pt);

    if ((from = *ptr++) == SQ_NONE)
        return mlist;

    checkSqs = pos.attacks_from<Pt>(ksq) & pos.empty_squares();

    do
    {
        if (   (Pt == QUEEN  && !(QueenPseudoAttacks[from]  & checkSqs))
            || (Pt == ROOK   && !(RookPseudoAttacks[from]   & checkSqs))
            || (Pt == BISHOP && !(BishopPseudoAttacks[from] & checkSqs)))
            continue;

        if (dc && bit_is_set(dc, from))
            continue;

        b = pos.attacks_from<Pt>(from) & checkSqs;
        SERIALIZE_MOVES(b);

    } while ((from = *ptr++) != SQ_NONE);

    return mlist;
  }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movl %edx, 0x4c(%rsp)
movq %rcx, 0x40(%rsp)
movl %r8d, 0x3c(%rsp)
movq 0x58(%rsp), %rdi
movl 0x4c(%rsp), %esi
movl $0x3, %edx
callq 0x299d0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, 0x18(%rsp)
movl (%rax), %eax
movl %eax, 0x24(%rsp)
cmpl $0x40, %eax
jne 0x2f67f
movq 0x50(%rsp), %rax
movq %rax, 0x60(%rsp)
jmp 0x2f767
movq 0x58(%rsp), %rdi
movl 0x3c(%rsp), %esi
callq 0x1b550
movq %rax, 0x10(%rsp)
movq 0x58(%rsp), %rdi
callq 0x33220
movq %rax, %rcx
movq 0x10(%rsp), %rax
andq %rcx, %rax
movq %rax, 0x30(%rsp)
movslq 0x24(%rsp), %rcx
leaq 0x123da8(%rip), %rax    # 0x153460
movq (%rax,%rcx,8), %rax
andq 0x30(%rsp), %rax
cmpq $0x0, %rax
jne 0x2f6c9
jmp 0x2f73d
cmpq $0x0, 0x40(%rsp)
je 0x2f6e7
movq 0x40(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0xd760
cmpq $0x0, %rax
je 0x2f6e7
jmp 0x2f73d
movq 0x58(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x1b550
andq 0x30(%rsp), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x2f73b
movl 0x24(%rsp), %eax
movl %eax, 0xc(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xd940
movl 0xc(%rsp), %edi
movl %eax, %esi
callq 0xf810
movl %eax, %ecx
movq 0x50(%rsp), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x50(%rsp)
movl %ecx, (%rax)
jmp 0x2f6ff
jmp 0x2f73d
movq 0x18(%rsp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, 0x18(%rsp)
movl (%rax), %eax
movl %eax, 0x24(%rsp)
cmpl $0x40, %eax
jne 0x2f6ac
movq 0x50(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: ATOMIC-LICHESS[P]ATOMKRAFT/movegen.cpp
// Function: MoveStack* generate<(MoveType)7>(Position const&, MoveStack*)
MoveStack* generate<MV_PSEUDO_LEGAL>(const Position& pos, MoveStack* mlist) {
  NEW assert(pos.piece_count(WHITE, KING) && pos.piece_count(BLACK, KING));
		
  assert(pos.is_ok());
  
  STARTNEW
  // TODO: maybe unnecessary
  if (pos.piece_count(WHITE, KING) == 0 || pos.piece_count(BLACK, KING) == 0) {
	  return mlist;
  }
  ENDNEW
  
  return pos.in_check() ? generate<MV_EVASION>(pos, mlist)
                        : generate<MV_NON_EVASION>(pos, mlist);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
xorl %esi, %esi
movl $0x6, %edx
callq 0x164c0
cmpl $0x0, %eax
je 0x303bd
movq 0x18(%rsp), %rdi
movl $0x1, %esi
movl $0x6, %edx
callq 0x164c0
cmpl $0x0, %eax
jne 0x303c9
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x3040d
movq 0x18(%rsp), %rdi
callq 0x2e600
testb $0x1, %al
jne 0x303d9
jmp 0x303ef
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x2fa40
movq %rax, 0x8(%rsp)
jmp 0x30403
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x33240
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: ATOMIC-LICHESS[P]ATOMKRAFT/movegen.cpp
// Function: MoveStack* generate<(MoveType)6>(Position const&, MoveStack*)
MoveStack* generate<MV_LEGAL>(const Position& pos, MoveStack* mlist) {
  STARTNEW
  if (!(pos.piece_count(WHITE, KING) && pos.piece_count(BLACK, KING))) {
	  return mlist;
  }
  ENDNEW
  //NEW assert(pos.piece_count(WHITE, KING) && pos.piece_count(BLACK, KING));
		
  assert(pos.is_ok());
  

  MoveStack *last, *cur = mlist;
  Bitboard pinned = pos.pinned_pieces(pos.side_to_move());

  last = generate<MV_PSEUDO_LEGAL>(pos, mlist);
  
  
  
  // Remove illegal moves from the list
  while (cur != last) {
	  //NEW assert(pos.color_of_piece_on(move_from(cur->move)) == pos.side_to_move());
      if (!pos.pl_move_is_legal(cur->move, pinned))
          cur->move = (--last)->move;
      else
          cur++;
      
  }

  return last;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
xorl %esi, %esi
movl $0x6, %edx
callq 0x164c0
cmpl $0x0, %eax
je 0x3045d
movq 0x28(%rsp), %rdi
movl $0x1, %esi
movl $0x6, %edx
callq 0x164c0
cmpl $0x0, %eax
jne 0x3046c
movq 0x20(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x3050a
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rdi
callq 0xf5d0
movq (%rsp), %rdi
movl %eax, %esi
callq 0x38990
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x30380
movq %rax, 0x18(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x18(%rsp), %rax
je 0x30500
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rax
movl (%rax), %esi
movq 0x8(%rsp), %rdx
callq 0x38e80
testb $0x1, %al
jne 0x304f0
movq 0x18(%rsp), %rax
movq %rax, %rcx
addq $-0x8, %rcx
movq %rcx, 0x18(%rsp)
movl -0x8(%rax), %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
jmp 0x304fe
movq 0x10(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x10(%rsp)
jmp 0x304ad
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: ATOMIC-LICHESS[P]ATOMKRAFT/movegen.cpp
// Function: MoveStack* (anonymous namespace)::generate_promotions<(Color)0, (MoveType)4, (Square)8>(Position const&, MoveStack*, unsigned long, unsigned long)
inline MoveStack* generate_promotions(const Position& pos, MoveStack* mlist, Bitboard pawnsOn7, Bitboard target) {
	NEW assert(pos.piece_count(WHITE, KING) && pos.piece_count(BLACK, KING));
	  	
    const Bitboard TFileABB = (Delta == DELTA_NE || Delta == DELTA_SE ? FileABB : FileHBB);

    Bitboard b;
    Square to;

    // Promotions and under-promotions, both captures and non-captures
    b = move_pawns<Delta>(pawnsOn7) & target;

    if (Delta != DELTA_N && Delta != DELTA_S)
        b &= ~TFileABB;

    while (b)
    {
        to = pop_1st_bit(&b);

        if (Type == MV_CAPTURE || Type == MV_EVASION)
            (*mlist++).move = make_promotion_move(to - Delta, to, QUEEN);

        if (Type == MV_NON_CAPTURE || Type == MV_EVASION)
        {
            (*mlist++).move = make_promotion_move(to - Delta, to, ROOK);
            (*mlist++).move = make_promotion_move(to - Delta, to, BISHOP);
            (*mlist++).move = make_promotion_move(to - Delta, to, KNIGHT);
        }

        // This is the only possible under promotion that can give a check
        // not already included in the queen-promotion.
        NEW assert(pos.piece_count(opposite_color(Us), KING));
        if (   Type == MV_CHECK
            && bit_is_set(pos.attacks_from<KNIGHT>(to), pos.king_square(opposite_color(Us))))
            (*mlist++).move = make_promotion_move(to - Delta, to, KNIGHT);
        else (void)pos; // Silence a warning under MSVC
    }
    return mlist;
  }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movabsq $-0x7f7f7f7f7f7f7f80, %rax # imm = 0x8080808080808080
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x30aa0
andq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x32266
leaq 0x8(%rsp), %rdi
callq 0xd940
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %edi
movl $0x8, %esi
callq 0xe9c0
movl %eax, %edi
movl 0x4(%rsp), %esi
movl $0x5, %edx
callq 0xf650
movl %eax, %ecx
movq 0x28(%rsp), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x28(%rsp)
movl %ecx, (%rax)
movl 0x4(%rsp), %edi
movl $0x8, %esi
callq 0xe9c0
movl %eax, %edi
movl 0x4(%rsp), %esi
movl $0x4, %edx
callq 0xf650
movl %eax, %ecx
movq 0x28(%rsp), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x28(%rsp)
movl %ecx, (%rax)
movl 0x4(%rsp), %edi
movl $0x8, %esi
callq 0xe9c0
movl %eax, %edi
movl 0x4(%rsp), %esi
movl $0x3, %edx
callq 0xf650
movl %eax, %ecx
movq 0x28(%rsp), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x28(%rsp)
movl %ecx, (%rax)
movl 0x4(%rsp), %edi
movl $0x8, %esi
callq 0xe9c0
movl %eax, %edi
movl 0x4(%rsp), %esi
movl $0x2, %edx
callq 0xf650
movl %eax, %ecx
movq 0x28(%rsp), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x28(%rsp)
movl %ecx, (%rax)
jmp 0x3217b
movq 0x28(%rsp), %rax
addq $0x38, %rsp
retq
// File: ATOMIC-LICHESS[P]ATOMKRAFT/movegen.cpp
// Function: MoveStack* (anonymous namespace)::generate_pawn_captures<(MoveType)0, (Square)9>(MoveStack*, unsigned long, unsigned long)
inline MoveStack* generate_pawn_captures(MoveStack* mlist, Bitboard pawns, Bitboard target) {
	  	
    const Bitboard TFileABB = (Delta == DELTA_NE || Delta == DELTA_SE ? FileABB : FileHBB);

    Bitboard b;
    Square to;

    // Captures in the a1-h8 (a8-h1 for black) diagonal or in the h1-a8 (h8-a1 for black)
    b = move_pawns<Delta>(pawns) & target & ~TFileABB;
    SERIALIZE_MOVES_D(b, -Delta);
    return mlist;
  }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movabsq $0x101010101010101, %rax # imm = 0x101010101010101
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
callq 0x31230
andq 0x20(%rsp), %rax
movabsq $-0x101010101010102, %rcx # imm = 0xFEFEFEFEFEFEFEFE
andq %rcx, %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x31168
leaq 0x10(%rsp), %rdi
callq 0xd940
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x8(%rsp)
movl $0x9, %edi
callq 0x33a00
movl 0x8(%rsp), %edi
movl %eax, %esi
callq 0xd780
movl %eax, %edi
movl 0xc(%rsp), %esi
callq 0xf810
movl %eax, %ecx
movq 0x30(%rsp), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x30(%rsp)
movl %ecx, (%rax)
jmp 0x31113
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: ATOMIC-LICHESS[P]ATOMKRAFT/movepick.cpp
// Function: MovePicker::go_next_phase()
void MovePicker::go_next_phase() {

  curMove = moves;
  phase = *(++phasePtr);
  switch (phase) {

  case PH_TT_MOVES:
      curMove = ttMoves;
      lastMove = curMove + 2;
      return;

  case PH_GOOD_CAPTURES:
      lastMove = generate<MV_CAPTURE>(pos, moves);
      score_captures();
      return;

  case PH_KILLERS:
      curMove = killers;
      lastMove = curMove + 2;
      return;

  case PH_NONCAPTURES:
      lastMove = generate<MV_NON_CAPTURE>(pos, moves);
      score_noncaptures();
      sort_moves(moves, lastMove, &lastGoodNonCapture);
      return;

  case PH_BAD_CAPTURES:
      // Bad captures SEE value is already calculated so just pick
      // them in order to get SEE move ordering.
      curMove = badCaptures;
      lastMove = moves + MAX_MOVES;
      return;

  case PH_EVASIONS:
      assert(pos.in_check());
      lastMove = generate<MV_EVASION>(pos, moves);
      score_evasions();
      return;

  case PH_QCAPTURES:
      lastMove = generate<MV_CAPTURE>(pos, moves);
      score_captures();
      return;

  case PH_QCHECKS:
      lastMove = generate<MV_NON_CAPTURE_CHECK>(pos, moves);
      return;

  case PH_STOP:
      lastMove = curMove + 1; // Avoid another go_next_phase() call
      return;

  default:
      assert(false);
      return;
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq %rax, %rcx
addq $0x68, %rcx
movq %rcx, 0x48(%rax)
movq 0x40(%rax), %rcx
movq %rcx, %rdx
incq %rdx
movq %rdx, 0x40(%rax)
movzbl 0x1(%rcx), %ecx
movl %ecx, 0x3c(%rax)
movl 0x3c(%rax), %eax
movq %rax, 0x8(%rsp)
subq $0x8, %rax
ja 0x33ea2
movq 0x8(%rsp), %rax
leaq 0x26d50(%rip), %rcx     # 0x5aac0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rsp), %rax
movq %rax, %rcx
addq $0x18, %rcx
movq %rcx, 0x48(%rax)
movq 0x48(%rax), %rcx
addq $0x10, %rcx
movq %rcx, 0x50(%rax)
jmp 0x33ea4
movq (%rsp), %rsi
movq (%rsi), %rdi
addq $0x68, %rsi
callq 0x32660
movq (%rsp), %rdi
movq %rax, 0x50(%rdi)
callq 0x33fe0
jmp 0x33ea4
movq (%rsp), %rax
movq %rax, %rcx
addq $0x28, %rcx
movq %rcx, 0x48(%rax)
movq 0x48(%rax), %rcx
addq $0x10, %rcx
movq %rcx, 0x50(%rax)
jmp 0x33ea4
movq (%rsp), %rsi
movq (%rsi), %rdi
addq $0x68, %rsi
callq 0x32bc0
movq (%rsp), %rdi
movq %rax, 0x50(%rdi)
callq 0x340c0
movq (%rsp), %rdx
movq %rdx, %rdi
addq $0x68, %rdi
movq 0x50(%rdx), %rsi
addq $0x58, %rdx
callq 0x346f0
jmp 0x33ea4
movq (%rsp), %rax
movq 0x60(%rax), %rcx
movq %rcx, 0x48(%rax)
movq %rax, %rcx
addq $0x68, %rcx
addq $0x800, %rcx            # imm = 0x800
movq %rcx, 0x50(%rax)
jmp 0x33ea4
movq (%rsp), %rsi
movq (%rsi), %rdi
addq $0x68, %rsi
callq 0x2fa40
movq (%rsp), %rdi
movq %rax, 0x50(%rdi)
callq 0x34160
jmp 0x33ea4
movq (%rsp), %rsi
movq (%rsi), %rdi
addq $0x68, %rsi
callq 0x32660
movq (%rsp), %rdi
movq %rax, 0x50(%rdi)
callq 0x33fe0
jmp 0x33ea4
movq (%rsp), %rsi
movq (%rsi), %rdi
addq $0x68, %rsi
callq 0x2f040
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x50(%rax)
jmp 0x33ea4
movq (%rsp), %rax
movq 0x48(%rax), %rcx
addq $0x8, %rcx
movq %rcx, 0x50(%rax)
jmp 0x33ea4
jmp 0x33ea4
addq $0x18, %rsp
retq
nopl (%rax)
// File: ATOMIC-LICHESS[P]ATOMKRAFT/movepick.cpp
// Function: MovePicker::MovePicker(Position const&, Move, Depth, History const&)
MovePicker::MovePicker(const Position& p, Move ttm, Depth d, const History& h)
                      : pos(p), H(h) {
  int searchTT = ttm;
  ttMoves[0].move = ttm;
  ttMoves[1].move = MOVE_NONE;

  assert(d <= DEPTH_ZERO);

  pinned = p.pinned_pieces(pos.side_to_move());

  if (p.in_check())
      phasePtr = EvasionTable;
  else if (d >= DEPTH_QS_CHECKS)
      phasePtr = QsearchWithChecksTable;
  else
  {
      phasePtr = QsearchWithoutChecksTable;

      // Skip TT move if is not a capture or a promotion, this avoids
      // qsearch tree explosion due to a possible perpetual check or
      // similar rare cases when TT table is full.
      if (ttm != MOVE_NONE && !pos.move_is_capture_or_promotion(ttm))
          searchTT = ttMoves[0].move = MOVE_NONE;
  }

  phasePtr += int(!searchTT) - 1;
  go_next_phase();
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movl %ecx, 0x20(%rsp)
movq %r8, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rcx
movq %rcx, (%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl 0x24(%rsp), %ecx
movl %ecx, 0x14(%rsp)
movl 0x24(%rsp), %ecx
movl %ecx, 0x18(%rax)
movl $0x0, 0x20(%rax)
movq 0x28(%rsp), %rcx
movq %rcx, (%rsp)
movq (%rax), %rdi
callq 0xf5d0
movq (%rsp), %rdi
movl %eax, %esi
callq 0x38990
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x28(%rsp), %rdi
callq 0x2e600
testb $0x1, %al
jne 0x33f34
jmp 0x33f46
movq 0x8(%rsp), %rax
leaq 0x26bc8(%rip), %rcx     # 0x5ab08
movq %rcx, 0x40(%rax)
jmp 0x33fa3
cmpl $-0x2, 0x20(%rsp)
jl 0x33f5f
movq 0x8(%rsp), %rax
leaq 0x26bed(%rip), %rcx     # 0x5ab46
movq %rcx, 0x40(%rax)
jmp 0x33fa1
movq 0x8(%rsp), %rax
leaq 0x26bdf(%rip), %rcx     # 0x5ab4a
movq %rcx, 0x40(%rax)
cmpl $0x0, 0x24(%rsp)
je 0x33f9f
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movl 0x24(%rsp), %esi
callq 0x34680
testb $0x1, %al
jne 0x33f9f
movq 0x8(%rsp), %rax
movl $0x0, 0x18(%rax)
movl $0x0, 0x14(%rsp)
jmp 0x33fa1
jmp 0x33fa3
movq 0x8(%rsp), %rdi
cmpl $0x0, 0x14(%rsp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %ecx
subl $0x1, %ecx
movq 0x40(%rdi), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x40(%rdi)
callq 0x33d20
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: ATOMIC-LICHESS[P]ATOMKRAFT/movepick.cpp
// Function: MovePicker::score_captures()
void MovePicker::score_captures() {
  // Winning and equal captures in the main search are ordered by MVV/LVA.
  // Suprisingly, this appears to perform slightly better than SEE based
  // move ordering. The reason is probably that in a position with a winning
  // capture, capturing a more valuable (but sufficiently defended) piece
  // first usually doesn't hurt. The opponent will have to recapture, and
  // the hanging piece will still be hanging (except in the unusual cases
  // where it is possible to recapture with the hanging piece). Exchanging
  // big pieces before capturing a hanging piece probably helps to reduce
  // the subtree size.
  // In main search we want to push captures with negative SEE values to
  // badCaptures[] array, but instead of doing it now we delay till when
  // the move has been picked up in pick_move_from_list(), this way we save
  // some SEE calls in case we get a cutoff (idea from Pablo Vazquez).
  Move m;

  // Use MVV/LVA ordering
  for (MoveStack* cur = moves; cur != lastMove; cur++)
  {
      m = cur->move;
      if (move_is_promotion(m))
          cur->score = QueenValueMidgame; NEW // this never happens in atomic chess
      else
          cur->score =  pos.midgame_value_of_piece_on(move_to(m))
                      - pos.type_of_piece_on(move_from(m));
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
addq $0x68, %rax
movq %rax, 0x20(%rsp)
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %rax
cmpq 0x50(%rcx), %rax
je 0x340af
movq 0x20(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x2c(%rsp)
movl 0x2c(%rsp), %edi
callq 0xfb40
testb $0x1, %al
jne 0x3402a
jmp 0x3403d
leaq 0x38547(%rip), %rax     # 0x6c578
movl (%rax), %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x4(%rax)
jmp 0x3409a
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
movl 0x2c(%rsp), %edi
callq 0xf690
movq (%rsp), %rdi
movl %eax, %esi
callq 0x347f0
movl %eax, %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x14(%rsp)
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movl 0x2c(%rsp), %edi
callq 0xf680
movq 0x8(%rsp), %rdi
movl %eax, %esi
callq 0x11f10
movl 0x14(%rsp), %edi
movl %eax, %esi
callq 0x29ca0
movl %eax, %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x4(%rax)
jmp 0x3409c
movq 0x20(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x20(%rsp)
jmp 0x33ffc
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: ATOMIC-LICHESS[P]ATOMKRAFT/movepick.cpp
// Function: MovePicker::score_noncaptures()
void MovePicker::score_noncaptures() {

  Move m;
  Square from;

  for (MoveStack* cur = moves; cur != lastMove; cur++)
  {
      m = cur->move;
      from = move_from(m);
      cur->score = H.value(pos.piece_on(from), move_to(m));
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
addq $0x68, %rax
movq %rax, 0x20(%rsp)
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %rax
cmpq 0x50(%rcx), %rax
je 0x34157
movq 0x20(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x2c(%rsp)
movl 0x2c(%rsp), %edi
callq 0xf680
movl %eax, %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x28(%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %rdi
movl 0x28(%rsp), %esi
callq 0xf530
movl %eax, 0x14(%rsp)
movl 0x2c(%rsp), %edi
callq 0xf690
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %esi
movl %eax, %edx
callq 0x34820
movl %eax, %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x4(%rax)
movq 0x20(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x20(%rsp)
jmp 0x340dc
addq $0x38, %rsp
retq
nopl (%rax)
// File: ATOMIC-LICHESS[P]ATOMKRAFT/movepick.cpp
// Function: MovePicker::score_evasions()
void MovePicker::score_evasions() {
  // Try good captures ordered by MVV/LVA, then non-captures if
  // destination square is not under attack, ordered by history
  // value, and at the end bad-captures and non-captures with a
  // negative SEE. This last group is ordered by the SEE score.
  Move m;
  int seeScore;

  // Skip if we don't have at least two moves to order
  if (lastMove < moves + 2)
      return;

  for (MoveStack* cur = moves; cur != lastMove; cur++)
  {
      m = cur->move;
      if ((seeScore = pos.see_sign(m)) < 0)
          cur->score = seeScore - History::MaxValue; // Be sure we are at the bottom
      else if (pos.move_is_capture(m))
          cur->score =  pos.midgame_value_of_piece_on(move_to(m))
                      - pos.type_of_piece_on(move_from(m)) + History::MaxValue;
      else
          cur->score = H.value(pos.piece_on(move_from(m)), move_to(m));
  }
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rcx
movq %rcx, 0x38(%rsp)
movq 0x50(%rcx), %rax
addq $0x68, %rcx
addq $0x10, %rcx
cmpq %rcx, %rax
jae 0x34189
jmp 0x342d4
movq 0x38(%rsp), %rax
addq $0x68, %rax
movq %rax, 0x40(%rsp)
movq 0x38(%rsp), %rcx
movq 0x40(%rsp), %rax
cmpq 0x50(%rcx), %rax
je 0x342d4
movq 0x38(%rsp), %rax
movq 0x40(%rsp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x4c(%rsp)
movq (%rax), %rdi
movl 0x4c(%rsp), %esi
callq 0x3d470
movl %eax, 0x48(%rsp)
cmpl $0x0, %eax
jge 0x341e7
movl 0x48(%rsp), %ecx
subl $0x7d0, %ecx            # imm = 0x7D0
movq 0x40(%rsp), %rax
movl %ecx, 0x4(%rax)
jmp 0x342bf
movq 0x38(%rsp), %rax
movq (%rax), %rdi
movl 0x4c(%rsp), %esi
callq 0x2e590
testb $0x1, %al
jne 0x341fe
jmp 0x3426b
movq 0x38(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x20(%rsp)
movl 0x4c(%rsp), %edi
callq 0xf690
movq 0x20(%rsp), %rdi
movl %eax, %esi
callq 0x347f0
movl %eax, %ecx
movq 0x38(%rsp), %rax
movl %ecx, 0x34(%rsp)
movq (%rax), %rax
movq %rax, 0x28(%rsp)
movl 0x4c(%rsp), %edi
callq 0xf680
movq 0x28(%rsp), %rdi
movl %eax, %esi
callq 0x11f10
movl 0x34(%rsp), %edi
movl %eax, %esi
callq 0x29ca0
movl %eax, %edi
movl $0x7d0, %esi            # imm = 0x7D0
callq 0x1b320
movl %eax, %ecx
movq 0x40(%rsp), %rax
movl %ecx, 0x4(%rax)
jmp 0x342bd
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movl 0x4c(%rsp), %edi
callq 0xf680
movq 0x8(%rsp), %rdi
movl %eax, %esi
callq 0xf530
movl %eax, 0x1c(%rsp)
movl 0x4c(%rsp), %edi
callq 0xf690
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %esi
movl %eax, %edx
callq 0x34820
movl %eax, %ecx
movq 0x40(%rsp), %rax
movl %ecx, 0x4(%rax)
jmp 0x342bf
jmp 0x342c1
movq 0x40(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x40(%rsp)
jmp 0x34197
addq $0x58, %rsp
retq
nopl (%rax)