LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Rjerk[P]ratabase/Sockets.cpp
// Function: sockets::setNonBlockAndCloseOnExec(int)
void sockets::setNonBlockAndCloseOnExec(int sockfd)
{
    int flags = ::fcntl(sockfd, F_GETFL, 0);
    flags = flags | O_NONBLOCK;
    if ((::fcntl(sockfd, F_SETFL, flags)) == -1) {
        LOG_ERROR << "setNonBlockAndCloseOnExec: fcntl error - set O_NONBLOCK";
    }

    flags = ::fcntl(sockfd, F_GETFL, 0);
    flags |= FD_CLOEXEC;
    if (::fcntl(sockfd, F_SETFL, flags) == -1) {
        LOG_ERROR << "setNonBlockAndCloseOnExec: fcntl error - set FD_CLOEXEC";
    }
}

// Assembly:
subq $0x348, %rsp            # imm = 0x348
movl %edi, 0x344(%rsp)
movl 0x344(%rsp), %edi
movl $0x3, %esi
xorl %edx, %edx
movb $0x0, %al
callq 0x2120
movl %eax, 0x340(%rsp)
movl 0x340(%rsp), %eax
orl $0x800, %eax            # imm = 0x800
movl %eax, 0x340(%rsp)
movl 0x344(%rsp), %edi
movl 0x340(%rsp), %edx
movl $0x4, %esi
movb $0x0, %al
callq 0x2120
cmpl $-0x1, %eax
jne 0x3438
leaq 0xec1(%rip), %rsi       # 0x4278
leaq 0xec6(%rip), %rcx       # 0x4284
leaq 0x1b8(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movl $0xe, %edx
movl $0x4, %r8d
callq 0x28e0
movq 0x10(%rsp), %rdi
callq 0x2c80
movq %rax, 0x18(%rsp)
jmp 0x33ec
movq 0x18(%rsp), %rdi
addq $0x10, %rdi
leaq 0xea2(%rip), %rsi       # 0x429e
callq 0x2200
jmp 0x3403
leaq 0x1b8(%rsp), %rdi
callq 0x2b40
jmp 0x3438
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1b0(%rsp)
movl %eax, 0x1ac(%rsp)
leaq 0x1b8(%rsp), %rdi
callq 0x2b40
jmp 0x3506
movl 0x344(%rsp), %edi
movl $0x3, %esi
xorl %edx, %edx
movb $0x0, %al
callq 0x2120
movl %eax, 0x340(%rsp)
movl 0x340(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x340(%rsp)
movl 0x344(%rsp), %edi
movl 0x340(%rsp), %edx
movl $0x4, %esi
movb $0x0, %al
callq 0x2120
cmpl $-0x1, %eax
jne 0x34fe
leaq 0xded(%rip), %rsi       # 0x4278
leaq 0xdf2(%rip), %rcx       # 0x4284
leaq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
movl $0x14, %edx
movl $0x4, %r8d
callq 0x28e0
movq (%rsp), %rdi
callq 0x2c80
movq %rax, 0x8(%rsp)
jmp 0x34bb
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
leaq 0xe0b(%rip), %rsi       # 0x42d6
callq 0x2200
jmp 0x34d2
leaq 0x20(%rsp), %rdi
callq 0x2b40
jmp 0x34fe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1b0(%rsp)
movl %eax, 0x1ac(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x2b40
jmp 0x3506
addq $0x348, %rsp            # imm = 0x348
retq
movq 0x1b0(%rsp), %rdi
callq 0x22e0
nopw %cs:(%rax,%rax)
// File: Rjerk[P]ratabase/Sockets.cpp
// Function: sockets::read(int, void*, unsigned long)
ssize_t sockets::read(int sockfd, void* buf, size_t count)
{
    ssize_t n;
    if ((n = ::read(sockfd, buf, count)) == -1) {
        LOG_ERROR << "sockets::read";
    }
    return n;
}

// Assembly:
subq $0x1c8, %rsp            # imm = 0x1C8
movl %edi, 0x1c4(%rsp)
movq %rsi, 0x1b8(%rsp)
movq %rdx, 0x1b0(%rsp)
movl 0x1c4(%rsp), %edi
movq 0x1b8(%rsp), %rsi
movq 0x1b0(%rsp), %rdx
callq 0x2280
movq %rax, 0x1a8(%rsp)
cmpq $-0x1, %rax
jne 0x3b8c
leaq 0x759(%rip), %rsi       # 0x4278
leaq 0x884(%rip), %rcx       # 0x43aa
leaq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
movl $0x5f, %edx
movl $0x4, %r8d
callq 0x28e0
movq (%rsp), %rdi
callq 0x2c80
movq %rax, 0x8(%rsp)
jmp 0x3b4f
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
leaq 0x842(%rip), %rsi       # 0x43a1
callq 0x2200
jmp 0x3b66
leaq 0x20(%rsp), %rdi
callq 0x2b40
jmp 0x3b8c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x2b40
jmp 0x3b9c
movq 0x1a8(%rsp), %rax
addq $0x1c8, %rsp            # imm = 0x1C8
retq
movq 0x18(%rsp), %rdi
callq 0x22e0
nopw %cs:(%rax,%rax)
// File: Rjerk[P]ratabase/Sockets.cpp
// Function: sockets::write(int, void const*, unsigned long)
ssize_t sockets::write(int sockfd, const void* buf, size_t count)
{
    ssize_t n;
    if ((n = ::write(sockfd, buf, count)) == -1) {
        LOG_ERROR << "sockets::write";
    }
    return n;
}

// Assembly:
subq $0x1c8, %rsp            # imm = 0x1C8
movl %edi, 0x1c4(%rsp)
movq %rsi, 0x1b8(%rsp)
movq %rdx, 0x1b0(%rsp)
movl 0x1c4(%rsp), %edi
movq 0x1b8(%rsp), %rsi
movq 0x1b0(%rsp), %rdx
callq 0x20b0
movq %rax, 0x1a8(%rsp)
cmpq $-0x1, %rax
jne 0x3c6c
leaq 0x679(%rip), %rsi       # 0x4278
leaq 0x7b2(%rip), %rcx       # 0x43b8
leaq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
movl $0x68, %edx
movl $0x4, %r8d
callq 0x28e0
movq (%rsp), %rdi
callq 0x2c80
movq %rax, 0x8(%rsp)
jmp 0x3c2f
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
leaq 0x770(%rip), %rsi       # 0x43af
callq 0x2200
jmp 0x3c46
leaq 0x20(%rsp), %rdi
callq 0x2b40
jmp 0x3c6c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x2b40
jmp 0x3c7c
movq 0x1a8(%rsp), %rax
addq $0x1c8, %rsp            # imm = 0x1C8
retq
movq 0x18(%rsp), %rdi
callq 0x22e0
// File: openflightmaps[P]ofm2xplane/main.cpp
// Function: my_stoi(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int my_stoi(string s)
{
    if(s.length()==0)
        return 0;
    int out=0;
    int add=1;
    size_t p1=s.find_first_of("1234567890");
    s=s.substr(p1);
    p1=s.find_first_not_of("1234567890");
    s=s.substr(0,p1);
    int m=s.length();
    for (int i=m-1; i>=0; i--)
    {
        out+=add * (int(s.at(i))-48);
        add=add*10;
    }
    return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, -0x10(%rbp)
callq 0x3360
cmpq $0x0, %rax
jne 0x854a
movl $0x0, -0x4(%rbp)
jmp 0x863c
movq -0x70(%rbp), %rdi
movl $0x0, -0x14(%rbp)
movl $0x1, -0x18(%rbp)
leaq 0x9019(%rip), %rsi      # 0x1157c
xorl %eax, %eax
movl %eax, %edx
callq 0x3120
movq -0x70(%rbp), %rsi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdx
leaq -0x40(%rbp), %rdi
movq $-0x1, %rcx
callq 0x3230
movq -0x70(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x32c0
leaq -0x40(%rbp), %rdi
callq 0x3160
movq -0x70(%rbp), %rdi
leaq 0x8fd3(%rip), %rsi      # 0x1157c
xorl %eax, %eax
movl %eax, %edx
callq 0x3150
movq -0x70(%rbp), %rsi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
leaq -0x60(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
callq 0x3230
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x32c0
leaq -0x60(%rbp), %rdi
callq 0x3160
movq -0x70(%rbp), %rdi
callq 0x3360
movl %eax, -0x64(%rbp)
movl -0x64(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x68(%rbp)
cmpl $0x0, -0x68(%rbp)
jl 0x8636
movq -0x70(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, -0x74(%rbp)
movslq -0x68(%rbp), %rsi
callq 0x34a0
movq %rax, %rcx
movl -0x74(%rbp), %eax
movsbl (%rcx), %ecx
subl $0x30, %ecx
imull %ecx, %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
imull $0xa, -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x68(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x68(%rbp)
jmp 0x85f6
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: openflightmaps[P]ofm2xplane/main.cpp
// Function: my_itos[abi:cxx11](int, int)
string my_itos(int i,int n)
{
    int j=i, d=0;
    string s;
    while(j!=0)
    {
        j=j/10;
        d++;
    }
    if(d>n)
        n=d;
    
    s.assign(n,'0');
    j=s.length();
    for(int k=0;k<d;k++)
    {
        s[j-1-k]=i%10+48;
        i=i/10;
    }
    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x32f0
cmpl $0x0, -0x14(%rbp)
je 0x8902
movl -0x14(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x88e3
movl -0x18(%rbp), %eax
cmpl -0x10(%rbp), %eax
jle 0x8910
movl -0x18(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x40(%rbp), %rdi
movslq -0x10(%rbp), %rsi
movl $0x30, %edx
callq 0x3430
jmp 0x8924
movq -0x40(%rbp), %rdi
callq 0x3360
movl %eax, -0x14(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x89bc
movq -0x40(%rbp), %rdi
movslq -0xc(%rbp), %rcx
movl %ecx, %eax
imulq $0x66666667, %rcx, %rdx # imm = 0x66666667
movq %rdx, %rcx
shrq $0x3f, %rcx
shrq $0x22, %rdx
addl %ecx, %edx
addl %edx, %edx
movl %edx, %ecx
leal (%rcx,%rcx,4), %ecx
subl %ecx, %eax
addb $0x30, %al
movb %al, -0x49(%rbp)
movl -0x14(%rbp), %ecx
movl -0x30(%rbp), %eax
notl %eax
addl %ecx, %eax
movslq %eax, %rsi
callq 0x34e0
movq %rax, -0x48(%rbp)
jmp 0x8983
movq -0x48(%rbp), %rax
movb -0x49(%rbp), %cl
movb %cl, (%rax)
movl -0xc(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, -0xc(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x8937
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x3160
jmp 0x89d9
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x89cf
movq -0x40(%rbp), %rdi
callq 0x3160
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3440
nopw %cs:(%rax,%rax)
// File: openflightmaps[P]ofm2xplane/main.cpp
// Function: check_ID(rapidxml::xml_node<char>*, int)
bool check_ID(xml_node<> *node,int id)
{
    for(int i=0;i<4;i++)
    {
        if(node->first_attribute("mid")==NULL)
        {
            if(node->first_node()==NULL)
                return false;
            else
            {
                node=node->first_node();
                continue;
            }
        }else
        {
            if(my_stoi(string(node->first_attribute("mid")->value()))==id)
                return true;
            else
                return false;     
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x4, -0x18(%rbp)
jge 0x8b2e
movq -0x10(%rbp), %rdi
leaq 0x8827(%rip), %rsi      # 0x11242
xorl %eax, %eax
movl %eax, %edx
movl $0x1, %ecx
callq 0xccc0
cmpq $0x0, %rax
jne 0x8a71
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movl $0x1, %ecx
movq %rdx, %rsi
callq 0xca70
cmpq $0x0, %rax
jne 0x8a53
movb $0x0, -0x1(%rbp)
jmp 0x8b30
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movl $0x1, %ecx
movq %rdx, %rsi
callq 0xca70
movq %rax, -0x10(%rbp)
jmp 0x8b20
movq -0x10(%rbp), %rdi
leaq 0x87c6(%rip), %rsi      # 0x11242
xorl %eax, %eax
movl %eax, %edx
movl $0x1, %ecx
callq 0xccc0
movq %rax, %rdi
callq 0xcd90
movq %rax, -0x60(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x3450
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0xcdd0
jmp 0x8ab6
leaq -0x38(%rbp), %rdi
callq 0x8520
movl %eax, -0x64(%rbp)
jmp 0x8ac4
movl -0x14(%rbp), %eax
movl %eax, -0x68(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3160
leaq -0x39(%rbp), %rdi
callq 0x3260
movl -0x68(%rbp), %ecx
movl -0x64(%rbp), %eax
cmpl %ecx, %eax
jne 0x8b1a
movb $0x1, -0x1(%rbp)
jmp 0x8b30
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x8b0f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3160
leaq -0x39(%rbp), %rdi
callq 0x3260
jmp 0x8b3b
movb $0x0, -0x1(%rbp)
jmp 0x8b30
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x8a06
ud2
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3440
nopw %cs:(%rax,%rax)
// File: openflightmaps[P]ofm2xplane/main.cpp
// Function: surface_code(rapidxml::xml_node<char>*)
int surface_code(xml_node<> *node)
{
    string s(node->first_node("codeComposition")->value());
    if(s.length()==0)
        s=string(def->first_node("others")->first_node("codeComposition")->value());
    if(s.compare("ASPH")==0)
        return 1;
    if(s.compare("CONC")==0)
        return 2;
    if(s.compare("GRASS")==0)
        return 3;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x8989(%rip), %rsi      # 0x114f3
xorl %eax, %eax
movl %eax, %edx
movl $0x1, %ecx
callq 0xca70
movq %rax, %rdi
callq 0xcd90
movq %rax, -0x80(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x3450
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0xcdd0
jmp 0x8ba4
leaq -0x31(%rbp), %rdi
callq 0x3260
leaq -0x30(%rbp), %rdi
callq 0x3360
cmpq $0x0, %rax
jne 0x8cae
movq 0xd6d9(%rip), %rdi      # 0x162a0
leaq 0x8935(%rip), %rsi      # 0x11503
xorl %eax, %eax
movl %eax, %edx
movl $0x1, %ecx
callq 0xca70
movq %rax, -0x88(%rbp)
jmp 0x8be5
movq -0x88(%rbp), %rdi
leaq 0x8900(%rip), %rsi      # 0x114f3
xorl %eax, %eax
movl %eax, %edx
movl $0x1, %ecx
callq 0xca70
movq %rax, -0x90(%rbp)
jmp 0x8c0a
movq -0x90(%rbp), %rdi
callq 0xcd90
movq %rax, -0x98(%rbp)
jmp 0x8c1f
leaq -0x69(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x3450
movq -0x98(%rbp), %rsi
movq -0xa0(%rbp), %rdx
leaq -0x68(%rbp), %rdi
callq 0xcdd0
jmp 0x8c48
leaq -0x30(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x32c0
leaq -0x68(%rbp), %rdi
callq 0x3160
leaq -0x69(%rbp), %rdi
callq 0x3260
jmp 0x8cae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x3260
jmp 0x8d3d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x8d34
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x69(%rbp), %rdi
callq 0x3260
jmp 0x8d34
leaq -0x30(%rbp), %rdi
leaq 0x8851(%rip), %rsi      # 0x1150a
callq 0x30a0
cmpl $0x0, %eax
jne 0x8cd3
movl $0x1, -0x4(%rbp)
movl $0x1, -0x70(%rbp)
jmp 0x8d1f
leaq -0x30(%rbp), %rdi
leaq 0x8831(%rip), %rsi      # 0x1150f
callq 0x30a0
cmpl $0x0, %eax
jne 0x8cf8
movl $0x2, -0x4(%rbp)
movl $0x1, -0x70(%rbp)
jmp 0x8d1f
leaq -0x30(%rbp), %rdi
leaq 0x8811(%rip), %rsi      # 0x11514
callq 0x30a0
cmpl $0x0, %eax
jne 0x8d1d
movl $0x3, -0x4(%rbp)
movl $0x1, -0x70(%rbp)
jmp 0x8d1f
ud2
leaq -0x30(%rbp), %rdi
callq 0x3160
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x3160
movq -0x40(%rbp), %rdi
callq 0x3440
nopw %cs:(%rax,%rax)
// File: openflightmaps[P]ofm2xplane/main.cpp
// Function: return_ID(rapidxml::xml_node<char>*)
int return_ID(xml_node<> *node)
{
    for(int i=0;i<4;i++)
    {
        if(node->first_attribute("mid")==NULL)
        {
            if(node->first_node()==NULL)
                return -1;
            else
            {
                node=node->first_node();
                continue;
            }
        }else
            return my_stoi(string(node->first_attribute("mid")->value()));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x4, -0x14(%rbp)
jge 0xc35a
movq -0x10(%rbp), %rdi
leaq 0x4fea(%rip), %rsi      # 0x11242
xorl %eax, %eax
movl %eax, %edx
movl $0x1, %ecx
callq 0xccc0
cmpq $0x0, %rax
jne 0xc2b1
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movl $0x1, %ecx
movq %rdx, %rsi
callq 0xca70
cmpq $0x0, %rax
jne 0xc293
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc35c
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movl $0x1, %ecx
movq %rdx, %rsi
callq 0xca70
movq %rax, -0x10(%rbp)
jmp 0xc34c
movq -0x10(%rbp), %rdi
leaq 0x4f86(%rip), %rsi      # 0x11242
xorl %eax, %eax
movl %eax, %edx
movl $0x1, %ecx
callq 0xccc0
movq %rax, %rdi
callq 0xcd90
movq %rax, -0x60(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x3450
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0xcdd0
jmp 0xc2f6
leaq -0x38(%rbp), %rdi
callq 0x8520
movl %eax, -0x64(%rbp)
jmp 0xc304
movl -0x64(%rbp), %eax
movl %eax, -0x4(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3160
leaq -0x39(%rbp), %rdi
callq 0x3260
jmp 0xc35c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0xc341
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3160
leaq -0x39(%rbp), %rdi
callq 0x3260
jmp 0xc365
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xc243
ud2
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3440
nop
// File: alexwarth[P]nothing/main.cpp
// Function: growOT()
void growOT(void) {
  size_t  newOTSize    = OTSize > 0 ? OTSize * 2 : OrigOTSize;
  dPrintf2("growOT, new size is %d\n", newOTSize);
  OTEntry *newOT       = allocate(newOTSize, OTEntry);
  byte_t  *newMarked   = allocate(newOTSize, byte_t);
  memcpy(newOT, OT, sizeof(OTEntry) * OTSize);
  for (int i = OTSize; i < newOTSize; i++) {
    newOT[i].numSlots = Int(-1);
    newOT[i].ptr.next = i + 1 < newOTSize ? &newOT[i + 1] : NULL;
  }
  if (OTSize > 0) {
    free(OT);
    free(marked);
  }
  freeList = &newOT[OTSize];
  OTSize   = newOTSize;
  OT       = newOT;
  marked   = newMarked;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
cmpq $0x0, 0x1fb58(%rip)     # 0x220e8
jbe 0x25a2
movq 0x1fb4f(%rip), %rax     # 0x220e8
shlq %rax
movq %rax, -0x28(%rbp)
jmp 0x25ad
movl $0x2, %eax
movq %rax, -0x28(%rbp)
jmp 0x25ad
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x17a4c(%rip), %rdi     # 0x1a00c
movb $0x0, %al
callq 0x2410
movq -0x8(%rbp), %rdi
movl $0x18, %esi
callq 0x1070
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x1070
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq 0x1fafa(%rip), %rsi     # 0x220f0
imulq $0x18, 0x1faea(%rip), %rdx # 0x220e8
callq 0x1080
movq 0x1fade(%rip), %rax     # 0x220e8
movl %eax, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
cmpq -0x8(%rbp), %rax
jae 0x267e
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movl -0x1c(%rbp), %eax
addl $0x1, %eax
cltq
cmpq -0x8(%rbp), %rax
jae 0x2654
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
jmp 0x265c
xorl %eax, %eax
movq %rax, -0x30(%rbp)
jmp 0x265c
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x10(%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x260d
cmpq $0x0, 0x1fa62(%rip)     # 0x220e8
jbe 0x26a0
movq 0x1fa61(%rip), %rdi     # 0x220f0
callq 0x1090
movq 0x1fa65(%rip), %rdi     # 0x22100
callq 0x1090
movq -0x10(%rbp), %rax
imulq $0x18, 0x1fa3c(%rip), %rcx # 0x220e8
addq %rcx, %rax
movq %rax, 0x1fa42(%rip)     # 0x220f8
movq -0x8(%rbp), %rax
movq %rax, 0x1fa27(%rip)     # 0x220e8
movq -0x10(%rbp), %rax
movq %rax, 0x1fa24(%rip)     # 0x220f0
movq -0x18(%rbp), %rax
movq %rax, 0x1fa29(%rip)     # 0x22100
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: alexwarth[P]nothing/main.cpp
// Function: mk(unsigned long)
value_t mk(size_t numSlots) {
  if (freeList == NULL || debug) {
    gc();
    if (freeList == NULL)
      growOT();
  }
  OTEntry *newGuy = freeList;
  freeList = freeList->ptr.next;
  newGuy->numSlots  = Int(numSlots);
  newGuy->cls       = Obj;
  newGuy->ptr.slots = allocate(numSlots, value_t);
  newGuy->isBinary  = 0;
  return Oop(newGuy - OT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, 0x1f164(%rip)     # 0x220f8
je 0x2f9f
cmpl $0x0, 0x1f0e3(%rip)     # 0x22080
je 0x2fb5
callq 0x31d0
cmpq $0x0, 0x1f14c(%rip)     # 0x220f8
jne 0x2fb3
callq 0x2580
jmp 0x2fb5
movq 0x1f13c(%rip), %rax     # 0x220f8
movq %rax, -0x10(%rbp)
movq 0x1f131(%rip), %rax     # 0x220f8
movq 0x10(%rax), %rax
movq %rax, 0x1f126(%rip)     # 0x220f8
movq -0x8(%rbp), %rax
shlq %rax
orq $0x1, %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl 0x1f0c1(%rip), %ecx     # 0x220ac
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rdi
movl $0x4, %esi
callq 0x1070
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x1f0cf(%rip), %rcx     # 0x220f0
subq %rcx, %rax
movl $0x18, %ecx
cqto
idivq %rcx
shlq %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: alexwarth[P]nothing/main.cpp
// Function: mark(int)
int mark(value_t oop) {
  if (!isOop(oop))
    return 0;
  int otIdx = OopValue(oop);
  if (marked[otIdx])
    return 0;
  marked[otIdx] = 1;
  if (OT[otIdx].isBinary)
    return 1;
  size_t r = 1;
  OTEntry e = OT[otIdx];
  value_t *slot = e.ptr.slots;
  for (int i = 0; i < IntValue(e.numSlots); i++)
    r += mark(*slot++);
  return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x3062
movl $0x0, -0x4(%rbp)
jmp 0x31c2
movl -0x8(%rbp), %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, 0x1f011(%rip)     # 0x22080
je 0x309f
movl -0x10(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x307e
jmp 0x309d
leaq 0x16fd5(%rip), %rdi     # 0x1a05a
leaq 0x16fab(%rip), %rsi     # 0x1a037
movl $0x87, %edx
leaq 0x172b5(%rip), %rcx     # 0x1a34d
callq 0x1060
jmp 0x309f
movl -0x10(%rbp), %eax
sarl %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0xc(%rbp)
movq 0x1f04c(%rip), %rax     # 0x22100
movslq -0xc(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x30ca
movl $0x0, -0x4(%rbp)
jmp 0x31c2
movq 0x1f02f(%rip), %rax     # 0x22100
movslq -0xc(%rbp), %rcx
movb $0x1, (%rax,%rcx)
movq 0x1f010(%rip), %rax     # 0x220f0
movslq -0xc(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x8(%rax)
je 0x30fd
movl $0x1, -0x4(%rbp)
jmp 0x31c2
movq $0x1, -0x20(%rbp)
movq 0x1efe4(%rip), %rax     # 0x220f0
movslq -0xc(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
movl %eax, -0x50(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x48(%rbp)
cmpl $0x0, 0x1ef30(%rip)     # 0x22080
je 0x3180
movl -0x48(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x315f
jmp 0x317e
leaq 0x17041(%rip), %rdi     # 0x1a1a7
leaq 0x16eca(%rip), %rsi     # 0x1a037
movl $0x90, %edx
leaq 0x171d4(%rip), %rcx     # 0x1a34d
callq 0x1060
jmp 0x3180
movl -0x50(%rbp), %eax
movl -0x48(%rbp), %ecx
sarl %ecx
movl %ecx, -0x4c(%rbp)
cmpl -0x4c(%rbp), %eax
jge 0x31bb
movq -0x40(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x40(%rbp)
movl (%rax), %edi
callq 0x3040
cltq
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x313d
movq -0x20(%rbp), %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: alexwarth[P]nothing/main.cpp
// Function: gc()
size_t gc(void) {
  memset(marked, 0, OTSize);
  int numMarked = mark(globals);
  for (int i = 0; i < OTSize; i++) {
    if (marked[i] || OT[i].numSlots == Int(-1))
      continue;
    free(OT[i].ptr.slots);
    OT[i].numSlots = Int(-1);
    OT[i].cls      = nil;
    OT[i].ptr.next = freeList;
    freeList       = &OT[i];
  }
  dPrintf2("GC reclaimed %d OTEntries\n", OTSize - numMarked);
  return OTSize - numMarked;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x1ef21(%rip), %rdi     # 0x22100
movq 0x1ef02(%rip), %rdx     # 0x220e8
xorl %esi, %esi
callq 0x1050
movl 0x1eead(%rip), %edi     # 0x220a0
callq 0x3040
movl %eax, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movslq -0x8(%rbp), %rax
cmpq 0x1eedb(%rip), %rax     # 0x220e8
jae 0x32d2
movq 0x1eee6(%rip), %rax     # 0x22100
movslq -0x8(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
jne 0x323b
movq 0x1eec5(%rip), %rax     # 0x220f0
movslq -0x8(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpl $-0x1, (%rax)
jne 0x3240
jmp 0x32c4
movq 0x1eea9(%rip), %rax     # 0x220f0
movslq -0x8(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdi
callq 0x1090
movq 0x1ee8e(%rip), %rax     # 0x220f0
movslq -0x8(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movl 0x1ee0f(%rip), %ecx     # 0x22088
movq 0x1ee70(%rip), %rax     # 0x220f0
movslq -0x8(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x4(%rax)
movq 0x1ee63(%rip), %rcx     # 0x220f8
movq 0x1ee54(%rip), %rax     # 0x220f0
movslq -0x8(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x10(%rax)
movq 0x1ee3e(%rip), %rax     # 0x220f0
movslq -0x8(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x1ee34(%rip)     # 0x220f8
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x3202
movq 0x1ee0f(%rip), %rsi     # 0x220e8
movslq -0x4(%rbp), %rax
subq %rax, %rsi
leaq 0x17078(%rip), %rdi     # 0x1a35f
movb $0x0, %al
callq 0x2410
movq 0x1edf3(%rip), %rax     # 0x220e8
movslq -0x4(%rbp), %rcx
subq %rcx, %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: alexwarth[P]nothing/main.cpp
// Function: addPrim(char const*, int (*)(int))
value_t addPrim(const char *n, value_t (*f)(value_t)) { assert(numPrims < MaxNumPrims);
                                                        prims[numPrims]     = f;
                                                        primNames[numPrims] = (void *)n;
                                                        return Int(numPrims++); }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x40, 0x1f158(%rip)    # 0x22510
jae 0x33bc
jmp 0x33db
leaq 0x16fd0(%rip), %rdi     # 0x1a393
leaq 0x16c6d(%rip), %rsi     # 0x1a037
movl $0xbf, %edx
leaq 0x16fd4(%rip), %rcx     # 0x1a3aa
callq 0x1060
movq -0x10(%rbp), %rdx
movq 0x1f12a(%rip), %rcx     # 0x22510
leaq 0x1ed23(%rip), %rax     # 0x22110
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rdx
movq 0x1f114(%rip), %rcx     # 0x22510
leaq 0x1ef0d(%rip), %rax     # 0x22310
movq %rdx, (%rax,%rcx,8)
movq 0x1f102(%rip), %rax     # 0x22510
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x1f0f4(%rip)     # 0x22510
shlq %rax
orq $0x1, %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: tyhsu[P]Ewn/play.cpp
// Function: Play::two_players_mode()
void Play::two_players_mode()
{
    this->game.print_board();
    while (1) {
        //update: 0(game continues), 1(A wins), 2(B wins)
        int dice = this->game.roll_dice();
        cout << "dice: " << dice+1 << endl;
        int game_status = this->game.update_game_status(player_move(dice));
        this->game.print_board();
        if (game_status != 0) {
            cout << "====================================" << endl;
            if (game_status == 1) cout << "A is the winner!!!" << endl;
            else cout << "B is the winner!!!" << endl;
            cout << "====================================" << endl;
            return;
        }
        this->game.switch_player();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0xab80
movq -0x20(%rbp), %rdi
callq 0xad70
movl %eax, -0xc(%rbp)
movq 0xf1dc(%rip), %rdi      # 0x11fc8
leaq 0xa332(%rip), %rsi      # 0xd125
callq 0x2150
movq %rax, %rdi
movl -0xc(%rbp), %esi
addl $0x1, %esi
callq 0x2200
movq %rax, %rdi
movq 0xf1a8(%rip), %rsi      # 0x11fb8
callq 0x2190
movq -0x20(%rbp), %rdi
leaq -0xc(%rbp), %rsi
callq 0x2b70
movq -0x20(%rbp), %rdi
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rsi
callq 0xb120
movq -0x20(%rbp), %rdi
movl %eax, -0x10(%rbp)
callq 0xab80
cmpl $0x0, -0x10(%rbp)
je 0x2edf
movq 0xf178(%rip), %rdi      # 0x11fc8
leaq 0xa6c8(%rip), %rsi      # 0xd51f
callq 0x2150
movq %rax, %rdi
movq 0xf152(%rip), %rsi      # 0x11fb8
callq 0x2190
cmpl $0x1, -0x10(%rbp)
jne 0x2e95
movq 0xf150(%rip), %rdi      # 0x11fc8
leaq 0xa2ad(%rip), %rsi      # 0xd12c
callq 0x2150
movq %rax, %rdi
movq 0xf12a(%rip), %rsi      # 0x11fb8
callq 0x2190
jmp 0x2eb7
movq 0xf12c(%rip), %rdi      # 0x11fc8
leaq 0xa29c(%rip), %rsi      # 0xd13f
callq 0x2150
movq %rax, %rdi
movq 0xf106(%rip), %rsi      # 0x11fb8
callq 0x2190
movq 0xf10a(%rip), %rdi      # 0x11fc8
leaq 0xa65a(%rip), %rsi      # 0xd51f
callq 0x2150
movq %rax, %rdi
movq 0xf0e4(%rip), %rsi      # 0x11fb8
callq 0x2190
addq $0x20, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xb440
jmp 0x2dd9
nopl (%rax)
// File: tyhsu[P]Ewn/ewnAi.cpp
// Function: EwnAI::AI_move(Game, int)
Movement EwnAI::AI_move(Game cur_game, int dice)
{
    switch (this->ai_mode) {
        case 0:
            return this->minimax.AI_move(cur_game, dice);
        case 1:
            return this->minimax1.AI_move(cur_game, dice);
        case 2:
            return this->minimax2.AI_move(cur_game, dice);
        case 3:
            return this->minimax3.AI_move(cur_game, dice);
        case 4:
            return this->minimax4.AI_move(cur_game, dice);
        case 5:
            return this->mcts.AI_move(cur_game, dice);
        case 6:
            return this->randomAi.AI_move(cur_game, dice);
        default:
            return this->minimax.AI_move(cur_game, dice);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl (%rax), %eax
movq %rax, -0x28(%rbp)
subq $0x6, %rax
ja 0x5764
movq -0x28(%rbp), %rax
leaq 0x800a(%rip), %rcx      # 0xd694
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
movl -0x1c(%rbp), %edx
callq 0x7f70
movq %rax, -0x8(%rbp)
jmp 0x577c
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdi
addq $0x88, %rdi
movl -0x1c(%rbp), %edx
callq 0x7f70
movq %rax, -0x8(%rbp)
jmp 0x577c
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdi
addq $0x108, %rdi            # imm = 0x108
movl -0x1c(%rbp), %edx
callq 0x7f70
movq %rax, -0x8(%rbp)
jmp 0x577c
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdi
addq $0x188, %rdi            # imm = 0x188
movl -0x1c(%rbp), %edx
callq 0x7f70
movq %rax, -0x8(%rbp)
jmp 0x577c
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdi
addq $0x208, %rdi            # imm = 0x208
movl -0x1c(%rbp), %edx
callq 0x7f70
movq %rax, -0x8(%rbp)
jmp 0x577c
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdi
addq $0x288, %rdi            # imm = 0x288
movl -0x1c(%rbp), %edx
callq 0x6b10
movq %rax, -0x8(%rbp)
jmp 0x577c
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdi
addq $0x298, %rdi            # imm = 0x298
movl -0x1c(%rbp), %edx
callq 0x6810
movq %rax, -0x8(%rbp)
jmp 0x577c
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
movl -0x1c(%rbp), %edx
callq 0x7f70
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: tyhsu[P]Ewn/mcts.cpp
// Function: MCTS::recursive_delete_tree_node(Tree_node*)
void MCTS::recursive_delete_tree_node(Tree_node* node_ptr) {
	for (int i = 0; i < 18; i++) {
		if (node_ptr->get_child_ptr(i)) {
			recursive_delete_tree_node(node_ptr->get_child_ptr(i));
		}
	}
	delete node_ptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x12, -0x14(%rbp)
jge 0x71ae
movq -0x10(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x7a80
cmpq $0x0, %rax
je 0x71a1
movq -0x10(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x7a80
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x7150
jmp 0x71a3
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x716f
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x71ca
movq -0x28(%rbp), %rdi
movl $0x190, %esi            # imm = 0x190
callq 0x2170
addq $0x30, %rsp
popq %rbp
retq
// File: tyhsu[P]Ewn/tree_node.cpp
// Function: Tree_node::Tree_node()
Tree_node::Tree_node() {
	this->win_count = 0;
	this->visit_count = 0;
	this->game_status = 0;
	this->parent_ptr = NULL;
	for (int i = 0; i < 18; i++)
		this->children_ptr_list[i] = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x10, %rdi
callq 0xa1a0
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movl $0x0, 0x4(%rax)
movl $0x0, 0x8(%rax)
movq $0x0, 0xf8(%rax)
movl $0x0, -0xc(%rbp)
cmpl $0x12, -0xc(%rbp)
jge 0x75fc
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq $0x0, 0x100(%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x75d7
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: tyhsu[P]Ewn/tree_node.cpp
// Function: Tree_node::Tree_node(Game const&)
Tree_node::Tree_node(const Game& game_) {
	this->win_count = 0;
	this->visit_count = 0;
	this->game_status = 0;
	this->game = game_;
	this->parent_ptr = NULL;
	new_child_nodes();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x10, %rdi
callq 0xa1a0
movq -0x18(%rbp), %rdi
movl $0x0, (%rdi)
movl $0x0, 0x4(%rdi)
movl $0x0, 0x8(%rdi)
movq -0x10(%rbp), %rsi
addq $0x10, %rdi
callq 0xa720
movq -0x18(%rbp), %rdi
movq $0x0, 0xf8(%rdi)
callq 0x7670
addq $0x20, %rsp
popq %rbp
retq
// File: tyhsu[P]Ewn/tree_node.cpp
// Function: Tree_node::Tree_node(Tree_node*)
Tree_node::Tree_node(Tree_node* node) {
	this->win_count = node->win_count;
	this->visit_count = node->visit_count;
	this->game_status = node->game_status;
	this->game = node->game;
	this->parent_ptr = node->parent_ptr;
	for (int i = 0; i < 18; i++) {
		this->children_ptr_list[i] = node->children_ptr_list[i];
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x10, %rdi
callq 0xa1a0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, (%rdi)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, 0x4(%rdi)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x8(%rdi)
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
addq $0x10, %rdi
callq 0xa720
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0xf8(%rcx), %rcx
movq %rcx, 0xf8(%rax)
movl $0x0, -0x14(%rbp)
cmpl $0x12, -0x14(%rbp)
jge 0x78d0
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movq 0x100(%rcx,%rdx,8), %rdx
movslq -0x14(%rbp), %rcx
movq %rdx, 0x100(%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x789f
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: tyhsu[P]Ewn/tree_node.cpp
// Function: Tree_node::operator=(Tree_node const&)
void Tree_node::operator=(const Tree_node& node) {
	this->win_count = node.win_count;
	this->visit_count = node.visit_count;
	this->game_status = node.game_status;
	this->game = node.game;
	this->parent_ptr = node.parent_ptr;
	for (int i = 0; i < 18; i++) {
		this->children_ptr_list[i] = node.children_ptr_list[i];
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, (%rdi)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, 0x4(%rdi)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x8(%rdi)
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
addq $0x10, %rdi
callq 0xa720
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0xf8(%rcx), %rcx
movq %rcx, 0xf8(%rax)
movl $0x0, -0x14(%rbp)
cmpl $0x12, -0x14(%rbp)
jge 0x7973
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movq 0x100(%rcx,%rdx,8), %rdx
movslq -0x14(%rbp), %rcx
movq %rdx, 0x100(%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x7942
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: tyhsu[P]Ewn/minimax.cpp
// Function: Minimax::evaluate_simulation(Game const&)
int Minimax::evaluate_simulation(const Game& cur_game) {
	float win_times = 0;
	for (int game_cnt = 0; game_cnt < SIMU_TIMES; game_cnt++) {
		win_times += simulation(cur_game);
	}
	return (int)(win_times / SIMU_TIMES * 20);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x108(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x108(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0xc(%rcx), %eax
jge 0x88c8
movq -0x10(%rbp), %rsi
leaq -0x100(%rbp), %rdi
callq 0xa520
movq -0x108(%rbp), %rdi
leaq -0x100(%rbp), %rsi
callq 0x8900
cvtsi2ss %eax, %xmm0
addss -0x14(%rbp), %xmm0
movss %xmm0, -0x14(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x887d
movq -0x108(%rbp), %rax
movss -0x14(%rbp), %xmm0
cvtsi2ssl 0xc(%rax), %xmm1
divss %xmm1, %xmm0
movss 0x4efb(%rip), %xmm1     # 0xd7e0
mulss %xmm1, %xmm0
cvttss2si %xmm0, %eax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: tyhsu[P]Ewn/game.cpp
// Function: Chess::assign(char const&, bool const&, int const&, int const&)
void Chess::assign(const char& symbol_, const bool& exist_, const int& x, const int& y)
{
	this->symbol = symbol_;
	this->exist = exist_;
	this->x = x;
	this->y = y;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movb (%rcx), %cl
movb %cl, (%rax)
movq -0x18(%rbp), %rcx
movb (%rcx), %cl
andb $0x1, %cl
movb %cl, 0x1(%rax)
movq -0x20(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x4(%rax)
movq -0x28(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x8(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: tyhsu[P]Ewn/game.cpp
// Function: Game::print_board()
void Game::print_board()
{
	cout << "\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" << endl;
	cout << "The current board:" << endl;
	cout << "     /-----\\" << endl;
	for (int i=0; i<5; i++) {
		cout << "     |";
		for (int j=0; j<5; j++) {
			char c = this->board[j][i];
			if (c==0) cout << " ";
			else if (c >= 'A' && c <= 'F')
				cout << ANSI_COLOR_RED << c << ANSI_COLOR_RESET;
			else
				cout << ANSI_COLOR_YELLOW << c << ANSI_COLOR_RESET;
			//else cout << c;
		}
		cout << "|" << endl;
	}
	cout << "     \\-----/" << endl;
	cout << "====================================" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x742d(%rip), %rdi      # 0x11fc8
leaq 0x2c7e(%rip), %rsi      # 0xd820
callq 0x2150
movq %rax, %rdi
movq 0x7407(%rip), %rsi      # 0x11fb8
callq 0x2190
movq 0x740b(%rip), %rdi      # 0x11fc8
leaq 0x2c82(%rip), %rsi      # 0xd846
callq 0x2150
movq %rax, %rdi
movq 0x73e5(%rip), %rsi      # 0x11fb8
callq 0x2190
movq 0x73e9(%rip), %rdi      # 0x11fc8
leaq 0x2c73(%rip), %rsi      # 0xd859
callq 0x2150
movq %rax, %rdi
movq 0x73c3(%rip), %rsi      # 0x11fb8
callq 0x2190
movl $0x0, -0xc(%rbp)
cmpl $0x5, -0xc(%rbp)
jge 0xad18
movq 0x73b6(%rip), %rdi      # 0x11fc8
leaq 0x2c4d(%rip), %rsi      # 0xd866
callq 0x2150
movl $0x0, -0x10(%rbp)
cmpl $0x5, -0x10(%rbp)
jge 0xace8
movq -0x20(%rbp), %rax
movslq -0x10(%rbp), %rcx
imulq $0x5, %rcx, %rcx
addq %rcx, %rax
movslq -0xc(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x11(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $0x0, %eax
jne 0xac66
movq 0x7370(%rip), %rdi      # 0x11fc8
leaq 0x28b0(%rip), %rsi      # 0xd50f
callq 0x2150
jmp 0xacd8
movsbl -0x11(%rbp), %eax
cmpl $0x41, %eax
jl 0xaca8
movsbl -0x11(%rbp), %eax
cmpl $0x46, %eax
jg 0xaca8
movq 0x7349(%rip), %rdi      # 0x11fc8
leaq 0x2be7(%rip), %rsi      # 0xd86d
callq 0x2150
movq %rax, %rdi
movsbl -0x11(%rbp), %esi
callq 0x21a0
movq %rax, %rdi
leaq 0x2bd2(%rip), %rsi      # 0xd873
callq 0x2150
jmp 0xacd6
movq 0x7319(%rip), %rdi      # 0x11fc8
leaq 0x2bc2(%rip), %rsi      # 0xd878
callq 0x2150
movq %rax, %rdi
movsbl -0x11(%rbp), %esi
callq 0x21a0
movq %rax, %rdi
leaq 0x2ba2(%rip), %rsi      # 0xd873
callq 0x2150
jmp 0xacd8
jmp 0xacda
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xac25
movq 0x72d9(%rip), %rdi      # 0x11fc8
leaq 0x2b75(%rip), %rsi      # 0xd86b
callq 0x2150
movq %rax, %rdi
movq 0x72b3(%rip), %rsi      # 0x11fb8
callq 0x2190
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xac01
movq 0x72a9(%rip), %rdi      # 0x11fc8
leaq 0x2b58(%rip), %rsi      # 0xd87e
callq 0x2150
movq %rax, %rdi
movq 0x7283(%rip), %rsi      # 0x11fb8
callq 0x2190
movq 0x7287(%rip), %rdi      # 0x11fc8
leaq 0x27d7(%rip), %rsi      # 0xd51f
callq 0x2150
movq %rax, %rdi
movq 0x7261(%rip), %rsi      # 0x11fb8
callq 0x2190
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: tyhsu[P]Ewn/game.cpp
// Function: Game::check_in_board(std::pair<int, int> const&)
bool Game::check_in_board(const Movement& mvmt)
{
	Chess chs = this->cur_chs_list_ptr[mvmt.first];
	int side = (this->is_switch == false) ? 1 : -1;
	int x = chs.x, y = chs.y;
	x += (mvmt.second == 1) ? 0 : side;
	y += (mvmt.second == 0) ? 0 : side;
	return ( x >= 0 && x < 5 && y >= 0 && y < 5);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0xd0(%rax), %rcx
movq -0x10(%rbp), %rdx
movslq (%rdx), %rdx
imulq $0xc, %rdx, %rdx
addq %rdx, %rcx
movq (%rcx), %rdx
movq %rdx, -0x1c(%rbp)
movl 0x8(%rcx), %ecx
movl %ecx, -0x14(%rbp)
movb 0xe4(%rax), %al
andb $0x1, %al
movzbl %al, %edx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0x1, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
movl %eax, -0x20(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1, 0x4(%rax)
jne 0xb04d
xorl %eax, %eax
movl %eax, -0x2c(%rbp)
jmp 0xb053
movl -0x20(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0xb06d
xorl %eax, %eax
movl %eax, -0x30(%rbp)
jmp 0xb073
movl -0x20(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
addl -0x28(%rbp), %eax
movl %eax, -0x28(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x24(%rbp)
movb %al, -0x31(%rbp)
jl 0xb0a7
xorl %eax, %eax
cmpl $0x5, -0x24(%rbp)
movb %al, -0x31(%rbp)
jge 0xb0a7
xorl %eax, %eax
cmpl $0x0, -0x28(%rbp)
movb %al, -0x31(%rbp)
jl 0xb0a7
cmpl $0x5, -0x28(%rbp)
setl %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nop
// File: tyhsu[P]Ewn/game.cpp
// Function: Game::switch_player()
void Game::switch_player()
{
	if (this->is_switch) {	//now is B
		this->cur_chs_list_ptr = this->chs_list_A;
		this->cur_exist_bitwise_ptr = this->exist_bitwise_A;
		this->is_switch = false;
	}
	else {				//now is A
		this->cur_chs_list_ptr = this->chs_list_B;
		this->cur_exist_bitwise_ptr = this->exist_bitwise_B;
		this->is_switch = true;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
testb $0x1, 0xe4(%rax)
je 0xb480
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x3c, %rcx
movq %rcx, 0xd0(%rax)
movl 0xd8(%rax), %ecx
movl %ecx, 0xe0(%rax)
movb $0x0, 0xe4(%rax)
jmp 0xb4a8
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x84, %rcx
movq %rcx, 0xd0(%rax)
movl 0xdc(%rax), %ecx
movl %ecx, 0xe0(%rax)
movb $0x1, 0xe4(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: wichtounet[P]cpp_utils_test/include/cpp_utils/aligned_array.hpp
// Function: cpp::aligned_array<float, 7ul, 32ul>::aligned_array()
aligned_array() {
        auto raw = reinterpret_cast<std::size_t>(storage);

        if (raw % A) {
            aligned_data = reinterpret_cast<value_type*>(raw + (A - (raw % A)));
        } else {
            aligned_data = reinterpret_cast<value_type*>(raw);
        }

        new (aligned_data) value_type[size()]();
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
andq $0x1f, %rax
cmpq $0x0, %rax
je 0x23a99
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movq 0x8(%rsp), %rsi
andq $0x1f, %rsi
movl $0x20, %edx
subq %rsi, %rdx
addq %rdx, %rcx
movq %rcx, 0x40(%rax)
jmp 0x23aa6
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, 0x40(%rax)
movq (%rsp), %rdi
callq 0x23b30
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdx
movq (%rsp), %rax
seto %sil
movq $-0x1, %rcx
testb $0x1, %sil
cmovneq %rcx, %rdx
movq 0x40(%rax), %rdi
xorl %esi, %esi
callq 0xa2a0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: wichtounet[P]cpp_utils_test/include/cpp_utils/aligned_allocator.hpp
// Function: cpp::aligned_allocator<float, 32ul>::allocate(unsigned long) const
T* allocate(const std::size_t n) const {
        // The return value of allocate(0) is unspecified.
        // Mallocator returns nullptr in order to avoid depending
        // on malloc(0)'s implementation-defined behavior
        // (the implementation can define malloc(0) to return nullptr,
        // in which case the bad_alloc check below would fire).
        // All allocators can return nullptr in this case.
        if (n == 0) {
            return nullptr;
        }

        // All allocators should contain an integer overflow check.
        // The Standardization Committee recommends that std::length_error
        // be thrown in the case of integer overflow.
        if (n > max_size()) {
            throw std::length_error("aligned_allocator<T>::allocate() - Integer overflow.");
        }

        void* pv = aligned_allocate(n);

        // Allocators should throw std::bad_alloc in the case of memory allocation failure.
        if (!pv) {
            throw std::bad_alloc();
        }

        return static_cast<T*>(pv);
    }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x40(%rsp)
jne 0x2781e
movq $0x0, 0x50(%rsp)
jmp 0x278e4
movq 0x20(%rsp), %rdi
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
callq 0x276c0
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jbe 0x27894
movl $0x10, %edi
callq 0xa240
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
leaq 0xb8efd(%rip), %rsi     # 0xe0758
callq 0xa5c0
jmp 0x27862
movq 0x10(%rsp), %rdi
movq 0x104742(%rip), %rsi    # 0x12bfb0
movq 0x1046f3(%rip), %rdx    # 0x12bf68
callq 0xa820
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
callq 0xa360
jmp 0x278ee
movq 0x40(%rsp), %rdi
callq 0x27900
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x278da
movl $0x8, %edi
callq 0xa240
movq %rax, %rdi
movq %rdi, 0x8(%rsp)
callq 0x279e0
movq 0x8(%rsp), %rdi
movq 0x1046d2(%rip), %rsi    # 0x12bfa0
movq 0x10466b(%rip), %rdx    # 0x12bf40
callq 0xa820
movq 0x28(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0xa890
nopl (%rax,%rax)
// File: wichtounet[P]cpp_utils_test/include/cpp_utils/aligned_allocator.hpp
// Function: cpp::aligned_allocator<float, 32ul>::aligned_allocate(unsigned long)
static T* aligned_allocate(std::size_t size) {
        auto required_bytes = sizeof(T) * size;
        auto offset         = (A - 1) + sizeof(uintptr_t);
        auto orig           = malloc(required_bytes + offset);

        if (!orig) {
            return nullptr;
        }

        if ((reinterpret_cast<size_t>(orig) + sizeof(uintptr_t)) % A == 0) {
            auto aligned = reinterpret_cast<void**>((reinterpret_cast<size_t>(orig) + sizeof(uintptr_t)));
            aligned[-1] = orig;
            return reinterpret_cast<T*>(aligned);
        } else {
            auto diff    = (reinterpret_cast<size_t>(orig) + sizeof(uintptr_t)) % A;
            auto offset  = A - diff;
            auto aligned = reinterpret_cast<void**>((reinterpret_cast<size_t>(orig) + sizeof(uintptr_t) + offset));
            aligned[-1] = orig;
            return reinterpret_cast<T*>(aligned);
        }
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rax
shlq $0x2, %rax
movq %rax, 0x30(%rsp)
movq $0x27, 0x28(%rsp)
movq 0x30(%rsp), %rdi
addq 0x28(%rsp), %rdi
callq 0xa680
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x2794a
movq $0x0, 0x40(%rsp)
jmp 0x279ce
movq 0x20(%rsp), %rax
addq $0x8, %rax
andq $0x1f, %rax
cmpq $0x0, %rax
jne 0x27985
movq 0x20(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, -0x8(%rax)
movq 0x18(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x279ce
movq 0x20(%rsp), %rax
addq $0x8, %rax
andq $0x1f, %rax
movq %rax, 0x10(%rsp)
movl $0x20, %eax
subq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
addq $0x8, %rax
addq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, -0x8(%rax)
movq (%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax,%rax)