LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/bjohnsonfl[P]Overhead-Chess-Engine-/moveGen.cpp
// Function: printmove(move)
void printmove (move m)
{
   /* square from ,to;
    char mv [4];
    
        from = source_sq(m);
    to = destination_sq(m);
        mv[0] = square_to_file(from) + 'A';
        mv[1] = square_to_rank(from) + '1';
        mv[2] = square_to_file(to) + 'A';
        mv[3] = square_to_rank(to) + '1';
        std::cout << mv[0] << mv[1] << mv[2] << mv[3] << "\n";
    
    */
    std::string pieceletters = "_NBRQ";
    std::string flagletters = "_recp";
    square from ,to;
    char mv [7];
    
    from = source_sq(m);
    to = destination_sq(m);
    mv[0] = square_to_file(from) + 'A';
    mv[1] = square_to_rank(from) + '1';
    mv[2] = square_to_file(to) + 'A';
    mv[3] = square_to_rank(to) + '1';
    mv[4] = ' ';
    mv[5] = pieceletters[promo_pieceType(m)] ;
    mv[6] = flagletters[move_flag(m)+1]; //for non promotions, shows up at N because the offset of piece promotion
    std::cout << mv[0] << mv[1] << mv[2] << mv[3] << mv[4] << mv[5] << mv[6]  << "\n";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movl %edi, %ebx
leaq 0x40(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x40d9(%rip), %rsi      # 0x8230
leaq 0x40d7(%rip), %rdx      # 0x8235
leaq 0x30(%rsp), %rdi
callq 0x44f4
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x40be(%rip), %rsi      # 0x8236
leaq 0x40bc(%rip), %rdx      # 0x823b
leaq 0x10(%rsp), %rdi
callq 0x44f4
movl %ebx, %eax
andb $0x7, %al
addb $0x41, %al
movl %ebx, %ecx
shrl $0xc, %ecx
andl $0x3, %ecx
movq 0x30(%rsp), %rdx
movb 0x1(%rdx,%rcx), %r12b
movl %ebx, %ecx
shrl $0xe, %ecx
andl $0x3, %ecx
movq 0x10(%rsp), %rdx
movb 0x1(%rdx,%rcx), %bpl
leaq 0xf(%rsp), %rsi
movb %al, (%rsi)
movq 0x6dff(%rip), %rdi      # 0xafc0
movl $0x1, %edx
callq 0x2180
movl %ebx, %ecx
shrb $0x3, %cl
andb $0x7, %cl
addb $0x31, %cl
leaq 0xf(%rsp), %rsi
movb %cl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x2180
movl %ebx, %ecx
shrl $0x6, %ecx
andb $0x7, %cl
addb $0x41, %cl
leaq 0xf(%rsp), %rsi
movb %cl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x2180
shrl $0x9, %ebx
andb $0x7, %bl
addb $0x31, %bl
leaq 0xf(%rsp), %rsi
movb %bl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x2180
leaq 0xf(%rsp), %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x2180
leaq 0xf(%rsp), %rsi
movb %r12b, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x2180
leaq 0xf(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x2180
leaq 0x4105(%rip), %rsi      # 0x8371
movl $0x1, %edx
movq %rax, %rdi
callq 0x2180
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x4290
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x2160
movq 0x30(%rsp), %rdi
cmpq %r14, %rdi
je 0x42a7
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x2160
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x42d3
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x42d3
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x2160
movq 0x30(%rsp), %rdi
cmpq %r14, %rdi
je 0x42ea
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x2160
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movl $0x48, %edi
callq 0x2150
movl $0x0, 0x8(%rax)
movabsq $0x4000000000, %rcx     # imm = 0x4000000000
movq %rcx, (%rax)
movl $0xc, %ecx
movq %rcx, 0xc(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x28(%rax)
movups %xmm0, 0x38(%rax)
movq %rax, 0x188(%rbx)
movq %rcx, 0xc(%rax)
movq $0x0, 0x18(%rax)
movups %xmm0, 0x178(%rbx)
movq %rbx, %rdi
callq 0x4b4a
movq 0x188(%rbx), %rsi
movq %rbx, %rdi
callq 0x4a96
movq 0x188(%rbx), %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x4b02
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl $0x48, %edi
callq 0x2150
movl $0x0, 0x8(%rax)
movabsq $0x4000000000, %rcx     # imm = 0x4000000000
movq %rcx, (%rax)
movq $0xc, 0xc(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x28(%rax)
movups %xmm0, 0x38(%rax)
movq 0x188(%rbx), %rcx
movq %rcx, 0x18(%rax)
movq %rax, 0x188(%rbx)
xorl %eax, %eax
movl $0xc, (%rbx,%rax,4)
incq %rax
cmpq $0x40, %rax
jne 0x4665
xorps %xmm0, %xmm0
movups %xmm0, 0x150(%rbx)
movups %xmm0, 0x140(%rbx)
movups %xmm0, 0x130(%rbx)
movups %xmm0, 0x120(%rbx)
movups %xmm0, 0x110(%rbx)
movups %xmm0, 0x100(%rbx)
xorl %eax, %eax
movq %rax, 0x180(%rbx)
movups %xmm0, 0x160(%rbx)
movq %rax, 0x170(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x46ea
movq 0x188(%rbx), %rsi
movq %rbx, %rdi
callq 0x4a96
movq 0x188(%rbx), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4b02
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %r12d, %r12d
leaq 0x66b2(%rip), %r15      # 0xb160
movq 0x100(%r14,%r12,8), %rdi
movl 0x40(%rbx), %ebp
callq 0x28c9
imull 0x4(%r15,%r12,4), %eax
incq %r12
addl %ebp, %eax
movl %eax, 0x40(%rbx)
cmpq $0x5, %r12
jne 0x4aae
xorl %r12d, %r12d
movq 0x130(%r14,%r12,8), %rdi
movl 0x44(%rbx), %ebp
callq 0x28c9
imull 0x4(%r15,%r12,4), %eax
addl %ebp, %eax
movl %eax, 0x44(%rbx)
incq %r12
cmpq $0x5, %r12
jne 0x4ad5
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/bjohnsonfl[P]Overhead-Chess-Engine-/position.cpp
// Function: position::update_check_boards(returnState*)
void position::update_check_boards(returnState *state)
{
   
    //these are our own pieces pinned due to blocking the attacks on the king
    //The function also passes in pinners which is the their pieces causing the pin
    state -> absolutePinned[white] = pinningBoards(get_king_sq(white), state->pinners[black], white);
   
    state -> absolutePinned[black] = pinningBoards(get_king_sq(black), state->pinners[white], black);

    
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
bsfq 0x128(%rdi), %rsi
leaq 0x30(%rbx), %r15
leaq 0x38(%rbx), %rdx
xorl %ecx, %ecx
callq 0x55d6
movq %rax, 0x20(%rbx)
bsfq 0x158(%r14), %rsi
movq %r14, %rdi
movq %r15, %rdx
movl $0x1, %ecx
callq 0x55d6
movq %rax, 0x28(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
cmpl $0xc, %edx
je 0x4c5e
movl %esi, %eax
movl %edx, (%rdi,%rax,4)
movl %edx, %ecx
leaq 0x71b7(%rip), %rsi      # 0xbde0
movq (%rsi,%rax,8), %r8
orq %r8, 0x100(%rdi,%rcx,8)
xorl %ecx, %ecx
cmpl $0x6, %edx
setge %cl
movq (%rsi,%rax,8), %rax
orq %rax, 0x160(%rdi,%rcx,8)
movq 0x168(%rdi), %rax
orq 0x160(%rdi), %rax
movq %rax, 0x170(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x5d67(%rip), %r14      # 0xafc0
leaq 0x3149(%rip), %rsi      # 0x83a9
movl $0x10, %edx
movq %r14, %rdi
callq 0x2180
leaq 0x2d9e(%rip), %rsi      # 0x8012
movl $0x10, %edx
movq %r14, %rdi
callq 0x2180
addq $0xe0, %rbx
movl $0x7, %ebp
leaq 0x7(%rsp), %r15
leaq 0x330a(%rip), %r12      # 0x85a3
xorl %r13d, %r13d
movl (%rbx,%r13,4), %eax
movq 0xeb269(%rip), %rcx     # 0xf0510
movb (%rcx,%rax), %al
movb %al, 0x7(%rsp)
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2180
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2180
incq %r13
cmpq $0x8, %r13
jne 0x529c
movl $0x1, %edx
movq %r14, %rdi
leaq 0x308b(%rip), %rsi      # 0x8371
callq 0x2180
addq $-0x20, %rbx
subq $0x1, %rbp
jae 0x5299
movq 0x5cc4(%rip), %rdi      # 0xafc0
leaq 0x2d0f(%rip), %rsi      # 0x8012
movl $0x10, %edx
callq 0x2180
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
cmpl $0xc, %edx
je 0x5368
movl %esi, %eax
movl $0xc, (%rdi,%rax,4)
movl %edx, %ecx
leaq 0x6aad(%rip), %rsi      # 0xbde0
movq (%rsi,%rax,8), %r8
xorq %r8, 0x100(%rdi,%rcx,8)
xorl %ecx, %ecx
cmpl $0x6, %edx
setge %cl
movq (%rsi,%rax,8), %rax
xorq %rax, 0x160(%rdi,%rcx,8)
movq 0x168(%rdi), %rax
orq 0x160(%rdi), %rax
movq %rax, 0x170(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, %eax
leaq 0x793f(%rip), %rcx      # 0xd0e0
movq 0x100(%rdi), %rdx
movq 0x130(%rdi), %rsi
andq 0x200(%rcx,%rax,8), %rdx
andq (%rcx,%rax,8), %rsi
movq 0x138(%rdi), %rcx
orq 0x108(%rdi), %rcx
leaq 0x6d10(%rip), %rdi      # 0xc4e0
andq 0x200(%rdi,%rax,8), %rcx
movq 0x158(%rbx), %r15
orq 0x128(%rbx), %r15
andq 0xa00(%rdi,%rax,8), %r15
orq %rdx, %rsi
orq %rcx, %r15
orq %rsi, %r15
movq 0x170(%rbx), %rsi
movl %ebp, %edi
movl $0x3, %edx
callq 0x34b9
movq %rax, %r14
movq 0x148(%rbx), %rax
orq 0x118(%rbx), %rax
orq 0x120(%rbx), %rax
movq 0x170(%rbx), %rsi
orq 0x150(%rbx), %rax
andq %rax, %r14
movl %ebp, %edi
movl $0x2, %edx
callq 0x34b9
movq 0x140(%rbx), %rcx
orq 0x110(%rbx), %rcx
orq 0x120(%rbx), %rcx
orq 0x150(%rbx), %rcx
andq %rcx, %rax
orq %r14, %rax
orq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r15d, %r15d
movq 0x552c(%rip), %r14      # 0xafc0
leaq 0x7(%rsp), %r12
leaq 0x28d1(%rip), %r13      # 0x8371
leaq 0x28c8(%rip), %rbp      # 0x836f
movl $0x7, %edx
movq %r14, %rdi
leaq 0x28b1(%rip), %rsi      # 0x8367
callq 0x2180
movq 0xeaa4e(%rip), %rax     # 0xf0510
movb (%rax,%r15), %al
movb %al, 0x7(%rsp)
movl $0x1, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x2180
movl $0x1, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x2180
movq 0x100(%rbx,%r15,8), %rdi
callq 0x3532
movl $0x3, %edx
movq %r14, %rdi
movq %rbp, %rsi
callq 0x2180
incq %r15
cmpq $0xc, %r15
jne 0x5aa7
movq 0x54a9(%rip), %r14      # 0xafc0
leaq 0x2855(%rip), %rsi      # 0x8373
movl $0x13, %edx
movq %r14, %rdi
callq 0x2180
movq 0x160(%rbx), %rdi
callq 0x3532
leaq 0x2831(%rip), %r15      # 0x836f
movl $0x3, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2180
leaq 0x2832(%rip), %rsi      # 0x8387
movl $0x13, %edx
movq %r14, %rdi
callq 0x2180
movq 0x168(%rbx), %rdi
callq 0x3532
movl $0x3, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2180
leaq 0x2816(%rip), %rsi      # 0x839b
movl $0xd, %edx
movq %r14, %rdi
callq 0x2180
movq 0x170(%rbx), %rdi
callq 0x3532
movl $0x3, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2180
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x858, %rsp            # imm = 0x858
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x58(%rsp), %r14
movq %r14, -0x10(%r14)
movq %r14, -0x8(%r14)
movq %rsi, %rdi
movq %r14, %rsi
callq 0x3d21
movq %rax, -0x10(%r14)
movabsq $0xc00000000, %rcx      # imm = 0xC00000000
movq %rcx, 0x8(%rsp)
movabsq $0x4000000000, %rcx     # imm = 0x4000000000
movq %rcx, (%rsp)
movl $0x0, 0x10(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rsp)
movups %xmm0, 0x28(%rsp)
movups %xmm0, 0x38(%rsp)
movq -0x8(%r14), %rcx
cmpq %rax, %rcx
je 0x608b
decl %ebp
xorl %r14d, %r14d
movq %rsp, %r15
movl (%rcx), %esi
movq %rbx, %rdi
callq 0x58f8
testb %al, %al
je 0x6074
movq 0x50(%rsp), %rax
movl (%rax), %esi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x4c60
movl %ebp, %edi
movq %rbx, %rsi
callq 0x5bc0
addq %rax, %r14
movq 0x50(%rsp), %rax
movl (%rax), %esi
movq %rbx, %rdi
callq 0x536a
movq 0x50(%rsp), %rcx
addq $0x8, %rcx
movq %rcx, 0x50(%rsp)
cmpq 0x48(%rsp), %rcx
jne 0x6038
jmp 0x608e
xorl %r14d, %r14d
movq %r14, %rax
addq $0x858, %rsp            # imm = 0x858
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
leaq 0xea645(%rip), %rax     # 0xf09d0
xorl %ecx, %ecx
movl %ecx, %edx
xorl $0x38, %edx
movl %edx, (%rax)
incq %rcx
addq $0x4, %rax
cmpq $0x40, %rcx
jne 0x638d
movl $0x1a7c, 0xea725(%rip)  # imm = 0x1A7C
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x838, %rsp            # imm = 0x838
movq %rsi, %rbx
leaq 0x38(%rsp), %r14
movq %r14, -0x10(%r14)
movq %r14, -0x8(%r14)
addq $0x18, %rdi
movq %r14, %rsi
callq 0x3d21
movq %rax, -0x10(%r14)
movq -0x8(%r14), %rcx
cmpq %rax, %rcx
je 0x774b
leaq 0x18(%rsp), %r15
leaq 0x8(%rsp), %r14
movl (%rcx), %edx
movq %r14, %rdi
callq 0x7760
movq 0x8(%rbx), %rdx
cmpq 0x10(%rsp), %rdx
jne 0x7713
testq %rdx, %rdx
je 0x7717
movq 0x8(%rsp), %rsi
movq (%rbx), %rdi
callq 0x2170
testl %eax, %eax
sete %bpl
jmp 0x771a
xorl %ebp, %ebp
jmp 0x771a
movb $0x1, %bpl
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x7731
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2160
movq 0x30(%rsp), %rcx
testb %bpl, %bpl
jne 0x774f
addq $0x8, %rcx
movq %rcx, 0x30(%rsp)
cmpq 0x28(%rsp), %rcx
jne 0x76e4
xorl %eax, %eax
jmp 0x7751
movl (%rcx), %eax
addq $0x838, %rsp            # imm = 0x838
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/bjohnsonfl[P]Overhead-Chess-Engine-/UCI.cpp
// Function: UCI::moveToString[abi:cxx11](move)
std::string UCI::moveToString (move m)
{
    
    //the only internal moves different to external are castling and promotions
    //internally: castling is king to rook sq
    //externally: castling is king src to king dest
    //for promotions, just add the promo letter i.e. fromToPromo
    std::string mv = "    ";
    std::string pieceletters = " nbrq";
    square from ,to;
    from = source_sq(m);
    to = destination_sq(m);
    mv[0] = square_to_file(from) + 'a';
    mv[1] = square_to_rank(from) + '1';
    mv[2] = square_to_file(to) + 'a';
    mv[3] = square_to_rank(to) + '1';
    
    if(move_flag(m) == promoting)
        mv += pieceletters[promo_pieceType(m)];
    
    if(move_flag(m) == castling){
        if(to == a1){
            mv[2] = 'c';
            mv[3] = '1';
        }
        else if(to == h1){
            mv[2] = 'g';
            mv[3] = '1';
        }
        else if(to == a8){
            mv[2] = 'c';
            mv[3] = '8';
        }
        else if(to == h8){
            mv[2] = 'g';
            mv[3] = '8';
        }
    }
    return mv;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %r14d
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
leaq 0xe1e(%rip), %rsi       # 0x85a0
leaq 0xe1b(%rip), %rdx       # 0x85a4
callq 0x44f4
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xe07(%rip), %rsi       # 0x85a5
leaq 0xe05(%rip), %rdx       # 0x85aa
leaq 0x8(%rsp), %rdi
callq 0x44f4
movl %r14d, %ebp
shrl $0x6, %ebp
movl %r14d, %eax
andb $0x7, %al
addb $0x61, %al
movq (%rbx), %rcx
movb %al, (%rcx)
movl %r14d, %eax
shrb $0x3, %al
andb $0x7, %al
addb $0x31, %al
movq (%rbx), %rcx
movb %al, 0x1(%rcx)
movl %ebp, %eax
andb $0x7, %al
addb $0x61, %al
movq (%rbx), %rcx
movb %al, 0x2(%rcx)
movl %r14d, %eax
shrl $0x9, %eax
andb $0x7, %al
addb $0x31, %al
movq (%rbx), %rcx
movb %al, 0x3(%rcx)
movl %r14d, %r13d
shrl $0xe, %r13d
andl $0x3, %r13d
cmpl $0x2, %r13d
je 0x7825
cmpl $0x3, %r13d
jne 0x785a
shrl $0xc, %r14d
andl $0x3, %r14d
movq 0x8(%rsp), %rax
movsbl 0x1(%rax,%r14), %esi
movq %rbx, %rdi
callq 0x2120
cmpl $0x2, %r13d
jne 0x785a
andl $0x3f, %ebp
movb $0x63, %al
cmpl $0x37, %ebp
jg 0x783c
movb $0x31, %cl
testl %ebp, %ebp
je 0x784e
cmpl $0x7, %ebp
je 0x7848
jmp 0x785a
cmpl $0x38, %ebp
je 0x784c
cmpl $0x3f, %ebp
jne 0x785a
movb $0x38, %cl
movb $0x67, %al
jmp 0x784e
movb $0x38, %cl
movq (%rbx), %rdx
movb %al, 0x2(%rdx)
movq (%rbx), %rax
movb %cl, 0x3(%rax)
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x7871
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2160
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x78a2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2160
jmp 0x78a2
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x78b6
movq (%r12), %rsi
incq %rsi
callq 0x2160
movq %r14, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq 0x2dfe(%rip), %rbx      # 0x3fd8
movq %rbx, %rdi
movl $0xffffffaa, %esi       # imm = 0xFFFFFFAA
callq 0x1080
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %r14, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
movq %rbx, %rdi
movl $0xffffffee, %esi       # imm = 0xFFFFFFEE
callq 0x1080
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %r14, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1080
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %r14, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
movq %rbx, %rdi
movl $0x2, %esi
callq 0x1080
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %r14, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x1080
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %r14, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
movq %rbx, %rdi
movl $0x5b, %esi
callq 0x1080
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/ef-gy[P]libefgy/include/ef.gy/vector.h
// Function: std::basic_ostream<char, std::char_traits<char>>& efgy::math::operator<<<char, float, 3u, efgy::math::format::cartesian>(std::basic_ostream<char, std::char_traits<char>>&, efgy::math::vector<float, 3u, 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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xc1c3(%rip), %rsi      # 0x24c62
movl $0x1, %edx
callq 0x42c0
leaq 0xc1b7(%rip), %rsi      # 0x24c67
movl $0xb, %edx
movq %rbx, %rdi
callq 0x42c0
xorl %r15d, %r15d
leaq 0xc00e(%rip), %r12      # 0x24ad5
leaq 0xc196(%rip), %r13      # 0x24c64
xorl %edx, %edx
testq %r15, %r15
movq %r13, %rsi
cmoveq %r12, %rsi
setne %dl
incq %rdx
movq %rbx, %rdi
callq 0x42c0
xorps %xmm0, %xmm0
cvtss2sd (%r14,%r15,4), %xmm0
movq %rbx, %rdi
callq 0x4390
incq %r15
cmpq $0x3, %r15
jne 0x18ace
leaq 0xbf51(%rip), %rsi      # 0x24a5a
movl $0x1, %edx
movq %rbx, %rdi
callq 0x42c0
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ef-gy[P]libefgy/include/ef.gy/polytope.h
// Function: efgy::geometry::generators::cube<float, 3ul>::faces(efgy::geometry::parameters<float> const&)
static std::vector<face> faces(const parameters<Q> &parameter) {
    std::vector<face> res(source::size(), face());
    const auto pd = parameter.radius * Q(.5);
    const auto nd = parameter.radius * Q(-.5);
    auto r = res.begin();

    for (auto fa : source::faces()) {
      for (std::size_t j = 0; j < depth; j++) {
        (*r)[0][j] = fa[0][j] ? pd : nd;
        (*r)[1][j] = fa[1][j] ? pd : nd;
        (*r)[2][j] = fa[2][j] ? pd : nd;
        (*r)[3][j] = fa[3][j] ? pd : nd;
      }
      r++;
    }

    return res;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl $0x120, %edi            # imm = 0x120
callq 0x4250
xorps %xmm0, %xmm0
movq %rax, %r14
movq %rax, (%rbx)
movq %rax, 0x8(%rbx)
addq $0x120, %rax            # imm = 0x120
movq %rax, 0x10(%rbx)
xorl %eax, %eax
movups %xmm0, 0x20(%r14,%rax)
movups %xmm0, 0x10(%r14,%rax)
movups %xmm0, (%r14,%rax)
addq $0x30, %rax
cmpq $0x120, %rax            # imm = 0x120
jne 0x18b64
movq %r14, %rcx
addq %rax, %rcx
movq %rcx, 0x8(%rbx)
movss (%r15), %xmm0
movss %xmm0, 0xc(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x18c92
leaq 0x28(%rsp), %r15
movq 0x10(%r15), %rax
cmpq %r15, %rax
movss 0xc(%rsp), %xmm1
je 0x18c63
movss 0xb588(%rip), %xmm2     # 0x24148
mulss %xmm1, %xmm2
mulss 0xb580(%rip), %xmm1     # 0x2414c
movss %xmm1, 0xc(%rsp)
movss %xmm2, 0x1c(%rsp)
movl 0x28(%rax), %ecx
movl %ecx, 0x18(%rsp)
movq 0x20(%rax), %rcx
movq %rcx, 0x10(%rsp)
xorl %ecx, %ecx
cmpb $0x0, 0x10(%rsp,%rcx)
movaps %xmm2, %xmm0
jne 0x18bf7
movaps %xmm1, %xmm0
movss %xmm0, (%r14,%rcx,4)
cmpb $0x0, 0x13(%rsp,%rcx)
movaps %xmm2, %xmm0
jne 0x18c0a
movaps %xmm1, %xmm0
movss %xmm0, 0xc(%r14,%rcx,4)
cmpb $0x0, 0x16(%rsp,%rcx)
movaps %xmm2, %xmm0
jne 0x18c1e
movaps %xmm1, %xmm0
movss %xmm0, 0x18(%r14,%rcx,4)
cmpb $0x0, 0x19(%rsp,%rcx)
movaps %xmm2, %xmm0
jne 0x18c32
movaps %xmm1, %xmm0
movss %xmm0, 0x24(%r14,%rcx,4)
incq %rcx
cmpq $0x3, %rcx
jne 0x18bea
addq $0x30, %r14
movq %rax, %rdi
callq 0x42e0
movss 0x1c(%rsp), %xmm2
movss 0xc(%rsp), %xmm1
cmpq %r15, %rax
jne 0x18bd8
leaq 0x20(%rsp), %rdi
callq 0x19018
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x120, %esi            # imm = 0x120
movq %r14, %rdi
callq 0x4260
movq %rbx, %rdi
callq 0x4400
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq %rdi, %rax
movq 0x50(%rsi), %rcx
movq 0x68(%rsi), %rdx
shlq $0x5, %rdx
movups (%rcx,%rdx), %xmm0
movups 0x10(%rcx,%rdx), %xmm1
leaq -0x28(%rsp), %rcx
movaps %xmm1, 0x10(%rcx)
movaps %xmm0, (%rcx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq (%rsi), %rdx
xorl %esi, %esi
movq $0x0, -0x30(%rsp)
xorl %r8d, %r8d
movq 0x8(%rdx,%r8,4), %r9
testq %r9, %r9
js 0x1dccb
xorps %xmm0, %xmm0
cvtsi2ss %r9, %xmm0
jmp 0x1dce4
movq %r9, %r10
shrq %r10
andl $0x1, %r9d
orq %r10, %r9
xorps %xmm0, %xmm0
cvtsi2ss %r9, %xmm0
addss %xmm0, %xmm0
mulss 0x4(%rdx,%r8,4), %xmm0
addss (%rdx,%r8,4), %xmm0
movss %xmm0, -0x30(%rsp,%r8)
addq $0x4, %r8
cmpq $0x4, %r8
je 0x1dcb7
movsd -0x30(%rsp), %xmm0
movsd %xmm0, -0x30(%rsp)
xorl %r8d, %r8d
movss (%rcx,%r8,4), %xmm0
addss -0x30(%rsp,%r8,4), %xmm0
movss %xmm0, -0x30(%rsp,%r8,4)
incq %r8
cmpq $0x1, %r8
je 0x1dd11
movq -0x30(%rsp), %r8
movq %r8, (%rdi)
addq $0x8, %rdi
addq $0x8, %rsi
addq $0x8, %rcx
cmpq $0x20, %rsi
jne 0x1dcab
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ef-gy[P]libefgy/include/ef.gy/parametric.h
// Function: efgy::geometry::parametricIterator<float, 2ul, efgy::geometry::formula::plane>::operator++()
parametricIterator &operator++(void) {
    basePosition++;

    if (basePosition < base.size()) {
      return *this;
    } else {
      basePosition = 0;
    }

    for (int dim = (od - 1); dim >= 0; dim--) {
      if (positions[dim] < ends[dim]) {
        positions[dim]++;
      }

      if (positions[dim] < ends[dim]) {
        break;
      } else if (dim > 0) {
        positions[dim] = starts[dim];
      }
    }
    return *this;
  }

// Assembly:
movq %rdi, %rax
movq 0x58(%rdi), %rcx
movq 0x68(%rdi), %rdx
incq %rdx
movq %rdx, 0x68(%rdi)
subq 0x50(%rdi), %rcx
sarq $0x5, %rcx
cmpq %rcx, %rdx
jb 0x1ddc2
movq $0x0, 0x68(%rax)
movl $0x2, %ecx
leal -0x1(%rcx), %edx
shlq $0x4, %rdx
movq (%rax), %rsi
movq 0x30(%rax), %rdi
movq 0x8(%rsi,%rdx), %r8
addq %rdx, %rsi
cmpq 0x8(%rdi,%rdx), %r8
jae 0x1dd9e
incq %r8
movq %r8, 0x8(%rsi)
addq %rdx, %rdi
addq $0x8, %rdi
movq 0x8(%rsi), %r8
cmpq (%rdi), %r8
jb 0x1ddc2
cmpl $0x1, %ecx
je 0x1ddbe
movq 0x18(%rax), %rdi
movups (%rdi,%rdx), %xmm0
movups %xmm0, (%rsi)
decl %ecx
jne 0x1dd7a
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ef-gy[P]libefgy/include/ef.gy/parametric.h
// Function: efgy::geometry::parametric<float, 2ul, efgy::geometry::formula::plane>::size() const
std::size_t size(void) const {
#if 0
    std::size_t s = source::getRange(parent::parameter, 0).size();
    for (std::size_t i = 1; i < od; i++) {
      s *= source::getRange(parent::parameter, i).size();
    }
    return s;
#else
    // TODO: this is really bad, but the closed form currently eludes me.
    return std::count_if(begin(), end(),
                         [](const typename parent::face &) { return true; });
#endif
  }

// Assembly:
pushq %rbx
subq $0x170, %rsp            # imm = 0x170
movq %rdi, %rbx
movq (%rdi), %rsi
leaq 0xb8(%rsp), %rdi
callq 0x1dfae
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x1db8c
leaq 0xb8(%rsp), %rdi
movq %rsp, %rsi
callq 0x1eb37
movq %rax, %rbx
movq 0xa0(%rsp), %rdi
testq %rdi, %rdi
je 0x1de90
movq 0xb0(%rsp), %rsi
subq %rdi, %rsi
callq 0x4260
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x1dea7
movq 0x60(%rsp), %rsi
subq %rdi, %rsi
callq 0x4260
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x1debe
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x4260
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x1ded5
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x4260
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1deeb
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x4260
movq 0x158(%rsp), %rdi
testq %rdi, %rdi
je 0x1df08
movq 0x168(%rsp), %rsi
subq %rdi, %rsi
callq 0x4260
movq 0x108(%rsp), %rdi
testq %rdi, %rdi
je 0x1df25
movq 0x118(%rsp), %rsi
subq %rdi, %rsi
callq 0x4260
movq 0xe8(%rsp), %rdi
testq %rdi, %rdi
je 0x1df42
movq 0xf8(%rsp), %rsi
subq %rdi, %rsi
callq 0x4260
movq 0xd0(%rsp), %rdi
testq %rdi, %rdi
je 0x1df5f
movq 0xe0(%rsp), %rsi
subq %rdi, %rsi
callq 0x4260
movq 0xb8(%rsp), %rdi
testq %rdi, %rdi
je 0x1df7c
movq 0xc8(%rsp), %rsi
subq %rdi, %rsi
callq 0x4260
movq %rbx, %rax
addq $0x170, %rsp            # imm = 0x170
popq %rbx
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1ddc4
jmp 0x1df98
movq %rax, %rbx
leaq 0xb8(%rsp), %rdi
callq 0x1ddc4
movq %rbx, %rdi
callq 0x4400
nop
// File: /workspace/github_cpp_makefile_star2_O1/ef-gy[P]libefgy/include/ef.gy/parametric.h
// Function: efgy::geometry::parametricIterator<float, 2ul, efgy::geometry::formula::plane>::getBase(efgy::math::vector<float, 2u, efgy::math::format::cartesian> const&)
static const faces getBase(const vector &strides) {
    parameters<Q> cubeParameter;
    cube<Q, od> cube(cubeParameter);
    faces base;

    const Q r2 = cubeParameter.radius / Q(2);

    for (auto f : cube) {
      auto cf = f;
      for (auto &v : cf) {
        auto s = strides.begin();
        for (auto &q : v) {
          q = (q + r2) * (*s);
          s++;
        }
      }
      base.push_back(cf);
    }

    return base;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x58(%rsp), %r15
movq %r15, %rdi
callq 0x18612
leaq 0x30(%rsp), %rdi
movq %r15, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
xorl %eax, %eax
movq %rax, 0x20(%rdi)
movq %rax, 0x10(%rbx)
movups %xmm0, (%rbx)
movss (%r15), %xmm0
movss %xmm0, 0xc(%rsp)
callq 0x186de
movq %rax, %r15
movq 0x48(%rsp), %r13
cmpq %r13, %rax
je 0x1e352
movss 0xc(%rsp), %xmm0
mulss 0x5e9a(%rip), %xmm0     # 0x24148
movss %xmm0, 0xc(%rsp)
leaq 0x10(%rsp), %r12
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movaps %xmm1, 0xb0(%rsp)
movaps %xmm0, 0xa0(%rsp)
movaps %xmm1, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movq %r12, %rax
xorl %ecx, %ecx
addq $0x8, %rcx
xorl %edx, %edx
movss 0xc(%rsp), %xmm1
movss (%rax,%rdx), %xmm0
addss %xmm1, %xmm0
mulss (%r14,%rdx), %xmm0
movss %xmm0, (%rax,%rdx)
addq $0x4, %rdx
cmpq $0x8, %rdx
jne 0x1e2ed
addq $0x8, %rax
cmpq $0x20, %rcx
jne 0x1e2e1
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x1e33a
movaps 0x10(%rsp), %xmm0
movaps 0x20(%rsp), %xmm1
movups %xmm1, 0x10(%rsi)
movups %xmm0, (%rsi)
addq $0x20, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x1e345
movq %rbx, %rdi
movq %r12, %rdx
callq 0x1e6ea
addq $0x20, %r15
cmpq %r13, %r15
jne 0x1e2b9
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x1e369
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x4260
movq 0x88(%rsp), %rdi
testq %rdi, %rdi
je 0x1e386
movq 0x98(%rsp), %rsi
subq %rdi, %rsi
callq 0x4260
movq %rbx, %rax
addq $0xc0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x1e39c
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1e3b3
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x4260
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x1e3ca
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x4260
movq 0x88(%rsp), %rdi
testq %rdi, %rdi
je 0x1e3e7
movq 0x98(%rsp), %rsi
subq %rdi, %rsi
callq 0x4260
movq %r14, %rdi
callq 0x4400
nop
// File: /workspace/github_cpp_makefile_star2_O1/ef-gy[P]libefgy/include/ef.gy/ifs.h
// Function: efgy::geometry::ifs<float, 2ul, efgy::geometry::cube, efgy::geometry::generators::gasket>::iterator::operator*() const
const face operator*(void)const {
      auto f = *basePosition;
      face g;
      auto o = g.begin();
      for (auto &p : f) {
        *o = p;
        for (const auto &i : iteration()) {
          *o = functions[i] * (*o);
        }
        o++;
      }
      return g;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %r12
movq 0x28(%rsi), %rax
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movaps %xmm1, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
xorl %r13d, %r13d
movq %rsp, %r15
movq %rdi, 0x18(%rsp)
movq 0x20(%rsp,%r13), %rax
movq %rax, (%r12)
movq %r15, %rdi
movq %r14, %rsi
callq 0x216e0
movq (%rsp), %rbp
movq 0x8(%rsp), %rbx
cmpq %rbx, %rbp
je 0x20f7b
movq (%rbp), %rax
leaq (%rax,%rax,8), %rdi
shlq $0x2, %rdi
addq 0x30(%r14), %rdi
movq %r12, %rsi
callq 0x217f0
movlps %xmm0, (%r12)
addq $0x8, %rbp
jmp 0x20f53
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x20f91
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x4260
addq $0x8, %r12
addq $0x8, %r13
cmpq $0x20, %r13
jne 0x20f36
movq 0x18(%rsp), %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x20fcc
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x4260
movq %rbx, %rdi
callq 0x4400
// File: /workspace/github_cpp_makefile_star2_O1/ef-gy[P]libefgy/include/ef.gy/ifs.h
// Function: efgy::geometry::ifs<float, 2ul, efgy::geometry::cube, efgy::geometry::generators::gasket>::iterator::operator++()
iterator &operator++(void) {
      if (basePosition != base.end()) {
        basePosition++;
      }

      if (basePosition == base.end()) {
        basePosition = base.begin();
        iterations++;
      }

      return *this;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rax
movq 0x28(%rdi), %rcx
cmpq %rax, %rcx
je 0x20fed
addq $0x20, %rcx
movq %rcx, 0x28(%rbx)
cmpq %rax, 0x28(%rbx)
jne 0x21003
movq %rbx, %rdi
callq 0x186de
movq %rax, 0x28(%rbx)
incq 0x48(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/ef-gy[P]libefgy/include/ef.gy/ifs.h
// Function: efgy::geometry::generators::gasket<float, 4ul, 4ul>::functions(efgy::geometry::parameters<float> const&)
static std::vector<translation> functions(const parameters<Q> &parameter) {
    std::vector<translation> rv = {};

    const std::size_t nfunctions = (1 << (depth - 1)) + 1;
    std::array<math::vector<Q, renderDepth>, nfunctions> translations;

    translations[0][0] = Q(0.25);

    for (std::size_t i = 1; i < translations.size(); i++) {
      translations[i][0] = Q(-0.25);
      for (std::size_t j = 1; j < depth; j++) {
        const std::size_t k = i - 1;
        const std::size_t l = j - 1;
        const std::size_t b = 1 << l;
        const bool s = k & b;
        translations[i][j] = Q(s ? -0.25 : 0.25);
      }
    }

    for (const auto &t : translations) {
      rv.push_back(scale(0.5) * translate(t));
    }

    return rv;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1e8, %rsp            # imm = 0x1E8
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq 0xc(%rsp), %r14
movl $0x90, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x4150
movl $0x3e800000, (%r14)     # imm = 0x3E800000
movl $0x1, %eax
leaq 0x20(%rsp), %rcx
leaq 0x196e(%rip), %rdx      # 0x24040
movq %rax, %rsi
shlq $0x4, %rsi
movl $0xbe800000, 0xc(%rsp,%rsi) # imm = 0xBE800000
leaq 0x7fffffff(%rax), %rsi
xorl %edi, %edi
xorl %r8d, %r8d
btq %rdi, %rsi
setae %r8b
movss (%rdx,%r8,4), %xmm0
movss %xmm0, (%rcx,%rdi,4)
incq %rdi
cmpq $0x3, %rdi
jne 0x226ea
incq %rax
addq $0x10, %rcx
cmpq $0x9, %rax
jne 0x226d2
xorl %ebp, %ebp
leaq 0x100(%rsp), %r14
leaq 0x8(%rsp), %r15
leaq 0x168(%rsp), %r12
leaq 0x9c(%rsp), %r13
movl $0x3f000000, 0x8(%rsp)  # imm = 0x3F000000
movq %r14, %rdi
movq %r15, %rsi
callq 0x228c2
leaq (%rsp,%rbp), %rsi
addq $0xc, %rsi
movq %r12, %rdi
callq 0x22968
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x22b9f
movq 0x8(%rbx), %rax
cmpq 0x10(%rbx), %rax
je 0x22787
movl $0x19, %ecx
movq %rax, %rdi
movq %r13, %rsi
rep  movsl (%rsi), %es:(%rdi)
addq $0x64, %rax
movq %rax, 0x8(%rbx)
jmp 0x22795
movq %rbx, %rdi
movq %rax, %rsi
movq %r13, %rdx
callq 0x22a2e
addq $0x10, %rbp
cmpq $0x90, %rbp
jne 0x22735
movq %rbx, %rax
addq $0x1e8, %rsp            # imm = 0x1E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x227b9
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x227d0
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x4260
movq %r14, %rdi
callq 0x4400
// File: /workspace/github_cpp_makefile_star2_O1/ef-gy[P]libefgy/include/ef.gy/matrix.h
// Function: efgy::math::matrix<float, 3ul, 3ul> efgy::math::operator*<float, 3ul, 3ul, 3ul>(efgy::math::matrix<float, 3ul, 3ul> const&, efgy::math::matrix<float, 3ul, 3ul> const&)
matrix<Q, n, p> operator*(const matrix<Q, n, m> &a, const matrix<Q, m, p> &b) {
  matrix<Q, n, p> r;

  for (std::size_t i = 0; i < n; i++) {
    for (std::size_t j = 0; j < p; j++) {
      r[i][j] = a[i][0] * b[0][j];

      for (std::size_t k = 1; k < m; k++) {
        r[i][j] += a[i][k] * b[k][j];
      }
    }
  }

  return r;
}

// Assembly:
pushq %r14
pushq %rbx
movq %rdi, %rax
leaq 0x4(%rsi), %rcx
leaq 0xc(%rdx), %rdi
xorl %r8d, %r8d
leaq (,%r8,4), %r9
leaq (%r9,%r9,2), %r9
movss (%rsi,%r9), %xmm0
addq %rax, %r9
movq %rdi, %r10
xorl %r11d, %r11d
movss (%rdx,%r11,4), %xmm1
mulss %xmm0, %xmm1
movss %xmm1, (%r9,%r11,4)
movq %r10, %rbx
xorl %r14d, %r14d
movss (%rcx,%r14,4), %xmm2
mulss (%rbx), %xmm2
addss %xmm2, %xmm1
incq %r14
addq $0xc, %rbx
cmpq $0x2, %r14
jne 0x21561
movss %xmm1, (%r9,%r11,4)
incq %r11
addq $0x4, %r10
cmpq $0x3, %r11
jne 0x2154b
incq %r8
addq $0xc, %rcx
cmpq $0x3, %r8
jne 0x21530
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/ef-gy[P]libefgy/include/ef.gy/ifs.h
// Function: efgy::geometry::ifs<float, 2ul, efgy::geometry::cube, efgy::geometry::generators::gasket>::iterator::iteration() const
std::vector<std::size_t> iteration(void) const {
      std::vector<std::size_t> rv = {};
      std::size_t n = iterations;
      for (std::size_t i = 0; i < totalIterations; i++) {
        rv.push_back(n % functions.size());
        n /= functions.size();
      }
      std::reverse(rv.begin(), rv.end());
      return rv;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
cmpq $0x0, 0x50(%rsi)
je 0x2177c
movq %rsi, %r14
movq 0x48(%rsi), %r12
xorl %r13d, %r13d
movabsq $-0x71c71c71c71c71c7, %rbp # imm = 0x8E38E38E38E38E39
movq %rsp, %r15
movq 0x38(%r14), %rcx
subq 0x30(%r14), %rcx
sarq $0x2, %rcx
imulq %rbp, %rcx
movq %r12, %rax
xorl %edx, %edx
divq %rcx
movq %rdx, (%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x2174d
movq %rdx, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x21758
movq %rbx, %rdi
movq %r15, %rdx
callq 0x2184e
movq 0x38(%r14), %rcx
subq 0x30(%r14), %rcx
sarq $0x2, %rcx
imulq %rbp, %rcx
movq %r12, %rax
xorl %edx, %edx
divq %rcx
incq %r13
movq %rax, %r12
cmpq 0x50(%r14), %r13
jb 0x2171a
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
cmpq %rcx, %rax
setne %dl
addq $-0x8, %rcx
cmpq %rax, %rcx
seta %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x217bf
addq $0x8, %rax
movq -0x8(%rax), %rdx
movq (%rcx), %rsi
movq %rsi, -0x8(%rax)
movq %rdx, (%rcx)
addq $-0x8, %rcx
leaq 0x8(%rax), %rdx
cmpq %rcx, %rax
movq %rdx, %rax
jb 0x217a1
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x217e8
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x4260
movq %r14, %rdi
callq 0x4400
// File: /workspace/github_cpp_makefile_star2_O1/ef-gy[P]libefgy/include/ef.gy/transformation.h
// Function: efgy::math::vector<float, 2u, efgy::math::format::cartesian> efgy::geometry::transformation::affine<float, 2ul>::operator*<efgy::math::format::cartesian>(efgy::math::vector<float, 2u, efgy::math::format::cartesian> const&) const
math::vector<Q, d, format> operator*(
      const math::vector<Q, d, format> &pV) const {
    math::vector<Q, d, format> rv;

    math::matrix<Q, 1, d + 1> vectorMatrix;

    for (std::size_t i = 0; i < d; i++) {
      vectorMatrix[0][i] = pV[i];
    }

    vectorMatrix[0][d] = Q(1);

    vectorMatrix = vectorMatrix * matrix;

    for (std::size_t i = 0; i < d; i++) {
      rv[i] = vectorMatrix[0][i] / vectorMatrix[0][d];
    }

    return rv;
  }

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rax
movq $0x0, 0x8(%rsp)
movq (%rsi), %rcx
leaq 0x10(%rsp), %rbx
movq %rcx, (%rbx)
movl $0x3f800000, 0x8(%rbx)  # imm = 0x3F800000
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2192a
movlps %xmm0, (%rbx)
movss %xmm1, 0x8(%rbx)
xorl %eax, %eax
movss 0x10(%rsp,%rax,4), %xmm0
divss %xmm1, %xmm0
movss %xmm0, 0x8(%rsp,%rax,4)
incq %rax
cmpq $0x1, %rax
je 0x21828
movsd 0x8(%rsp), %xmm0
addq $0x20, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/trapexit[P]bbf/src/badblockfile.cpp
// Function: BadBlockFile::filepath[abi:cxx11](BlkDev const&)
std::string
BadBlockFile::filepath(const BlkDev &blkdev_)
{
  const char *homedir;
  std::stringstream ss;

  homedir = ::getenv("HOME");
  if((homedir == NULL) || (homedir[0] == '\0'))
    homedir = "/root";

  ss << homedir << "/badblocks." << captcha::calculate(blkdev_);

  return ss.str();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
callq 0x4330
leaq 0x11413(%rip), %rdi     # 0x16004
callq 0x4530
testq %rax, %rax
je 0x4c03
movq %rax, %r12
cmpb $0x0, (%rax)
jne 0x4c0a
leaq 0x113ff(%rip), %r12     # 0x16009
leaq 0x30(%rsp), %r15
movq %r12, %rdi
callq 0x4200
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x4500
leaq 0x113e3(%rip), %rsi     # 0x1600f
movl $0xb, %edx
movq %r15, %rdi
callq 0x4500
movq %rsp, %rdi
movq %r14, %rsi
callq 0xd8ec
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %r15, %rdi
callq 0x4500
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4c70
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x44b0
leaq 0x38(%rsp), %rsi
movq %rbx, %rdi
callq 0x4650
movq 0x1f30c(%rip), %rsi     # 0x23f90
leaq 0x20(%rsp), %rdi
callq 0x4370
leaq 0xa0(%rsp), %rdi
callq 0x4190
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4cd2
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x44b0
jmp 0x4cd2
jmp 0x4ccf
movq %rax, %rbx
movq 0x1f2b7(%rip), %rsi     # 0x23f90
leaq 0x20(%rsp), %rdi
callq 0x4370
leaq 0xa0(%rsp), %rdi
callq 0x4190
movq %rbx, %rdi
callq 0x46f0