LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/amadvance[P]tommyds/tommyds/tommyhashlin.c
// Function: tommy_hashlin_foreach
void tommy_hashlin_foreach(tommy_hashlin* hashlin, tommy_foreach_func* func)
{
	tommy_size_t bucket_max;
	tommy_size_t pos;

	/* number of valid buckets */
	bucket_max = hashlin->low_max + hashlin->split;

	for (pos = 0; pos < bucket_max; ++pos) {
		tommy_hashlin_node* node = *tommy_hashlin_pos(hashlin, pos);

		while (node) {
			void* data = node->data;
			node = node->next;
			func(data);
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x220(%rdi), %r15
addq 0x210(%rdi), %r15
xorl %r12d, %r12d
cmpq %r15, %r12
je 0x4dcc
movq %r12, %rax
orq $0x1, %rax
bsrq %rax, %rax
shll $0x3, %eax
movq (%r14,%rax), %rax
movq (%rax,%r12,8), %rax
testq %rax, %rax
je 0x4dc7
movq (%rax), %r13
movq 0x10(%rax), %rdi
callq *%rbx
movq %r13, %rax
jmp 0x4db4
incq %r12
jmp 0x4d99
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/amadvance[P]tommyds/tommyds/tommyhashlin.c
// Function: tommy_hashlin_foreach_arg
void tommy_hashlin_foreach_arg(tommy_hashlin* hashlin, tommy_foreach_arg_func* func, void* arg)
{
	tommy_size_t bucket_max;
	tommy_size_t pos;

	/* number of valid buckets */
	bucket_max = hashlin->low_max + hashlin->split;

	for (pos = 0; pos < bucket_max; ++pos) {
		tommy_hashlin_node* node = *tommy_hashlin_pos(hashlin, pos);

		while (node) {
			void* data = node->data;
			node = node->next;
			func(arg, data);
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x220(%rdi), %r12
addq 0x210(%rdi), %r12
xorl %r13d, %r13d
cmpq %r12, %r13
je 0x4e32
movq %r13, %rax
orq $0x1, %rax
bsrq %rax, %rax
shll $0x3, %eax
movq (%r15,%rax), %rax
movq (%rax,%r13,8), %rax
testq %rax, %rax
je 0x4e2d
movq (%rax), %rbp
movq 0x10(%rax), %rsi
movq %rbx, %rdi
callq *%r14
movq %rbp, %rax
jmp 0x4e16
incq %r13
jmp 0x4dfb
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/amadvance[P]tommyds/tommyds/tommytree.c
// Function: tommy_tree_balance
static tommy_tree_node* tommy_tree_balance(tommy_tree_node* root)
{
	tommy_ssize_t delta = tommy_tree_delta(root);

	if (delta < -1) {
		if (tommy_tree_delta(root->next) > 0)
			root->next = tommy_tree_rotate_right(root->next);
		return tommy_tree_rotate_left(root);
	}

	if (delta > 1) {
		if (tommy_tree_delta(root->prev) < 0)
			root->prev = tommy_tree_rotate_left(root->prev);
		return tommy_tree_rotate_right(root);
	}

	/* recompute key */
	root->index = 0;

	if (root->prev && root->prev->index > root->index)
		root->index = root->prev->index;

	if (root->next && root->next->index > root->index)
		root->index = root->next->index;

	/* count itself */
	root->index += 1;

	return root;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x5026
cmpq $-0x2, %rax
jg 0x4fb3
movq (%rbx), %r14
movq %r14, %rdi
callq 0x5026
testq %rax, %rax
jle 0x4fa4
movq %r14, %rdi
callq 0x504b
movq %rax, (%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5068
cmpq $0x2, %rax
jl 0x4fe2
movq 0x8(%rbx), %r14
movq %r14, %rdi
callq 0x5026
testq %rax, %rax
jns 0x4fd6
movq %r14, %rdi
callq 0x5068
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x504b
andq $0x0, 0x18(%rbx)
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x4fff
movq 0x18(%rax), %rax
testq %rax, %rax
je 0x4fff
movq %rax, 0x18(%rbx)
jmp 0x5001
xorl %eax, %eax
movq (%rbx), %rcx
testq %rcx, %rcx
je 0x5014
movq 0x18(%rcx), %rcx
cmpq %rax, %rcx
cmovaq %rcx, %rax
incq %rax
movq %rax, 0x18(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/Rjerk[P]ratabase/Logger.cpp
// Function: logging::getTimeStr[abi:cxx11]()
std::string getTimeStr()
{
    std::time_t t;
    std::time(&t);
    std::string str = std::ctime(&t);
    str.erase(str.size()-1);
    return str;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x21b0
movq %r14, %rdi
callq 0x20c0
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x20d0
movq 0x8(%rbx), %rsi
decq %rsi
pushq $-0x1
popq %rdx
movq %rbx, %rdi
callq 0x2050
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x2100
movq %r14, %rdi
callq 0x2290
nop
// File: /workspace/github_cpp_makefile_star2_O2/Rjerk[P]ratabase/Logger.cpp
// Function: logging::Logger::Logger(char const*, int, char const*, logging::Logger::LogLevel)
Logger::Logger(const char* filename, int line, const char* func_name, LogLevel level)
{
    setLevel(level);
    sstream_ << "[";
    sstream_ << level_string[level];
    sstream_ << "]";
    sstream_ << getTimeStr() << " ";
    sstream_ << filename << " ";
    sstream_ << "(" << line << ") ";
    sstream_ << func_name << " ";
    sstream_ << ": ";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %r13d
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %rbx
callq 0x2150
movl %r13d, 0x2b20(%rip)     # 0x51b8
leaq 0x10(%rbx), %r14
leaq 0x9fd(%rip), %rsi       # 0x30a0
movq %r14, %rdi
callq 0x21c0
movl %r13d, %eax
leaq 0x2abb(%rip), %rcx      # 0x5170
movq (%rcx,%rax,8), %rsi
movq %r14, %rdi
callq 0x21c0
leaq 0x9da(%rip), %rsi       # 0x30a2
movq %r14, %rdi
callq 0x21c0
leaq 0x8(%rsp), %rdi
callq 0x2610
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x21a0
leaq 0x9b9(%rip), %rsi       # 0x30a7
movq %rax, %rdi
callq 0x21c0
leaq 0x8(%rsp), %rdi
callq 0x2100
movq %r14, %rdi
movq %r12, %rsi
callq 0x21c0
leaq 0x995(%rip), %rsi       # 0x30a7
movq %rax, %rdi
callq 0x21c0
leaq 0x983(%rip), %rsi       # 0x30a4
movq %r14, %rdi
callq 0x21c0
movq %rax, %rdi
movl %ebp, %esi
callq 0x2270
leaq 0x96c(%rip), %rsi       # 0x30a6
movq %rax, %rdi
callq 0x21c0
movq %r14, %rdi
movq %r15, %rsi
callq 0x21c0
leaq 0x953(%rip), %rsi       # 0x30a7
movq %rax, %rdi
callq 0x21c0
leaq 0xa57(%rip), %rsi       # 0x31ba
movq %r14, %rdi
callq 0x21c0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x278b
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x2100
jmp 0x278e
movq %rax, %r14
movq %rbx, %rdi
callq 0x2160
movq %r14, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O2/Rjerk[P]ratabase/Logger.cpp
// Function: logging::Logger::~Logger()
Logger::~Logger()
{
    if (output_callback_) {
        std::string str = sstream_.str();
        sstream_.flush();
        output_callback_(std::move(str));
    }
    if (level_limit_ == Fatal) {
        sstream_.flush();
        ::abort();
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x2a0e(%rip)      # 0x51d0
je 0x284b
leaq 0x18(%rbx), %rsi
leaq 0x8(%rsp), %rdi
callq 0x2260
leaq 0x10(%rbx), %rdi
callq 0x2140
leaq 0x38(%rsp), %rcx
movq %rcx, -0x10(%rcx)
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdx
cmpq %rax, %rdx
je 0x2807
movq %rdx, 0x28(%rsp)
movq 0x18(%rsp), %rcx
movq %rcx, 0x38(%rsp)
jmp 0x280d
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x10(%rsp), %rcx
leaq 0x28(%rsp), %rsi
movq %rcx, 0x8(%rsi)
movq %rax, 0x8(%rsp)
andq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
leaq 0x298e(%rip), %rdi      # 0x51c0
callq 0x293e
leaq 0x28(%rsp), %rdi
callq 0x2100
leaq 0x8(%rsp), %rdi
callq 0x2100
cmpl $0x5, 0x2966(%rip)      # 0x51b8
je 0x2864
movq %rbx, %rdi
callq 0x2160
addq $0x48, %rsp
popq %rbx
popq %r14
retq
leaq 0x10(%rbx), %rdi
callq 0x2140
callq 0x2120
jmp 0x2892
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x2100
jmp 0x2886
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x2100
jmp 0x2895
movq %rax, %r14
movq %rbx, %rdi
callq 0x2160
movq %r14, %rdi
callq 0x2200
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r14
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movl %edi, %ebx
pushq $0x3
popq %rsi
xorl %edx, %edx
xorl %eax, %eax
callq 0x2130
orl $0x800, %eax            # imm = 0x800
pushq $0x4
popq %rsi
movl %ebx, %edi
movl %eax, %edx
xorl %eax, %eax
callq 0x2130
cmpl $-0x1, %eax
jne 0x2a3b
leaq 0x6c0(%rip), %rsi       # 0x30bf
leaq 0x6c5(%rip), %rcx       # 0x30cb
movq %rsp, %r14
pushq $0xe
popq %rdx
pushq $0x4
popq %r8
movq %r14, %rdi
callq 0x2670
movq %r14, %rdi
callq 0x28be
addq $0x10, %rax
leaq 0x6ba(%rip), %rsi       # 0x30e5
movq %rax, %rdi
callq 0x21c0
movq %rsp, %rdi
callq 0x27b0
pushq $0x3
popq %rsi
movl %ebx, %edi
xorl %edx, %edx
xorl %eax, %eax
callq 0x2130
orl $0x1, %eax
pushq $0x4
popq %rsi
movl %ebx, %edi
movl %eax, %edx
xorl %eax, %eax
callq 0x2130
cmpl $-0x1, %eax
jne 0x2aa2
leaq 0x659(%rip), %rsi       # 0x30bf
leaq 0x65e(%rip), %rcx       # 0x30cb
movq %rsp, %rbx
pushq $0x14
popq %rdx
pushq $0x4
popq %r8
movq %rbx, %rdi
callq 0x2670
movq %rbx, %rdi
callq 0x28be
addq $0x10, %rax
leaq 0x68b(%rip), %rsi       # 0x311d
movq %rax, %rdi
callq 0x21c0
movq %rsp, %rdi
callq 0x27b0
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r14
retq
jmp 0x2aaf
movq %rax, %rbx
movq %rsp, %rdi
callq 0x27b0
movq %rbx, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r14
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
callq 0x2220
movq %rax, %rbx
cmpq $-0x1, %rax
jne 0x2ecb
leaq 0x230(%rip), %rsi       # 0x30bf
leaq 0x35b(%rip), %rcx       # 0x31f1
movq %rsp, %r14
pushq $0x5f
popq %rdx
pushq $0x4
popq %r8
movq %r14, %rdi
callq 0x2670
movq %r14, %rdi
callq 0x28be
addq $0x10, %rax
leaq 0x32d(%rip), %rsi       # 0x31e8
movq %rax, %rdi
callq 0x21c0
movq %rsp, %rdi
callq 0x27b0
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x27b0
movq %rbx, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r14
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
callq 0x20a0
movq %rax, %rbx
cmpq $-0x1, %rax
jne 0x2f47
leaq 0x1b4(%rip), %rsi       # 0x30bf
leaq 0x2ed(%rip), %rcx       # 0x31ff
movq %rsp, %r14
pushq $0x68
popq %rdx
pushq $0x4
popq %r8
movq %r14, %rdi
callq 0x2670
movq %r14, %rdi
callq 0x28be
addq $0x10, %rax
leaq 0x2bf(%rip), %rsi       # 0x31f6
movq %rax, %rdi
callq 0x21c0
movq %rsp, %rdi
callq 0x27b0
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x27b0
movq %rbx, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
cmpq $0x0, 0x8(%rdi)
je 0x47c9
movq %rdi, %r14
leaq 0x4e42(%rip), %r15      # 0x9576
xorl %ebx, %ebx
movq %r15, %rsi
xorl %edx, %edx
callq 0x2100
leaq -0x40(%rbp), %r12
pushq $-0x1
popq %rcx
movq %r12, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x21e0
movq %r14, %rdi
movq %r12, %rsi
callq 0x2200
movq %r12, %rdi
callq 0x20d0
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x2150
leaq -0x40(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x21e0
movq %r14, %rdi
movq %r15, %rsi
callq 0x2200
movq %r15, %rdi
callq 0x20d0
movl 0x8(%r14), %r15d
pushq $0x1
popq %r12
testl %r15d, %r15d
jle 0x47cb
decq %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x2360
movsbl (%rax), %eax
addl $-0x30, %eax
imull %r12d, %eax
addl %eax, %ebx
imull $0xa, %r12d, %r12d
jmp 0x47a4
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/openflightmaps[P]ofm2xplane/main.cpp
// Function: my_stof(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
float my_stof(string s, int d)
{
    if(s.length()==0)
        return 0.0;
    float out=0.0;
    float add=1.0;
    int l1;
    int l2;
    size_t p1=s.find_first_of("1234567890.");
    s=s.substr(p1);
    p1=s.find_first_not_of("1234567890.");
    s=s.substr(0,p1);
    
    l1=s.find(".");
    if(l1==s.npos)
        l1=s.length();
    l2=s.length();
    
    for(int i=l1-1;i>=0;i--)
    {
        out+=add*(int(s.at(i))-48);
        add=add*10;
    }
    
    add=0.1;
    int j=0;
    for(int i=l1+1;i<l2;i++)
    {
        out+=add*(int(s.at(i))-48);
        add=add*0.1;
        j++;
        if(j==d)
            break;
    }
    return out;
}

// Assembly:
cmpq $0x0, 0x8(%rdi)
je 0x494b
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebx
movq %rdi, %r14
leaq 0x4d13(%rip), %r15      # 0x9515
movq %r15, %rsi
xorl %edx, %edx
callq 0x2100
leaq -0x50(%rbp), %r12
pushq $-0x1
popq %rcx
movq %r12, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x21e0
movq %r14, %rdi
movq %r12, %rsi
callq 0x2200
movq %r12, %rdi
callq 0x20d0
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x2150
leaq -0x50(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x21e0
movq %r14, %rdi
movq %r15, %rsi
callq 0x2200
movq %r15, %rdi
callq 0x20d0
leaq 0x4825(%rip), %rsi      # 0x9094
movq %r14, %rdi
xorl %edx, %edx
callq 0x2380
movq %rax, %r15
cmpl $-0x1, %r15d
movq 0x8(%r14), %r13
cmoveq %r13, %r15
movl %r15d, %r12d
xorps %xmm0, %xmm0
movss 0x47aa(%rip), %xmm2     # 0x9040
testl %r12d, %r12d
jle 0x48d9
decq %r12
movq %r14, %rdi
movq %r12, %rsi
movss %xmm0, -0x30(%rbp)
movss %xmm2, -0x2c(%rbp)
callq 0x2360
movss -0x2c(%rbp), %xmm2
movss -0x30(%rbp), %xmm0
movsbl (%rax), %eax
addl $-0x30, %eax
cvtsi2ss %eax, %xmm1
mulss %xmm2, %xmm1
addss %xmm1, %xmm0
mulss 0x4771(%rip), %xmm2     # 0x9048
jmp 0x4896
movslq %r15d, %r15
movslq %r13d, %r12
incq %r15
decl %ebx
movss 0x4758(%rip), %xmm1     # 0x9044
cmpq %r12, %r15
jge 0x493c
movq %r14, %rdi
movq %r15, %rsi
movss %xmm0, -0x30(%rbp)
movss %xmm1, -0x2c(%rbp)
callq 0x2360
movss -0x2c(%rbp), %xmm2
movss -0x30(%rbp), %xmm0
movsbl (%rax), %eax
addl $-0x30, %eax
cvtsi2ss %eax, %xmm1
mulss %xmm2, %xmm1
addss %xmm1, %xmm0
subl $0x1, %ebx
jb 0x493c
cvtss2sd %xmm2, %xmm1
mulsd 0x46ed(%rip), %xmm1     # 0x9020
cvtsd2ss %xmm1, %xmm1
incq %r15
jmp 0x48ec
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ecx
movl %esi, %r14d
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
xorl %r15d, %r15d
pushq $0xa
popq %r12
movl %esi, %eax
testl %eax, %eax
je 0x4988
cltd
idivl %r12d
incq %r15
jmp 0x497b
cmpl %ecx, %r15d
cmovgl %r15d, %ecx
pushq $0x30
popq %rdx
movq %rbx, %rdi
movq %rcx, %rsi
callq 0x2320
movabsq $-0x100000000, %rcx     # imm = 0xFFFFFFFF00000000
movq 0x8(%rbx), %rsi
shlq $0x20, %rsi
addq %rcx, %rsi
subq $0x1, %r15
jb 0x49d8
movl %r14d, %eax
cltd
idivl %r12d
addb $0x30, %dl
movq %rsi, %rdi
sarq $0x20, %rdi
movq (%rbx), %r8
movb %dl, (%r8,%rdi)
addq %rcx, %rsi
movl %eax, %r14d
jmp 0x49b2
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x20d0
movq %r14, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %esi, %ebx
movq %rdi, %r14
leaq 0x484c(%rip), %r15      # 0x925e
pushq $0x1
popq %r12
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
movl %r12d, %ecx
callq 0x6e98
testq %rax, %rax
jne 0x4a38
movq 0x30(%r14), %r14
testq %r14, %r14
jne 0x4a16
xorl %ebx, %ebx
jmp 0x4a84
leaq 0x481f(%rip), %rsi      # 0x925e
pushq $0x1
popq %rcx
movq %r14, %rdi
xorl %edx, %edx
callq 0x6e98
movq 0x8(%rax), %rax
testq %rax, %rax
leaq 0x879e(%rip), %rsi      # 0xd1f8
cmovneq %rax, %rsi
leaq -0x48(%rbp), %r14
leaq -0x21(%rbp), %rdx
movq %r14, %rdi
callq 0x6f24
movq %r14, %rdi
callq 0x4710
cmpl %ebx, %eax
sete %bl
leaq -0x48(%rbp), %rdi
callq 0x20d0
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
leaq 0x4a32(%rip), %rsi      # 0x94ed
pushq $0x1
popq %rbx
xorl %edx, %edx
movl %ebx, %ecx
callq 0x6d52
movq 0x8(%rax), %rsi
testq %rsi, %rsi
leaq 0x8723(%rip), %r14      # 0xd1f8
cmoveq %r14, %rsi
leaq -0x40(%rbp), %r15
leaq -0x60(%rbp), %rdx
movq %r15, %rdi
callq 0x6f24
cmpq $0x0, 0x8(%r15)
jne 0x4b4f
movq 0x86f9(%rip), %rdi      # 0xd1f0
leaq 0x49ff(%rip), %rsi      # 0x94fd
pushq $0x1
popq %rcx
xorl %edx, %edx
callq 0x6d52
leaq 0x49de(%rip), %rsi      # 0x94ed
pushq $0x1
popq %rcx
movq %rax, %rdi
xorl %edx, %edx
callq 0x6d52
movq 0x8(%rax), %rax
testq %rax, %rax
cmovneq %rax, %r14
leaq -0x60(%rbp), %rdi
leaq -0x19(%rbp), %rdx
movq %r14, %rsi
callq 0x6f24
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %r14
movq %r14, %rsi
callq 0x2200
movq %r14, %rdi
callq 0x20d0
leaq 0x49ae(%rip), %rsi      # 0x9504
leaq -0x40(%rbp), %rdi
callq 0x2090
testl %eax, %eax
je 0x4b8e
leaq 0x499f(%rip), %rsi      # 0x9509
leaq -0x40(%rbp), %rdi
callq 0x2090
testl %eax, %eax
je 0x4b8b
leaq 0x4990(%rip), %rsi      # 0x950e
leaq -0x40(%rbp), %rdi
callq 0x2090
pushq $0x3
jmp 0x4b8d
pushq $0x2
popq %rbx
leaq -0x40(%rbp), %rdi
callq 0x20d0
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4ba6
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O2/openflightmaps[P]ofm2xplane/main.cpp
// Function: my_stod(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
double my_stod(string s, int d)
{
    if(s.length()==0)
        return 0.0;
    double out=0.0;
    double add=1.0;
    int l1;
    int l2;
    size_t p1=s.find_first_of("1234567890.");
    s=s.substr(p1);
    p1=s.find_first_not_of("1234567890.");
    s=s.substr(0,p1);
    
    l1=s.find(".");
    if(l1==s.npos)
        l1=s.length();
    l2=s.length();
    
    for(int i=l1-1;i>=0;i--)
    {
        out+=add*(int(s.at(i))-48);
        add=add*10;
    }
    int j=0;
    add=0.1;
    for(int i=l1+1;i<l2;i++)
    {
        out+=add*(int(s.at(i))-48);
        add=add*0.1;
        j++;
/*         cout << "add: " << add << endl;
        cout << "out: " << out << endl << endl;
        system("pause"); */
        if(j==d)
            break;
    }
    return out;
}

// Assembly:
cmpq $0x0, 0x8(%rdi)
je 0x4d37
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %esi, %ebx
movq %rdi, %r14
leaq 0x4933(%rip), %r15      # 0x9515
movq %r15, %rsi
xorl %edx, %edx
callq 0x2100
leaq -0x58(%rbp), %r12
pushq $-0x1
popq %rcx
movq %r12, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x21e0
movq %r14, %rdi
movq %r12, %rsi
callq 0x2200
movq %r12, %rdi
callq 0x20d0
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x2150
leaq -0x58(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x21e0
movq %r14, %rdi
movq %r15, %rsi
callq 0x2200
movq %r15, %rdi
callq 0x20d0
leaq 0x4445(%rip), %rsi      # 0x9094
movq %r14, %rdi
xorl %edx, %edx
callq 0x2380
movq %rax, %r15
cmpl $-0x1, %r15d
movq 0x8(%r14), %r13
cmoveq %r13, %r15
movl %r15d, %r12d
xorps %xmm0, %xmm0
movsd 0x43b2(%rip), %xmm2     # 0x9028
testl %r12d, %r12d
jle 0x4cc3
decq %r12
movq %r14, %rdi
movq %r12, %rsi
movsd %xmm0, -0x30(%rbp)
movsd %xmm2, -0x38(%rbp)
callq 0x2360
movsd -0x38(%rbp), %xmm2
movsbl (%rax), %eax
addl $-0x30, %eax
cvtsi2sd %eax, %xmm0
mulsd %xmm2, %xmm0
movsd -0x30(%rbp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
mulsd 0x436f(%rip), %xmm2     # 0x9030
jmp 0x4c76
movslq %r15d, %r15
movslq %r13d, %r12
incq %r15
decl %ebx
movsd 0x434a(%rip), %xmm2     # 0x9020
cmpq %r12, %r15
jge 0x4d28
movq %r14, %rdi
movq %r15, %rsi
movsd %xmm0, -0x30(%rbp)
movsd %xmm2, -0x38(%rbp)
callq 0x2360
movsd -0x38(%rbp), %xmm2
movsbl (%rax), %eax
addl $-0x30, %eax
cvtsi2sd %eax, %xmm0
mulsd %xmm2, %xmm0
movsd -0x30(%rbp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
subl $0x1, %ebx
jb 0x4d28
mulsd 0x42fd(%rip), %xmm2     # 0x9020
incq %r15
jmp 0x4cd6
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O2/openflightmaps[P]ofm2xplane/main.cpp
// Function: search_all_nodes(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, rapidxml::xml_node<char>*, std::basic_ofstream<char, std::char_traits<char>>&)
void search_all_nodes(string target, xml_node<> *start, ofstream &out)
{
    xml_node<> * current=start;
	int ebene=0;
	out << current->name() << endl << endl;
	while(true)
	{
	    if(current->first_node()!=NULL && current->first_node()->name()[0] != '\0')
		{
			ebene++;
			current=current->first_node();
			goto check;
		}
		sibparent:
		if(current->next_sibling()!=NULL)
		{
			current=current->next_sibling();
			goto check;
		}
		if(current->parent()!=NULL && ebene > 0)
		{
			ebene--;
			current=current->parent();
			goto sibparent;
		}
		break;
		
		check:
		string s(current->name());
		if(s.compare(target)==0)
			out << current->value() << endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r15
movq %rdi, -0x40(%rbp)
movq (%rsi), %rsi
testq %rsi, %rsi
leaq 0x6ba7(%rip), %rbx      # 0xd1f8
cmoveq %rbx, %rsi
movq %rdx, -0x38(%rbp)
movq %rdx, %rdi
callq 0x21b0
movq %rax, %rdi
callq 0x20e0
movq %rax, %rdi
callq 0x20e0
xorl %r14d, %r14d
pushq $0x1
popq %r12
leaq -0x60(%rbp), %r13
movq 0x30(%r15), %rax
testq %rax, %rax
je 0x66b0
movq (%rax), %rsi
testq %rsi, %rsi
movq %rsi, %rcx
cmoveq %rbx, %rcx
cmpb $0x0, (%rcx)
je 0x66b0
incl %r14d
movq %rax, %r15
jmp 0x66d9
movq 0x20(%r15), %r15
testq %r15, %r15
je 0x6725
testl %r14d, %r14d
jle 0x6725
decl %r14d
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
movl %r12d, %ecx
callq 0x6dec
testq %rax, %rax
je 0x669f
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
movl %r12d, %ecx
callq 0x6dec
movq %rax, %r15
movq (%rax), %rsi
testq %rsi, %rsi
cmoveq %rbx, %rsi
movq %r13, %rdi
leaq -0x29(%rbp), %rdx
callq 0x6f24
movq %r13, %rdi
movq -0x40(%rbp), %rsi
callq 0x2040
testl %eax, %eax
jne 0x6718
movq 0x8(%r15), %rsi
testq %rsi, %rsi
cmoveq %rbx, %rsi
movq -0x38(%rbp), %rdi
callq 0x21b0
movq %rax, %rdi
callq 0x20e0
movq %r13, %rdi
callq 0x20d0
jmp 0x667c
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
leaq 0x287c(%rip), %r15      # 0x925e
pushq $0x1
popq %r12
pushq $-0x1
popq %rbx
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
movl %r12d, %ecx
callq 0x6e98
testq %rax, %rax
jne 0x6a09
movq 0x30(%r14), %r14
testq %r14, %r14
jne 0x69e9
jmp 0x6a52
leaq 0x284e(%rip), %rsi      # 0x925e
pushq $0x1
popq %rcx
movq %r14, %rdi
xorl %edx, %edx
callq 0x6e98
movq 0x8(%rax), %rax
testq %rax, %rax
leaq 0x67cd(%rip), %rsi      # 0xd1f8
cmovneq %rax, %rsi
leaq -0x48(%rbp), %rbx
leaq -0x21(%rbp), %rdx
movq %rbx, %rdi
callq 0x6f24
movq %rbx, %rdi
callq 0x4710
movl %eax, %ebx
leaq -0x48(%rbp), %rdi
callq 0x20d0
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x10ccc(%rip), %rax     # 0x135a8
leaq (%rax,%rax), %rcx
testq %rax, %rax
pushq $0x2
popq %rbx
cmovneq %rcx, %rbx
leaq 0x871b(%rip), %rdi      # 0xb00c
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2786
pushq $0x18
popq %rsi
movq %rbx, %rdi
callq 0x2070
movq %rax, %r14
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x2070
movq %rax, %r15
movq 0x10c92(%rip), %r12     # 0x135b0
movq 0x10c83(%rip), %r13     # 0x135a8
imulq $0x18, %r13, %rdx
movq %r14, %rdi
movq %r12, %rsi
callq 0x2080
movslq %r13d, %rax
imulq $0x18, %rax, %rcx
addq %r14, %rcx
addq $0x18, %rcx
cmpq %rax, %rbx
jbe 0x2964
orl $-0x1, -0x18(%rcx)
incq %rax
cmpq %rax, %rbx
movl $0x0, %edx
cmovaq %rcx, %rdx
movq %rdx, -0x8(%rcx)
addq $0x18, %rcx
jmp 0x2942
testq %r13, %r13
je 0x2986
movq %r12, %rdi
callq 0x2090
movq 0x10c48(%rip), %rdi     # 0x135c0
callq 0x2090
movq 0x10c24(%rip), %rax     # 0x135a8
jmp 0x2988
xorl %eax, %eax
imulq $0x18, %rax, %rax
movq %r14, %rcx
addq %rax, %rcx
movq %rcx, 0x10c1f(%rip)     # 0x135b8
movq %rbx, 0x10c08(%rip)     # 0x135a8
movq %r14, 0x10c09(%rip)     # 0x135b0
movq %r15, 0x10c12(%rip)     # 0x135c0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/alexwarth[P]nothing/main.cpp
// Function: asClass(int)
classSlots *asClass(value_t oop)        { dAssert(isOop(oop));
                                          // TODO: replace the following assert with an instanceof (or at least class) check
                                          dAssert(numSlots(oop) == Int(sizeof(classSlots) / sizeof(value_t)));
                                          return (classSlots *)slots(oop); }

// Assembly:
pushq %rbx
movl %edi, %ebx
movl 0x10a8f(%rip), %eax     # 0x13540
testl %eax, %eax
sete %cl
testb $0x1, %bl
sete %dl
orb %cl, %dl
je 0x2ad8
testl %eax, %eax
je 0x2ad0
movl %ebx, %edi
callq 0x29b8
cmpl $0xf, %eax
jne 0x2af1
movl %ebx, %edi
popq %rbx
jmp 0x29f9
leaq 0x8545(%rip), %rdi      # 0xb024
leaq 0x8551(%rip), %rsi      # 0xb037
leaq 0x85bd(%rip), %rcx      # 0xb0aa
pushq $0x76
jmp 0x2b08
leaq 0x85cf(%rip), %rdi      # 0xb0c7
leaq 0x8538(%rip), %rsi      # 0xb037
leaq 0x85a4(%rip), %rcx      # 0xb0aa
pushq $0x78
popq %rdx
callq 0x2060
// File: /workspace/github_cpp_makefile_star2_O2/alexwarth[P]nothing/main.cpp
// Function: asContext(int)
contextSlots *asContext(value_t oop)    { dAssert(isOop(oop));
                                          // TODO: replace the following assert with an instanceof (or at least class) check
                                          dAssert(numSlots(oop) > Int(sizeof(contextSlots) / sizeof(value_t)));
                                          return (contextSlots *)slots(oop); }

// Assembly:
pushq %rbx
movl %edi, %ebx
movl 0x10a29(%rip), %eax     # 0x13540
testl %eax, %eax
sete %cl
testb $0x1, %bl
sete %dl
orb %cl, %dl
je 0x2b3e
testl %eax, %eax
je 0x2b36
movl %ebx, %edi
callq 0x29b8
cmpl $0xb, %eax
jbe 0x2b57
movl %ebx, %edi
popq %rbx
jmp 0x29f9
leaq 0x84df(%rip), %rdi      # 0xb024
leaq 0x84eb(%rip), %rsi      # 0xb037
leaq 0x85b9(%rip), %rcx      # 0xb10c
pushq $0x7b
jmp 0x2b6e
leaq 0x85cf(%rip), %rdi      # 0xb12d
leaq 0x84d2(%rip), %rsi      # 0xb037
leaq 0x85a0(%rip), %rcx      # 0xb10c
pushq $0x7d
popq %rdx
callq 0x2060
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x108dd(%rip), %rbx     # 0x135b8
testq %rbx, %rbx
je 0x2ce9
cmpl $0x0, 0x10859(%rip)     # 0x13540
je 0x2d06
callq 0x2df8
movq 0x108c3(%rip), %rbx     # 0x135b8
testq %rbx, %rbx
jne 0x2d06
callq 0x28cc
movq 0x108b2(%rip), %rbx     # 0x135b8
movq 0x10(%rbx), %rax
movq %rax, 0x108a7(%rip)     # 0x135b8
leal 0x1(,%r14,2), %eax
movl %eax, (%rbx)
movl 0x1084b(%rip), %eax     # 0x1356c
movl %eax, 0x4(%rbx)
pushq $0x4
popq %rsi
movq %r14, %rdi
callq 0x2070
movq %rax, 0x10(%rbx)
andl $0x0, 0x8(%rbx)
subq 0x10872(%rip), %rbx     # 0x135b0
pushq $0x18
popq %rcx
movq %rbx, %rax
cqto
idivq %rcx
addl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
xorl %ebx, %ebx
testb $0x1, %dil
jne 0x2d8e
sarl %edi
movq 0x10854(%rip), %rcx     # 0x135c0
movslq %edi, %rax
cmpb $0x0, (%rcx,%rax)
jne 0x2d8e
movb $0x1, (%rcx,%rax)
movq 0x10830(%rip), %rcx     # 0x135b0
imulq $0x18, %rax, %rax
cmpl $0x0, 0x8(%rcx,%rax)
je 0x2d99
pushq $0x1
popq %rbx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl (%rcx,%rax), %ebp
movq 0x10(%rcx,%rax), %r14
movl %ebp, %r15d
sarl %r15d
xorl %r12d, %r12d
testl %r15d, %r15d
cmovlel %r12d, %r15d
pushq $0x1
popq %rbx
andl $0x1, %ebp
cmpl $0x0, 0x10782(%rip)     # 0x13540
je 0x2dc4
testl %ebp, %ebp
je 0x2dd9
cmpl %r12d, %r15d
je 0x2d8e
movl (%r14,%r12,4), %edi
callq 0x2d53
addl %eax, %ebx
incq %r12
jmp 0x2db7
leaq 0x83ae(%rip), %rdi      # 0xb18e
leaq 0x8250(%rip), %rsi      # 0xb037
leaq 0x8546(%rip), %rcx      # 0xb334
movl $0x90, %edx
callq 0x2060
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq 0x107bc(%rip), %rdi     # 0x135c0
movq 0x1079d(%rip), %rdx     # 0x135a8
xorl %r14d, %r14d
xorl %esi, %esi
callq 0x2050
movl 0x10745(%rip), %edi     # 0x13560
callq 0x2d53
movl %eax, %ebx
movq 0x1077f(%rip), %rsi     # 0x135a8
xorl %r15d, %r15d
cmpq %r15, %rsi
jbe 0x2e9b
movq 0x10788(%rip), %rax     # 0x135c0
cmpb $0x0, (%rax,%r15)
jne 0x2e92
movq 0x1076a(%rip), %rax     # 0x135b0
cmpl $-0x1, (%rax,%r14)
je 0x2e92
movq 0x10(%rax,%r14), %rdi
callq 0x2090
movq 0x10752(%rip), %rax     # 0x135b0
orl $-0x1, (%rax,%r14)
movl 0x106df(%rip), %ecx     # 0x13548
movl %ecx, 0x4(%rax,%r14)
movq 0x10743(%rip), %rcx     # 0x135b8
movq %rcx, 0x10(%rax,%r14)
movq 0x1072f(%rip), %rax     # 0x135b0
addq %r14, %rax
movq %rax, 0x1072d(%rip)     # 0x135b8
movq 0x10716(%rip), %rsi     # 0x135a8
incq %r15
addq $0x18, %r14
jmp 0x2e2c
movslq %ebx, %rbx
subq %rbx, %rsi
leaq 0x849e(%rip), %rdi      # 0xb346
xorl %eax, %eax
callq 0x2786
movq 0x106f2(%rip), %rax     # 0x135a8
subq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
movq 0x10566(%rip), %rax     # 0x13480
cmpq $0x40, %rax
jae 0x2f49
leaq 0x10159(%rip), %rcx     # 0x13080
movq %rsi, (%rcx,%rax,8)
leaq 0x1034e(%rip), %rcx     # 0x13280
movq %rdi, (%rcx,%rax,8)
leaq 0x1(%rax), %rcx
movq %rcx, 0x1053f(%rip)     # 0x13480
leal 0x1(,%rax,2), %eax
retq
pushq %rax
leaq 0x8429(%rip), %rdi      # 0xb37a
leaq 0x80df(%rip), %rsi      # 0xb037
leaq 0x8432(%rip), %rcx      # 0xb391
movl $0xbf, %edx
callq 0x2060
// File: /workspace/github_cpp_makefile_star2_O2/alexwarth[P]nothing/main.cpp
// Function: stringify(char const*)
value_t stringify(const char *s) {
  value_t r = _p1(Push, _p2(MkObj, Str, Int(strlen(s))));
  for (int idx = 0; *s != 0; idx++, s++)
    slotAtPut(r, Int(idx), Int(*s));
  _p(Pop);
  return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl 0xbdc2(%rip), %eax      # 0x13488
cmpl $0x0, 0xbe73(%rip)      # 0x13540
setne %cl
testb $0x1, %al
sete %dl
andb %cl, %dl
cmpb $0x1, %dl
je 0x7810
movq %rdi, %rbx
sarl %eax
cltq
leaq 0xb992(%rip), %r14      # 0x13080
movq (%r14,%rax,8), %r15
callq 0x2040
leal 0x1(,%rax,2), %edi
callq *%r15
movl 0xbddd(%rip), %eax      # 0x134e4
cmpl $0x0, 0xbe32(%rip)      # 0x13540
setne %cl
testb $0x1, %al
sete %dl
andb %cl, %dl
cmpb $0x1, %dl
je 0x7810
sarl %eax
cltq
movl 0xbe4d(%rip), %edi      # 0x13578
callq *(%r14,%rax,8)
movl %eax, %edi
callq *%r15
movl %eax, %ebp
sarl %eax
movq 0xbe71(%rip), %rcx      # 0x135b0
cltq
imulq $0x18, %rax, %rdx
leaq (%rcx,%rdx), %rax
addq %rdx, %rcx
addq $0x10, %rcx
xorl %edx, %edx
movsbl (%rbx), %esi
testl %esi, %esi
je 0x77ab
testb $0x1, %bpl
sete %dil
movl 0xbdd8(%rip), %r8d      # 0x13540
testl %r8d, %r8d
sete %r9b
orb %dil, %r9b
je 0x77e8
movl %edx, %edi
sarl %edi
testl %r8d, %r8d
je 0x7792
testl %edi, %edi
js 0x77df
movl (%rax), %r8d
testb $0x1, %r8b
je 0x77f1
sarl %r8d
cmpl %r8d, %edi
jge 0x77df
leal 0x1(,%rsi,2), %esi
movq (%rcx), %r8
movslq %edi, %rdi
movl %esi, (%r8,%rdi,4)
incq %rbx
addl $0x2, %edx
jmp 0x7752
movl 0xbcdb(%rip), %eax      # 0x1348c
cmpl $0x0, 0xbd88(%rip)      # 0x13540
setne %cl
testb $0x1, %al
sete %dl
testb %dl, %cl
jne 0x782f
sarl %eax
cltq
movl 0xbd7a(%rip), %edi      # 0x13548
callq *(%r14,%rax,8)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7055(%rip), %rdi      # 0xe83b
jmp 0x77f8
leaq 0x386b(%rip), %rdi      # 0xb05a
jmp 0x77f8
leaq 0x3996(%rip), %rdi      # 0xb18e
leaq 0x3838(%rip), %rsi      # 0xb037
leaq 0x7015(%rip), %rcx      # 0xe81b
movl $0x1f9, %edx            # imm = 0x1F9
callq 0x2060
leaq 0x3977(%rip), %rdi      # 0xb18e
leaq 0x3819(%rip), %rsi      # 0xb037
leaq 0x6ff6(%rip), %rcx      # 0xe81b
movl $0x1f7, %edx            # imm = 0x1F7
callq 0x2060
leaq 0x3958(%rip), %rdi      # 0xb18e
leaq 0x37fa(%rip), %rsi      # 0xb037
leaq 0x6fd7(%rip), %rcx      # 0xe81b
movl $0x1fa, %edx            # imm = 0x1FA
callq 0x2060
// File: /workspace/github_cpp_makefile_star2_O2/tyhsu[P]Ewn/main.cpp
// Function: main
int main() {
	int cmd;
	cout << "====================================" << endl;
	cout << "------EinStein würfelt nicht!------" << endl;
	cout << "====================================" << endl;
	cout << "Please choose a mode:" << endl;
	cout << "0)Player v.s Player" << endl;
	cout << "1)AI v.s Player" << endl;
	cout << "2)AI v.s AI" << endl;
	cout << "3)Contest mode" << endl;
	cout << "4)Compare mode" << endl;
	cout << "Choose: ";
	cin >> cmd;
	cout << endl;
	Play ewn;
	if (cmd == 0)
		ewn.two_players_mode();
	else if (cmd == 1)
		ewn.player_AI_mode();
	else if (cmd == 2)
		ewn.two_AIs_mode();
	else if (cmd == 3)
		ewn.contest_AI_mode();
	else if (cmd == 4)
		ewn.compare_AI_mode();
	else
		cout << "It's not a command" << endl;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xf0, %rsp
movq 0x9a87(%rip), %rbx      # 0xbfc8
leaq 0x5fe7(%rip), %r14      # 0x852f
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2150
movq %rax, %rdi
callq 0x2090
leaq 0x5ab6(%rip), %rsi      # 0x8018
movq %rbx, %rdi
callq 0x2150
movq %rax, %rdi
callq 0x2090
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2150
movq %rax, %rdi
callq 0x2090
leaq 0x5ab1(%rip), %rsi      # 0x803d
movq %rbx, %rdi
callq 0x2150
movq %rax, %rdi
callq 0x2090
leaq 0x5ab0(%rip), %rsi      # 0x8053
movq %rbx, %rdi
callq 0x2150
movq %rax, %rdi
callq 0x2090
leaq 0x5aad(%rip), %rsi      # 0x8067
movq %rbx, %rdi
callq 0x2150
movq %rax, %rdi
callq 0x2090
leaq 0x5aa6(%rip), %rsi      # 0x8077
movq %rbx, %rdi
callq 0x2150
movq %rax, %rdi
callq 0x2090
leaq 0x5a9b(%rip), %rsi      # 0x8083
movq %rbx, %rdi
callq 0x2150
movq %rax, %rdi
callq 0x2090
leaq 0x5a93(%rip), %rsi      # 0x8092
movq %rbx, %rdi
callq 0x2150
movq %rax, %rdi
callq 0x2090
leaq 0x5a8b(%rip), %rsi      # 0x80a1
movq %rbx, %rdi
callq 0x2150
movq 0x99b3(%rip), %rdi      # 0xbfd8
leaq -0x14(%rbp), %r14
movq %r14, %rsi
callq 0x20b0
movq %rbx, %rdi
callq 0x2090
leaq -0x100(%rbp), %rdi
callq 0x615a
movl (%r14), %eax
cmpq $0x4, %rax
ja 0x26a4
leaq 0x59af(%rip), %rcx      # 0x8004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq -0x100(%rbp), %rdi
callq 0x28a2
jmp 0x26bf
leaq -0x100(%rbp), %rdi
callq 0x3214
jmp 0x26bf
leaq -0x100(%rbp), %rdi
callq 0x2b14
jmp 0x26bf
leaq -0x100(%rbp), %rdi
callq 0x2d06
jmp 0x26bf
leaq -0x100(%rbp), %rdi
callq 0x2996
jmp 0x26bf
movq 0x991d(%rip), %rdi      # 0xbfc8
leaq 0x59f8(%rip), %rsi      # 0x80aa
callq 0x2150
movq %rax, %rdi
callq 0x2090
xorl %eax, %eax
addq $0xf0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tyhsu[P]Ewn/play.cpp
// Function: Play::player_move(int const&)
Movement Play::player_move(const int& dice)
{
    int movable_chs_cnt = this->game.count_movable_chs(dice);
    int chs_index, direct;
    Movement mvmt;

    do {
        cout << endl << "Next chessman able to move: ";
        for (int i=0; i<movable_chs_cnt; i++)
            cout << i << ")" << this->game.get_movable_chs(i).symbol << " ";
        cout << endl;
        cout << "Choose: ";
        cin >> chs_index;

        if (!this->game.get_is_switch())
            cout << "Direction: 0)Right 1)Down 2)Right-down" << endl;
        else
            cout << "Direction: 0)Left 1)Up 2)Left-up" << endl;
        cout << "Choose: ";
        cin >> direct;

        // get index
        chs_index = (this->game.get_is_switch() == false) ? this->game.get_movable_chs(chs_index).symbol - '1' : this->game.get_movable_chs(chs_index).symbol - 'A';
        mvmt.first = chs_index;
        mvmt.second = direct;
        //If the movement is illegal, run the loop
    } while (!this->game.check_in_board(mvmt));

    return mvmt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0x67b0
leaq -0x38(%rbp), %rcx
andq $0x0, (%rcx)
movl %eax, %r15d
movq 0x9859(%rip), %r12      # 0xbfc8
leaq 0x5da9(%rip), %r13      # 0x851f
movq %r12, %rdi
callq 0x2090
movq %rax, %rdi
leaq 0x5948(%rip), %rsi      # 0x80d0
callq 0x2150
xorl %esi, %esi
movl %esi, -0x2c(%rbp)
movq %r12, %rdi
cmpl %r15d, %esi
jge 0x27da
callq 0x2210
movq %rax, %rdi
leaq 0x5de9(%rip), %rsi      # 0x8592
callq 0x2150
movq %rax, %r14
movq %rbx, %rdi
leaq -0x2c(%rbp), %rsi
callq 0x6d0e
movsbl %al, %esi
movq %r14, %rdi
callq 0x2190
movq %rax, %rdi
movq %r13, %rsi
callq 0x2150
movl -0x2c(%rbp), %esi
incl %esi
jmp 0x278f
callq 0x2090
movq %r12, %rdi
leaq 0x58b8(%rip), %r14      # 0x80a1
movq %r14, %rsi
callq 0x2150
movq 0x97e0(%rip), %rdi      # 0xbfd8
leaq -0x30(%rbp), %rsi
callq 0x20b0
movq %rbx, %rdi
callq 0x6d72
testb %al, %al
leaq 0x58db(%rip), %rsi      # 0x80ed
leaq 0x58fb(%rip), %rax      # 0x8114
cmovneq %rax, %rsi
movq %r12, %rdi
callq 0x2150
movq %rax, %rdi
callq 0x2090
movq %r12, %rdi
movq %r14, %rsi
callq 0x2150
movq 0x9799(%rip), %rdi      # 0xbfd8
leaq -0x3c(%rbp), %rsi
callq 0x20b0
movq %rbx, %rdi
callq 0x6d72
xorb $0x1, %al
movzbl %al, %r14d
shll $0x4, %r14d
movq %rbx, %rdi
leaq -0x30(%rbp), %rsi
callq 0x6d0e
movsbl %al, %eax
addl %r14d, %eax
addl $-0x41, %eax
movl %eax, -0x30(%rbp)
movl %eax, -0x38(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, -0x34(%rbp)
movq %rbx, %rdi
leaq -0x38(%rbp), %rsi
callq 0x68b6
testb %al, %al
je 0x2776
movq -0x38(%rbp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0x6652
leaq 0x5873(%rip), %r15      # 0x8135
leaq -0x2c(%rbp), %r12
leaq -0x38(%rbp), %r13
movq %rbx, %rdi
callq 0x679c
movl %eax, -0x2c(%rbp)
movq 0x96ec(%rip), %rdi      # 0xbfc8
movq %r15, %rsi
callq 0x2150
movl -0x2c(%rbp), %esi
incl %esi
movq %rax, %rdi
callq 0x2210
movq %rax, %rdi
callq 0x2090
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2744
movq %rax, -0x38(%rbp)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x692c
movl %eax, %r14d
movq %rbx, %rdi
callq 0x6652
testl %r14d, %r14d
jne 0x292d
movq %rbx, %rdi
callq 0x6a92
jmp 0x28ca
movq 0x9694(%rip), %rbx      # 0xbfc8
leaq 0x5bf4(%rip), %r15      # 0x852f
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2150
movq %rax, %rdi
callq 0x2090
cmpl $0x1, %r14d
leaq 0x57e3(%rip), %rax      # 0x813c
leaq 0x57ef(%rip), %rsi      # 0x814f
cmoveq %rax, %rsi
movq %rbx, %rdi
callq 0x2150
movq %rax, %rdi
callq 0x2090
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2150
movq %rax, %rdi
callq 0x2090
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tyhsu[P]Ewn/play.cpp
// Function: Play::player_AI_mode()
void Play::player_AI_mode()
{
    EwnAI ewnAI;
    this->game.print_board();
    while (1) {
        int dice = this->game.roll_dice();
        cout << "dice: " << dice+1 << endl;
        int game_status;
        if (this->game.get_is_switch() == true) {
            game_status = this->game.update_game_status(player_move(dice));
        }
        else
            game_status = this->game.update_game_status(ewnAI.AI_move(this->game, dice));

        this->game.print_board();
        //update: 0(game continues), 1(A wins), 2(B wins)
        if (game_status != 0) {
            cout << "====================================" << endl;
            if (game_status == 1) cout << "AI is the winner!!!" << endl;
            else cout << "B is the winner!!!" << endl;
            cout << "====================================" << endl;
            return;
        }
        this->game.switch_player();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x398, %rsp            # imm = 0x398
movq %rdi, %rbx
leaq -0x2d8(%rbp), %rdi
callq 0x3c24
movq %rbx, %rdi
callq 0x6652
leaq 0x576d(%rip), %r15      # 0x8135
leaq -0x38(%rbp), %r13
leaq -0x3c0(%rbp), %r12
movq %rbx, %rdi
callq 0x679c
movl %eax, -0x2c(%rbp)
movq 0x95e3(%rip), %rdi      # 0xbfc8
movq %r15, %rsi
callq 0x2150
movl -0x2c(%rbp), %esi
incl %esi
movq %rax, %rdi
callq 0x2210
movq %rax, %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x6d72
testb %al, %al
je 0x2a2b
movq %rbx, %rdi
leaq -0x2c(%rbp), %rsi
callq 0x2744
movq %rax, -0x38(%rbp)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x692c
jmp 0x2a57
movq %r12, %rdi
movq %rbx, %rsi
callq 0x6336
movl -0x2c(%rbp), %edx
leaq -0x2d8(%rbp), %rdi
movq %r12, %rsi
callq 0x3f00
movq %rax, -0x38(%rbp)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x692c
movl %eax, %r14d
movq %rbx, %rdi
callq 0x6652
testl %r14d, %r14d
jne 0x2a74
movq %rbx, %rdi
callq 0x6a92
jmp 0x29d3
movq 0x954d(%rip), %rdi      # 0xbfc8
leaq 0x5aad(%rip), %rsi      # 0x852f
callq 0x2150
movq %rax, %rdi
callq 0x2090
cmpl $0x1, %r14d
leaq 0x5886(%rip), %rax      # 0x8320
leaq 0x56ae(%rip), %rsi      # 0x814f
cmoveq %rax, %rsi
movq 0x951c(%rip), %rdi      # 0xbfc8
callq 0x2150
movq %rax, %rdi
callq 0x2090
movq 0x9508(%rip), %rdi      # 0xbfc8
leaq 0x5a68(%rip), %rsi      # 0x852f
callq 0x2150
movq %rax, %rdi
callq 0x2090
leaq -0x2d8(%rbp), %rdi
callq 0x3b3e
addq $0x398, %rsp            # imm = 0x398
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2afc
jmp 0x2afc
jmp 0x2afc
jmp 0x2afc
jmp 0x2afc
movq %rax, %rbx
leaq -0x2d8(%rbp), %rdi
callq 0x3b3e
movq %rbx, %rdi
callq 0x2220
nop