LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Azer0s[P]littl/bin/../src/tree/base/variable.hpp
// Function: littl::Variable::toCode[abi:cxx11]() const
virtual std::string toCode() const{
                std::string x; 
                if(constant){
                    x = "const ";
                }else{
                    x = "var ";
                }
                x += varname->toCode() + " = " + value->toCode() + ";\n";
                return x;
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0xe0(%rbp)
movq %rdi, %rax
movq %rax, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xd0(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x7590
movq -0xd0(%rbp), %rax
testb $0x1, 0x10(%rax)
je 0x35a1d
movq -0xe0(%rbp), %rdi
leaq 0x10f8c(%rip), %rsi     # 0x4698f
callq 0x7580
jmp 0x35a0a
jmp 0x35a34
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x35ba9
movq -0xe0(%rbp), %rdi
leaq 0x10f6b(%rip), %rsi     # 0x46996
callq 0x7580
jmp 0x35a32
jmp 0x35a34
movq -0xd0(%rbp), %rax
movq 0x8(%rax), %rsi
movq (%rsi), %rax
movq 0x10(%rax), %rax
leaq -0xa8(%rbp), %rdi
callq *%rax
jmp 0x35a51
leaq 0x10f43(%rip), %rdx     # 0x4699b
leaq -0x88(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0xcf30
jmp 0x35a6d
movq -0xd0(%rbp), %rax
movq 0x18(%rax), %rsi
movq (%rsi), %rax
movq 0x10(%rax), %rax
leaq -0xc8(%rbp), %rdi
callq *%rax
jmp 0x35a8a
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rsi
leaq -0xc8(%rbp), %rdx
callq 0xd0e0
jmp 0x35aa3
leaq 0x10600(%rip), %rdx     # 0x460aa
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0xcf30
jmp 0x35ab9
movq -0xe0(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x7530
jmp 0x35acb
leaq -0x48(%rbp), %rdi
callq 0x72a0
leaq -0x68(%rbp), %rdi
callq 0x72a0
leaq -0xc8(%rbp), %rdi
callq 0x72a0
leaq -0x88(%rbp), %rdi
callq 0x72a0
leaq -0xa8(%rbp), %rdi
callq 0x72a0
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x35b99
jmp 0x35b8d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x35b7f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x35b73
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x35b67
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x35b5e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x72a0
leaq -0x68(%rbp), %rdi
callq 0x72a0
leaq -0xc8(%rbp), %rdi
callq 0x72a0
leaq -0x88(%rbp), %rdi
callq 0x72a0
leaq -0xa8(%rbp), %rdi
callq 0x72a0
jmp 0x35ba9
movq -0xe0(%rbp), %rdi
callq 0x72a0
movq -0xd8(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
movq -0xe0(%rbp), %rdi
callq 0x72a0
movq -0x20(%rbp), %rdi
callq 0x7740
nop
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x2dd65(%rip), %rcx     # 0x649c0
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x36c7a
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x36c96
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x36cb2
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x36cce
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rdi
callq 0xc180
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x2d755(%rip), %rcx     # 0x64a40
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x3730a
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x37326
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x37342
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x3735e
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rdi
callq 0xc180
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: Azer0s[P]littl/bin/lex.yy.c
// Function: yy_try_NUL_trans(int)
static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
{
	int yy_is_jam;
    	char *yy_cp = (yy_c_buf_p);

	YY_CHAR yy_c = 1;
	if ( yy_accept[yy_current_state] )
		{
		(yy_last_accepting_state) = yy_current_state;
		(yy_last_accepting_cpos) = yy_cp;
		}
	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
		{
		yy_current_state = (int) yy_def[yy_current_state];
		if ( yy_current_state >= 87 )
			yy_c = yy_meta[yy_c];
		}
	yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
	yy_is_jam = (yy_current_state == 86);

		return yy_is_jam ? 0 : yy_current_state;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq 0x2244a(%rip), %rax     # 0x65908
movq %rax, -0x10(%rbp)
movb $0x1, -0x11(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x3f2f(%rip), %rax      # 0x47400
cmpw $0x0, (%rax,%rcx,2)
je 0x434ec
movl -0x4(%rbp), %eax
movl %eax, 0x22433(%rip)     # 0x65914
movq -0x10(%rbp), %rax
movq %rax, 0x2242c(%rip)     # 0x65918
jmp 0x434ee
movslq -0x4(%rbp), %rcx
leaq 0x40e7(%rip), %rax      # 0x475e0
movswl (%rax,%rcx,2), %eax
movzbl -0x11(%rbp), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0x3fa3(%rip), %rax      # 0x474b0
movswl (%rax,%rcx,2), %eax
cmpl -0x4(%rbp), %eax
je 0x43543
movslq -0x4(%rbp), %rcx
leaq 0x417f(%rip), %rax      # 0x476a0
movswl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
cmpl $0x57, -0x4(%rbp)
jl 0x43541
movzbl -0x11(%rbp), %eax
movl %eax, %ecx
leaq 0x4225(%rip), %rax      # 0x47760
movb (%rax,%rcx), %al
movb %al, -0x11(%rbp)
jmp 0x434ee
movslq -0x4(%rbp), %rcx
leaq 0x4092(%rip), %rax      # 0x475e0
movswl (%rax,%rcx,2), %eax
movzbl -0x11(%rbp), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0x422e(%rip), %rax      # 0x47790
movswl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
cmpl $0x56, -0x4(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0x43585
xorl %eax, %eax
movl %eax, -0x18(%rbp)
jmp 0x4358b
movl -0x4(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
popq %rbp
retq
// File: 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
subq $0x280, %rsp            # imm = 0x280
movl $0x0, -0x4(%rbp)
callq 0x7a20
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x44614
movq 0x209b1(%rip), %rdi     # 0x64fa8
leaq 0x3512(%rip), %rsi      # 0x47b10
callq 0x73e0
movq %rax, %rdi
movq 0x2095b(%rip), %rsi     # 0x64f68
callq 0x7430
jmp 0x44636
movq 0x2098d(%rip), %rdi     # 0x64fa8
leaq 0x34fe(%rip), %rsi      # 0x47b20
callq 0x73e0
movq %rax, %rdi
movq 0x20937(%rip), %rsi     # 0x64f68
callq 0x7430
leaq -0x208(%rbp), %rdi
movq %rdi, -0x268(%rbp)
callq 0x76d0
movq -0x268(%rbp), %rdi
leaq 0x34d8(%rip), %rsi      # 0x47b2f
movl $0x10, %edx
callq 0x7090
jmp 0x44663
leaq -0x239(%rbp), %rdi
movq %rdi, -0x270(%rbp)
callq 0x7750
movq -0x270(%rbp), %rdx
leaq 0x34b2(%rip), %rsi      # 0x47b36
leaq -0x238(%rbp), %rdi
callq 0xb050
jmp 0x44692
leaq -0x239(%rbp), %rdi
callq 0x7460
leaq 0x211ab(%rip), %rax     # 0x65850
movq (%rax), %rsi
movq (%rsi), %rax
movq 0x10(%rax), %rax
leaq -0x260(%rbp), %rdi
callq *%rax
jmp 0x446ba
leaq -0x238(%rbp), %rdi
leaq -0x260(%rbp), %rsi
callq 0x7530
jmp 0x446cf
leaq -0x260(%rbp), %rdi
callq 0x72a0
leaq -0x208(%rbp), %rdi
leaq -0x238(%rbp), %rsi
callq 0x73b0
jmp 0x446f0
leaq -0x208(%rbp), %rdi
callq 0x75c0
jmp 0x446fe
movq 0x208a3(%rip), %rdi     # 0x64fa8
leaq 0x346d(%rip), %rsi      # 0x47b79
callq 0x73e0
movq %rax, -0x278(%rbp)
jmp 0x4471a
movq -0x278(%rbp), %rdi
leaq 0x21110(%rip), %rax     # 0x65838
movl (%rax), %esi
callq 0x7710
movq %rax, -0x280(%rbp)
jmp 0x44738
movq -0x280(%rbp), %rdi
movq 0x20822(%rip), %rsi     # 0x64f68
callq 0x7430
jmp 0x4474d
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
leaq -0x238(%rbp), %rdi
callq 0x72a0
leaq -0x208(%rbp), %rdi
callq 0x7610
movl -0x4(%rbp), %eax
addq $0x280, %rsp            # imm = 0x280
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x210(%rbp)
movl %eax, -0x214(%rbp)
jmp 0x447e9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x210(%rbp)
movl %eax, -0x214(%rbp)
leaq -0x239(%rbp), %rdi
callq 0x7460
jmp 0x447e9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x210(%rbp)
movl %eax, -0x214(%rbp)
jmp 0x447dd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x210(%rbp)
movl %eax, -0x214(%rbp)
leaq -0x260(%rbp), %rdi
callq 0x72a0
leaq -0x238(%rbp), %rdi
callq 0x72a0
leaq -0x208(%rbp), %rdi
callq 0x7610
movq -0x210(%rbp), %rdi
callq 0x7740
// File: 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:
subq $0x18, %rsp
movl $0x0, 0x14(%rsp)
movl %edi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpl $0x3, 0x10(%rsp)
jge 0x24027
movq 0x27ff5(%rip), %rdi     # 0x4bfd8
leaq 0x1c073(%rip), %rsi     # 0x4005d
callq 0x23320
movq %rax, %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rsi
callq 0x23320
movq %rax, %rdi
leaq 0x1c05c(%rip), %rsi     # 0x40065
callq 0x23320
movq %rax, %rdi
movq 0x27fa0(%rip), %rsi     # 0x4bfb8
callq 0x23380
movl $0x0, 0x14(%rsp)
jmp 0x24046
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x237c0
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x98(%rbp)
movq %rsi, -0x90(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x51f0
movq -0x98(%rbp), %rdi
movl $0x2, -0x4c(%rbp)
movl $0x1, -0x48(%rbp)
movl $0x0, -0x5c(%rbp)
callq 0x5150
movq -0x90(%rbp), %rdi
movq %rax, -0x88(%rbp)
callq 0x5150
movq -0x88(%rbp), %rdi
movq %rax, %rsi
leaq -0x50(%rbp), %rdx
leaq -0x58(%rbp), %rcx
callq 0x54a0
movl %eax, -0x5c(%rbp)
cmpl $0x0, %eax
je 0x912c
movq 0x1df05(%rip), %rdi     # 0x26ff0
leaq 0x10025(%rip), %rsi     # 0x19117
callq 0x5390
movq %rax, -0xa0(%rbp)
movl -0x5c(%rbp), %edi
callq 0x5540
movq -0xa0(%rbp), %rdi
movq %rax, %rsi
callq 0x5390
movq %rax, %rdi
movl $0xa, %esi
callq 0x5460
movl $0x2, %edi
callq 0x5470
movq -0x58(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x80(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x51f0
cmpq $0x0, -0x68(%rbp)
je 0x9176
movq -0x68(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x68(%rbp), %rax
movl 0x4(%rax), %edi
movq -0x70(%rbp), %rsi
addq $0x4, %rsi
leaq -0x80(%rbp), %rdx
movl $0x10, %ecx
callq 0x5410
jmp 0x91b1
movq 0x1de73(%rip), %rdi     # 0x26ff0
leaq 0xffa1(%rip), %rsi      # 0x19125
callq 0x5390
movq -0x98(%rbp), %rsi
movq %rax, %rdi
callq 0x5330
movq %rax, %rdi
movq 0x1ddc6(%rip), %rsi     # 0x26f68
callq 0x53f0
movl $0x3, %edi
callq 0x5470
movq -0x90(%rbp), %rdi
movw $0x2, -0x10(%rbp)
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0xa960
movzwl %ax, %edi
callq 0x5070
movw %ax, -0xe(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x53b0
movl %eax, -0xc(%rbp)
movq $0x0, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq 0xea75(%rip), %rax      # 0x19608
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x10d20
cmpl $0x1, %eax
jne 0xabd2
movq 0x1c440(%rip), %rdi     # 0x26ff0
leaq 0xe605(%rip), %rsi      # 0x191bc
callq 0x5390
movq %rax, %rdi
movl $0xa, %esi
callq 0x5460
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xabd9
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
leaq 0x2e12(%rip), %rax      # 0x4048
movq %rax, -0x10(%rbp)
leaq 0x2e07(%rip), %rdi      # 0x4048
callq 0x12c0
movq %rax, -0x18(%rbp)
leaq 0x2df7(%rip), %rdi      # 0x4048
callq 0x12f0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x1320
testb $0x1, %al
jne 0x126d
jmp 0x12a9
leaq -0x18(%rbp), %rdi
callq 0x1350
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdx
movq 0x2d53(%rip), %rdi      # 0x3fd8
movl $0x5, %esi
callq 0x11b0
movq %rax, %rdi
movq 0x2d2f(%rip), %rsi      # 0x3fc8
callq 0x1050
leaq -0x18(%rbp), %rdi
callq 0x1370
jmp 0x125a
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x23d7
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x7b, %eax
jne 0x23aa
movb $0x1, -0x9(%rbp)
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x7d, %eax
jne 0x23ca
movl 0xed9f(%rip), %eax      # 0x11160
addl $-0x1, %eax
movl %eax, 0xed96(%rip)      # 0x11160
jmp 0x23cc
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2387
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl 0xed79(%rip), %eax      # 0x11160
jge 0x2402
leaq 0xac14(%rip), %rdi      # 0xd004
movb $0x0, %al
callq 0x2040
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x23de
testb $0x1, -0x9(%rbp)
je 0x2417
movl 0xed52(%rip), %eax      # 0x11160
addl $0x1, %eax
movl %eax, 0xed49(%rip)      # 0x11160
movq -0x8(%rbp), %rdi
callq 0x2200
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xb5b0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0xb5e0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xb610
testb $0x1, %al
jne 0x2475
jmp 0x24ba
leaq -0x20(%rbp), %rdi
callq 0xb650
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x20a0
movq %rax, %rdx
leaq 0xecdb(%rip), %rdi      # 0x11170
leaq 0xab6b(%rip), %rsi      # 0xd007
movb $0x0, %al
callq 0x2060
leaq 0xecc6(%rip), %rdi      # 0x11170
callq 0x2370
leaq -0x20(%rbp), %rdi
callq 0xb670
jmp 0x2462
movq -0x38(%rbp), %rdi
callq 0x20a0
movq %rax, %rdx
leaq 0xeca3(%rip), %rdi      # 0x11170
leaq 0xab40(%rip), %rsi      # 0xd014
movb $0x0, %al
callq 0x2060
leaq 0xec8e(%rip), %rdi      # 0x11170
callq 0x2370
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x20a0
movq %rax, %rdx
leaq 0xec5d(%rip), %rdi      # 0x11170
leaq 0xaaed(%rip), %rsi      # 0xd007
movb $0x0, %al
callq 0x2060
leaq 0xec48(%rip), %rdi      # 0x11170
callq 0x2370
movq -0x18(%rbp), %rdi
callq 0x20a0
movq %rax, %rdx
leaq 0xec30(%rip), %rdi      # 0x11170
leaq 0xaacd(%rip), %rsi      # 0xd014
movb $0x0, %al
callq 0x2060
leaq 0xec1b(%rip), %rdi      # 0x11170
callq 0x2370
addq $0x20, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
leaq 0xa647(%rip), %rdi      # 0xd01e
callq 0x2370
movq -0x60(%rbp), %rdi
callq 0x20a0
movq %rax, %rdx
leaq 0xe781(%rip), %rdi      # 0x11170
movq %rdi, -0x68(%rbp)
leaq 0xa744(%rip), %rsi      # 0xd13e
xorl %eax, %eax
callq 0x2060
movq -0x68(%rbp), %rdi
callq 0x2370
leaq 0xa73b(%rip), %rdi      # 0xd14c
callq 0x2370
movq -0x60(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x20b0
movq -0x60(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x20b0
jmp 0x2a32
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x24f0
jmp 0x2a41
leaq -0x48(%rbp), %rdi
callq 0x20e0
leaq -0x28(%rbp), %rdi
callq 0x20e0
leaq 0xa704(%rip), %rdi      # 0xd15e
callq 0x2370
leaq 0xa70b(%rip), %rdi      # 0xd171
callq 0x2370
leaq 0xa5ec(%rip), %rdi      # 0xd05e
callq 0x2370
leaq 0xa5e0(%rip), %rdi      # 0xd05e
callq 0x2370
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x2aac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x20e0
leaq -0x28(%rbp), %rdi
callq 0x20e0
movq -0x50(%rbp), %rdi
callq 0x2220
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
leaq 0xa547(%rip), %rdi      # 0xd01e
callq 0x2370
movq -0x60(%rbp), %rdi
callq 0x20a0
movq %rax, %rdx
leaq 0xe681(%rip), %rdi      # 0x11170
movq %rdi, -0x68(%rbp)
leaq 0xa68f(%rip), %rsi      # 0xd189
xorl %eax, %eax
callq 0x2060
movq -0x68(%rbp), %rdi
callq 0x2370
leaq 0xa689(%rip), %rdi      # 0xd19a
callq 0x2370
movq -0x60(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x20b0
movq -0x60(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x20b0
jmp 0x2b32
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x24f0
jmp 0x2b41
leaq -0x48(%rbp), %rdi
callq 0x20e0
leaq -0x28(%rbp), %rdi
callq 0x20e0
leaq 0xa64e(%rip), %rdi      # 0xd1a8
callq 0x2370
leaq 0xa650(%rip), %rdi      # 0xd1b6
callq 0x2370
leaq 0xa4ec(%rip), %rdi      # 0xd05e
callq 0x2370
leaq 0xa4e0(%rip), %rdi      # 0xd05e
callq 0x2370
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x2bac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x20e0
leaq -0x28(%rbp), %rdi
callq 0x20e0
movq -0x50(%rbp), %rdi
callq 0x2220
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
leaq 0xa447(%rip), %rdi      # 0xd01e
callq 0x2370
movq -0x60(%rbp), %rdi
callq 0x20a0
movq %rax, %rdx
leaq 0xe581(%rip), %rdi      # 0x11170
movq %rdi, -0x68(%rbp)
leaq 0xa5cc(%rip), %rsi      # 0xd1c6
xorl %eax, %eax
callq 0x2060
movq -0x68(%rbp), %rdi
callq 0x2370
leaq 0xa5c5(%rip), %rdi      # 0xd1d6
callq 0x2370
movq -0x60(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x20b0
movq -0x60(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x20b0
jmp 0x2c32
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x24f0
jmp 0x2c41
leaq -0x48(%rbp), %rdi
callq 0x20e0
leaq -0x28(%rbp), %rdi
callq 0x20e0
leaq 0xa404(%rip), %rdi      # 0xd05e
callq 0x2370
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x2c88
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x20e0
leaq -0x28(%rbp), %rdi
callq 0x20e0
movq -0x50(%rbp), %rdi
callq 0x2220
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rcx, -0xa0(%rbp)
movq %rdx, -0x80(%rbp)
movq %rsi, -0x88(%rbp)
movq %rdi, -0x98(%rbp)
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
leaq 0xa338(%rip), %rdi      # 0xd01e
callq 0x2370
movq -0x98(%rbp), %rdi
callq 0x20a0
movq %rax, %rdx
leaq 0xe46f(%rip), %rdi      # 0x11170
movq %rdi, -0x90(%rbp)
leaq 0xa317(%rip), %rsi      # 0xd026
xorl %eax, %eax
callq 0x2060
movq -0x90(%rbp), %rdi
callq 0x2370
leaq 0xa4ba(%rip), %rdi      # 0xd1e3
callq 0x2370
movq -0x88(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x20b0
movq -0x80(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x20b0
jmp 0x2d4d
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x24f0
jmp 0x2d5c
leaq -0x68(%rbp), %rdi
callq 0x20e0
leaq -0x48(%rbp), %rdi
callq 0x20e0
leaq 0xa47e(%rip), %rdi      # 0xd1f3
callq 0x2370
movq -0xa0(%rbp), %rdi
callq 0x20a0
movq %rax, %rdx
leaq 0xe3e0(%rip), %rdi      # 0x11170
leaq 0xa46c(%rip), %rsi      # 0xd203
movb $0x0, %al
callq 0x2060
leaq 0xe3cb(%rip), %rdi      # 0x11170
callq 0x2370
movl -0x24(%rbp), %edx
leaq 0xe3bc(%rip), %rdi      # 0x11170
leaq 0xa2fd(%rip), %rsi      # 0xd0b8
movb $0x0, %al
callq 0x2060
leaq 0xe3a7(%rip), %rdi      # 0x11170
callq 0x2370
movl -0x28(%rbp), %edx
leaq 0xe398(%rip), %rdi      # 0x11170
leaq 0xa303(%rip), %rsi      # 0xd0e2
movb $0x0, %al
callq 0x2060
leaq 0xe383(%rip), %rdi      # 0x11170
callq 0x2370
cmpl $0x0, 0x10(%rbp)
je 0x2e4c
movl 0x10(%rbp), %edx
leaq 0xe36e(%rip), %rdi      # 0x11170
leaq 0xa293(%rip), %rsi      # 0xd09c
movb $0x0, %al
callq 0x2060
leaq 0xe359(%rip), %rdi      # 0x11170
callq 0x2370
jmp 0x2e4c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x2e41
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x20e0
leaq -0x48(%rbp), %rdi
callq 0x20e0
jmp 0x2e6d
leaq 0xa20b(%rip), %rdi      # 0xd05e
callq 0x2370
leaq 0xa1ff(%rip), %rdi      # 0xd05e
callq 0x2370
addq $0xa0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x2220
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x80(%rbp)
movq %rsi, -0x70(%rbp)
movq %rdx, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0xa174(%rip), %rdi      # 0xd01e
callq 0x2370
movq -0x80(%rbp), %rdi
callq 0x20a0
movq %rax, %rdx
leaq 0xe2ae(%rip), %rdi      # 0x11170
movq %rdi, -0x78(%rbp)
leaq 0xa159(%rip), %rsi      # 0xd026
xorl %eax, %eax
callq 0x2060
movq -0x78(%rbp), %rdi
callq 0x2370
leaq 0xa328(%rip), %rdi      # 0xd20c
callq 0x2370
movq -0x70(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0xb690
movq -0x68(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x20b0
jmp 0x2f05
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x2430
jmp 0x2f14
leaq -0x50(%rbp), %rdi
callq 0x20e0
leaq -0x30(%rbp), %rdi
callq 0xb780
leaq 0xa131(%rip), %rdi      # 0xd05e
callq 0x2370
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x2f5e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x20e0
leaq -0x30(%rbp), %rdi
callq 0xb780
movq -0x58(%rbp), %rdi
callq 0x2220
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
leaq -0x14(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x6470
leaq -0x14(%rbp), %rdi
callq 0x6490
cmpl $0x1, %eax
je 0x5be4
movq -0x10(%rbp), %rdi
leaq 0x2d5ed(%rip), %rsi     # 0x331c6
callq 0x5350
movb $0x0, -0x1(%rbp)
jmp 0x5c58
movl $0x1, -0x20(%rbp)
leaq -0x1c(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x6470
leaq -0x1c(%rbp), %rdi
callq 0x6490
cmpl $0x1, %eax
je 0x5c1c
movq -0x10(%rbp), %rdi
leaq 0x2d5d1(%rip), %rsi     # 0x331e2
callq 0x5350
movb $0x0, -0x1(%rbp)
jmp 0x5c58
movl $0x5, -0x28(%rbp)
leaq -0x24(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x6470
leaq -0x24(%rbp), %rdi
callq 0x6490
cmpl $0x78, %eax
je 0x5c54
movq -0x10(%rbp), %rdi
leaq 0x2d5b5(%rip), %rsi     # 0x331fe
callq 0x5350
movb $0x0, -0x1(%rbp)
jmp 0x5c58
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x1, -0xc(%rbp)
movl $0x2, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl (%rcx), %eax
jg 0x64ce
movl -0xc(%rbp), %eax
imull -0x10(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x64ae
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x80, %rdi
callq 0x6e2c0
movq -0x10(%rbp), %rdi
addq $0x60, %rdi
callq 0x6ba50
movq -0x10(%rbp), %rdi
addq $0xd0, %rdi
callq 0x6a7d0
movq -0x10(%rbp), %rdi
addq $0x90, %rdi
callq 0x6ba50
movq -0x10(%rbp), %rdi
addq $0xf8, %rdi
callq 0x6c650
movq -0x10(%rbp), %rdi
addq $0xd0, %rdi
callq 0x69870
movq -0x10(%rbp), %rdi
addq $0xb0, %rdi
callq 0x6e458
movq -0x10(%rbp), %rdi
addq $0x90, %rdi
callq 0x6e458
movq -0x10(%rbp), %rdi
addq $0x80, %rdi
callq 0x6b680
movq -0x10(%rbp), %rdi
addq $0x60, %rdi
callq 0x6e458
movq -0x10(%rbp), %rdi
addq $0x40, %rdi
callq 0x6e458
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x6e458
movq -0x10(%rbp), %rdi
callq 0x6e458
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0xb0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x90(%rbp)
movq -0x18(%rbp), %rsi
addq $0x40, %rdi
callq 0x67190
movq -0x90(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x60, %rdi
movq %rdi, -0x88(%rbp)
callq 0x67190
xorl %eax, %eax
movl %eax, -0x74(%rbp)
movl %eax, %esi
leaq -0x50(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x6a260
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdx
movl -0x74(%rbp), %r8d
leaq -0x30(%rbp), %rdi
movl $0x1, %ecx
callq 0x67c90
jmp 0x6f272
movq -0x90(%rbp), %rdi
addq $0x80, %rdi
leaq -0x30(%rbp), %rsi
callq 0x68bc0
leaq -0x30(%rbp), %rdi
callq 0x6b680
leaq -0x50(%rbp), %rdi
callq 0x67880
jmp 0x6f3d7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x67880
movl -0x5c(%rbp), %eax
movl %eax, -0xa4(%rbp)
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0x6f332
movq -0x58(%rbp), %rdi
callq 0x683e0
movq -0x90(%rbp), %rdi
movq %rax, -0x70(%rbp)
addq $0x90, %rdi
callq 0x6ba50
movq -0x70(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq -0x90(%rbp), %rdi
movq %rax, %rsi
addq $0xb0, %rdi
callq 0x6bce0
jmp 0x6f30c
movq -0xa0(%rbp), %rdi
movq -0x90(%rbp), %rsi
addq $0x90, %rsi
callq 0x685c0
jmp 0x6f328
callq 0x6ced0
jmp 0x6f3ea
movl -0xa4(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x6f3fa
movq -0x58(%rbp), %rdi
callq 0x683e0
movq -0x90(%rbp), %rdi
movq %rax, -0x68(%rbp)
addq $0x90, %rdi
callq 0x6ba50
movq -0x68(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq -0x90(%rbp), %rdi
movq %rax, %rsi
addq $0xb0, %rdi
callq 0x6bce0
jmp 0x6f38a
movq -0xa0(%rbp), %rdi
movq -0x90(%rbp), %rsi
addq $0x90, %rsi
callq 0x685c0
jmp 0x6f3a6
callq 0x6ced0
jmp 0x6f3ea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
callq 0x6ced0
jmp 0x6f3c0
jmp 0x6f3fa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
callq 0x6ced0
jmp 0x6f3d5
jmp 0x6f3fa
movq -0x90(%rbp), %rsi
movq -0xa0(%rbp), %rdi
callq 0x68860
movq -0x98(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x6d7b0
movq %rax, %rdi
callq 0x76800
nopl (%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0xb0, %rdi
callq 0x6ba50
movq -0x48(%rbp), %rsi
movq %rsi, %rdx
addq $0x40, %rdx
leaq -0x28(%rbp), %rdi
callq 0x67670
movq -0x48(%rbp), %rdi
addq $0xd0, %rdi
leaq -0x28(%rbp), %rsi
callq 0x691c0
leaq -0x28(%rbp), %rdi
callq 0x69870
movq -0x48(%rbp), %rax
movq $0x0, 0xe8(%rax)
movq -0x48(%rbp), %rdi
addq $0xf8, %rdi
callq 0x67210
xorb $-0x1, %al
testb $0x1, %al
jne 0x6f497
jmp 0x6f4a9
movq -0x48(%rbp), %rdi
addq $0xf8, %rdi
callq 0x69bc0
jmp 0x6f47f
movq -0x48(%rbp), %rsi
movq %rsi, %rdi
addq $0xf8, %rdi
subq $-0x80, %rsi
callq 0x67460
movq -0x48(%rbp), %rdi
movb $0x1, 0x148(%rdi)
addq $0x90, %rdi
callq 0x6ba50
movq -0x48(%rbp), %rdi
callq 0x68c10
jmp 0x6f4e2
jmp 0x6f55d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x6f57b
movq -0x30(%rbp), %rdi
callq 0x683e0
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq -0x48(%rbp), %rdi
movq %rax, %rsi
addq $0xb0, %rdi
callq 0x6bce0
jmp 0x6f52b
movq -0x58(%rbp), %rdi
movq -0x48(%rbp), %rsi
addq $0x90, %rsi
callq 0x685c0
jmp 0x6f541
callq 0x6ced0
jmp 0x6f571
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x6ced0
jmp 0x6f55b
jmp 0x6f57b
movq -0x58(%rbp), %rdi
movq -0x48(%rbp), %rsi
addq $0x90, %rsi
callq 0x685c0
movq -0x50(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x6d7b0
movq %rax, %rdi
callq 0x76800
nopl (%rax)
// File: xelia-it[P]mustache/src/mustache-light.cpp
// Function: mustache::Mustache::partialSearchVariable(std::map<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::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<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&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Mustache::VariableConstIterator Mustache::partialSearchVariable(const Mustache::Variables& variables,
        const string& valueToSearch) {
        VariableConstIterator it;
        LOG("  Search in variables: ");
        LOG(valueToSearch);

        if (valueToSearch[0] == '\'' || valueToSearch[0] == '\"') {
                LOG_END("  LITERAL!");
                return variables.end();
        }
        if ((it = variables.find(valueToSearch)) != variables.end()) {
                LOG(" { ");
                LOG(it->first);
                LOG(" : ");
                LOG(it->second);
                LOG_END(" }  YES!");
        } else {
                LOG_END("  NO!");
        }

        return it;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x6c8b0
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x6afd0
movsbl (%rax), %eax
cmpl $0x27, %eax
je 0x761d7
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x6afd0
movsbl (%rax), %eax
cmpl $0x22, %eax
jne 0x761e6
movq -0x18(%rbp), %rdi
callq 0x67e30
movq %rax, -0x8(%rbp)
jmp 0x7622b
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x69f20
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x67e30
movq %rax, -0x38(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x6d310
testb $0x1, %al
jne 0x7621f
jmp 0x76221
jmp 0x76223
jmp 0x76223
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x200, %rsp            # imm = 0x200
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1e0(%rbp)
movl $0x10, %edi
movl $0x8, %esi
callq 0x6d9d0
movq -0x1e0(%rbp), %rsi
movl %eax, %edx
leaq -0x1a8(%rbp), %rdi
callq 0x6cc30
leaq -0x1c8(%rbp), %rdi
callq 0x6bf40
movsbl -0x11(%rbp), %edx
leaq -0x1a8(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
callq 0x6dc20
movq %rax, -0x1e8(%rbp)
jmp 0x762b7
movq -0x1e8(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x6b840
movb %al, -0x1e9(%rbp)
jmp 0x762d5
movb -0x1e9(%rbp), %al
testb $0x1, %al
jne 0x762e1
jmp 0x76321
movq -0x20(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
callq 0x68a60
jmp 0x762f3
jmp 0x76297
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d0(%rbp)
movl %eax, -0x1d4(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0x6e458
leaq -0x1a8(%rbp), %rdi
callq 0x69a00
jmp 0x76354
movq -0x20(%rbp), %rax
movq %rax, -0x1f8(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0x6e458
leaq -0x1a8(%rbp), %rdi
callq 0x69a00
movq -0x1f8(%rbp), %rax
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
movq -0x1d0(%rbp), %rdi
callq 0x6d7b0
// File: 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
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x28(%rbp)
callq 0x68b00
movq -0x28(%rbp), %rdi
callq 0x6ba00
testb $0x1, %al
jne 0x7811b
jmp 0x7813f
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x6b730
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x69d90
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x78a37
jmp 0x78a4e
movq -0x50(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x6d840
addq $0x60, %rsp
popq %rbp
retq
movb $0x1, -0x45(%rbp)
movl $0x20, %edi
callq 0x687d0
movq -0x50(%rbp), %rdi
movq %rax, -0x58(%rbp)
callq 0x69ed0
movq %rax, -0x38(%rbp)
leaq 0x36884(%rip), %rsi     # 0xaf2f8
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rdx
callq 0x6d2b0
jmp 0x78a83
movq -0x50(%rbp), %rcx
movq -0x58(%rbp), %rdi
movl $0x131, %esi            # imm = 0x131
leaq -0x30(%rbp), %rdx
callq 0x6cf60
jmp 0x78a9b
movq -0x58(%rbp), %rdi
movb $0x0, -0x45(%rbp)
movq 0x4d3e6(%rip), %rsi     # 0xc5e90
movq 0x4d417(%rip), %rdx     # 0xc5ec8
callq 0x6d470
jmp 0x78af7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x78adb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6e458
testb $0x1, -0x45(%rbp)
jne 0x78ae3
jmp 0x78aec
movq -0x58(%rbp), %rdi
callq 0x69830
jmp 0x78aee
movq -0x40(%rbp), %rdi
callq 0x6d7b0
nopw (%rax,%rax)
// File: xelia-it[P]mustache/src/mustache-light.cpp
// Function: mustache::Mustache::rtrim(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
inline std::string& Mustache::rtrim(string& s) {
   s.erase(std::find_if(s.rbegin(), s.rend(), [](unsigned char ch) {
        return !std::isspace(ch);
    }).base(), s.end());
    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x6d560
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x6b4c0
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x67ab0
leaq -0x28(%rbp), %rdi
callq 0x68a80
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x679f0
movq -0x10(%rbp), %rdi
callq 0x68fc0
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x679f0
movq -0x60(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0x67850
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)