LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/MingYueRuYa[P]cprimeprimecode/memory_manager.cpp
// Function: global_new_delete::test_global_new_delete()
void test_global_new_delete()
{
	Foo *foo = new Foo();
	delete foo;
	foo = NULL;

	Foo *arrayfoo = new Foo[10];
	delete []arrayfoo;
	arrayfoo = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl $0x1, %edi
callq 0x2180
movq %rax, %rbx
movq %rax, %rdi
callq 0x425a
movq %rbx, %rdi
callq 0x42b8
movl $0x1, %esi
movq %rbx, %rdi
callq 0x2190
movl $0x12, %edi
callq 0x2030
movq %rax, %rbx
movq $0xa, (%rax)
leaq 0x8(%rax), %r14
xorl %r15d, %r15d
movq %r14, %rdi
callq 0x425a
decq %r15
incq %r14
cmpq $-0xa, %r15
jne 0x372f
movq (%rbx), %r14
testq %r14, %r14
je 0x3763
movq %rbx, %r15
addq $0x7, %r15
movq %r14, %r12
leaq (%r15,%r12), %rdi
callq 0x42b8
decq %r12
jne 0x3755
addq $0x8, %r14
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2270
movq %rax, %r14
movl $0x1, %esi
movq %rbx, %rdi
callq 0x2190
jmp 0x37b9
movq %rax, %r14
testq %r15, %r15
je 0x37ac
negq %r15
movq %rbx, %r12
addq $0x7, %r12
leaq (%r12,%r15), %rdi
callq 0x42b8
decq %r15
jne 0x379e
movl $0x12, %esi
movq %rbx, %rdi
callq 0x2270
movq %r14, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O1/MingYueRuYa[P]cprimeprimecode/memory_manager.cpp
// Function: ext_pool_allocator::test_pool_alloc()
void test_pool_alloc()
	{
		std::cout << sizeof(__gnu_cxx::__pool_alloc<int>) << std::endl;
		cookie_test(__gnu_cxx::__pool_alloc<double>(), 1);

		std::cout << sizeof(std::allocator<int>) << std::endl;
		cookie_test(std::allocator<double>(), 1);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq 0x4635(%rip), %rbx      # 0x7fd0
movl $0x1, %esi
movq %rbx, %rdi
callq 0x20c0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20d0
leaq -0x12(%rbp), %rdi
movl $0x1, %esi
callq 0x444e
movl $0x1, %esi
movq %rbx, %rdi
callq 0x20c0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20d0
leaq -0x11(%rbp), %rdi
movl $0x1, %esi
callq 0x459a
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/MingYueRuYa[P]cprimeprimecode/memory_manager.cpp
// Function: void ext_pool_allocator::cookie_test<__gnu_cxx::__pool_alloc<double>>(__gnu_cxx::__pool_alloc<double>, unsigned long)
void cookie_test(Alloc alloc, size_t n)
	{
		typename Alloc::value_type *p1, *p2, *p3;

		p1 = alloc.allocate(n);
		p2 = alloc.allocate(n);
		p3 = alloc.allocate(n);

		std::cout << "p1=" << p1 << "\t" << "p2=" << p2 << "\t" << "p3=" << p3 << "\t" << std::endl;

		alloc.deallocate(p1, sizeof(typename Alloc::value_type));
		alloc.deallocate(p2, sizeof(typename Alloc::value_type));
		alloc.deallocate(p3, sizeof(typename Alloc::value_type));
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
xorl %edx, %edx
callq 0x47d8
movq %rax, %r14
movq %rax, -0x30(%rbp)
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x47d8
movq %rax, %r12
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x47d8
movq %rax, %r15
movq 0x3b39(%rip), %r13      # 0x7fd0
leaq 0x1037(%rip), %rsi      # 0x54d5
movl $0x3, %edx
movq %r13, %rdi
callq 0x21a0
movq %r13, %rdi
movq %r14, %rsi
callq 0x2100
movq %rax, %r14
leaq 0x1019(%rip), %r13      # 0x54d9
movl $0x1, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x21a0
leaq 0x1004(%rip), %rsi      # 0x54db
movl $0x3, %edx
movq %r14, %rdi
callq 0x21a0
movq %r14, %rdi
movq %r12, %rsi
callq 0x2100
movq %rax, %r14
movl $0x1, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x21a0
leaq 0xfd6(%rip), %rsi       # 0x54df
movl $0x3, %edx
movq %r14, %rdi
callq 0x21a0
movq %r14, %rdi
movq %r15, %rsi
callq 0x2100
movq %rax, %r14
movl $0x1, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x21a0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20d0
movl $0x8, %edx
movq %rbx, %rdi
movq -0x30(%rbp), %rsi
callq 0x492e
movl $0x8, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x492e
movl $0x8, %edx
movq %rbx, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x492e
// File: /workspace/github_cpp_makefile_star2_O1/MingYueRuYa[P]cprimeprimecode/memory_manager.cpp
// Function: custom_allocator::allocator::alloc(unsigned long)
void *alloc(const size_t size)
	{
		object *p = NULL;
		if (NULL == freeHead) {
			p = freeHead = (object *)malloc(chunksize*size);
			for (int i=0; i<chunksize-1; ++i) {
				p->next = (object *)((char *)p+size);
				p = p->next;
			}
			p->next = NULL; //last
		}
		p = freeHead;
		freeHead = freeHead->next;
		return p;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
jne 0x4728
movq %rsi, %r14
movslq (%rbx), %r15
movq %r15, %rdi
imulq %rsi, %rdi
callq 0x21e0
movq %rax, 0x8(%rbx)
cmpq $0x2, %r15
jl 0x471e
decl %r15d
leaq (%rax,%r14), %rcx
movq %rcx, (%rax)
movq %rcx, %rax
decl %r15d
jne 0x470d
jmp 0x4721
movq %rax, %rcx
movq $0x0, (%rcx)
movq 0x8(%rbx), %rax
movq (%rax), %rcx
movq %rcx, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Azer0s[P]littl/bin/../src/tree/base/native.hpp
// Function: littl::Native::Native(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Native(const std::string& name){
                std::regex str("^.(.*)..$");
                const char* c = name.c_str();
                std::cmatch cm;
                std::regex_match(c,cm,str,std::regex_constants::match_default);
                this->name = cm[1];
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
leaq 0x24753(%rip), %rax     # 0x2c540
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
leaq 0x18(%rdi), %r12
movq %r12, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
leaq 0x19122(%rip), %rsi     # 0x20f31
leaq -0x80(%rbp), %rdi
movl $0x10, %edx
callq 0x8f2e
movq (%r14), %r14
xorps %xmm0, %xmm0
leaq -0x40(%rbp), %r15
movaps %xmm0, 0x10(%r15)
movaps %xmm0, (%r15)
movq %r14, %rdi
callq 0x6160
leaq (%rax,%r14), %rsi
leaq -0x80(%rbp), %rcx
movq %r14, %rdi
movq %r15, %rdx
xorl %r8d, %r8d
callq 0x1499a
movq -0x40(%rbp), %rcx
movq -0x38(%rbp), %rax
cmpq %rax, %rcx
je 0x7e80
movq %rax, %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
movabsq $-0x5555555555555555, %rsi # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdx, %rsi
addq $-0x5, %rsi
cmpq $-0x2, %rsi
setb %dl
jmp 0x7e82
xorl %edx, %edx
addq $0x18, %rcx
addq $-0x48, %rax
testb %dl, %dl
cmovneq %rcx, %rax
cmpb $0x1, 0x10(%rax)
jne 0x7eb0
movq (%rax), %rsi
movq 0x8(%rax), %rdx
leaq -0x50(%rbp), %rax
movq %rax, -0x10(%rax)
leaq -0x60(%rbp), %rdi
callq 0xde10
jmp 0x7ec3
leaq -0x50(%rbp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x60(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x63b0
movq (%r14), %rdi
leaq -0x50(%rbp), %rax
cmpq %rax, %rdi
je 0x7eea
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x62e0
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x7eff
movq -0x30(%rbp), %rsi
subq %rdi, %rsi
callq 0x62e0
leaq -0x80(%rbp), %rdi
callq 0x8f9a
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7f17
movq %rax, %r14
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x7f2f
movq -0x30(%rbp), %rsi
subq %rdi, %rsi
callq 0x62e0
leaq -0x80(%rbp), %rdi
callq 0x8f9a
jmp 0x7f3d
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x7f51
movq (%r12), %rsi
incq %rsi
callq 0x62e0
movq %r14, %rdi
callq 0x6540
nop
// File: /workspace/github_cpp_makefile_star2_O1/Azer0s[P]littl/bin/../src/tree/program.hpp
// Function: littl::Program::toCode[abi:cxx11]() const
virtual std::string toCode() const{
                std::string program;
                for(SyntaxTree* node : tree){
                    program += node->toCode();
                }
                return program;
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, -0x30(%rbp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %r12
movq 0x10(%rsi), %r15
cmpq %r15, %r12
je 0x866b
leaq -0x40(%rbp), %r13
leaq -0x50(%rbp), %r14
movq (%r12), %rsi
movq (%rsi), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq %rbx, %rdi
callq 0x60e0
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x8662
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x62e0
addq $0x8, %r12
cmpq %r15, %r12
jne 0x8630
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x869a
movq %rax, %r14
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x869a
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x62e0
movq (%rbx), %rdi
cmpq -0x30(%rbp), %rdi
je 0x86b2
movq -0x30(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x62e0
movq %r14, %rdi
callq 0x6540
// File: /workspace/github_cpp_makefile_star2_O1/Azer0s[P]littl/bin/../src/tree/blocks/ifElseIfElse.hpp
// Function: littl::IfElseIfElse::~IfElseIfElse()
virtual ~IfElseIfElse(){
                delete condition;
                delete block;
                delete elseIfBlock;
                delete elseBlock;
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x143a6(%rip), %rax     # 0x2c9e0
movq %rax, (%rdi)
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x1864c
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x1865b
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x1866a
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x1867f
movq (%rdi), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmpq *0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Azer0s[P]littl/bin/../src/tree/blocks/countedFor.hpp
// Function: littl::CountedFor::~CountedFor()
virtual ~CountedFor(){
                delete var;
                delete condition;
                delete op;
                delete block;
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x13904(%rip), %rax     # 0x2ca60
movq %rax, (%rdi)
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x1916e
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x1917d
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x1918c
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x191a1
movq (%rdi), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmpq *0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Azer0s[P]littl/src/main.cpp
// Function: main
int main(){
    int result = yyparse();

    if(result == 0){
        std::cout << "Input is valid!" << std::endl;
    }else{
        std::cout << "Input invalid!" << std::endl;
    }

    std::ofstream outputfile;
    outputfile.open ("out.js");

    std::string code = "//littl compiler output\n//Copyright 2018-present Ariel Simulevski\n";
    code +=  root->toCode();
    outputfile << code;
    outputfile.close();

    std::cout << "Lines in source file: " << yylineno << std::endl;

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x248, %rsp            # imm = 0x248
callq 0x69cc
movl %eax, %ebx
movq 0xdf8e(%rip), %rdi      # 0x2cfb8
testl %eax, %eax
je 0x1f03c
leaq 0x38c3(%rip), %rsi      # 0x228f8
movl $0xe, %edx
jmp 0x1f048
leaq 0x38a5(%rip), %rsi      # 0x228e8
movl $0xf, %edx
callq 0x6360
movq 0xdf64(%rip), %r14      # 0x2cfb8
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x62c0
movsbl %al, %esi
movq %r14, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x6210
leaq -0x258(%rbp), %r14
movq %r14, %rdi
callq 0x6500
leaq 0x3876(%rip), %rsi      # 0x22907
movq %r14, %rdi
movl $0x10, %edx
callq 0x6070
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x3861(%rip), %rsi      # 0x2290e
leaq 0x389c(%rip), %rdx      # 0x22950
leaq -0x38(%rbp), %rdi
callq 0xde10
leaq 0xe66c(%rip), %rax      # 0x2d730
movq (%rax), %rsi
movq (%rsi), %rax
leaq -0x58(%rbp), %rdi
callq *0x10(%rax)
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x60e0
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1f0fb
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x62e0
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
leaq -0x258(%rbp), %rdi
callq 0x6360
leaq -0x258(%rbp), %rdi
callq 0x6420
movq 0xde96(%rip), %rdi      # 0x2cfb8
leaq 0x3828(%rip), %rsi      # 0x22951
movl $0x16, %edx
callq 0x6360
leaq 0xe5de(%rip), %rax      # 0x2d718
movl (%rax), %esi
movq 0xde75(%rip), %rdi      # 0x2cfb8
callq 0x6520
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x62c0
movsbl %al, %esi
movq %r14, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x6210
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x1f187
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x62e0
movq 0xde02(%rip), %rax      # 0x2cf90
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq -0x250(%rbp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, -0x258(%rbp,%rcx)
callq 0x6280
leaq -0x160(%rbp), %rdi
callq 0x6100
movl %ebx, %eax
addq $0x248, %rsp            # imm = 0x248
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1f1f7
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x62e0
jmp 0x1f1f7
jmp 0x1f1f4
jmp 0x1f1ef
movq %rax, %rbx
jmp 0x1f20c
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x1f20c
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x62e0
leaq -0x258(%rbp), %rdi
callq 0x6470
movq %rbx, %rdi
callq 0x6540
// File: /workspace/github_cpp_makefile_star2_O1/swxlion[P]swxJson/tests/swxJsonParseTest.cpp
// Function: main
int main(int argc, const char** argv)
{
	if (argc < 3)
	{
		std::cout<<"Usage: "<<argv[0]<<" <json_filename> <fetch_path>"<<std::endl;
		return 0;
	}

	parseTest(argv[1], argv[2]);
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
cmpl $0x2, %edi
jg 0xbd03
movq 0x1330d(%rip), %rbx     # 0x1efd8
leaq 0xc38b(%rip), %rsi      # 0x1805d
movl $0x7, %edx
movq %rbx, %rdi
callq 0xb300
movq (%r14), %r14
testq %r14, %r14
je 0xbd12
movq %r14, %rdi
callq 0xb100
movq 0x132e2(%rip), %rdi     # 0x1efd8
movq %r14, %rsi
movq %rax, %rdx
callq 0xb300
jmp 0xbd29
movq 0x8(%r14), %rdi
movq 0x10(%r14), %rsi
callq 0xb65c
jmp 0xbd64
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0xb400
leaq 0xc335(%rip), %rsi      # 0x18065
movl $0x1d, %edx
movq %rbx, %rdi
callq 0xb300
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0xb280
movsbl %al, %esi
movq %rbx, %rdi
callq 0xb030
movq %rax, %rdi
callq 0xb1b0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/m1c0l[P]http-client-server/web-client.cpp
// Function: getServerAddr(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
struct sockaddr_in getServerAddr(string hostname, string port) {
	struct addrinfo hints;
	struct addrinfo* res;

	// prepare hints
	memset(&hints, 0, sizeof(hints));
	hints.ai_family = AF_INET; // IPv4
	hints.ai_socktype = SOCK_STREAM; // TCP

	// get address
	int status = 0;
	if ((status = getaddrinfo(hostname.c_str(), port.c_str(), &hints, &res)) != 0) {
		cerr << "getaddrinfo: " << gai_strerror(status) << '\n';
		exit(2);
	}

	struct addrinfo* p = res;
	// convert address to IPv4 address
	struct sockaddr_in* ipv4;
	char ipstr[INET_ADDRSTRLEN] = {'\0'};
	if (p != 0) {
		ipv4 = (struct sockaddr_in*)p->ai_addr;

		// convert the IP to a string
		inet_ntop(p->ai_family, &(ipv4->sin_addr), ipstr, sizeof(ipstr));
	}
	else {
		cerr << "IP address not found for " << hostname << endl;
		exit(3);
	}

	struct sockaddr_in serverAddr;
	serverAddr.sin_family = AF_INET;
	serverAddr.sin_port = htons(stoi(port));     // short, network byte order
	serverAddr.sin_addr.s_addr = inet_addr(ipstr);
	memset(serverAddr.sin_zero, '\0', sizeof(serverAddr.sin_zero));
	return serverAddr;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, 0x20(%rdx)
movabsq $0x100000002, %rax      # imm = 0x100000002
movq %rax, 0x4(%rdx)
movq (%rdi), %rdi
movq (%rsi), %rsi
leaq 0x8(%rsp), %rcx
callq 0x53d0
testl %eax, %eax
jne 0x7a9e
movq 0x8(%rsp), %rax
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
testq %rax, %rax
je 0x7adf
movq 0x18(%rax), %rsi
movl 0x4(%rax), %edi
addq $0x4, %rsi
leaq 0x10(%rsp), %rdx
movl $0x10, %ecx
callq 0x5360
movq (%rbx), %r15
callq 0x5040
movq %rax, %rbx
movl (%rax), %ebp
movl $0x0, (%rax)
leaq 0x28(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
movl $0xa, %edx
callq 0x5450
cmpq %r15, (%r12)
je 0x7b0f
movq %rax, %r14
movslq %r14d, %rax
cmpq %r14, %rax
jne 0x7b1b
movl (%rbx), %eax
cmpl $0x22, %eax
je 0x7b1b
testl %eax, %eax
jne 0x7a71
movl %ebp, (%rbx)
rolw $0x8, %r14w
leaq 0x10(%rsp), %rdi
callq 0x5310
shlq $0x20, %rax
shll $0x10, %r14d
addq %r14, %rax
addq $0x2, %rax
xorl %edx, %edx
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %ebp
movq 0xa549(%rip), %rdi      # 0x11ff0
leaq 0x45e5(%rip), %rsi      # 0xc093
callq 0x52f0
movq %rax, %rbx
movl %ebp, %edi
callq 0x5430
movq %rbx, %rdi
movq %rax, %rsi
callq 0x52f0
movq %rax, %rdi
movl $0xa, %esi
callq 0x53a0
movl $0x2, %edi
callq 0x53b0
movq 0xa50a(%rip), %rdi      # 0x11ff0
leaq 0x45b4(%rip), %rsi      # 0xc0a1
callq 0x52f0
movq %rax, %rdi
movq %r14, %rsi
callq 0x5290
movq %rax, %rdi
callq 0x5150
movl $0x3, %edi
callq 0x53b0
leaq 0x4609(%rip), %rdi      # 0xc11f
callq 0x51c0
leaq 0x45fd(%rip), %rdi      # 0xc11f
callq 0x5470
cmpl $0x0, (%rbx)
jne 0x7b2e
movl %ebp, (%rbx)
movq %rax, %rdi
callq 0x5540
// File: /workspace/github_cpp_makefile_star2_O1/m1c0l[P]http-client-server/web-client.cpp
// Function: int waitFor<int>(std::future<int>&)
int waitFor(future<T>& promise) {
	chrono::seconds timer(timeout);
	// abort if request times out
	if (promise.wait_for(timer) == future_status::timeout) {
		cerr << "Connection timed out." << '\n';
		return -1;
	}
	return 0;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
leaq 0x8(%rsp), %rsi
movq $0xa, (%rsi)
callq 0xa584
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x1, %ecx
jne 0x9270
movq 0x8dae(%rip), %rbx      # 0x11ff0
leaq 0x2eef(%rip), %rsi      # 0xc138
movl $0x15, %edx
movq %rbx, %rdi
callq 0x5390
leaq 0x7(%rsp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x5390
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/rom1v[P]metahanoi/metahanoi.cpp
// Function: main
int main() {
    using disks = Disks<0, 0, 0, 0, 0>;
    using solver = Solver<disks::count, disks::packed, 2>;
    for (state s : solver::list) {
        print_state(std::cout, disks::count, s) << std::endl;
    }
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0x2e48(%rip), %r15      # 0x4058
movq 0x2dc1(%rip), %rbx      # 0x3fd8
movq (%r15), %rdx
movq %rbx, %rdi
movl $0x5, %esi
callq 0x11bc
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x1070
movsbl %al, %esi
movq %r14, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1050
movq 0x8(%r15), %r15
testq %r15, %r15
jne 0x1217
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/kazel1990[P]Inception-v4/generator.cpp
// Function: print(char const*)
void print(const char * str)
{
    bool add_indent = false;
    for(int i=0;str[i];i++)
    {
        if(str[i] == '{') add_indent = true;
        if(str[i] == '}') indent--;
    }
    for(int i=0;i<indent;i++) printf("  ");
    if(add_indent) indent++;
    puts(str);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x10c64(%rip), %eax     # 0x120f0
xorl %ebp, %ebp
movq %rdi, %rcx
movzbl (%rcx), %edx
cmpl $0x7b, %edx
je 0x149f
testl %edx, %edx
jne 0x14a2
jmp 0x14b4
movb $0x1, %bpl
cmpb $0x7d, %dl
jne 0x14af
decl %eax
movl %eax, 0x10c41(%rip)     # 0x120f0
incq %rcx
jmp 0x1491
movl 0x10c36(%rip), %eax     # 0x120f0
testl %eax, %eax
jle 0x14e0
leaq 0xcb3f(%rip), %r14      # 0xe004
xorl %r15d, %r15d
movq %r14, %rdi
xorl %eax, %eax
callq 0x1030
incl %r15d
movl 0x10c15(%rip), %eax     # 0x120f0
cmpl %eax, %r15d
jl 0x14c8
testb $0x1, %bpl
je 0x14ee
incl %eax
movl %eax, 0x10c02(%rip)     # 0x120f0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1130
// File: /workspace/github_cpp_makefile_star2_O1/kazel1990[P]Inception-v4/generator.cpp
// Function: in_out(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<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 in_out(std::vector<std::string> bot, std::string top)
{
    for(std::string & str : bot)
    {
        sprintf(buf,"bottom: \"%s\"",str.c_str());
        print(buf);
    }
    sprintf(buf,"top: \"%s\"",top.c_str());
    print(buf);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq (%rdi), %r12
movq 0x8(%rdi), %r13
cmpq %r13, %r12
je 0x1548
leaq 0x10be1(%rip), %r14     # 0x12100
leaq 0xcae1(%rip), %r15      # 0xe007
movq (%r12), %rdx
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x1040
movq %r14, %rdi
callq 0x147c
addq $0x20, %r12
cmpq %r13, %r12
jne 0x1526
movq (%rbx), %rdx
leaq 0x10bae(%rip), %rbx     # 0x12100
leaq 0xcabb(%rip), %rsi      # 0xe014
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1040
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x147c
// File: /workspace/github_cpp_makefile_star2_O1/kazel1990[P]Inception-v4/generator.cpp
// Function: in_out(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 in_out(std::string bot, std::string top)
{
    sprintf(buf,"bottom: \"%s\"",bot.c_str());
    print(buf);
    sprintf(buf,"top: \"%s\"",top.c_str());
    print(buf);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rdi), %rdx
leaq 0x10b7b(%rip), %r14     # 0x12100
leaq 0xca7b(%rip), %rsi      # 0xe007
movq %r14, %rdi
xorl %eax, %eax
callq 0x1040
movq %r14, %rdi
callq 0x147c
movq (%rbx), %rdx
leaq 0xca6c(%rip), %rsi      # 0xe014
movq %r14, %rdi
xorl %eax, %eax
callq 0x1040
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x147c
// File: /workspace/github_cpp_makefile_star2_O1/kazel1990[P]Inception-v4/generator.cpp
// Function: batch_norm(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void batch_norm(std::string blob)
{
    print("layer {");
    sprintf(buf,"name: \"%s_bn\"",blob.c_str());
    print(buf);
    print("type: \"BatchNorm\"");
    in_out(blob,blob);
    print("batch_norm_param {");
    print("use_global_stats: false");
    print("}");

    print("}");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0xc5ef(%rip), %rdi      # 0xe01e
callq 0x147c
movq (%rbx), %rdx
leaq 0x106c2(%rip), %r14     # 0x12100
leaq 0xc6f9(%rip), %rsi      # 0xe13e
movq %r14, %rdi
xorl %eax, %eax
callq 0x1040
movq %r14, %rdi
callq 0x147c
leaq 0xc6ee(%rip), %rdi      # 0xe14c
callq 0x147c
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0xd204
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0xd204
movq %rsp, %rdi
leaq 0x20(%rsp), %rbx
movq %rbx, %rsi
callq 0x1574
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x1ac0
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x10f0
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x1ad6
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x10f0
leaq 0xc681(%rip), %rdi      # 0xe15e
callq 0x147c
leaq 0xc688(%rip), %rdi      # 0xe171
callq 0x147c
leaq 0xc569(%rip), %rbx      # 0xe05e
movq %rbx, %rdi
callq 0x147c
movq %rbx, %rdi
callq 0x147c
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x1b28
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x10f0
movq %rbx, %rdi
callq 0x1160
// File: /workspace/github_cpp_makefile_star2_O1/kazel1990[P]Inception-v4/generator.cpp
// Function: scale(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void scale(std::string blob)
{
    print("layer {");
    sprintf(buf,"name: \"%s_scale\"",blob.c_str());
    print(buf);
    print("type: \"Scale\"");
    in_out(blob,blob);
    print("scale_param {");
    print("bias_term: true");
    print("}");
    print("}");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0xc4db(%rip), %rdi      # 0xe01e
callq 0x147c
movq (%rbx), %rdx
leaq 0x105ae(%rip), %r14     # 0x12100
leaq 0xc630(%rip), %rsi      # 0xe189
movq %r14, %rdi
xorl %eax, %eax
callq 0x1040
movq %r14, %rdi
callq 0x147c
leaq 0xc628(%rip), %rdi      # 0xe19a
callq 0x147c
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0xd204
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0xd204
movq %rsp, %rdi
leaq 0x20(%rsp), %rbx
movq %rbx, %rsi
callq 0x1574
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x1bd4
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x10f0
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x1bea
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x10f0
leaq 0xc5b7(%rip), %rdi      # 0xe1a8
callq 0x147c
leaq 0xc5b9(%rip), %rdi      # 0xe1b6
callq 0x147c
leaq 0xc455(%rip), %rbx      # 0xe05e
movq %rbx, %rdi
callq 0x147c
movq %rbx, %rdi
callq 0x147c
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x1c3c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x10f0
movq %rbx, %rdi
callq 0x1160
// File: /workspace/github_cpp_makefile_star2_O1/kazel1990[P]Inception-v4/generator.cpp
// Function: relu(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void relu(std::string blob)
{
    print("layer {");
    sprintf(buf,"name: \"%s_relu\"",blob.c_str());
    print(buf);
    print("type: \"ReLU\"");
    in_out(blob,blob);
    print("}");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0xc3c7(%rip), %rdi      # 0xe01e
callq 0x147c
movq (%rbx), %rdx
leaq 0x1049a(%rip), %r14     # 0x12100
leaq 0xc559(%rip), %rsi      # 0xe1c6
movq %r14, %rdi
xorl %eax, %eax
callq 0x1040
movq %r14, %rdi
callq 0x147c
leaq 0xc550(%rip), %rdi      # 0xe1d6
callq 0x147c
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0xd204
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0xd204
movq %rsp, %rdi
leaq 0x20(%rsp), %rbx
movq %rbx, %rsi
callq 0x1574
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x1ce8
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x10f0
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x1cfe
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x10f0
leaq 0xc359(%rip), %rdi      # 0xe05e
callq 0x147c
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x1d2d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x10f0
movq %rbx, %rdi
callq 0x1160
// File: /workspace/github_cpp_makefile_star2_O1/kazel1990[P]Inception-v4/generator.cpp
// Function: pool(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int, int)
void pool(std::string name, std::string bot, std::string top,
        std::string type, int kernel, int stride, int pad=0)
{
    print("layer {");
    sprintf(buf,"name: \"%s\"",name.c_str());
    print(buf);
    print("type: \"Pooling\"");
    in_out(bot, top);
    print("pooling_param {");
    sprintf(buf,"pool: %s",type.c_str());
    print(buf);
    sprintf(buf,"kernel_size: %d",kernel);
    print(buf);
    sprintf(buf,"stride: %d",stride);
    print(buf);
    if(pad)
    {
        sprintf(buf,"pad: %d",pad);
        print(buf);
    }
    print("}");

    print("}");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r9d, %ebx
movl %r8d, %ebp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
leaq 0xc2c2(%rip), %rdi      # 0xe01e
callq 0x147c
movq (%r13), %rdx
leaq 0x10394(%rip), %r13     # 0x12100
leaq 0xc2b3(%rip), %rsi      # 0xe026
movq %r13, %rdi
xorl %eax, %eax
callq 0x1040
movq %r13, %rdi
callq 0x147c
leaq 0xc457(%rip), %rdi      # 0xe1e3
callq 0x147c
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0xd204
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0xd204
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %r15
movq %r15, %rsi
callq 0x1574
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x1df5
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10f0
movl 0x80(%rsp), %r15d
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x1e14
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10f0
leaq 0xc3d8(%rip), %rdi      # 0xe1f3
callq 0x147c
movq (%r14), %rdx
leaq 0x102d6(%rip), %r14     # 0x12100
leaq 0xc3d2(%rip), %rsi      # 0xe203
movq %r14, %rdi
xorl %eax, %eax
callq 0x1040
movq %r14, %rdi
callq 0x147c
leaq 0xc26e(%rip), %rsi      # 0xe0b8
movq %r14, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x1040
movq %r14, %rdi
callq 0x147c
leaq 0xc27d(%rip), %rsi      # 0xe0e2
movq %r14, %rdi
movl %ebx, %edx
xorl %eax, %eax
callq 0x1040
movq %r14, %rdi
callq 0x147c
testl %r15d, %r15d
je 0x1ea1
leaq 0x1027b(%rip), %rbx     # 0x12100
leaq 0xc210(%rip), %rsi      # 0xe09c
movq %rbx, %rdi
movl %r15d, %edx
xorl %eax, %eax
callq 0x1040
movq %rbx, %rdi
callq 0x147c
leaq 0xc1b6(%rip), %rbx      # 0xe05e
movq %rbx, %rdi
callq 0x147c
movq %rbx, %rdi
callq 0x147c
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x1ee1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10f0
movq %rbx, %rdi
callq 0x1160
// File: /workspace/github_cpp_makefile_star2_O1/kazel1990[P]Inception-v4/generator.cpp
// Function: concat(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<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 concat(std::string name, std::vector<std::string> bot, std::string top)
{
    print("layer {");
    sprintf(buf,"name: \"%s\"",name.c_str());
    print(buf);
    print("type: \"Concat\"");
    in_out(bot, top);
    print("}");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0xc11c(%rip), %rdi      # 0xe01e
callq 0x147c
movq (%r15), %rdx
leaq 0x101ef(%rip), %r15     # 0x12100
leaq 0xc10e(%rip), %rsi      # 0xe026
movq %r15, %rdi
xorl %eax, %eax
callq 0x1040
movq %r15, %rdi
callq 0x147c
leaq 0xc2db(%rip), %rdi      # 0xe20c
callq 0x147c
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0xd0ca
leaq 0x30(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0xd204
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rbx
movq %rbx, %rsi
callq 0x1500
movq (%rbx), %rdi
cmpq %r14, %rdi
je 0x1f87
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x10f0
leaq 0x8(%rsp), %rdi
callq 0xd154
leaq 0xc0c6(%rip), %rdi      # 0xe05e
callq 0x147c
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xd154
movq %rbx, %rdi
callq 0x1160
// File: /workspace/github_cpp_makefile_star2_O1/kazel1990[P]Inception-v4/generator.cpp
// Function: create_data()
void create_data()
{
    for(int i=0;i<=1;i++)
    {
        print("layer {");

        print("name: \"data\"");
        print("type: \"Data\"");
        print("top: \"data\"");
        print("top: \"label\"");

        print("include {");
        sprintf(buf,"phase: %s",i?"TEST":"TRAIN");
        print(buf);
        print("}");

        print("transform_param {");
        sprintf(buf,"mirror: %s",i?"false":"true");
        print(buf);
        sprintf(buf,"crop_size: %d",crop_size);
        print(buf);
        print("mean_value: 104");
        print("mean_value: 117");
        print("mean_value: 123");
        print("}");

        print("data_param {");
        sprintf(buf,"source: \"%s\"",i?test_path:train_path);
        print(buf);
        sprintf(buf,"batch_size: %d",batch_size);
        print(buf);
        print("backend: LMDB");
        print("}");

        print("}");
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl $0x1, %r12d
leaq 0x10072(%rip), %rbx     # 0x12100
leaq 0xbfc9(%rip), %r15      # 0xe05e
leaq 0xc250(%rip), %r13      # 0xe2ec
leaq 0xbf7b(%rip), %rdi      # 0xe01e
callq 0x147c
leaq 0xc16c(%rip), %rdi      # 0xe21b
callq 0x147c
leaq 0xc16d(%rip), %rdi      # 0xe228
callq 0x147c
leaq 0xc16e(%rip), %rdi      # 0xe235
callq 0x147c
leaq 0xc16e(%rip), %rdi      # 0xe241
callq 0x147c
leaq 0xc16f(%rip), %rdi      # 0xe24e
callq 0x147c
cmpl $0x1, %r12d
leaq 0xc600(%rip), %rdx      # 0xe6ef
leaq 0xc16c(%rip), %rax      # 0xe262
cmoveq %rax, %rdx
leaq 0xc082(%rip), %r14      # 0xe183
leaq 0xc4fe(%rip), %rax      # 0xe606
cmoveq %rax, %r14
leaq 0xc68d(%rip), %rbp      # 0xe7a0
leaq 0xc6f6(%rip), %rax      # 0xe810
cmoveq %rax, %rbp
movq %rbx, %rdi
leaq 0xc130(%rip), %rsi      # 0xe258
xorl %eax, %eax
callq 0x1040
movq %rbx, %rdi
callq 0x147c
movq %r15, %rdi
callq 0x147c
leaq 0xc122(%rip), %rdi      # 0xe268
callq 0x147c
movq %rbx, %rdi
leaq 0xc125(%rip), %rsi      # 0xe27a
movq %r14, %rdx
xorl %eax, %eax
callq 0x1040
movq %rbx, %rdi
callq 0x147c
movq %rbx, %rdi
leaq 0xc114(%rip), %rsi      # 0xe285
movl $0x12b, %edx            # imm = 0x12B
xorl %eax, %eax
callq 0x1040
movq %rbx, %rdi
callq 0x147c
leaq 0xc107(%rip), %rdi      # 0xe293
callq 0x147c
leaq 0xc10b(%rip), %rdi      # 0xe2a3
callq 0x147c
leaq 0xc10f(%rip), %rdi      # 0xe2b3
callq 0x147c
movq %r15, %rdi
callq 0x147c
leaq 0xc10b(%rip), %rdi      # 0xe2c3
callq 0x147c
movq %rbx, %rdi
leaq 0xc109(%rip), %rsi      # 0xe2d0
movq %rbp, %rdx
xorl %eax, %eax
callq 0x1040
movq %rbx, %rdi
callq 0x147c
movq %rbx, %rdi
leaq 0xc0fa(%rip), %rsi      # 0xe2dd
movl $0x20, %edx
xorl %eax, %eax
callq 0x1040
movq %rbx, %rdi
callq 0x147c
movq %r13, %rdi
callq 0x147c
movq %r15, %rdi
callq 0x147c
movq %r15, %rdi
callq 0x147c
decl %r12d
je 0x209c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/xelia-it[P]mustache/src/mustache-light.cpp
// Function: mustache::Mustache::~Mustache()
Mustache::~Mustache() {
        data_.clear();
        context_.clear();
        tokens_.clear();
        rendered_.clear();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x80(%rdi), %r14
movq %r14, %rdi
callq 0x18720
xorl %r12d, %r12d
movq %r12, 0x68(%rbx)
movq 0x60(%rbx), %rax
movb %r12b, (%rax)
leaq 0xd0(%rbx), %r15
movq %r15, %rdi
callq 0x17b30
movq %r12, 0x98(%rbx)
movq 0x90(%rbx), %rax
movb %r12b, (%rax)
leaq 0xf8(%rbx), %rdi
callq 0x178f0
movq %r15, %rdi
callq 0x177a0
movq 0xb0(%rbx), %rdi
leaq 0xc0(%rbx), %rax
cmpq %rax, %rdi
je 0x1935f
callq 0x17b00
movq 0x90(%rbx), %rdi
leaq 0xa0(%rbx), %rax
cmpq %rax, %rdi
je 0x19377
callq 0x17b00
movq %r14, %rdi
callq 0x17d70
movq 0x60(%rbx), %rdi
leaq 0x70(%rbx), %rax
cmpq %rax, %rdi
je 0x19391
callq 0x17b00
movq 0x40(%rbx), %rdi
leaq 0x50(%rbx), %rax
cmpq %rax, %rdi
je 0x193a3
callq 0x17b00
movq 0x20(%rbx), %rdi
leaq 0x30(%rbx), %rax
cmpq %rax, %rdi
je 0x193b5
callq 0x17b00
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x193ce
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x17b00
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/xelia-it[P]mustache/src/mustache-light.cpp
// Function: mustache::Mustache::render(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string Mustache::render(const string& view, const string& context) {
        view_ = view;
        context_ = context;
        try {
                data_ = json::parse(context_);
        } catch (const std::runtime_error& err) {
                rendered_.clear();
                error_ = err.what();
                return rendered_;
        } catch (const std::invalid_argument& err) {
                rendered_.clear();
                error_ = err.what();
                return rendered_;
        }

        return render();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rcx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x40(%rsi), %rdi
movq %rdx, %rsi
callq 0x17560
leaq 0x60(%r14), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x17560
xorps %xmm0, %xmm0
leaq -0x40(%rbp), %rdx
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, (%rdx)
leaq -0x50(%rbp), %rdi
movq %r12, %rsi
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x17240
leaq 0x80(%r14), %rdi
leaq -0x50(%rbp), %r15
movq %r15, %rsi
callq 0x17550
movq %r15, %rdi
callq 0x17d70
movq -0x30(%rbp), %rax
testq %rax, %rax
je 0x1945f
leaq -0x40(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
movq %r14, %rsi
callq 0x17480
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
callq 0x1d285
movq %rdx, %r12
movq %rax, %r15
movq -0x30(%rbp), %rax
testq %rax, %rax
je 0x1949f
leaq -0x40(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
cmpl $0x2, %r12d
jne 0x194fc
movq %r15, %rdi
callq 0x173f0
movq $0x0, 0x98(%r14)
movq 0x90(%r14), %rcx
movb $0x0, (%rcx)
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
leaq 0xb0(%r14), %rdi
movq %rax, %rsi
callq 0x17f00
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x90(%r14), %rsi
movq 0x98(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x173d0
jmp 0x19557
cmpl $0x1, %r12d
jne 0x19578
movq %r15, %rdi
callq 0x173f0
movq $0x0, 0x98(%r14)
movq 0x90(%r14), %rcx
movb $0x0, (%rcx)
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
leaq 0xb0(%r14), %rdi
movq %rax, %rsi
callq 0x17f00
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x90(%r14), %rsi
movq 0x98(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x173d0
callq 0x18320
jmp 0x1946a
jmp 0x1947a
movq %rax, %r15
callq 0x18320
jmp 0x19578
movq %rax, %r15
callq 0x18320
movq %r15, %rdi
callq 0x184b0
jmp 0x1947a
nop
// File: /workspace/github_cpp_makefile_star2_O1/xelia-it[P]mustache/src/mustache-light.cpp
// Function: mustache::Mustache::render[abi:cxx11]()
string Mustache::render() {
        error_.clear();

        // Tokenize view
#ifdef DEBUG
        LOG_END("BEFORE TOKEN");
        dumpTokens();
#endif
        tokens_ = tokenize(view_);

#ifdef DEBUG
        LOG_END("AFTER TOKEN");
        dumpTokens();
#endif
        currentToken_ = 0;

        // Reset stack: start from a stack containing the whole json
        while (!stack_.empty()) {
                stack_.pop();
        }
        stack_.push(data_);
        visible_ = true;
        rendered_.clear();

        LOG_END("------------------------------------------------------");
        LOG_END("Render:");
        try {
                produceMessage();
        } catch (const RenderException& err) {
                error_ = err.what();
                return rendered_;
        }
        LOG_END("------------------------------------------------------");
        LOG_END("Output:");
        LOG_END(rendered_);
        return rendered_;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorl %r12d, %r12d
movq %r12, 0xb8(%rsi)
movq 0xb0(%rsi), %rax
movb $0x0, (%rax)
leaq 0x40(%rsi), %rdx
leaq -0x58(%rbp), %r15
movq %r15, %rdi
callq 0x17150
leaq -0x40(%rbp), %rdi
movq %r12, 0x10(%rdi)
xorps %xmm0, %xmm0
movaps %xmm0, (%rdi)
movq 0xd0(%r14), %rax
movups 0xd8(%r14), %xmm0
movq (%r15), %rcx
movq %rcx, 0xd0(%r14)
movq 0x8(%r15), %rcx
movq %rcx, 0xd8(%r14)
movq 0x10(%r15), %rcx
movq %rcx, 0xe0(%r14)
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
movq 0x10(%rdi), %rsi
movq %rax, (%rdi)
movups %xmm0, 0x8(%rdi)
movq %rcx, (%r15)
movq %rdx, 0x8(%r15)
movq %rsi, 0x10(%r15)
callq 0x177a0
movq %r15, %rdi
callq 0x177a0
movq %r12, 0xe8(%r14)
leaq 0xf8(%r14), %r12
movq 0x128(%r14), %rax
cmpq 0x108(%r14), %rax
je 0x1964e
movq %r12, %rdi
callq 0x17f40
jmp 0x19634
leaq 0xb0(%r14), %r15
leaq 0x80(%r14), %rsi
movq %r12, %rdi
callq 0x17fb0
movb $0x1, 0x148(%r14)
movq $0x0, 0x98(%r14)
movq 0x90(%r14), %rax
movb $0x0, (%rax)
movq %r14, %rdi
callq 0x17570
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x90(%r14), %rsi
movq 0x98(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x173d0
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
cmpl $0x1, %edx
jne 0x1970c
movq %r12, %rdi
callq 0x173f0
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq %r15, %rdi
movq %rax, %rsi
callq 0x17f00
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x90(%r14), %rsi
movq 0x98(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x173d0
callq 0x18320
jmp 0x196a9
movq %rax, %r12
callq 0x18320
movq %r12, %rdi
callq 0x184b0
movq %rax, %rdi
callq 0x1d285
// File: /workspace/github_cpp_makefile_star2_O1/xelia-it[P]mustache/src/mustache-light.cpp
// Function: mustache::Mustache::produceVariable()
void Mustache::produceVariable()
{
        LOG("VARIABLE := ");
        LOG_START(TOKEN_START_VARIABLE);

        // Token must be (txt)
        CHECK_TOKEN_IS_TEXT();

        printVariable(true);

        CONSUME_TOKEN();
        CHECK_TOKEN_NOT_EMPTY();
        CHECK_TOKEN_IS(TOKEN_END);
        LOG("  ");
        LOG_END(TOKEN_END);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq 0xd8(%rdi), %rax
subq 0xd0(%rdi), %rax
sarq $0x5, %rax
cmpq %rax, 0xe8(%rdi)
je 0x1a39e
movq %rdi, %rbx
movl $0x1, %esi
callq 0x18220
movq 0xe8(%rbx), %rsi
incq %rsi
movq %rsi, 0xe8(%rbx)
movq 0xd0(%rbx), %rax
movq 0xd8(%rbx), %rdx
subq %rax, %rdx
sarq $0x5, %rdx
cmpq %rdx, %rsi
je 0x1a3c6
jae 0x1a3ee
shlq $0x5, %rsi
movq 0x8(%rax,%rsi), %rdx
movq 0x23b22(%rip), %rcx     # 0x3de78
cmpq 0x8(%rcx), %rdx
jne 0x1a37c
testq %rdx, %rdx
je 0x1a373
addq %rsi, %rax
movq (%rcx), %rsi
movq (%rax), %rdi
callq 0x17be0
testl %eax, %eax
jne 0x1a37c
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x16956(%rip), %rsi     # 0x30cd9
movq 0x23aee(%rip), %rdx     # 0x3de78
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x17a70
movq %rbx, %rsi
callq 0x17e70
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x16914(%rip), %rsi     # 0x30cc1
leaq 0x16924(%rip), %rdx     # 0x30cd8
leaq -0x30(%rbp), %rdi
callq 0x173a0
leaq -0x30(%rbp), %rsi
callq 0x17e70
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x168ec(%rip), %rsi     # 0x30cc1
leaq 0x168fc(%rip), %rdx     # 0x30cd8
leaq -0x30(%rbp), %rdi
callq 0x173a0
leaq -0x30(%rbp), %rsi
callq 0x17e70
leaq 0x1a2eb(%rip), %rdi     # 0x346e0
xorl %eax, %eax
callq 0x18110
jmp 0x1a400
jmp 0x1a40e
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
jne 0x1a423
jmp 0x1a428
movq %rax, %rbx
jmp 0x1a428
movq %rax, %rbx
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1a428
callq 0x17b00
movq %rbx, %rdi
callq 0x184b0
// File: /workspace/github_cpp_makefile_star2_O1/xelia-it[P]mustache/src/mustache-light.cpp
// Function: mustache::Mustache::produceVariableUnescaped()
void Mustache::produceVariableUnescaped()
{
        LOG("VARIABLE_UNESCAPED := ");
        LOG_START(TOKEN_START_VARIABLE_UNESCAPED);

        // Token must be (txt)
        CHECK_TOKEN_IS_TEXT();

        printVariable(false);

        CONSUME_TOKEN();
        CHECK_TOKEN_NOT_EMPTY();
        CHECK_TOKEN_IS(TOKEN_END_UNESCAPED);
        LOG("  ");
        LOG_END(TOKEN_END_UNESCAPED);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq 0xd8(%rdi), %rax
subq 0xd0(%rdi), %rax
sarq $0x5, %rax
cmpq %rax, 0xe8(%rdi)
je 0x1a4f1
movq %rdi, %rbx
xorl %esi, %esi
callq 0x18220
movq 0xe8(%rbx), %rsi
incq %rsi
movq %rsi, 0xe8(%rbx)
movq 0xd0(%rbx), %rax
movq 0xd8(%rbx), %rdx
subq %rax, %rdx
sarq $0x5, %rdx
cmpq %rdx, %rsi
je 0x1a519
jae 0x1a541
shlq $0x5, %rsi
movq 0x8(%rax,%rsi), %rdx
movq 0x23aaf(%rip), %rcx     # 0x3df58
cmpq 0x8(%rcx), %rdx
jne 0x1a4cf
testq %rdx, %rdx
je 0x1a4c6
addq %rsi, %rax
movq (%rcx), %rsi
movq (%rax), %rdi
callq 0x17be0
testl %eax, %eax
jne 0x1a4cf
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x16803(%rip), %rsi     # 0x30cd9
movq 0x23a7b(%rip), %rdx     # 0x3df58
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x17a70
movq %rbx, %rsi
callq 0x17e70
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x167c1(%rip), %rsi     # 0x30cc1
leaq 0x167d1(%rip), %rdx     # 0x30cd8
leaq -0x30(%rbp), %rdi
callq 0x173a0
leaq -0x30(%rbp), %rsi
callq 0x17e70
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x16799(%rip), %rsi     # 0x30cc1
leaq 0x167a9(%rip), %rdx     # 0x30cd8
leaq -0x30(%rbp), %rdi
callq 0x173a0
leaq -0x30(%rbp), %rsi
callq 0x17e70
leaq 0x1a198(%rip), %rdi     # 0x346e0
xorl %eax, %eax
callq 0x18110
jmp 0x1a553
jmp 0x1a561
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
jne 0x1a576
jmp 0x1a57b
movq %rax, %rbx
jmp 0x1a57b
movq %rax, %rbx
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1a57b
callq 0x17b00
movq %rbx, %rdi
callq 0x184b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/xelia-it[P]mustache/src/mustache-light.cpp
// Function: mustache::Mustache::produceComment()
void Mustache::produceComment() {
        LOG_START("COMMENT := ");
        LOG_END(TOKEN_START_VARIABLE);

        // Token must be (txt)
        LOG_END("token not empty  ");
        CHECK_TOKEN_IS_TEXT();

        LOG_END("consume token  ");
        CONSUME_TOKEN();
        LOG_END("check token not empty  ");
        CHECK_TOKEN_NOT_EMPTY();
        LOG_END("check token is  ");
        CHECK_TOKEN_IS(TOKEN_END);

        LOG("  ");
        LOG_END(TOKEN_END);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq 0xe8(%rdi), %rsi
movq 0xd0(%rdi), %rax
movq 0xd8(%rdi), %rdx
subq %rax, %rdx
sarq $0x5, %rdx
cmpq %rdx, %rsi
je 0x1a621
incq %rsi
movq %rsi, 0xe8(%rdi)
cmpq %rdx, %rsi
je 0x1a649
jae 0x1a671
shlq $0x5, %rsi
movq 0x8(%rax,%rsi), %rdx
movq 0x2389f(%rip), %rcx     # 0x3de78
cmpq 0x8(%rcx), %rdx
jne 0x1a5ff
testq %rdx, %rdx
je 0x1a5f6
addq %rsi, %rax
movq (%rcx), %rsi
movq (%rax), %rdi
callq 0x17be0
testl %eax, %eax
jne 0x1a5ff
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x166d3(%rip), %rsi     # 0x30cd9
movq 0x2386b(%rip), %rdx     # 0x3de78
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x17a70
movq %rbx, %rsi
callq 0x17e70
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x16691(%rip), %rsi     # 0x30cc1
leaq 0x166a1(%rip), %rdx     # 0x30cd8
leaq -0x30(%rbp), %rdi
callq 0x173a0
leaq -0x30(%rbp), %rsi
callq 0x17e70
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x16669(%rip), %rsi     # 0x30cc1
leaq 0x16679(%rip), %rdx     # 0x30cd8
leaq -0x30(%rbp), %rdi
callq 0x173a0
leaq -0x30(%rbp), %rsi
callq 0x17e70
leaq 0x1a068(%rip), %rdi     # 0x346e0
xorl %eax, %eax
callq 0x18110
jmp 0x1a683
jmp 0x1a691
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
jne 0x1a6a6
jmp 0x1a6ab
movq %rax, %rbx
jmp 0x1a6ab
movq %rax, %rbx
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1a6ab
callq 0x17b00
movq %rbx, %rdi
callq 0x184b0
nop