LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: chulchultrain[P]FactoryHead/BattleEvaluator/BattleEvaluator.cpp
// Function: BattleEvaluator::Evaluate(int, int)
void BattleEvaluator::Evaluate(int i, int j) {

		
	for(int x = 0; x < 4; x++) {
		res[i][j][x].damage = participants[i].getMoveDamageRange(participants[j],x);
		res[i][j][x].participants = make_pair(participants[i].getName(),participants[j].getName() );
		res[i][j][x].moveName = participants[i].getMove(x).name;
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp            # imm = 0x160
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x140(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x4, -0x14(%rbp)
jge 0x2704b
movq -0x140(%rbp), %rdi
addq $0x1b8, %rdi            # imm = 0x1B8
movq %rdi, -0x148(%rbp)
movslq -0xc(%rbp), %rsi
callq 0x27460
movq -0x148(%rbp), %rdi
movq %rax, -0x150(%rbp)
movslq -0x10(%rbp), %rsi
callq 0x27460
movq -0x150(%rbp), %rdi
movq %rax, %rsi
movl -0x14(%rbp), %edx
callq 0x1d570
movq -0x140(%rbp), %rdi
movq %rax, -0x1c(%rbp)
addq $0x1d0, %rdi            # imm = 0x1D0
movslq -0xc(%rbp), %rsi
callq 0x275e0
movq %rax, %rdi
movslq -0x10(%rbp), %rsi
callq 0x27600
movq %rax, %rdi
movslq -0x14(%rbp), %rsi
callq 0x25960
movq %rax, %rdi
addq $0x60, %rdi
leaq -0x1c(%rbp), %rsi
callq 0x27620
movq -0x148(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x27460
movq %rax, %rsi
leaq -0x80(%rbp), %rdi
callq 0x1d330
movq -0x148(%rbp), %rdi
movslq -0x10(%rbp), %rsi
callq 0x27460
movq %rax, %rsi
leaq -0xa0(%rbp), %rdi
callq 0x1d330
jmp 0x26f08
leaq -0x60(%rbp), %rdi
leaq -0x80(%rbp), %rsi
leaq -0xa0(%rbp), %rdx
callq 0x27650
jmp 0x26f1e
movq -0x140(%rbp), %rdi
addq $0x1d0, %rdi            # imm = 0x1D0
movslq -0xc(%rbp), %rsi
callq 0x275e0
movq %rax, %rdi
movslq -0x10(%rbp), %rsi
callq 0x27600
movq %rax, %rdi
movslq -0x14(%rbp), %rsi
callq 0x25960
movq %rax, %rdi
leaq -0x60(%rbp), %rsi
callq 0x27690
leaq -0x60(%rbp), %rdi
callq 0x25c00
leaq -0xa0(%rbp), %rdi
callq 0x3180
leaq -0x80(%rbp), %rdi
callq 0x3180
movq -0x140(%rbp), %rdi
addq $0x1b8, %rdi            # imm = 0x1B8
movslq -0xc(%rbp), %rsi
callq 0x27460
movq %rax, %rsi
movl -0x14(%rbp), %edx
leaq -0x138(%rbp), %rdi
callq 0x1d360
movq -0x140(%rbp), %rdi
leaq -0x138(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x158(%rbp)
addq $0x1d0, %rdi            # imm = 0x1D0
movslq -0xc(%rbp), %rsi
callq 0x275e0
movq %rax, %rdi
movslq -0x10(%rbp), %rsi
callq 0x27600
movq %rax, %rdi
movslq -0x14(%rbp), %rsi
callq 0x25960
movq -0x158(%rbp), %rsi
movq %rax, %rdi
addq $0x40, %rdi
callq 0x32f0
leaq -0x138(%rbp), %rdi
callq 0x75d0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x26e37
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0x27040
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x3180
leaq -0x80(%rbp), %rdi
callq 0x3180
jmp 0x27054
addq $0x160, %rsp            # imm = 0x160
popq %rbp
retq
movq -0xa8(%rbp), %rdi
callq 0x3410
// File: niekh1234[P]nnchesslib/attacks.cpp
// Function: nnchesslib::Attacks::initRookMasks()
void Attacks::initRookMasks()
{
    for (int i = 0; i <= 63; i++)
    {
        rookMasks[i] =  Rays::getRay(NORTH, i) & ~rank_bb[RANK_8] |
                        Rays::getRay(SOUTH, i) & ~rank_bb[RANK_1] |
                        Rays::getRay(WEST, i) & ~file_bb[FILE_A]  |
                        Rays::getRay(EAST, i) & ~file_bb[FILE_H];
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
cmpl $0x3f, -0x4(%rbp)
jg 0x3c96
movl -0x4(%rbp), %esi
xorl %edi, %edi
callq 0xd630
movq 0xa56e(%rip), %rcx      # 0xe168
xorq $-0x1, %rcx
andq %rcx, %rax
movq %rax, -0x20(%rbp)
movl -0x4(%rbp), %esi
movl $0x2, %edi
callq 0xd630
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq 0xa510(%rip), %rdx      # 0xe130
xorq $-0x1, %rdx
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %esi
movl $0x3, %edi
callq 0xd630
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq 0xa527(%rip), %rdx      # 0xe170
xorq $-0x1, %rdx
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %esi
movl $0x1, %edi
callq 0xd630
movq -0x10(%rbp), %rdx
movq 0xa539(%rip), %rcx      # 0xe1a8
xorq $-0x1, %rcx
andq %rcx, %rax
orq %rax, %rdx
movslq -0x4(%rbp), %rcx
leaq 0xf62c(%rip), %rax      # 0x132b0
movq %rdx, (%rax,%rcx,8)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x3bdf
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: niekh1234[P]nnchesslib/attacks.cpp
// Function: nnchesslib::Attacks::initBishopMasks()
void Attacks::initBishopMasks()
{
    for (int i = 0; i <= 63; i++)
    {
        bishopMasks[i] =   (Rays::getRay(NORTH_EAST, i) | Rays::getRay(NORTH_WEST, i)  |
                            Rays::getRay(SOUTH_EAST, i) | Rays::getRay(SOUTH_WEST, i)) &
                            ~(file_bb[FILE_H] | file_bb[FILE_A] | rank_bb[RANK_1] | rank_bb[RANK_8]);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
cmpl $0x3f, -0x4(%rbp)
jg 0x3d54
movl -0x4(%rbp), %esi
movl $0x4, %edi
callq 0xd630
movq %rax, -0x20(%rbp)
movl -0x4(%rbp), %esi
movl $0x5, %edi
callq 0xd630
movq %rax, %rcx
movq -0x20(%rbp), %rax
orq %rcx, %rax
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %esi
movl $0x6, %edi
callq 0xd630
movq %rax, %rcx
movq -0x18(%rbp), %rax
orq %rcx, %rax
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %esi
movl $0x7, %edi
callq 0xd630
movq -0x10(%rbp), %rdx
orq %rax, %rdx
movq 0xa48d(%rip), %rax      # 0xe1a8
orq 0xa44e(%rip), %rax      # 0xe170
orq 0xa407(%rip), %rax      # 0xe130
orq 0xa438(%rip), %rax      # 0xe168
xorq $-0x1, %rax
andq %rax, %rdx
movslq -0x4(%rbp), %rcx
leaq 0xf76e(%rip), %rax      # 0x134b0
movq %rdx, (%rax,%rcx,8)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x3caf
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: niekh1234[P]nnchesslib/attacks.cpp
// Function: nnchesslib::Attacks::initRookMagics()
void Attacks::initRookMagics()
{
    for(int sq = 0; sq <= 63; sq++)
    {
        for(int i = 0; i < (1 << countBits(Attacks::rookMasks[sq])); i++)
        {
            U64 blockers = Attacks::genBlockers(i, Attacks::rookMasks[sq]);

            Attacks::rookTable[sq][(blockers * Attacks::rookMagics[sq]) >> (64 - countBits(Attacks::rookMasks[sq]))] = Attacks::getRookAttacksRays(sq, blockers);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
cmpl $0x3f, -0x4(%rbp)
jg 0x3e5c
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x14(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0xf51f(%rip), %rax      # 0x132b0
movq (%rax,%rcx,8), %rdi
callq 0xd790
movl %eax, %ecx
movl -0x14(%rbp), %eax
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
cmpl %ecx, %eax
jge 0x3e4c
movl -0x8(%rbp), %edi
movslq -0x4(%rbp), %rcx
leaq 0xf4f2(%rip), %rax      # 0x132b0
movq (%rax,%rcx,8), %rsi
callq 0x4240
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x42d0
movq %rax, -0x28(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0xf8ca(%rip), %rax      # 0x136b0
shlq $0xf, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movslq -0x4(%rbp), %rdx
leaq 0xa3b0(%rip), %rcx      # 0xe1b0
imulq (%rcx,%rdx,8), %rax
movq %rax, -0x30(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0xf49c(%rip), %rax      # 0x132b0
movq (%rax,%rcx,8), %rdi
callq 0xd790
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
movl %eax, %edi
movq -0x20(%rbp), %rax
movl $0x40, %ecx
subl %edi, %ecx
movl %ecx, %ecx
shrq %cl, %rsi
movq %rsi, %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x3d80
jmp 0x3e4e
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x3d6f
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: niekh1234[P]nnchesslib/attacks.cpp
// Function: nnchesslib::Attacks::initBishopMagics()
void Attacks::initBishopMagics()
{
    for(int sq = 0; sq <= 63; sq++)
    {
        for(int i = 0; i < (1 << countBits(Attacks::bishopMasks[sq])); i++)
        {
            U64 blockers = Attacks::genBlockers(i, Attacks::bishopMasks[sq]);

            Attacks::bishopTable[sq][(blockers * Attacks::bishopMagics[sq]) >> (64 - countBits(Attacks::bishopMasks[sq]))] = Attacks::getBishopAttacksRays(sq, blockers);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
cmpl $0x3f, -0x4(%rbp)
jg 0x3f6c
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x14(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0xf60f(%rip), %rax      # 0x134b0
movq (%rax,%rcx,8), %rdi
callq 0xd790
movl %eax, %ecx
movl -0x14(%rbp), %eax
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
cmpl %ecx, %eax
jge 0x3f5c
movl -0x8(%rbp), %edi
movslq -0x4(%rbp), %rcx
leaq 0xf5e2(%rip), %rax      # 0x134b0
movq (%rax,%rcx,8), %rsi
callq 0x4240
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x4440
movq %rax, -0x28(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x20f7ba(%rip), %rax    # 0x2136b0
shlq $0xd, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movslq -0x4(%rbp), %rdx
leaq 0xa4a0(%rip), %rcx      # 0xe3b0
imulq (%rcx,%rdx,8), %rax
movq %rax, -0x30(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0xf58c(%rip), %rax      # 0x134b0
movq (%rax,%rcx,8), %rdi
callq 0xd790
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
movl %eax, %edi
movq -0x20(%rbp), %rax
movl $0x40, %ecx
subl %edi, %ecx
movl %ecx, %ecx
shrq %cl, %rsi
movq %rsi, %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x3e90
jmp 0x3f5e
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x3e7f
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: niekh1234[P]nnchesslib/attacks.cpp
// Function: nnchesslib::Attacks::initPawnAttacks()
void Attacks::initPawnAttacks()
{
    for (int i = 0; i <= 63; i++)
    {
        U64 pos = (U64)1 << i;

        U64 wpAttacks = ((pos << 9) & ~file_bb[FILE_A]) | ((pos << 7) & ~file_bb[FILE_H]);  //White pawn attacks, checking for no wraparound
        U64 bpAttacks = ((pos >> 7) & ~file_bb[FILE_A]) | ((pos >> 9) & ~file_bb[FILE_H]);  //Black pawn attacks, checking for no wraparound

        nonSlidingAttacks[WHITE][PAWN][i] = wpAttacks;
        nonSlidingAttacks[BLACK][PAWN][i] = bpAttacks;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, -0x4(%rbp)
cmpl $0x3f, -0x4(%rbp)
jg 0x4044
movl -0x4(%rbp), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
shlq $0x9, %rax
movq 0xa1bb(%rip), %rcx      # 0xe170
xorq $-0x1, %rcx
andq %rcx, %rax
movq -0x10(%rbp), %rcx
shlq $0x7, %rcx
movq 0xa1dd(%rip), %rdx      # 0xe1a8
xorq $-0x1, %rdx
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
shrq $0x7, %rax
movq 0xa188(%rip), %rcx      # 0xe170
xorq $-0x1, %rcx
andq %rcx, %rax
movq -0x10(%rbp), %rcx
shrq $0x9, %rcx
movq 0xa1aa(%rip), %rdx      # 0xe1a8
xorq $-0x1, %rdx
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdx
movslq -0x4(%rbp), %rcx
leaq 0x28f695(%rip), %rax    # 0x2936b0
movq %rdx, 0xc00(%rax,%rcx,8)
movq -0x20(%rbp), %rdx
movslq -0x4(%rbp), %rcx
leaq 0x28f67e(%rip), %rax    # 0x2936b0
movq %rdx, (%rax,%rcx,8)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x3f8b
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: niekh1234[P]nnchesslib/attacks.cpp
// Function: nnchesslib::Attacks::initKnightAttacks()
void Attacks::initKnightAttacks()
{
    for (int i = 0; i <= 63; i++)
    {
        U64 pos = (U64)1 << i;

        U64 kAttacks =  (((pos >> 6) | (pos << 10)) & ~(file_bb[FILE_B] | file_bb[FILE_A])) |   //Knight moves two to the left
                        (((pos << 6) | (pos >> 10)) & ~(file_bb[FILE_H] | file_bb[FILE_G])) |   //Knight moves two to the right
                        (((pos >> 15) | (pos << 17)) & ~(file_bb[FILE_A])) |                    //Knight moves one to the left
                        (((pos << 15) | (pos >> 17)) & ~(file_bb[FILE_H]));                     //Knight moves one to the right

        nonSlidingAttacks[WHITE][KNIGHT][i] = kAttacks;
        nonSlidingAttacks[BLACK][KNIGHT][i] = kAttacks;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, -0x4(%rbp)
cmpl $0x3f, -0x4(%rbp)
jg 0x4151
movl -0x4(%rbp), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
shrq $0x6, %rax
movq -0x10(%rbp), %rcx
shlq $0xa, %rcx
orq %rcx, %rax
movq 0xa0e8(%rip), %rcx      # 0xe178
orq 0xa0d9(%rip), %rcx      # 0xe170
xorq $-0x1, %rcx
andq %rcx, %rax
movq -0x10(%rbp), %rcx
shlq $0x6, %rcx
movq -0x10(%rbp), %rdx
shrq $0xa, %rdx
orq %rdx, %rcx
movq 0xa0f0(%rip), %rdx      # 0xe1a8
orq 0xa0e1(%rip), %rdx      # 0xe1a0
xorq $-0x1, %rdx
andq %rdx, %rcx
orq %rcx, %rax
movq -0x10(%rbp), %rcx
shrq $0xf, %rcx
movq -0x10(%rbp), %rdx
shlq $0x11, %rdx
orq %rdx, %rcx
movq 0xa08d(%rip), %rdx      # 0xe170
xorq $-0x1, %rdx
andq %rdx, %rcx
orq %rcx, %rax
movq -0x10(%rbp), %rcx
shlq $0xf, %rcx
movq -0x10(%rbp), %rdx
shrq $0x11, %rdx
orq %rdx, %rcx
movq 0xa0a1(%rip), %rdx      # 0xe1a8
xorq $-0x1, %rdx
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdx
movslq -0x4(%rbp), %rcx
leaq 0x28f58c(%rip), %rax    # 0x2936b0
movq %rdx, 0xe00(%rax,%rcx,8)
movq -0x18(%rbp), %rdx
movslq -0x4(%rbp), %rcx
leaq 0x28f575(%rip), %rax    # 0x2936b0
movq %rdx, 0x200(%rax,%rcx,8)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x405b
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: niekh1234[P]nnchesslib/attacks.cpp
// Function: nnchesslib::Attacks::initKingAttacks()
void Attacks::initKingAttacks()
{
    for (int i = 0; i <= 63; i++)
    {
        U64 pos = (U64)1 << i;

        U64 kAttacks =  ((pos << 7) | (pos >> 1) | (pos >> 9)) & ~file_bb[FILE_H] | //King moves to the right
                        ((pos >> 7) | (pos << 1) | (pos << 9)) & ~file_bb[FILE_A] | //King moves to the left
                        ((pos >> 8) | (pos << 8));                                  //King moves up and down | easy, no bounds checking :^)

        nonSlidingAttacks[WHITE][KING][i] = kAttacks;
        nonSlidingAttacks[BLACK][KING][i] = kAttacks;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, -0x4(%rbp)
cmpl $0x3f, -0x4(%rbp)
jg 0x4235
movl -0x4(%rbp), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
shlq $0x7, %rax
movq -0x10(%rbp), %rcx
shrq %rcx
orq %rcx, %rax
movq -0x10(%rbp), %rcx
shrq $0x9, %rcx
orq %rcx, %rax
movq 0x9ffe(%rip), %rcx      # 0xe1a8
xorq $-0x1, %rcx
andq %rcx, %rax
movq -0x10(%rbp), %rcx
shrq $0x7, %rcx
movq -0x10(%rbp), %rdx
shlq %rdx
orq %rdx, %rcx
movq -0x10(%rbp), %rdx
shlq $0x9, %rdx
orq %rdx, %rcx
movq 0x9f9b(%rip), %rdx      # 0xe170
xorq $-0x1, %rdx
andq %rdx, %rcx
orq %rcx, %rax
movq -0x10(%rbp), %rcx
shrq $0x8, %rcx
movq -0x10(%rbp), %rdx
shlq $0x8, %rdx
orq %rdx, %rcx
orq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdx
movslq -0x4(%rbp), %rcx
leaq 0x28f4a8(%rip), %rax    # 0x2936b0
movq %rdx, 0x1600(%rax,%rcx,8)
movq -0x18(%rbp), %rdx
movslq -0x4(%rbp), %rcx
leaq 0x28f491(%rip), %rax    # 0x2936b0
movq %rdx, 0xa00(%rax,%rcx,8)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x416b
popq %rbp
retq
nopw (%rax,%rax)
// File: niekh1234[P]nnchesslib/attacks.cpp
// Function: nnchesslib::Attacks::genBlockers(int, unsigned long long)
U64 Attacks::genBlockers(int index, U64 mask)
{
    U64 blockerBoard = (U64)0;

    int bitIndex = 0;
    for(int i = 0; i <= 63; i++)
    {
        if(mask & (U64)1 << i)
        {
            if(index & (1 << bitIndex))
            {
                blockerBoard |= ((U64)1 << i);
            }

            bitIndex++;
        }
    }

    return blockerBoard;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
cmpl $0x3f, -0x20(%rbp)
jg 0x42c3
movq -0x10(%rbp), %rax
movl -0x20(%rbp), %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
je 0x42b6
movl -0x4(%rbp), %eax
movl -0x1c(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x42ad
movl -0x20(%rbp), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
orq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x42b8
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x4261
movq -0x18(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: niekh1234[P]nnchesslib/attacks.cpp
// Function: nnchesslib::Attacks::getSlidingAttacks(int, nnchesslib::PieceType, unsigned long long)
U64 Attacks::getSlidingAttacks(int sq, PieceType p, U64 blockers)
{
    assert(p == 2 || p == 3 || p == 4);
    switch(p)
    {
        case BISHOP:
            return getBishopAttacks(sq, blockers);
            break;
        case ROOK:
            return getRookAttacks(sq, blockers);
            break;
        case QUEEN:
            return (getRookAttacks(sq, blockers) | getBishopAttacks(sq, blockers));
            break;
        default:
            return (U64)0;
            break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x1, %al
cmpl $0x2, -0x10(%rbp)
movb %al, -0x19(%rbp)
je 0x47a2
movb $0x1, %al
cmpl $0x3, -0x10(%rbp)
movb %al, -0x19(%rbp)
je 0x47a2
cmpl $0x4, -0x10(%rbp)
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x47ab
jmp 0x47ad
jmp 0x47cc
leaq 0x98f5(%rip), %rdi      # 0xe0a9
leaq 0x989d(%rip), %rsi      # 0xe058
movl $0x107, %edx            # imm = 0x107
leaq 0x98fd(%rip), %rcx      # 0xe0c4
callq 0x3150
movl -0x10(%rbp), %eax
movl %eax, -0x20(%rbp)
subl $0x2, %eax
je 0x47ed
jmp 0x47d9
movl -0x20(%rbp), %eax
subl $0x3, %eax
je 0x47ff
jmp 0x47e3
movl -0x20(%rbp), %eax
subl $0x4, %eax
je 0x4811
jmp 0x483d
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x4650
movq %rax, -0x8(%rbp)
jmp 0x4845
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x45c0
movq %rax, -0x8(%rbp)
jmp 0x4845
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x45c0
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x4650
movq %rax, %rcx
movq -0x28(%rbp), %rax
orq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x4845
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: niekh1234[P]nnchesslib/bitboard.cpp
// Function: nnchesslib::BitBoard::set(int, bool)
void BitBoard::set(int square, bool set)
{
    assert(0 <= square && square <= 63);
    if(set)
        board |= ((U64)1 << square);
    else
        board &= ~((U64)1 << square);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
andb $0x1, %al
movb %al, -0xd(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
xorl %eax, %eax
xorl %ecx, %ecx
cmpl -0xc(%rbp), %ecx
movb %al, -0xe(%rbp)
jg 0x4c74
cmpl $0x3f, -0xc(%rbp)
setle %al
movb %al, -0xe(%rbp)
movb -0xe(%rbp), %al
testb $0x1, %al
jne 0x4c7d
jmp 0x4c7f
jmp 0x4c9e
leaq 0x992a(%rip), %rdi      # 0xe5b0
leaq 0x993f(%rip), %rsi      # 0xe5cc
movl $0x1c, %edx
leaq 0x9940(%rip), %rcx      # 0xe5d9
callq 0x3150
testb $0x1, -0xd(%rbp)
je 0x4cbe
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
orq (%rax), %rcx
movq %rcx, (%rax)
jmp 0x4cda
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
xorq $-0x1, %rcx
andq (%rax), %rcx
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: niekh1234[P]nnchesslib/bitboard.cpp
// Function: nnchesslib::BitBoard::printDebug()
void BitBoard::printDebug()
{
    std::string boardString = getBoardString();
    std::cout<<"---------------"<<std::endl;
    for (int y = 0; y <= 7; y++)
    {
        for (int x = 0; x <= 7; x++)
        {
            // if (boardString[63 - (8*y+x)] == '1')
            if (boardString[8*y+7-x] == '1')
                std::cout << "1 ";
            else
                std::cout << ". ";
        }
        std::cout << std::endl;
    }
    std::cout<<"---------------"<<std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x4be0
movq 0xe050(%rip), %rdi      # 0x12fd0
leaq 0x9711(%rip), %rsi      # 0xe698
callq 0x3250
movq %rax, -0x48(%rbp)
jmp 0x4f92
movq -0x48(%rbp), %rdi
movq 0xe01b(%rip), %rsi      # 0x12fb8
callq 0x3290
jmp 0x4fa4
movl $0x0, -0x38(%rbp)
cmpl $0x7, -0x38(%rbp)
jg 0x506f
movl $0x0, -0x3c(%rbp)
cmpl $0x7, -0x3c(%rbp)
jg 0x504a
movl -0x38(%rbp), %eax
shll $0x3, %eax
movl -0x3c(%rbp), %ecx
subl %ecx, %eax
addl $0x7, %eax
movslq %eax, %rsi
leaq -0x28(%rbp), %rdi
callq 0x3480
movq %rax, -0x50(%rbp)
jmp 0x4fe6
movq -0x50(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x31, %eax
jne 0x5023
movq 0xdfd7(%rip), %rdi      # 0x12fd0
leaq 0x96a8(%rip), %rsi      # 0xe6a8
callq 0x3250
jmp 0x5007
jmp 0x503a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x34a8
jmp 0x50a9
movq 0xdfa6(%rip), %rdi      # 0x12fd0
leaq 0x98a2(%rip), %rsi      # 0xe8d3
callq 0x3250
jmp 0x5038
jmp 0x503a
jmp 0x503c
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x4fbc
movq 0xdf7f(%rip), %rdi      # 0x12fd0
movq 0xdf60(%rip), %rsi      # 0x12fb8
callq 0x3290
jmp 0x505f
jmp 0x5061
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x4fab
movq 0xdf5a(%rip), %rdi      # 0x12fd0
leaq 0x961b(%rip), %rsi      # 0xe698
callq 0x3250
movq %rax, -0x58(%rbp)
jmp 0x5088
movq -0x58(%rbp), %rdi
movq 0xdf25(%rip), %rsi      # 0x12fb8
callq 0x3290
jmp 0x509a
leaq -0x28(%rbp), %rdi
callq 0x34a8
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x3410
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: niekh1234[P]nnchesslib/board.cpp
// Function: nnchesslib::ChessBoard::ChessBoard(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
ChessBoard::ChessBoard(std::string fen)
{
    std::string valid_fen;

    if (!isValidFen(fen))
        valid_fen = STARTING_FEN;
    else
        valid_fen = fen;

    generateBitBoards(valid_fen);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rsi, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x9950
movq -0x90(%rbp), %rdi
addq $0x68, %rdi
callq 0x9950
leaq -0x30(%rbp), %rdi
callq 0x3350
movq -0x88(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x30d0
jmp 0x5cd5
movq -0x90(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x5dc0
movb %al, -0x91(%rbp)
jmp 0x5ced
movb -0x91(%rbp), %al
xorb $-0x1, %al
movb %al, -0x92(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x34a8
movb -0x92(%rbp), %al
testb $0x1, %al
jne 0x5d10
jmp 0x5d49
leaq 0x28f1c1(%rip), %rsi    # 0x294ed8
leaq -0x30(%rbp), %rdi
callq 0x3030
jmp 0x5d22
jmp 0x5d5d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x5dae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x34a8
jmp 0x5dae
movq -0x88(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x3030
jmp 0x5d5b
jmp 0x5d5d
leaq -0x80(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x30d0
jmp 0x5d6c
movq -0x90(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x53f0
jmp 0x5d7e
leaq -0x80(%rbp), %rdi
callq 0x34a8
leaq -0x30(%rbp), %rdi
callq 0x34a8
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x34a8
leaq -0x30(%rbp), %rdi
callq 0x34a8
movq -0x58(%rbp), %rdi
callq 0x3410
// File: niekh1234[P]nnchesslib/board.cpp
// Function: nnchesslib::ChessBoard::getBoard(nnchesslib::Color, nnchesslib::PieceType)
BitBoard ChessBoard::getBoard(Color color, PieceType piece)
{
    assert(color == WHITE || color == BLACK);

    U64 boardColor = boardinfo.whitePieces.board;
    if(color == BLACK) boardColor = boardinfo.blackPieces.board;

    switch(piece){
        case PAWN:
            return (boardColor & boardinfo.pawns.board);
            break;
        case KNIGHT:
            return (boardColor & boardinfo.knights.board);
            break;
        case BISHOP:
            return (boardColor & boardinfo.bishops.board);
            break;
        case ROOK:
            return (boardColor & boardinfo.rooks.board);
            break;
        case QUEEN:
            return (boardColor & boardinfo.queens.board);
            break;
        case KING:
            return (boardColor & boardinfo.kings.board);
            break;
        default:
            return (boardinfo.whitePieces.board & boardinfo.pawns.board);
            break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movb $0x1, %al
cmpl $0x1, -0x14(%rbp)
movb %al, -0x21(%rbp)
je 0x771f
cmpl $0x0, -0x14(%rbp)
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x7728
jmp 0x772a
jmp 0x7749
leaq 0x71d8(%rip), %rdi      # 0xe909
leaq 0x6e97(%rip), %rsi      # 0xe5cf
movl $0xff, %edx
leaq 0x71e6(%rip), %rcx      # 0xe92a
callq 0x3150
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x7766
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x18(%rbp), %eax
movq %rax, -0x38(%rbp)
subq $0x5, %rax
ja 0x7818
movq -0x38(%rbp), %rax
leaq 0x704a(%rip), %rcx      # 0xe7cc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rsi
andq 0x10(%rax), %rsi
leaq -0x8(%rbp), %rdi
callq 0x4bc0
jmp 0x782c
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rsi
andq 0x18(%rax), %rsi
leaq -0x8(%rbp), %rdi
callq 0x4bc0
jmp 0x782c
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rsi
andq 0x20(%rax), %rsi
leaq -0x8(%rbp), %rdi
callq 0x4bc0
jmp 0x782c
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rsi
andq 0x28(%rax), %rsi
leaq -0x8(%rbp), %rdi
callq 0x4bc0
jmp 0x782c
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rsi
andq 0x30(%rax), %rsi
leaq -0x8(%rbp), %rdi
callq 0x4bc0
jmp 0x782c
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rsi
andq 0x38(%rax), %rsi
leaq -0x8(%rbp), %rdi
callq 0x4bc0
jmp 0x782c
movq -0x30(%rbp), %rax
movq (%rax), %rsi
andq 0x10(%rax), %rsi
leaq -0x8(%rbp), %rdi
callq 0x4bc0
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: niekh1234[P]nnchesslib/board.cpp
// Function: nnchesslib::ChessBoard::getPieceOnSquare(int)
BitBoard * ChessBoard::getPieceOnSquare(int index)
{
    if(boardinfo.pawns.get(index)) return(&boardinfo.pawns);
    if(boardinfo.knights.get(index)) return(&boardinfo.knights);
    if(boardinfo.bishops.get(index)) return(&boardinfo.bishops);
    if(boardinfo.rooks.get(index)) return(&boardinfo.rooks);
    if(boardinfo.queens.get(index)) return(&boardinfo.queens);
    if(boardinfo.kings.get(index)) return(&boardinfo.kings);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x10, %rdi
movl -0x14(%rbp), %esi
callq 0x4ce0
cmpl $0x0, %eax
je 0x7959
movq -0x20(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x8(%rbp)
jmp 0x7a13
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
movl -0x14(%rbp), %esi
callq 0x4ce0
cmpl $0x0, %eax
je 0x797f
movq -0x20(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x8(%rbp)
jmp 0x7a13
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
movl -0x14(%rbp), %esi
callq 0x4ce0
cmpl $0x0, %eax
je 0x79a2
movq -0x20(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x8(%rbp)
jmp 0x7a13
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
movl -0x14(%rbp), %esi
callq 0x4ce0
cmpl $0x0, %eax
je 0x79c5
movq -0x20(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x8(%rbp)
jmp 0x7a13
movq -0x20(%rbp), %rdi
addq $0x30, %rdi
movl -0x14(%rbp), %esi
callq 0x4ce0
cmpl $0x0, %eax
je 0x79e8
movq -0x20(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x8(%rbp)
jmp 0x7a13
movq -0x20(%rbp), %rdi
addq $0x38, %rdi
movl -0x14(%rbp), %esi
callq 0x4ce0
cmpl $0x0, %eax
je 0x7a0b
movq -0x20(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x8(%rbp)
jmp 0x7a13
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: niekh1234[P]nnchesslib/board.cpp
// Function: nnchesslib::ChessBoard::setEnPassantPossibility(nnchesslib::BitBoard, int, int)
void ChessBoard::setEnPassantPossibility(BitBoard ourPieces, int from, int to)
{
    // There can only be one target at the time, so clearing the boards every move.
    boardinfo.whiteEnPassantTarget.board = (U64)0;
    boardinfo.blackEnPassantTarget.board = (U64)0;
    // black en passant possibility (white has double moved)
    if((from / 8 == 1 && to / 8 == 3) && ourPieces.board & boardinfo.pawns.board)
    {
        // set the square under the pawn as a target for a black pawn (in a seperate bitboard)
        boardinfo.blackEnPassantTarget.set(to - 8, true);
    }
    // white en passant possibility (black has double moved)
    else if((from / 8 == 6 && to / 8 == 4) && ourPieces.board & boardinfo.pawns.board)
    {
        boardinfo.whiteEnPassantTarget.set(to + 8, true);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, 0x58(%rax)
movq $0x0, 0x60(%rax)
movl -0x14(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
cmpl $0x1, %eax
jne 0x7eaa
movl -0x18(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
cmpl $0x3, %eax
jne 0x7eaa
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
andq 0x10(%rcx), %rax
cmpq $0x0, %rax
je 0x7eaa
movq -0x20(%rbp), %rdi
addq $0x60, %rdi
movl -0x18(%rbp), %esi
subl $0x8, %esi
movl $0x1, %edx
callq 0x4c40
jmp 0x7ef6
movl -0x14(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
cmpl $0x6, %eax
jne 0x7ef4
movl -0x18(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
cmpl $0x4, %eax
jne 0x7ef4
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
andq 0x10(%rcx), %rax
cmpq $0x0, %rax
je 0x7ef4
movq -0x20(%rbp), %rdi
addq $0x58, %rdi
movl -0x18(%rbp), %esi
addl $0x8, %esi
movl $0x1, %edx
callq 0x4c40
jmp 0x7ef6
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: niekh1234[P]nnchesslib/board.cpp
// Function: nnchesslib::ChessBoard::pushPromotionMove(unsigned int)
void ChessBoard::pushPromotionMove(Move move)
{
    int from = from_Square(move);
    int to = to_Square(move);

    BitBoard * ourPieces = getColorOnSquare(from);

    PieceType piece = movePromotionType(move);

    boardinfo.pawns.set(from, false);
    ourPieces->set(from, false);
    ourPieces->set(to, true);

    if(piece == QUEEN) boardinfo.queens.set(to, true);
    if(piece == ROOK) boardinfo.rooks.set(to, true);
    if(piece == BISHOP) boardinfo.bishops.set(to, true);
    if(piece == KNIGHT) boardinfo.knights.set(to, true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0xc(%rbp), %edi
callq 0xaa40
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %edi
callq 0xaa60
movq -0x30(%rbp), %rdi
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %esi
callq 0x7a20
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %edi
callq 0xaa70
movq -0x30(%rbp), %rdi
movl %eax, -0x24(%rbp)
addq $0x10, %rdi
movl -0x10(%rbp), %esi
xorl %edx, %edx
callq 0x4c40
movq -0x20(%rbp), %rdi
movl -0x10(%rbp), %esi
xorl %edx, %edx
callq 0x4c40
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
movl $0x1, %edx
callq 0x4c40
cmpl $0x4, -0x24(%rbp)
jne 0x84c4
movq -0x30(%rbp), %rdi
addq $0x30, %rdi
movl -0x14(%rbp), %esi
movl $0x1, %edx
callq 0x4c40
cmpl $0x3, -0x24(%rbp)
jne 0x84df
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
movl -0x14(%rbp), %esi
movl $0x1, %edx
callq 0x4c40
cmpl $0x2, -0x24(%rbp)
jne 0x84fa
movq -0x30(%rbp), %rdi
addq $0x20, %rdi
movl -0x14(%rbp), %esi
movl $0x1, %edx
callq 0x4c40
cmpl $0x1, -0x24(%rbp)
jne 0x8515
movq -0x30(%rbp), %rdi
addq $0x18, %rdi
movl -0x14(%rbp), %esi
movl $0x1, %edx
callq 0x4c40
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: niekh1234[P]nnchesslib/board.cpp
// Function: nnchesslib::ChessBoard::pushEnPassantMove(unsigned int)
void ChessBoard::pushEnPassantMove(Move move)
{
    int from = from_Square(move);
    int to = to_Square(move);

    BitBoard * ourPieceType = getPieceOnSquare(from);

    // White double pawn move (this needs to be seperated because we need to remove the pawn above or under the targetted square)
    if(from >= A5)
    {
        BitBoard * theirPiece = getPieceOnSquare(to - 8);
        boardinfo.whitePieces.set(from, false);
        boardinfo.whitePieces.set(to, true);
        ourPieceType->set(from, false);
        ourPieceType->set(to, true);
        theirPiece->set(to - 8, false);
        boardinfo.blackPieces.set(to - 8, false);
    } 
    else if(from <= H4)
    {
        BitBoard * theirPiece = getPieceOnSquare(to + 8);
        boardinfo.blackPieces.set(from, false);
        boardinfo.blackPieces.set(to, true);
        ourPieceType->set(from, false);
        ourPieceType->set(to, true);
        theirPiece->set(to + 8, false);
        boardinfo.whitePieces.set(to + 8, false);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0xc(%rbp), %edi
callq 0xaa40
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %edi
callq 0xaa60
movq -0x38(%rbp), %rdi
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %esi
callq 0x7920
movq %rax, -0x20(%rbp)
cmpl $0x20, -0x10(%rbp)
jl 0x85df
movq -0x38(%rbp), %rdi
movl -0x14(%rbp), %esi
subl $0x8, %esi
callq 0x7920
movq -0x38(%rbp), %rdi
movq %rax, -0x28(%rbp)
movl -0x10(%rbp), %esi
xorl %edx, %edx
callq 0x4c40
movq -0x38(%rbp), %rdi
movl -0x14(%rbp), %esi
movl $0x1, %edx
callq 0x4c40
movq -0x20(%rbp), %rdi
movl -0x10(%rbp), %esi
xorl %edx, %edx
callq 0x4c40
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
movl $0x1, %edx
callq 0x4c40
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %esi
subl $0x8, %esi
xorl %edx, %edx
callq 0x4c40
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
movl -0x14(%rbp), %esi
subl $0x8, %esi
xorl %edx, %edx
callq 0x4c40
jmp 0x8662
cmpl $0x1f, -0x10(%rbp)
jg 0x8660
movq -0x38(%rbp), %rdi
movl -0x14(%rbp), %esi
addl $0x8, %esi
callq 0x7920
movq -0x38(%rbp), %rdi
movq %rax, -0x30(%rbp)
addq $0x8, %rdi
movl -0x10(%rbp), %esi
xorl %edx, %edx
callq 0x4c40
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
movl -0x14(%rbp), %esi
movl $0x1, %edx
callq 0x4c40
movq -0x20(%rbp), %rdi
movl -0x10(%rbp), %esi
xorl %edx, %edx
callq 0x4c40
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
movl $0x1, %edx
callq 0x4c40
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %esi
addl $0x8, %esi
xorl %edx, %edx
callq 0x4c40
movq -0x38(%rbp), %rdi
movl -0x14(%rbp), %esi
addl $0x8, %esi
xorl %edx, %edx
callq 0x4c40
jmp 0x8662
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: niekh1234[P]nnchesslib/board.cpp
// Function: nnchesslib::ChessBoard::pushRegularMove(unsigned int)
void ChessBoard::pushRegularMove(Move move)
{
    int from = from_Square(move);
    int to = to_Square(move);

    // gets the bitboard corresponding to our piecetype, e.g. knights, pawns etc.
    BitBoard * ourPieceType = getPieceOnSquare(from);
    // gets the bitboard corresponding to the opponent piecetype (at least if it is a capture).
    BitBoard * theirPieceType = getPieceOnSquare(to);
    // if board is empty it returns 0.
    bool isCapture = theirPieceType;
    // gets the bitboard corresponding to our piece color.
    BitBoard * ourPieces = getColorOnSquare(from);

    boardinfo.fiftyMoveRule++;

    if (boardinfo.pawns.board & ourPieceType->board)    
        boardinfo.fiftyMoveRule = 0;

    if(isCapture)
    {
        theirPieceType->set(to, false);

        BitBoard * theirPieces = getColorOnSquare(to);
        theirPieces->set(to, false);
        boardinfo.fiftyMoveRule = 0;
    }
    // changing to the position of a piece on one of the piece boards: pawn, knight, rook king etc.
    ourPieceType->set(from, false);
    ourPieceType->set(to, true);
    // changing the position of the piece on the white_pieces or black_pieces board.
    ourPieces->set(from, false);
    ourPieces->set(to, true);

    setEnPassantPossibility(*ourPieces, from, to);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movl -0xc(%rbp), %edi
callq 0xaa40
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %edi
callq 0xaa60
movq -0x50(%rbp), %rdi
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %esi
callq 0x7920
movq -0x50(%rbp), %rdi
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %esi
callq 0x7920
movq -0x50(%rbp), %rdi
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
setne %al
andb $0x1, %al
movb %al, -0x29(%rbp)
movl -0x10(%rbp), %esi
callq 0x7a20
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, -0x38(%rbp)
movl 0x48(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x48(%rax)
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
andq (%rcx), %rax
cmpq $0x0, %rax
je 0x8706
movq -0x50(%rbp), %rax
movl $0x0, 0x48(%rax)
testb $0x1, -0x29(%rbp)
je 0x8743
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %esi
xorl %edx, %edx
callq 0x4c40
movq -0x50(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x7a20
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movl -0x14(%rbp), %esi
xorl %edx, %edx
callq 0x4c40
movq -0x50(%rbp), %rax
movl $0x0, 0x48(%rax)
movq -0x20(%rbp), %rdi
movl -0x10(%rbp), %esi
xorl %edx, %edx
callq 0x4c40
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
movl $0x1, %edx
callq 0x4c40
movq -0x38(%rbp), %rdi
movl -0x10(%rbp), %esi
xorl %edx, %edx
callq 0x4c40
movq -0x38(%rbp), %rdi
movl -0x14(%rbp), %esi
movl $0x1, %edx
callq 0x4c40
movq -0x50(%rbp), %rdi
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movl -0x10(%rbp), %edx
movl -0x14(%rbp), %ecx
movq -0x48(%rbp), %rsi
callq 0x7e30
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: niekh1234[P]nnchesslib/board.cpp
// Function: nnchesslib::ChessBoard::pushMove(unsigned int)
void ChessBoard::pushMove(Move move)
{
    // setting previous board information the the current position when there has not been made a move.
    previousBoard = boardinfo;
    // getting the movetype
    MoveType type = moveType(move);

    if(type == CASTLING) pushCastlingMove(move);
    else if(type == PROMOTION) pushPromotionMove(move);
    else if(type == ENPASSANT) pushEnPassantMove(move);
    else if(type == NORMAL) pushRegularMove(move);

    // Update board information
    updateCastlingRights();
    boardinfo.whiteToMove = !boardinfo.whiteToMove;

    if (boardinfo.whiteToMove)
        boardinfo.plyCount++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x18(%rbp)
movq %rsi, %rdi
addq $0x68, %rdi
movl $0x68, %edx
callq 0x31e0
movl -0xc(%rbp), %edi
callq 0xaa90
movl %eax, -0x10(%rbp)
cmpl $0x3, -0x10(%rbp)
jne 0x87f7
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x80e0
jmp 0x8837
cmpl $0x1, -0x10(%rbp)
jne 0x880b
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x8430
jmp 0x8835
cmpl $0x2, -0x10(%rbp)
jne 0x881f
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x8520
jmp 0x8833
cmpl $0x0, -0x10(%rbp)
jne 0x8831
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x8670
jmp 0x8833
jmp 0x8835
jmp 0x8837
movq -0x18(%rbp), %rdi
callq 0x7f00
movq -0x18(%rbp), %rax
movb 0x40(%rax), %cl
xorb $-0x1, %cl
andb $0x1, %cl
movb %cl, 0x40(%rax)
testb $0x1, 0x40(%rax)
je 0x8863
movq -0x18(%rbp), %rax
movl 0x4c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4c(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: niekh1234[P]nnchesslib/main.cpp
// Function: initAll()
void initAll()
{
    time_t begin, end;
    begin = clock();
    std::cout << "Initializing..." << std::endl;

    Rays::initRays();
    Attacks::initAllAttacks();

    end = clock();

    std::cout << "Finished initializing." << std::endl;
    std::cout << "Time taken: " << (float)(end-begin)/CLOCKS_PER_SEC << " seconds." << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x3160
movq %rax, -0x8(%rbp)
movq 0x8728(%rip), %rdi      # 0x12fd0
leaq 0x4231(%rip), %rsi      # 0xeae0
callq 0x3250
movq %rax, %rdi
movq 0x86fa(%rip), %rsi      # 0x12fb8
callq 0x3290
callq 0xd410
callq 0x3ba0
callq 0x3160
movq %rax, -0x10(%rbp)
movq 0x86f3(%rip), %rdi      # 0x12fd0
leaq 0x420c(%rip), %rsi      # 0xeaf0
callq 0x3250
movq %rax, %rdi
movq 0x86c5(%rip), %rsi      # 0x12fb8
callq 0x3290
movq 0x86d1(%rip), %rdi      # 0x12fd0
leaq 0x4201(%rip), %rsi      # 0xeb07
callq 0x3250
movq %rax, %rdi
movq -0x10(%rbp), %rax
subq -0x8(%rbp), %rax
cvtsi2ss %rax, %xmm0
movss 0x41b9(%rip), %xmm1     # 0xeadc
divss %xmm1, %xmm0
callq 0x31b0
movq %rax, %rdi
leaq 0x41de(%rip), %rsi      # 0xeb14
callq 0x3250
movq %rax, %rdi
movq 0x8673(%rip), %rsi      # 0x12fb8
callq 0x3290
addq $0x10, %rsp
popq %rbp
retq
// File: niekh1234[P]nnchesslib/main.cpp
// Function: main
int main(int argc, char *argv[])
{
    initAll();

    ChessBoard myBoard = ChessBoard();

    myBoard.pushFromUci("e2e4");
    
    myBoard.print();
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0xa890
leaq -0xe0(%rbp), %rdi
callq 0x5370
leaq -0x101(%rbp), %rdi
movq %rdi, -0x120(%rbp)
callq 0x3420
movq -0x120(%rbp), %rdx
leaq 0x4183(%rip), %rsi      # 0xeb1e
leaq -0x100(%rbp), %rdi
callq 0x4850
jmp 0xa9a9
leaq -0xe0(%rbp), %rdi
leaq -0x100(%rbp), %rsi
callq 0x9840
jmp 0xa9be
leaq -0x100(%rbp), %rdi
callq 0x34a8
leaq -0x101(%rbp), %rdi
callq 0x32b0
leaq -0xe0(%rbp), %rdi
callq 0x7140
xorl %eax, %eax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x110(%rbp)
movl %eax, -0x114(%rbp)
jmp 0xaa1f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x110(%rbp)
movl %eax, -0x114(%rbp)
leaq -0x100(%rbp), %rdi
callq 0x34a8
leaq -0x101(%rbp), %rdi
callq 0x32b0
movq -0x110(%rbp), %rdi
callq 0x3410
nopw (%rax,%rax)
// File: niekh1234[P]nnchesslib/move.cpp
// Function: nnchesslib::toUci[abi:cxx11](unsigned int)
std::string nnchesslib::toUci(Move m)
{
    std::string from = getSquareString(from_Square(m));
    std::string to = getSquareString(to_Square(m));

    std::string output = from + to;

    if(moveType(m) == PROMOTION)
    {
        switch(movePromotionType(m))
        {
            case QUEEN:
                output+="q";
                break;
            case KNIGHT:
                output+="n";
                break;
            case BISHOP:
                output+="b";
                break;
            case ROOK:
                output+="r";
                break;
        }
    }
    return output;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %edi
callq 0xaa40
movl %eax, %esi
leaq -0x30(%rbp), %rdi
callq 0xd870
movl -0xc(%rbp), %edi
callq 0xaa60
movl %eax, %esi
leaq -0x50(%rbp), %rdi
callq 0xd870
jmp 0xab65
movq -0x70(%rbp), %rdi
movb $0x0, -0x5d(%rbp)
leaq -0x30(%rbp), %rsi
leaq -0x50(%rbp), %rdx
callq 0xad10
jmp 0xab7c
movl -0xc(%rbp), %edi
callq 0xaa90
cmpl $0x1, %eax
jne 0xac45
movl -0xc(%rbp), %edi
callq 0xaa70
decl %eax
movl %eax, %ecx
movq %rcx, -0x78(%rbp)
subl $0x3, %eax
ja 0xac43
movq -0x78(%rbp), %rax
leaq 0x3f73(%rip), %rcx      # 0xeb24
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xac80
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xac77
movq -0x70(%rbp), %rdi
leaq 0x3c5d(%rip), %rsi      # 0xe844
callq 0x3240
jmp 0xabee
jmp 0xac43
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
callq 0x34a8
jmp 0xac77
movq -0x70(%rbp), %rdi
leaq 0x3da1(%rip), %rsi      # 0xe9b3
callq 0x3240
jmp 0xac19
jmp 0xac43
movq -0x70(%rbp), %rdi
leaq 0x3c14(%rip), %rsi      # 0xe83a
callq 0x3240
jmp 0xac2d
jmp 0xac43
movq -0x70(%rbp), %rdi
leaq 0x3d7b(%rip), %rsi      # 0xe9b5
callq 0x3240
jmp 0xac41
jmp 0xac43
jmp 0xac45
movb $0x1, -0x5d(%rbp)
testb $0x1, -0x5d(%rbp)
jne 0xac58
movq -0x70(%rbp), %rdi
callq 0x34a8
leaq -0x50(%rbp), %rdi
callq 0x34a8
leaq -0x30(%rbp), %rdi
callq 0x34a8
movq -0x68(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
leaq -0x50(%rbp), %rdi
callq 0x34a8
leaq -0x30(%rbp), %rdi
callq 0x34a8
movq -0x58(%rbp), %rdi
callq 0x3410
nopw %cs:(%rax,%rax)
// File: niekh1234[P]nnchesslib/movegen.cpp
// Function: nnchesslib::genLegalMoves(nnchesslib::ChessBoard)
MoveList nnchesslib::genLegalMoves(ChessBoard board)
{
    MoveList pseudoLegalMoves;
    MoveList legalMoves;

    genPseudoLegalMoves(board, pseudoLegalMoves);
    
    for(auto move : pseudoLegalMoves)
    {
        ChessBoard temp = board;
        temp.pushMove(move);

        Color boardTurn = BLACK;
        if(board.getWhiteToMove()) boardTurn = WHITE;

        if(!temp.kingInCheck(boardTurn)) 
        {
            legalMoves.push_back(move);
        }
    }
    return legalMoves;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x310, %rsp            # imm = 0x310
movq %rdi, -0x220(%rbp)
movq %rdi, %rax
movq %rax, -0x228(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x218(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0x208(%rbp)
callq 0xcaf0
movq -0x220(%rbp), %rdi
movb $0x0, -0x21(%rbp)
callq 0xcaf0
movq -0x218(%rbp), %rsi
leaq -0xf8(%rbp), %rdi
movq %rdi, -0x210(%rbp)
movl $0xd0, %edx
callq 0x31e0
movq -0x210(%rbp), %rsi
movq %rsp, %rdi
movl $0x1a, %ecx
rep  movsq (%rsi), %es:(%rdi)
movq -0x208(%rbp), %rdi
callq 0xafa0
jmp 0xae1a
leaq -0x20(%rbp), %rax
movq %rax, -0x110(%rbp)
movq -0x110(%rbp), %rdi
callq 0xcb10
movq %rax, -0x118(%rbp)
movq -0x110(%rbp), %rdi
callq 0xcb40
movq %rax, -0x120(%rbp)
leaq -0x118(%rbp), %rdi
leaq -0x120(%rbp), %rsi
callq 0xcb70
testb $0x1, %al
jne 0xae67
jmp 0xaf5d
leaq -0x118(%rbp), %rdi
callq 0xcbb0
movq -0x218(%rbp), %rsi
movl (%rax), %eax
movl %eax, -0x124(%rbp)
leaq -0x1f8(%rbp), %rdi
movq %rdi, -0x230(%rbp)
movl $0xd0, %edx
callq 0x31e0
movq -0x230(%rbp), %rdi
movl -0x124(%rbp), %esi
callq 0x87b0
jmp 0xaeae
movq -0x218(%rbp), %rdi
movl $0x0, -0x1fc(%rbp)
callq 0x7900
movb %al, -0x231(%rbp)
jmp 0xaecc
movb -0x231(%rbp), %al
testb $0x1, %al
jne 0xaed8
jmp 0xaf0d
movl $0x1, -0x1fc(%rbp)
jmp 0xaf0d
movq -0x220(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x100(%rbp)
movl %eax, -0x104(%rbp)
callq 0x9e20
leaq -0x20(%rbp), %rdi
callq 0x9e20
jmp 0xaf8c
movl -0x1fc(%rbp), %esi
leaq -0x1f8(%rbp), %rdi
callq 0x7a90
movb %al, -0x232(%rbp)
jmp 0xaf27
movb -0x232(%rbp), %al
testb $0x1, %al
jne 0xaf4a
jmp 0xaf33
movq -0x220(%rbp), %rdi
leaq -0x124(%rbp), %rsi
callq 0xcbd0
jmp 0xaf48
jmp 0xaf4a
jmp 0xaf4c
leaq -0x118(%rbp), %rdi
callq 0xcc40
jmp 0xae4b
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0xaf73
movq -0x220(%rbp), %rdi
callq 0x9e20
leaq -0x20(%rbp), %rdi
callq 0x9e20
movq -0x228(%rbp), %rax
addq $0x310, %rsp            # imm = 0x310
popq %rbp
retq
movq -0x100(%rbp), %rdi
callq 0x3410
nopl (%rax,%rax)
// File: niekh1234[P]nnchesslib/movegen.cpp
// Function: nnchesslib::genPseudoLegalMoves(nnchesslib::ChessBoard, std::vector<unsigned int, std::allocator<unsigned int>>&)
void nnchesslib::genPseudoLegalMoves(ChessBoard board, MoveList& moveList)
{
    BitBoard blockers = board.getBlockers();
    
    if(board.getWhiteToMove())
        genWhiteMoves(board, moveList, blockers);
    else
        genBlackMoves(board, moveList, blockers);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2c0, %rsp            # imm = 0x2C0
movq %rdi, %rax
leaq 0x10(%rbp), %rdi
movq %rdi, -0x1c8(%rbp)
movq %rax, -0x8(%rbp)
callq 0x78d0
movq -0x1c8(%rbp), %rdi
movq %rax, -0x10(%rbp)
callq 0x7900
testb $0x1, %al
jne 0xafd8
jmp 0xb03b
movq -0x1c8(%rbp), %rsi
leaq -0xe0(%rbp), %rdi
movl $0xd0, %edx
callq 0x31e0
movq -0x8(%rbp), %rax
movq %rax, -0x1d0(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xe8(%rbp)
movq -0xe8(%rbp), %rax
movq %rax, -0x1d8(%rbp)
movq %rsp, %rdi
movl $0x1a, %ecx
leaq -0xe0(%rbp), %rsi
rep  movsq (%rsi), %es:(%rdi)
movq -0x1d8(%rbp), %rsi
movq -0x1d0(%rbp), %rdi
callq 0xb0b0
jmp 0xb09c
movq -0x1c8(%rbp), %rsi
leaq -0x1b8(%rbp), %rdi
movl $0xd0, %edx
callq 0x31e0
movq -0x8(%rbp), %rax
movq %rax, -0x1e0(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1c0(%rbp)
movq -0x1c0(%rbp), %rax
movq %rax, -0x1e8(%rbp)
movq %rsp, %rdi
movl $0x1a, %ecx
leaq -0x1b8(%rbp), %rsi
rep  movsq (%rsi), %es:(%rdi)
movq -0x1e8(%rbp), %rsi
movq -0x1e0(%rbp), %rdi
callq 0xb430
addq $0x2c0, %rsp            # imm = 0x2C0
popq %rbp
retq
nopw %cs:(%rax,%rax)