LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2475b(%rip), %rax     # 0x2b570
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
leaq 0x18(%rdi), %r12
movq %r12, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
leaq 0x190fa(%rip), %rsi     # 0x1ff31
leaq -0x80(%rbp), %rdi
movl $0x10, %edx
callq 0x7f5c
movq (%r14), %r14
xorps %xmm0, %xmm0
leaq -0x40(%rbp), %r15
movaps %xmm0, 0x10(%r15)
movaps %xmm0, (%r15)
movq %r14, %rdi
callq 0x5160
leaq (%rax,%r14), %rsi
leaq -0x80(%rbp), %rcx
movq %r14, %rdi
movq %r15, %rdx
xorl %r8d, %r8d
callq 0x13a6c
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rcx
subq %rax, %rcx
je 0x6ea8
movq %rcx, %rdx
sarq $0x3, %rdx
movabsq $-0x5555555555555555, %rsi # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdx, %rsi
addq $-0x5, %rsi
cmpq $-0x3, %rsi
ja 0x6ea8
addq $0x18, %rax
jmp 0x6eaf
addq %rcx, %rax
addq $-0x48, %rax
cmpb $0x1, 0x10(%rax)
jne 0x6ecf
movq (%rax), %rsi
movq 0x8(%rax), %rdx
leaq -0x50(%rbp), %rax
movq %rax, -0x10(%rax)
leaq -0x60(%rbp), %rdi
callq 0xce8c
jmp 0x6ee2
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 0x53b0
movq (%r14), %rdi
leaq -0x50(%rbp), %rax
cmpq %rax, %rdi
je 0x6f09
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x52e0
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x6f1e
movq -0x30(%rbp), %rsi
subq %rdi, %rsi
callq 0x52e0
leaq -0x80(%rbp), %rdi
callq 0x7fc8
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6f36
movq %rax, %r14
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x6f4e
movq -0x30(%rbp), %rsi
subq %rdi, %rsi
callq 0x52e0
leaq -0x80(%rbp), %rdi
callq 0x7fc8
jmp 0x6f5c
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x6f70
movq (%r12), %rsi
incq %rsi
callq 0x52e0
movq %r14, %rdi
callq 0x5540
// File: /workspace/github_cpp_makefile_star2_O3/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 0x769d
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 0x50e0
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x7694
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x52e0
addq $0x8, %r12
cmpq %r15, %r12
jne 0x7662
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x76cc
movq %rax, %r14
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x76cc
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x52e0
movq (%rbx), %rdi
cmpq -0x30(%rbp), %rdi
je 0x76e4
movq -0x30(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x52e0
movq %r14, %rdi
callq 0x5540
// File: /workspace/github_cpp_makefile_star2_O3/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 0x142f6(%rip), %rax     # 0x2b9e0
movq %rax, (%rdi)
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x176fc
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x1770b
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x1771a
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x1772f
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_O3/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 0x13856(%rip), %rax     # 0x2ba60
movq %rax, (%rdi)
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x1821c
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x1822b
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x1823a
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x1824f
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_O3/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 0x59cc
movl %eax, %ebx
movq 0xdf86(%rip), %rdi      # 0x2bfb8
testl %eax, %eax
je 0x1e044
leaq 0x38bb(%rip), %rsi      # 0x218f8
movl $0xe, %edx
jmp 0x1e050
leaq 0x389d(%rip), %rsi      # 0x218e8
movl $0xf, %edx
callq 0x5360
movq 0xdf5c(%rip), %r14      # 0x2bfb8
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x52c0
movsbl %al, %esi
movq %r14, %rdi
callq 0x5040
movq %rax, %rdi
callq 0x5210
leaq -0x258(%rbp), %r14
movq %r14, %rdi
callq 0x5500
leaq 0x386e(%rip), %rsi      # 0x21907
movq %r14, %rdi
movl $0x10, %edx
callq 0x5070
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x3859(%rip), %rsi      # 0x2190e
leaq 0x3894(%rip), %rdx      # 0x21950
leaq -0x38(%rbp), %rdi
callq 0xce8c
leaq 0xe664(%rip), %rax      # 0x2c730
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 0x50e0
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1e103
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x52e0
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
leaq -0x258(%rbp), %rdi
callq 0x5360
leaq -0x258(%rbp), %rdi
callq 0x5420
movq 0xde8e(%rip), %rdi      # 0x2bfb8
leaq 0x3820(%rip), %rsi      # 0x21951
movl $0x16, %edx
callq 0x5360
leaq 0xe5d6(%rip), %rax      # 0x2c718
movl (%rax), %esi
movq 0xde6d(%rip), %rdi      # 0x2bfb8
callq 0x5520
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x52c0
movsbl %al, %esi
movq %r14, %rdi
callq 0x5040
movq %rax, %rdi
callq 0x5210
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x1e18f
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x52e0
movq 0xddfa(%rip), %rax      # 0x2bf90
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 0x5280
leaq -0x160(%rbp), %rdi
callq 0x5100
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 0x1e1ff
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x52e0
jmp 0x1e1ff
jmp 0x1e1fc
jmp 0x1e1f7
movq %rax, %rbx
jmp 0x1e214
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x1e214
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x52e0
leaq -0x258(%rbp), %rdi
callq 0x5470
movq %rbx, %rdi
callq 0x5540
// File: /workspace/github_cpp_makefile_star2_O3/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 0xbcf3
movq 0x1331d(%rip), %rbx     # 0x1efd8
leaq 0xc39b(%rip), %rsi      # 0x1805d
movl $0x7, %edx
movq %rbx, %rdi
callq 0xb300
movq (%r14), %r14
testq %r14, %r14
je 0xbd02
movq %r14, %rdi
callq 0xb100
movq 0x132f2(%rip), %rdi     # 0x1efd8
movq %r14, %rsi
movq %rax, %rdx
callq 0xb300
jmp 0xbd19
movq 0x8(%r14), %rdi
movq 0x10(%r14), %rsi
callq 0xb64c
jmp 0xbd54
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0xb400
leaq 0xc345(%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_O3/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 0x7a72
movq 0x8(%rsp), %rax
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
testq %rax, %rax
je 0x7ab3
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 0x7ae3
movq %rax, %r14
movslq %r14d, %rax
cmpq %r14, %rax
jne 0x7aef
movl (%rbx), %eax
cmpl $0x22, %eax
je 0x7aef
testl %eax, %eax
jne 0x7a45
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 0xa575(%rip), %rdi      # 0x11ff0
leaq 0x4611(%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 0xa536(%rip), %rdi      # 0x11ff0
leaq 0x45e0(%rip), %rsi      # 0xc0a1
callq 0x52f0
movq %rax, %rdi
movq %r14, %rsi
callq 0x5290
movq %rax, %rdi
callq 0x5150
movl $0x3, %edi
callq 0x53b0
leaq 0x4635(%rip), %rdi      # 0xc11f
callq 0x51c0
leaq 0x4629(%rip), %rdi      # 0xc11f
callq 0x5470
cmpl $0x0, (%rbx)
jne 0x7b02
movl %ebp, (%rbx)
movq %rax, %rdi
callq 0x5540
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa498
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x1, %ecx
jne 0x920e
movq 0x8e10(%rip), %rbx      # 0x11ff0
leaq 0x2f51(%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_O3/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 0x10d14(%rip), %eax     # 0x120f0
xorl %ebp, %ebp
movq %rdi, %rcx
movzbl (%rcx), %edx
cmpl $0x7b, %edx
je 0x13fe
cmpl $0x7d, %edx
je 0x13f4
testl %edx, %edx
jne 0x1401
jmp 0x1406
decl %eax
movl %eax, 0x10cf4(%rip)     # 0x120f0
jmp 0x1401
movb $0x1, %bpl
incq %rcx
jmp 0x13e1
testl %eax, %eax
jle 0x142c
leaq 0xcbf3(%rip), %r14      # 0xe004
xorl %r15d, %r15d
movq %r14, %rdi
xorl %eax, %eax
callq 0x1030
incl %r15d
movl 0x10cc9(%rip), %eax     # 0x120f0
cmpl %eax, %r15d
jl 0x1414
testb $0x1, %bpl
je 0x143a
incl %eax
movl %eax, 0x10cb6(%rip)     # 0x120f0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1130
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1494
leaq 0x10c95(%rip), %r14     # 0x12100
leaq 0xcb95(%rip), %r15      # 0xe007
movq (%r12), %rdx
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x1040
movq %r14, %rdi
callq 0x13cc
addq $0x20, %r12
cmpq %r13, %r12
jne 0x1472
movq (%rbx), %rdx
leaq 0x10c62(%rip), %rbx     # 0x12100
leaq 0xcb6f(%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 0x13cc
// File: /workspace/github_cpp_makefile_star2_O3/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 0x10c2f(%rip), %r14     # 0x12100
leaq 0xcb2f(%rip), %rsi      # 0xe007
movq %r14, %rdi
xorl %eax, %eax
callq 0x1040
movq %r14, %rdi
callq 0x13cc
movq (%rbx), %rdx
leaq 0xcb20(%rip), %rsi      # 0xe014
movq %r14, %rdi
xorl %eax, %eax
callq 0x1040
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x13cc
// File: /workspace/github_cpp_makefile_star2_O3/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 0xc6a3(%rip), %rdi      # 0xe01e
callq 0x13cc
movq (%rbx), %rdx
leaq 0x10776(%rip), %r14     # 0x12100
leaq 0xc7ad(%rip), %rsi      # 0xe13e
movq %r14, %rdi
xorl %eax, %eax
callq 0x1040
movq %r14, %rdi
callq 0x13cc
leaq 0xc7a2(%rip), %rdi      # 0xe14c
callq 0x13cc
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0xd0c8
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0xd0c8
movq %rsp, %rdi
leaq 0x20(%rsp), %rbx
movq %rbx, %rsi
callq 0x14c0
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x1a0c
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x10f0
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x1a22
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x10f0
leaq 0xc735(%rip), %rdi      # 0xe15e
callq 0x13cc
leaq 0xc73c(%rip), %rdi      # 0xe171
callq 0x13cc
leaq 0xc61d(%rip), %rbx      # 0xe05e
movq %rbx, %rdi
callq 0x13cc
movq %rbx, %rdi
callq 0x13cc
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x1a74
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x10f0
movq %rbx, %rdi
callq 0x1160
// File: /workspace/github_cpp_makefile_star2_O3/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 0xc58f(%rip), %rdi      # 0xe01e
callq 0x13cc
movq (%rbx), %rdx
leaq 0x10662(%rip), %r14     # 0x12100
leaq 0xc6e4(%rip), %rsi      # 0xe189
movq %r14, %rdi
xorl %eax, %eax
callq 0x1040
movq %r14, %rdi
callq 0x13cc
leaq 0xc6dc(%rip), %rdi      # 0xe19a
callq 0x13cc
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0xd0c8
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0xd0c8
movq %rsp, %rdi
leaq 0x20(%rsp), %rbx
movq %rbx, %rsi
callq 0x14c0
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x1b20
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x10f0
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x1b36
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x10f0
leaq 0xc66b(%rip), %rdi      # 0xe1a8
callq 0x13cc
leaq 0xc66d(%rip), %rdi      # 0xe1b6
callq 0x13cc
leaq 0xc509(%rip), %rbx      # 0xe05e
movq %rbx, %rdi
callq 0x13cc
movq %rbx, %rdi
callq 0x13cc
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x1b88
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x10f0
movq %rbx, %rdi
callq 0x1160
// File: /workspace/github_cpp_makefile_star2_O3/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 0xc47b(%rip), %rdi      # 0xe01e
callq 0x13cc
movq (%rbx), %rdx
leaq 0x1054e(%rip), %r14     # 0x12100
leaq 0xc60d(%rip), %rsi      # 0xe1c6
movq %r14, %rdi
xorl %eax, %eax
callq 0x1040
movq %r14, %rdi
callq 0x13cc
leaq 0xc604(%rip), %rdi      # 0xe1d6
callq 0x13cc
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0xd0c8
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0xd0c8
movq %rsp, %rdi
leaq 0x20(%rsp), %rbx
movq %rbx, %rsi
callq 0x14c0
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x1c34
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x10f0
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x1c4a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x10f0
leaq 0xc40d(%rip), %rdi      # 0xe05e
callq 0x13cc
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x1c79
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x10f0
movq %rbx, %rdi
callq 0x1160
// File: /workspace/github_cpp_makefile_star2_O3/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 0xc376(%rip), %rdi      # 0xe01e
callq 0x13cc
movq (%r13), %rdx
leaq 0x10448(%rip), %r13     # 0x12100
leaq 0xc367(%rip), %rsi      # 0xe026
movq %r13, %rdi
xorl %eax, %eax
callq 0x1040
movq %r13, %rdi
callq 0x13cc
leaq 0xc50b(%rip), %rdi      # 0xe1e3
callq 0x13cc
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0xd0c8
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0xd0c8
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %r15
movq %r15, %rsi
callq 0x14c0
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x1d41
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10f0
movl 0x80(%rsp), %r15d
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x1d60
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10f0
leaq 0xc48c(%rip), %rdi      # 0xe1f3
callq 0x13cc
movq (%r14), %rdx
leaq 0x1038a(%rip), %r14     # 0x12100
leaq 0xc486(%rip), %rsi      # 0xe203
movq %r14, %rdi
xorl %eax, %eax
callq 0x1040
movq %r14, %rdi
callq 0x13cc
leaq 0xc322(%rip), %rsi      # 0xe0b8
movq %r14, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x1040
movq %r14, %rdi
callq 0x13cc
leaq 0xc331(%rip), %rsi      # 0xe0e2
movq %r14, %rdi
movl %ebx, %edx
xorl %eax, %eax
callq 0x1040
movq %r14, %rdi
callq 0x13cc
testl %r15d, %r15d
je 0x1ded
leaq 0x1032f(%rip), %rbx     # 0x12100
leaq 0xc2c4(%rip), %rsi      # 0xe09c
movq %rbx, %rdi
movl %r15d, %edx
xorl %eax, %eax
callq 0x1040
movq %rbx, %rdi
callq 0x13cc
leaq 0xc26a(%rip), %rbx      # 0xe05e
movq %rbx, %rdi
callq 0x13cc
movq %rbx, %rdi
callq 0x13cc
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 0x1e2d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10f0
movq %rbx, %rdi
callq 0x1160
// File: /workspace/github_cpp_makefile_star2_O3/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 0xc1d0(%rip), %rdi      # 0xe01e
callq 0x13cc
movq (%r15), %rdx
leaq 0x102a3(%rip), %r15     # 0x12100
leaq 0xc1c2(%rip), %rsi      # 0xe026
movq %r15, %rdi
xorl %eax, %eax
callq 0x1040
movq %r15, %rdi
callq 0x13cc
leaq 0xc38f(%rip), %rdi      # 0xe20c
callq 0x13cc
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0xcf8c
leaq 0x30(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0xd0c8
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rbx
movq %rbx, %rsi
callq 0x144c
movq (%rbx), %rdi
cmpq %r14, %rdi
je 0x1ed3
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x10f0
leaq 0x8(%rsp), %rdi
callq 0xd016
leaq 0xc17a(%rip), %rdi      # 0xe05e
callq 0x13cc
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xd016
movq %rbx, %rdi
callq 0x1160
// File: /workspace/github_cpp_makefile_star2_O3/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
movb $0x1, %r12b
leaq 0x10129(%rip), %rbx     # 0x12100
leaq 0xc080(%rip), %r15      # 0xe05e
leaq 0xc307(%rip), %r13      # 0xe2ec
leaq 0xc032(%rip), %rdi      # 0xe01e
callq 0x13cc
leaq 0xc223(%rip), %rdi      # 0xe21b
callq 0x13cc
leaq 0xc224(%rip), %rdi      # 0xe228
callq 0x13cc
leaq 0xc225(%rip), %rdi      # 0xe235
callq 0x13cc
leaq 0xc225(%rip), %rdi      # 0xe241
callq 0x13cc
leaq 0xc226(%rip), %rdi      # 0xe24e
callq 0x13cc
testb $0x1, %r12b
leaq 0xc6b7(%rip), %rdx      # 0xe6ef
leaq 0xc223(%rip), %rax      # 0xe262
cmovneq %rax, %rdx
leaq 0xc139(%rip), %r14      # 0xe183
leaq 0xc5b5(%rip), %rax      # 0xe606
cmovneq %rax, %r14
leaq 0xc744(%rip), %rbp      # 0xe7a0
leaq 0xc7ad(%rip), %rax      # 0xe810
cmovneq %rax, %rbp
movq %rbx, %rdi
leaq 0xc1e7(%rip), %rsi      # 0xe258
xorl %eax, %eax
callq 0x1040
movq %rbx, %rdi
callq 0x13cc
movq %r15, %rdi
callq 0x13cc
leaq 0xc1d9(%rip), %rdi      # 0xe268
callq 0x13cc
movq %rbx, %rdi
leaq 0xc1dc(%rip), %rsi      # 0xe27a
movq %r14, %rdx
xorl %eax, %eax
callq 0x1040
movq %rbx, %rdi
callq 0x13cc
movq %rbx, %rdi
leaq 0xc1cb(%rip), %rsi      # 0xe285
movl $0x12b, %edx            # imm = 0x12B
xorl %eax, %eax
callq 0x1040
movq %rbx, %rdi
callq 0x13cc
leaq 0xc1be(%rip), %rdi      # 0xe293
callq 0x13cc
leaq 0xc1c2(%rip), %rdi      # 0xe2a3
callq 0x13cc
leaq 0xc1c6(%rip), %rdi      # 0xe2b3
callq 0x13cc
movq %r15, %rdi
callq 0x13cc
leaq 0xc1c2(%rip), %rdi      # 0xe2c3
callq 0x13cc
movq %rbx, %rdi
leaq 0xc1c0(%rip), %rsi      # 0xe2d0
movq %rbp, %rdx
xorl %eax, %eax
callq 0x1040
movq %rbx, %rdi
callq 0x13cc
movq %rbx, %rdi
leaq 0xc1b1(%rip), %rsi      # 0xe2dd
movl $0x20, %edx
xorl %eax, %eax
callq 0x1040
movq %rbx, %rdi
callq 0x13cc
movq %r13, %rdi
callq 0x13cc
movq %r15, %rdi
callq 0x13cc
movq %r15, %rdi
callq 0x13cc
testb $0x1, %r12b
movl $0x0, %r12d
jne 0x1fe5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x18700
xorl %r12d, %r12d
movq %r12, 0x68(%rbx)
movq 0x60(%rbx), %rax
movb %r12b, (%rax)
leaq 0xd0(%rbx), %r15
movq %r15, %rdi
callq 0x17b10
movq %r12, 0x98(%rbx)
movq 0x90(%rbx), %rax
movb %r12b, (%rax)
leaq 0xf8(%rbx), %rdi
callq 0x178d0
movq %r15, %rdi
callq 0x17790
movq 0xb0(%rbx), %rdi
leaq 0xc0(%rbx), %rax
cmpq %rax, %rdi
je 0x1940f
callq 0x17ae0
movq 0x90(%rbx), %rdi
leaq 0xa0(%rbx), %rax
cmpq %rax, %rdi
je 0x19427
callq 0x17ae0
movq %r14, %rdi
callq 0x17d50
movq 0x60(%rbx), %rdi
leaq 0x70(%rbx), %rax
cmpq %rax, %rdi
je 0x19441
callq 0x17ae0
movq 0x40(%rbx), %rdi
leaq 0x50(%rbx), %rax
cmpq %rax, %rdi
je 0x19453
callq 0x17ae0
movq 0x20(%rbx), %rdi
leaq 0x30(%rbx), %rax
cmpq %rax, %rdi
je 0x19465
callq 0x17ae0
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x1947e
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x17ae0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x17550
leaq 0x60(%r14), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x17550
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 0x17540
movq %r15, %rdi
callq 0x17d50
movq -0x30(%rbp), %rax
testq %rax, %rax
je 0x1950f
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 0x1d3c1
movq %rdx, %r12
movq %rax, %r15
movq -0x30(%rbp), %rax
testq %rax, %rax
je 0x1954f
leaq -0x40(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
cmpl $0x2, %r12d
jne 0x195ac
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 0x17ee0
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x90(%r14), %rsi
movq 0x98(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x173d0
jmp 0x19607
cmpl $0x1, %r12d
jne 0x19628
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 0x17ee0
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x90(%r14), %rsi
movq 0x98(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x173d0
callq 0x18300
jmp 0x1951a
jmp 0x1952a
movq %rax, %r15
callq 0x18300
jmp 0x19628
movq %rax, %r15
callq 0x18300
movq %r15, %rdi
callq 0x18490
jmp 0x1952a
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 -0x40(%rbp), %r15
movq %r15, %rdi
callq 0x17150
movups 0xd0(%r14), %xmm0
movq 0xe0(%r14), %rax
movq (%r15), %rcx
movq %rcx, 0xd0(%r14)
movq 0x8(%r15), %rcx
movq %rcx, 0xd8(%r14)
movq 0x10(%r15), %rcx
movq %rcx, 0xe0(%r14)
leaq -0x58(%rbp), %rdi
movups %xmm0, (%rdi)
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movaps %xmm0, (%r15)
movq %r12, 0x10(%r15)
callq 0x17790
movq %r15, %rdi
callq 0x17790
movq %r12, 0xe8(%r14)
leaq 0xf8(%r14), %r12
movq 0x128(%r14), %rax
cmpq 0x108(%r14), %rax
je 0x196e9
movq %r12, %rdi
callq 0x17f20
jmp 0x196cf
leaq 0xb0(%r14), %r15
leaq 0x80(%r14), %rsi
movq %r12, %rdi
callq 0x17f90
movb $0x1, 0x148(%r14)
movq $0x0, 0x98(%r14)
movq 0x90(%r14), %rax
movb $0x0, (%rax)
movq %r14, %rdi
callq 0x17560
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 0x197a7
movq %r12, %rdi
callq 0x173f0
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq %r15, %rdi
movq %rax, %rsi
callq 0x17ee0
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x90(%r14), %rsi
movq 0x98(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x173d0
callq 0x18300
jmp 0x19744
movq %rax, %r12
callq 0x18300
movq %r12, %rdi
callq 0x18490
movq %rax, %rdi
callq 0x1d3c1
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1a472
movq %rdi, %rbx
movl $0x1, %esi
callq 0x18200
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 0x1a49a
jae 0x1a4c2
shlq $0x5, %rsi
movq 0x8(%rax,%rsi), %rdx
movq 0x22a4e(%rip), %rcx     # 0x3ce78
cmpq 0x8(%rcx), %rdx
jne 0x1a450
testq %rdx, %rdx
je 0x1a447
addq %rsi, %rax
movq (%rcx), %rsi
movq (%rax), %rdi
callq 0x17bc0
testl %eax, %eax
jne 0x1a450
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x15876(%rip), %rsi     # 0x2fccd
movq 0x22a1a(%rip), %rdx     # 0x3ce78
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x17a50
movq %rbx, %rsi
callq 0x17e50
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x15834(%rip), %rsi     # 0x2fcb5
leaq 0x15844(%rip), %rdx     # 0x2fccc
leaq -0x30(%rbp), %rdi
callq 0x173a0
leaq -0x30(%rbp), %rsi
callq 0x17e50
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x1580c(%rip), %rsi     # 0x2fcb5
leaq 0x1581c(%rip), %rdx     # 0x2fccc
leaq -0x30(%rbp), %rdi
callq 0x173a0
leaq -0x30(%rbp), %rsi
callq 0x17e50
leaq 0x1920b(%rip), %rdi     # 0x336d4
xorl %eax, %eax
callq 0x180f0
jmp 0x1a4d4
jmp 0x1a4e2
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
jne 0x1a4f7
jmp 0x1a4fc
movq %rax, %rbx
jmp 0x1a4fc
movq %rax, %rbx
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1a4fc
callq 0x17ae0
movq %rbx, %rdi
callq 0x18490
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1a5c5
movq %rdi, %rbx
xorl %esi, %esi
callq 0x18200
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 0x1a5ed
jae 0x1a615
shlq $0x5, %rsi
movq 0x8(%rax,%rsi), %rdx
movq 0x229db(%rip), %rcx     # 0x3cf58
cmpq 0x8(%rcx), %rdx
jne 0x1a5a3
testq %rdx, %rdx
je 0x1a59a
addq %rsi, %rax
movq (%rcx), %rsi
movq (%rax), %rdi
callq 0x17bc0
testl %eax, %eax
jne 0x1a5a3
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x15723(%rip), %rsi     # 0x2fccd
movq 0x229a7(%rip), %rdx     # 0x3cf58
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x17a50
movq %rbx, %rsi
callq 0x17e50
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x156e1(%rip), %rsi     # 0x2fcb5
leaq 0x156f1(%rip), %rdx     # 0x2fccc
leaq -0x30(%rbp), %rdi
callq 0x173a0
leaq -0x30(%rbp), %rsi
callq 0x17e50
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x156b9(%rip), %rsi     # 0x2fcb5
leaq 0x156c9(%rip), %rdx     # 0x2fccc
leaq -0x30(%rbp), %rdi
callq 0x173a0
leaq -0x30(%rbp), %rsi
callq 0x17e50
leaq 0x190b8(%rip), %rdi     # 0x336d4
xorl %eax, %eax
callq 0x180f0
jmp 0x1a627
jmp 0x1a635
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
jne 0x1a64a
jmp 0x1a64f
movq %rax, %rbx
jmp 0x1a64f
movq %rax, %rbx
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1a64f
callq 0x17ae0
movq %rbx, %rdi
callq 0x18490
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1a6f5
incq %rsi
movq %rsi, 0xe8(%rdi)
cmpq %rdx, %rsi
je 0x1a71d
jae 0x1a745
shlq $0x5, %rsi
movq 0x8(%rax,%rsi), %rdx
movq 0x227cb(%rip), %rcx     # 0x3ce78
cmpq 0x8(%rcx), %rdx
jne 0x1a6d3
testq %rdx, %rdx
je 0x1a6ca
addq %rsi, %rax
movq (%rcx), %rsi
movq (%rax), %rdi
callq 0x17bc0
testl %eax, %eax
jne 0x1a6d3
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x155f3(%rip), %rsi     # 0x2fccd
movq 0x22797(%rip), %rdx     # 0x3ce78
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x17a50
movq %rbx, %rsi
callq 0x17e50
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x155b1(%rip), %rsi     # 0x2fcb5
leaq 0x155c1(%rip), %rdx     # 0x2fccc
leaq -0x30(%rbp), %rdi
callq 0x173a0
leaq -0x30(%rbp), %rsi
callq 0x17e50
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x15589(%rip), %rsi     # 0x2fcb5
leaq 0x15599(%rip), %rdx     # 0x2fccc
leaq -0x30(%rbp), %rdi
callq 0x173a0
leaq -0x30(%rbp), %rsi
callq 0x17e50
leaq 0x18f88(%rip), %rdi     # 0x336d4
xorl %eax, %eax
callq 0x180f0
jmp 0x1a757
jmp 0x1a765
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
jne 0x1a77a
jmp 0x1a77f
movq %rax, %rbx
jmp 0x1a77f
movq %rax, %rbx
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1a77f
callq 0x17ae0
movq %rbx, %rdi
callq 0x18490
nop
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/src/mustache-light.cpp
// Function: mustache::Mustache::getTemplateNameFromContext(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string Mustache::getTemplateNameFromContext(const string& key)
{
    json variable;
    try {
        variable = searchVariableInContext(key);
    } catch(const std::out_of_range& ex) {
        variable = nullptr;
    } catch(const std::invalid_argument& ex) {
        variable = nullptr;
    }

    if (variable.is_null()) {
        error("Missing template variable: " + key);
    } else if (!variable.is_string()) {
        error("Wrong template variable type: " + key + " must be a string");
    }

    return variable.get<string>();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq -0x30(%rbp), %r12
movb $0x0, (%r12)
movq $0x0, 0x8(%r12)
movq %r12, %rdi
movl $0x1, %esi
callq 0x17520
movq %r12, %rdi
movl $0x1, %esi
callq 0x17520
leaq -0x60(%rbp), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x17c10
leaq -0x30(%rbp), %rdi
leaq -0x60(%rbp), %r15
movq %r15, %rsi
callq 0x17540
movq %r15, %rdi
callq 0x17d50
movzbl -0x30(%rbp), %eax
cmpl $0x3, %eax
jne 0x1c5c1
leaq -0x30(%rbp), %rsi
movq %r14, %rdi
callq 0x18410
leaq -0x30(%rbp), %rdi
callq 0x17d50
movq %r14, %rax
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
testl %eax, %eax
jne 0x1c5e1
leaq 0x13841(%rip), %rsi     # 0x2fe0d
leaq -0x50(%rbp), %rdi
movq %rbx, %rdx
callq 0x17a50
leaq -0x50(%rbp), %rsi
callq 0x17e50
leaq 0x13841(%rip), %rsi     # 0x2fe29
leaq -0x80(%rbp), %rdi
movq %rbx, %rdx
callq 0x17a50
leaq 0x1384d(%rip), %rsi     # 0x2fe48
leaq -0x80(%rbp), %rdi
callq 0x18660
leaq -0x40(%rbp), %rbx
movq %rbx, -0x10(%rbx)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x1c623
movups (%rcx), %xmm0
movups %xmm0, (%rbx)
jmp 0x1c62e
movq %rdx, -0x50(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x40(%rbp)
movq 0x8(%rax), %rdx
leaq -0x50(%rbp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
callq 0x17e50
movq %rax, %r15
movq -0x50(%rbp), %rdi
cmpq %rbx, %rdi
je 0x1c664
callq 0x17ae0
jmp 0x1c664
movq %rax, %r15
leaq -0x70(%rbp), %rax
jmp 0x1c671
movq %rax, %r15
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1c688
callq 0x17ae0
jmp 0x1c688
jmp 0x1c685
jmp 0x1c685
movq %rax, %r15
leaq -0x30(%rbp), %rdi
callq 0x17d50
movq %r15, %rdi
callq 0x18490
movq %rax, %r15
cmpl $0x2, %edx
jne 0x1c6d8
movq %r15, %rdi
callq 0x173f0
leaq -0x90(%rbp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x17e00
leaq -0x30(%rbp), %rdi
movq %r15, %rsi
callq 0x17540
movq %r15, %rdi
callq 0x17d50
callq 0x18300
jmp 0x1c590
cmpl $0x1, %edx
jne 0x1c688
movq %r15, %rdi
callq 0x173f0
leaq -0xa0(%rbp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x17e00
leaq -0x30(%rbp), %rdi
movq %r15, %rsi
callq 0x17540
movq %r15, %rdi
callq 0x17d50
callq 0x18300
jmp 0x1c590
jmp 0x1c685
jmp 0x1c685
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/src/mustache-light.cpp
// Function: mustache::Mustache::split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, 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>>>>&)
vector<string>& Mustache::split(const string &str, char delim, vector<string> &elems) {
        std::stringstream ss(str);
        std::string item;
        while (std::getline(ss, item, delim)) {
                elems.push_back(item);
        }
        return elems;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rcx, %rbx
movl %edx, %r15d
leaq -0x1d0(%rbp), %r14
movq %r14, %rdi
movl $0x18, %edx
callq 0x18270
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
movsbl %r15b, %r15d
leaq -0x48(%rbp), %r12
movq %r14, %rdi
movq %r12, %rsi
movl %r15d, %edx
callq 0x185b0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x1d02c
movq %rbx, %rdi
movq %r12, %rsi
callq 0x174f0
jmp 0x1d003
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x1d03a
callq 0x17ae0
movq 0x1fe4f(%rip), %rsi     # 0x3ce90
leaq -0x1d0(%rbp), %rdi
callq 0x177b0
leaq -0x150(%rbp), %rdi
callq 0x172f0
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x1d07f
callq 0x17ae0
movq 0x1fe0a(%rip), %rsi     # 0x3ce90
leaq -0x1d0(%rbp), %rdi
callq 0x177b0
leaq -0x150(%rbp), %rdi
callq 0x172f0
movq %rbx, %rdi
callq 0x18490
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/src/./../third-party/json/single_include/nlohmann/json.hpp
// Function: nlohmann::json_abi_v3_11_2::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::find(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
iterator find(const typename object_t::key_type& key)
    {
        auto result = end();

        if (is_object())
        {
            result.m_it.object_iterator = m_value.object->find(key);
        }

        return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq %rax, 0x18(%rdi)
callq 0x17200
cmpb $0x1, (%r15)
jne 0x1dbac
movq %rbx, %r12
addq $0x8, %r12
movq 0x8(%r15), %rdi
movq %r14, %rsi
callq 0x18520
movq %rax, (%r12)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq