LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: WinChua[P]MLDemo/data.cpp
// Function: File::File(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
File::File(std::string f): filename(f), positive_case(0), negative_case(0)
{
    std::ifstream fin(filename.c_str());
    std::string line;
    while(std::getline(fin, line))
    {
        records.emplace(records.end(), line, featureset);
        if((records.end()-1)->label == 1)
            positive_case += 1;
        else
            negative_case += 1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2b0, %rsp            # imm = 0x2B0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x278(%rbp)
movq %rdi, %rax
movq %rax, -0x290(%rbp)
callq 0x20f0
movq -0x278(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x288(%rbp)
callq 0x8c90
movq -0x278(%rbp), %rdi
addq $0x38, %rdi
movq %rdi, -0x280(%rbp)
callq 0x8cb0
movq -0x278(%rbp), %rdi
movl $0x0, 0x68(%rdi)
movl $0x0, 0x6c(%rdi)
callq 0x20e0
movq %rax, %rsi
leaq -0x218(%rbp), %rdi
movl $0x8, %edx
callq 0x2390
jmp 0x8acb
leaq -0x248(%rbp), %rdi
callq 0x22e0
leaq -0x218(%rbp), %rdi
leaq -0x248(%rbp), %rsi
callq 0x2070
movq %rax, -0x298(%rbp)
jmp 0x8af3
movq -0x298(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x22c0
movb %al, -0x299(%rbp)
jmp 0x8b11
movb -0x299(%rbp), %al
testb $0x1, %al
jne 0x8b20
jmp 0x8c34
movq -0x290(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x2b0(%rbp)
callq 0x3f40
movq %rax, -0x258(%rbp)
leaq -0x250(%rbp), %rdi
leaq -0x258(%rbp), %rsi
callq 0x8d20
movq -0x290(%rbp), %rcx
movq -0x2b0(%rbp), %rdi
addq $0x38, %rcx
movq -0x250(%rbp), %rsi
leaq -0x248(%rbp), %rdx
callq 0x8cd0
movq %rax, -0x2a8(%rbp)
jmp 0x8b7f
movq -0x290(%rbp), %rdi
movq -0x2a8(%rbp), %rax
movq %rax, -0x260(%rbp)
addq $0x20, %rdi
callq 0x3f40
movq %rax, -0x270(%rbp)
leaq -0x270(%rbp), %rdi
movl $0x1, %esi
callq 0x8d60
movq %rax, -0x268(%rbp)
leaq -0x268(%rbp), %rdi
callq 0x8da0
cmpl $0x1, (%rax)
jne 0x8c1f
movq -0x290(%rbp), %rax
movl 0x68(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x68(%rax)
jmp 0x8c2f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
jmp 0x8c55
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
leaq -0x248(%rbp), %rdi
callq 0x2140
leaq -0x218(%rbp), %rdi
callq 0x2090
jmp 0x8c55
movq -0x290(%rbp), %rax
movl 0x6c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x6c(%rax)
jmp 0x8ad7
leaq -0x248(%rbp), %rdi
callq 0x2140
leaq -0x218(%rbp), %rdi
callq 0x2090
addq $0x2b0, %rsp            # imm = 0x2B0
popq %rbp
retq
movq -0x280(%rbp), %rdi
callq 0x3b70
movq -0x288(%rbp), %rdi
callq 0x8dc0
movq -0x278(%rbp), %rdi
callq 0x2140
movq -0x220(%rbp), %rdi
callq 0x2350
nopw %cs:(%rax,%rax)
nop
// File: yanlinlin82[P]icpp/icpp.cpp
// Function: dump_enum()
void dump_enum()
{
	for (auto it = enum_values.begin(); it != enum_values.end(); ++it) {
		log("[DEBUG] enum '%s': [ ", it->first.c_str());
		size_t i = 0;
		for (auto e : it->second) {
			log("%s%s = %d", (++i == 1 ? "" : ", "), e.first.c_str(), e.second);
		}
		log(" ]\n");
	}
	for (auto it = enum_types.begin(); it != enum_types.end(); ++it) {
		log("[DEBUG] '%s' => [ '%s', %d ]\n", it->first.c_str(),
				it->second.first.c_str(), it->second.second);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
leaq 0x4c386(%rip), %rdi     # 0x507b8
callq 0x19390
movq %rax, -0x8(%rbp)
leaq 0x4c376(%rip), %rdi     # 0x507b8
callq 0x193f0
movq %rax, -0x10(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x193c0
testb $0x1, %al
jne 0x4461
jmp 0x4580
leaq -0x8(%rbp), %rdi
callq 0x194c0
movq %rax, %rdi
callq 0x3110
movq %rax, %rsi
leaq 0x32cf6(%rip), %rdi     # 0x37172
movb $0x0, %al
callq 0x19420
movq $0x0, -0x18(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x194c0
addq $0x20, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x194f0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x19520
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x19550
testb $0x1, %al
jne 0x44cc
jmp 0x4564
leaq -0x28(%rbp), %rdi
callq 0x19580
movq %rax, %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x195b0
movq -0x88(%rbp), %rdi
movq -0x18(%rbp), %rax
incq %rax
movq %rax, -0x18(%rbp)
subq $0x1, %rax
leaq 0x33ebf(%rip), %rcx     # 0x383c4
leaq 0x32c86(%rip), %rax     # 0x37192
cmoveq %rcx, %rax
movq %rax, -0x80(%rbp)
callq 0x3110
movq -0x80(%rbp), %rsi
movq %rax, %rdx
movl -0x38(%rbp), %ecx
leaq 0x32c5e(%rip), %rdi     # 0x37188
xorl %eax, %eax
callq 0x19420
jmp 0x4533
leaq -0x58(%rbp), %rdi
callq 0x18db0
leaq -0x28(%rbp), %rdi
callq 0x195f0
jmp 0x44b6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x18db0
jmp 0x4626
leaq 0x33ddb(%rip), %rdi     # 0x38346
movb $0x0, %al
callq 0x19420
leaq -0x8(%rbp), %rdi
callq 0x19620
jmp 0x443b
leaq 0x4c269(%rip), %rdi     # 0x507f0
callq 0x19650
movq %rax, -0x70(%rbp)
leaq 0x4c259(%rip), %rdi     # 0x507f0
callq 0x196b0
movq %rax, -0x78(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x19680
testb $0x1, %al
jne 0x45b3
jmp 0x461d
leaq -0x70(%rbp), %rdi
callq 0x196e0
movq %rax, %rdi
callq 0x3110
movq %rax, -0x98(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x196e0
movq %rax, %rdi
addq $0x20, %rdi
callq 0x3110
movq %rax, -0x90(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x196e0
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rdx
movl 0x40(%rax), %ecx
leaq 0x32b8d(%rip), %rdi     # 0x37195
movb $0x0, %al
callq 0x19420
leaq -0x70(%rbp), %rdi
callq 0x19710
jmp 0x4590
addq $0xa0, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x3460
nop
// File: yanlinlin82[P]icpp/icpp.cpp
// Function: print_source_code_line(unsigned long)
void print_source_code_line(size_t n)
{
	log("%4zd ", n + 1);
	for (const char* p = src[n].c_str(); *p; ++p) {
		if (*p == '\t') log("    "); else log("%c", *p);
	}
	log("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
addq $0x1, %rsi
leaq 0x32b68(%rip), %rdi     # 0x371b3
movb $0x0, %al
callq 0x19420
movq -0x8(%rbp), %rsi
leaq 0x4be5b(%rip), %rdi     # 0x504b8
callq 0x19740
movq %rax, %rdi
callq 0x3110
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x46b8
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x9, %eax
jne 0x4693
leaq 0x32b33(%rip), %rdi     # 0x371bd
movb $0x0, %al
callq 0x19420
jmp 0x46a8
movq -0x10(%rbp), %rax
movsbl (%rax), %esi
leaq 0x32b18(%rip), %rdi     # 0x371b9
movb $0x0, %al
callq 0x19420
jmp 0x46aa
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x466e
leaq 0x33b96(%rip), %rdi     # 0x38255
movb $0x0, %al
callq 0x19420
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: yanlinlin82[P]icpp/icpp.cpp
// Function: print_current(bool)
void print_current(bool with_source_code = true)
{
	if (with_source_code) {
		print_source_code_line(line_no - 1);
	}
	log("     ");
	for (const char* q = src[line_no - 1].c_str(); *q && q + token.size() != p; ++q) {
		if (*q == '\t') log("    "); else log(" ");
	}
	for (size_t i = 0; i < token.size(); ++i) {
		log("^");
	}
	log("--(token='%s',type='%s')\n", token.c_str(), token_type_text[type]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
testb $0x1, -0x1(%rbp)
je 0x46f6
movq 0x4bdeb(%rip), %rdi     # 0x504d8
subq $0x1, %rdi
callq 0x4630
leaq 0x32abf(%rip), %rdi     # 0x371bc
movb $0x0, %al
callq 0x19420
movq 0x4bdcd(%rip), %rsi     # 0x504d8
subq $0x1, %rsi
leaq 0x4bda2(%rip), %rdi     # 0x504b8
callq 0x19740
movq %rax, %rdi
callq 0x3110
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpb $0x0, (%rcx)
movb %al, -0x19(%rbp)
je 0x4760
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0x4bda4(%rip), %rdi     # 0x504e8
callq 0x31c0
movq %rax, %rcx
movq -0x28(%rbp), %rax
addq %rcx, %rax
cmpq 0x4bd76(%rip), %rax     # 0x504d0
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x4769
jmp 0x47a3
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x9, %eax
jne 0x4785
leaq 0x32a41(%rip), %rdi     # 0x371bd
movb $0x0, %al
callq 0x19420
jmp 0x4793
leaq 0x32a34(%rip), %rdi     # 0x371c0
movb $0x0, %al
callq 0x19420
jmp 0x4795
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x4727
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x4bd2e(%rip), %rdi     # 0x504e8
callq 0x31c0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x47e7
leaq 0x32956(%rip), %rdi     # 0x37128
movb $0x0, %al
callq 0x19420
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x47ab
leaq 0x4bcfa(%rip), %rdi     # 0x504e8
callq 0x3110
movq %rax, %rsi
movl 0x4bce4(%rip), %eax     # 0x504e0
movl %eax, %ecx
leaq 0x4ba8b(%rip), %rax     # 0x50290
movq (%rax,%rcx,8), %rdx
leaq 0x329b2(%rip), %rdi     # 0x371c2
movb $0x0, %al
callq 0x19420
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: yanlinlin82[P]icpp/icpp.cpp
// Function: add_const_string(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<int, std::allocator<int>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
size_t add_const_string(string name, vector<int> val, string type)
{
	size_t offset = data_sec.size();
	add_symbol(name, false, offset, val.size(), type, "", 0);
	data_sec.insert(data_sec.end(), val.begin(), val.end());
	return offset;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0xe8(%rbp)
movq %rsi, -0xe0(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x4ba3d(%rip), %rdi     # 0x50570
callq 0x19990
movq -0xe8(%rbp), %rsi
movq %rax, -0x20(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3120
movq -0xe0(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0xd8(%rbp)
callq 0x19990
movq -0xd0(%rbp), %rsi
movq %rax, -0xc8(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3120
jmp 0x4b7c
leaq -0x91(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
callq 0x3470
movq -0xf0(%rbp), %rdx
leaq 0x33827(%rip), %rsi     # 0x383c4
leaq -0x90(%rbp), %rdi
callq 0x199b0
jmp 0x4bab
movq -0xc8(%rbp), %rcx
movq -0xd8(%rbp), %rdx
movq %rsp, %rax
movl $0x0, (%rax)
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
leaq -0x60(%rbp), %r8
leaq -0x90(%rbp), %r9
callq 0x4840
jmp 0x4bda
leaq -0x90(%rbp), %rdi
callq 0x34d8
leaq -0x91(%rbp), %rdi
callq 0x32b0
leaq -0x60(%rbp), %rdi
callq 0x34d8
leaq -0x40(%rbp), %rdi
callq 0x34d8
leaq 0x4b965(%rip), %rdi     # 0x50570
callq 0x19b10
movq %rax, -0xa8(%rbp)
leaq -0xa0(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x19b40
movq -0xe0(%rbp), %rdi
callq 0x19b80
movq -0xe0(%rbp), %rdi
movq %rax, -0xb0(%rbp)
callq 0x19b10
movq %rax, -0xb8(%rbp)
movq -0xa0(%rbp), %rsi
movq -0xb0(%rbp), %rdx
movq -0xb8(%rbp), %rcx
leaq 0x4b904(%rip), %rdi     # 0x50570
callq 0x19a60
movq %rax, -0xc0(%rbp)
movq -0x20(%rbp), %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x4cce
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x4cb9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x34d8
leaq -0x91(%rbp), %rdi
callq 0x32b0
leaq -0x60(%rbp), %rdi
callq 0x34d8
leaq -0x40(%rbp), %rdi
callq 0x34d8
movq -0x68(%rbp), %rdi
callq 0x3460
// File: yanlinlin82[P]icpp/icpp.cpp
// Function: print_stack_frame()
void print_stack_frame()
{
	if (verbose >= 4) {
		log("[DEBUG] current stack frame has %zd variable\n", stack_frame_table.back().second.size());
		size_t i = 0;
		for (auto it = stack_frame_table.back().second.begin();
				it != stack_frame_table.back().second.end();
				++it) {
			auto [ offset, size, type ] = it->second;
			log("[DEBUG] [%zd] '%s': offset=%d, size=%d, type='%s'\n", i++, it->first.c_str(), offset, size, type.c_str());
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
cmpl $0x4, 0x4b7a6(%rip)     # 0x50828
jl 0x51f2
leaq 0x4b509(%rip), %rdi     # 0x50598
callq 0x19cb0
movq %rax, %rdi
addq $0x8, %rdi
callq 0x19e20
movq %rax, %rsi
leaq 0x321cc(%rip), %rdi     # 0x37276
movb $0x0, %al
callq 0x19420
movq $0x0, -0x8(%rbp)
leaq 0x4b4d8(%rip), %rdi     # 0x50598
callq 0x19cb0
movq %rax, %rdi
addq $0x8, %rdi
callq 0x19e40
movq %rax, -0x10(%rbp)
leaq 0x4b4bc(%rip), %rdi     # 0x50598
callq 0x19cb0
movq %rax, %rdi
addq $0x8, %rdi
callq 0x19ea0
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x19e70
testb $0x1, %al
jne 0x5107
jmp 0x51f0
leaq -0x10(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x19ed0
movq %rax, %rsi
addq $0x20, %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x19f00
movq -0x90(%rbp), %rdi
callq 0x19f30
movq -0x90(%rbp), %rdi
movq %rax, -0x48(%rbp)
callq 0x19f50
movq -0x90(%rbp), %rdi
movq %rax, -0x50(%rbp)
callq 0x19f70
movq -0x88(%rbp), %rdi
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
incq %rax
movq %rax, -0x8(%rbp)
callq 0x19ed0
movq %rax, %rdi
callq 0x3110
movq %rax, -0x78(%rbp)
movq -0x48(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x6c(%rbp)
movq -0x50(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x68(%rbp)
movq -0x58(%rbp), %rdi
callq 0x3110
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rdx
movl -0x6c(%rbp), %ecx
movl -0x68(%rbp), %r8d
movq %rax, %r9
leaq 0x320eb(%rip), %rdi     # 0x372a4
xorl %eax, %eax
callq 0x19420
jmp 0x51c2
leaq -0x40(%rbp), %rdi
callq 0x19f90
leaq -0x10(%rbp), %rdi
callq 0x19fb0
jmp 0x50d5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x19f90
jmp 0x51fb
jmp 0x51f2
addq $0x90, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x3460
nopw %cs:(%rax,%rax)
// File: yanlinlin82[P]icpp/icpp.cpp
// Function: add_argument(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned long)
void add_argument(string name, string type, size_t offset)
{
	log<3>("[DEBUG] add argument '%s', type = '%s'\n", name.c_str(), type.c_str());
	auto& stack_frame = stack_frame_table.back().second;
	stack_frame.insert(make_pair(name, make_tuple(offset, 1, type)));
	print_stack_frame();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0xd8(%rbp)
movq %rsi, -0xe8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
callq 0x3110
movq -0xe8(%rbp), %rdi
movq %rax, -0xf0(%rbp)
callq 0x3110
movq -0xf0(%rbp), %rsi
movq %rax, %rdx
leaq 0x32079(%rip), %rdi     # 0x372d7
xorl %eax, %eax
callq 0x19760
leaq 0x4b32c(%rip), %rdi     # 0x50598
callq 0x19cb0
movq -0xe8(%rbp), %rcx
addq $0x8, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0xe0(%rbp)
movl $0x1, -0xa4(%rbp)
leaq -0xa0(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
leaq -0x18(%rbp), %rsi
leaq -0xa4(%rbp), %rdx
callq 0x19fe0
movq -0xd8(%rbp), %rsi
movq -0xd0(%rbp), %rdx
leaq -0x70(%rbp), %rdi
callq 0x19d50
jmp 0x52cc
movq -0xe0(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x19d10
movb %dl, -0xf9(%rbp)
movq %rax, -0xf8(%rbp)
jmp 0x52eb
movb -0xf9(%rbp), %al
movq -0xf8(%rbp), %rcx
movq %rcx, -0xc8(%rbp)
movb %al, -0xc0(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x19dd0
leaq -0xa0(%rbp), %rdi
callq 0x19e00
callq 0x5070
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x5357
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x19dd0
leaq -0xa0(%rbp), %rdi
callq 0x19e00
movq -0xb0(%rbp), %rdi
callq 0x3460
nop
// File: yanlinlin82[P]icpp/icpp.cpp
// Function: print_code(std::vector<int, std::allocator<int>> const&, unsigned long, unsigned long)
size_t print_code(const vector<int>& mem, size_t ip, size_t code_loading_position = 0)
{
	size_t code_offset = ip;
	log(COLOR_YELLOW "%-10zd" COLOR_BLUE, ip);
	size_t i = mem[ip++];
	if (i < INVALID) {
		log("%-14.6s", &instruction_name[i * 6]);
	} else {
		log("<0x%08zX>  ", i);
	}
	if (instruction_has_parameter(i)) {
		int v = mem[ip++];
		char buf[64];
		snprintf(buf, sizeof(buf), "0x%08X (%d)", v, v);
		log("%-25s", buf);
		auto it = comments.find(code_offset - code_loading_position);
		if (it != comments.end()) {
			log(" ; %s", it->second.c_str());
		} else if (i == CALL || i == JMP || i == JZ || i == JNZ) {
			log(" ; address %d", ip + v);
		}
	}
	log(COLOR_NORMAL "\n");
	return ip;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rsi
leaq 0x31da5(%rip), %rdi     # 0x372ff
movb $0x0, %al
callq 0x19420
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq %rsi, %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
callq 0x1a110
movslq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x2a, -0x28(%rbp)
jae 0x55a6
movq 0x4acf2(%rip), %rsi     # 0x50280
imulq $0x6, -0x28(%rbp), %rax
addq %rax, %rsi
leaq 0x31d73(%rip), %rdi     # 0x37310
movb $0x0, %al
callq 0x19420
jmp 0x55b8
movq -0x28(%rbp), %rsi
leaq 0x31d67(%rip), %rdi     # 0x37318
movb $0x0, %al
callq 0x19420
movq -0x28(%rbp), %rax
movl %eax, %edi
callq 0x1a130
testb $0x1, %al
jne 0x55cc
jmp 0x56c3
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq %rsi, %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
callq 0x1a110
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
leaq -0x70(%rbp), %rdi
movl -0x2c(%rbp), %ecx
movl -0x2c(%rbp), %r8d
movl $0x40, %esi
leaq 0x31d24(%rip), %rdx     # 0x37324
movb $0x0, %al
callq 0x33d0
leaq -0x70(%rbp), %rsi
leaq 0x31d1e(%rip), %rdi     # 0x37330
movb $0x0, %al
callq 0x19420
movq -0x20(%rbp), %rax
subq -0x18(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq 0x4af84(%rip), %rdi     # 0x505b0
leaq -0x80(%rbp), %rsi
callq 0x1a1e0
movq %rax, -0x78(%rbp)
leaq 0x4af70(%rip), %rdi     # 0x505b0
callq 0x1a240
movq %rax, -0x88(%rbp)
leaq -0x78(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x1a210
testb $0x1, %al
jne 0x5662
jmp 0x568a
leaq -0x78(%rbp), %rdi
callq 0x1a270
movq %rax, %rdi
addq $0x8, %rdi
callq 0x3110
movq %rax, %rsi
leaq 0x31cb5(%rip), %rdi     # 0x37336
movb $0x0, %al
callq 0x19420
jmp 0x56c1
cmpq $0x25, -0x28(%rbp)
je 0x56a6
cmpq $0x27, -0x28(%rbp)
je 0x56a6
cmpq $0x28, -0x28(%rbp)
je 0x56a6
cmpq $0x29, -0x28(%rbp)
jne 0x56bf
movq -0x10(%rbp), %rsi
movslq -0x2c(%rbp), %rax
addq %rax, %rsi
leaq 0x31c84(%rip), %rdi     # 0x3733c
movb $0x0, %al
callq 0x19420
jmp 0x56c1
jmp 0x56c3
leaq 0x32994(%rip), %rdi     # 0x3805e
movb $0x0, %al
callq 0x19420
movq -0x10(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
nop
// File: yanlinlin82[P]icpp/icpp.cpp
// Function: prepare_string(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
vector<int> prepare_string(const string& s)
{
	size_t bytes = s.size() + 1;
	size_t size = (bytes + sizeof(int) - 1) / sizeof(int);
	vector<int> a(size);
	memcpy(&a[0], s.c_str(), bytes);
	return a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31c0
incq %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x3, %rax
shrq $0x2, %rax
movq %rax, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x22(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x18e90
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x18eb0
jmp 0x5f37
leaq -0x22(%rbp), %rdi
callq 0x18f20
movq -0x50(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x19cf0
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3110
movq -0x60(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rdx
callq 0x3210
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x5f96
jmp 0x5f8d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x22(%rbp), %rdi
callq 0x18f20
jmp 0x5fa0
movq -0x50(%rbp), %rdi
callq 0x18f40
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x3460
nopl (%rax)
// File: yanlinlin82[P]icpp/icpp.cpp
// Function: skip_until(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void skip_until(string expected_token, string stat)
{
	next();
	while (!token.empty() && token != expected_token) {
		next();
	}
	if (token.empty()) {
		expect_token(expected_token, stat);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x70(%rbp)
movq %rsi, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x6030
leaq 0x49cb1(%rip), %rdi     # 0x504e8
callq 0x3430
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x71(%rbp)
jne 0x685b
movq -0x70(%rbp), %rsi
leaq 0x49c95(%rip), %rdi     # 0x504e8
callq 0x1a750
movb %al, -0x71(%rbp)
movb -0x71(%rbp), %al
testb $0x1, %al
jne 0x6864
jmp 0x686b
callq 0x6030
jmp 0x6830
leaq 0x49c76(%rip), %rdi     # 0x504e8
callq 0x3430
testb $0x1, %al
jne 0x687d
jmp 0x68ea
movq -0x70(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x3120
movq -0x68(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x3120
jmp 0x6899
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x6790
jmp 0x68a8
leaq -0x50(%rbp), %rdi
callq 0x34d8
leaq -0x30(%rbp), %rdi
callq 0x34d8
jmp 0x68ea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x68df
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x34d8
leaq -0x30(%rbp), %rdi
callq 0x34d8
jmp 0x68f3
addq $0x80, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x3460
nopl (%rax)
// File: yanlinlin82[P]icpp/icpp.cpp
// Function: precedence(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int precedence(string token)
{
	auto it = operator_precedence.find(token);
	if (it == operator_precedence.end()) {
		err("unknown operator '%s'!\n", token.c_str());
	}
	return it->second;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, %rsi
movq %rsi, -0x20(%rbp)
movq %rsi, -0x8(%rbp)
leaq 0x49b4e(%rip), %rdi     # 0x50468
callq 0x1a850
movq %rax, -0x10(%rbp)
leaq 0x49b3e(%rip), %rdi     # 0x50468
callq 0x19520
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x1a880
testb $0x1, %al
jne 0x6946
jmp 0x6960
movq -0x20(%rbp), %rdi
callq 0x3110
movq %rax, %rsi
leaq 0x30ac1(%rip), %rdi     # 0x3741a
movb $0x0, %al
callq 0x1a780
leaq -0x10(%rbp), %rdi
callq 0x1a8b0
movl 0x20(%rax), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: yanlinlin82[P]icpp/icpp.cpp
// Function: eval_string(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string eval_string(string s)
{
	string r;
	for (size_t i = 1; i + 1 < s.size(); ++i) {
		if (s[i] != '\\') {
			r += s[i];
		} else {
			char c = s[++i];
			switch (c) {
			default: r += c; break;
			case 'r': r += '\r'; break;
			case 'n': r += '\n'; break;
			case 't': r += '\t'; break;
			case '\'': r += '\''; break;
			case '\"': r += '\"'; break;
			}
		}
	}
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x48(%rbp)
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x3380
movq $0x1, -0x20(%rbp)
movq -0x48(%rbp), %rdi
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
callq 0x31c0
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jae 0x6ef5
movq -0x48(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x34c0
movq %rax, -0x58(%rbp)
jmp 0x6dc8
movq -0x58(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5c, %eax
je 0x6e18
movq -0x48(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x34c0
movq %rax, -0x60(%rbp)
jmp 0x6de7
movq -0x40(%rbp), %rdi
movq -0x60(%rbp), %rax
movsbl (%rax), %esi
callq 0x3190
jmp 0x6df9
jmp 0x6ee2
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x34d8
jmp 0x6f12
movq -0x48(%rbp), %rdi
movq -0x20(%rbp), %rsi
incq %rsi
movq %rsi, -0x20(%rbp)
callq 0x34c0
movq %rax, -0x68(%rbp)
jmp 0x6e32
movq -0x68(%rbp), %rax
movb (%rax), %al
movb %al, -0x2d(%rbp)
movsbl -0x2d(%rbp), %eax
movl %eax, -0x6c(%rbp)
subl $0x22, %eax
je 0x6ece
jmp 0x6e4d
movl -0x6c(%rbp), %eax
subl $0x27, %eax
je 0x6ebc
jmp 0x6e57
movl -0x6c(%rbp), %eax
subl $0x6e, %eax
je 0x6e98
jmp 0x6e61
movl -0x6c(%rbp), %eax
subl $0x72, %eax
je 0x6e86
jmp 0x6e6b
movl -0x6c(%rbp), %eax
subl $0x74, %eax
je 0x6eaa
jmp 0x6e75
movq -0x40(%rbp), %rdi
movsbl -0x2d(%rbp), %esi
callq 0x3190
jmp 0x6e84
jmp 0x6ee0
movq -0x40(%rbp), %rdi
movl $0xd, %esi
callq 0x3190
jmp 0x6e96
jmp 0x6ee0
movq -0x40(%rbp), %rdi
movl $0xa, %esi
callq 0x3190
jmp 0x6ea8
jmp 0x6ee0
movq -0x40(%rbp), %rdi
movl $0x9, %esi
callq 0x3190
jmp 0x6eba
jmp 0x6ee0
movq -0x40(%rbp), %rdi
movl $0x27, %esi
callq 0x3190
jmp 0x6ecc
jmp 0x6ee0
movq -0x40(%rbp), %rdi
movl $0x22, %esi
callq 0x3190
jmp 0x6ede
jmp 0x6ee0
jmp 0x6ee2
jmp 0x6ee4
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x6d90
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x6f08
movq -0x40(%rbp), %rdi
callq 0x34d8
movq -0x38(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3460
nopl (%rax,%rax)
// File: yanlinlin82[P]icpp/icpp.cpp
// Function: is_built_in_type()
bool is_built_in_type()
{
	return (token == "char" || token == "short" || token == "int" ||
			token == "long" || token == "longlong" ||
			token == "float" || token == "double" ||
			token == "signed" || token == "unsigned" ||
			token == "size_t");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x495b9(%rip), %rdi     # 0x504e8
leaq 0x3053b(%rip), %rsi     # 0x37471
callq 0x1a9c0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x1(%rbp)
jne 0x7069
leaq 0x49596(%rip), %rdi     # 0x504e8
leaq 0x3051d(%rip), %rsi     # 0x37476
callq 0x1a9c0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x1(%rbp)
jne 0x7069
leaq 0x49573(%rip), %rdi     # 0x504e8
leaq 0x30ea8(%rip), %rsi     # 0x37e24
callq 0x1a9c0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x1(%rbp)
jne 0x7069
leaq 0x49550(%rip), %rdi     # 0x504e8
leaq 0x304e1(%rip), %rsi     # 0x37480
callq 0x1a9c0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x1(%rbp)
jne 0x7069
leaq 0x4952d(%rip), %rdi     # 0x504e8
leaq 0x304ba(%rip), %rsi     # 0x3747c
callq 0x1a9c0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x1(%rbp)
jne 0x7069
leaq 0x4950a(%rip), %rdi     # 0x504e8
leaq 0x304a0(%rip), %rsi     # 0x37485
callq 0x1a9c0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x1(%rbp)
jne 0x7069
leaq 0x494eb(%rip), %rdi     # 0x504e8
leaq 0x30e2c(%rip), %rsi     # 0x37e30
callq 0x1a9c0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x1(%rbp)
jne 0x7069
leaq 0x494cc(%rip), %rdi     # 0x504e8
leaq 0x3046a(%rip), %rsi     # 0x3748d
callq 0x1a9c0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x1(%rbp)
jne 0x7069
leaq 0x494ad(%rip), %rdi     # 0x504e8
leaq 0x30449(%rip), %rsi     # 0x3748b
callq 0x1a9c0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x1(%rbp)
jne 0x7069
leaq 0x4948e(%rip), %rdi     # 0x504e8
leaq 0x30433(%rip), %rsi     # 0x37494
callq 0x1a9c0
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: yanlinlin82[P]icpp/icpp.cpp
// Function: get_type_size(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int get_type_size(string type_name)
{
	if (type_name.substr(type_name.size() - 1) == "*") { // pointer
		return sizeof(int); // we use 'int' as word size
	} else {
		return sizeof(int); // we use 'int' as default type
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, -0x10(%rbp)
callq 0x31c0
movq -0x50(%rbp), %rsi
movq %rax, %rdx
decq %rdx
leaq -0x30(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movq $-0x1, %rcx
callq 0x3280
movq -0x48(%rbp), %rdi
leaq 0x291d3(%rip), %rsi     # 0x37111
callq 0x1a9c0
movb %al, -0x3d(%rbp)
jmp 0xdf48
leaq -0x30(%rbp), %rdi
callq 0x34d8
movb -0x3d(%rbp), %al
testb $0x1, %al
jne 0xdf5a
jmp 0xdf7a
movl $0x4, -0x4(%rbp)
jmp 0xdf81
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x34d8
jmp 0xdf8a
movl $0x4, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x3460
nopw %cs:(%rax,%rax)
// File: yanlinlin82[P]icpp/icpp.cpp
// Function: parse_init_statement()
void parse_init_statement()
{
	log<3>("[DEBUG] > %s:\n", __FUNCTION__);

	if (token == "auto" || token == "const" || token == "static" ||
				token == "extern" || is_built_in_type()) { // start as type
		parse_declare();
	} else {
		parse_expression();
		expect_token(";", "statement");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
leaq 0x25ca1(%rip), %rdi     # 0x37b03
leaq 0x25ca9(%rip), %rsi     # 0x37b12
movb $0x0, %al
callq 0x19760
leaq 0x3e671(%rip), %rdi     # 0x504e8
leaq 0x2562b(%rip), %rsi     # 0x374a9
callq 0x1a9c0
testb $0x1, %al
jne 0x11ed7
leaq 0x3e65a(%rip), %rdi     # 0x504e8
leaq 0x25619(%rip), %rsi     # 0x374ae
callq 0x1a9c0
testb $0x1, %al
jne 0x11ed7
leaq 0x3e643(%rip), %rdi     # 0x504e8
leaq 0x255ef(%rip), %rsi     # 0x3749b
callq 0x1a9c0
testb $0x1, %al
jne 0x11ed7
leaq 0x3e62c(%rip), %rdi     # 0x504e8
leaq 0x255df(%rip), %rsi     # 0x374a2
callq 0x1a9c0
testb $0x1, %al
jne 0x11ed7
callq 0x6f20
testb $0x1, %al
jne 0x11ed7
jmp 0x11ee1
callq 0xfcd0
jmp 0x12056
leaq -0x41(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x3470
movq -0xb0(%rbp), %rdx
leaq 0x25253(%rip), %rsi     # 0x37152
leaq -0x40(%rbp), %rdi
callq 0x199b0
jmp 0x11f0a
leaq -0x20(%rbp), %rdi
leaq -0x40(%rbp), %rsi
xorl %edx, %edx
movl $0x1, %ecx
callq 0xa530
jmp 0x11f20
leaq -0x20(%rbp), %rdi
callq 0x34d8
leaq -0x40(%rbp), %rdi
callq 0x34d8
leaq -0x41(%rbp), %rdi
callq 0x32b0
leaq -0x79(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x3470
movq -0xb8(%rbp), %rdx
leaq 0x251f9(%rip), %rsi     # 0x37152
leaq -0x78(%rbp), %rdi
callq 0x199b0
jmp 0x11f64
leaq -0xa1(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x3470
movq -0xc0(%rbp), %rdx
leaq 0x25b98(%rip), %rsi     # 0x37b1d
leaq -0xa0(%rbp), %rdi
callq 0x199b0
jmp 0x11f93
leaq -0x78(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x6790
jmp 0x11fa5
leaq -0xa0(%rbp), %rdi
callq 0x34d8
leaq -0xa1(%rbp), %rdi
callq 0x32b0
leaq -0x78(%rbp), %rdi
callq 0x34d8
leaq -0x79(%rbp), %rdi
callq 0x32b0
jmp 0x12056
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x11ff7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x34d8
leaq -0x41(%rbp), %rdi
callq 0x32b0
jmp 0x1205f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x1204b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x12036
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x34d8
leaq -0xa1(%rbp), %rdi
callq 0x32b0
leaq -0x78(%rbp), %rdi
callq 0x34d8
leaq -0x79(%rbp), %rdi
callq 0x32b0
jmp 0x1205f
addq $0xc0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x3460
nopl (%rax,%rax)
// File: yanlinlin82[P]icpp/icpp.cpp
// Function: load(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool load(string filename)
{
	ifstream file(filename);
	if (!file.is_open()) {
		err("failed to open file '%s'!\n", filename.c_str());
		return false;
	}
	string line;
	while (getline(file, line)) {
		src.push_back(line);
	}
	file.close();
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x270, %rsp            # imm = 0x270
movq %rdi, %rsi
movq %rsi, -0x260(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x218(%rbp), %rdi
movq %rdi, -0x258(%rbp)
movl $0x8, %edx
callq 0x33f0
movq -0x258(%rbp), %rdi
callq 0x33e0
movb %al, -0x249(%rbp)
jmp 0x14c15
movb -0x249(%rbp), %al
testb $0x1, %al
jne 0x14c6a
jmp 0x14c21
movq -0x260(%rbp), %rdi
callq 0x3110
movq %rax, %rsi
leaq 0x2317a(%rip), %rdi     # 0x37db1
xorl %eax, %eax
callq 0x1a780
jmp 0x14c40
movb $0x0, -0x1(%rbp)
movl $0x1, -0x228(%rbp)
jmp 0x14d1b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
jmp 0x14d35
leaq -0x248(%rbp), %rdi
callq 0x3380
leaq -0x218(%rbp), %rdi
leaq -0x248(%rbp), %rsi
callq 0x3070
movq %rax, -0x268(%rbp)
jmp 0x14c92
movq -0x268(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x3320
movb %al, -0x269(%rbp)
jmp 0x14cb0
movb -0x269(%rbp), %al
testb $0x1, %al
jne 0x14cbc
jmp 0x14cf3
leaq 0x3b7f5(%rip), %rdi     # 0x504b8
leaq -0x248(%rbp), %rsi
callq 0x1b480
jmp 0x14cd1
jmp 0x14c76
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
leaq -0x248(%rbp), %rdi
callq 0x34d8
jmp 0x14d35
leaq -0x218(%rbp), %rdi
callq 0x3090
jmp 0x14d01
movb $0x1, -0x1(%rbp)
movl $0x1, -0x228(%rbp)
leaq -0x248(%rbp), %rdi
callq 0x34d8
leaq -0x218(%rbp), %rdi
callq 0x30b0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x270, %rsp            # imm = 0x270
popq %rbp
retq
leaq -0x218(%rbp), %rdi
callq 0x30b0
movq -0x220(%rbp), %rdi
callq 0x3460
nopl (%rax)
// File: yanlinlin82[P]icpp/icpp.cpp
// Function: get_data_symbol[abi:cxx11](unsigned long)
string get_data_symbol(size_t offset)
{
	auto it = data_symbol_dict.find(offset);
	if (it == data_symbol_dict.end()) {
		err("Unknown data symbol offset '%zd'\n", offset);
		exit(1);
	}
	return it->second;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x3970e(%rip), %rdi     # 0x50620
leaq -0x10(%rbp), %rsi
callq 0x1a1e0
movq %rax, -0x18(%rbp)
leaq 0x396fa(%rip), %rdi     # 0x50620
callq 0x1a240
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x1c870
testb $0x1, %al
jne 0x16f42
jmp 0x16f5e
movq -0x10(%rbp), %rsi
leaq 0x211c0(%rip), %rdi     # 0x3810d
movb $0x0, %al
callq 0x1a780
movl $0x1, %edi
callq 0x32f0
leaq -0x18(%rbp), %rdi
callq 0x1a270
movq -0x30(%rbp), %rdi
movq %rax, %rsi
addq $0x8, %rsi
callq 0x3120
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: yanlinlin82[P]icpp/icpp.cpp
// Function: main
int main(int argc, const char** argv)
{
	bool assembly = false;
	const char* filename = nullptr;
	for (--argc, ++argv; argc > 0 && !filename; --argc, ++argv) {
		if (**argv == '-') {
			if (*(*argv+1) == 'v') { ++verbose; }
			if (*(*argv+1) == 's') { assembly = true; }
		} else {
			filename = *argv;
		}
	}
	if (!filename) {
		log("usage: icpp [-s] [-v] <foo.cpp> ...\n");
		return false;
	}
	on_err = print_current_and_exit;
	if (load(filename)) parse();
	return assembly ? show() : run(argc, argv);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movq $0x0, -0x20(%rbp)
movl -0x8(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x8(%rbp)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x8(%rbp)
movb %al, -0x55(%rbp)
jle 0x18acf
cmpq $0x0, -0x20(%rbp)
setne %al
xorb $-0x1, %al
movb %al, -0x55(%rbp)
movb -0x55(%rbp), %al
testb $0x1, %al
jne 0x18ad8
jmp 0x18b43
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x18b1c
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl 0x1(%rax), %eax
cmpl $0x76, %eax
jne 0x18b06
movl 0x37d2b(%rip), %eax     # 0x50828
addl $0x1, %eax
movl %eax, 0x37d22(%rip)     # 0x50828
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl 0x1(%rax), %eax
cmpl $0x73, %eax
jne 0x18b1a
movb $0x1, -0x11(%rbp)
jmp 0x18b27
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x18b29
movl -0x8(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x8(%rbp)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
jmp 0x18ab7
cmpq $0x0, -0x20(%rbp)
jne 0x18b64
leaq 0x1f8b9(%rip), %rdi     # 0x3840a
movb $0x0, %al
callq 0x19420
movl $0x0, -0x4(%rbp)
jmp 0x18c1d
leaq -0x1434b(%rip), %rax    # 0x4820
movq %rax, 0x37cc6(%rip)     # 0x50838
movq -0x20(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x3470
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x199b0
jmp 0x18b9a
leaq -0x40(%rbp), %rdi
callq 0x14bd0
movb %al, -0x69(%rbp)
jmp 0x18ba8
leaq -0x40(%rbp), %rdi
callq 0x34d8
leaq -0x41(%rbp), %rdi
callq 0x32b0
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0x18bc3
jmp 0x18bf8
callq 0x15bc0
jmp 0x18bf8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x18bed
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x34d8
leaq -0x41(%rbp), %rdi
callq 0x32b0
jmp 0x18c26
testb $0x1, -0x11(%rbp)
je 0x18c08
callq 0x164a0
movl %eax, -0x70(%rbp)
jmp 0x18c17
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x17740
movl %eax, -0x70(%rbp)
movl -0x70(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x3460
nop
// File: yanlinlin82[P]icpp/icpp.cpp
// Function: instruction_has_parameter(int)
inline bool instruction_has_parameter(int code)
{
	return (code == ADJ || code == MOV ||
			code == LEA || code == GET || code == PUT ||
			code == LLEA || code == LGET || code == LPUT ||
			code == ENTER || code == CALL || code == RET ||
			code == JMP || code == JZ || code == JNZ);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movb $0x1, %al
cmpl $0x3, -0x4(%rbp)
movb %al, -0x5(%rbp)
je 0x1a1d8
movb $0x1, %al
cmpl $0x4, -0x4(%rbp)
movb %al, -0x5(%rbp)
je 0x1a1d8
movb $0x1, %al
cmpl $0x5, -0x4(%rbp)
movb %al, -0x5(%rbp)
je 0x1a1d8
movb $0x1, %al
cmpl $0x6, -0x4(%rbp)
movb %al, -0x5(%rbp)
je 0x1a1d8
movb $0x1, %al
cmpl $0x7, -0x4(%rbp)
movb %al, -0x5(%rbp)
je 0x1a1d8
movb $0x1, %al
cmpl $0x8, -0x4(%rbp)
movb %al, -0x5(%rbp)
je 0x1a1d8
movb $0x1, %al
cmpl $0x9, -0x4(%rbp)
movb %al, -0x5(%rbp)
je 0x1a1d8
movb $0x1, %al
cmpl $0xa, -0x4(%rbp)
movb %al, -0x5(%rbp)
je 0x1a1d8
movb $0x1, %al
cmpl $0x23, -0x4(%rbp)
movb %al, -0x5(%rbp)
je 0x1a1d8
movb $0x1, %al
cmpl $0x25, -0x4(%rbp)
movb %al, -0x5(%rbp)
je 0x1a1d8
movb $0x1, %al
cmpl $0x26, -0x4(%rbp)
movb %al, -0x5(%rbp)
je 0x1a1d8
movb $0x1, %al
cmpl $0x27, -0x4(%rbp)
movb %al, -0x5(%rbp)
je 0x1a1d8
movb $0x1, %al
cmpl $0x28, -0x4(%rbp)
movb %al, -0x5(%rbp)
je 0x1a1d8
cmpl $0x29, -0x4(%rbp)
sete %al
movb %al, -0x5(%rbp)
movb -0x5(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nop
// File: probonopd[P]decodeir/DecodeIR.cpp
// Function: Signal::setPreempt(int)
void Signal::setPreempt(int prValue)
// GD 2009.  This sets a preempt value when there is a valid decode which
// is not reported at the time, so we could not use NewPreemptValue as
// that only takes effect when protocol is reported.
{
	if (	preemptValue < prValue	
		||	preemptValue == prValue	
			&&	nFrameL > preemptLength )	
	{										
		preemptValue = prValue;
		preemptLength = nFrameL;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl 0x54(%rax), %eax
cmpl -0xc(%rbp), %eax
jl 0x2843
movq -0x18(%rbp), %rax
movl 0x54(%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x2853
movq -0x18(%rbp), %rcx
movl 0x48(%rcx), %eax
cmpl 0x50(%rcx), %eax
jle 0x2853
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0x54(%rax)
movl 0x48(%rax), %ecx
movl %ecx, 0x50(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: probonopd[P]decodeir/DecodeIR.cpp
// Function: Signal::tryGXB()
void Signal::tryGXB()
// GXB  {38.3k,520}<1,-3|3,-1>(1,-1,D:4,F:8,P:1,1,^???)+
// P is odd parity for F
{
	if (nFrameL != 15)
		return;
	if (   sortBurst.min2 != sortBurst.mid2
		|| sortBurst.min1 >= sortOn.max1
		|| sortBurst.min1 != pFrame[0] + pFrame[1]
		|| sortBurst.min1*1.5 > sortBurst.mid2
		|| sortBurst.mid2*1.25 < sortBurst.max1 )
	{
		return;
	}
	nMaxShort = sortBurst.mid2*.5;
	cleanup();
	pBit+=2;
	decodeX( 13 );
	makeMsb();
	*pDevice = getMsb(0,4);
	*pOBC = getMsb(4,8);
	if ( parity( getMsb(4,9) ) )
	{
		strcpy(pProtocol, "GXB");
	}
	else
	{
		sprintf(pProtocol, "GXB-%03X.%d", getMsb(0,12), getMsb(12,1));
	}


}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $0xf, 0x48(%rax)
je 0x128ff
jmp 0x12acb
movq -0x10(%rbp), %rax
movss 0x1cc(%rax), %xmm0
ucomiss 0x1d8(%rax), %xmm0
jne 0x129b7
jp 0x129b7
movq -0x10(%rbp), %rax
movss 0x1d0(%rax), %xmm0
ucomiss 0x184(%rax), %xmm0
jae 0x129b7
movq -0x10(%rbp), %rax
movss 0x1d0(%rax), %xmm0
movq 0x38(%rax), %rcx
movss (%rcx), %xmm1
movq 0x38(%rax), %rax
addss 0x4(%rax), %xmm1
ucomiss %xmm1, %xmm0
jne 0x129b7
jp 0x129b7
movq -0x10(%rbp), %rax
movss 0x1d0(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x791d(%rip), %xmm1     # 0x1a290
mulsd %xmm1, %xmm0
movss 0x1d8(%rax), %xmm1
cvtss2sd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
ja 0x129b7
movq -0x10(%rbp), %rax
movss 0x1d8(%rax), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x7ae7(%rip), %xmm0     # 0x1a488
mulsd %xmm0, %xmm1
movss 0x1dc(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jbe 0x129bc
jmp 0x12acb
movq -0x10(%rbp), %rdi
movss 0x1d8(%rdi), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x77ec(%rip), %xmm1     # 0x1a1c0
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xe8(%rdi)
callq 0x16180
movq -0x10(%rbp), %rdi
movq 0xc8(%rdi), %rax
addq $0x8, %rax
movq %rax, 0xc8(%rdi)
movl $0xd, %esi
callq 0x161d0
movq -0x10(%rbp), %rdi
callq 0x16110
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x15f50
movq -0x10(%rbp), %rdi
movl %eax, %ecx
movq 0x160(%rdi), %rax
movl %ecx, (%rax)
movl $0x4, %esi
movl $0x8, %edx
callq 0x15f50
movq -0x10(%rbp), %rdi
movl %eax, %ecx
movq 0x170(%rdi), %rax
movl %ecx, (%rax)
movl $0x4, %esi
movl $0x9, %edx
callq 0x15f50
movl %eax, %edi
callq 0x18a30
cmpl $0x0, %eax
je 0x12a83
movq -0x10(%rbp), %rax
movq 0x148(%rax), %rdi
leaq 0x864a(%rip), %rsi      # 0x1b0c6
callq 0x2120
jmp 0x12acb
movq -0x10(%rbp), %rdi
movq 0x148(%rdi), %rax
movq %rax, -0x20(%rbp)
xorl %esi, %esi
movl $0xc, %edx
callq 0x15f50
movq -0x10(%rbp), %rdi
movl %eax, -0x14(%rbp)
movl $0xc, %esi
movl $0x1, %edx
callq 0x15f50
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %edx
movl %eax, %ecx
leaq 0x8606(%rip), %rsi      # 0x1b0ca
movb $0x0, %al
callq 0x2060
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: probonopd[P]decodeir/DecodeIR.cpp
// Function: Signal::tryAirAsync()
void Signal::tryAirAsync()
{
	if (!framed(22*8*105))
		return;
	if ( nFrameL < 5 )
		return;
	if (preemptValue >= prAsync)
		return;

	// Longest > 22 bits is treated as a decode boundary
	// Longest < 2 (shortened) bits makes false decode too likely
	if (sortOff.max1 > 22*8*105 || sortOff.max1 < 2*7*105)
		return;
    if (sortOn.max1 > 9*9*105)
        return;

	int result = decodeAsync(pFrame, 0, 0, 7*105, 9*105, 11, 11);
	if (result)
	{
		sprintf(pProtocol, "AirAsync%d-", result);
		for (int nn=0; nn<result; ++nn)
		{
			sprintf(pProtocol+strlen(pProtocol),
				   ( nn ? ".%02X" : "%02X" )
				, cBits[nn] );
		}
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movss 0x7238(%rip), %xmm0     # 0x1a154
callq 0x18840
cmpl $0x0, %eax
jne 0x12f2b
jmp 0x1305d
movq -0x18(%rbp), %rax
cmpl $0x5, 0x48(%rax)
jge 0x12f3a
jmp 0x1305d
movq -0x18(%rbp), %rax
cmpl $0x1, 0x54(%rax)
jl 0x12f49
jmp 0x1305d
movq -0x18(%rbp), %rax
movss 0x190(%rax), %xmm0
movss 0x71f7(%rip), %xmm1     # 0x1a154
ucomiss %xmm1, %xmm0
ja 0x12f77
movq -0x18(%rbp), %rax
movss 0x71f2(%rip), %xmm0     # 0x1a160
ucomiss 0x190(%rax), %xmm0
jbe 0x12f7c
jmp 0x1305d
movq -0x18(%rbp), %rax
movss 0x184(%rax), %xmm0
movss 0x71d4(%rip), %xmm1     # 0x1a164
ucomiss %xmm1, %xmm0
jbe 0x12f9a
jmp 0x1305d
movq -0x18(%rbp), %rdi
movq 0x38(%rdi), %rsi
xorl %ecx, %ecx
movsd 0x7764(%rip), %xmm0     # 0x1a710
movsd 0x7764(%rip), %xmm1     # 0x1a718
movl $0xb, %r9d
movl %ecx, %edx
movl %r9d, %r8d
callq 0x16770
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x1305d
movq -0x18(%rbp), %rax
movq 0x148(%rax), %rdi
movl -0xc(%rbp), %edx
leaq 0x811a(%rip), %rsi      # 0x1b100
movb $0x0, %al
callq 0x2060
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x1305b
movq -0x18(%rbp), %rax
movq 0x148(%rax), %rcx
movq %rcx, -0x20(%rbp)
movq 0x148(%rax), %rdi
callq 0x20a0
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movq -0x18(%rbp), %rax
addq %rcx, %rdi
movl -0x10(%rbp), %edx
leaq 0x8008(%rip), %rsi      # 0x1b037
leaq 0x80c4(%rip), %rcx      # 0x1b0fa
cmpl $0x0, %edx
cmovneq %rcx, %rsi
movslq -0x10(%rbp), %rcx
movzbl 0xa0(%rax,%rcx), %edx
movb $0x0, %al
callq 0x2060
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x12ff4
jmp 0x1305d
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: probonopd[P]decodeir/DecodeIR.cpp
// Function: Signal::trySunfire()
void Signal::trySunfire()
{
	if (nFrameL != 25)
		return;
	if ( pFrame[1] <= sortBurst.max2 )
		return;
	if ( ! framed(sortBurst.max1) )
		return;
	cleanup();
   	pBit = pFrame+2;
	nMaxShort = sortBurst.min1;
	decodeX(24);
	if (getLsb(0,12) + getLsb(12,12) != 0xFFF )
		return;
	makeMsb();
	strcpy(pProtocol, "Sunfire");
	*pDevice = getMsb(0,4);
	*pOBC = getMsb(4,8);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $0x19, 0x48(%rax)
je 0x1338f
jmp 0x1348f
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rcx
movss 0x4(%rcx), %xmm1
movss 0x1e0(%rax), %xmm0
ucomiss %xmm1, %xmm0
jb 0x133ae
jmp 0x1348f
movq -0x10(%rbp), %rdi
movss 0x1dc(%rdi), %xmm0
callq 0x18840
cmpl $0x0, %eax
jne 0x133c9
jmp 0x1348f
movq -0x10(%rbp), %rdi
callq 0x16180
movq -0x10(%rbp), %rdi
movq 0x38(%rdi), %rax
addq $0x8, %rax
movq %rax, 0xc8(%rdi)
movss 0x1d0(%rdi), %xmm0
movss %xmm0, 0xe8(%rdi)
movl $0x18, %esi
callq 0x161d0
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0xc, %edx
callq 0x16030
movq -0x10(%rbp), %rdi
movl %eax, -0x14(%rbp)
movl $0xc, %edx
movl %edx, %esi
callq 0x16030
movl %eax, %ecx
movl -0x14(%rbp), %eax
addl %ecx, %eax
cmpl $0xfff, %eax            # imm = 0xFFF
je 0x13432
jmp 0x1348f
movq -0x10(%rbp), %rdi
callq 0x16110
movq -0x10(%rbp), %rax
movq 0x148(%rax), %rdi
leaq 0x7b9c(%rip), %rsi      # 0x1afe9
callq 0x2120
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x15f50
movq -0x10(%rbp), %rdi
movl %eax, %ecx
movq 0x160(%rdi), %rax
movl %ecx, (%rax)
movl $0x4, %esi
movl $0x8, %edx
callq 0x15f50
movl %eax, %ecx
movq -0x10(%rbp), %rax
movq 0x170(%rax), %rax
movl %ecx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)