LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: JacobLCarter[P]2D-Portal/utils.cpp
// Function: getVerticalChar()
char getVerticalChar()
{
    
    std::string input;
  
    std::getline(std::cin, input);

    while (input.find_first_not_of("wsx") != std::string::npos ||
            input == "")
    {
        std::cout << "Not a valid control input -- try again" 
            << std::endl;
        std::getline(std::cin, input);
    }

    return input[0];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq -0x20(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x3330
movq -0x38(%rbp), %rsi
movq 0x8dd0(%rip), %rdi      # 0x12fe0
callq 0x3060
jmp 0xa217
jmp 0xa219
leaq -0x20(%rbp), %rdi
leaq 0x38dc(%rip), %rsi      # 0xdb00
xorl %eax, %eax
movl %eax, %edx
callq 0x3120
movq %rax, %rcx
movb $0x1, %al
cmpq $-0x1, %rcx
movb %al, -0x39(%rbp)
jne 0xa258
leaq 0x24a9(%rip), %rsi      # 0xc6eb
leaq -0x20(%rbp), %rdi
callq 0xaa60
movb %al, -0x3a(%rbp)
jmp 0xa250
movb -0x3a(%rbp), %al
movb %al, -0x39(%rbp)
jmp 0xa258
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0xa261
jmp 0xa2ba
movq 0x8d68(%rip), %rdi      # 0x12fd0
leaq 0x3866(%rip), %rsi      # 0xdad5
callq 0x3210
movq %rax, -0x48(%rbp)
jmp 0xa27a
movq -0x48(%rbp), %rdi
movq 0x8d3b(%rip), %rsi      # 0x12fc0
callq 0x3240
jmp 0xa28c
movq 0x8d4d(%rip), %rdi      # 0x12fe0
leaq -0x20(%rbp), %rsi
callq 0x3060
jmp 0xa29e
jmp 0xa219
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x3140
jmp 0xa2e8
xorl %eax, %eax
movl %eax, %esi
leaq -0x20(%rbp), %rdi
callq 0x33f0
movq %rax, -0x50(%rbp)
jmp 0xa2cd
movq -0x50(%rbp), %rax
movb (%rax), %al
movb %al, -0x51(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x3140
movb -0x51(%rbp), %al
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x33b0
nopw %cs:(%rax,%rax)
// File: JacobLCarter[P]2D-Portal/utils.cpp
// Function: getMenuChar()
char getMenuChar()
{
    
    std::string input;
  
    std::getline(std::cin, input);

    while (input.find_first_not_of("yn") != std::string::npos ||
            input == "")
    {
        std::cout << "Not a valid control input -- try again" 
            << std::endl;
        std::getline(std::cin, input);
    }

    return input[0];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq -0x20(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x3330
movq -0x38(%rbp), %rsi
movq 0x8cc0(%rip), %rdi      # 0x12fe0
callq 0x3060
jmp 0xa327
jmp 0xa329
leaq -0x20(%rbp), %rdi
leaq 0x37d0(%rip), %rsi      # 0xdb04
xorl %eax, %eax
movl %eax, %edx
callq 0x3120
movq %rax, %rcx
movb $0x1, %al
cmpq $-0x1, %rcx
movb %al, -0x39(%rbp)
jne 0xa368
leaq 0x2399(%rip), %rsi      # 0xc6eb
leaq -0x20(%rbp), %rdi
callq 0xaa60
movb %al, -0x3a(%rbp)
jmp 0xa360
movb -0x3a(%rbp), %al
movb %al, -0x39(%rbp)
jmp 0xa368
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0xa371
jmp 0xa3ca
movq 0x8c58(%rip), %rdi      # 0x12fd0
leaq 0x3756(%rip), %rsi      # 0xdad5
callq 0x3210
movq %rax, -0x48(%rbp)
jmp 0xa38a
movq -0x48(%rbp), %rdi
movq 0x8c2b(%rip), %rsi      # 0x12fc0
callq 0x3240
jmp 0xa39c
movq 0x8c3d(%rip), %rdi      # 0x12fe0
leaq -0x20(%rbp), %rsi
callq 0x3060
jmp 0xa3ae
jmp 0xa329
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x3140
jmp 0xa3f8
xorl %eax, %eax
movl %eax, %esi
leaq -0x20(%rbp), %rdi
callq 0x33f0
movq %rax, -0x50(%rbp)
jmp 0xa3dd
movq -0x50(%rbp), %rax
movb (%rax), %al
movb %al, -0x51(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x3140
movb -0x51(%rbp), %al
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x33b0
nopw %cs:(%rax,%rax)
// File: JacobLCarter[P]2D-Portal/utils.cpp
// Function: setRange(int, int, int)
int setRange(int size, int lowerRange, int upperRange)
{
    int status = -1;

    //if the input is within the desired range and 0 is
    //allowed, set status to 0
    if (size >= lowerRange && size <= upperRange)
    {
        status = 0;
    }

    return status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl $0xffffffff, -0x10(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
cmpl -0x8(%rbp), %eax
jl 0xa43b
movl -0x4(%rbp), %eax
cmpl -0xc(%rbp), %eax
jg 0xa43b
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
popq %rbp
retq
// File: JacobLCarter[P]2D-Portal/utils.cpp
// Function: fillArray(int*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void fillArray(int *array, std::string filename)
{
    std::ifstream fins;
    fins.open(filename.c_str());
    
    std::string line;
    
    while (std::getline(fins, line))
    {
        line.erase(std::remove_if(line.begin(), line.end(), isspace), line.end());

        for (unsigned int i = 0; i < line.size(); i++)
        {
            int j = line[i] - '0'; 
            array[i] = j;
        }
    }
    fins.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2e0, %rsp            # imm = 0x2E0
movq %rsi, -0x298(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x218(%rbp), %rdi
movq %rdi, -0x290(%rbp)
callq 0x3290
movq -0x298(%rbp), %rdi
callq 0x30e0
movq -0x290(%rbp), %rdi
movq %rax, %rsi
movl $0x8, %edx
callq 0x3160
jmp 0xa48f
leaq -0x248(%rbp), %rdi
callq 0x3330
leaq -0x218(%rbp), %rdi
leaq -0x248(%rbp), %rsi
callq 0x3060
movq %rax, -0x2a0(%rbp)
jmp 0xa4b7
movq -0x2a0(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x32f0
movb %al, -0x2a1(%rbp)
jmp 0xa4d5
movb -0x2a1(%rbp), %al
testb $0x1, %al
jne 0xa4e4
jmp 0xa676
leaq -0x248(%rbp), %rdi
movq %rdi, -0x2b8(%rbp)
callq 0x31d0
movq -0x2b8(%rbp), %rdi
movq %rax, -0x260(%rbp)
callq 0x3130
movq %rax, -0x268(%rbp)
movq -0x260(%rbp), %rdi
movq -0x268(%rbp), %rsi
movq 0x8a8a(%rip), %rdx      # 0x12fb0
callq 0xaa90
movq %rax, -0x2b0(%rbp)
jmp 0xa534
movq -0x2b0(%rbp), %rax
movq %rax, -0x258(%rbp)
leaq -0x250(%rbp), %rdi
leaq -0x258(%rbp), %rsi
callq 0xaae0
leaq -0x248(%rbp), %rdi
movq %rdi, -0x2c8(%rbp)
callq 0x3130
movq %rax, -0x278(%rbp)
leaq -0x270(%rbp), %rdi
leaq -0x278(%rbp), %rsi
callq 0xaae0
movq -0x2c8(%rbp), %rdi
movq -0x250(%rbp), %rsi
movq -0x270(%rbp), %rdx
callq 0x3080
movq %rax, -0x2c0(%rbp)
jmp 0xa5a5
movq -0x2c0(%rbp), %rax
movq %rax, -0x280(%rbp)
movl $0x0, -0x284(%rbp)
movl -0x284(%rbp), %eax
movq %rax, -0x2d0(%rbp)
leaq -0x248(%rbp), %rdi
callq 0x3180
movq %rax, %rcx
movq -0x2d0(%rbp), %rax
cmpq %rcx, %rax
jae 0xa671
movl -0x284(%rbp), %eax
movl %eax, %esi
leaq -0x248(%rbp), %rdi
callq 0x33f0
movq %rax, -0x2d8(%rbp)
jmp 0xa606
movq -0x2d8(%rbp), %rax
movsbl (%rax), %eax
subl $0x30, %eax
movl %eax, -0x288(%rbp)
movl -0x288(%rbp), %edx
movq -0x8(%rbp), %rax
movl -0x284(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
movl -0x284(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x284(%rbp)
jmp 0xa5bd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
jmp 0xa6a5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
leaq -0x248(%rbp), %rdi
callq 0x3140
jmp 0xa6a5
jmp 0xa49b
leaq -0x218(%rbp), %rdi
callq 0x3070
jmp 0xa684
leaq -0x248(%rbp), %rdi
callq 0x3140
leaq -0x218(%rbp), %rdi
callq 0x3090
addq $0x2e0, %rsp            # imm = 0x2E0
popq %rbp
retq
leaq -0x218(%rbp), %rdi
callq 0x3090
movq -0x220(%rbp), %rdi
callq 0x33b0
nopl (%rax)
// File: JacobLCarter[P]2D-Portal/utils.cpp
// Function: printArray(int*, int)
void printArray(int *array, int s)
{
    int i = 0;
    
    while (i < s)
    {
        std::cout << array[i] << " ";
        i++;
    }
    std::cout << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xa70f
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %esi
movq 0x88e0(%rip), %rdi      # 0x12fd0
callq 0x33a0
movq %rax, %rdi
leaq 0x244c(%rip), %rsi      # 0xcb4b
callq 0x3210
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xa6d6
movq 0x88ba(%rip), %rdi      # 0x12fd0
movq 0x88a3(%rip), %rsi      # 0x12fc0
callq 0x3240
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: JacobLCarter[P]2D-Portal/utils.cpp
// Function: replay()
char replay()
{
    char choice;

    do
    {
        std::cout << std::endl;
        std::cout << "Would you like to play again? (y/n)" << std::endl;
        choice = getMenuChar();
    }
    while (choice != 'y' && choice !='n');

    return choice;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x8641(%rip), %rdi      # 0x12fd0
movq 0x862a(%rip), %rsi      # 0x12fc0
callq 0x3240
movq 0x862e(%rip), %rdi      # 0x12fd0
leaq 0x345b(%rip), %rsi      # 0xde04
callq 0x3210
movq %rax, %rdi
movq 0x8608(%rip), %rsi      # 0x12fc0
callq 0x3240
callq 0xa300
movb %al, -0x1(%rbp)
movsbl -0x1(%rbp), %ecx
xorl %eax, %eax
cmpl $0x79, %ecx
movb %al, -0x2(%rbp)
je 0xa9e0
movsbl -0x1(%rbp), %eax
cmpl $0x6e, %eax
setne %al
movb %al, -0x2(%rbp)
movb -0x2(%rbp), %al
testb $0x1, %al
jne 0xa988
movb -0x1(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
// File: JacobLCarter[P]2D-Portal/utils.cpp
// Function: selectionYN()
char selectionYN()
{
    char choice;

    do
    {
        std::cout << std::endl;
        std::cout << "Please enter yes or no? (y/n)" << std::endl;
        choice = getMenuChar();
    }
    while (choice != 'y' && choice != 'n');

    return choice;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x85d1(%rip), %rdi      # 0x12fd0
movq 0x85ba(%rip), %rsi      # 0x12fc0
callq 0x3240
movq 0x85be(%rip), %rdi      # 0x12fd0
leaq 0x340f(%rip), %rsi      # 0xde28
callq 0x3210
movq %rax, %rdi
movq 0x8598(%rip), %rsi      # 0x12fc0
callq 0x3240
callq 0xa300
movb %al, -0x1(%rbp)
movsbl -0x1(%rbp), %ecx
xorl %eax, %eax
cmpl $0x79, %ecx
movb %al, -0x2(%rbp)
je 0xaa50
movsbl -0x1(%rbp), %eax
cmpl $0x6e, %eax
setne %al
movb %al, -0x2(%rbp)
movb -0x2(%rbp), %al
testb $0x1, %al
jne 0xa9f8
movb -0x1(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
// File: vjeux[P]jspp/example/scope.cpp
// Function: main::$_4::operator()(Object, Object)
_(function (var $) {
	var global = "local";

	std::cout << "Inside:      $ = " << $ << std::endl;
	std::cout << "Inside: global = " << global << std::endl;

	// Inside:      $ = jQuery
	// Inside: global = local

	return undefined;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rcx, -0x98(%rbp)
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq 0x50a1(%rip), %rsi      # 0x101db
leaq -0x38(%rbp), %rdi
callq 0x7b00
movq 0xae8e(%rip), %rdi      # 0x15fd8
leaq 0x5090(%rip), %rsi      # 0x101e1
callq 0x21f0
movq %rax, -0x80(%rbp)
jmp 0xb15c
movq -0x98(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x7840
jmp 0xb16e
movq -0x80(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x2550
movq %rax, -0xa0(%rbp)
jmp 0xb184
movq -0xa0(%rbp), %rdi
movq 0xae36(%rip), %rsi      # 0x15fc8
callq 0x2240
jmp 0xb199
leaq -0x60(%rbp), %rdi
callq 0xb730
movq 0xae2f(%rip), %rdi      # 0x15fd8
leaq 0x5043(%rip), %rsi      # 0x101f3
callq 0x21f0
movq %rax, -0xa8(%rbp)
jmp 0xb1be
leaq -0x78(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x7840
jmp 0xb1cd
movq -0xa8(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x2550
movq %rax, -0xb0(%rbp)
jmp 0xb1e6
movq -0xb0(%rbp), %rdi
movq 0xadd4(%rip), %rsi      # 0x15fc8
callq 0x2240
jmp 0xb1fb
leaq -0x78(%rbp), %rdi
callq 0xb730
movq -0x90(%rbp), %rdi
leaq 0xaff6(%rip), %rsi      # 0x16208
callq 0x7840
jmp 0xb219
leaq -0x38(%rbp), %rdi
callq 0xb730
movq -0x88(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xb26c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xb730
jmp 0xb26c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x78(%rbp), %rdi
callq 0xb730
leaq -0x38(%rbp), %rdi
callq 0xb730
movq -0x40(%rbp), %rdi
callq 0x2340
nop
// File: cpirc[P]Monochrome/src/eval.cpp
// Function: int evaluate_mobility<(Piece)4>(Position const&)
int evaluate_mobility<QUEEN>(const Position& pos) {
    int score = 0;
    uint64_t pieces = get_piece(pos, QUEEN, US);

    while (pieces) {
        score += popcnt(attacks<QUEEN>(lsb(pieces), get_occupancy(pos))) *
                 mobility_weights[QUEEN];

        pieces &= pieces - 1;
    }

    return score;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl $0x4, %esi
xorl %edx, %edx
callq 0x3cf0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x3b98
movq -0x18(%rbp), %rdi
callq 0x3e50
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3ea0
movq %rax, %rsi
movb -0x19(%rbp), %al
movzbl %al, %edi
callq 0x3db0
movq %rax, %rdi
callq 0x3d40
imull 0xe520(%rip), %eax      # 0x120a0
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
subq $0x1, %rax
andq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x3b47
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: cpirc[P]Monochrome/src/eval.cpp
// Function: evaluate(Position&)
int evaluate(Position& pos) {
    int opening = 0, endgame = 0;
    int phase = material_phase<>(pos);
    Colour side;

    for (side = US; side <= THEM; ++side) {
        // material + PST
        opening += evaluate_material<>(pos) + evaluate_pst<OPENING>(pos);
        endgame += evaluate_material<>(pos) + evaluate_pst<ENDGAME>(pos);

        // King safety
        opening += king_safety(pos);

        opening += evaluate_mobility<>(pos);
        endgame += evaluate_mobility<>(pos);

        // Passed pawns
        opening += evaluate_passers(pos);
        endgame += evaluate_passers(pos);

        opening = -opening;
        endgame = -endgame;
        flip_position(pos);
    }

    int score = ((phase * opening) + ((24 - phase) * endgame)) / 24;

    return score;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3ec0
movl %eax, -0x14(%rbp)
movb $0x0, -0x15(%rbp)
movzbl -0x15(%rbp), %eax
cmpl $0x1, %eax
jg 0x3c9d
movq -0x8(%rbp), %rdi
callq 0x3f10
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3f60
movl %eax, %ecx
movl -0x24(%rbp), %eax
addl %ecx, %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3f10
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3fe0
movl %eax, %ecx
movl -0x20(%rbp), %eax
addl %ecx, %eax
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4060
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x40e0
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x40e0
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4180
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4180
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
xorl %eax, %eax
subl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
xorl %eax, %eax
subl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x42a0
leaq -0x15(%rbp), %rdi
callq 0x43d0
jmp 0x3bda
movl -0x14(%rbp), %eax
imull -0xc(%rbp), %eax
movl $0x18, %ecx
subl -0x14(%rbp), %ecx
imull -0x10(%rbp), %ecx
addl %ecx, %eax
movl $0x18, %ecx
cltd
idivl %ecx
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: cpirc[P]Monochrome/src/eval.cpp
// Function: int evaluate_pst<(Phase)0, (Piece)0>(Position const&)
inline int evaluate_pst(const Position& pos) {
    int score = 0;
    uint64_t pieces = get_piece(pos, p, US);

    while (pieces) {
        score += pst[p][ph][lsb(pieces)];

        pieces &= pieces - 1;
    }

    return score + evaluate_pst<ph, p + 1>(pos);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x3cf0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x3fbb
movq -0x18(%rbp), %rdi
callq 0x3e50
movzbl %al, %eax
movl %eax, %ecx
leaq 0xe150(%rip), %rax      # 0x120f0
movl (%rax,%rcx,4), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
subq $0x1, %rax
andq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x3f84
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4910
movl %eax, %ecx
movl -0x1c(%rbp), %eax
addl %ecx, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: cpirc[P]Monochrome/src/eval.cpp
// Function: king_safety(Position const&)
inline int king_safety(const Position& pos) {
    std::uint64_t king_bb = get_piece(pos, KING, US);
    Square king_sq = lsb(king_bb);
    std::uint64_t surrounding = attacks<KING>(king_sq, (std::uint64_t)0);

    int score = 0;

    // Nearby friendly pieces
    score += 5 * popcnt(surrounding & get_colour(pos, US));

    // Nearby unfriendly pieces
    // score -= 5*popcnt(surrounding & get_colour(pos, THEM));

    return score;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x5, %esi
xorl %edx, %edx
callq 0x3cf0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3e50
movb %al, -0x11(%rbp)
xorl %eax, %eax
movl %eax, %esi
movzbl -0x11(%rbp), %edi
callq 0x4440
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x4420
movq -0x30(%rbp), %rdi
andq %rax, %rdi
callq 0x3d40
imull $0x5, %eax, %eax
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: cpirc[P]Monochrome/src/eval.cpp
// Function: int evaluate_mobility<(Piece)1>(Position const&)
int evaluate_mobility(const Position& pos) {
    int score = 0;
    uint64_t pieces = get_piece(pos, p, US);

    while (pieces) {
        score += popcnt(attacks<p>(lsb(pieces), get_occupancy(pos))) *
                 mobility_weights[p];

        pieces &= pieces - 1;
    }

    return score + evaluate_mobility<p + 1>(pos);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x3cf0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x4158
movq -0x18(%rbp), %rdi
callq 0x3e50
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3ea0
movq %rax, %rsi
movb -0x19(%rbp), %al
movzbl %al, %edi
callq 0x4df0
movq %rax, %rdi
callq 0x3d40
imull 0xdf54(%rip), %eax      # 0x12094
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
subq $0x1, %rax
andq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x4107
movl -0xc(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4e20
movl %eax, %ecx
movl -0x20(%rbp), %eax
addl %ecx, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: cpirc[P]Monochrome/src/eval.cpp
// Function: evaluate_passers(Position const&)
inline int evaluate_passers(const Position& pos) {
    int score = 0;
    std::uint64_t pawns = get_piece(pos, PAWN, US);

    while (pawns) {
        int sq = lsb(pawns);
        int rank = sq >> 3;
        int file = sq & 7;  // Do we have a macro for this?

        std::uint64_t mask = 0;

        mask |= 0x0101010101010101ULL << (sq + 8);

        if (file >= 1) {
            mask |= 0x0101010101010101ULL << (sq + 7);
        }

        if (file <= 6) {
            mask |= 0x0101010101010101ULL << (sq + 9);
        }

        if (!(mask & get_piece(pos, PAWN, THEM))) {
            score += passed_pawn_bonus[rank];
        }

        pawns &= pawns - 1;
    }

    return score;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x3cf0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x4292
movq -0x18(%rbp), %rdi
callq 0x3e50
movzbl %al, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
sarl $0x3, %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
andl $0x7, %eax
movl %eax, -0x24(%rbp)
movq $0x0, -0x30(%rbp)
movl -0x1c(%rbp), %eax
addl $0x8, %eax
movl %eax, %eax
movl %eax, %ecx
movabsq $0x101010101010101, %rax # imm = 0x101010101010101
shlq %cl, %rax
orq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpl $0x1, -0x24(%rbp)
jl 0x421c
movl -0x1c(%rbp), %eax
addl $0x7, %eax
movl %eax, %eax
movl %eax, %ecx
movabsq $0x101010101010101, %rax # imm = 0x101010101010101
shlq %cl, %rax
orq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpl $0x6, -0x24(%rbp)
jg 0x4241
movl -0x1c(%rbp), %eax
addl $0x9, %eax
movl %eax, %eax
movl %eax, %ecx
movabsq $0x101010101010101, %rax # imm = 0x101010101010101
shlq %cl, %rax
orq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x3cf0
movq %rax, %rcx
movq -0x38(%rbp), %rax
andq %rcx, %rax
cmpq $0x0, %rax
jne 0x427d
movslq -0x20(%rbp), %rcx
leaq 0xde3c(%rip), %rax      # 0x120b0
movl (%rax,%rcx,4), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
subq $0x1, %rax
andq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x41a4
movl -0xc(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: cpirc[P]Monochrome/src/position.h
// Function: flip_position(Position&)
inline void flip_position(Position& pos) {
    // Flip piece bitboards
    std::uint64_t* curr;
    for (curr = pos.pieces; curr < pos.pieces + 6; ++curr) *curr = bswap(*curr);

    // Reverse colour bitboards
    std::uint64_t tmp = pos.colours[1];
    pos.colours[1] = pos.colours[0];
    pos.colours[0] = tmp;

    // Flip colour bitboards
    for (curr = pos.colours; curr < pos.colours + 2; ++curr)
        *curr = bswap(*curr);

    // Flip epsq
    if (pos.epsq != INVALID_SQUARE) pos.epsq = Square(int(pos.epsq) ^ 56);

    // Flip castling rights
    std::uint8_t tmp2 = (pos.castle & 3) << 2;
    pos.castle >>= 2;
    pos.castle ^= tmp2;

    // Flip flipped
    pos.flipped = !pos.flipped;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
addq $0x30, %rcx
cmpq %rcx, %rax
jae 0x42e9
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x4470
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
jmp 0x42b4
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
addq $0x30, %rcx
addq $0x10, %rcx
cmpq %rcx, %rax
jae 0x4356
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x4470
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
jmp 0x431d
movq -0x8(%rbp), %rax
movzbl 0x42(%rax), %eax
cmpl $0x40, %eax
je 0x4377
movq -0x8(%rbp), %rax
movzbl 0x42(%rax), %eax
xorl $0x38, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x42(%rax)
movq -0x8(%rbp), %rax
movzbl 0x40(%rax), %eax
andl $0x3, %eax
shll $0x2, %eax
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x40(%rax), %ecx
sarl $0x2, %ecx
movb %cl, 0x40(%rax)
movzbl -0x19(%rbp), %edx
movq -0x8(%rbp), %rax
movzbl 0x40(%rax), %ecx
xorl %edx, %ecx
movb %cl, 0x40(%rax)
movq -0x8(%rbp), %rax
movb 0x41(%rax), %cl
xorb $-0x1, %cl
movq -0x8(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x41(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: cpirc[P]Monochrome/src/eval.cpp
// Function: int evaluate_pst<(Phase)0, (Piece)5>(Position const&)
inline int evaluate_pst<OPENING, KING>(const Position& pos) {
    int score = 0;
    uint64_t pieces = get_piece(pos, KING, US);

    while (pieces) {
        score += pst[KING][OPENING][lsb(pieces)];

        pieces &= pieces - 1;
    }

    return score;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl $0x5, %esi
xorl %edx, %edx
callq 0x3cf0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x4b72
movq -0x18(%rbp), %rdi
callq 0x3e50
movzbl %al, %eax
movl %eax, %ecx
leaq 0xd59d(%rip), %rax      # 0x120f0
movl 0xa00(%rax,%rcx,4), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
subq $0x1, %rax
andq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x4b37
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: cpirc[P]Monochrome/src/eval.cpp
// Function: int evaluate_pst<(Phase)1, (Piece)5>(Position const&)
inline int evaluate_pst<ENDGAME, KING>(const Position& pos) {
    int score = 0;
    uint64_t pieces = get_piece(pos, KING, US);

    while (pieces) {
        score += pst[KING][ENDGAME][lsb(pieces)];

        pieces &= pieces - 1;
    }

    return score;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl $0x5, %esi
xorl %edx, %edx
callq 0x3cf0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x4de2
movq -0x18(%rbp), %rdi
callq 0x3e50
movzbl %al, %eax
movl %eax, %ecx
leaq 0xd32d(%rip), %rax      # 0x120f0
movl 0xb00(%rax,%rcx,4), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
subq $0x1, %rax
andq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x4da7
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: cpirc[P]Monochrome/src/main.cpp
// Function: main
int main() {
    seed_rng(17594872);
    init_keys();
    init_bitboards();

    std::setbuf(stdout, NULL);
    std::setbuf(stdin, NULL);

    std::string line;
    while (true) {
        std::getline(std::cin, line);
        if (line == "uci") {
            UCI::listen();
            break;
        } else if (line == "xboard") {
            std::cout << "Protocol not supported" << std::endl;
        } else if (line == "quit") {
            break;
        } else {
            std::cout << "Unknown protocol" << std::endl;
        }
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl $0x0, -0x4(%rbp)
movl $0x10c79f8, %edi        # imm = 0x10C79F8
callq 0x58a0
callq 0x9930
callq 0x36d0
movq 0x15846(%rip), %rax     # 0x1afa0
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x32b0
movq 0x1585b(%rip), %rax     # 0x1afc8
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x32b0
leaq -0x28(%rbp), %rdi
callq 0x3290
jmp 0x5784
movq 0x15855(%rip), %rdi     # 0x1afe0
leaq -0x28(%rbp), %rsi
callq 0x3060
jmp 0x5796
leaq 0xe083(%rip), %rsi      # 0x13820
leaq -0x28(%rbp), %rdi
callq 0x58d0
movb %al, -0x35(%rbp)
jmp 0x57ab
movb -0x35(%rbp), %al
testb $0x1, %al
jne 0x57b4
jmp 0x57da
callq 0x10480
jmp 0x57bb
jmp 0x587b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3120
jmp 0x5894
leaq 0xe043(%rip), %rsi      # 0x13824
leaq -0x28(%rbp), %rdi
callq 0x58d0
movb %al, -0x36(%rbp)
jmp 0x57ef
movb -0x36(%rbp), %al
testb $0x1, %al
jne 0x57f8
jmp 0x5825
movq 0x157d1(%rip), %rdi     # 0x1afd0
leaq 0xe025(%rip), %rsi      # 0x1382b
callq 0x31e0
movq %rax, -0x40(%rbp)
jmp 0x5811
movq -0x40(%rbp), %rdi
movq 0x15794(%rip), %rsi     # 0x1afb0
callq 0x3200
jmp 0x5823
jmp 0x5874
leaq 0xe016(%rip), %rsi      # 0x13842
leaq -0x28(%rbp), %rdi
callq 0x58d0
movb %al, -0x41(%rbp)
jmp 0x583a
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x5843
jmp 0x5845
jmp 0x587b
movq 0x15784(%rip), %rdi     # 0x1afd0
leaq 0xdff4(%rip), %rsi      # 0x13847
callq 0x31e0
movq %rax, -0x50(%rbp)
jmp 0x585e
movq -0x50(%rbp), %rdi
movq 0x15747(%rip), %rsi     # 0x1afb0
callq 0x3200
jmp 0x5870
jmp 0x5872
jmp 0x5874
jmp 0x5876
jmp 0x5782
movl $0x0, -0x4(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3120
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x3350
nopl (%rax)
// File: cpirc[P]Monochrome/src/move.cpp
// Function: move_to_lan(char*, unsigned int)
void move_to_lan(char* lan_str, const Move move) {
    assert(lan_str);

    Square from = from_square(move), to = to_square(move);

    lan_str[0] = square_str[(std::size_t)from][0];
    lan_str[1] = square_str[(std::size_t)from][1];

    lan_str[2] = square_str[(std::size_t)to][0];
    lan_str[3] = square_str[(std::size_t)to][1];

    if (promotion_type(move)) {
        switch (promotion_type(move)) {
            case KNIGHT:
                lan_str[4] = 'n';
                break;
            case BISHOP:
                lan_str[4] = 'b';
                break;
            case ROOK:
                lan_str[4] = 'r';
                break;
            case QUEEN:
                lan_str[4] = 'q';
                break;
            default:
                break;
        }
        lan_str[5] = '\0';
    } else
        lan_str[4] = '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5cb8
jmp 0x5cd7
leaq 0xdc01(%rip), %rdi      # 0x138c0
leaq 0xdc02(%rip), %rsi      # 0x138c8
movl $0x7a, %edx
leaq 0xdc03(%rip), %rcx      # 0x138d5
callq 0x3150
movl -0xc(%rbp), %edi
callq 0x66b0
movb %al, -0xd(%rbp)
movl -0xc(%rbp), %edi
callq 0x66c0
movb %al, -0xe(%rbp)
movzbl -0xd(%rbp), %eax
movl %eax, %ecx
leaq 0x154e6(%rip), %rax     # 0x1b1e0
movq (%rax,%rcx,8), %rax
movb (%rax), %cl
movq -0x8(%rbp), %rax
movb %cl, (%rax)
movzbl -0xd(%rbp), %eax
movl %eax, %ecx
leaq 0x154cd(%rip), %rax     # 0x1b1e0
movq (%rax,%rcx,8), %rax
movb 0x1(%rax), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x1(%rax)
movzbl -0xe(%rbp), %eax
movl %eax, %ecx
leaq 0x154b2(%rip), %rax     # 0x1b1e0
movq (%rax,%rcx,8), %rax
movb (%rax), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x2(%rax)
movzbl -0xe(%rbp), %eax
movl %eax, %ecx
leaq 0x15498(%rip), %rax     # 0x1b1e0
movq (%rax,%rcx,8), %rax
movb 0x1(%rax), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x3(%rax)
movl -0xc(%rbp), %edi
callq 0x68f0
cmpb $0x0, %al
je 0x5dc2
movl -0xc(%rbp), %edi
callq 0x68f0
movzbl %al, %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x3, %eax
ja 0x5db6
movq -0x18(%rbp), %rax
leaq 0xdadb(%rip), %rcx      # 0x13860
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rax
movb $0x6e, 0x4(%rax)
jmp 0x5db8
movq -0x8(%rbp), %rax
movb $0x62, 0x4(%rax)
jmp 0x5db8
movq -0x8(%rbp), %rax
movb $0x72, 0x4(%rax)
jmp 0x5db8
movq -0x8(%rbp), %rax
movb $0x71, 0x4(%rax)
jmp 0x5db8
jmp 0x5db8
movq -0x8(%rbp), %rax
movb $0x0, 0x5(%rax)
jmp 0x5dca
movq -0x8(%rbp), %rax
movb $0x0, 0x4(%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: cpirc[P]Monochrome/src/move.cpp
// Function: run_move_to_lan_tests()
void run_move_to_lan_tests(void) {
    char str[6];

    move_to_lan(str, get_move(H2, H1, PROMOTION, TO_ROOK));
    printf("%s\n", str);
    move_to_lan(str, get_move(A5, C7, NORMAL));
    printf("%s\n", str);
    move_to_lan(str, get_move(G7, G8, PROMOTION, TO_BISHOP));
    printf("%s\n", str);
    move_to_lan(str, get_move(E7, E8, PROMOTION, TO_QUEEN));
    printf("%s\n", str);
    move_to_lan(str, get_move(F2, F1, PROMOTION, TO_KNIGHT));
    printf("%s\n", str);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq -0x6(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0xf, %edi
movl $0x7, %esi
movl $0x4000, %edx           # imm = 0x4000
movl $0x18000, %ecx          # imm = 0x18000
callq 0x69a0
movq -0x30(%rbp), %rdi
movl %eax, %esi
callq 0x5ca0
leaq -0x6(%rbp), %rsi
leaq 0xe419(%rip), %rdi      # 0x14228
movb $0x0, %al
callq 0x3030
leaq -0x6(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x20, %edi
movl $0x32, %esi
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x69a0
movq -0x28(%rbp), %rdi
movl %eax, %esi
callq 0x5ca0
leaq -0x6(%rbp), %rsi
leaq 0xe3e1(%rip), %rdi      # 0x14228
movb $0x0, %al
callq 0x3030
leaq -0x6(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x36, %edi
movl $0x3e, %esi
movl $0x4000, %edx           # imm = 0x4000
movl $0x10000, %ecx          # imm = 0x10000
callq 0x69a0
movq -0x20(%rbp), %rdi
movl %eax, %esi
callq 0x5ca0
leaq -0x6(%rbp), %rsi
leaq 0xe3a3(%rip), %rdi      # 0x14228
movb $0x0, %al
callq 0x3030
leaq -0x6(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x34, %edi
movl $0x3c, %esi
movl $0x4000, %edx           # imm = 0x4000
movl $0x20000, %ecx          # imm = 0x20000
callq 0x69a0
movq -0x18(%rbp), %rdi
movl %eax, %esi
callq 0x5ca0
leaq -0x6(%rbp), %rsi
leaq 0xe365(%rip), %rdi      # 0x14228
movb $0x0, %al
callq 0x3030
leaq -0x6(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0xd, %edi
movl $0x5, %esi
movl $0x4000, %edx           # imm = 0x4000
movl $0x8000, %ecx           # imm = 0x8000
callq 0x69a0
movq -0x10(%rbp), %rdi
movl %eax, %esi
callq 0x5ca0
leaq -0x6(%rbp), %rsi
leaq 0xe327(%rip), %rdi      # 0x14228
movb $0x0, %al
callq 0x3030
addq $0x30, %rsp
popq %rbp
retq
nop
// File: cpirc[P]Monochrome/src/move.cpp
// Function: pv_verify(Position const&, std::vector<unsigned int, std::allocator<unsigned int>>&)
bool pv_verify(const Position& pos, PV& pv) {
    Position npos = pos;
    Move moves[256];

    for (const auto& pv_move : pv) {
        bool found = false;

        int movecount = generate(npos, moves);
        for (int i = 0; i < movecount; i++) {
            if (pv_move == moves[i]) {
                make_move(npos, pv_move);
                found = true;
                break;
            }
        }

        if (!found) {
            return false;
        }
    }

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x4c0, %rsp            # imm = 0x4C0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x6a30
movq -0x18(%rbp), %rax
movq %rax, -0x488(%rbp)
movq -0x488(%rbp), %rdi
callq 0x6a80
movq %rax, -0x490(%rbp)
movq -0x488(%rbp), %rdi
callq 0x6ab0
movq %rax, -0x498(%rbp)
leaq -0x490(%rbp), %rdi
leaq -0x498(%rbp), %rsi
callq 0x6ae0
testb $0x1, %al
jne 0x613d
jmp 0x6225
leaq -0x490(%rbp), %rdi
callq 0x6b20
movq %rax, -0x4a0(%rbp)
movb $0x0, -0x4a1(%rbp)
leaq -0x80(%rbp), %rdi
leaq -0x480(%rbp), %rsi
callq 0x8b20
movl %eax, -0x4c0(%rbp)
jmp 0x616f
movl -0x4c0(%rbp), %eax
movl %eax, -0x4a8(%rbp)
movl $0x0, -0x4b8(%rbp)
movl -0x4b8(%rbp), %eax
cmpl -0x4a8(%rbp), %eax
jge 0x61f9
movq -0x4a0(%rbp), %rax
movl (%rax), %eax
movslq -0x4b8(%rbp), %rcx
cmpl -0x480(%rbp,%rcx,4), %eax
jne 0x61e6
movq -0x4a0(%rbp), %rax
movl (%rax), %esi
leaq -0x80(%rbp), %rdi
callq 0x5900
jmp 0x61c0
movb $0x1, -0x4a1(%rbp)
jmp 0x61f9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x4b0(%rbp)
movl %eax, -0x4b4(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x6b60
jmp 0x624a
jmp 0x61e8
movl -0x4b8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4b8(%rbp)
jmp 0x6185
testb $0x1, -0x4a1(%rbp)
jne 0x6212
movb $0x0, -0x1(%rbp)
movl $0x1, -0x4bc(%rbp)
jmp 0x6233
jmp 0x6214
leaq -0x490(%rbp), %rdi
callq 0x6b40
jmp 0x6121
movb $0x1, -0x1(%rbp)
movl $0x1, -0x4bc(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x6b60
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x4c0, %rsp            # imm = 0x4C0
popq %rbp
retq
movq -0x4b0(%rbp), %rdi
callq 0x3350
nopw %cs:(%rax,%rax)
// File: cpirc[P]Monochrome/src/position.h
// Function: move_piece(Position&, Square, Square, Piece, Colour)
inline void move_piece(Position& pos, const Square from, const Square to,
                       const Piece piece, const Colour colour) {
    assert(from != to);
    std::uint64_t from_to = (1ULL << from) ^ (1ULL << to);
    pos.pieces[piece] ^= from_to;
    pos.colours[colour] ^= from_to;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movb %sil, -0x9(%rbp)
movb %dl, -0xa(%rbp)
movb %cl, -0xb(%rbp)
movb %al, -0xc(%rbp)
movzbl -0x9(%rbp), %eax
movzbl -0xa(%rbp), %ecx
cmpl %ecx, %eax
je 0x672a
jmp 0x6749
leaq 0xd292(%rip), %rdi      # 0x139c3
leaq 0xd296(%rip), %rsi      # 0x139ce
movl $0x77, %edx
leaq 0xd299(%rip), %rcx      # 0x139dd
callq 0x3150
movzbl -0x9(%rbp), %eax
movl %eax, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movzbl -0xa(%rbp), %ecx
movl %ecx, %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
xorq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
movzbl -0xb(%rbp), %ecx
xorq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
movzbl -0xc(%rbp), %ecx
xorq 0x30(%rax,%rcx,8), %rdx
movq %rdx, 0x30(%rax,%rcx,8)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: cpirc[P]Monochrome/src/position.h
// Function: is_checked(Position const&, Colour)
inline bool is_checked(const Position& pos, const Colour c) {
    Colour by = (c == US ? THEM : US);
    return (attacks_to(pos, lsb(get_piece(pos, KING, c)), get_occupancy(pos),
                       c) &
            get_colour(pos, by)) > std::uint64_t(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movzbl -0x9(%rbp), %ecx
movb $0x1, %al
xorl %edx, %edx
movb %dl, -0xc(%rbp)
cmpl $0x0, %ecx
movb %al, -0xb(%rbp)
je 0x6bab
movb -0xc(%rbp), %al
movb %al, -0xb(%rbp)
movb -0xb(%rbp), %al
movb %al, -0xa(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl $0x5, %esi
movzbl -0x9(%rbp), %edx
callq 0x3cf0
movq %rax, %rdi
callq 0x3e50
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3ea0
movq -0x28(%rbp), %rdi
movq %rax, %rdx
movb -0x19(%rbp), %al
movzbl %al, %esi
movzbl -0x9(%rbp), %ecx
callq 0x7560
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movzbl -0xa(%rbp), %esi
callq 0x4420
movq %rax, %rcx
movq -0x18(%rbp), %rax
andq %rcx, %rax
cmpq $0x0, %rax
seta %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: cpirc[P]Monochrome/src/move_gen.cpp
// Function: void add_moves<true, (Piece)5>(Position const&, unsigned int*, int&)
void add_moves<true, KING>(const Position& pos, Move* ml, int& idx) {
    std::uint64_t occ = get_colour(pos, US) | get_colour(pos, THEM);

    Square from = lsb(get_piece(pos, KING, US));

    std::uint64_t attack_bb = attacks<KING>(from, occ) & get_colour(pos, THEM);

    while (attack_bb) {
        Square dest = lsb(attack_bb);

        ml[idx] = get_move(from, dest, CAPTURE);
        idx++;

        attack_bb &= attack_bb - 1;
    }

    // No tail call to end template recursion.
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x4420
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x4420
movq %rax, %rcx
movq -0x48(%rbp), %rax
orq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl $0x5, %esi
xorl %edx, %edx
callq 0x3cf0
movq %rax, %rdi
callq 0x3e50
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
movq -0x20(%rbp), %rsi
movzbl %al, %edi
callq 0x4440
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x4420
movq %rax, %rcx
movq -0x40(%rbp), %rax
andq %rcx, %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x8b0f
movq -0x30(%rbp), %rdi
callq 0x3e50
movb %al, -0x31(%rbp)
movb -0x21(%rbp), %al
movl $0x2000, %edx           # imm = 0x2000
xorl %ecx, %ecx
movzbl %al, %edi
movzbl -0x31(%rbp), %esi
callq 0x69a0
movl %eax, %edx
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x30(%rbp), %rax
subq $0x1, %rax
andq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x8ab9
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: cpirc[P]Monochrome/src/move_gen.cpp
// Function: generate(Position const&, unsigned int*)
int generate(const Position& pos, Move* ml) {
    int idx = 0;

    add_moves<true>(pos, ml, idx);
    add_moves<false>(pos, ml, idx);

    return idx;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x14(%rbp), %rdx
callq 0x8350
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x14(%rbp), %rdx
callq 0x80b0
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: cpirc[P]Monochrome/src/move_gen.cpp
// Function: void add_moves<false, (Piece)1>(Position const&, unsigned int*, int&)
void add_moves(const Position& pos, Move* ml, int& idx) {
    std::uint64_t pieces = get_piece(pos, pc, US);
    std::uint64_t occ = get_occupancy(pos);
    std::uint64_t capturemask = (captures) ? get_colour(pos, THEM) : ~occ;
    MoveType mt = captures ? CAPTURE : NORMAL;

    while (pieces) {
        Square from = lsb(pieces);

        std::uint64_t attack_bb = attacks<pc>(from, occ) & capturemask;

        while (attack_bb) {
            Square dest = lsb(attack_bb);

            ml[idx] = get_move(from, dest, mt);
            idx++;

            attack_bb &= attack_bb - 1;
        }

        pieces &= pieces - 1;
    }

    add_moves<captures, pc + 1>(pos, ml, idx);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x3cf0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3ea0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
xorq $-0x1, %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x8c93
movq -0x20(%rbp), %rdi
callq 0x3e50
movb %al, -0x35(%rbp)
movb -0x35(%rbp), %al
movq -0x28(%rbp), %rsi
movzbl %al, %edi
callq 0x4df0
andq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x8c7e
movq -0x40(%rbp), %rdi
callq 0x3e50
movb %al, -0x41(%rbp)
movb -0x35(%rbp), %sil
movb -0x41(%rbp), %al
movl -0x34(%rbp), %edx
xorl %ecx, %ecx
movzbl %sil, %edi
movzbl %al, %esi
callq 0x69a0
movl %eax, %edx
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x40(%rbp), %rax
subq $0x1, %rax
andq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x8c26
movq -0x20(%rbp), %rax
subq $0x1, %rax
andq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x8bf8
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x8db0
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: cpirc[P]Monochrome/src/perft.cpp
// Function: perft(Position const&, int)
std::uint64_t perft(const Position& pos, const int depth) {
    if (depth == 0) {
        return 1;
    }

    uint64_t nodes = 0;
    Move moves[256];
    int movecount = generate(pos, moves);

    for (int i = 0; i < movecount; i++) {
        Position npos = pos;

        make_move(npos, moves[i]);
        if (is_checked(npos, THEM)) continue;

        nodes += perft(npos, depth - 1);
    }

    return nodes;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x4c0, %rsp            # imm = 0x4C0
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x93d5
movq $0x1, -0x8(%rbp)
jmp 0x94fe
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x420(%rbp), %rsi
callq 0x8b20
movl %eax, -0x424(%rbp)
movl $0x0, -0x428(%rbp)
movl -0x428(%rbp), %eax
cmpl -0x424(%rbp), %eax
jge 0x94f6
movq -0x10(%rbp), %rsi
leaq -0x490(%rbp), %rdi
movq %rdi, -0x4a8(%rbp)
callq 0x6a30
movq -0x4a8(%rbp), %rdi
movslq -0x428(%rbp), %rax
movl -0x420(%rbp,%rax,4), %esi
callq 0x5900
jmp 0x9442
leaq -0x490(%rbp), %rdi
movl $0x1, %esi
callq 0x6b80
movb %al, -0x4a9(%rbp)
jmp 0x945b
movb -0x4a9(%rbp), %al
testb $0x1, %al
jne 0x9467
jmp 0x9493
movl $0x4, -0x4a0(%rbp)
jmp 0x94c6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x498(%rbp)
movl %eax, -0x49c(%rbp)
leaq -0x490(%rbp), %rdi
callq 0x6b60
jmp 0x950b
movl -0x14(%rbp), %esi
decl %esi
leaq -0x490(%rbp), %rdi
callq 0x93b0
movq %rax, -0x4b8(%rbp)
jmp 0x94ad
movq -0x4b8(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x4a0(%rbp)
leaq -0x490(%rbp), %rdi
callq 0x6b60
movl -0x4a0(%rbp), %eax
testl %eax, %eax
je 0x94e0
jmp 0x94de
jmp 0x94e2
jmp 0x94e2
movl -0x428(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x428(%rbp)
jmp 0x93fd
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x4c0, %rsp            # imm = 0x4C0
popq %rbp
retq
movq -0x498(%rbp), %rdi
callq 0x3350
nopw (%rax,%rax)
// File: cpirc[P]Monochrome/src/perft.cpp
// Function: perft_tt(TT*, Position const&, int)
std::uint64_t perft_tt(TT* tt, const Position& pos, const int depth) {
    assert(tt);

    if (depth == 0) {
        return 1;
    }

    TTEntry entry = tt_poll(tt, pos.hash_key);
    if (entry.hash_key == pos.hash_key && tt_depth(entry.data) == depth) {
        return tt_nodes(entry.data);
    }

    uint64_t nodes = 0;
    Move moves[256];
    int movecount = generate(pos, moves);
    for (int i = 0; i < movecount; i++) {
        Position npos = pos;

        make_move(npos, moves[i]);
        if (is_checked(npos, THEM)) continue;

        nodes += perft_tt(tt, npos, depth - 1);
    }

    tt_add_perft(tt, pos.hash_key, depth, nodes);

    return nodes;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x4e0, %rsp            # imm = 0x4E0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x953f
jmp 0x955e
leaq 0xa64a(%rip), %rdi      # 0x13b90
leaq 0xa646(%rip), %rsi      # 0x13b93
movl $0x38, %edx
leaq 0xa648(%rip), %rcx      # 0x13ba1
callq 0x3150
cmpl $0x0, -0x1c(%rbp)
jne 0x9571
movq $0x1, -0x8(%rbp)
jmp 0x9702
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rsi
callq 0xf300
movq %rax, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x48(%rcx), %rax
jne 0x95ba
movq -0x30(%rbp), %rdi
callq 0x97d0
cmpl -0x1c(%rbp), %eax
jne 0x95ba
movq -0x30(%rbp), %rdi
callq 0x9850
cltq
movq %rax, -0x8(%rbp)
jmp 0x9702
movq $0x0, -0x38(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x440(%rbp), %rsi
callq 0x8b20
movl %eax, -0x444(%rbp)
movl $0x0, -0x448(%rbp)
movl -0x448(%rbp), %eax
cmpl -0x444(%rbp), %eax
jge 0x96e2
movq -0x18(%rbp), %rsi
leaq -0x4b0(%rbp), %rdi
movq %rdi, -0x4c8(%rbp)
callq 0x6a30
movq -0x4c8(%rbp), %rdi
movslq -0x448(%rbp), %rax
movl -0x440(%rbp,%rax,4), %esi
callq 0x5900
jmp 0x9627
leaq -0x4b0(%rbp), %rdi
movl $0x1, %esi
callq 0x6b80
movb %al, -0x4c9(%rbp)
jmp 0x9640
movb -0x4c9(%rbp), %al
testb $0x1, %al
jne 0x964c
jmp 0x967b
movl $0x4, -0x4c0(%rbp)
jmp 0x96b2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x4b8(%rbp)
movl %eax, -0x4bc(%rbp)
leaq -0x4b0(%rbp), %rdi
callq 0x6b60
jmp 0x970f
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %edx
decl %edx
leaq -0x4b0(%rbp), %rsi
callq 0x9520
movq %rax, -0x4d8(%rbp)
jmp 0x9699
movq -0x4d8(%rbp), %rax
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x4c0(%rbp)
leaq -0x4b0(%rbp), %rdi
callq 0x6b60
movl -0x4c0(%rbp), %eax
testl %eax, %eax
je 0x96cc
jmp 0x96ca
jmp 0x96ce
jmp 0x96ce
movl -0x448(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x448(%rbp)
jmp 0x95e2
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rsi
movl -0x1c(%rbp), %edx
movq -0x38(%rbp), %rcx
callq 0xf670
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x4e0, %rsp            # imm = 0x4E0
popq %rbp
retq
movq -0x4b8(%rbp), %rdi
callq 0x3350
nopl (%rax,%rax)
// File: cpirc[P]Monochrome/src/perft.cpp
// Function: run_perft_tests()
void run_perft_tests() {
    Position pos;
    parse_fen_to_position((const char*)"r3k2r/Pppp1ppp/1b3nbN/nP6/BBP1P3/q4N2/Pp1P2PP/R2Q1RK1 w kq - 0 1", pos);
    for (int i = 1; i <= 6; i++) {
        std::printf("Perft(%d) = %" PRIu64 "\n", i, perft(pos, i));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
leaq -0x68(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x9870
movq -0x80(%rbp), %rsi
leaq 0xa498(%rip), %rdi      # 0x13bdb
callq 0x9b80
jmp 0x974a
movl $0x1, -0x78(%rbp)
cmpl $0x6, -0x78(%rbp)
jg 0x97b3
movl -0x78(%rbp), %esi
movl %esi, -0x8c(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x93b0
movq %rax, -0x88(%rbp)
jmp 0x9772
movq -0x88(%rbp), %rdx
movl -0x8c(%rbp), %esi
leaq 0xa496(%rip), %rdi      # 0x13c1c
xorl %eax, %eax
callq 0x3030
jmp 0x978f
jmp 0x9791
movl -0x78(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x78(%rbp)
jmp 0x9751
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x6b60
jmp 0x97c5
leaq -0x68(%rbp), %rdi
callq 0x6b60
addq $0x90, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x3350
nop