LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: bjohnsonfl[P]Overhead-Chess-Engine-/moveGen.cpp
// Function: generateCapture(position const&, candidate*)
candidate* generateCapture(const position& pos, candidate* moveList)
{
    
    player us = pos.get_sideToPlay();
    player them = player(!us);
    bitboard captures = pos.get_pieces(them);
    bitboard pawnCaptures = us == white ? captures & clearRank[rank_8] : captures & clearRank[rank_1];
    
    moveList = kingMoves(pos, captures, moveList);
    moveList = knightMoves(pos.get_pieces(us, p_knight), captures, moveList);
    moveList = pawnAttackMoves(pos.get_pieces(us, p_pawn), us, pawnCaptures , moveList);
    moveList = sliderMoves(pos, captures, moveList);
    
    
    
    return moveList;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x75c0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x7600
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x5c58
movq -0x20(%rbp), %rax
leaq 0xd912(%rip), %rcx      # 0x13560
andq 0x38(%rcx), %rax
movq %rax, -0x30(%rbp)
jmp 0x5c6a
movq -0x20(%rbp), %rax
leaq 0xd8fd(%rip), %rcx      # 0x13560
andq (%rcx), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x6c70
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
movl $0x1, %edx
callq 0x76b0
movq %rax, %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x6d80
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
xorl %edx, %edx
callq 0x76b0
movq %rax, %rdi
movl -0x14(%rbp), %esi
movq -0x28(%rbp), %rdx
movq -0x10(%rbp), %rcx
callq 0x6e40
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x6820
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: bjohnsonfl[P]Overhead-Chess-Engine-/moveGen.cpp
// Function: generateLegal(position const&, candidate*, moveType)
candidate* generateLegal (const position& pos, candidate* moveList, moveType T)
{
    moveList = T == quiet   ? generate <quiet>   (pos, moveList):
    T == capture ? generate <capture> (pos, moveList):
    generate <evasion> (pos, moveList);
    
    
    return moveList;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x613c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5aa0
movq %rax, -0x20(%rbp)
jmp 0x616e
cmpl $0x1, -0x14(%rbp)
jne 0x6155
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5bd0
movq %rax, -0x28(%rbp)
jmp 0x6166
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5cf0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: bjohnsonfl[P]Overhead-Chess-Engine-/moveGen.cpp
// Function: generateNonEvasions(position const&, candidate*)
candidate* generateNonEvasions(const position& pos, candidate* moveList)
{
    moveList = generateCapture(pos, moveList);
    moveList = generatePromotions(pos, moveList);
    moveList = generateQuiet(pos, moveList);
    if(pos.get_castlingRights(pos.get_sideToPlay()))moveList = generateCastling(pos, moveList);
    if(pos.get_enPassent() != empty) moveList = generateEnPassent(pos, moveList);

return moveList;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5c00
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6220
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5ad0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x75c0
movq -0x18(%rbp), %rdi
movl %eax, %esi
callq 0x7570
cmpl $0x0, %eax
je 0x61f5
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6340
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x75e0
cmpl $0x40, %eax
je 0x6214
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x65b0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: bjohnsonfl[P]Overhead-Chess-Engine-/moveGen.cpp
// Function: generatePromotions(position const&, candidate*)
candidate* generatePromotions(const position& pos, candidate* moveList){
 
    
    player us = pos.get_sideToPlay();
    player them = player(!us);
    bitboard quiets = ~(pos.get_pieces());
    bitboard captures = pos.get_pieces(them);
    bitboard rank7Sq = us == white ? rankBitMask[rank_7] : rankBitMask[rank_2];
    bitboard rank8Sq = us == white ? rankBitMask[rank_8] : rankBitMask[rank_1];
    
    moveList = pawnPushMoves(pos, pos.get_pieces(us, p_pawn) & rank7Sq, us, quiets & rank8Sq, moveList);
    
    moveList = pawnAttackMoves(pos.get_pieces(us, p_pawn) & rank7Sq, us, captures & rank8Sq, moveList);
    
    return moveList;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x75c0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7690
xorq $-0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x7600
movq %rax, -0x28(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x6285
leaq 0xce65(%rip), %rax      # 0x130e0
movq 0x30(%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0x6294
leaq 0xce54(%rip), %rax      # 0x130e0
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x62b3
leaq 0xce37(%rip), %rax      # 0x130e0
movq 0x38(%rax), %rax
movq %rax, -0x48(%rbp)
jmp 0x62c1
leaq 0xce26(%rip), %rax      # 0x130e0
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
xorl %edx, %edx
callq 0x76b0
movq -0x50(%rbp), %rdi
movq %rax, %rsi
andq -0x30(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
andq -0x38(%rbp), %rcx
movq -0x10(%rbp), %r8
callq 0x6a80
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
xorl %edx, %edx
callq 0x76b0
movq %rax, %rdi
andq -0x30(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x28(%rbp), %rdx
andq -0x38(%rbp), %rdx
movq -0x10(%rbp), %rcx
callq 0x6e40
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: bjohnsonfl[P]Overhead-Chess-Engine-/moveGen.cpp
// Function: generateAllLegal(position const&, candidate*)
candidate* generateAllLegal (const position& pos, candidate* moveList)
{
   
    if(pos.get_pieces(player(!(pos.get_sideToPlay()))) & pos.squareAttackedBy(pos.get_king_sq(pos.get_sideToPlay()))) {
       //std::cout <<"inside evasion\n";
       // printBitboard(pos.get_pieces(player(!(pos.get_sideToPlay())))&pos.squareAttackedBy(pos.get_king_sq(pos.get_sideToPlay())));
       // pos.printBoard();
        
        return generateEvasion(pos, moveList);
    }
    else{
       //  std::cout <<"inside else\n";
    
    moveList = generateCapture(pos, moveList);
    moveList = generatePromotions(pos, moveList);
    moveList = generateQuiet(pos, moveList);
    if(pos.get_castlingRights(pos.get_sideToPlay()))moveList = generateCastling(pos, moveList);
    if(pos.get_enPassent() != empty) moveList = generateEnPassent(pos, moveList);
    }
   
    
    return moveList;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x75c0
movq -0x38(%rbp), %rdi
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %esi
callq 0x7600
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x75c0
movq -0x30(%rbp), %rdi
movl %eax, %esi
callq 0x7640
movq -0x28(%rbp), %rdi
movl %eax, %esi
callq 0x98b0
movq %rax, %rcx
movq -0x20(%rbp), %rax
andq %rcx, %rax
cmpq $0x0, %rax
je 0x6780
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5d20
movq %rax, -0x8(%rbp)
jmp 0x680e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5c00
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6220
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5ad0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x75c0
movq -0x40(%rbp), %rdi
movl %eax, %esi
callq 0x7570
cmpl $0x0, %eax
je 0x67e5
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6340
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x75e0
cmpl $0x40, %eax
je 0x6804
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x65b0
movq %rax, -0x18(%rbp)
jmp 0x6806
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: bjohnsonfl[P]Overhead-Chess-Engine-/moveGen.cpp
// Function: kingMoves(position const&, unsigned long, candidate*)
candidate* kingMoves (const position& pos, bitboard target, candidate* moveList){
    
    bitboard squares = 0, enemyKing, king;
    square from = empty, to = empty;
    move mov  = none;
    player color = pos.get_sideToPlay();
    king = pos.get_king(color);
    
   
    from = lsb_sq(king);
    squares = openBoardAttacks[p_king][from];
    enemyKing = openBoardAttacks[p_king][pos.get_king_sq(player(!color))];
    squares = squares ^( squares & enemyKing );
    squares &= target;
    
    
    while(squares)
    {
        //could check here if the to square places their king in check
        to  = lsb_sq(squares);
        mov = make_move(from, to);
        (*moveList++).mv = mov;
        
        pop_lsb(&squares);
    }

    return moveList;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x40, -0x34(%rbp)
movl $0x40, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movq -0x8(%rbp), %rdi
callq 0x75c0
movl %eax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movl -0x40(%rbp), %esi
callq 0x77f0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x7780
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, %ecx
leaq 0xc8cb(%rip), %rax      # 0x135a0
movq 0xa00(%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
cmpl $0x0, -0x40(%rbp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %esi
callq 0x7640
movl %eax, %eax
movl %eax, %ecx
leaq 0xc89d(%rip), %rax      # 0x135a0
movq 0xa00(%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq -0x20(%rbp), %rcx
andq -0x28(%rbp), %rcx
xorq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
andq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x6d6e
movq -0x20(%rbp), %rdi
callq 0x7780
movl %eax, -0x38(%rbp)
movl -0x34(%rbp), %edi
movl -0x38(%rbp), %esi
callq 0x77d0
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %ecx
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, -0x18(%rbp)
movl %ecx, (%rax)
leaq -0x20(%rbp), %rdi
callq 0x77a0
jmp 0x6d2e
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: bjohnsonfl[P]Overhead-Chess-Engine-/moveGen.cpp
// Function: knightMoves(unsigned long, unsigned long, candidate*)
candidate* knightMoves (bitboard knights,bitboard target, candidate* moveList)
{
    bitboard squares = 0;
    square from = empty, to = empty;
    move mov = none;
    while(knights)
    {
        from =lsb_sq(knights);
        //check now if the from square is absolute pinned
        squares = target & openBoardAttacks[p_knight][from];
        
        while(squares)
        {
            //could check here if the to square places their king in check
            to  = lsb_sq(squares);
            mov = make_move(from, to);
            (*moveList++).mv = mov;
            
            pop_lsb(&squares);
        }
        pop_lsb(&knights);
    }
    return moveList;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x40, -0x24(%rbp)
movl $0x40, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x6e2b
movq -0x8(%rbp), %rdi
callq 0x7780
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movl -0x24(%rbp), %ecx
movl %ecx, %edx
leaq 0xc7cc(%rip), %rcx      # 0x135a0
andq 0x200(%rcx,%rdx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x6e20
movq -0x20(%rbp), %rdi
callq 0x7780
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %edi
movl -0x28(%rbp), %esi
callq 0x77d0
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %ecx
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, -0x18(%rbp)
movl %ecx, (%rax)
leaq -0x20(%rbp), %rdi
callq 0x77a0
jmp 0x6de0
leaq -0x8(%rbp), %rdi
callq 0x77a0
jmp 0x6db1
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: bjohnsonfl[P]Overhead-Chess-Engine-/moveGen.cpp
// Function: pawnAttackMoves(unsigned long, player, unsigned long, candidate*)
candidate* pawnAttackMoves (bitboard pawns, player color ,bitboard target, candidate* moveList){
    
    bitboard squares = 0;
    square from = empty, to = empty;
    move mov = none;
    bitboard rank8Sq = color == white ? rankBitMask[rank_8] : rankBitMask[rank_1];
    
    while(pawns)
    {
        from = lsb_sq(pawns);
        //check now if the from square is absolute pinned
        squares = target & openBoardPawnAttacks[color][from];
        while(squares)
        {
            //could check here if the to square places their king in check
            to  = lsb_sq(squares);
            
            if (squareBitMask[to]  & rank8Sq) {
               moveList = makePromotionMoves(from, to, moveList);
            }
            else{
                mov = make_move(from, to);
                (*moveList++).mv = mov;
            }
            pop_lsb(&squares);
        }
        pop_lsb(&pawns);
        
    }
    
    return moveList;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movl $0x40, -0x2c(%rbp)
movl $0x40, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x6e8b
leaq 0xc25f(%rip), %rax      # 0x130e0
movq 0x38(%rax), %rax
movq %rax, -0x48(%rbp)
jmp 0x6e99
leaq 0xc24e(%rip), %rax      # 0x130e0
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x6f57
movq -0x8(%rbp), %rdi
callq 0x7780
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, %edx
leaq 0xd2d8(%rip), %rcx      # 0x141a0
shlq $0x9, %rdx
addq %rdx, %rcx
movl -0x2c(%rbp), %edx
andq (%rcx,%rdx,8), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x6f49
movq -0x28(%rbp), %rdi
callq 0x7780
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
movl %eax, %ecx
leaq 0xbfa7(%rip), %rax      # 0x12ea0
movq (%rax,%rcx,8), %rax
andq -0x40(%rbp), %rax
cmpq $0x0, %rax
je 0x6f1c
movl -0x2c(%rbp), %edi
movl -0x30(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x6f70
movq %rax, -0x20(%rbp)
jmp 0x6f3e
movl -0x2c(%rbp), %edi
movl -0x30(%rbp), %esi
callq 0x77d0
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %ecx
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, -0x20(%rbp)
movl %ecx, (%rax)
leaq -0x28(%rbp), %rdi
callq 0x77a0
jmp 0x6eda
leaq -0x8(%rbp), %rdi
callq 0x77a0
jmp 0x6ea1
movq -0x20(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: bjohnsonfl[P]Overhead-Chess-Engine-/position.cpp
// Function: position::reset()
void position::reset(){
   
    state = new returnState();
    
    //reset return state, its ok to do it twice at start up, this is for reset by gui
    state ->captured = not_piece;
    state -> m = none;
    state -> prev = NULL;
    
    
    //these could be overwritten by the fen called in setboard
    ply = 0;
    sideToPlay = white;
    nodes = 0;
    
    //all pieces and square realted things should be handdled in setboard()
    setboard();
    update_material(state);
    update_check_boards(state);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x48, %edi
callq 0x31f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x20(%rbp)
callq 0x9f10
jmp 0x792f
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, 0x188(%rdi)
movq 0x188(%rdi), %rax
movl $0xc, 0xc(%rax)
movq 0x188(%rdi), %rax
movl $0x0, 0x10(%rax)
movq 0x188(%rdi), %rax
movq $0x0, 0x18(%rax)
movl $0x0, 0x178(%rdi)
movl $0x0, 0x17c(%rdi)
movq $0x0, 0x180(%rdi)
callq 0x84e0
movq -0x28(%rbp), %rdi
movq 0x188(%rdi), %rsi
callq 0x8360
movq -0x28(%rbp), %rdi
movq 0x188(%rdi), %rsi
callq 0x8460
addq $0x30, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl $0x48, %esi
callq 0x3200
movq -0x10(%rbp), %rdi
callq 0x3390
nopw %cs:(%rax,%rax)
// File: bjohnsonfl[P]Overhead-Chess-Engine-/position.cpp
// Function: position::updatePositionFen(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void position::updatePositionFen(std::string fen)
{
    returnState *newState = new returnState();
    newState ->prev = state;
    state = newState;
    
    
    //Code ripped from the setboard function below.
    for(square sq =a1; sq < numOfSq; sq++)
    {
        board[sq] = not_piece;
    }
    
    for(piece p = w_pawn; p<numOfPieces ; p++ )
    {
        pieces[p] = 0ULL;
    }
    allWhitePieces = 0ULL;
    allBlackPieces = 0ULL;
    allPieces = allWhitePieces | allBlackPieces;
    
    nodes = 0;
    
    fenParser(fen);
    update_material(state);
    update_check_boards(state);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x48, %edi
callq 0x31f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
callq 0x9f10
jmp 0x7a17
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movq 0x188(%rax), %rdx
movq -0x18(%rbp), %rcx
movq %rdx, 0x18(%rcx)
movq -0x18(%rbp), %rcx
movq %rcx, 0x188(%rax)
movl $0x0, -0x28(%rbp)
cmpl $0x40, -0x28(%rbp)
jge 0x7a84
movq -0x40(%rbp), %rax
movl -0x28(%rbp), %ecx
movl $0xc, (%rax,%rcx,4)
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x5a80
jmp 0x7a44
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x48, %esi
callq 0x3200
jmp 0x7b1a
movl $0x0, -0x2c(%rbp)
cmpl $0xc, -0x2c(%rbp)
jge 0x7ab1
movq -0x40(%rbp), %rax
movl -0x2c(%rbp), %ecx
movq $0x0, 0x100(%rax,%rcx,8)
leaq -0x2c(%rbp), %rdi
xorl %esi, %esi
callq 0x9f80
jmp 0x7a8b
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq $0x0, 0x160(%rdi)
movq $0x0, 0x168(%rdi)
movq 0x160(%rdi), %rax
orq 0x168(%rdi), %rax
movq %rax, 0x170(%rdi)
movq $0x0, 0x180(%rdi)
callq 0x7b30
movq -0x40(%rbp), %rdi
movq 0x188(%rdi), %rsi
callq 0x8360
movq -0x40(%rbp), %rdi
movq 0x188(%rdi), %rsi
callq 0x8460
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x3390
nopw %cs:(%rax,%rax)
// File: bjohnsonfl[P]Overhead-Chess-Engine-/position.cpp
// Function: position::update_material(returnState*)
void position::update_material(returnState *state)
{
    bitboard pieces = 0;
   //white
    //have to increment pt+1 due to indexing
    for( piece pt = w_pawn ; pt < w_king; pt++)
    {
        pieces = get_pieces(pt);
        state -> material[white]  = state -> material[white] +(popcount(pieces) * pieceValue[pt+1]);
    }
    //black
    for( piece pt = b_pawn ; pt < b_king; pt++)
    {
        pieces = get_pieces(pt);
        state -> material[black]  =  state -> material[black] + (popcount(pieces) * pieceValue[pt-5]);
    }
    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x5, -0x1c(%rbp)
jge 0x83ea
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0xa140
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x40(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3fa0
movl %eax, %edi
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rcx
leaq 0x9e5e(%rip), %rax      # 0x12220
movl (%rax,%rcx,4), %esi
callq 0xa160
movl -0x2c(%rbp), %edi
movl %eax, %esi
callq 0xa0f0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x40(%rax)
leaq -0x1c(%rbp), %rdi
xorl %esi, %esi
callq 0x9f80
jmp 0x8387
movl $0x6, -0x20(%rbp)
cmpl $0xb, -0x20(%rbp)
jge 0x8454
movq -0x28(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0xa140
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x44(%rax), %eax
movl %eax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3fa0
movl %eax, %edi
movl -0x20(%rbp), %eax
subl $0x5, %eax
movslq %eax, %rcx
leaq 0x9df4(%rip), %rax      # 0x12220
movl (%rax,%rcx,4), %esi
callq 0xa160
movl -0x30(%rbp), %edi
movl %eax, %esi
callq 0xa0f0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x44(%rax)
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x9f80
jmp 0x83f1
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: bjohnsonfl[P]Overhead-Chess-Engine-/position.cpp
// Function: position::place_piece(square, piece)
void position::place_piece(square sq, piece pt)
{
    //do not erase data by placing empty pieces. that is reserved for remove_piece
    player color = neither;
    if(pt != not_piece){
        board[sq] = pt;
        pieces[pt] = pieces[pt] | squareBitMask[sq];
        pt < 6 ? color = white : color = black;
        color == white ? allWhitePieces |= squareBitMask[sq] : allBlackPieces |= squareBitMask[sq];
        allPieces = allWhitePieces | allBlackPieces;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x2, -0x14(%rbp)
cmpl $0xc, -0x10(%rbp)
je 0x86e9
movq -0x20(%rbp), %rax
movl -0x10(%rbp), %edx
movl -0xc(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
movl -0x10(%rbp), %ecx
movq 0x100(%rax,%rcx,8), %rdx
movl -0xc(%rbp), %ecx
movl %ecx, %esi
leaq 0xa855(%rip), %rcx      # 0x12ea0
orq (%rcx,%rsi,8), %rdx
movl -0x10(%rbp), %ecx
movq %rdx, 0x100(%rax,%rcx,8)
cmpl $0x6, -0x10(%rbp)
jge 0x8669
movl $0x0, -0x14(%rbp)
jmp 0x8670
movl $0x1, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x86a4
movq -0x20(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, %edx
leaq 0xa81a(%rip), %rcx      # 0x12ea0
movq (%rcx,%rdx,8), %rcx
movq %rax, %rdx
addq $0x160, %rdx            # imm = 0x160
orq 0x160(%rax), %rcx
movq %rcx, 0x160(%rax)
jmp 0x86d0
movq -0x20(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, %edx
leaq 0xa7ec(%rip), %rcx      # 0x12ea0
movq (%rcx,%rdx,8), %rcx
movq %rax, %rdx
addq $0x168, %rdx            # imm = 0x168
orq 0x168(%rax), %rcx
movq %rcx, 0x168(%rax)
movq -0x20(%rbp), %rax
movq 0x160(%rax), %rcx
orq 0x168(%rax), %rcx
movq %rcx, 0x170(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: bjohnsonfl[P]Overhead-Chess-Engine-/position.cpp
// Function: position::printBoard() const
void position::printBoard() const{
    std::cout <<"Current Board: \n";
    std::cout << "---------------\n";
    for(rank r = rank_8; r>=0; r--)
    {
        for(file f = file_a; f<numOfFile; f++)
        {
            std::cout<< pieceChar [ board[rankFile_to_sq(r, f)] ] << " ";
        }
        std::cout <<"\n";
    }
    std::cout << "---------------\n";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x8e8d(%rip), %rdi      # 0x11fc8
leaq 0x52bb(%rip), %rsi      # 0xe3fd
callq 0x31e0
movq 0x8e7a(%rip), %rdi      # 0x11fc8
leaq 0x4ee7(%rip), %rsi      # 0xe03c
callq 0x31e0
movl $0x7, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x91e6
movl $0x0, -0x10(%rbp)
cmpl $0x8, -0x10(%rbp)
jge 0x91c3
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
callq 0x5a00
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, %ecx
movl (%rax,%rcx,4), %eax
movl %eax, %esi
leaq 0xee43d(%rip), %rdi     # 0xf75d0
callq 0x3250
movq 0x8e29(%rip), %rdi      # 0x11fc8
movsbl (%rax), %esi
callq 0x3270
movq %rax, %rdi
leaq 0x5446(%rip), %rsi      # 0xe5f7
callq 0x31e0
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x5a20
jmp 0x916e
movq 0x8dfe(%rip), %rdi      # 0x11fc8
leaq 0x51f4(%rip), %rsi      # 0xe3c5
callq 0x31e0
leaq -0xc(%rbp), %rdi
xorl %esi, %esi
callq 0x5a60
jmp 0x9161
movq 0x8ddb(%rip), %rdi      # 0x11fc8
leaq 0x4e48(%rip), %rsi      # 0xe03c
callq 0x31e0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: bjohnsonfl[P]Overhead-Chess-Engine-/position.cpp
// Function: position::remove_piece(square, piece)
void position::remove_piece(square sq, piece pt)
{
        
    player color = neither;
    if(pt != not_piece){
        board[sq] = not_piece;
        pieces[pt] = pieces[pt] ^ squareBitMask[sq];
        pt < 6 ? color = white : color = black;
        color == white ? allWhitePieces ^= squareBitMask[sq] : allBlackPieces ^= squareBitMask[sq];
        allPieces = allWhitePieces | allBlackPieces;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x2, -0x14(%rbp)
cmpl $0xc, -0x10(%rbp)
je 0x92ea
movq -0x20(%rbp), %rax
movl -0xc(%rbp), %ecx
movl $0xc, (%rax,%rcx,4)
movl -0x10(%rbp), %ecx
movq 0x100(%rax,%rcx,8), %rdx
movl -0xc(%rbp), %ecx
movl %ecx, %esi
leaq 0x9c54(%rip), %rcx      # 0x12ea0
xorq (%rcx,%rsi,8), %rdx
movl -0x10(%rbp), %ecx
movq %rdx, 0x100(%rax,%rcx,8)
cmpl $0x6, -0x10(%rbp)
jge 0x926a
movl $0x0, -0x14(%rbp)
jmp 0x9271
movl $0x1, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x92a5
movq -0x20(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, %edx
leaq 0x9c19(%rip), %rcx      # 0x12ea0
movq (%rcx,%rdx,8), %rcx
movq %rax, %rdx
addq $0x160, %rdx            # imm = 0x160
xorq 0x160(%rax), %rcx
movq %rcx, 0x160(%rax)
jmp 0x92d1
movq -0x20(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, %edx
leaq 0x9beb(%rip), %rcx      # 0x12ea0
movq (%rcx,%rdx,8), %rcx
movq %rax, %rdx
addq $0x168, %rdx            # imm = 0x168
xorq 0x168(%rax), %rcx
movq %rcx, 0x168(%rax)
movq -0x20(%rbp), %rax
movq 0x160(%rax), %rcx
orq 0x168(%rax), %rcx
movq %rcx, 0x170(%rax)
popq %rbp
retq
nopl (%rax)
// File: bjohnsonfl[P]Overhead-Chess-Engine-/position.cpp
// Function: position::squareAttackedBy(square) const
bitboard position::squareAttackedBy (square sq) const
{
    
  //  printBitboard((attacksFromPawn(sq, black)      & get_pieces(white, p_pawn)));
   // printBitboard((attacksFromPawn(sq, white)    & get_pieces(black, p_pawn)));
    // printBitboard((attacksFrom (sq, p_knight)         & get_pieces(p_knight)));
  //   printBitboard((attacksFrom (sq, p_king)           & get_pieces(p_king)));
 //    printBitboard((attacksFrom (sq, p_rook) & get_pieces(  p_rook, p_queen)));
  //   printBitboard((attacksFrom (sq, p_bishop) & get_pieces(p_bishop, p_queen)));
    bitboard attacks =    (attacksFromPawn(sq, black)      & get_pieces(white, p_pawn))
                        | (attacksFromPawn(sq, white)    & get_pieces(black, p_pawn))
                        | (attacksFrom (sq, p_knight)         & get_pieces(p_knight))
                        | (attacksFrom (sq, p_king)           & get_pieces(p_king))
                        | (attacksFrom (sq, p_rook) & get_pieces(  p_rook, p_queen))
                        | (attacksFrom (sq, p_bishop) & get_pieces(p_bishop, p_queen));
    return attacks;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movl -0xc(%rbp), %esi
movl $0x1, %edx
callq 0xa110
movq -0x30(%rbp), %rdi
movq %rax, -0x78(%rbp)
xorl %edx, %edx
movl %edx, %esi
callq 0x76b0
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movq -0x78(%rbp), %rax
andq %rcx, %rax
movq %rax, -0x68(%rbp)
movl -0xc(%rbp), %esi
xorl %edx, %edx
callq 0xa110
movq -0x30(%rbp), %rdi
movq %rax, -0x70(%rbp)
movl $0x1, %esi
xorl %edx, %edx
callq 0x76b0
movq -0x70(%rbp), %rcx
movq -0x30(%rbp), %rdi
movq %rax, %rdx
movq -0x68(%rbp), %rax
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, -0x58(%rbp)
movl -0xc(%rbp), %esi
movl $0x1, %edx
callq 0xa180
movq -0x30(%rbp), %rdi
movq %rax, -0x60(%rbp)
movl $0x1, %esi
callq 0x7750
movq -0x60(%rbp), %rcx
movq -0x30(%rbp), %rdi
movq %rax, %rdx
movq -0x58(%rbp), %rax
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, -0x48(%rbp)
movl -0xc(%rbp), %esi
movl $0x5, %edx
callq 0xa180
movq -0x30(%rbp), %rdi
movq %rax, -0x50(%rbp)
movl $0x5, %esi
callq 0x7750
movq -0x50(%rbp), %rcx
movq -0x30(%rbp), %rdi
movq %rax, %rdx
movq -0x48(%rbp), %rax
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, -0x38(%rbp)
movl -0xc(%rbp), %esi
movl $0x3, %edx
callq 0xa180
movq -0x30(%rbp), %rdi
movq %rax, -0x40(%rbp)
movl $0x3, %esi
movl $0x4, %edx
callq 0x7700
movq -0x40(%rbp), %rcx
movq -0x30(%rbp), %rdi
movq %rax, %rdx
movq -0x38(%rbp), %rax
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %esi
movl $0x2, %edx
callq 0xa180
movq -0x30(%rbp), %rdi
movq %rax, -0x28(%rbp)
movl $0x2, %esi
movl $0x4, %edx
callq 0x7700
movq -0x28(%rbp), %rcx
movq %rax, %rdx
movq -0x20(%rbp), %rax
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: bjohnsonfl[P]Overhead-Chess-Engine-/position.cpp
// Function: position::printAllBitboards() const
void position::printAllBitboards() const{
    
   
    for(piece p = w_pawn; p<numOfPieces; p++)
    {
        std::cout <<  "Piece: " << pieceChar[p] << "\n";
        printBitboard(pieces[p]);
        std::cout <<  "\n\n\n";
    }
    
    std::cout <<  "all White Pieces: \n";
    printBitboard(allWhitePieces);
    std::cout <<  "\n\n\n";
    
    std::cout <<  "all Black Pieces: \n";
    printBitboard(allBlackPieces);
    std::cout <<  "\n\n\n";
    
    std::cout <<  "ALL Pieces: \n";
    printBitboard(allPieces);
    std::cout <<  "\n\n\n";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0xc, -0xc(%rbp)
jge 0x9e68
movq 0x81d0(%rip), %rdi      # 0x11fc8
leaq 0x45bc(%rip), %rsi      # 0xe3bb
callq 0x31e0
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
movl %eax, %esi
leaq 0xed7bc(%rip), %rdi     # 0xf75d0
callq 0x3250
movq -0x20(%rbp), %rdi
movsbl (%rax), %esi
callq 0x3270
movq %rax, %rdi
leaq 0x4596(%rip), %rsi      # 0xe3c5
callq 0x31e0
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
movq 0x100(%rax,%rcx,8), %rdi
callq 0x58f0
movq 0x8179(%rip), %rdi      # 0x11fc8
leaq 0x456d(%rip), %rsi      # 0xe3c3
callq 0x31e0
leaq -0xc(%rbp), %rdi
xorl %esi, %esi
callq 0x9f80
jmp 0x9deb
movq 0x8159(%rip), %rdi      # 0x11fc8
leaq 0x4551(%rip), %rsi      # 0xe3c7
callq 0x31e0
movq -0x18(%rbp), %rax
movq 0x160(%rax), %rdi
callq 0x58f0
movq 0x8136(%rip), %rdi      # 0x11fc8
leaq 0x452a(%rip), %rsi      # 0xe3c3
callq 0x31e0
movq 0x8123(%rip), %rdi      # 0x11fc8
leaq 0x452f(%rip), %rsi      # 0xe3db
callq 0x31e0
movq -0x18(%rbp), %rax
movq 0x168(%rax), %rdi
callq 0x58f0
movq 0x8100(%rip), %rdi      # 0x11fc8
leaq 0x44f4(%rip), %rsi      # 0xe3c3
callq 0x31e0
movq 0x80ed(%rip), %rdi      # 0x11fc8
leaq 0x450d(%rip), %rsi      # 0xe3ef
callq 0x31e0
movq -0x18(%rbp), %rax
movq 0x170(%rax), %rdi
callq 0x58f0
movq 0x80ca(%rip), %rdi      # 0x11fc8
leaq 0x44be(%rip), %rsi      # 0xe3c3
callq 0x31e0
addq $0x20, %rsp
popq %rbp
retq
// File: bjohnsonfl[P]Overhead-Chess-Engine-/./position.hpp
// Function: returnState::returnState()
returnState () {
        castling = noRights;  //Always take from the fen
        enPassent = empty;
        fiftyMove = 0;
        captured = not_piece;
        m = none;
        prev = NULL;
        absolutePinned[white] = 0;
        absolutePinned[black] = 0;
        pinners[white] = 0;
        pinners[black] = 0;
        material[white] = draw;
        material [black] = draw;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
movl $0x40, 0x4(%rax)
movl $0x0, (%rax)
movl $0xc, 0xc(%rax)
movl $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
movq $0x0, 0x20(%rax)
movq $0x0, 0x28(%rax)
movq $0x0, 0x30(%rax)
movq $0x0, 0x38(%rax)
movl $0x0, 0x40(%rax)
movl $0x0, 0x44(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: bjohnsonfl[P]Overhead-Chess-Engine-/./position.hpp
// Function: position::attacksFrom(square, pieceType) const
inline bitboard position::attacksFrom (square sq, pieceType pt) const {
    
    bitboard attacks =  pt == p_pawn ? attacksFromPawn(sq, sideToPlay) :
    pt == p_rook ? sliderAttacks(sq, allPieces, p_rook) :
    pt == p_bishop ? sliderAttacks(sq, allPieces, p_bishop) :
    pt == p_queen ? sliderAttacks(sq, allPieces, p_rook) | sliderAttacks(sq, allPieces, p_bishop) :        openBoardAttacks[pt][sq];
    
    return attacks;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x10(%rbp)
jne 0xa1bb
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %esi
movl 0x17c(%rdi), %edx
callq 0xa110
movq %rax, -0x28(%rbp)
jmp 0xa289
cmpl $0x3, -0x10(%rbp)
jne 0xa1e2
movq -0x20(%rbp), %rax
movl -0xc(%rbp), %edi
movq 0x170(%rax), %rsi
movl $0x3, %edx
callq 0x57b0
movq %rax, -0x30(%rbp)
jmp 0xa281
cmpl $0x2, -0x10(%rbp)
jne 0xa206
movq -0x20(%rbp), %rax
movl -0xc(%rbp), %edi
movq 0x170(%rax), %rsi
movl $0x2, %edx
callq 0x57b0
movq %rax, -0x38(%rbp)
jmp 0xa279
cmpl $0x4, -0x10(%rbp)
jne 0xa253
movq -0x20(%rbp), %rax
movl -0xc(%rbp), %edi
movq 0x170(%rax), %rsi
movl $0x3, %edx
callq 0x57b0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, -0x48(%rbp)
movl -0xc(%rbp), %edi
movq 0x170(%rax), %rsi
movl $0x2, %edx
callq 0x57b0
movq %rax, %rcx
movq -0x48(%rbp), %rax
orq %rcx, %rax
movq %rax, -0x40(%rbp)
jmp 0xa271
movl -0x10(%rbp), %eax
movl %eax, %ecx
leaq 0x9341(%rip), %rax      # 0x135a0
shlq $0x9, %rcx
addq %rcx, %rax
movl -0xc(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: bjohnsonfl[P]Overhead-Chess-Engine-/search.cpp
// Function: perftDivide(int, position&)
bitboard perftDivide (int depth, position& pos)
{
    
    candMoveList movs;
    
    movs.end = generateAllLegal(pos, movs.end);
    returnState state = returnState();
    bitboard nodes = 0;
    bitboard totalNodes =0;
    while( movs.start != movs.end)
    {
        if(pos.legal(movs.start -> mv))
        {
            pos.do_move(movs.start -> mv, state);
            nodes = perft(depth -1, pos);
            totalNodes += nodes;
         //   printmove(movs.start->mv);
          //  std::cout << "nodes: " << nodes << "\n\n";
            pos.undo_move(movs.start -> mv);
        }
        
        movs.start ++;
        
    }
    return totalNodes;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x880, %rsp            # imm = 0x880
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x820(%rbp), %rdi
callq 0xad00
movq -0x10(%rbp), %rdi
movq -0x820(%rbp), %rsi
callq 0x66f0
movq %rax, -0x820(%rbp)
leaq -0x868(%rbp), %rdi
callq 0x9f10
movq $0x0, -0x870(%rbp)
movq $0x0, -0x878(%rbp)
movq -0x818(%rbp), %rax
cmpq -0x820(%rbp), %rax
je 0xa920
movq -0x10(%rbp), %rdi
movq -0x818(%rbp), %rax
movl (%rax), %esi
callq 0x9b10
testb $0x1, %al
jne 0xa8b3
jmp 0xa909
movq -0x10(%rbp), %rdi
movq -0x818(%rbp), %rax
movl (%rax), %esi
leaq -0x868(%rbp), %rdx
callq 0x86f0
movl -0x4(%rbp), %edi
subl $0x1, %edi
movq -0x10(%rbp), %rsi
callq 0xa2d0
movq %rax, -0x870(%rbp)
movq -0x870(%rbp), %rax
addq -0x878(%rbp), %rax
movq %rax, -0x878(%rbp)
movq -0x10(%rbp), %rdi
movq -0x818(%rbp), %rax
movl (%rax), %esi
callq 0x92f0
movq -0x818(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x818(%rbp)
jmp 0xa887
movq -0x878(%rbp), %rax
addq $0x880, %rsp            # imm = 0x880
popq %rbp
retq
// File: bjohnsonfl[P]Overhead-Chess-Engine-/evaluate.cpp
// Function: evaluation::init()
void evaluation::init(){
   
    for(square sq = a1; sq < numOfSq; sq++)
    {
        oppSq[sq] = square(sq ^ (black * 56));
    }
    
    int totalMaterial = (8 * pawnVal) + (2 * knightVal) + (2 * bishopVal) +  (2 * rookVal) + queenVal;
    gamePhaseCutoff = 2 * totalMaterial - 2 * (rookVal * 2);
    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
cmpl $0x40, -0x4(%rbp)
jge 0xade7
movl -0x4(%rbp), %edx
xorl $0x38, %edx
movl -0x4(%rbp), %eax
movl %eax, %ecx
leaq 0xeccb9(%rip), %rax     # 0xf7a90
movl %edx, (%rax,%rcx,4)
leaq -0x4(%rbp), %rdi
xorl %esi, %esi
callq 0x5a80
jmp 0xadbf
movl $0x8, %edi
movl $0x64, %esi
callq 0xa160
movl %eax, -0x18(%rbp)
movl $0x2, %edi
movl $0x136, %esi            # imm = 0x136
callq 0xa160
movl -0x18(%rbp), %edi
movl %eax, %esi
callq 0xa0f0
movl %eax, -0x14(%rbp)
movl $0x2, %edi
movl $0x14a, %esi            # imm = 0x14A
callq 0xa160
movl -0x14(%rbp), %edi
movl %eax, %esi
callq 0xa0f0
movl %eax, -0x10(%rbp)
movl $0x2, %edi
movl $0x28a, %esi            # imm = 0x28A
callq 0xa160
movl -0x10(%rbp), %edi
movl %eax, %esi
callq 0xa0f0
movl %eax, %edi
movl $0x51e, %esi            # imm = 0x51E
callq 0xa0f0
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
shll %eax
movl %eax, -0xc(%rbp)
movl $0x28a, %edi            # imm = 0x28A
movl $0x2, %esi
callq 0xb2f0
movl %eax, %esi
movl $0x2, %edi
callq 0xa160
movl %eax, %ecx
movl -0xc(%rbp), %eax
subl %ecx, %eax
movl %eax, 0xecd07(%rip)     # 0xf7b90
addq $0x20, %rsp
popq %rbp
retq
nop
// File: bjohnsonfl[P]Overhead-Chess-Engine-/UCI.cpp
// Function: UCI::UCI()
UCI::UCI()
{
     wTime = 0;
     bTime = 0;
     wInc = 0;
     bInc = 0;
    
     depth = 0;
     moveTime = 0;
    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x18, %rdi
callq 0x78d0
movq -0x10(%rbp), %rdi
addq $0x1b0, %rdi            # imm = 0x1B0
callq 0x3370
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movl $0x0, 0x4(%rax)
movl $0x0, 0x8(%rax)
movl $0x0, 0xc(%rax)
movl $0x0, 0x10(%rax)
movl $0x0, 0x14(%rax)
addq $0x10, %rsp
popq %rbp
retq
// File: bjohnsonfl[P]Overhead-Chess-Engine-/UCI.cpp
// Function: UCI::moveCheck(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
move UCI::moveCheck(std::string str)
{
    candMoveList movs;
    movs.end = generateAllLegal(pos, movs.end);
    
    while(movs.start != movs.end)
    {
       // std::cout<< moveToString(movs.start -> mv) << "\n";
       // std::cout<<str << "\n";
        if(str == moveToString(movs.start -> mv))
        {
            return movs.start -> mv;
        }
        movs.start++;
    }
    
    return none;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x860, %rsp            # imm = 0x860
movq %rsi, -0x858(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x850(%rbp)
leaq -0x828(%rbp), %rdi
callq 0xad00
movq -0x850(%rbp), %rdi
addq $0x18, %rdi
movq -0x828(%rbp), %rsi
callq 0x66f0
movq %rax, -0x828(%rbp)
movq -0x820(%rbp), %rax
cmpq -0x828(%rbp), %rax
je 0xc8ce
movq -0x850(%rbp), %rsi
movq -0x820(%rbp), %rax
movl (%rax), %edx
leaq -0x848(%rbp), %rdi
callq 0xc8f0
movq -0x858(%rbp), %rdi
leaq -0x848(%rbp), %rsi
callq 0xceb0
movb %al, -0x859(%rbp)
leaq -0x848(%rbp), %rdi
callq 0x3408
movb -0x859(%rbp), %al
testb $0x1, %al
jne 0xc8ac
jmp 0xc8ba
movq -0x820(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0xc8d5
movq -0x820(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x820(%rbp)
jmp 0xc84f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x860, %rsp            # imm = 0x860
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH04_Expressions/examples/arith-ex.cc
// Function: main
int main()
{
	cout << -30 * 3 + 21 / 5 << endl;
	
	cout << -30 + 3 * 21 / 5 << endl;
	
	cout << 30 / 3 * 21 % 5 << endl;
	
	cout << 30 / 3 * 21 % 4 << endl;
	
	cout << -30 / 3 * 21 % 4 << endl;
	
	cout << 12 / 3 * 4 + 5 * 15 + 24 % 4 / 2 << endl;
	
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movq 0x2e12(%rip), %rdi      # 0x3fd8
movl $0xffffffaa, %esi       # imm = 0xFFFFFFAA
callq 0x1060
movq %rax, %rdi
movq 0x2dee(%rip), %rsi      # 0x3fc8
callq 0x1040
movq 0x2df2(%rip), %rdi      # 0x3fd8
movl $0xffffffee, %esi       # imm = 0xFFFFFFEE
callq 0x1060
movq %rax, %rdi
movq 0x2dce(%rip), %rsi      # 0x3fc8
callq 0x1040
movq 0x2dd2(%rip), %rdi      # 0x3fd8
xorl %esi, %esi
callq 0x1060
movq %rax, %rdi
movq 0x2db1(%rip), %rsi      # 0x3fc8
callq 0x1040
movq 0x2db5(%rip), %rdi      # 0x3fd8
movl $0x2, %esi
callq 0x1060
movq %rax, %rdi
movq 0x2d91(%rip), %rsi      # 0x3fc8
callq 0x1040
movq 0x2d95(%rip), %rdi      # 0x3fd8
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x1060
movq %rax, %rdi
movq 0x2d71(%rip), %rsi      # 0x3fc8
callq 0x1040
movq 0x2d75(%rip), %rdi      # 0x3fd8
movl $0x5b, %esi
callq 0x1060
movq %rax, %rdi
movq 0x2d51(%rip), %rsi      # 0x3fc8
callq 0x1040
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: ef-gy[P]libefgy/include/ef.gy/vector.h
// Function: std::basic_ostream<char, std::char_traits<char>>& efgy::math::operator<<<char, float, 2u, efgy::math::format::cartesian>(std::basic_ostream<char, std::char_traits<char>>&, efgy::math::vector<float, 2u, efgy::math::format::cartesian> const&)
std::basic_ostream<C> &operator<<(std::basic_ostream<C> &stream,
                                  const vector<F, n, format> &v) {
  stream << "(" << v.tag();
  for (unsigned int i = 0; i < n; i++) {
    stream << (i > 0 ? ", " : " ") << v[i];
  }
  return stream << ")";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x3089b(%rip), %rsi     # 0x69dd6
callq 0x5370
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3b270
movq -0x20(%rbp), %rdi
leaq -0x11(%rbp), %rsi
callq 0x3b240
movl $0x0, -0x18(%rbp)
cmpl $0x2, -0x18(%rbp)
jae 0x395b2
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %ecx
leaq 0x306d4(%rip), %rsi     # 0x69c49
leaq 0x3085c(%rip), %rax     # 0x69dd8
cmpl $0x0, %ecx
cmovaq %rax, %rsi
callq 0x5370
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0x3b280
movq -0x28(%rbp), %rdi
movss (%rax), %xmm0
callq 0x52d0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x39561
movq -0x8(%rbp), %rdi
leaq 0x30611(%rip), %rsi     # 0x69bce
callq 0x5370
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: ef-gy[P]libefgy/include/ef.gy/colour-space-rgb.h
// Function: efgy::math::vector<float, 3u, efgy::math::format::RGB>::vector(float const&, float const&, float const&)
vector(const Q &pRed, const Q &pGreen, const Q &pBlue)
      : std::array<Q, 3>({pRed, pGreen, pBlue}),
        red((*this)[0]),
        green((*this)[1]),
        blue((*this)[2]) {}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
movss %xmm0, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movss (%rax), %xmm0
movss %xmm0, -0x28(%rbp)
movq -0x20(%rbp), %rax
movss (%rax), %xmm0
movss %xmm0, -0x24(%rbp)
movq -0x2c(%rbp), %rax
movq %rax, (%rdi)
movl -0x24(%rbp), %eax
movl %eax, 0x8(%rdi)
xorl %eax, %eax
movl %eax, %esi
callq 0x397b0
movq -0x38(%rbp), %rdi
movq %rax, 0x10(%rdi)
movl $0x1, %esi
callq 0x397b0
movq -0x38(%rbp), %rdi
movq %rax, 0x18(%rdi)
movl $0x2, %esi
callq 0x397b0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x20(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ef-gy[P]libefgy/include/ef.gy/colour-space-rgb.h
// Function: efgy::math::vector<float, 3u, efgy::math::format::RGB>::vector(efgy::math::vector<float, 3u, efgy::math::format::RGB> const&)
vector(const vector &v)
      : std::array<Q, 3>({v.red, v.green, v.blue}),
        red((*this)[0]),
        green((*this)[1]),
        blue((*this)[2]) {}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movss (%rax), %xmm0
movss %xmm0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movss (%rax), %xmm0
movss %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movss (%rax), %xmm0
movss %xmm0, -0x14(%rbp)
movq -0x1c(%rbp), %rax
movq %rax, (%rdi)
movl -0x14(%rbp), %eax
movl %eax, 0x8(%rdi)
xorl %eax, %eax
movl %eax, %esi
callq 0x397b0
movq -0x28(%rbp), %rdi
movq %rax, 0x10(%rdi)
movl $0x1, %esi
callq 0x397b0
movq -0x28(%rbp), %rdi
movq %rax, 0x18(%rdi)
movl $0x2, %esi
callq 0x397b0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ef-gy[P]libefgy/include/ef.gy/parametric.h
// Function: efgy::geometry::parametricIterator<float, 2ul, efgy::geometry::formula::plane>::operator*() const
const face operator*(void)const {
    auto f = base[basePosition];
    face g;
    auto o = g.begin();
    for (auto &p : f) {
      *o = std::array<Q, parent::renderDepth>(
          source::getCoordinates(parameter, getPosition() + p));
      o++;
    }
    return g;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, -0x98(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
movq %rax, %rdi
addq $0x50, %rdi
movq 0x68(%rax), %rsi
callq 0x5a690
movq -0x88(%rbp), %rdi
movq (%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x20(%rbp)
movq 0x10(%rax), %rcx
movq %rcx, -0x18(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
callq 0x3a570
movq -0x88(%rbp), %rdi
callq 0x394e0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x394e0
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x39500
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x48(%rbp), %rax
je 0x56e23
movq -0x90(%rbp), %rdi
movq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
movq %rdi, %rax
addq $0x70, %rax
movq %rax, -0xa0(%rbp)
callq 0x5a3f0
movlpd %xmm0, -0x78(%rbp)
movq -0x50(%rbp), %rdi
movsd -0x78(%rbp), %xmm0
callq 0x5a780
movq -0xa0(%rbp), %rdi
movlpd %xmm0, -0x70(%rbp)
leaq -0x70(%rbp), %rsi
callq 0x5a6b0
movlpd %xmm0, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x60(%rbp), %rsi
leaq -0x79(%rbp), %rdx
callq 0x3a850
movq -0x30(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x40(%rbp)
jmp 0x56d85
movq -0x98(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)