LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: CobaltXII[P]cxcc/./compiler/compiler.hpp
// Function: compiler_t::pack_strings(expression_t*)
void pack_strings(expression_t* expression) {
		if (expression->type == et_string_literal) {
			long string_label = label++;
			expression->string_label = string_label;
			emit("S%ld:\n", string_label);
			for (int i = 0; i < expression->string_literal.size(); i++) {
				emit("    .quad   %u\n", (unsigned char)expression->string_literal[i]);
			}
			emit("    .quad   0\n");
		} else if (expression->type == et_function_call) {
			function_call_expression_t expr = expression->function_call;
			for (int i = 0; i < expr.arguments.size(); i++) {
				pack_strings(expr.arguments[i]);
			}
		} else if (expression->type == et_binary) {
			pack_strings(expression->binary.left_operand);
			pack_strings(expression->binary.right_operand);
		} else if (expression->type == et_unary) {
			pack_strings(expression->unary.operand);
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x244dd
movq -0x78(%rbp), %rdi
movq 0x20(%rdi), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rdi)
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x18(%rbp), %rdx
leaq 0x45d5(%rip), %rsi      # 0x28a3b
movb $0x0, %al
callq 0x245e0
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x31f0
movq %rax, %rcx
movq -0x80(%rbp), %rax
cmpq %rcx, %rax
jae 0x244c6
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x3540
movq -0x78(%rbp), %rdi
movzbl (%rax), %edx
leaq 0x458e(%rip), %rsi      # 0x28a42
movb $0x0, %al
callq 0x245e0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x24474
movq -0x78(%rbp), %rdi
leaq 0x4581(%rip), %rsi      # 0x28a52
movb $0x0, %al
callq 0x245e0
jmp 0x245cc
movq -0x10(%rbp), %rax
cmpl $0x5, (%rax)
jne 0x24576
movq -0x10(%rbp), %rsi
addq $0xb8, %rsi
leaq -0x58(%rbp), %rdi
callq 0x21240
movl $0x0, -0x5c(%rbp)
movslq -0x5c(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x58(%rbp), %rdi
addq $0x20, %rdi
callq 0x12ed0
movq %rax, %rcx
movq -0x88(%rbp), %rax
cmpq %rcx, %rax
jae 0x2456b
leaq -0x38(%rbp), %rdi
movslq -0x5c(%rbp), %rsi
callq 0x12ef0
movq -0x78(%rbp), %rdi
movq (%rax), %rsi
callq 0x24410
jmp 0x24547
jmp 0x24549
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
jmp 0x24505
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x16c50
jmp 0x245d5
leaq -0x58(%rbp), %rdi
callq 0x16c50
jmp 0x245ca
movq -0x10(%rbp), %rax
cmpl $0x6, (%rax)
jne 0x245a9
movq -0x78(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0xf0(%rax), %rsi
callq 0x24410
movq -0x78(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rsi
callq 0x24410
jmp 0x245c8
movq -0x10(%rbp), %rax
cmpl $0x7, (%rax)
jne 0x245c6
movq -0x78(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x108(%rax), %rsi
callq 0x24410
jmp 0x245c8
jmp 0x245ca
jmp 0x245cc
addq $0x90, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x34c0
nop
// File: CobaltXII[P]cxcc/./compiler/compiler.hpp
// Function: compiler_t::aligned_offset(function_t, symbol_table_t&)
long aligned_offset(function_t function, symbol_table_t& symbols) {
		symbol_table_t new_symbols(&symbols);
		long lowest_offset = 0;
		for (int i = 0; i < function.body.size(); i++) {
			aligned_offset_statement(function.body[i], new_symbols, lowest_offset);
		}

		long params_offset;
		if (function.parameters.size() >= 6) {
			params_offset = 48;
		} else {
			params_offset = function.parameters.size() * 8;
		}

		long highest_offset = -lowest_offset + params_offset;
		int remainder = highest_offset % 8;
		if (!remainder) {
			return highest_offset;
		}
		return highest_offset + 8 - remainder;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rsi, -0xa8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x191a0
movq $0x0, -0x68(%rbp)
movl $0x0, -0x6c(%rbp)
movq -0xa8(%rbp), %rdi
movslq -0x6c(%rbp), %rax
movq %rax, -0xb0(%rbp)
addq $0x40, %rdi
callq 0x10c30
movq %rax, %rcx
movq -0xb0(%rbp), %rax
cmpq %rcx, %rax
jae 0x24743
movq -0xa8(%rbp), %rdi
addq $0x40, %rdi
movslq -0x6c(%rbp), %rsi
callq 0x1c130
movq -0xa0(%rbp), %rdi
movq (%rax), %rsi
leaq -0x60(%rbp), %rdx
leaq -0x68(%rbp), %rcx
callq 0x24ee0
jmp 0x2471c
jmp 0x2471e
movl -0x6c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x6c(%rbp)
jmp 0x246c5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x19c10
jmp 0x24807
movq -0xa8(%rbp), %rdi
addq $0x28, %rdi
callq 0xf6c0
cmpq $0x6, %rax
jb 0x24766
movq $0x30, -0x88(%rbp)
jmp 0x24781
movq -0xa8(%rbp), %rdi
addq $0x28, %rdi
callq 0xf6c0
shlq $0x3, %rax
movq %rax, -0x88(%rbp)
xorl %eax, %eax
subq -0x68(%rbp), %rax
addq -0x88(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rax
movl $0x8, %ecx
cqto
idivq %rcx
movl %edx, %eax
movl %eax, -0x94(%rbp)
cmpl $0x0, -0x94(%rbp)
jne 0x247ce
movq -0x90(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0x98(%rbp)
jmp 0x247f1
movq -0x90(%rbp), %rax
addq $0x8, %rax
movslq -0x94(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0x98(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x19c10
movq -0x8(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x34c0
// File: saumya-prakash[P]AssemblerEmulator/emu.cpp
// Function: print_options()
void print_options()
{
    cout<<"Options :-"<<endl;

    cout<<"\tt - Execute one instruction with trace"<<endl;
    cout<<"\ts - Execute all instrutions with trace"<<endl;
    cout<<"\tn number - Execute specified number of instructions"<<endl;
    cout<<"\ta - Execute all instrucions without trace"<<endl;
    cout<<"\tq - Show current architectural state"<<endl;
    cout<<"\tc - Display number of instructions executed so far"<<endl;
    cout<<"\tu - Disassemble"<<endl;
    cout<<"\td - Show memory dump"<<endl;
    cout<<"\tx - Quit the emulator"<<endl;

    return;
}

// Assembly:
pushq %rax
movq 0xaa18(%rip), %rdi      # 0xdfd0
leaq 0x6aa5(%rip), %rsi      # 0xa064
callq 0x21f0
movq %rax, %rdi
movq 0xa9f2(%rip), %rsi      # 0xdfc0
callq 0x2240
movq 0xa9f6(%rip), %rdi      # 0xdfd0
leaq 0x6a8e(%rip), %rsi      # 0xa06f
callq 0x21f0
movq %rax, %rdi
movq 0xa9d0(%rip), %rsi      # 0xdfc0
callq 0x2240
movq 0xa9d4(%rip), %rdi      # 0xdfd0
leaq 0x6a94(%rip), %rsi      # 0xa097
callq 0x21f0
movq %rax, %rdi
movq 0xa9ae(%rip), %rsi      # 0xdfc0
callq 0x2240
movq 0xa9b2(%rip), %rdi      # 0xdfd0
leaq 0x6a9a(%rip), %rsi      # 0xa0bf
callq 0x21f0
movq %rax, %rdi
movq 0xa98c(%rip), %rsi      # 0xdfc0
callq 0x2240
movq 0xa990(%rip), %rdi      # 0xdfd0
leaq 0x6aad(%rip), %rsi      # 0xa0f4
callq 0x21f0
movq %rax, %rdi
movq 0xa96a(%rip), %rsi      # 0xdfc0
callq 0x2240
movq 0xa96e(%rip), %rdi      # 0xdfd0
leaq 0x6ab6(%rip), %rsi      # 0xa11f
callq 0x21f0
movq %rax, %rdi
movq 0xa948(%rip), %rsi      # 0xdfc0
callq 0x2240
movq 0xa94c(%rip), %rdi      # 0xdfd0
leaq 0x6aba(%rip), %rsi      # 0xa145
callq 0x21f0
movq %rax, %rdi
movq 0xa926(%rip), %rsi      # 0xdfc0
callq 0x2240
movq 0xa92a(%rip), %rdi      # 0xdfd0
leaq 0x6acc(%rip), %rsi      # 0xa179
callq 0x21f0
movq %rax, %rdi
movq 0xa904(%rip), %rsi      # 0xdfc0
callq 0x2240
movq 0xa908(%rip), %rdi      # 0xdfd0
leaq 0x6abb(%rip), %rsi      # 0xa18a
callq 0x21f0
movq %rax, %rdi
movq 0xa8e2(%rip), %rsi      # 0xdfc0
callq 0x2240
movq 0xa8e6(%rip), %rdi      # 0xdfd0
leaq 0x6aaf(%rip), %rsi      # 0xa1a0
callq 0x21f0
movq %rax, %rdi
movq 0xa8c0(%rip), %rsi      # 0xdfc0
callq 0x2240
popq %rax
retq
nopw (%rax,%rax)
// File: saumya-prakash[P]AssemblerEmulator/Emulator.cpp
// Function: Emulator::get_endianess()
Emulator::endianess Emulator::get_endianess()
{
    unsigned a = 1;
    char* ptr = (char *) &a;

    if(*ptr==1)
        return lil_endian;
    
    else
        return big_endian;
}

// Assembly:
movl $0x1, -0x8(%rsp)
leaq -0x8(%rsp), %rax
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x1, %eax
jne 0x4a89
movl $0x0, -0x4(%rsp)
jmp 0x4a91
movl $0x1, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: saumya-prakash[P]AssemblerEmulator/Emulator.cpp
// Function: Emulator::get_int(std::basic_ifstream<char, std::char_traits<char>>&) const
unsigned Emulator::get_int(ifstream& fi) const
{
    unsigned res = 0;

    char *ptr = (char *) &res;
    char byte = 0;

    if(machine_type==big_endian)    // just read byte and put it
    {
        fi.read(&byte, 1);
        *ptr = byte;
        ptr++;

        fi.read(&byte, 1);
        *ptr = byte;
        ptr++;

        fi.read(&byte, 1);
        *ptr = byte;
        ptr++;

        fi.read(&byte, 1);
        *ptr = byte;
    }

    else    // read and put in reverse order
    {
        ptr += 3;

        fi.read(&byte, 1);
        *ptr = byte;
        ptr--;

        fi.read(&byte, 1);
        *ptr = byte;
        ptr--;

        fi.read(&byte, 1);
        *ptr = byte;
        ptr--;

        fi.read(&byte, 1);
        *ptr = byte;
    }
    
    return res;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
leaq 0x14(%rsp), %rax
movq %rax, 0x8(%rsp)
movb $0x0, 0x7(%rsp)
cmpl $0x1, 0x9414(%rip)      # 0xe280
jne 0x4f1d
movq 0x18(%rsp), %rdi
leaq 0x7(%rsp), %rsi
movl $0x1, %edx
callq 0x22d0
movb 0x7(%rsp), %cl
movq 0x8(%rsp), %rax
movb %cl, (%rax)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x7(%rsp), %rsi
movl $0x1, %edx
callq 0x22d0
movb 0x7(%rsp), %cl
movq 0x8(%rsp), %rax
movb %cl, (%rax)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x7(%rsp), %rsi
movl $0x1, %edx
callq 0x22d0
movb 0x7(%rsp), %cl
movq 0x8(%rsp), %rax
movb %cl, (%rax)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x7(%rsp), %rsi
movl $0x1, %edx
callq 0x22d0
movb 0x7(%rsp), %cl
movq 0x8(%rsp), %rax
movb %cl, (%rax)
jmp 0x4fd1
movq 0x8(%rsp), %rax
addq $0x3, %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x7(%rsp), %rsi
movl $0x1, %edx
callq 0x22d0
movb 0x7(%rsp), %cl
movq 0x8(%rsp), %rax
movb %cl, (%rax)
movq 0x8(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x7(%rsp), %rsi
movl $0x1, %edx
callq 0x22d0
movb 0x7(%rsp), %cl
movq 0x8(%rsp), %rax
movb %cl, (%rax)
movq 0x8(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x7(%rsp), %rsi
movl $0x1, %edx
callq 0x22d0
movb 0x7(%rsp), %cl
movq 0x8(%rsp), %rax
movb %cl, (%rax)
movq 0x8(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x7(%rsp), %rsi
movl $0x1, %edx
callq 0x22d0
movb 0x7(%rsp), %cl
movq 0x8(%rsp), %rax
movb %cl, (%rax)
movl 0x14(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: saumya-prakash[P]AssemblerEmulator/Emulator.cpp
// Function: Emulator::check_PC(int)
bool Emulator::check_PC(int a)
{
    if(a<0 || a>pc_upper)
    {
        fault = true;
        string tmp = faults.find(0)->second;
        PC--;
        string tmp2 = current_state();
        PC++;

        fault_cause = tmp + " when executing " + tmp2;

        return false;
    }

    return true;
}

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0xb8(%rsp)
movl %esi, 0xb4(%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0x0, 0xb4(%rsp)
jl 0x5ede
cmpl $0x3ff, 0xb4(%rsp) # imm = 0x3FF
jbe 0x601f
movq 0x8(%rsp), %rax
movb $0x1, 0x51(%rax)
movl $0x0, 0x84(%rsp)
leaq 0x8357(%rip), %rdi      # 0xe250
leaq 0x84(%rsp), %rsi
callq 0x7420
movq %rax, 0x88(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x7450
movq %rax, %rsi
addq $0x8, %rsi
leaq 0x90(%rsp), %rdi
callq 0x20e0
movq 0x8(%rsp), %rsi
movl 0x28(%rsi), %eax
decl %eax
movl %eax, 0x28(%rsi)
leaq 0x60(%rsp), %rdi
callq 0x5a00
jmp 0x5f48
movq 0x8(%rsp), %rax
movl 0x28(%rax), %ecx
incl %ecx
movl %ecx, 0x28(%rax)
leaq 0x45c8(%rip), %rdx      # 0xa524
leaq 0x10(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x7470
jmp 0x5f70
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x60(%rsp), %rdx
callq 0x7500
jmp 0x5f86
movq 0x8(%rsp), %rdi
addq $0x58, %rdi
leaq 0x30(%rsp), %rsi
callq 0x22b0
leaq 0x30(%rsp), %rdi
callq 0x2140
leaq 0x10(%rsp), %rdi
callq 0x2140
movb $0x0, 0xc7(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x2140
leaq 0x90(%rsp), %rdi
callq 0x2140
jmp 0x6027
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x6010
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x6006
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x2140
leaq 0x60(%rsp), %rdi
callq 0x2140
leaq 0x90(%rsp), %rdi
callq 0x2140
jmp 0x6038
movb $0x1, 0xc7(%rsp)
movb 0xc7(%rsp), %al
andb $0x1, %al
addq $0xc8, %rsp
retq
movq 0x58(%rsp), %rdi
callq 0x2390
nopw %cs:(%rax,%rax)
// File: saumya-prakash[P]AssemblerEmulator/Emulator.cpp
// Function: Emulator::check_memory_access(int)
bool Emulator::check_memory_access(int a)
{
    string tmp;

    if(a<0 || a>end_address)
    {
        fault = true;
        tmp = faults.find(3)->second;
    }

    if(a<=pc_upper)
    {
        fault = true;
        tmp = faults.find(2)->second;
    }

    if(fault==false)
        return true;

    PC--;
    string tmp2 = current_state();
    PC++;

    fault_cause = tmp + " when executing " + tmp2;

    return false;
}

// Assembly:
subq $0xe8, %rsp
movq %rdi, 0xd8(%rsp)
movl %esi, 0xd4(%rsp)
movq 0xd8(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0xb0(%rsp), %rdi
callq 0x2320
cmpl $0x0, 0xd4(%rsp)
jl 0x6097
cmpl $0xffff, 0xd4(%rsp) # imm = 0xFFFF
jbe 0x6111
movq 0x18(%rsp), %rax
movb $0x1, 0x51(%rax)
movl $0x3, 0xa4(%rsp)
leaq 0x819e(%rip), %rdi      # 0xe250
leaq 0xa4(%rsp), %rsi
callq 0x7420
movq %rax, 0x10(%rsp)
jmp 0x60c6
movq 0x10(%rsp), %rax
movq %rax, 0xa8(%rsp)
leaq 0xa8(%rsp), %rdi
callq 0x7450
movq %rax, %rsi
addq $0x8, %rsi
leaq 0xb0(%rsp), %rdi
callq 0x2040
jmp 0x60f6
jmp 0x6111
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0x62a4
cmpl $0x3ff, 0xd4(%rsp) # imm = 0x3FF
ja 0x617f
movq 0x18(%rsp), %rax
movb $0x1, 0x51(%rax)
movl $0x2, 0x84(%rsp)
leaq 0x8117(%rip), %rdi      # 0xe250
leaq 0x84(%rsp), %rsi
callq 0x7420
movq %rax, 0x8(%rsp)
jmp 0x614d
movq 0x8(%rsp), %rax
movq %rax, 0x88(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x7450
movq %rax, %rsi
addq $0x8, %rsi
leaq 0xb0(%rsp), %rdi
callq 0x2040
jmp 0x617d
jmp 0x617f
movq 0x18(%rsp), %rax
movb 0x51(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x61a9
movb $0x1, 0xe7(%rsp)
movl $0x1, 0x80(%rsp)
jmp 0x6286
movq 0x18(%rsp), %rsi
movl 0x28(%rsi), %eax
decl %eax
movl %eax, 0x28(%rsi)
leaq 0x60(%rsp), %rdi
callq 0x5a00
jmp 0x61c2
movq 0x18(%rsp), %rax
movl 0x28(%rax), %ecx
incl %ecx
movl %ecx, 0x28(%rax)
leaq 0x434e(%rip), %rdx      # 0xa524
leaq 0x20(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
callq 0x7470
jmp 0x61ea
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
leaq 0x60(%rsp), %rdx
callq 0x7500
jmp 0x6200
movq 0x18(%rsp), %rdi
addq $0x58, %rdi
leaq 0x40(%rsp), %rsi
callq 0x22b0
leaq 0x40(%rsp), %rdi
callq 0x2140
leaq 0x20(%rsp), %rdi
callq 0x2140
movb $0x0, 0xe7(%rsp)
movl $0x1, 0x80(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x2140
jmp 0x6286
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0x627a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x2140
leaq 0x60(%rsp), %rdi
callq 0x2140
jmp 0x62a4
leaq 0xb0(%rsp), %rdi
callq 0x2140
movb 0xe7(%rsp), %al
andb $0x1, %al
addq $0xe8, %rsp
retq
leaq 0xb0(%rsp), %rdi
callq 0x2140
movq 0x98(%rsp), %rdi
callq 0x2390
nop
// File: saumya-prakash[P]AssemblerEmulator/Emulator.cpp
// Function: Emulator::check_SP(int)
bool Emulator::check_SP(int a)
{
    if(a>end_address || a<=data_upper)
    {
        fault = true;
        string tmp = faults.find(1)->second;
        PC--;
        string tmp2 = current_state();
        PC++;

        fault_cause = tmp + " when executing " + tmp2;
        return false;
    }

    return true;
}

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0xb8(%rsp)
movl %esi, 0xb4(%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0xffff, 0xb4(%rsp) # imm = 0xFFFF
ja 0x6305
movq 0x8(%rsp), %rcx
movl 0xb4(%rsp), %eax
cmpl 0x38(%rcx), %eax
jg 0x6446
movq 0x8(%rsp), %rax
movb $0x1, 0x51(%rax)
movl $0x1, 0x84(%rsp)
leaq 0x7f30(%rip), %rdi      # 0xe250
leaq 0x84(%rsp), %rsi
callq 0x7420
movq %rax, 0x88(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x7450
movq %rax, %rsi
addq $0x8, %rsi
leaq 0x90(%rsp), %rdi
callq 0x20e0
movq 0x8(%rsp), %rsi
movl 0x28(%rsi), %eax
decl %eax
movl %eax, 0x28(%rsi)
leaq 0x60(%rsp), %rdi
callq 0x5a00
jmp 0x636f
movq 0x8(%rsp), %rax
movl 0x28(%rax), %ecx
incl %ecx
movl %ecx, 0x28(%rax)
leaq 0x41a1(%rip), %rdx      # 0xa524
leaq 0x10(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x7470
jmp 0x6397
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x60(%rsp), %rdx
callq 0x7500
jmp 0x63ad
movq 0x8(%rsp), %rdi
addq $0x58, %rdi
leaq 0x30(%rsp), %rsi
callq 0x22b0
leaq 0x30(%rsp), %rdi
callq 0x2140
leaq 0x10(%rsp), %rdi
callq 0x2140
movb $0x0, 0xc7(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x2140
leaq 0x90(%rsp), %rdi
callq 0x2140
jmp 0x644e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x6437
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x642d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x2140
leaq 0x60(%rsp), %rdi
callq 0x2140
leaq 0x90(%rsp), %rdi
callq 0x2140
jmp 0x645f
movb $0x1, 0xc7(%rsp)
movb 0xc7(%rsp), %al
andb $0x1, %al
addq $0xc8, %rsp
retq
movq 0x58(%rsp), %rdi
callq 0x2390
nopl (%rax)
// File: saumya-prakash[P]AssemblerEmulator/Emulator.cpp
// Function: Emulator::get_program_status() const
int Emulator::get_program_status() const
{
    if(finished==true)
        return 0;       // finished execution
    
    if(fault==true)
        return -1;

    return 1;    // active

}

// Assembly:
movq %rdi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x18(%rsp)
movb 0x50(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x6496
movl $0x0, -0x4(%rsp)
jmp 0x64ba
movq -0x18(%rsp), %rax
movb 0x51(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x64b2
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x64ba
movl $0x1, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nop
// File: saumya-prakash[P]AssemblerEmulator/Emulator.cpp
// Function: Emulator::reverse_decode[abi:cxx11](unsigned int) const
string Emulator::reverse_decode(unsigned a) const
{
    unsigned opcode = (a<<24)>>24;

    ostringstream oss;

    map<unsigned, pair<unsigned, string> >::const_iterator mt = decoder.find(opcode);

    string mnem = mt->second.second;    // storing the mnemonic

    oss<<mnem;

    if(mt->second.first==1)     // operand also present
    {
        int tmp = a & 0xffffff00;
        tmp /= 256;

        oss<<" "<<tmp;
    }

    return oss.str();
}

// Assembly:
subq $0x1f8, %rsp            # imm = 0x1F8
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x1f0(%rsp)
movq %rsi, 0x1e8(%rsp)
movl %edx, 0x1e4(%rsp)
movzbl 0x1e4(%rsp), %eax
movl %eax, 0x1e0(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x2310
leaq 0x7d15(%rip), %rdi      # 0xe220
leaq 0x1e0(%rsp), %rsi
callq 0x7550
movq %rax, 0x20(%rsp)
jmp 0x651f
movq 0x20(%rsp), %rax
movq %rax, 0x60(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x7580
movq %rax, %rsi
addq $0x10, %rsi
leaq 0x30(%rsp), %rdi
callq 0x20e0
jmp 0x6546
leaq 0x68(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x21d0
jmp 0x6557
leaq 0x60(%rsp), %rdi
callq 0x7580
cmpl $0x1, 0x8(%rax)
jne 0x65e3
movl 0x1e4(%rsp), %eax
andl $0xffffff00, %eax       # imm = 0xFFFFFF00
movl %eax, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
movl %eax, %ecx
addl $0xff, %ecx
testl %eax, %eax
cmovsl %ecx, %eax
sarl $0x8, %eax
movl %eax, 0x2c(%rsp)
leaq 0x3fa7(%rip), %rsi      # 0xa53d
leaq 0x68(%rsp), %rdi
callq 0x21f0
movq %rax, 0x8(%rsp)
jmp 0x65a7
movq 0x8(%rsp), %rdi
movl 0x2c(%rsp), %esi
callq 0x2380
jmp 0x65b7
jmp 0x65e3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x6615
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x2140
jmp 0x6615
movq 0x10(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x2220
jmp 0x65f4
leaq 0x30(%rsp), %rdi
callq 0x2140
leaq 0x68(%rsp), %rdi
callq 0x2080
movq 0x18(%rsp), %rax
addq $0x1f8, %rsp            # imm = 0x1F8
retq
leaq 0x68(%rsp), %rdi
callq 0x2080
movq 0x58(%rsp), %rdi
callq 0x2390
nopl (%rax)
// File: saumya-prakash[P]AssemblerEmulator/Emulator.cpp
// Function: Emulator::memory_dump(std::ostream&) const
void Emulator::memory_dump(ostream& os) const
{
    int per_line = 4;

    os<<hex<<showbase;

    os<<"Text Segment :-\n\tsize = "<<text_size<<'\n';

    unsigned i = pc_lower;
    while(i<text_size)
    {
        os<<i<<": "<<mempory_space[i]<<'\n';
        i++;
    }

    os<<"\n\n";

    os<<"Data Segment :-\n\tsize = "<<data_size<<'\n';
    i = 0;
    while(i<data_size)
    {
        os<<i+data_lower<<": "<<mempory_space[i+data_lower];
        os<<"  (In decimal: "<<dec<<mempory_space[i+data_lower]<<hex<<")\n";
        i++;
    }


    os<<'\n'<<noshowbase;

    os<<dec;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x4, 0x14(%rsp)
movq 0x18(%rsp), %rdi
leaq 0xc34(%rip), %rsi       # 0x75e0
callq 0x20b0
movq %rax, %rdi
leaq 0xc65(%rip), %rsi       # 0x7620
callq 0x20b0
movq 0x18(%rsp), %rdi
leaq 0x3b88(%rip), %rsi      # 0xa554
callq 0x21f0
movq %rax, %rdi
movq 0x8(%rsp), %rax
movl 0x48(%rax), %esi
callq 0x2300
movq %rax, %rdi
movl $0xa, %esi
callq 0x22a0
movl $0x0, 0x10(%rsp)
movq 0x8(%rsp), %rcx
movl 0x10(%rsp), %eax
cmpl 0x48(%rcx), %eax
jae 0x6a53
movq 0x18(%rsp), %rdi
movl 0x10(%rsp), %esi
callq 0x2300
movq %rax, %rdi
leaq 0x3b7a(%rip), %rsi      # 0xa596
callq 0x21f0
movq %rax, %rdi
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rax
movl 0x10(%rsp), %ecx
movl (%rax,%rcx,4), %esi
callq 0x2380
movq %rax, %rdi
movl $0xa, %esi
callq 0x22a0
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x69f6
movq 0x18(%rsp), %rdi
leaq 0x3b0e(%rip), %rsi      # 0xa56d
callq 0x21f0
movq 0x18(%rsp), %rdi
leaq 0x3b00(%rip), %rsi      # 0xa570
callq 0x21f0
movq %rax, %rdi
movq 0x8(%rsp), %rax
movl 0x4c(%rax), %esi
callq 0x2300
movq %rax, %rdi
movl $0xa, %esi
callq 0x22a0
movl $0x0, 0x10(%rsp)
movq 0x8(%rsp), %rcx
movl 0x10(%rsp), %eax
cmpl 0x4c(%rcx), %eax
jae 0x6b5d
movq 0x18(%rsp), %rdi
movl 0x10(%rsp), %esi
addl $0x400, %esi            # imm = 0x400
callq 0x2300
movq %rax, %rdi
leaq 0x3acc(%rip), %rsi      # 0xa596
callq 0x21f0
movq %rax, %rdi
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rax
movl 0x10(%rsp), %ecx
addl $0x400, %ecx            # imm = 0x400
movl %ecx, %ecx
movl (%rax,%rcx,4), %esi
callq 0x2380
movq 0x18(%rsp), %rdi
leaq 0x3a8e(%rip), %rsi      # 0xa589
callq 0x21f0
movq %rax, %rdi
leaq 0xaf6(%rip), %rsi       # 0x7600
callq 0x20b0
movq %rax, %rdi
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rax
movl 0x10(%rsp), %ecx
addl $0x400, %ecx            # imm = 0x400
movl %ecx, %ecx
movl (%rax,%rcx,4), %esi
callq 0x2380
movq %rax, %rdi
leaq 0xaa7(%rip), %rsi       # 0x75e0
callq 0x20b0
movq %rax, %rdi
leaq 0x3a51(%rip), %rsi      # 0xa599
callq 0x21f0
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x6a9a
movq 0x18(%rsp), %rdi
movl $0xa, %esi
callq 0x22a0
movq %rax, %rdi
leaq 0xaca(%rip), %rsi       # 0x7640
callq 0x20b0
movq 0x18(%rsp), %rdi
leaq 0xa79(%rip), %rsi       # 0x7600
callq 0x20b0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: nmmmnu[P]HM3/hm3/main/db_lsmload.cc
// Function: main
int main(int argc, char **argv){
	if (argc <= 2){
		printUsage(argv[0]);
		return 1;
	}

	const auto filename	= argv[1];
	const auto lsm_path	= argv[2];
	const auto lsm_ext	= ".db";

	MemList memlist;

	using MyList	= hm3::FlushList<MemList,Flusher>;

	MyList mylist{
		memlist,
		Flusher{
			MyIDGenerator{},
			lsm_path,
			lsm_ext
		},
		MEMLIST_SIZE
	};

	FileReader reader{ filename };

	return listLoad(mylist, reader);
}

// Assembly:
subq $0x558, %rsp            # imm = 0x558
movl $0x0, 0x554(%rsp)
movl %edi, 0x550(%rsp)
movq %rsi, 0x548(%rsp)
cmpl $0x2, 0x550(%rsp)
jg 0x36db
movq 0x548(%rsp), %rax
movq (%rax), %rdi
callq 0x38d0
movl $0x1, 0x554(%rsp)
jmp 0x38ae
movq 0x548(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x540(%rsp)
movq 0x548(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x538(%rsp)
leaq 0x98fa(%rip), %rax      # 0xd004
movq %rax, 0x530(%rsp)
leaq 0x318(%rsp), %rdi
movl $0x20, %esi
callq 0x5420
movq 0x538(%rsp), %rsi
leaq 0x248(%rsp), %rdi
callq 0x3c30
jmp 0x373b
leaq 0x98c2(%rip), %rsi      # 0xd004
leaq 0x228(%rsp), %rdi
callq 0x3c30
jmp 0x3751
leaq 0x260(%rsp), %rdi
leaq 0x25f(%rsp), %rsi
leaq 0x248(%rsp), %rdx
leaq 0x228(%rsp), %rcx
movl $0x1, %r8d
callq 0x3c80
jmp 0x377e
leaq 0x2b0(%rsp), %rdi
leaq 0x318(%rsp), %rsi
leaq 0x260(%rsp), %rdx
movl $0xa00000, %ecx         # imm = 0xA00000
callq 0x3d10
jmp 0x37a2
leaq 0x260(%rsp), %rdi
callq 0x3d50
movq 0x540(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x3c30
jmp 0x37c3
leaq 0x18(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movl $0x3, %edx
callq 0x3d80
jmp 0x37d9
leaq 0x2b0(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x3910
movl %eax, 0x4(%rsp)
jmp 0x37f1
movl 0x4(%rsp), %eax
movl %eax, 0x554(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x3e10
leaq 0x2b0(%rsp), %rdi
callq 0x3e20
leaq 0x318(%rsp), %rdi
callq 0x5550
jmp 0x38ae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x240(%rsp)
movl %eax, 0x23c(%rsp)
jmp 0x389f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x240(%rsp)
movl %eax, 0x23c(%rsp)
leaq 0x260(%rsp), %rdi
callq 0x3d50
jmp 0x389f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x240(%rsp)
movl %eax, 0x23c(%rsp)
jmp 0x3892
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x240(%rsp)
movl %eax, 0x23c(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x3e10
leaq 0x2b0(%rsp), %rdi
callq 0x3e20
leaq 0x318(%rsp), %rdi
callq 0x5550
jmp 0x38bd
movl 0x554(%rsp), %eax
addq $0x558, %rsp            # imm = 0x558
retq
movq 0x240(%rsp), %rdi
callq 0x3410
nopw (%rax,%rax)
// File: nmmmnu[P]HM3/hm3/main/db_lsmload.cc
// Function: int listLoad<hm3::FlushList<hm3::SkipList, hm3::flusher::DiskFileFlusher<hm3::idgenerator::IDGeneratorDate>, std::nullptr_t>, FileReader>(hm3::FlushList<hm3::SkipList, hm3::flusher::DiskFileFlusher<hm3::idgenerator::IDGeneratorDate>, std::nullptr_t>&, FileReader&)
static int listLoad(LIST &list, READER &reader){
	size_t i = 0;

	while(reader){
		std::string line = reader.getLine();

		StringTokenizer tok{ line };

		const StringRef &key = tok.getNext();
		const StringRef &val = tok.getNext();

		if (! key.empty())
			list.put( { key, val } );

		++i;

		if (i % PROCESS_STEP == 0){
			printf("Processed %10zu records, In memory %10zu records, %10zu bytes...\n",
						i,
						size_t{ list.getList().getCount() },
						list.getList().getBytes() );
		}
	}

	return 0;
}

// Assembly:
subq $0x108, %rsp            # imm = 0x108
movq %rdi, 0x100(%rsp)
movq %rsi, 0xf8(%rsp)
movq $0x0, 0xf0(%rsp)
movq 0xf8(%rsp), %rdi
callq 0x4e40
testb $0x1, %al
jne 0x3949
jmp 0x3b60
movq 0xf8(%rsp), %rsi
leaq 0xd0(%rsp), %rdi
movq %rdi, 0x50(%rsp)
callq 0x4e60
movq 0x50(%rsp), %rsi
leaq 0xa0(%rsp), %rdi
callq 0x43a0
jmp 0x3977
leaq 0xb0(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
movl $0x20, %edx
callq 0x4f70
jmp 0x3993
leaq 0xb0(%rsp), %rdi
callq 0x6e50
movq %rdx, 0x40(%rsp)
movq %rax, 0x48(%rsp)
jmp 0x39ac
movq 0x40(%rsp), %rax
movq 0x48(%rsp), %rcx
movq %rcx, 0x78(%rsp)
movq %rax, 0x80(%rsp)
leaq 0x78(%rsp), %rax
movq %rax, 0x88(%rsp)
leaq 0xb0(%rsp), %rdi
callq 0x6e50
movq %rdx, 0x30(%rsp)
movq %rax, 0x38(%rsp)
jmp 0x39e9
movq 0x30(%rsp), %rax
movq 0x38(%rsp), %rcx
movq %rcx, 0x60(%rsp)
movq %rax, 0x68(%rsp)
leaq 0x60(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x88(%rsp), %rdi
callq 0x4fb0
testb $0x1, %al
jne 0x3aa1
movq 0x100(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x88(%rsp), %rsi
movq 0x70(%rsp), %rdx
leaq 0x58(%rsp), %rdi
xorl %r8d, %r8d
movl %r8d, %ecx
callq 0x7c40
jmp 0x3a48
movq 0x28(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x4fd0
jmp 0x3a59
leaq 0x58(%rsp), %rdi
callq 0x7bd0
jmp 0x3aa1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0x3b51
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x7bd0
jmp 0x3b51
movq 0xf0(%rsp), %rax
addq $0x1, %rax
movq %rax, 0xf0(%rsp)
movq 0xf0(%rsp), %rax
movl $0x2710, %ecx           # imm = 0x2710
xorl %edx, %edx
divq %rcx
cmpq $0x0, %rdx
jne 0x3b3f
movq 0xf0(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x100(%rsp), %rdi
callq 0x5000
movq %rax, 0x20(%rsp)
jmp 0x3aee
movq 0x20(%rsp), %rdi
movl $0x1, %esi
callq 0x4440
movq %rax, 0x8(%rsp)
movq 0x100(%rsp), %rdi
callq 0x5000
movq %rax, 0x10(%rsp)
jmp 0x3b16
movq 0x10(%rsp), %rdi
callq 0x5010
movq 0x18(%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rax, %rcx
leaq 0x954e(%rip), %rdi      # 0xd082
xorl %eax, %eax
callq 0x3030
jmp 0x3b3d
jmp 0x3b3f
leaq 0xd0(%rsp), %rdi
callq 0x3180
jmp 0x3933
leaq 0xd0(%rsp), %rdi
callq 0x3180
jmp 0x3b6a
xorl %eax, %eax
addq $0x108, %rsp            # imm = 0x108
retq
movq 0x98(%rsp), %rdi
callq 0x3410
nopw (%rax,%rax)
// File: nmmmnu[P]HM3/hm3/flusher/diskfileflusher.h
// Function: bool hm3::flusher::DiskFileFlusher<hm3::idgenerator::IDGeneratorDate>::operator<<<hm3::SkipList>(hm3::SkipList const&) const
bool operator << (const LIST &list) const{
		if (list.isEmpty())
			return false;

		printf("Flushing data to disk...\n");

		const auto &filename = path_ + _idGenerator() + _ext;

		using DiskFileBuilder = diskfile::DiskFileBuilder;

		DiskFileBuilder df;
		df.createFromList(filename, list, _keepTombstones);

		return true;
	}

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xa8(%rsp)
movq %rsi, 0xa0(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0xa0(%rsp), %rdi
callq 0x4260
testb $0x1, %al
jne 0x4117
jmp 0x4124
movb $0x0, 0xb7(%rsp)
jmp 0x423c
leaq 0x8f31(%rip), %rdi      # 0xd05c
xorl %eax, %eax
callq 0x3030
movq 0x10(%rsp), %rsi
movq %rsi, %rax
addq $0x8, %rax
movq %rax, (%rsp)
leaq 0x38(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x6ca0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0x58(%rsp), %rdi
callq 0x42d0
jmp 0x4166
movq 0x10(%rsp), %rdx
addq $0x28, %rdx
leaq 0x78(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x4280
jmp 0x4180
leaq 0x58(%rsp), %rdi
callq 0x3180
leaq 0x38(%rsp), %rdi
callq 0x3180
leaq 0x78(%rsp), %rax
movq %rax, 0x98(%rsp)
movq 0x98(%rsp), %rsi
leaq 0x18(%rsp), %rdi
callq 0x43a0
jmp 0x41b5
movq 0x10(%rsp), %rax
movq 0xa0(%rsp), %rdx
movzbl 0x48(%rax), %ecx
andl $0x1, %ecx
leaq 0x2b(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x4320
jmp 0x41da
movb $0x1, 0xb7(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x3180
jmp 0x423c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x4216
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x3180
leaq 0x38(%rsp), %rdi
callq 0x3180
jmp 0x424d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x3180
jmp 0x424d
movb 0xb7(%rsp), %al
andb $0x1, %al
addq $0xb8, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x3410
nopw (%rax,%rax)
// File: nmmmnu[P]HM3/hm3/flushlist.h
// Function: bool hm3::FlushList<hm3::SkipList, hm3::flusher::DiskFileFlusher<hm3::idgenerator::IDGeneratorDate>, std::nullptr_t>::putT_<hm3::Pair>(hm3::Pair&&)
bool putT_(UPAIR &&data){
		bool const result = list_.put( std::forward<UPAIR>(data) );

		if (list_.getBytes() > maxSize_){
			flush();
			list_.removeAll();
			notifyLoader_(loader_);
		}

		return result;
	}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq (%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0x5120
movb %al, %cl
movq 0x8(%rsp), %rax
andb $0x1, %cl
movb %cl, 0x17(%rsp)
movq (%rax), %rdi
callq 0x5010
movq 0x8(%rsp), %rcx
cmpq 0x60(%rcx), %rax
jbe 0x510b
movq 0x8(%rsp), %rdi
callq 0x40b0
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x5570
movq 0x8(%rsp), %rax
movq 0x58(%rax), %rdi
callq 0x5150
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/scn2img/scn2img.cpp
// Function: CaptureScalar(gaps::R2Grid&, double)
static int
CaptureScalar(R2Grid& image, RNScalar max_value = 65535)
{
  // Allocate pixel buffer
  float *pixels = new float [ width * height ];

  // Set packing parameters for glReadPixels
  if ((width % 4) != 0) glPixelStorei(GL_PACK_ALIGNMENT, 1);

  // Read blue channel
  glReadPixels(0, 0, width, height, GL_BLUE, GL_FLOAT, pixels);
  
  // Fill image
  float *pixelp = pixels;
  for (int iy = 0; iy < height; iy++) {
    for (int ix = 0; ix < width; ix++) {
      RNScalar value = *pixelp++;
      image.SetGridValue(ix, iy, max_value * value);
    }
  }

  // Delete pixels
  delete [] pixels;
  
  // Return success
  return 1;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movsd %xmm0, 0x38(%rsp)
movl 0x1ee0db(%rip), %eax    # 0x218ab0
imull 0x1ee0d8(%rip), %eax    # 0x218ab4
cltq
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x23040
movq %rax, 0x30(%rsp)
movl 0x1ee0a6(%rip), %eax    # 0x218ab0
movl $0x4, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
je 0x2aa26
movl $0xd05, %edi            # imm = 0xD05
movl $0x1, %esi
callq 0x23470
movl 0x1ee084(%rip), %edx    # 0x218ab0
movl 0x1ee082(%rip), %ecx    # 0x218ab4
movq 0x30(%rsp), %rax
xorl %esi, %esi
movl $0x1905, %r8d           # imm = 0x1905
movl $0x1406, %r9d           # imm = 0x1406
movl %esi, %edi
movq %rax, (%rsp)
callq 0x23420
movq 0x30(%rsp), %rax
movq %rax, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x1ee048(%rip), %eax    # 0x218ab4
jge 0x2aadb
movl $0x0, 0x20(%rsp)
movl 0x20(%rsp), %eax
cmpl 0x1ee030(%rip), %eax    # 0x218ab0
jge 0x2aacc
movq 0x28(%rsp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, 0x28(%rsp)
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x18(%rsp)
movq 0x40(%rsp), %rdi
movl 0x20(%rsp), %esi
movl 0x24(%rsp), %edx
movsd 0x38(%rsp), %xmm0
mulsd 0x18(%rsp), %xmm0
callq 0x2ef50
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x2aa76
jmp 0x2aace
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x2aa62
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x2aaf5
movq 0x10(%rsp), %rdi
callq 0x23d80
movl $0x1, %eax
addq $0x48, %rsp
retq
nop
// File: tomfunkhouser[P]gaps/apps/scn2img/scn2img.cpp
// Function: CaptureInteger(gaps::R2Grid&)
static int
CaptureInteger(R2Grid& image)
{
  // Allocate pixel buffer
  unsigned char *pixels = new unsigned char [ 3 * width * height ];

  // Set packing parameters for glReadPixels
  if ((width % 4) != 0) glPixelStorei(GL_PACK_ALIGNMENT, 1);

  // Run main loop  -- never returns   // Read pixels
  glReadPixels(0, 0, width, height, GL_RGB, GL_UNSIGNED_BYTE, pixels);

  // Fill image
  unsigned char *pixelp = pixels;
  for (int iy = 0; iy < height; iy++) {
    for (int ix = 0; ix < width; ix++) {
      unsigned int red = *pixelp++;
      unsigned int green = *pixelp++;
      unsigned int blue = *pixelp++;
      unsigned int value = 0;
      value |= red << 16;
      value |= green <<  8;
      value |= blue;
      image.SetGridValue(ix, iy, value);
    }
  }

  // Delete pixels
  delete [] pixels;
  
  // Return success
  return 1;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
imull $0x3, 0x1edfa0(%rip), %eax # 0x218ab0
imull 0x1edf9d(%rip), %eax    # 0x218ab4
movslq %eax, %rdi
callq 0x23040
movq %rax, 0x38(%rsp)
movl 0x1edf86(%rip), %eax    # 0x218ab0
movl $0x4, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
je 0x2ab46
movl $0xd05, %edi            # imm = 0xD05
movl $0x1, %esi
callq 0x23470
movl 0x1edf64(%rip), %edx    # 0x218ab0
movl 0x1edf62(%rip), %ecx    # 0x218ab4
movq 0x38(%rsp), %rax
xorl %esi, %esi
movl $0x1907, %r8d           # imm = 0x1907
movl $0x1401, %r9d           # imm = 0x1401
movl %esi, %edi
movq %rax, (%rsp)
callq 0x23420
movq 0x38(%rsp), %rax
movq %rax, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
cmpl 0x1edf28(%rip), %eax    # 0x218ab4
jge 0x2ac64
movl $0x0, 0x28(%rsp)
movl 0x28(%rsp), %eax
cmpl 0x1edf0c(%rip), %eax    # 0x218ab0
jge 0x2ac52
movq 0x30(%rsp), %rax
movq %rax, %rcx
incq %rcx
movq %rcx, 0x30(%rsp)
movzbl (%rax), %eax
movl %eax, 0x24(%rsp)
movq 0x30(%rsp), %rax
movq %rax, %rcx
incq %rcx
movq %rcx, 0x30(%rsp)
movzbl (%rax), %eax
movl %eax, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq %rax, %rcx
incq %rcx
movq %rcx, 0x30(%rsp)
movzbl (%rax), %eax
movl %eax, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movl 0x24(%rsp), %ecx
shll $0x10, %ecx
movl 0x18(%rsp), %eax
orl %ecx, %eax
movl %eax, 0x18(%rsp)
movl 0x20(%rsp), %ecx
shll $0x8, %ecx
movl 0x18(%rsp), %eax
orl %ecx, %eax
movl %eax, 0x18(%rsp)
movl 0x1c(%rsp), %ecx
movl 0x18(%rsp), %eax
orl %ecx, %eax
movl %eax, 0x18(%rsp)
movq 0x40(%rsp), %rdi
movl 0x28(%rsp), %esi
movl 0x2c(%rsp), %edx
movl 0x18(%rsp), %eax
cvtsi2sd %rax, %xmm0
callq 0x2ef50
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x2ab9a
jmp 0x2ac54
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x2ab82
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x2ac7e
movq 0x10(%rsp), %rdi
callq 0x23d80
movl $0x1, %eax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/scn2img/scn2img.cpp
// Function: main
int main(int argc, char **argv)
{
  // Parse program arguments
  if (!ParseArgs(argc, argv)) exit(-1);

  // Read scene
  if (!ReadScene(input_scene_name)) exit(-1);

  // Read cameras 
  if (!ReadCameras(input_cameras_name)) exit(-1);

  // Read categories
  if (input_categories_name) {
    if (!ReadCategories(input_categories_name)) exit(-1);
  }

  // Read/create lights
  if (input_lights_name) { if (!ReadLights(input_lights_name)) exit(-1); }
  else { scene->CreateDirectionalLights(); headlight = 1; }

  // Write node names
  if (output_nodes_filename) {
    if (!WriteNodeNames(output_nodes_filename)) exit(-1);
  }

  // Render images
  if (!RenderImages(output_image_directory)) exit(-1);

  // Return success 
  return 0;
}

// Assembly:
subq $0x18, %rsp
movl $0x0, 0x14(%rsp)
movl %edi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl 0x10(%rsp), %edi
movq 0x8(%rsp), %rsi
callq 0x2b280
cmpl $0x0, %eax
jne 0x2b192
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x23c30
movq 0x1f3a9f(%rip), %rdi    # 0x21ec38
callq 0x2bdb0
cmpq $0x0, %rax
jne 0x2b1ae
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x23c30
movq 0x1f3a8b(%rip), %rdi    # 0x21ec40
callq 0x2bfc0
cmpl $0x0, %eax
jne 0x2b1c9
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x23c30
cmpq $0x0, 0x1f3a77(%rip)    # 0x21ec48
je 0x2b1f0
movq 0x1f3a6e(%rip), %rdi    # 0x21ec48
callq 0x2c400
cmpl $0x0, %eax
jne 0x2b1ee
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x23c30
jmp 0x2b1f0
cmpq $0x0, 0x1f3a58(%rip)    # 0x21ec50
je 0x2b217
movq 0x1f3a4f(%rip), %rdi    # 0x21ec50
callq 0x2c4a0
cmpl $0x0, %eax
jne 0x2b215
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x23c30
jmp 0x2b22d
movq 0x1f399a(%rip), %rdi    # 0x21ebb8
callq 0x31d90
movl $0x1, 0x1f39b3(%rip)    # 0x21ebe0
cmpq $0x0, 0x1f3a23(%rip)    # 0x21ec58
je 0x2b254
movq 0x1f3a1a(%rip), %rdi    # 0x21ec58
callq 0x2c590
cmpl $0x0, %eax
jne 0x2b252
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x23c30
jmp 0x2b254
movq 0x1f3995(%rip), %rdi    # 0x21ebf0
callq 0x2c710
cmpl $0x0, %eax
jne 0x2b26f
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x23c30
xorl %eax, %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/scn2img/scn2img.cpp
// Function: ReadLights(char const*)
static int
ReadLights(const char *filename)
{
  // Start statistics
  RNTime start_time;
  start_time.Read();

  // Read lights file
  if (!scene->ReadSUNCGLightsFile(filename)) return 0;

  // Set default vertex spacing
  if (max_vertex_spacing == 0) max_vertex_spacing = 0.1;

  // Print statistics
  if (print_verbose) {
    printf("Read lights from %s ...\n", filename);
    printf("  Time = %.2f seconds\n", start_time.Elapsed());
    printf("  # Lights = %d\n", scene->NLights());
    printf("  Max vertex spacing = %g\n", max_vertex_spacing);
    fflush(stdout);
  }

  // Return success
  return 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x10e120
leaq 0x8(%rsp), %rdi
callq 0x2ed70
movq 0x1f26f4(%rip), %rdi    # 0x21ebb8
movq 0x18(%rsp), %rsi
callq 0x45520
cmpl $0x0, %eax
jne 0x2c4e0
movl $0x0, 0x24(%rsp)
jmp 0x2c580
movsd 0x1f2810(%rip), %xmm0   # 0x21ecf8
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x2c503
jp 0x2c503
movsd 0x180b65(%rip), %xmm0   # 0x1ad060
movsd %xmm0, 0x1f27f5(%rip)   # 0x21ecf8
cmpl $0x0, 0x1f26d2(%rip)    # 0x21ebdc
je 0x2c578
movq 0x18(%rsp), %rsi
leaq 0x181231(%rip), %rdi    # 0x1ad749
movb $0x0, %al
callq 0x23090
leaq 0x8(%rsp), %rdi
callq 0x10e1e0
leaq 0x180ba0(%rip), %rdi    # 0x1ad0d0
movb $0x1, %al
callq 0x23090
movq 0x1f267a(%rip), %rdi    # 0x21ebb8
callq 0x2f0e0
movl %eax, %esi
leaq 0x181130(%rip), %rdi    # 0x1ad67c
movb $0x0, %al
callq 0x23090
movsd 0x1f279d(%rip), %xmm0   # 0x21ecf8
leaq 0x181200(%rip), %rdi    # 0x1ad762
movb $0x1, %al
callq 0x23090
movq 0x1eba20(%rip), %rax    # 0x217f90
movq (%rax), %rdi
callq 0x23bd0
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/apps/scn2img/scn2img.cpp
// Function: RenderImages(char const*)
static int
RenderImages(const char *output_image_directory)
{
  // Subdivide triangles (for lighting)
  if (max_vertex_spacing > 0) scene->SubdivideTriangles(max_vertex_spacing);

  // Render images
  if (glut) { if (!RenderImagesWithGlut(output_image_directory)) exit(-1); }
  else if (mesa) { if (!RenderImagesWithMesa(output_image_directory)) exit(-1); }
  else { if (!RenderImagesWithRaycasting(output_image_directory)) exit(-1); }

  // Return success
  return 1;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movsd 0x1f25db(%rip), %xmm0   # 0x21ecf8
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x2c73a
movq 0x1f248b(%rip), %rdi    # 0x21ebb8
movsd 0x1f25c3(%rip), %xmm0   # 0x21ecf8
callq 0x31af0
cmpl $0x0, 0x1ec39f(%rip)    # 0x218ae0
je 0x2c75d
movq (%rsp), %rdi
callq 0x2dae0
cmpl $0x0, %eax
jne 0x2c75b
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x23c30
jmp 0x2c79c
cmpl $0x0, 0x1f258c(%rip)    # 0x21ecf0
je 0x2c780
movq (%rsp), %rdi
callq 0x2dbd0
cmpl $0x0, %eax
jne 0x2c77e
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x23c30
jmp 0x2c79a
movq (%rsp), %rdi
callq 0x2dbf0
cmpl $0x0, %eax
jne 0x2c798
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x23c30
jmp 0x2c79a
jmp 0x2c79c
movl $0x1, %eax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/scn2img/scn2img.cpp
// Function: DrawRootWithOpenGL(gaps::R3Camera const&, gaps::R3Scene*, int, int)
static void
DrawRootWithOpenGL(const R3Camera& camera, R3Scene *scene, int color_scheme, RNBoolean omit_objects = FALSE)
{
  // This is a hack to account for coincident front and back faces
  glDepthRange(0, 0.999999);
  glEnable(GL_CULL_FACE);
  R3null_material.Draw();
  DrawNodeWithOpenGL(camera, scene, scene->Root(), color_scheme, omit_objects);
  glDisable(GL_CULL_FACE);
  glDepthRange(0, 1);
  R3null_material.Draw();
  DrawNodeWithOpenGL(camera, scene, scene->Root(), color_scheme, omit_objects);
  R3null_material.Draw();
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movl %ecx, 0x20(%rsp)
xorps %xmm0, %xmm0
movsd 0x1808cf(%rip), %xmm1   # 0x1ad0a0
callq 0x241f0
movl $0xb44, %edi            # imm = 0xB44
callq 0x238e0
leaq 0x1f2959(%rip), %rdi    # 0x21f140
xorl %esi, %esi
callq 0x67b80
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
callq 0x2f060
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
movl 0x24(%rsp), %ecx
movl 0x20(%rsp), %r8d
callq 0x2c8a0
movl $0xb44, %edi            # imm = 0xB44
callq 0x23220
xorps %xmm0, %xmm0
movsd 0x18080e(%rip), %xmm1   # 0x1ad048
callq 0x241f0
leaq 0x1f28fa(%rip), %rdi    # 0x21f140
xorl %esi, %esi
callq 0x67b80
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
callq 0x2f060
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq %rax, %rdx
movl 0x24(%rsp), %ecx
movl 0x20(%rsp), %r8d
callq 0x2c8a0
leaq 0x1f28b3(%rip), %rdi    # 0x21f140
xorl %esi, %esi
callq 0x67b80
addq $0x38, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/apps/scn2img/scn2img.cpp
// Function: LoadInteger(int)
static void
LoadInteger(int value)
{
  // Set color to represent an integer (24 bits)
  unsigned char color[4];
  color[0] = (value >> 16) & 0xFF;
  color[1] = (value >>  8) & 0xFF;
  color[2] = (value      ) & 0xFF;
  RNLoadRgb(color);
}

// Assembly:
pushq %rax
movl %edi, 0x4(%rsp)
movl 0x4(%rsp), %eax
sarl $0x10, %eax
andl $0xff, %eax
movb %al, (%rsp)
movl 0x4(%rsp), %eax
sarl $0x8, %eax
andl $0xff, %eax
movb %al, 0x1(%rsp)
movl 0x4(%rsp), %eax
andl $0xff, %eax
movb %al, 0x2(%rsp)
movq %rsp, %rdi
callq 0x2f540
popq %rax
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/scn2img/scn2img.cpp
// Function: EstimateGroundY(gaps::R3Camera const&, gaps::R3Scene*)
static RNScalar
EstimateGroundY(const R3Camera& camera, R3Scene *scene)
{
  // Get convenient variables
  if (!scene) return 0;

  // Check if scene has a node named "Room#*" containing camera
  for (int i = 0; i < scene->NNodes(); i++) {
    R3SceneNode *node = scene->Node(i);
    if (node->Name() && !strncmp(node->Name(), "Room#", 5)) {
      if (R3Contains(node->BBox(), camera.Origin())) {
        return node->BBox().YMin();
      }
    }
  }

#if 0
  // Check first intersection with ray cast straight down
  if (R3Contains(scene->BBox(), camera.Origin())) {
    R3Ray ray(camera.Origin(), R3negy_vector);
    R3Point position;
    R3Vector normal;
    if (scene->Intersects(ray, NULL, NULL, NULL, &position, &normal)) {
      if (normal.Y() > 0.9) return position.Y();
    }
  }
#endif
  
  // If all else fails, return bounding box ymin
  return scene->BBox().YMin();
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x2d9a4
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rsp)
jmp 0x2da81
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rdi
callq 0x30040
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x2da69
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x30060
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x2f070
cmpq $0x0, %rax
je 0x2da57
movq 0x10(%rsp), %rdi
callq 0x2f070
movq %rax, %rdi
leaq 0x17f936(%rip), %rsi    # 0x1ad339
movl $0x5, %edx
callq 0x23440
cmpl $0x0, %eax
jne 0x2da57
movq 0x10(%rsp), %rdi
callq 0x5a400
movq %rax, (%rsp)
movq 0x28(%rsp), %rdi
callq 0x2f380
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x77eb0
cmpl $0x0, %eax
je 0x2da55
movq 0x10(%rsp), %rdi
callq 0x5a400
movq %rax, %rdi
callq 0x30090
movsd %xmm0, 0x30(%rsp)
jmp 0x2da81
jmp 0x2da57
jmp 0x2da59
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x2d9ac
movq 0x20(%rsp), %rdi
callq 0x300b0
movq %rax, %rdi
callq 0x30090
movsd %xmm0, 0x30(%rsp)
movsd 0x30(%rsp), %xmm0
addq $0x38, %rsp
retq
nopl (%rax)