LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x240, %rsp            # imm = 0x240
callq 0x679f
movl %eax, %ebx
testl %eax, %eax
leaq 0x2d9a(%rip), %rax      # 0x1d8e8
leaq 0x2da3(%rip), %rsi      # 0x1d8f8
cmoveq %rax, %rsi
movq 0x10450(%rip), %rdi     # 0x2afb0
callq 0x62c0
movq %rax, %rdi
callq 0x6190
leaq -0x250(%rbp), %r14
movq %r14, %rdi
callq 0x64e0
leaq 0x2d84(%rip), %rsi      # 0x1d907
pushq $0x10
popq %rdx
movq %r14, %rdi
callq 0x6060
leaq 0x2d79(%rip), %rsi      # 0x1d90e
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x7aee
leaq 0x10b87(%rip), %rax     # 0x2b730
movq (%rax), %rsi
movq (%rsi), %rax
leaq -0x30(%rbp), %rdi
callq *0x10(%rax)
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x65c0
leaq -0x30(%rbp), %rdi
callq 0x6170
leaq -0x250(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x62a0
leaq -0x250(%rbp), %rdi
callq 0x6410
movq 0x103c1(%rip), %rdi     # 0x2afb0
leaq 0x2d5b(%rip), %rsi      # 0x1d951
callq 0x62c0
leaq 0x10b16(%rip), %rcx     # 0x2b718
movl (%rcx), %esi
movq %rax, %rdi
callq 0x6500
movq %rax, %rdi
callq 0x6190
leaq -0x50(%rbp), %rdi
callq 0x6170
leaq -0x250(%rbp), %rdi
callq 0x6450
movl %ebx, %eax
addq $0x240, %rsp            # imm = 0x240
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x6170
jmp 0x1ac51
jmp 0x1ac4e
jmp 0x1ac49
movq %rax, %rbx
jmp 0x1ac5a
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x6170
leaq -0x250(%rbp), %rdi
callq 0x6450
movq %rbx, %rdi
callq 0x6530
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rsi, %rbx
cmpl $0x2, %edi
jg 0xea1d
movq 0x125eb(%rip), %rdi     # 0x20fd8
leaq 0xa669(%rip), %rsi      # 0x1905d
callq 0xe2a0
movq (%rbx), %rsi
movq %rax, %rdi
callq 0xe2a0
leaq 0xa65a(%rip), %rsi      # 0x19065
movq %rax, %rdi
callq 0xe2a0
movq %rax, %rdi
callq 0xe120
jmp 0xea2a
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rsi
callq 0xe61c
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
leaq 0x20(%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 0x53b0
testl %eax, %eax
jne 0x6d15
movq 0x8(%rsp), %rax
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
testq %rax, %rax
je 0x6d4e
movq 0x18(%rax), %rsi
movl 0x4(%rax), %edi
addq $0x4, %rsi
leaq 0x10(%rsp), %r14
pushq $0x10
popq %rcx
movq %r14, %rdx
callq 0x5360
pushq $0xa
popq %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x7a79
movl %eax, %ebx
rolw $0x8, %bx
movq %r14, %rdi
callq 0x5320
shlq $0x20, %rax
shll $0x10, %ebx
addq %rbx, %rax
addq $0x2, %rax
xorl %edx, %edx
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl %eax, %ebp
movq 0xb2d2(%rip), %rdi      # 0x11ff0
leaq 0x436e(%rip), %rsi      # 0xb093
callq 0x5300
movq %rax, %rbx
movl %ebp, %edi
callq 0x5430
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5300
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0x5380
pushq $0x2
jmp 0x6d76
movq 0xb29b(%rip), %rdi      # 0x11ff0
leaq 0x4345(%rip), %rsi      # 0xb0a1
callq 0x5300
movq %rax, %rdi
movq %r14, %rsi
callq 0x52b0
movq %rax, %rdi
callq 0x5170
pushq $0x3
popq %rdi
callq 0x5390
// File: /workspace/github_cpp_makefile_star2_O2/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 %rax
movq %rsp, %rsi
movq $0xa, (%rsi)
callq 0x921e
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x1, %ecx
jne 0x7c10
movq 0xa3fa(%rip), %rdi      # 0x11ff0
leaq 0x353b(%rip), %rsi      # 0xb138
callq 0x5300
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0x5380
pushq $-0x1
popq %rax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
leaq 0x2e74(%rip), %r14      # 0x4048
movq 0x2dfd(%rip), %rbx      # 0x3fd8
pushq $0x5
popq %rbp
testq %r14, %r14
je 0x11fe
movq (%r14), %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x119c
movq %rax, %rdi
callq 0x1030
movq 0x8(%r14), %r14
jmp 0x11de
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xbe44(%rip), %eax      # 0xd100
xorl %ebp, %ebp
movq %rdi, %rcx
movzbl (%rcx), %edx
cmpl $0x7b, %edx
je 0x12de
cmpl $0x7d, %edx
je 0x12d4
testl %edx, %edx
jne 0x12e1
jmp 0x12e6
decl %eax
movl %eax, 0xbe24(%rip)      # 0xd100
jmp 0x12e1
movb $0x1, %bpl
incq %rcx
jmp 0x12c1
leaq 0x7d17(%rip), %r14      # 0x9004
xorl %r15d, %r15d
cmpl %eax, %r15d
jge 0x130a
movq %r14, %rdi
xorl %eax, %eax
callq 0x1030
incl %r15d
movl 0xbdf8(%rip), %eax      # 0xd100
jmp 0x12f0
testb $0x1, %bpl
je 0x1318
incl %eax
movl %eax, 0xbde8(%rip)      # 0xd100
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1150
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq 0xbdcc(%rip), %r14      # 0xd110
leaq 0x7cbc(%rip), %r15      # 0x9007
cmpq %r13, %r12
je 0x136f
movq (%r12), %rdx
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x1040
movq %r14, %rdi
callq 0x12ac
addq $0x20, %r12
jmp 0x134b
movq (%rbx), %rdx
leaq 0xbd97(%rip), %rbx      # 0xd110
leaq 0x7c94(%rip), %rsi      # 0x9014
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1040
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x12ac
// File: /workspace/github_cpp_makefile_star2_O2/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 0xbd64(%rip), %r14      # 0xd110
leaq 0x7c54(%rip), %rsi      # 0x9007
movq %r14, %rdi
xorl %eax, %eax
callq 0x1040
movq %r14, %rdi
callq 0x12ac
movq (%rbx), %rdx
leaq 0x7c45(%rip), %rsi      # 0x9014
movq %r14, %rdi
xorl %eax, %eax
callq 0x1040
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x12ac
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x78a5(%rip), %rdi      # 0x901e
callq 0x12ac
movq (%rbx), %rdx
leaq 0xb988(%rip), %r14      # 0xd110
leaq 0x79af(%rip), %rsi      # 0x913e
movq %r14, %rdi
xorl %eax, %eax
callq 0x1040
movq %r14, %rdi
callq 0x12ac
leaq 0x79a4(%rip), %rdi      # 0x914c
callq 0x12ac
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x1130
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq 0x1130
leaq 0x8(%rsp), %rbx
leaq 0x28(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x139b
movq %r14, %rdi
callq 0x1090
movq %rbx, %rdi
callq 0x1090
leaq 0x796b(%rip), %rdi      # 0x915e
callq 0x12ac
leaq 0x7972(%rip), %rdi      # 0x9171
callq 0x12ac
leaq 0x7853(%rip), %rbx      # 0x905e
movq %rbx, %rdi
callq 0x12ac
movq %rbx, %rdi
callq 0x12ac
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1090
movq %rbx, %rdi
callq 0x1170
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x77d5(%rip), %rdi      # 0x901e
callq 0x12ac
movq (%rbx), %rdx
leaq 0xb8b8(%rip), %r14      # 0xd110
leaq 0x792a(%rip), %rsi      # 0x9189
movq %r14, %rdi
xorl %eax, %eax
callq 0x1040
movq %r14, %rdi
callq 0x12ac
leaq 0x7922(%rip), %rdi      # 0x919a
callq 0x12ac
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x1130
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq 0x1130
leaq 0x8(%rsp), %rbx
leaq 0x28(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x139b
movq %r14, %rdi
callq 0x1090
movq %rbx, %rdi
callq 0x1090
leaq 0x78e5(%rip), %rdi      # 0x91a8
callq 0x12ac
leaq 0x78e7(%rip), %rdi      # 0x91b6
callq 0x12ac
leaq 0x7783(%rip), %rbx      # 0x905e
movq %rbx, %rdi
callq 0x12ac
movq %rbx, %rdi
callq 0x12ac
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1090
movq %rbx, %rdi
callq 0x1170
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x7705(%rip), %rdi      # 0x901e
callq 0x12ac
movq (%rbx), %rdx
leaq 0xb7e8(%rip), %r14      # 0xd110
leaq 0x7897(%rip), %rsi      # 0x91c6
movq %r14, %rdi
xorl %eax, %eax
callq 0x1040
movq %r14, %rdi
callq 0x12ac
leaq 0x788e(%rip), %rdi      # 0x91d6
callq 0x12ac
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x1130
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq 0x1130
leaq 0x8(%rsp), %rbx
leaq 0x28(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x139b
movq %r14, %rdi
callq 0x1090
movq %rbx, %rdi
callq 0x1090
leaq 0x76cb(%rip), %rdi      # 0x905e
callq 0x12ac
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1090
movq %rbx, %rdi
callq 0x1170
// File: /workspace/github_cpp_makefile_star2_O2/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, %r15
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r13
leaq 0x7642(%rip), %rdi      # 0x901e
callq 0x12ac
movq (%r13), %rdx
leaq 0xb724(%rip), %r13      # 0xd110
leaq 0x7633(%rip), %rsi      # 0x9026
movq %r13, %rdi
xorl %eax, %eax
callq 0x1040
movq %r13, %rdi
callq 0x12ac
leaq 0x77d7(%rip), %rdi      # 0x91e3
callq 0x12ac
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x1130
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x1130
movl 0x80(%rsp), %r14d
leaq 0x8(%rsp), %r12
leaq 0x28(%rsp), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x139b
movq %r13, %rdi
callq 0x1090
movq %r12, %rdi
callq 0x1090
leaq 0x7794(%rip), %rdi      # 0x91f3
callq 0x12ac
movq (%r15), %rdx
leaq 0xb6a2(%rip), %r15      # 0xd110
leaq 0x778e(%rip), %rsi      # 0x9203
movq %r15, %rdi
xorl %eax, %eax
callq 0x1040
movq %r15, %rdi
callq 0x12ac
leaq 0x762a(%rip), %rsi      # 0x90b8
movq %r15, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x1040
movq %r15, %rdi
callq 0x12ac
leaq 0x7639(%rip), %rsi      # 0x90e2
movq %r15, %rdi
movl %ebx, %edx
xorl %eax, %eax
callq 0x1040
movq %r15, %rdi
callq 0x12ac
testl %r14d, %r14d
je 0x1ae5
leaq 0xb647(%rip), %rbx      # 0xd110
leaq 0x75cc(%rip), %rsi      # 0x909c
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x1040
movq %rbx, %rdi
callq 0x12ac
leaq 0x7572(%rip), %rbx      # 0x905e
movq %rbx, %rdi
callq 0x12ac
movq %rbx, %rdi
callq 0x12ac
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1090
movq %rbx, %rdi
callq 0x1170
// File: /workspace/github_cpp_makefile_star2_O2/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 0x74e5(%rip), %rdi      # 0x901e
callq 0x12ac
movq (%r15), %rdx
leaq 0xb5c8(%rip), %r15      # 0xd110
leaq 0x74d7(%rip), %rsi      # 0x9026
movq %r15, %rdi
xorl %eax, %eax
callq 0x1040
movq %r15, %rdi
callq 0x12ac
leaq 0x76a4(%rip), %rdi      # 0x920c
callq 0x12ac
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x7f42
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x1130
leaq 0x8(%rsp), %rbx
leaq 0x20(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x132a
movq %r14, %rdi
callq 0x1090
movq %rbx, %rdi
callq 0x7f96
leaq 0x74ab(%rip), %rdi      # 0x905e
callq 0x12ac
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x7f96
movq %rbx, %rdi
callq 0x1170
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x2
popq %r14
leaq 0xb4b8(%rip), %rbx      # 0xd110
leaq 0x73ff(%rip), %r15      # 0x905e
leaq 0x7686(%rip), %rbp      # 0x92ec
movl %r14d, %r13d
subl $0x1, %r13d
jb 0x1dec
leaq 0x73a4(%rip), %rdi      # 0x901e
callq 0x12ac
leaq 0x7595(%rip), %rdi      # 0x921b
callq 0x12ac
leaq 0x7596(%rip), %rdi      # 0x9228
callq 0x12ac
leaq 0x7597(%rip), %rdi      # 0x9235
callq 0x12ac
leaq 0x7597(%rip), %rdi      # 0x9241
callq 0x12ac
leaq 0x7598(%rip), %rdi      # 0x924e
callq 0x12ac
cmpl $0x2, %r14d
leaq 0x7a29(%rip), %rdx      # 0x96ef
leaq 0x7595(%rip), %rax      # 0x9262
cmoveq %rax, %rdx
leaq 0x74ab(%rip), %r12      # 0x9183
leaq 0x7927(%rip), %rax      # 0x9606
cmoveq %rax, %r12
leaq 0x7ab6(%rip), %r14      # 0x97a0
leaq 0x7b1f(%rip), %rax      # 0x9810
cmoveq %rax, %r14
movq %rbx, %rdi
leaq 0x7559(%rip), %rsi      # 0x9258
xorl %eax, %eax
callq 0x1040
movq %rbx, %rdi
callq 0x12ac
movq %r15, %rdi
callq 0x12ac
leaq 0x754b(%rip), %rdi      # 0x9268
callq 0x12ac
movq %rbx, %rdi
leaq 0x754e(%rip), %rsi      # 0x927a
movq %r12, %rdx
xorl %eax, %eax
callq 0x1040
movq %rbx, %rdi
callq 0x12ac
movq %rbx, %rdi
leaq 0x753d(%rip), %rsi      # 0x9285
movl $0x12b, %edx            # imm = 0x12B
xorl %eax, %eax
callq 0x1040
movq %rbx, %rdi
callq 0x12ac
leaq 0x7530(%rip), %rdi      # 0x9293
callq 0x12ac
leaq 0x7534(%rip), %rdi      # 0x92a3
callq 0x12ac
leaq 0x7538(%rip), %rdi      # 0x92b3
callq 0x12ac
movq %r15, %rdi
callq 0x12ac
leaq 0x7534(%rip), %rdi      # 0x92c3
callq 0x12ac
movq %rbx, %rdi
leaq 0x7532(%rip), %rsi      # 0x92d0
movq %r14, %rdx
xorl %eax, %eax
callq 0x1040
movq %rbx, %rdi
callq 0x12ac
movq %rbx, %rdi
leaq 0x7523(%rip), %rsi      # 0x92dd
pushq $0x20
popq %rdx
xorl %eax, %eax
callq 0x1040
movq %rbx, %rdi
callq 0x12ac
movq %rbp, %rdi
callq 0x12ac
movq %r15, %rdi
callq 0x12ac
movq %r15, %rdi
callq 0x12ac
movl %r13d, %r14d
jmp 0x1c69
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/kazel1990[P]Inception-v4/generator.cpp
// Function: main
int main()
{
    freopen("train_val.prototxt","w",stdout);
    create_data();
    std::string res = create_stem("data");
    for(int i=1; i<=4; i++)
        res = inceptionA(res, i);
    res = reductionA(res);
    for(int i=1; i<=7; i++)
        res = inceptionB(res, i);
    res = reductionB(res);
    for(int i=1; i<=3; i++)
        res = inceptionC(res, i);
    create_loss(res);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x120, %rsp            # imm = 0x120
movq 0x52ff(%rip), %rax      # 0xcfd0
movq (%rax), %rdx
leaq 0x1a3e(%rip), %rdi      # 0x9719
leaq 0x1a4a(%rip), %rsi      # 0x972c
callq 0x1110
callq 0x1c42
leaq 0x1a3b(%rip), %rsi      # 0x972e
leaq 0xa0(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x7fb8
movq %rsp, %rdi
leaq 0xa0(%rsp), %rsi
callq 0x1dfb
leaq 0xa0(%rsp), %rdi
callq 0x1090
pushq $0x1
popq %rbx
leaq 0x100(%rsp), %r14
movq %rsp, %r15
leaq 0x20(%rsp), %r12
cmpl $0x5, %ebx
je 0x7d71
movq %r14, %rdi
movq %r15, %rsi
callq 0x1130
movq %r12, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x3062
movq %r15, %rdi
movq %r12, %rsi
callq 0x1120
movq %r12, %rdi
callq 0x1090
movq %r14, %rdi
callq 0x1090
incl %ebx
jmp 0x7d35
leaq 0x80(%rsp), %rdi
movq %rsp, %rsi
callq 0x1130
leaq 0x20(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x3d9b
movq %rsp, %rbx
leaq 0x20(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1120
movq %r14, %rdi
callq 0x1090
leaq 0x80(%rsp), %rdi
callq 0x1090
pushq $0x1
popq %rbp
leaq 0xe0(%rsp), %r15
cmpl $0x8, %ebp
je 0x7e02
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1130
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x4642
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1120
movq %r14, %rdi
callq 0x1090
movq %r15, %rdi
callq 0x1090
incl %ebp
jmp 0x7dc6
leaq 0x60(%rsp), %rdi
movq %rsp, %rsi
callq 0x1130
leaq 0x20(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x57a6
movq %rsp, %rbx
leaq 0x20(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1120
movq %r14, %rdi
callq 0x1090
leaq 0x60(%rsp), %rdi
callq 0x1090
pushq $0x1
popq %rbp
leaq 0xc0(%rsp), %r15
cmpl $0x4, %ebp
je 0x7e8a
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1130
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x633b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1120
movq %r14, %rdi
callq 0x1090
movq %r15, %rdi
callq 0x1090
incl %ebp
jmp 0x7e4e
leaq 0x40(%rsp), %rdi
movq %rsp, %rsi
callq 0x1130
leaq 0x40(%rsp), %rdi
callq 0x751a
leaq 0x40(%rsp), %rdi
callq 0x1090
movq %rsp, %rdi
callq 0x1090
xorl %eax, %eax
addq $0x120, %rsp            # imm = 0x120
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
jmp 0x7f2c
jmp 0x7f1c
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
jmp 0x7f2c
jmp 0x7f1c
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
jmp 0x7f2c
jmp 0x7f1c
movq %rax, %rbx
leaq 0xa0(%rsp), %rdi
jmp 0x7f34
movq %rax, %rbx
jmp 0x7f39
jmp 0x7f1c
movq %rax, %rbx
leaq 0xc0(%rsp), %rdi
jmp 0x7f2c
jmp 0x7f1c
movq %rax, %rbx
leaq 0xe0(%rsp), %rdi
jmp 0x7f2c
movq %rax, %rbx
jmp 0x7f31
movq %rax, %rbx
leaq 0x100(%rsp), %rdi
callq 0x1090
movq %rsp, %rdi
callq 0x1090
movq %rbx, %rdi
callq 0x1170
nop
// File: /workspace/github_cpp_makefile_star2_O2/ef-gy[P]libefgy/src/test-case/factorial.cpp
// Function: testFactorial(std::ostream&)
bool testFactorial(ostream &log) {
  if (factorial<int>(0) != 1) {
    log << "Factorial of 0 should be 1.";
    return false;
  }

  if (factorial<int>(1) != 1) {
    log << "Factorial of 1 should be 1.";
    return false;
  }

  if (factorial<int>(5) != 120) {
    log << "Factorial of 5 should be 120.";
    return false;
  }

  return true;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %rdi
andl $0x0, (%rdi)
callq 0x4c00
cmpl $0x1, %eax
jne 0x48fd
leaq 0x8(%rsp), %rdi
movl $0x1, (%rdi)
callq 0x4c00
cmpl $0x1, %eax
jne 0x4906
leaq 0x4(%rsp), %rdi
movl $0x5, (%rdi)
callq 0x4c00
movl %eax, %ecx
movb $0x1, %al
cmpl $0x78, %ecx
je 0x4917
leaq 0xd857(%rip), %rsi      # 0x12152
jmp 0x490d
leaq 0xd816(%rip), %rsi      # 0x1211a
jmp 0x490d
leaq 0xd829(%rip), %rsi      # 0x12136
movq %rbx, %rdi
callq 0x4260
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ef-gy[P]libefgy/include/ef.gy/factorial.h
// Function: efgy::math::factorial<int>::operator int() const
operator Z() const {
    Z rv = Z(1);

    for (Z n = Z(2); n <= integer; n++) {
      rv = rv * n;
    }

    return rv;
  }

// Assembly:
movl (%rdi), %ecx
pushq $0x2
popq %rdx
pushq $0x1
popq %rax
cmpl %ecx, %edx
jg 0x4c13
imull %edx, %eax
incl %edx
jmp 0x4c08
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x80(%rdi), %r14
movq %r14, %rdi
callq 0x276f0
leaq 0x60(%rbx), %rax
movq %rax, -0x30(%rbp)
andq $0x0, 0x68(%rbx)
movq 0x60(%rbx), %rax
xorl %r15d, %r15d
movb %r15b, (%rax)
leaq 0xd0(%rbx), %r12
movq %r12, %rdi
callq 0x262f0
andq $0x0, 0x98(%rbx)
leaq 0x90(%rbx), %r13
movq 0x90(%rbx), %rax
movb %r15b, (%rax)
leaq 0xf8(%rbx), %rdi
callq 0x25f40
movq %r12, %rdi
callq 0x25d90
leaq 0xb0(%rbx), %rdi
callq 0x27788
movq %r13, %rdi
callq 0x27788
movq %r14, %rdi
callq 0x26730
movq -0x30(%rbp), %rdi
callq 0x27788
leaq 0x40(%rbx), %rdi
callq 0x27788
leaq 0x20(%rbx), %rdi
callq 0x27788
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x27788
// File: /workspace/github_cpp_makefile_star2_O2/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 0x259e0
leaq 0x60(%r14), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x259e0
xorps %xmm0, %xmm0
leaq -0x50(%rbp), %rdx
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, (%rdx)
leaq -0x30(%rbp), %rdi
pushq $0x1
popq %rcx
movq %r12, %rsi
xorl %r8d, %r8d
callq 0x25420
leaq 0x80(%r14), %rdi
leaq -0x30(%rbp), %r15
movq %r15, %rsi
callq 0x259c0
movq %r15, %rdi
callq 0x26730
leaq -0x50(%rbp), %rdi
callq 0x25d10
movq %rbx, %rdi
movq %r14, %rsi
callq 0x25870
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %r12
movq %rax, %r15
leaq -0x50(%rbp), %rdi
callq 0x25d10
cmpl $0x2, %r12d
jne 0x27f77
movq %r15, %rdi
callq 0x25700
andq $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 0x27620
addq $0x90, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x26a70
jmp 0x27fc1
cmpl $0x1, %r12d
jne 0x27fdd
movq %r15, %rdi
callq 0x25700
andq $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 0x27620
addq $0x90, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x26a70
callq 0x270b0
jmp 0x27f0c
movq %rax, %r15
callq 0x270b0
jmp 0x27fdd
movq %rax, %r15
callq 0x270b0
movq %r15, %rdi
callq 0x27310
movq %rax, %rdi
callq 0x2aaa9
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x20, %rsp
movq %rsi, %r15
movq %rdi, %rbx
andq $0x0, 0xb8(%rsi)
leaq 0xb0(%rsi), %r14
movq 0xb0(%rsi), %rax
movb $0x0, (%rax)
leaq 0x40(%rsi), %rdx
leaq -0x38(%rbp), %r12
movq %r12, %rdi
callq 0x25210
leaq 0xd0(%r15), %rdi
movq %r12, %rsi
callq 0x26140
movq %r12, %rdi
callq 0x25d90
andq $0x0, 0xe8(%r15)
leaq 0xf8(%r15), %r12
movq 0x128(%r15), %rax
cmpq 0x108(%r15), %rax
je 0x2806c
movq %r12, %rdi
callq 0x26a60
jmp 0x28052
leaq 0x80(%r15), %rsi
movq %r12, %rdi
callq 0x26b20
movb $0x1, 0x148(%r15)
andq $0x0, 0x98(%r15)
leaq 0x90(%r15), %r12
movq 0x90(%r15), %rax
movb $0x0, (%rax)
movq %r15, %rdi
callq 0x259f0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x26a70
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
cmpl $0x1, %edx
jne 0x280fd
movq %r15, %rdi
callq 0x25700
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq %r14, %rdi
movq %rax, %rsi
callq 0x27620
movq %rbx, %rdi
movq %r12, %rsi
callq 0x26a70
callq 0x270b0
jmp 0x280af
movq %rax, %r15
callq 0x270b0
movq %r15, %rdi
callq 0x27310
movq %rax, %rdi
callq 0x2aaa9
nop
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/src/mustache-light.cpp
// Function: mustache::Mustache::fileRead(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::fileRead(const string& fileName, const string& fileExtension) {
        const string realFileName = basePath_ + fileName + "." + fileExtension;
        std::ifstream in(realFileName.c_str(), std::ios::in | std::ios::binary);
        if (in) {
                string contents;
                in.seekg(0, std::ios::end);
                contents.resize(in.tellg());
                in.seekg(0, std::ios::beg);
                in.read(&contents[0], contents.size());
                in.close();
                return (contents);
        }
        error("Cannot open file: " + realFileName);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x248, %rsp            # imm = 0x248
movq %rcx, %r14
movq %rdi, %rbx
leaq -0x38(%rbp), %r15
movq %r15, %rdi
callq 0x27680
leaq 0x14a29(%rip), %rdx     # 0x3ccb0
leaq -0x260(%rbp), %rdi
movq %r15, %rsi
callq 0x25300
leaq -0x58(%rbp), %rdi
leaq -0x260(%rbp), %rsi
movq %r14, %rdx
callq 0x26d40
leaq -0x260(%rbp), %rdi
callq 0x27788
leaq -0x38(%rbp), %rdi
callq 0x27788
movq -0x58(%rbp), %rsi
leaq -0x260(%rbp), %rdi
pushq $0xc
popq %rdx
callq 0x27430
movq -0x260(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x240(%rbp,%rax)
jne 0x28377
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
leaq -0x260(%rbp), %rdi
pushq $0x2
popq %rdx
xorl %esi, %esi
callq 0x26990
leaq -0x260(%rbp), %rdi
callq 0x27260
movq %rbx, %rdi
movq %rax, %rsi
callq 0x26a80
leaq -0x260(%rbp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x26990
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
leaq -0x260(%rbp), %rdi
callq 0x267e0
leaq -0x260(%rbp), %rdi
callq 0x252b0
leaq -0x260(%rbp), %rdi
callq 0x25380
leaq -0x58(%rbp), %rdi
callq 0x27788
movq %rbx, %rax
addq $0x248, %rsp            # imm = 0x248
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x148ec(%rip), %rsi     # 0x3cc6a
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rdx
callq 0x261d0
leaq -0x38(%rbp), %rsi
callq 0x26890
movq %rax, %r14
leaq -0x38(%rbp), %rdi
jmp 0x283c9
movq %rax, %r14
jmp 0x283ce
movq %rax, %r14
jmp 0x283da
movq %rax, %r14
leaq -0x260(%rbp), %rdi
callq 0x27788
jmp 0x283bb
movq %rax, %r14
leaq -0x38(%rbp), %rdi
jmp 0x283de
jmp 0x283c3
movq %rax, %r14
movq %rbx, %rdi
callq 0x27788
leaq -0x260(%rbp), %rdi
callq 0x25380
leaq -0x58(%rbp), %rdi
callq 0x27788
movq %r14, %rdi
callq 0x27310
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x28, %rsp
movq 0xd8(%rdi), %rax
subq 0xd0(%rdi), %rax
sarq $0x5, %rax
cmpq %rax, 0xe8(%rdi)
je 0x28a2c
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x26f50
movq 0xd8(%rbx), %rax
movq 0xe8(%rbx), %rsi
incq %rsi
movq %rsi, 0xe8(%rbx)
subq 0xd0(%rbx), %rax
sarq $0x5, %rax
cmpq %rax, %rsi
je 0x28a49
addq $0xd0, %rbx
movq %rbx, %rdi
callq 0x25490
movq 0x23467(%rip), %rsi     # 0x4be80
movq %rax, %rdi
callq 0x273f0
testb %al, %al
jne 0x28a66
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
leaq 0x14267(%rip), %rsi     # 0x3cc9a
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x25670
leaq -0x30(%rbp), %rsi
callq 0x26890
leaq 0x1424a(%rip), %rsi     # 0x3cc9a
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x25670
leaq -0x30(%rbp), %rsi
callq 0x26890
leaq 0x14251(%rip), %rsi     # 0x3ccbe
movq 0x2340c(%rip), %rdx     # 0x4be80
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x261d0
movq %rbx, %rsi
callq 0x26890
jmp 0x28a93
jmp 0x28a8e
jmp 0x28a93
movq %rax, %rbx
jmp 0x28a9f
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x27788
movq %rbx, %rdi
callq 0x27310
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x28, %rsp
movq 0xd8(%rdi), %rax
subq 0xd0(%rdi), %rax
sarq $0x5, %rax
cmpq %rax, 0xe8(%rdi)
je 0x28b27
movq %rdi, %rbx
xorl %esi, %esi
callq 0x26f50
movq 0xd8(%rbx), %rax
movq 0xe8(%rbx), %rsi
incq %rsi
movq %rsi, 0xe8(%rbx)
subq 0xd0(%rbx), %rax
sarq $0x5, %rax
cmpq %rax, %rsi
je 0x28b44
addq $0xd0, %rbx
movq %rbx, %rdi
callq 0x25490
movq 0x2343c(%rip), %rsi     # 0x4bf50
movq %rax, %rdi
callq 0x273f0
testb %al, %al
jne 0x28b61
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
leaq 0x1416c(%rip), %rsi     # 0x3cc9a
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x25670
leaq -0x30(%rbp), %rsi
callq 0x26890
leaq 0x1414f(%rip), %rsi     # 0x3cc9a
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x25670
leaq -0x30(%rbp), %rsi
callq 0x26890
leaq 0x14156(%rip), %rsi     # 0x3ccbe
movq 0x233e1(%rip), %rdx     # 0x4bf50
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x261d0
movq %rbx, %rsi
callq 0x26890
jmp 0x28b8e
jmp 0x28b89
jmp 0x28b8e
movq %rax, %rbx
jmp 0x28b9a
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x27788
movq %rbx, %rdi
callq 0x27310
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x28, %rsp
movq 0xd8(%rdi), %rax
movq 0xe8(%rdi), %rsi
subq 0xd0(%rdi), %rax
sarq $0x5, %rax
cmpq %rax, %rsi
je 0x28bfe
incq %rsi
movq %rsi, 0xe8(%rdi)
cmpq %rax, %rsi
je 0x28c1b
addq $0xd0, %rdi
callq 0x25490
movq 0x23295(%rip), %rsi     # 0x4be80
movq %rax, %rdi
callq 0x273f0
testb %al, %al
jne 0x28c38
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
leaq 0x14095(%rip), %rsi     # 0x3cc9a
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x25670
leaq -0x30(%rbp), %rsi
callq 0x26890
leaq 0x14078(%rip), %rsi     # 0x3cc9a
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x25670
leaq -0x30(%rbp), %rsi
callq 0x26890
leaq 0x1407f(%rip), %rsi     # 0x3ccbe
movq 0x2323a(%rip), %rdx     # 0x4be80
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x261d0
movq %rbx, %rsi
callq 0x26890
jmp 0x28c65
jmp 0x28c60
jmp 0x28c65
movq %rax, %rbx
jmp 0x28c71
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x27788
movq %rbx, %rdi
callq 0x27310
nop
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/src/mustache-light.cpp
// Function: mustache::Mustache::htmlEscape(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void Mustache::htmlEscape(string& data)
{
    std::string buffer;

	auto it = data.cbegin();
	while (it != data.cend()) {
		int sz = 1;
		const uint8_t tchar = *it;

        // From Wikipedia: https://en.wikipedia.org/wiki/UTF-8
        // U+0000  - U+007F   0xxxxxxx
        // U+0080  - U+07FF   110xxxxx  10xxxxxx
        // U+0800  - U+FFFF   1110xxxx  10xxxxxx  10xxxxxx
        // U+10000 - U+10FFFF 11110xxx  10xxxxxx  10xxxxxx  10xxxxxx
		if ((tchar & 0x80) == 0x80) {
            // Multi-byte UTF-8 character
            if ((tchar & 0xC0) == 0xC0) {
                // 2-byte UTF-8 character
                // 110xxxxx
                sz = 2;
            } else if ((tchar & 0xE0) == 0xE0) {
                sz = 3; // 3-byte UTF-8 character
            } else if ((tchar & 0xF8) == 0xF8) {
                sz = 4; // 4-byte UTF-8 character
            }
			for (int cnt = 0; cnt < sz; ++cnt) {
				buffer.push_back(*it++);
			}
		} else { // single-byte character
			switch (tchar) {
			case '&':	buffer.append("&amp;");		break;
			case '\"':	buffer.append("&quot;");	break;
			case '\'':	buffer.append("&apos;");	break;
			case '<':	buffer.append("&lt;");		break;
			case '>':	buffer.append("&gt;");		break;
			case '%':	buffer.append("&percnt;");	break;
			default:
				if (! std::iscntrl(tchar)) {
					buffer.push_back(tchar);
				}
				break;
			}
			++it;
		}
	}
	data.swap(buffer);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movq %rsi, %rbx
movb $0x0, (%rax)
movq (%rsi), %rax
leaq -0x48(%rbp), %r14
leaq 0x12086(%rip), %r13     # 0x3c040
movq %rax, %r12
addq 0x8(%rbx), %rax
cmpq %rax, %r12
je 0x2a082
movzbl (%r12), %r15d
testb %r15b, %r15b
js 0x29ff7
leal -0x22(%r15), %eax
cmpl $0x5, %eax
ja 0x2a027
movslq (%r13,%rax,4), %rax
addq %r13, %rax
leaq 0x12ea0(%rip), %rsi     # 0x3ce8c
jmpq *%rax
leaq 0x12eaf(%rip), %rsi     # 0x3cea4
jmp 0x2a06f
notl %r15d
andl $0xc0, %r15d
cmpl $0x1, %r15d
movl $0x0, %r15d
adcl $0x1, %r15d
subl $0x1, %r15d
jb 0x2a07a
movsbl (%r12), %esi
movq %r14, %rdi
callq 0x260f0
incq %r12
jmp 0x2a00f
cmpl $0x3c, %r15d
je 0x2a068
cmpl $0x3e, %r15d
jne 0x2a03c
leaq 0x12e65(%rip), %rsi     # 0x3ce9f
jmp 0x2a06f
movl %r15d, %edi
callq 0x26c80
testl %eax, %eax
jne 0x2a077
movsbl %r15b, %esi
movq %r14, %rdi
callq 0x260f0
jmp 0x2a077
leaq 0x12e36(%rip), %rsi     # 0x3ce93
jmp 0x2a06f
leaq 0x12e20(%rip), %rsi     # 0x3ce86
jmp 0x2a06f
leaq 0x12e2b(%rip), %rsi     # 0x3ce9a
movq %r14, %rdi
callq 0x27600
incq %r12
movq (%rbx), %rax
jmp 0x29fbd
leaq -0x48(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x25d50
movq %r14, %rdi
callq 0x27788
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2a0aa
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x27788
movq %rbx, %rdi
callq 0x27310
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x88, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x26800
leaq -0x58(%rbp), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x264e0
leaq -0x28(%rbp), %rdi
leaq -0x58(%rbp), %r15
movq %r15, %rsi
callq 0x259c0
movq %r15, %rdi
callq 0x26730
movzbl -0x28(%rbp), %eax
cmpl $0x3, %eax
jne 0x2a176
leaq -0x28(%rbp), %rsi
movq %r14, %rdi
callq 0x27210
leaq -0x28(%rbp), %rdi
callq 0x26730
movq %r14, %rax
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
testl %eax, %eax
jne 0x2a196
leaq 0x12c7d(%rip), %rsi     # 0x3cdfe
leaq -0x48(%rbp), %rdi
movq %rbx, %rdx
callq 0x261d0
leaq -0x48(%rbp), %rsi
callq 0x26890
leaq 0x12c7d(%rip), %rsi     # 0x3ce1a
leaq -0x78(%rbp), %rdi
movq %rbx, %rdx
callq 0x261d0
leaq 0x12c89(%rip), %rdx     # 0x3ce39
leaq -0x48(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x25300
leaq -0x48(%rbp), %rsi
callq 0x26890
movq %rax, %r15
leaq -0x48(%rbp), %rdi
callq 0x27788
jmp 0x2a1d7
movq %rax, %r15
leaq -0x78(%rbp), %rdi
jmp 0x2a1e4
movq %rax, %r15
leaq -0x48(%rbp), %rdi
callq 0x27788
jmp 0x2a1f2
jmp 0x2a1ef
jmp 0x2a1ef
movq %rax, %r15
leaq -0x28(%rbp), %rdi
callq 0x26730
movq %r15, %rdi
callq 0x27310
movq %rax, %r15
cmpl $0x2, %edx
jne 0x2a242
movq %r15, %rdi
callq 0x25700
leaq -0x88(%rbp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x26800
leaq -0x28(%rbp), %rdi
movq %r15, %rsi
callq 0x259c0
movq %r15, %rdi
callq 0x26730
callq 0x270b0
jmp 0x2a147
cmpl $0x1, %edx
jne 0x2a1f2
movq %r15, %rdi
callq 0x25700
leaq -0x98(%rbp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x26800
leaq -0x28(%rbp), %rdi
movq %r15, %rsi
callq 0x259c0
movq %r15, %rdi
callq 0x26730
callq 0x270b0
jmp 0x2a147
jmp 0x2a1ef
jmp 0x2a1ef
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rcx, %rbx
movl %edx, %r15d
leaq -0x1c8(%rbp), %r14
pushq $0x18
popq %rdx
movq %r14, %rdi
callq 0x26fe0
leaq -0x30(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movsbl %r15b, %r15d
leaq -0x40(%rbp), %r12
movq %r14, %rdi
movq %r12, %rsi
movl %r15d, %edx
callq 0x274b0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x2a805
movq %rbx, %rdi
movq %r12, %rsi
callq 0x25920
jmp 0x2a7dc
leaq -0x40(%rbp), %rdi
callq 0x27788
leaq -0x1c8(%rbp), %rdi
callq 0x25e20
movq %rbx, %rax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x27788
leaq -0x1c8(%rbp), %rdi
callq 0x25e20
movq %rbx, %rdi
callq 0x27310
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x25970
cmpb $0x1, (%r15)
jne 0x2b332
movq 0x8(%r15), %rdi
movq %r14, %rsi
callq 0x273d0
movq %rax, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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>::operator[](unsigned long) const
const_reference operator[](size_type idx) const
    {
        // const operator[] only works for arrays
        if (JSON_HEDLEY_LIKELY(is_array()))
        {
            return m_value.array->operator[](idx);
        }

        JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a numeric argument with ", type_name()), this));
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
cmpb $0x2, (%rdi)
jne 0x2b798
movq 0x8(%r14), %rax
shlq $0x4, %rsi
addq (%rax), %rsi
movq %rsi, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x25840
movq %rax, %rbx
movq %r14, %rdi
callq 0x25fb0
leaq -0x20(%rbp), %rdx
movq %rax, (%rdx)
leaq 0x16312(%rip), %rsi     # 0x41acb
leaq -0x40(%rbp), %rdi
callq 0x271e0
movb $0x1, %r15b
leaq -0x40(%rbp), %rdx
movq %rbx, %rdi
movl $0x131, %esi            # imm = 0x131
movq %r14, %rcx
callq 0x27100
xorl %r15d, %r15d
movq 0x206f5(%rip), %rsi     # 0x4bed8
movq 0x206f6(%rip), %rdx     # 0x4bee0
movq %rbx, %rdi
callq 0x27240
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x27788
testb %r15b, %r15b
jne 0x2b808
jmp 0x2b810
movq %rax, %r14
movq %rbx, %rdi
callq 0x25d70
movq %r14, %rdi
callq 0x27310