LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/eschwabe[P]interview-practice/src/parenthesization.cpp
// Function: main
int main(int argc, char *argv[])
{
    const int count = 4;
    vector<string> tmp;
    BuildString("", count, count, &tmp);

    for(auto s : tmp) {
        cout << s << endl;
    }

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
leaq 0x48(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0xbf5(%rip), %rdx       # 0x2005
leaq 0x38(%rsp), %rdi
movq %rdx, %rsi
callq 0x18ba
leaq 0x38(%rsp), %rdi
movq %rsp, %rcx
movl $0x4, %esi
movl $0x4, %edx
callq 0x12ac
movq 0x38(%rsp), %rdi
cmpq %r14, %rdi
je 0x144b
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x10f0
movq (%rsp), %r12
movq 0x8(%rsp), %rbp
cmpq %rbp, %r12
je 0x14e3
leaq 0x28(%rsp), %r13
leaq 0x18(%rsp), %rbx
movq 0x2b6a(%rip), %r14      # 0x3fd8
movq %r13, 0x18(%rsp)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x15e6
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq %r14, %rdi
callq 0x1100
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x10d0
movsbl %al, %esi
movq %r15, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1080
movq 0x18(%rsp), %rdi
cmpq %r13, %rdi
je 0x14da
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x10f0
addq $0x20, %r12
cmpq %rbp, %r12
jne 0x146e
movq %rsp, %rdi
callq 0x1580
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x38(%rsp), %rdi
cmpq %r14, %rdi
je 0x1531
movq 0x48(%rsp), %rsi
jmp 0x1529
jmp 0x1512
movq %rax, %rbx
jmp 0x1531
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r13, %rdi
je 0x1531
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x10f0
movq %rsp, %rdi
callq 0x1580
movq %rbx, %rdi
callq 0x1140
nop
// File: /workspace/github_cpp_makefile_star2_O1/jaldhar[P]Lets-Build-a-Simple-Interpreter/calc4.cc
// Function: operator<<(std::ostream&, TOKENTYPE const&)
ostream& operator<<(ostream& out, const TOKENTYPE& t) {
    string repr;
    switch(t) {
        case TOKENTYPE::ENDOFFILE:
            repr = "ENDOFFILE";
            break;
        case TOKENTYPE::INTEGER:
            repr = "INTEGER";
            break;
        case TOKENTYPE::PLUS:
            repr = "PLUS";
            break;
        case TOKENTYPE::MINUS:
            repr = "MINUS";
            break;
        case TOKENTYPE::MUL:
            repr = "MUL";
            break;
        case TOKENTYPE::DIV:
            repr = "DIV";
            break;
    }

    out << repr;
    return out;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
movl (%rsi), %eax
cmpq $0x6, %rax
jae 0x239a
leaq 0xcb6(%rip), %rdx       # 0x3030
movslq (%rdx,%rax,4), %rcx
addq %rdx, %rcx
leaq 0xcc0(%rip), %rdx       # 0x3048
movq (%rdx,%rax,8), %r8
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x21b0
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x2160
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x23c3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2150
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x23e8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2150
movq %rbx, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O1/jaldhar[P]Lets-Build-a-Simple-Interpreter/calc4.cc
// Function: Interpreter::expression()
long Interpreter::expression() {
    long result = factor();

    while (_current_token.type == TOKENTYPE::MUL ||
    _current_token.type == TOKENTYPE::DIV ||
    _current_token.type == TOKENTYPE::PLUS ||
    _current_token.type == TOKENTYPE::MINUS) {
        Token token = _current_token;
        if (token.type == TOKENTYPE::MUL) {
            eat(TOKENTYPE::MUL);
            result *= factor();
        } else if (token.type == TOKENTYPE::DIV) {
            eat(TOKENTYPE::DIV);
            long rhs = factor();
            if (rhs == 0) {
                throw("Division by zero");
            }
            result /= rhs;
        } else if (token.type == TOKENTYPE::PLUS) {
            eat(TOKENTYPE::PLUS);
            result += factor();
        } else if (token.type == TOKENTYPE::MINUS) {
            eat(TOKENTYPE::MINUS);
            result -= factor();
        }
    }

    return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x10(%rdi), %rbx
movl $0x1, %esi
callq 0x29b4
movl 0x8(%r14), %eax
leal -0x2(%rax), %ecx
cmpl $0x3, %ecx
ja 0x296c
leaq 0x74a(%rip), %r15       # 0x3020
addl $-0x2, %eax
cmpl $0x3, %eax
ja 0x295c
movslq (%r15,%rax,4), %rax
addq %r15, %rax
jmpq *%rax
movq %r14, %rdi
movl $0x2, %esi
callq 0x29b4
addq 0x10(%r14), %rbx
jmp 0x294f
movq %r14, %rdi
movl $0x4, %esi
callq 0x29b4
imulq 0x10(%r14), %rbx
jmp 0x294f
movq %r14, %rdi
movl $0x5, %esi
callq 0x29b4
movq 0x10(%r14), %r12
movq %r14, %rdi
movl $0x1, %esi
callq 0x29b4
testq %r12, %r12
je 0x297b
movq %rbx, %rax
cqto
idivq %r12
movq %rax, %rbx
jmp 0x295c
movq %r14, %rdi
movl $0x3, %esi
callq 0x29b4
subq 0x10(%r14), %rbx
movq %r14, %rdi
movl $0x1, %esi
callq 0x29b4
movl 0x8(%r14), %eax
leal -0x2(%rax), %ecx
cmpl $0x4, %ecx
jb 0x28d6
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0x8, %edi
callq 0x2090
leaq 0x737(%rip), %rcx       # 0x30c3
movq %rcx, (%rax)
movq 0x261a(%rip), %rsi      # 0x4fb0
movq %rax, %rdi
xorl %edx, %edx
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O1/m1c0l[P]TCP/server.cpp
// Function: printSend(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned short, int, int, bool)
void printSend(string pktType, uint16_t seq, int cwnd, int ssThresh, bool isRetransmit) {
	cout << "Sending packet " << seq << " " << cwnd << " " << ssThresh;
	if (isRetransmit) {
		cout << " Retransmission";
	}
	if (pktType != "data") {
		// SYN or FIN
		cout << " " << pktType;
	}
	cout << '\n';
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movl %ecx, %r14d
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, %rbx
movq 0x5397(%rip), %r13      # 0x7fd0
leaq 0x243a(%rip), %rsi      # 0x507a
movl $0xf, %edx
movq %r13, %rdi
callq 0x21f0
movl %r12d, %esi
movq %r13, %rdi
callq 0x2120
movq %rax, %r12
leaq 0x2443(%rip), %r13      # 0x50a5
movl $0x1, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x21f0
movq %r12, %rdi
movl %r15d, %esi
callq 0x22c0
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x21f0
movq %r15, %rdi
movl %r14d, %esi
callq 0x22c0
testl %ebp, %ebp
je 0x2cb7
movq 0x532a(%rip), %rdi      # 0x7fd0
leaq 0x23dd(%rip), %rsi      # 0x508a
movl $0xf, %edx
callq 0x21f0
leaq 0x23dc(%rip), %rsi      # 0x509a
movq %rbx, %rdi
callq 0x20b0
testl %eax, %eax
je 0x2cf4
movq 0x52ff(%rip), %r14      # 0x7fd0
leaq 0x23cd(%rip), %rsi      # 0x50a5
movl $0x1, %edx
movq %r14, %rdi
callq 0x21f0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x21f0
leaq 0x7(%rsp), %rsi
movb $0xa, (%rsi)
movq 0x52cd(%rip), %rdi      # 0x7fd0
movl $0x1, %edx
callq 0x21f0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/t0mm4rx[P]piscine_cpp/day03/ex04/SuperTrap.cpp
// Function: SuperTrap::SuperTrap(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
SuperTrap::SuperTrap(std::string name) : ClapTrap(name), NinjaTrap(name), FragTrap(name)
{
	this->hitPoints = FragTrap::hitPoints;
	this->maxHit = FragTrap::maxHit;
	this->energyPoints = NinjaTrap::energyPoints;
	this->maxEnergyPoints = NinjaTrap::maxEnergyPoints;
	this->level = 1.0;
	this->meleeAttackDamage = NinjaTrap::meleeAttackDamage;
	this->rangedAttackDamage = FragTrap::rangedAttackDamage;
	this->armorDamageReduction = FragTrap::armorDamageReduction;
	std::cout << this->name << ": I'm a SuperTrap!" << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x10(%rdi), %rbx
leaq -0x78(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%rsi), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq -0x88(%rbp), %r12
movq %r12, %rdi
callq 0x2940
movq %rbx, %rdi
movq %r12, %rsi
callq 0x239c
movq -0x88(%rbp), %rdi
cmpq %r13, %rdi
je 0x42f7
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x2100
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq -0x68(%rbp), %rdi
callq 0x2940
leaq 0x3937(%rip), %rsi      # 0x7c50
leaq -0x68(%rbp), %rdx
movq %r14, %rdi
callq 0x31bc
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x433a
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x2100
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %rdi
callq 0x2940
leaq 0x8(%r14), %r15
leaq 0x3900(%rip), %rsi      # 0x7c60
leaq -0x48(%rbp), %rdx
movq %r15, %rdi
callq 0x29dc
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x4381
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2100
leaq 0x3820(%rip), %rax      # 0x7ba8
movq %rax, (%r14)
leaq 0x3896(%rip), %rax      # 0x7c28
movq %rax, 0x10(%r14)
leaq 0x3843(%rip), %rax      # 0x7be0
movq %rax, 0x8(%r14)
movl $0x3f800000, 0x28(%r14) # imm = 0x3F800000
movq 0x30(%r14), %rsi
movq 0x38(%r14), %rdx
movq 0x3c20(%rip), %rdi      # 0x7fd8
callq 0x2110
movq %rax, %r12
leaq 0x1111(%rip), %rsi      # 0x54d8
movl $0x12, %edx
movq %rax, %rdi
callq 0x2110
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x20f0
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2090
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x4478
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2100
jmp 0x4478
movq %rax, %r12
jmp 0x4478
movq %rax, %r12
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x4487
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x2100
jmp 0x4487
movq %rax, %r12
jmp 0x4487
movq %rax, %r12
movq -0x88(%rbp), %rdi
cmpq %r13, %rdi
je 0x448f
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x2100
jmp 0x448f
movq %rax, %r12
leaq 0x37f0(%rip), %rsi      # 0x7c60
movq %r15, %rdi
callq 0x2d44
leaq 0x37d1(%rip), %rsi      # 0x7c50
movq %r14, %rdi
callq 0x3534
movq %rbx, %rdi
callq 0x25b8
movq %r12, %rdi
callq 0x2150
nop
// File: /workspace/github_cpp_makefile_star2_O1/t0mm4rx[P]piscine_cpp/day03/ex04/main.cpp
// Function: main
int main(void)
{
	SuperTrap	alpha("Alpha");
	ScavTrap	lucie("Lucie");

	srand(time(0));
	alpha.meleeAttack("John");
	alpha.rangedAttack("Rose");
	alpha.vaulthunter_dot_exe("Micheal");
	alpha.ninjaShoebox(lucie);
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
leaq -0x60(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0xa5d(%rip), %rsi       # 0x550e
leaq 0xa5b(%rip), %rdx       # 0x5513
leaq -0x70(%rbp), %rbx
movq %rbx, %rdi
callq 0x4cb6
leaq -0xd0(%rbp), %rdi
movq %rbx, %rsi
callq 0x4298
movq -0x70(%rbp), %rdi
cmpq %r14, %rdi
je 0x4ae8
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x2100
leaq -0x40(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0xa1d(%rip), %rsi       # 0x5514
leaq 0xa1b(%rip), %rdx       # 0x5519
leaq -0x50(%rbp), %rdi
callq 0x4cb6
leaq -0x120(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x3bb4
movq -0x50(%rbp), %rdi
cmpq %r14, %rdi
je 0x4b2c
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2100
xorl %edi, %edi
callq 0x20d0
movl %eax, %edi
callq 0x20e0
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x9d1(%rip), %rsi       # 0x551a
leaq 0x9ce(%rip), %rdx       # 0x551e
leaq -0x30(%rbp), %rdi
callq 0x4cb6
leaq -0xd0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x4a68
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x4b7e
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x2100
leaq -0x30(%rbp), %rdi
movq %r14, (%rdi)
leaq 0x993(%rip), %rsi       # 0x551f
leaq 0x990(%rip), %rdx       # 0x5523
callq 0x4cb6
leaq -0xd0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x4a38
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x4bbd
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x2100
leaq -0x30(%rbp), %rdi
movq %r14, (%rdi)
leaq 0x959(%rip), %rsi       # 0x5524
leaq 0x959(%rip), %rdx       # 0x552b
callq 0x4cb6
leaq -0xc8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2e64
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x4bfc
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x2100
leaq -0xd0(%rbp), %rdi
leaq -0x120(%rbp), %rsi
callq 0x373c
leaq -0x120(%rbp), %rdi
callq 0x3dac
leaq -0xd0(%rbp), %rdi
callq 0x4960
xorl %eax, %eax
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x4c59
jmp 0x4c3f
jmp 0x4c59
jmp 0x4c3f
jmp 0x4c59
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x4c5c
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x2100
jmp 0x4c5c
movq %rax, %rbx
leaq -0x120(%rbp), %rdi
callq 0x3dac
leaq -0xd0(%rbp), %rdi
callq 0x4960
movq %rbx, %rdi
callq 0x2150
movq %rax, %rbx
movq -0x50(%rbp), %rdi
cmpq %r14, %rdi
je 0x4c68
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2100
jmp 0x4c68
movq %rax, %rbx
jmp 0x4c68
movq %rax, %rbx
movq -0x70(%rbp), %rdi
cmpq %r14, %rdi
je 0x4c74
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x2100
jmp 0x4c74
nop
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH02_VariablesAndBasicTypes/examples/scope_levels.cc
// Function: main
int main()
{
	int unique = 0; // unique has block scope

	// output #1: uses global reused; prints 42 0
	std::cout << reused << " " << unique << std::endl;   

	int reused = 0; // new, local object named reused hides global reused

	// output #2: uses local reused; prints 0 0
	std::cout << reused << " " <<  unique << std::endl;  

	// output #3: explicitly requests the global reused; prints 42 0
	std::cout << ::reused << " " <<  unique << std::endl;  

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl 0x2e74(%rip), %esi      # 0x4060
movq 0x2de5(%rip), %r14      # 0x3fd8
movq %r14, %rdi
callq 0x1090
movq %rax, %r15
leaq 0xdff(%rip), %rbx       # 0x2004
movl $0x1, %edx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1070
movq %r15, %rdi
xorl %esi, %esi
callq 0x1090
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %r15, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
movq %r14, %rdi
xorl %esi, %esi
callq 0x1090
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1070
movq %r15, %rdi
xorl %esi, %esi
callq 0x1090
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %r15, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
movl 0x2dc0(%rip), %esi      # 0x4060
movq %r14, %rdi
callq 0x1090
movq %rax, %r14
movl $0x1, %edx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1070
movq %r14, %rdi
xorl %esi, %esi
callq 0x1090
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/nightmeng[P]net/examples/http/httptest.cpp
// Function: handle_read(int, int, socket&)
void handle_read(int ec, int transfered, socket &sock){
	std::cout << buff << std::endl;
	bzero(buff, 2048);
	sock.async_read(buff, 2048, std::bind(handle_read, std::placeholders::_1,
				std::placeholders::_2, std::ref(sock)));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
leaq 0x9c5d(%rip), %r14      # 0xd1f0
movq %r14, %rdi
callq 0x30e0
movq 0x9a2e(%rip), %r15      # 0xcfd0
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x3220
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %r15, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3150
movl $0x800, %esi            # imm = 0x800
movq %r14, %rdi
callq 0x3300
xorps %xmm0, %xmm0
leaq -0x40(%rbp), %r15
movaps %xmm0, 0x10(%r15)
movaps %xmm0, (%r15)
movl $0x10, %edi
callq 0x3200
leaq -0x89(%rip), %rcx       # 0x357c
movq %rcx, (%rax)
movq %rbx, 0x8(%rax)
movq %rax, (%r15)
leaq 0x398(%rip), %rax       # 0x39ae
movq %rax, 0x18(%r15)
leaq 0x3a5(%rip), %rax       # 0x39c6
movq %rax, 0x10(%r15)
movl $0x800, %edx            # imm = 0x800
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0x5168
movq -0x30(%rbp), %rax
testq %rax, %rax
je 0x364f
leaq -0x40(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x367e
movq %rax, %rbx
movq -0x30(%rbp), %rax
testq %rax, %rax
je 0x3676
leaq -0x40(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x3310
movq %rax, %rdi
callq 0x399f
// File: /workspace/github_cpp_makefile_star2_O1/tsoding[P]cxx-invert-file-tree/generator.cpp
// Function: main
int main(int argc, char **argv)
{
    if (argc < 2) {
        usage(std::cerr);
        std::cerr << "ERROR: folder path is not provided" << std::endl;
        return 1;
    }

    srand(time(nullptr));

    fs::path folder_path(argv[1]);
    fs::create_directory(folder_path);
    std::cout << "Created Folder: " << folder_path << std::endl;
    generate_tree(folder_path);

    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpl $0x1, %edi
jg 0x3856
movq 0x37e7(%rip), %rbx      # 0x6ff0
movq %rbx, %rdi
callq 0x326c
leaq 0x182f(%rip), %rsi      # 0x5047
movl $0x22, %edx
movq %rbx, %rdi
callq 0x21f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
movl $0x1, %ebx
jmp 0x38eb
movq %rsi, %rbx
xorl %edi, %edi
callq 0x2180
movl %eax, %edi
callq 0x2190
addq $0x8, %rbx
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
movl $0x2, %edx
callq 0x3aa4
movq %r14, %rdi
callq 0x20d0
movq 0x3743(%rip), %rdi      # 0x6fd0
leaq 0x1793(%rip), %rsi      # 0x5027
movl $0x10, %edx
callq 0x21f0
movq 0x372b(%rip), %rdi      # 0x6fd0
movq %rsp, %rsi
callq 0x3a1c
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
xorl %ebx, %ebx
movq %rsp, %rdi
xorl %esi, %esi
callq 0x32c7
movq %rsp, %rdi
callq 0x39e4
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x39e4
movq %rbx, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O1/antoniogarro[P]Hara/engine.cpp
// Function: Engine::Engine(Goban*)
Engine::Engine(Goban *goban):tree(DEF_TREESIZE, goban), amaf(goban->get_size())
{
  main_goban = goban;
  max_playouts = DEF_PLAYOUTS;
  max_time = 10*CLOCKS_PER_SEC;
  max_time = INFINITE;
  tree_size = DEF_TREESIZE;
  rand_movs = 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movw $0x1, (%rdi)
addq $0x28, %rdi
movl $0x4c4b40, %esi         # imm = 0x4C4B40
movq %r14, %rdx
callq 0xa41e
movl 0x8(%r14), %eax
cmpl $0x13, %eax
movl $0x13, %ecx
cmovll %eax, %ecx
movl %ecx, 0x5f8(%rbx)
movb $0x0, 0x5fc(%rbx)
movq $-0x1, %rax
movl $0x0, 0x54(%rbx,%rax,4)
movl 0x5f8(%rbx), %ecx
imull %ecx, %ecx
incq %rax
cmpq %rcx, %rax
jb 0x365f
movq %r14, 0x8(%rbx)
movq $0x7fffffff, 0x608(%rbx) # imm = 0x7FFFFFFF
movabsq $0xbb8004c4b40, %rax    # imm = 0xBB8004C4B40
movq %rax, 0x10(%rbx)
movl $0x0, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/antoniogarro[P]Hara/engine.cpp
// Function: Engine::set_times(int, int, int)
void Engine::set_times(int main_time, int byo_time, int stones)
{
  max_playouts = INFINITE;
  this->byo_time = byo_time;
  if (stones) {
    max_time = (main_time/10 + byo_time/stones)*CLOCKS_PER_SEC;
  } else {
    max_time = (0.9*byo_time + main_time/60)*CLOCKS_PER_SEC;
  }
}

// Assembly:
movl $0x7fffffff, 0x14(%rdi) # imm = 0x7FFFFFFF
movslq %edx, %rax
movq %rax, 0x610(%rdi)
testl %ecx, %ecx
je 0x373e
movslq %esi, %rax
imulq $0x66666667, %rax, %rsi # imm = 0x66666667
movq %rsi, %rax
shrq $0x3f, %rax
sarq $0x22, %rsi
addl %eax, %esi
movl %edx, %eax
cltd
idivl %ecx
addl %esi, %eax
cltq
imulq $0xf4240, %rax, %rax    # imm = 0xF4240
jmp 0x3779
cvtsi2sd %edx, %xmm0
movslq %esi, %rax
imulq $-0x77777777, %rax, %rax # imm = 0x88888889
shrq $0x20, %rax
addl %esi, %eax
movl %eax, %ecx
shrl $0x1f, %ecx
sarl $0x5, %eax
addl %ecx, %eax
cvtsi2sd %eax, %xmm1
mulsd 0x78a0(%rip), %xmm0     # 0xb008
addsd %xmm1, %xmm0
mulsd 0x789c(%rip), %xmm0     # 0xb010
cvttsd2si %xmm0, %rax
movq %rax, 0x608(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/antoniogarro[P]Hara/engine.cpp
// Function: Engine::set_times(int, int)
void Engine::set_times(int time_left, int stones)
{
  max_playouts = INFINITE;
  if (stones) max_time = (0.9*time_left/stones)*CLOCKS_PER_SEC;
  else max_time = (0.9*time_left + byo_time)*CLOCKS_PER_SEC;
  std::cerr << max_time << "\n";
}

// Assembly:
movl $0x7fffffff, 0x14(%rdi) # imm = 0x7FFFFFFF
cvtsi2sd %esi, %xmm0
testl %edx, %edx
je 0x37a3
mulsd 0x786f(%rip), %xmm0     # 0xb008
cvtsi2sd %edx, %xmm1
divsd %xmm1, %xmm0
jmp 0x37b8
cvtsi2sdq 0x610(%rdi), %xmm1
mulsd 0x7854(%rip), %xmm0     # 0xb008
addsd %xmm1, %xmm0
pushq %rax
mulsd 0x784f(%rip), %xmm0     # 0xb010
cvttsd2si %xmm0, %rsi
movq %rsi, 0x608(%rdi)
movq 0xc81c(%rip), %rdi      # 0xfff0
callq 0x31a0
leaq 0x7e44(%rip), %rsi      # 0xb624
movl $0x1, %edx
movq %rax, %rdi
popq %rax
jmp 0x31f0
// File: /workspace/github_cpp_makefile_star2_O1/antoniogarro[P]Hara/engine.cpp
// Function: Engine::play_random_game(bool)
int Engine::play_random_game(bool heavy)
{
  int pass = 0;
  main_goban->shuffle_empty();
  while (pass < 2) {
    int move = heavy ? main_goban->play_heavy() : main_goban->play_random();
    amaf.play(move, ++simul_len);
    rand_movs++;
    if (move == Goban::PASS) pass++;
    else pass = 0;
#ifdef DEBUG_INFO
      main_goban->print_goban();
#endif
    int mercy = main_goban->mercy();    
    if (mercy != -1) {
      return 1-mercy;
    }
//#ifdef DEBUG_INFO
    if (simul_len > 2*main_goban->get_size2()) {
      std::cerr << "WARNING: Simulation exceeded max length.\n";
      discarded++;
      return -1;
    }
//#endif
  }
    return (main_goban->chinese_count() > 0) ? 1:0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl $0xfc120, %edi          # imm = 0xFC120
addq 0x8(%r14), %rdi
callq 0x3ef0
xorl %r13d, %r13d
leaq 0x781e(%rip), %r12      # 0xb034
xorl %r15d, %r15d
movq 0x8(%r14), %rdi
cmpl $0x1, %r15d
jg 0x38d1
testb %bl, %bl
je 0x3832
callq 0x84d2
jmp 0x3837
callq 0x84ae
movl 0x1c(%r14), %edx
leal 0x1(%rdx), %esi
movl %esi, 0x1c(%r14)
movslq %eax, %rdi
cmpl $0x0, 0x50(%r14,%rdi,4)
je 0x3856
movb 0x5fc(%r14), %cl
jmp 0x3869
movb 0x5fc(%r14), %cl
notl %edx
testb %cl, %cl
cmovnel %edx, %esi
movl %esi, 0x50(%r14,%rdi,4)
xorb $0x1, %cl
movb %cl, 0x5fc(%r14)
incl 0x18(%r14)
incl %r15d
testl %eax, %eax
cmovnel %r13d, %r15d
movq 0x8(%r14), %rdi
callq 0x5964
cmpl $-0x1, %eax
je 0x3897
movl $0x1, %ebp
subl %eax, %ebp
jmp 0x38c5
movq 0x8(%r14), %rax
movl 0xc(%rax), %ecx
addl %ecx, %ecx
movb $0x1, %al
cmpl %ecx, 0x1c(%r14)
jle 0x38c7
movl $0x29, %edx
movq 0xc73c(%rip), %rdi      # 0xfff0
movq %r12, %rsi
callq 0x31f0
incl 0x20(%r14)
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
xorl %eax, %eax
testb %al, %al
jne 0x3819
jmp 0x38e2
callq 0x579e
xorps %xmm1, %xmm1
xorl %ebp, %ebp
ucomiss %xmm1, %xmm0
seta %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/antoniogarro[P]Hara/engine.cpp
// Function: Engine::back_up_results(int, Node**, int, bool)
void Engine::back_up_results(int result, Node *node_history[], int nnodes, bool side)
{
  for (int i = 0; i < nnodes; i++) {
    node_history[i]->set_results(1-result); //Because root node belongs to opponent.
    node_history[i]->set_amaf(result, amaf, side, i+1);
    side = !side;
    result = 1-result;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, (%rsp)
testl %ecx, %ecx
jle 0x3bdf
movl %r8d, %ebx
movq %rdx, %r14
movl %esi, %ebp
addq $0x50, (%rsp)
movl %ecx, %r15d
xorl %r12d, %r12d
movq (%r14,%r12,8), %rdi
movl $0x1, %r13d
subl %ebp, %r13d
movl %r13d, %esi
callq 0x9dea
movq (%r14,%r12,8), %rdi
incq %r12
movzbl %bl, %ebx
movl %ebx, %ecx
andl $0x1, %ecx
movl %ebp, %esi
movq (%rsp), %rdx
movl %r12d, %r8d
callq 0x9e0c
xorb $0x1, %bl
movl %r13d, %ebp
cmpq %r12, %r15
jne 0x3ba2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/antoniogarro[P]Hara/engine.cpp
// Function: Engine::print_PV() const
void Engine::print_PV() const
{
  fin_clock = clock() - fin_clock;
  tree.print();
  int nplayouts = tree.get_root()->get_visits();
  std::cerr << "#Playouts: " << nplayouts
            << ", average length: " << rand_movs/nplayouts
            << ", discarded: " << discarded << ", playouts/sec: "
            << (float)nplayouts/fin_clock*CLOCKS_PER_SEC << "\n";
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x3100
subq 0x600(%rbx), %rax
movq %rax, 0x600(%rbx)
leaq 0x28(%rbx), %rdi
callq 0xa97c
movslq 0x44(%rbx), %rax
movq 0x28(%rbx,%rax,8), %rax
movsd 0x8(%rax), %xmm0
movapd %xmm0, (%rsp)
cvttsd2si %xmm0, %ebp
movq 0xc3bd(%rip), %r14      # 0xfff0
leaq 0x7424(%rip), %rsi      # 0xb05e
movl $0xb, %edx
movq %r14, %rdi
callq 0x31f0
movq %r14, %rdi
movl %ebp, %esi
callq 0x32f0
movq %rax, %r14
leaq 0x740f(%rip), %rsi      # 0xb06a
movl $0x12, %edx
movq %rax, %rdi
callq 0x31f0
movl 0x18(%rbx), %eax
cltd
idivl %ebp
movq %r14, %rdi
movl %eax, %esi
callq 0x32f0
movq %rax, %r14
leaq 0x73fb(%rip), %rsi      # 0xb07d
movl $0xd, %edx
movq %rax, %rdi
callq 0x31f0
movl 0x20(%rbx), %esi
movq %r14, %rdi
callq 0x32f0
movq %rax, %r14
leaq 0x73e7(%rip), %rsi      # 0xb08b
movl $0x10, %edx
movq %rax, %rdi
callq 0x31f0
cvttpd2dq (%rsp), %xmm0
cvtdq2ps %xmm0, %xmm0
cvtsi2ssq 0x600(%rbx), %xmm1
divss %xmm1, %xmm0
mulss 0x7362(%rip), %xmm0     # 0xb030
cvtss2sd %xmm0, %xmm0
movq %r14, %rdi
callq 0x32a0
leaq 0x7943(%rip), %rsi      # 0xb624
movl $0x1, %edx
movq %rax, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x31f0
// File: /workspace/github_cpp_makefile_star2_O1/antoniogarro[P]Hara/engine.cpp
// Function: Engine::score(std::vector<int, std::allocator<int>>*)
float Engine::score(std::vector<int> *dead)
{
  const int PLAYOUTS = 5000;
  int score = 0;
  int score_table[MAXSIZE2+1] = {0};
  for (int i = 0; i < PLAYOUTS; i++) {
    simul_len = 0;
    play_random_game(LIGHT);
    main_goban->score_area(score_table);
    main_goban->restore();
  }
  for (int i = 1; i <= main_goban->get_size2(); i++) {
    if (score_table[i] > PLAYOUTS/2) score_table[i] = 1;
    else if (score_table[i] < -PLAYOUTS/2) score_table[i] = -1;
    else score_table[i] = 0;
    
    if (dead && main_goban->get_value(i)
        && score_table[i] !=  main_goban->get_value(i)) {
      dead->insert(dead->end(), i);
    }
  }

  for (int i = 1; i <= main_goban->get_size2(); i++) {
    score += score_table[i];
  }
  return score - main_goban->get_komi();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x5c0, %rsp            # imm = 0x5C0
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rsp), %r15
movl $0x5a8, %edx            # imm = 0x5A8
movq %r15, %rdi
xorl %esi, %esi
callq 0x30e0
movl $0x1388, %ebp           # imm = 0x1388
movl $0x0, 0x1c(%r14)
movzbl 0x1(%r14), %esi
movq %r14, %rdi
callq 0x37ee
movq 0x8(%r14), %rdi
movq %r15, %rsi
callq 0x5890
movq 0x8(%r14), %rdi
callq 0x47a0
decl %ebp
jne 0x3d24
movl $0x1, 0xc(%rsp)
movq 0x8(%r14), %rdi
movl 0xc(%rdi), %eax
testl %eax, %eax
jle 0x3de0
movl $0x1, %ebp
leaq 0xc(%rsp), %r15
movl $0x1, %esi
movslq %esi, %rax
movl 0x10(%rsp,%rax,4), %ecx
xorl %edx, %edx
cmpl $0xfffff63c, %ecx       # imm = 0xFFFFF63C
setl %dl
negl %edx
cmpl $0x9c5, %ecx            # imm = 0x9C5
cmovgel %ebp, %edx
movl %edx, 0x10(%rsp,%rax,4)
testq %rbx, %rbx
je 0x3dca
callq 0x5784
testl %eax, %eax
je 0x3dca
movslq 0xc(%rsp), %rsi
movl 0x10(%rsp,%rsi,4), %r12d
movq 0x8(%r14), %rdi
callq 0x5784
cmpl %eax, %r12d
je 0x3dca
movq 0x8(%rbx), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x3e76
movl 0xc(%rsp), %ecx
leal 0x1(%rcx), %esi
movl %esi, 0xc(%rsp)
movq 0x8(%r14), %rdi
movl 0xc(%rdi), %eax
cmpl %eax, %ecx
jl 0x3d74
testl %eax, %eax
jle 0x3dff
incl %eax
xorl %ecx, %ecx
movl $0x1, %edx
addl 0x10(%rsp,%rdx,4), %ecx
incq %rdx
cmpq %rdx, %rax
jne 0x3ded
cvtsi2ss %ecx, %xmm0
jmp 0x3e02
xorps %xmm0, %xmm0
subss 0x10(%rdi), %xmm0
addq $0x5c0, %rsp            # imm = 0x5C0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/antoniogarro[P]Hara/engine.cpp
// Function: Engine::perft(int)
void Engine::perft(int max)
{
  for (int i = 0; i < max; i++) {
    simul_len = 0;
    play_random_game(LIGHT);
    std::cerr << "restoring\n";
    main_goban->restore();
  }
}

// Assembly:
testl %esi, %esi
jle 0x3e74
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq 0xc1c0(%rip), %r15      # 0xfff0
leaq 0x7265(%rip), %r12      # 0xb09c
movl $0x0, 0x1c(%r14)
movzbl 0x1(%r14), %esi
movq %r14, %rdi
callq 0x37ee
movl $0xa, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x31f0
movq 0x8(%r14), %rdi
callq 0x47a0
decl %ebx
jne 0x3e37
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/antoniogarro[P]Hara/goban.cpp
// Function: Goban::Goban(int)
Goban::Goban(int newsize)
{
  size = (newsize <= MAXSIZE) ? newsize : size;
  size2 = size*size;
  komi = 0.5;
  clear();
  init_adjacent();
  init_diagonals();
  init_vicinity();
  init_distance();
  init_manhattan();
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movl $0xb68, %r14d           # imm = 0xB68
leaq (%rbx,%r14), %rdi
callq 0x5dfc
addq $0x970, %r14            # imm = 0x970
cmpq $0xd63c8, %r14          # imm = 0xD63C8
jne 0x40b3
leaq 0xbbbd(%rip), %rax      # 0xfc90
movq %rax, 0xfc120(%rbx)
xorl %r14d, %r14d
movl %r14d, 0xfc6d0(%rbx)
movl %r14d, 0xfc128(%rbx)
leaq 0xbbe6(%rip), %rax      # 0xfcd8
movq %rax, 0xfc6d8(%rbx)
movl %r14d, 0xfd7cc(%rbx)
movl %r14d, 0xfc6e0(%rbx)
leaq 0xfd7d0(%rbx), %rdi
callq 0xac30
cmpl $0x14, %ebp
jl 0x411b
movl 0x8(%rbx), %ebp
movl %ebp, 0x8(%rbx)
imull %ebp, %ebp
movl %ebp, 0xc(%rbx)
movl $0x3f000000, 0x10(%rbx) # imm = 0x3F000000
movq %rbx, %rdi
callq 0x46ec
movl %r14d, 0x14(%rbx)
movl %r14d, 0xfd7cc(%rbx)
movl %r14d, 0xfc6e0(%rbx)
movq %rbx, %rdi
callq 0x418e
movq %rbx, %rdi
callq 0x422e
movq %rbx, %rdi
callq 0x42fc
movq %rbx, %rdi
callq 0x440c
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x4452
nop
// File: /workspace/github_cpp_makefile_star2_O1/antoniogarro[P]Hara/goban.cpp
// Function: Goban::init_adjacent()
void Goban::init_adjacent()
{
  for (int k = 1; k <= size2; k++) {
    int nadj = 0;
    if (k <= size*(size-1)) {  //N
      adjacent[k][nadj++] =  k + size;
    }
    if (k % size) {  //E
      adjacent[k][nadj++] =  k + 1;
    }
    if (k > size) {  //S
      adjacent[k][nadj++] = k - size;
    }
    if (k % size != 1) {  //W
      adjacent[k][nadj++] = k -1;
    }
    adjacent[k][nadj] = 0;
  }
}

// Assembly:
cmpl $0x0, 0xc(%rdi)
jle 0x422c
pushq %rbp
pushq %r14
pushq %rbx
movslq 0x8(%rdi), %rcx
movl %ecx, %esi
leal -0x1(%rcx), %eax
imull %ecx, %eax
movslq %eax, %r8
movslq 0xc(%rdi), %r9
movl $0x1, %r10d
subl %ecx, %r10d
addq $0xd63fc, %rdi          # imm = 0xD63FC
xorl %r11d, %r11d
leaq 0x1(%r11), %rbx
movl $0x0, %ebp
cmpq %r8, %rbx
jg 0x41dd
leal (%rsi,%r11), %eax
incl %eax
movl %eax, (%rdi)
movl $0x1, %ebp
leal 0x1(%r11), %eax
cltd
idivl %esi
testl %edx, %edx
je 0x41f4
movl %ebp, %eax
incl %ebp
leal 0x2(%r11), %r14d
movl %r14d, (%rdi,%rax,4)
cmpq %rcx, %rbx
jle 0x4206
leal (%r10,%r11), %eax
movl %ebp, %r14d
incl %ebp
movl %eax, (%rdi,%r14,4)
cmpl $0x1, %edx
je 0x4213
movl %ebp, %eax
incl %ebp
movl %r11d, (%rdi,%rax,4)
movl %ebp, %eax
movl $0x0, (%rdi,%rax,4)
addq $0x14, %rdi
movq %rbx, %r11
cmpq %r9, %rbx
jl 0x41c2
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/antoniogarro[P]Hara/goban.cpp
// Function: Goban::init_diagonals()
void Goban::init_diagonals()
{

  for (int k = 1; k <= size2; k++) {
    int ndiag = 0;
    if (k <= size*(size-1) && k % size != 1) {  //NW
      diagonals[k][ndiag++] =  k + size - 1;
    }  
    if (k <= size*(size-1) && k % size) {  //NE
      diagonals[k][ndiag++] =  k + size + 1;
    }
    if (k > size && k % size) {  //SE
      diagonals[k][ndiag++] = k - size +1;
    }
    if (k > size && k % size != 1) {  //SW
      diagonals[k][ndiag++] = k - size -1;
    }
    diagonals[k][ndiag] = 0;
  }
}

// Assembly:
cmpl $0x0, 0xc(%rdi)
jle 0x42fb
leaq 0xd8044(%rdi), %rcx
xorl %esi, %esi
movq %rsi, %r8
incq %rsi
movl 0x8(%rdi), %r9d
leal -0x1(%r9), %eax
imull %r9d, %eax
movslq %eax, %r11
movl $0x0, %r10d
cmpq %r11, %rsi
jg 0x427a
leal 0x1(%r8), %eax
cltd
idivl %r9d
cmpl $0x1, %edx
je 0x427a
leal (%r8,%r9), %eax
movl %eax, (%rcx)
movl $0x1, %r10d
cmpq %r11, %rsi
jg 0x429b
leal 0x1(%r8), %eax
cltd
idivl %r9d
testl %edx, %edx
je 0x429b
leal (%r8,%r9), %eax
addl $0x2, %eax
movl %r10d, %edx
incl %r10d
movl %eax, (%rcx,%rdx,4)
movslq %r9d, %r11
cmpq %r11, %rsi
jle 0x42c1
leal 0x1(%r8), %eax
cltd
idivl %r9d
testl %edx, %edx
je 0x42c1
movl %r8d, %eax
subl %r9d, %eax
addl $0x2, %eax
movl %r10d, %edx
incl %r10d
movl %eax, (%rcx,%rdx,4)
cmpq %r11, %rsi
jle 0x42e0
leal 0x1(%r8), %eax
cltd
idivl %r9d
cmpl $0x1, %edx
je 0x42e0
subl %r9d, %r8d
movl %r10d, %eax
incl %r10d
movl %r8d, (%rcx,%rax,4)
movl %r10d, %eax
movl $0x0, (%rcx,%rax,4)
movslq 0xc(%rdi), %rax
addq $0x14, %rcx
cmpq %rax, %rsi
jl 0x4241
retq
// File: /workspace/github_cpp_makefile_star2_O1/antoniogarro[P]Hara/goban.cpp
// Function: Goban::init_vicinity()
void Goban::init_vicinity()
{  
  for (int i = 0; i <= size2; i++) {
    for (int j = 0; j < 16; j++) {
      vicinity[i][j] = 0;
    }
  }
  //Duplicate to calculate rotations,avoiding run-time modulo division:
  for (int i = 0; i < 2; i++) {
    for (int k = 1; k <= size2; k++) {
      if (k <= size*(size-1)) {
        if (k % size != 1) {  //NW
          vicinity[k][0+8*i] =  k + size - 1;
        }
        vicinity[k][1+8*i] =  k + size;  //N
      }
      if (k % size ) {
        if (k <= size*(size-1)) {  //NE
          vicinity[k][2+8*i] =  k + size + 1;
        }
        vicinity[k][3+8*i] =  k + 1;  //E
      }
      if (k > size) {
        if (k % size) {  //SE
          vicinity[k][4+8*i] = k - size +1;
        }
        vicinity[k][5+8*i] = k - size;  //S
      }
      if (k % size != 1) {
        if (k > size) {  //SW
          vicinity[k][6+8*i] = k - size -1;
        }
        vicinity[k][7+8*i] = k - 1;  //W
      }
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0xc(%rdi), %r14d
testl %r14d, %r14d
js 0x4329
leaq 0xd9c78(%rbx), %rdi
movq %r14, %rdx
shlq $0x6, %rdx
addq $0x40, %rdx
xorl %esi, %esi
callq 0x30e0
movslq 0x8(%rbx), %rcx
movl %ecx, %esi
leal -0x1(%rcx), %eax
imull %ecx, %eax
movslq %eax, %rdi
leal 0x1(%r14), %r8d
movl %ecx, %r9d
negl %r9d
addq $0xd9cd4, %rbx          # imm = 0xD9CD4
decq %r8
xorl %r10d, %r10d
testl %r14d, %r14d
jle 0x43eb
movq %rbx, %r11
xorl %r15d, %r15d
leaq 0x1(%r15), %r12
cmpq %rdi, %r12
jg 0x4385
leal 0x1(%r15), %eax
cltd
idivl %esi
cmpl $0x1, %edx
je 0x437b
leal (%rsi,%r15), %eax
movl %eax, -0x1c(%r11)
leal (%rsi,%r15), %eax
incl %eax
movl %eax, -0x18(%r11)
leal 0x1(%r15), %eax
cltd
idivl %esi
testl %edx, %edx
je 0x43a8
cmpq %rdi, %r12
jg 0x43a0
leal (%rsi,%r15), %eax
addl $0x2, %eax
movl %eax, -0x14(%r11)
leal 0x2(%r15), %eax
movl %eax, -0x10(%r11)
cmpq %rcx, %r12
jle 0x43c6
testl %edx, %edx
je 0x43bc
leal (%r9,%r15), %eax
addl $0x2, %eax
movl %eax, -0xc(%r11)
leal (%r9,%r15), %eax
incl %eax
movl %eax, -0x8(%r11)
cmpl $0x1, %edx
je 0x43db
cmpq %rcx, %r12
jle 0x43d8
leal (%r9,%r15), %eax
movl %eax, -0x4(%r11)
movl %r15d, (%r11)
addq $0x40, %r11
movq %r12, %r15
cmpq %r12, %r8
jne 0x435e
leaq 0x1(%r10), %rax
addq $0x20, %rbx
testq %r10, %r10
movq %rax, %r10
je 0x434f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/antoniogarro[P]Hara/goban.cpp
// Function: Goban::init_distance()
void Goban::init_distance()
{
  for (int p = 0; p <= size2; p++) {
    int d = (p-1)%size < (p-1)/size ? (p-1)%size : (p-1)/size;
    if (size - (p-1)%size - 1 < d) {
      d = size - (p-1)%size - 1;
    }
    if (size - (p-1)/size - 1 < d) {
      d = size - (p-1)/size - 1;
    }
    distance_to_edge[p] = d;
  }
}

// Assembly:
movl 0xc(%rdi), %ecx
testl %ecx, %ecx
js 0x4450
movl 0x8(%rdi), %esi
incq %rcx
xorl %r8d, %r8d
leal -0x1(%r8), %eax
cltd
idivl %esi
cmpl %eax, %edx
movl %eax, %r9d
cmovll %edx, %r9d
notl %edx
addl %esi, %edx
cmpl %r9d, %edx
cmovgel %r9d, %edx
notl %eax
addl %esi, %eax
cmpl %edx, %eax
cmovgel %edx, %eax
movl %eax, 0xdf6f8(%rdi,%r8,4)
incq %r8
cmpq %r8, %rcx
jne 0x441c
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/antoniogarro[P]Hara/goban.cpp
// Function: Goban::reset()
void Goban::reset()
{
  side = BLACK;
  ko_point = 0;
#ifdef ZOBRIST
  zobrist.reset();
#endif
  stones_on_board[BLACK] = 0, stones_on_board[WHITE] = 0;
  last_atari[BLACK] = 0, last_atari[WHITE] = 0;
  last_point = 0, last_point2 = 0;
  
  for (int i = 0; i <= size2; i++) {
    if (Group *point = points[i]) {
      point->clear();
    }
    points[i] = 0;
  }
  empty_points.clear();
  for (int j = 0; j < size2; j++) {
    empty_points.add(j+1);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb $0x0, (%rdi)
movl $0x0, 0x4(%rdi)
addq $0xfd7d0, %rdi          # imm = 0xFD7D0
callq 0xae92
xorps %xmm0, %xmm0
movups %xmm0, 0xd63d8(%rbx)
movups %xmm0, 0xd63c8(%rbx)
cmpl $0x0, 0xc(%rbx)
js 0x474b
movq $-0x1, %r14
movq 0x20(%rbx,%r14,8), %rdi
testq %rdi, %rdi
je 0x4736
callq 0x5f4c
movq $0x0, 0x20(%rbx,%r14,8)
movslq 0xc(%rbx), %rax
incq %r14
cmpq %rax, %r14
jl 0x4727
xorl %eax, %eax
movl %eax, 0xfc6d0(%rbx)
movl %eax, 0xfc128(%rbx)
cmpl %eax, 0xc(%rbx)
jle 0x4797
incl %eax
movslq 0xfc6d0(%rbx), %rcx
cmpq $0x16a, %rcx            # imm = 0x16A
je 0x4792
leal 0x1(%rcx), %edx
movl %edx, 0xfc6d0(%rbx)
movl %eax, 0xfc128(%rbx,%rcx,4)
movslq 0xfc6d0(%rbx), %rcx
movl $0x0, 0xfc128(%rbx,%rcx,4)
cmpl 0xc(%rbx), %eax
jl 0x475e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/antoniogarro[P]Hara/goban.cpp
// Function: Goban::restore()
void Goban::restore()
{
  reset();
  set_fixed_handicap(handicap);
  for (int i = 0; i < game_history.length(); i++) {
    if (game_history[i]) {
      drop_stone(game_history[i], side);
      side = !side;
    } else {
      side = !side;
    }
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x46ec
movl 0x14(%rbx), %esi
movq %rbx, %rdi
callq 0x47f4
cmpl $0x0, 0xfd7cc(%rbx)
jle 0x47ec
xorl %r14d, %r14d
movl 0xfc6e0(%rbx,%r14,4), %esi
testl %esi, %esi
je 0x47da
movzbl (%rbx), %edx
movq %rbx, %rdi
callq 0x484a
xorb $0x1, (%rbx)
incq %r14
movslq 0xfd7cc(%rbx), %rax
cmpq %rax, %r14
jl 0x47c3
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/antoniogarro[P]Hara/goban.cpp
// Function: Goban::drop_stone(int, bool)
int Goban::drop_stone(int point, bool color)
{
  if (points[point] != 0) print_goban();
  
  PointSet<5> liberties;
  point_liberties(point, liberties);
  
  groups[point].set_up(point, color, liberties);
  points[point] = &(groups[point]);
  remove_empty(point);
  stones_on_board[color]++;
#ifdef ZOBRIST
  zobrist.update(point, color);
  zobrist.toggle_ko(ko_point);
#endif
  ko_point = handle_neighbours(point);
#ifdef ZOBRIST
  zobrist.toggle_ko(ko_point);
#endif
  if (points[point]->get_nliberties() == 0) {    //suicide.
      erase_neighbour(points[point]);
  } else if (points[point]->has_one_liberty()) { //self-atari.
    last_atari[color] = points[point] ;
  }
  last_point2 = last_point;
  last_point = point;
  return point;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %r12d
movl %esi, %ebx
movq %rdi, %r14
movslq %esi, %r15
cmpq $0x0, 0x18(%rdi,%r15,8)
je 0x4873
movq %r14, %rdi
callq 0x59a6
xorl %eax, %eax
leaq 0x8(%rsp), %r13
movl %eax, 0x1c(%r13)
movl %eax, 0x8(%r13)
leaq 0xb367(%rip), %rax      # 0xfbf0
movq %rax, (%r13)
movq %r14, %rdi
movl %r15d, %esi
movq %r13, %rdx
callq 0x525c
imulq $0x970, %r15, %rax      # imm = 0x970
leaq (%r14,%rax), %rbp
addq $0xb68, %rbp            # imm = 0xB68
movzbl %r12b, %r12d
movq %rbp, %rdi
movl %r15d, %esi
movl %r12d, %edx
movq %r13, %rcx
callq 0x5e16
movq %rbp, 0x18(%r14,%r15,8)
movslq 0xfc6d0(%r14), %rax
testq %rax, %rax
jle 0x4916
xorl %ecx, %ecx
cmpl %ebx, 0xfc128(%r14,%rcx,4)
je 0x48e9
incq %rcx
cmpq %rcx, %rax
jne 0x48d5
jmp 0x4916
leal -0x1(%rax), %edx
movl %edx, 0xfc6d0(%r14)
movl 0xfc124(%r14,%rax,4), %eax
movl %eax, 0xfc128(%r14,%rcx,4)
movslq 0xfc6d0(%r14), %rax
movl $0x0, 0xfc128(%r14,%rax,4)
incl 0xd63c8(%r14,%r12,4)
leaq 0xfd7d0(%r14), %r13
movq %r13, %rdi
movl %ebx, %esi
movl %r12d, %edx
callq 0xaec0
movl 0x4(%r14), %esi
movq %r13, %rdi
callq 0xaebe
movq %r14, %rdi
movl %ebx, %esi
callq 0x4aa4
movl %eax, 0x4(%r14)
movq %r13, %rdi
movl %eax, %esi
callq 0xaebe
movq 0x18(%r14,%r15,8), %rsi
movl 0x96c(%rsi), %eax
cmpl $0x1, %eax
je 0x4974
testl %eax, %eax
jne 0x497c
movq %r14, %rdi
callq 0x4b9a
jmp 0x497c
movq %rsi, 0xd63d0(%r14,%r12,8)
movl 0xd63e0(%r14), %eax
movl %eax, 0xd63e4(%r14)
movl %ebx, 0xd63e0(%r14)
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/antoniogarro[P]Hara/goban.cpp
// Function: Goban::set_handicap(int const*)
int Goban::set_handicap(const int handicap[])
{  
  for (int i = 0; i < 9 && handicap[i]; i++) {
    drop_stone(handicap[i], BLACK);
#ifdef ZOBRIST
    zobrist.update(handicap[i], 0);
#endif
    }
  side = 1;
#ifdef ZOBRIST
  zobrist.toggle_side();
#endif
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
leaq 0xfd7d0(%rdi), %rbx
xorl %r12d, %r12d
movl (%r15,%r12,4), %esi
testl %esi, %esi
je 0x49e3
movq %r14, %rdi
xorl %edx, %edx
callq 0x484a
movl (%r15,%r12,4), %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0xaec0
incq %r12
cmpq $0x9, %r12
jne 0x49ba
movb $0x1, (%r14)
movq %rbx, %rdi
callq 0xaebc
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/antoniogarro[P]Hara/goban.cpp
// Function: Goban::set_size(int)
int Goban::set_size(int newsize)
{
  size = (newsize <= MAXSIZE) ? newsize : size;
  size2 = size*size;
  init_adjacent();
  init_diagonals();
  init_vicinity();
  init_distance();
  init_manhattan();
  clear();
  return size;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0x14, %esi
jl 0x4a0a
movl 0x8(%rbx), %esi
movl %esi, 0x8(%rbx)
imull %esi, %esi
movl %esi, 0xc(%rbx)
movq %rbx, %rdi
callq 0x418e
movq %rbx, %rdi
callq 0x422e
movq %rbx, %rdi
callq 0x42fc
movq %rbx, %rdi
callq 0x440c
movq %rbx, %rdi
callq 0x4452
movq %rbx, %rdi
callq 0x46ec
xorl %eax, %eax
movl %eax, 0x14(%rbx)
movl %eax, 0xfd7cc(%rbx)
movl %eax, 0xfc6e0(%rbx)
movl 0x8(%rbx), %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/antoniogarro[P]Hara/goban.cpp
// Function: Goban::handle_neighbours(int)
int Goban::handle_neighbours(int point)
{
  int captured_lone = 0, ncapt_lone = 0;
  GroupSet<4> neighbours;
  int nneigh = neighbour_groups(point, neighbours);
  
  for (int i = 0; i < nneigh; i++) {
    Group *current_neigh = neighbours[i];
    if (current_neigh->get_color() == points[point]->get_color()) {
      merge_neighbour(point, current_neigh);
    } else {
      if (current_neigh->has_one_liberty()) {
        if (current_neigh->get_nstones() == 1) {  
          ncapt_lone++;
          captured_lone = current_neigh->get_stone(0);
        }
        erase_neighbour(current_neigh);
      } else {
        current_neigh->erase_liberties(point);
        if (current_neigh->has_one_liberty()) {
          last_atari[current_neigh->get_color()] = current_neigh;
        }
      }
    }
  }
  if (ncapt_lone == 1 && points[point]->get_nstones()== 1) {
    return captured_lone;  //new ko point.
  } else {
    return 0;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x10(%rsp), %rdx
movl $0x0, 0x30(%rdx)
movq $0x0, (%rdx)
callq 0x5210
movslq %ebp, %r12
testl %eax, %eax
jle 0x4b73
movl %eax, %r13d
xorl %r14d, %r14d
movl $0x0, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movq 0x10(%rsp,%r14,8), %r15
movb (%r15), %al
movq 0x18(%rbx,%r12,8), %rcx
cmpb (%rcx), %al
jne 0x4b10
movq %rbx, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x4cb8
jmp 0x4b5d
cmpl $0x1, 0x96c(%r15)
jne 0x4b3d
cmpl $0x1, 0x5a8(%r15)
jne 0x4b30
incl 0x8(%rsp)
movl 0x4(%r15), %eax
movl %eax, 0xc(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4b9a
jmp 0x4b5d
movq %r15, %rdi
movl %ebp, %esi
callq 0x5efa
cmpl $0x1, 0x96c(%r15)
jne 0x4b5d
movzbl (%r15), %eax
movq %r15, 0xd63d0(%rbx,%rax,8)
incq %r14
cmpq %r14, %r13
jne 0x4af0
cmpl $0x1, 0x8(%rsp)
sete %cl
movl 0xc(%rsp), %eax
jmp 0x4b77
xorl %ecx, %ecx
xorl %eax, %eax
testb %cl, %cl
je 0x4b89
movq 0x18(%rbx,%r12,8), %rcx
cmpl $0x1, 0x5a8(%rcx)
je 0x4b8b
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/antoniogarro[P]Hara/goban.cpp
// Function: Goban::erase_neighbour(Group*)
void Goban::erase_neighbour(Group *neigh)
{
  for (Group::StoneIterator st(neigh);  st; ++st) {
    points[*st] = 0;
    stones_on_board[neigh->get_color()]--;
#ifdef ZOBRIST
    zobrist.update(*st, neigh->get_color());
#endif    
    empty_points.add(*st);

    GroupSet<4> meta_neigh;
    int nmeta = neighbour_groups(*st, meta_neigh);
    for (int k = 0; k < nmeta; k++) {
      meta_neigh[k]->add_liberties(*st);
      if (meta_neigh[k] == last_atari[meta_neigh[k]->get_color()]) {
        last_atari[meta_neigh[k]->get_color()] = 0;
      }
    }
  }
  
  if (neigh == last_atari[neigh->get_color()]) {
    last_atari[neigh->get_color()] = 0;
  }
  neigh->clear();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl 0x4(%rsi), %eax
testl %eax, %eax
je 0x4c88
leaq 0x4(%rbx), %r13
leaq 0xfd7d0(%r14), %r15
cltq
movq $0x0, 0x18(%r14,%rax,8)
movzbl (%rbx), %edx
decl 0xd63c8(%r14,%rdx,4)
movl (%r13), %esi
movq %r15, %rdi
callq 0xaec0
movslq 0xfc6d0(%r14), %rax
cmpq $0x16a, %rax            # imm = 0x16A
je 0x4c1e
movl (%r13), %ecx
leal 0x1(%rax), %edx
movl %edx, 0xfc6d0(%r14)
movl %ecx, 0xfc128(%r14,%rax,4)
movslq 0xfc6d0(%r14), %rax
movl $0x0, 0xfc128(%r14,%rax,4)
movl $0x0, 0x30(%rsp)
movq $0x0, (%rsp)
movl (%r13), %esi
movq %r14, %rdi
movq %rsp, %rdx
callq 0x5210
testl %eax, %eax
jle 0x4c78
movl %eax, %ebp
xorl %r12d, %r12d
movq (%rsp,%r12,8), %rdi
movl (%r13), %esi
callq 0x5e92
movq (%rsp,%r12,8), %rcx
movzbl (%rcx), %eax
cmpq 0xd63d0(%r14,%rax,8), %rcx
jne 0x4c70
movq $0x0, 0xd63d0(%r14,%rax,8)
incq %r12
cmpq %r12, %rbp
jne 0x4c46
movl 0x4(%r13), %eax
addq $0x4, %r13
testl %eax, %eax
jne 0x4bc4
movzbl (%rbx), %eax
cmpq %rbx, 0xd63d0(%r14,%rax,8)
jne 0x4ca1
movq $0x0, 0xd63d0(%r14,%rax,8)
movq %rbx, %rdi
callq 0x5f4c
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/antoniogarro[P]Hara/goban.cpp
// Function: Goban::merge_neighbour(int, Group*)
void Goban::merge_neighbour(int point, Group *neigh)
{
  Group *group = points[point];
  neigh->erase_liberties(point);
  group->attach_group(neigh);
  for (Group::StoneIterator st(neigh);  st; ++st) {
    points[*st] = group;
  }
  neigh->clear();
  if (neigh == last_atari[neigh->get_color()]) {
    last_atari[neigh->get_color()] = 0;
    //merged group may still be in atari, but this case is handled in 'drop_stone()'.
  }    
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
movslq %esi, %rsi
movq 0x18(%rdi,%rsi,8), %r15
movq %rdx, %rdi
callq 0x5efa
movq %r15, %rdi
movq %r14, %rsi
callq 0x5f64
movl 0x4(%r14), %eax
testl %eax, %eax
je 0x4cfb
leaq 0x8(%r14), %rcx
cltq
movq %r15, 0x18(%rbx,%rax,8)
movl (%rcx), %eax
addq $0x4, %rcx
testl %eax, %eax
jne 0x4cea
movq %r14, %rdi
callq 0x5f4c
movzbl (%r14), %eax
cmpq %r14, 0xd63d0(%rbx,%rax,8)
jne 0x4d1d
movq $0x0, 0xd63d0(%rbx,%rax,8)
popq %rbx
popq %r14
popq %r15
retq
nop