LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: AndrewAlbert[P]Compiler-Theory/SourceCode/codeGenerator.cpp
// Function: codeGenerator::~codeGenerator()
codeGenerator::~codeGenerator(){
	if( testOutFile() ){
		buildBranchTable();
		buildHeap();
		fprintf( oFile, "\nPROGRAM_END:\n" );
		footer();
		fclose( oFile );
	}
	else if( oFile != nullptr ){ 
			fclose( oFile );
	//Remove the generated file if there was an error
	}
	if( ContinueToGenerate == false && outputName.compare("") != 0 ) remove(outputName.c_str());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x19340
movb %al, -0x9(%rbp)
jmp 0x1917e
movb -0x9(%rbp), %al
testb $0x1, %al
jne 0x19187
jmp 0x191d5
movq -0x18(%rbp), %rdi
callq 0x19390
jmp 0x19192
movq -0x18(%rbp), %rdi
callq 0x19420
jmp 0x1919d
movq -0x18(%rbp), %rax
movq 0x308(%rax), %rdi
leaq 0xdb3f(%rip), %rsi      # 0x26cee
xorl %eax, %eax
callq 0x3380
movq -0x18(%rbp), %rdi
callq 0x19520
jmp 0x191c1
movq -0x18(%rbp), %rax
movq 0x308(%rax), %rdi
callq 0x3280
jmp 0x191d3
jmp 0x191f9
movq -0x18(%rbp), %rax
cmpq $0x0, 0x308(%rax)
je 0x191f7
movq -0x18(%rbp), %rax
movq 0x308(%rax), %rdi
callq 0x3280
jmp 0x191f5
jmp 0x191f7
jmp 0x191f9
movq -0x18(%rbp), %rax
movb 0x330(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x19241
movq -0x18(%rbp), %rdi
addq $0x310, %rdi            # imm = 0x310
leaq 0xda62(%rip), %rsi      # 0x26c81
callq 0x30d0
cmpl $0x0, %eax
je 0x19241
movq -0x18(%rbp), %rdi
addq $0x310, %rdi            # imm = 0x310
callq 0x3120
movq %rax, %rdi
callq 0x3450
movq -0x18(%rbp), %rdi
addq $0x310, %rdi            # imm = 0x310
callq 0x31a0
movq -0x18(%rbp), %rdi
addq $0x2b8, %rdi            # imm = 0x2B8
callq 0x1f2a0
movq -0x18(%rbp), %rdi
addq $0x250, %rdi            # imm = 0x250
callq 0x1f2c0
movq -0x18(%rbp), %rdi
addq $0x228, %rdi            # imm = 0x228
callq 0x1f2e0
movq -0x18(%rbp), %rdi
addq $0x1d0, %rdi            # imm = 0x1D0
callq 0x1f300
movq -0x18(%rbp), %rdi
addq $0x180, %rdi            # imm = 0x180
callq 0x1f300
movq -0x18(%rbp), %rdi
addq $0x130, %rdi            # imm = 0x130
callq 0x1f300
movq -0x18(%rbp), %rdi
addq $0xf0, %rdi
callq 0x1f320
movq -0x18(%rbp), %rdi
addq $0xc8, %rdi
callq 0x31a0
movq -0x18(%rbp), %rdi
addq $0xa8, %rdi
callq 0x31a0
movq -0x18(%rbp), %rdi
addq $0x88, %rdi
callq 0x31a0
movq -0x18(%rbp), %rdi
addq $0x68, %rdi
callq 0x31a0
movq -0x18(%rbp), %rdi
addq $0x48, %rdi
callq 0x31a0
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
callq 0x31a0
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x31a0
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x61a0
nopw %cs:(%rax,%rax)
// File: AndrewAlbert[P]Compiler-Theory/SourceCode/codeGenerator.cpp
// Function: codeGenerator::buildBranchTable()
bool codeGenerator::buildBranchTable(){
	fprintf( oFile, "\n   goto PROGRAM_END;\n" );
	fprintf( oFile, "\nBRANCH_TABLE:\n" );
	if( !branchTable.empty() ){
		createEntry(0, branchTable.size() - 1);
	}
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x308(%rax), %rdi
leaq 0xe35e(%rip), %rsi      # 0x27710
movb $0x0, %al
callq 0x3380
movq -0x10(%rbp), %rax
movq 0x308(%rax), %rdi
leaq 0xe35c(%rip), %rsi      # 0x27727
movb $0x0, %al
callq 0x3380
movq -0x10(%rbp), %rdi
addq $0xf0, %rdi
callq 0x1f610
testb $0x1, %al
jne 0x19407
movq -0x10(%rbp), %rdi
addq $0xf0, %rdi
callq 0x1f630
movq -0x10(%rbp), %rdi
subq $0x1, %rax
movl %eax, %edx
xorl %esi, %esi
callq 0x1eeb0
movb $0x1, %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: AndrewAlbert[P]Compiler-Theory/SourceCode/codeGenerator.cpp
// Function: codeGenerator::buildHeap()
void codeGenerator::buildHeap(){
	fprintf( oFile, "\nBUILD_HEAP:\n" );
	while( string_heap.size() > 0 ){
		stringEntry = string_heap.front();
		string_heap.pop();
		fprintf( oFile, "   strcpy((char*)&MM[%d], %s);\n", stringEntry.MMlocation, stringEntry.contents.c_str() );
		fprintf( oFile, "   TP_reg = %d;\n", stringEntry.MMlocation );
	}
	fprintf( oFile, "   goto Label_0_Begin_Program;\n" );
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x308(%rax), %rdi
leaq 0xdd53(%rip), %rsi      # 0x27195
movb $0x0, %al
callq 0x3380
movq -0x10(%rbp), %rdi
addq $0x250, %rdi            # imm = 0x250
callq 0x1f400
cmpq $0x0, %rax
jbe 0x194fa
movq -0x10(%rbp), %rdi
addq $0x250, %rdi            # imm = 0x250
callq 0x1f420
movq -0x10(%rbp), %rdi
movq %rax, %rsi
addq $0x228, %rdi            # imm = 0x228
callq 0x1f440
movq -0x10(%rbp), %rdi
addq $0x250, %rdi            # imm = 0x250
callq 0x1f480
movq -0x10(%rbp), %rdi
movq 0x308(%rdi), %rax
movq %rax, -0x20(%rbp)
movl 0x228(%rdi), %eax
movl %eax, -0x14(%rbp)
addq $0x228, %rdi            # imm = 0x228
addq $0x8, %rdi
callq 0x3120
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %edx
movq %rax, %rcx
leaq 0xdcd4(%rip), %rsi      # 0x271a3
movb $0x0, %al
callq 0x3380
movq -0x10(%rbp), %rax
movq 0x308(%rax), %rdi
movl 0x228(%rax), %edx
leaq 0xdcd5(%rip), %rsi      # 0x271c3
movb $0x0, %al
callq 0x3380
jmp 0x19449
movq -0x10(%rbp), %rax
movq 0x308(%rax), %rdi
leaq 0xdcc8(%rip), %rsi      # 0x271d4
movb $0x0, %al
callq 0x3380
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: AndrewAlbert[P]Compiler-Theory/SourceCode/codeGenerator.cpp
// Function: codeGenerator::attachOutputFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool codeGenerator::attachOutputFile(string filename){
	outputName = filename;
	oFile = fopen( filename.c_str(), "w" );
	if( testOutFile() ){
		header();
		return true;
	}
	else{
		perror("Failed to open output file for writing.");
		fclose( oFile );
		ContinueToGenerate = false;
		return false;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x310, %rdi            # imm = 0x310
callq 0x3050
movq -0x28(%rbp), %rdi
callq 0x3120
movq %rax, %rdi
leaq 0xd702(%rip), %rsi      # 0x26cfd
callq 0x3320
movq -0x20(%rbp), %rdi
movq %rax, 0x308(%rdi)
callq 0x19340
testb $0x1, %al
jne 0x19616
jmp 0x19625
movq -0x20(%rbp), %rdi
callq 0x19660
movb $0x1, -0x1(%rbp)
jmp 0x19650
leaq 0xd6d3(%rip), %rdi      # 0x26cff
callq 0x3230
movq -0x20(%rbp), %rax
movq 0x308(%rax), %rdi
callq 0x3280
movq -0x20(%rbp), %rax
movb $0x0, 0x330(%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: AndrewAlbert[P]Compiler-Theory/SourceCode/codeGenerator.cpp
// Function: codeGenerator::comment(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool)
void codeGenerator::comment(string str, bool multi_line){
	if( multi_line ){
		fprintf( oFile, "\n" );
		fprintf( oFile, "// %s\n", str.c_str() );
		fprintf( oFile, "\n" );
	}
	else fprintf( oFile, "// %s\n", str.c_str() );
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x28(%rbp)
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
testb $0x1, -0x11(%rbp)
je 0x19c3a
movq -0x20(%rbp), %rax
movq 0x308(%rax), %rdi
leaq 0xd327(%rip), %rsi      # 0x26f12
movb $0x0, %al
callq 0x3380
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x308(%rax), %rax
movq %rax, -0x30(%rbp)
callq 0x3120
movq -0x30(%rbp), %rdi
movq %rax, %rdx
leaq 0xd10f(%rip), %rsi      # 0x26d27
movb $0x0, %al
callq 0x3380
movq -0x20(%rbp), %rax
movq 0x308(%rax), %rdi
leaq 0xd2e1(%rip), %rsi      # 0x26f12
movb $0x0, %al
callq 0x3380
jmp 0x19c67
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x308(%rax), %rax
movq %rax, -0x38(%rbp)
callq 0x3120
movq -0x38(%rbp), %rdi
movq %rax, %rdx
leaq 0xd0c7(%rip), %rsi      # 0x26d27
movb $0x0, %al
callq 0x3380
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: AndrewAlbert[P]Compiler-Theory/SourceCode/codeGenerator.cpp
// Function: codeGenerator::typeString[abi:cxx11](int)
string codeGenerator::typeString( int type ){
	switch( type ){
		case TYPE_CHAR: 
			return "char";
		case TYPE_INTEGER:
			return "int";
		case TYPE_FLOAT:
			return"float";
		case TYPE_BOOL:
			return "int";
		case TYPE_STRING: 
			return "char*";
		default: 
			return "ERROR:";
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
addl $0xfffffef6, %eax       # imm = 0xFFFFFEF6
movl %eax, %ecx
movq %rcx, -0x38(%rbp)
subl $0x4, %eax
ja 0x1a64d
movq -0x38(%rbp), %rax
leaq 0xc7e1(%rip), %rcx      # 0x26cb4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq -0x15(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x3430
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rdx
leaq 0xcb67(%rip), %rsi      # 0x2705f
callq 0x62d0
jmp 0x1a4ff
leaq -0x15(%rbp), %rdi
callq 0x32e0
jmp 0x1a692
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x15(%rbp), %rdi
callq 0x32e0
jmp 0x1a69f
leaq -0x25(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x3430
movq -0x48(%rbp), %rdi
movq -0x58(%rbp), %rdx
leaq 0xcb21(%rip), %rsi      # 0x27064
callq 0x62d0
jmp 0x1a54a
leaq -0x25(%rbp), %rdi
callq 0x32e0
jmp 0x1a692
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x25(%rbp), %rdi
callq 0x32e0
jmp 0x1a69f
leaq -0x26(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x3430
movq -0x48(%rbp), %rdi
movq -0x60(%rbp), %rdx
leaq 0xcada(%rip), %rsi      # 0x27068
callq 0x62d0
jmp 0x1a595
leaq -0x26(%rbp), %rdi
callq 0x32e0
jmp 0x1a692
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x26(%rbp), %rdi
callq 0x32e0
jmp 0x1a69f
leaq -0x27(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x3430
movq -0x48(%rbp), %rdi
movq -0x68(%rbp), %rdx
leaq 0xca8b(%rip), %rsi      # 0x27064
callq 0x62d0
jmp 0x1a5e0
leaq -0x27(%rbp), %rdi
callq 0x32e0
jmp 0x1a692
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x27(%rbp), %rdi
callq 0x32e0
jmp 0x1a69f
leaq -0x28(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x3430
movq -0x48(%rbp), %rdi
movq -0x70(%rbp), %rdx
leaq 0xca4a(%rip), %rsi      # 0x2706e
callq 0x62d0
jmp 0x1a62b
leaq -0x28(%rbp), %rdi
callq 0x32e0
jmp 0x1a692
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x32e0
jmp 0x1a69f
leaq -0x29(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x3430
movq -0x48(%rbp), %rdi
movq -0x78(%rbp), %rdx
leaq 0xca0b(%rip), %rsi      # 0x27074
callq 0x62d0
jmp 0x1a670
leaq -0x29(%rbp), %rdi
callq 0x32e0
jmp 0x1a692
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x29(%rbp), %rdi
callq 0x32e0
jmp 0x1a69f
movq -0x40(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x3420
nopl (%rax,%rax)
// File: AndrewAlbert[P]Compiler-Theory/SourceCode/codeGenerator.cpp
// Function: codeGenerator::pushStack(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char, int)
void codeGenerator::pushStack( string value, char stackID, int type ){
	if( !ShouldGenerate() ) return;
	switch( stackID ){
		case 'L':
			leftStack.push( value );
			break;
		case 'E':
			exprStack.push( value );
			if( type == TYPE_FLOAT ) freg_in_use++;
			else ireg_in_use++;
			break;
		case 'R':
			rightStack.push( value );
			break;
		default:
			cout << "Not a valid expression stack!\n";
			break;
	}
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x28(%rbp)
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x19590
testb $0x1, %al
jne 0x1a6e2
jmp 0x1a78c
movsbl -0x11(%rbp), %eax
movl %eax, -0x2c(%rbp)
subl $0x45, %eax
je 0x1a71a
jmp 0x1a6f0
movl -0x2c(%rbp), %eax
subl $0x4c, %eax
je 0x1a704
jmp 0x1a6fa
movl -0x2c(%rbp), %eax
subl $0x52, %eax
je 0x1a761
jmp 0x1a777
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdi
addq $0x1d0, %rdi            # imm = 0x1D0
callq 0x1f340
jmp 0x1a78a
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdi
addq $0x130, %rdi            # imm = 0x130
callq 0x1f340
cmpl $0x10b, -0x18(%rbp)     # imm = 0x10B
jne 0x1a74c
movq -0x20(%rbp), %rax
movl 0x124(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x124(%rax)
jmp 0x1a75f
movq -0x20(%rbp), %rax
movl 0x120(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x120(%rax)
jmp 0x1a78a
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdi
addq $0x180, %rdi            # imm = 0x180
callq 0x1f340
jmp 0x1a78a
movq 0x18852(%rip), %rdi     # 0x32fd0
leaq 0xc8f6(%rip), %rsi      # 0x2707b
callq 0x3270
jmp 0x1a78c
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: AndrewAlbert[P]Compiler-Theory/SourceCode/codeGenerator.cpp
// Function: codeGenerator::AddStringHeap(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int codeGenerator::AddStringHeap( string str ){
	if( !ShouldGenerate() ) return -1;
	HeapSize += ( str.size() + 1);
	stringEntry.MMlocation = HeapSize;
	stringEntry.contents = str;
	string_heap.push(stringEntry);
	return HeapSize;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x19590
testb $0x1, %al
jne 0x1c48e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1c4f9
movq -0x28(%rbp), %rdi
callq 0x31e0
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdi
movq %rax, %rcx
addq $0x1, %rcx
movslq 0x220(%rdi), %rax
addq %rcx, %rax
movl %eax, 0x220(%rdi)
movl 0x220(%rdi), %eax
movl %eax, 0x228(%rdi)
addq $0x228, %rdi            # imm = 0x228
addq $0x8, %rdi
callq 0x3050
movq -0x20(%rbp), %rsi
movq %rsi, %rdi
addq $0x250, %rdi            # imm = 0x250
addq $0x228, %rsi            # imm = 0x228
callq 0x1f3d0
movq -0x20(%rbp), %rax
movl 0x220(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: AndrewAlbert[P]Compiler-Theory/SourceCode/codeGenerator.cpp
// Function: codeGenerator::NegateTopRegisters(int, int)
void codeGenerator::NegateTopRegisters( int type, int size ){
	if( !ShouldGenerate() ) return;
	string reg;
	int i;
	// Ensure size is at least 1 for loops
	if( size == 0 ) size++;
	
	for( i = 0; i < size; i++ ){
		reg = popStack('E', type);
		pushStack( reg, 'L', type );
	}
	for( i = 0; i < size; i++ ){
		reg = popStack('L', type);
		pushStack( reg, 'E', type );
		fprintf( oFile, "   %s = -%s;\n", reg.c_str(), reg.c_str() );
	}
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x19590
testb $0x1, %al
jne 0x1c53e
jmp 0x1c747
leaq -0x30(%rbp), %rdi
callq 0x3370
cmpl $0x0, -0x10(%rbp)
jne 0x1c556
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x1c624
movq -0xd0(%rbp), %rsi
movl -0xc(%rbp), %ecx
leaq -0x58(%rbp), %rdi
movl $0x45, %edx
callq 0x1a7a0
jmp 0x1c583
leaq -0x30(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
leaq -0x58(%rbp), %rsi
movq %rsi, -0xe0(%rbp)
callq 0x3340
movq -0xe0(%rbp), %rdi
callq 0x31a0
movq -0xd8(%rbp), %rsi
leaq -0x88(%rbp), %rdi
callq 0x3130
jmp 0x1c5bf
movq -0xd0(%rbp), %rdi
movl -0xc(%rbp), %ecx
leaq -0x88(%rbp), %rsi
movl $0x4c, %edx
callq 0x1a6b0
jmp 0x1c5dc
leaq -0x88(%rbp), %rdi
callq 0x31a0
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x1c55d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x1c73c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x31a0
jmp 0x1c73c
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x1c731
movq -0xd0(%rbp), %rsi
movl -0xc(%rbp), %ecx
leaq -0xa8(%rbp), %rdi
movl $0x4c, %edx
callq 0x1a7a0
jmp 0x1c654
leaq -0x30(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
leaq -0xa8(%rbp), %rsi
movq %rsi, -0xf0(%rbp)
callq 0x3340
movq -0xf0(%rbp), %rdi
callq 0x31a0
movq -0xe8(%rbp), %rsi
leaq -0xc8(%rbp), %rdi
callq 0x3130
jmp 0x1c693
movq -0xd0(%rbp), %rdi
movl -0xc(%rbp), %ecx
leaq -0xc8(%rbp), %rsi
movl $0x45, %edx
callq 0x1a6b0
jmp 0x1c6b0
leaq -0xc8(%rbp), %rdi
callq 0x31a0
movq -0xd0(%rbp), %rax
movq 0x308(%rax), %rax
movq %rax, -0x100(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3120
movq %rax, -0xf8(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3120
movq -0x100(%rbp), %rdi
movq -0xf8(%rbp), %rdx
movq %rax, %rcx
leaq 0xaaf2(%rip), %rsi      # 0x271f4
movb $0x0, %al
callq 0x3380
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x1c62b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0x31a0
jmp 0x1c73c
leaq -0x30(%rbp), %rdi
callq 0x31a0
jmp 0x1c747
leaq -0x30(%rbp), %rdi
callq 0x31a0
jmp 0x1c750
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x3420
nopl (%rax)
// File: AndrewAlbert[P]Compiler-Theory/SourceCode/codeGenerator.cpp
// Function: codeGenerator::setProcedurePointers(int)
void codeGenerator::setProcedurePointers( int frameSize ){
	if( !ShouldGenerate() ) return;
	comment( "Set FP and SP using the caller's FP/SP values and the new frame size" );
	fprintf( oFile, "   FP_reg = SP_reg;\n" );
	fprintf( oFile, "   SP_reg = FP_reg + %d;\n", frameSize);
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x19590
testb $0x1, %al
jne 0x1e0e5
jmp 0x1e177
leaq -0x31(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x3430
movq -0x58(%rbp), %rdx
leaq 0x91e8(%rip), %rsi      # 0x272e5
leaq -0x30(%rbp), %rdi
callq 0x62d0
jmp 0x1e108
movq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
xorl %edx, %edx
callq 0x19bb0
leaq -0x30(%rbp), %rdi
callq 0x31a0
leaq -0x31(%rbp), %rdi
callq 0x32e0
movq -0x50(%rbp), %rax
movq 0x308(%rax), %rdi
leaq 0x91ef(%rip), %rsi      # 0x2732a
movb $0x0, %al
callq 0x3380
movq -0x50(%rbp), %rax
movq 0x308(%rax), %rdi
movl -0xc(%rbp), %edx
leaq 0x91e8(%rip), %rsi      # 0x2733f
movb $0x0, %al
callq 0x3380
jmp 0x1e177
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x32e0
jmp 0x1e17d
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3420
nopw %cs:(%rax,%rax)
// File: AndrewAlbert[P]Compiler-Theory/SourceCode/codeGenerator.cpp
// Function: codeGenerator::callProcedure(scopeValue, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void codeGenerator::callProcedure( scopeValue procValue, string id ){
	if( !ShouldGenerate() ) return;
	
	comment( "Call procedure" );
	fprintf( oFile, "   MM[SP_reg] = FP_reg;\n" );
	fprintf( oFile, "   MM[SP_reg + 1] = %d;\n", call_count );
	fprintf( oFile, "   goto %s;\n", procValue.CallLabel.c_str() );
	
	string retLabel = newReturnLabel(id);
	placeLabel( retLabel );
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rsi, -0xc8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x19590
testb $0x1, %al
jne 0x1e1ce
jmp 0x1e37b
leaq -0x39(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x3430
movq -0xd0(%rbp), %rdx
leaq 0x916d(%rip), %rsi      # 0x27359
leaq -0x38(%rbp), %rdi
callq 0x62d0
jmp 0x1e1f7
movq -0xb8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
movq %rsi, -0xf8(%rbp)
xorl %edx, %edx
movl %edx, -0xec(%rbp)
callq 0x19bb0
movq -0xf8(%rbp), %rdi
callq 0x31a0
leaq -0x39(%rbp), %rdi
callq 0x32e0
movl -0xec(%rbp), %eax
movq -0xb8(%rbp), %rcx
movq 0x308(%rcx), %rdi
leaq 0x9122(%rip), %rsi      # 0x27368
movb %al, -0xd9(%rbp)
callq 0x3380
movq -0xb8(%rbp), %rcx
movb -0xd9(%rbp), %al
movq 0x308(%rcx), %rdi
movl 0xe8(%rcx), %edx
leaq 0x910f(%rip), %rsi      # 0x27381
callq 0x3380
movq -0xc8(%rbp), %rdi
movq -0xb8(%rbp), %rax
movq 0x308(%rax), %rax
movq %rax, -0xe8(%rbp)
addq $0x20, %rdi
callq 0x3120
movq -0xe8(%rbp), %rdi
movq %rax, %rdx
movb -0xd9(%rbp), %al
leaq 0x90e7(%rip), %rsi      # 0x2739a
callq 0x3380
movq -0xc0(%rbp), %rsi
leaq -0x90(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x3130
movq -0xb8(%rbp), %rsi
movq -0xd8(%rbp), %rdx
leaq -0x70(%rbp), %rdi
callq 0x1e390
jmp 0x1e2eb
leaq -0x90(%rbp), %rdi
callq 0x31a0
leaq -0xb0(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x3130
jmp 0x1e309
movq -0xb8(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x1e060
leaq -0xb0(%rbp), %rdi
callq 0x31a0
leaq -0x70(%rbp), %rdi
callq 0x31a0
jmp 0x1e37b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0x32e0
jmp 0x1e384
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x31a0
jmp 0x1e384
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x31a0
jmp 0x1e384
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3420
nopl (%rax)
// File: AndrewAlbert[P]Compiler-Theory/SourceCode/codeGenerator.cpp
// Function: codeGenerator::newReturnLabel(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string codeGenerator::newReturnLabel( string prefix ){
	string label = "Label_Return_" + to_string(call_count) + "_" + prefix;
	branchTable[call_count] = label;
	call_count++;
	return label;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdx, -0xb8(%rbp)
movq %rdi, -0xb0(%rbp)
movq %rdi, %rax
movq %rax, -0xa8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
movb $0x0, -0x19(%rbp)
movl 0xe8(%rax), %esi
leaq -0x80(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x123d0
movq -0x98(%rbp), %rdx
leaq 0x9310(%rip), %rsi      # 0x27702
leaq -0x60(%rbp), %rdi
callq 0x12380
jmp 0x1e3fd
leaq 0x760f(%rip), %rdx      # 0x25a13
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x12330
jmp 0x1e413
movq -0xb8(%rbp), %rdx
movq -0xb0(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x122e0
jmp 0x1e42c
leaq -0x40(%rbp), %rdi
callq 0x31a0
leaq -0x60(%rbp), %rdi
callq 0x31a0
leaq -0x80(%rbp), %rdi
callq 0x31a0
movq -0xa0(%rbp), %rsi
movq %rsi, %rdi
addq $0xf0, %rdi
addq $0xe8, %rsi
callq 0x1f530
movq %rax, -0xc0(%rbp)
jmp 0x1e46d
movq -0xb0(%rbp), %rsi
movq -0xc0(%rbp), %rdi
callq 0x3050
jmp 0x1e482
movq -0xa0(%rbp), %rax
movl 0xe8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xe8(%rax)
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x1e52b
jmp 0x1e51f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x1e4f4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x1e4eb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x31a0
leaq -0x60(%rbp), %rdi
callq 0x31a0
leaq -0x80(%rbp), %rdi
callq 0x31a0
jmp 0x1e53b
movq -0xb0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
callq 0x31a0
jmp 0x1e53b
movq -0xb0(%rbp), %rdi
callq 0x31a0
movq -0xa8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0x3420
nopw (%rax,%rax)
// File: AndrewAlbert[P]Compiler-Theory/SourceCode/codeGenerator.cpp
// Function: codeGenerator::ProcedureReturn()
void codeGenerator::ProcedureReturn(){
	if( !ShouldGenerate() ) return;
	comment( "Procedure return" );
	fprintf( oFile, "   TP_reg = MM[FP_reg + 1];\n" );
	fprintf( oFile, "   FP_reg = MM[FP_reg];\n" );
	fprintf( oFile, "   goto BRANCH_TABLE;\n" );
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x19590
testb $0x1, %al
jne 0x1e572
jmp 0x1e61a
leaq -0x29(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x3430
movq -0x50(%rbp), %rdx
leaq 0x8e1d(%rip), %rsi      # 0x273a7
leaq -0x28(%rbp), %rdi
callq 0x62d0
jmp 0x1e595
movq -0x48(%rbp), %rdi
leaq -0x28(%rbp), %rsi
xorl %edx, %edx
callq 0x19bb0
leaq -0x28(%rbp), %rdi
callq 0x31a0
leaq -0x29(%rbp), %rdi
callq 0x32e0
movq -0x48(%rbp), %rax
movq 0x308(%rax), %rdi
leaq 0x8df0(%rip), %rsi      # 0x273b8
movb $0x0, %al
callq 0x3380
movq -0x48(%rbp), %rax
movq 0x308(%rax), %rdi
leaq 0x8df4(%rip), %rsi      # 0x273d5
movb $0x0, %al
callq 0x3380
movq -0x48(%rbp), %rax
movq 0x308(%rax), %rdi
leaq 0x8df4(%rip), %rsi      # 0x273ee
movb $0x0, %al
callq 0x3380
jmp 0x1e61a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x29(%rbp), %rdi
callq 0x32e0
jmp 0x1e620
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x3420
nopl (%rax)
// File: AndrewAlbert[P]Compiler-Theory/SourceCode/codeGenerator.cpp
// Function: codeGenerator::condBranch(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 codeGenerator::condBranch( string labelTrue, string labelFalse ){
	if( !ShouldGenerate() ) return;
	string cond = popStack('E', TYPE_BOOL);
	comment("Conditional branch");
	// goto true condition
	fprintf( oFile, "   if( %s ) goto %s;\n", cond.c_str(), labelTrue.c_str() );
	// goto else condition if one exists
	if( labelFalse.compare("") != 0 ) fprintf( oFile, "   goto %s;\n", labelFalse.c_str() );
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rsi, -0x88(%rbp)
movq %rdx, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x19590
testb $0x1, %al
jne 0x1e6b8
jmp 0x1e7d9
movq -0x78(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movl $0x45, %edx
movl $0x10c, %ecx            # imm = 0x10C
callq 0x1a7a0
leaq -0x59(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x3430
movq -0x90(%rbp), %rdx
leaq 0x8d18(%rip), %rsi      # 0x27405
leaq -0x58(%rbp), %rdi
callq 0x62d0
jmp 0x1e6f8
movq -0x78(%rbp), %rdi
leaq -0x58(%rbp), %rsi
xorl %edx, %edx
callq 0x19bb0
leaq -0x58(%rbp), %rdi
callq 0x31a0
leaq -0x59(%rbp), %rdi
callq 0x32e0
movq -0x78(%rbp), %rax
movq 0x308(%rax), %rax
movq %rax, -0xa0(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3120
movq -0x88(%rbp), %rdi
movq %rax, -0x98(%rbp)
callq 0x3120
movq -0xa0(%rbp), %rdi
movq -0x98(%rbp), %rdx
movq %rax, %rcx
leaq 0x8cb9(%rip), %rsi      # 0x27418
movb $0x0, %al
callq 0x3380
movq -0x80(%rbp), %rdi
leaq 0x8510(%rip), %rsi      # 0x26c81
callq 0x30d0
cmpl $0x0, %eax
je 0x1e7d0
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rax
movq 0x308(%rax), %rax
movq %rax, -0xa8(%rbp)
callq 0x3120
movq -0xa8(%rbp), %rdi
movq %rax, %rdx
leaq 0x8bf3(%rip), %rsi      # 0x2739a
movb $0x0, %al
callq 0x3380
jmp 0x1e7d0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x59(%rbp), %rdi
callq 0x32e0
leaq -0x38(%rbp), %rdi
callq 0x31a0
jmp 0x1e7e2
leaq -0x38(%rbp), %rdi
callq 0x31a0
addq $0xb0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x3420
nopl (%rax,%rax)
// File: AndrewAlbert[P]Compiler-Theory/SourceCode/codeGenerator.cpp
// Function: codeGenerator::branch(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void codeGenerator::branch( string label ){
	if( !ShouldGenerate() ) return;
	comment("Unconditional branch");
	fprintf( oFile, "   goto %s;\n", label.c_str() );
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x19590
testb $0x1, %al
jne 0x1e81a
jmp 0x1e8a4
leaq -0x31(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x3430
movq -0x60(%rbp), %rdx
leaq 0x8bfc(%rip), %rsi      # 0x2742e
leaq -0x30(%rbp), %rdi
callq 0x62d0
jmp 0x1e83d
movq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
xorl %edx, %edx
callq 0x19bb0
leaq -0x30(%rbp), %rdi
callq 0x31a0
leaq -0x31(%rbp), %rdi
callq 0x32e0
movq -0x50(%rbp), %rax
movq -0x58(%rbp), %rdi
movq 0x308(%rax), %rax
movq %rax, -0x68(%rbp)
callq 0x3120
movq -0x68(%rbp), %rdi
movq %rax, %rdx
leaq 0x8b16(%rip), %rsi      # 0x2739a
movb $0x0, %al
callq 0x3380
jmp 0x1e8a4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x32e0
jmp 0x1e8aa
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3420
nopw %cs:(%rax,%rax)
// File: AndrewAlbert[P]Compiler-Theory/SourceCode/codeGenerator.cpp
// Function: codeGenerator::resetArgument()
void codeGenerator::resetArgument(){
	if( !ShouldGenerate() ) return;
	savedArgument.paramType = TYPE_PARAM_NULL;
	savedArgument.type = 0;
	savedArgument.size = 0;
	savedArgument.index = -1;
	savedArgument.offset = -1;
	savedArgument.indirect = false;
	savedArgument.isGlobal = false;
	savedArgument.set = false;
	savedArgument.invalid = false;
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x19590
testb $0x1, %al
jne 0x1e8df
jmp 0x1e931
movq -0x10(%rbp), %rax
movl $0x122, 0x2a0(%rax)     # imm = 0x122
movl $0x0, 0x2a4(%rax)
movl $0x0, 0x2a8(%rax)
movl $0xffffffff, 0x2ac(%rax) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x2b0(%rax) # imm = 0xFFFFFFFF
movb $0x0, 0x2b4(%rax)
movb $0x0, 0x2b5(%rax)
movb $0x0, 0x2b6(%rax)
movb $0x0, 0x2b7(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: AndrewAlbert[P]Compiler-Theory/SourceCode/codeGenerator.cpp
// Function: codeGenerator::setArgument(scopeValue, bool, int, bool)
void codeGenerator::setArgument( scopeValue value, bool isGlobal, int index, bool indirect ){
	if( !ShouldGenerate() ) return;
	savedArgument.paramType = value.paramType;
	savedArgument.type = value.type;
	savedArgument.size = value.size;
	savedArgument.index = index;
	savedArgument.indirect = indirect;
	savedArgument.offset = value.FPoffset;
	savedArgument.isGlobal = isGlobal;
	savedArgument.set = true;
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x30(%rbp)
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %dl
movb %dl, -0x11(%rbp)
movl %ecx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x19590
testb $0x1, %al
jne 0x1e978
jmp 0x1e9cb
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movl 0x40(%rcx), %edx
movl %edx, 0x2a0(%rax)
movl (%rcx), %edx
movl %edx, 0x2a4(%rax)
movl 0x4(%rcx), %edx
movl %edx, 0x2a8(%rax)
movl -0x18(%rbp), %edx
movl %edx, 0x2ac(%rax)
movb -0x19(%rbp), %dl
andb $0x1, %dl
movb %dl, 0x2b4(%rax)
movl 0x44(%rcx), %ecx
movl %ecx, 0x2b0(%rax)
movb -0x11(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x2b5(%rax)
movb $0x1, 0x2b6(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: KinderRiven[P]rdma_demo/client.cc
// Function: post_send(rdma_context_t*, int)
static int post_send(rdma_context_t* context, int opcode)
{
    struct ibv_sge sge;
    struct ibv_send_wr sr;
    struct ibv_send_wr* bad_wr = NULL;

    // prepare the scatter / gather entry
    memset(&sge, 0, sizeof(sge)); // local
    memset((void*)context->ib_buf, 0xff, MSG_SIZE); // write
    sge.addr = (uintptr_t)context->ib_buf;
    sge.length = MSG_SIZE;
    sge.lkey = context->mr->lkey;

    // prepare the send work request
    memset(&sr, 0, sizeof(sr));
    sr.next = NULL;
    sr.wr_id = 0;
    sr.sg_list = &sge;
    sr.num_sge = 1;
    sr.opcode = (ibv_wr_opcode)opcode;
    sr.send_flags = IBV_SEND_SIGNALED;

    qp_info_t* qp_info = context->remote_qp;
    if (opcode != IBV_WR_SEND) { // remote
        sr.wr.rdma.remote_addr = qp_info->addr;
        sr.wr.rdma.rkey = qp_info->rkey;
        printf("[local:%llx][remote:0x%llx]\n", (uint64_t)context->ib_buf, qp_info->addr);
    }

    // there is a receive request in the responder side, so we won't get any
    // into RNR flow
    int ret = ibv_post_send(context->qp[0], &sr, &bad_wr);
    if (ret) {
        printf("%s\n", strerror(ret));
    }
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq $0x0, -0xa8(%rbp)
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x10b0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl $0xff, %esi
movl $0x40, %edx
callq 0x10b0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x40, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movl 0x24(%rax), %eax
movl %eax, -0x14(%rbp)
leaq -0xa0(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0x10b0
movq $0x0, -0x98(%rbp)
movq $0x0, -0xa0(%rbp)
leaq -0x20(%rbp), %rax
movq %rax, -0x90(%rbp)
movl $0x1, -0x88(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x84(%rbp)
movl $0x2, -0x80(%rbp)
movq -0x8(%rbp), %rax
movq 0x568(%rax), %rax
movq %rax, -0xb0(%rbp)
cmpl $0x2, -0xc(%rbp)
je 0x1a03
movq -0xb0(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x78(%rbp)
movq -0xb0(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x70(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq -0xb0(%rbp), %rax
movq (%rax), %rdx
leaq 0x1a3a(%rip), %rdi      # 0x3436
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
leaq -0xa0(%rbp), %rsi
leaq -0xa8(%rbp), %rdx
callq 0x2420
movl %eax, -0xb4(%rbp)
cmpl $0x0, -0xb4(%rbp)
je 0x1a49
movl -0xb4(%rbp), %edi
callq 0x1080
movq %rax, %rsi
leaq 0x1a11(%rip), %rdi      # 0x3453
movb $0x0, %al
callq 0x1050
movl -0xb4(%rbp), %eax
addq $0xc0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: KinderRiven[P]rdma_demo/client.cc
// Function: poll_cq(rdma_context_t*)
static void poll_cq(rdma_context_t* context)
{
    int num_wc = 1;
    struct ibv_cq* cq = context->cq;
    struct ibv_wc wc;
    while (true) {
        int n = ibv_poll_cq(cq, num_wc, &wc);
        if (n < 0) {
            printf("ibv_poll_cq failed.\n");
            exit(1);
        }
        if ((n) && (wc.status != IBV_WC_SUCCESS)) {
            printf("|Completion was found in CQ with error status [%s][%d]\n", ibv_wc_status_str(wc.status), n);
            printf("|-[wr_id:%d][status:%d][opcode:%d]\n", wc.wr_id, wc.status, wc.opcode);
            printf("|-[byte_len:%d][qp_num:%d][src_qp:%d]\n", wc.byte_len, wc.qp_num, wc.src_qp);
            break;
        } else if ((n) && (wc.status == IBV_WC_SUCCESS)) {
            printf("|Completion was found in CQ with success\n");
            break;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
leaq -0x48(%rbp), %rdx
callq 0x2460
movl %eax, -0x4c(%rbp)
cmpl $0x0, -0x4c(%rbp)
jge 0x1ab0
leaq 0x19b8(%rip), %rdi      # 0x3457
movb $0x0, %al
callq 0x1050
movl $0x1, %edi
callq 0x1120
cmpl $0x0, -0x4c(%rbp)
je 0x1b09
cmpl $0x0, -0x40(%rbp)
je 0x1b09
movl -0x40(%rbp), %edi
callq 0x1090
movq %rax, %rsi
movl -0x4c(%rbp), %edx
leaq 0x199b(%rip), %rdi      # 0x346c
movb $0x0, %al
callq 0x1050
movq -0x48(%rbp), %rsi
movl -0x40(%rbp), %edx
movl -0x3c(%rbp), %ecx
leaq 0x19bb(%rip), %rdi      # 0x34a4
movb $0x0, %al
callq 0x1050
movl -0x34(%rbp), %esi
movl -0x2c(%rbp), %edx
movl -0x28(%rbp), %ecx
leaq 0x19c8(%rip), %rdi      # 0x34c8
movb $0x0, %al
callq 0x1050
jmp 0x1b2c
cmpl $0x0, -0x4c(%rbp)
je 0x1b25
cmpl $0x0, -0x40(%rbp)
jne 0x1b25
leaq 0x19d3(%rip), %rdi      # 0x34ef
movb $0x0, %al
callq 0x1050
jmp 0x1b2c
jmp 0x1b27
jmp 0x1a7f
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: KinderRiven[P]rdma_demo/client.cc
// Function: modify_qp_to_rts(ibv_qp*)
static int modify_qp_to_rts(struct ibv_qp* qp)
{
    int flags;
    struct ibv_qp_attr attr;
    memset(&attr, 0, sizeof(attr));

    attr.qp_state = IBV_QPS_RTS;
    attr.timeout = 0x12; // 18
    attr.retry_cnt = 6;
    attr.rnr_retry = 0;
    attr.sq_psn = 0;
    attr.max_rd_atomic = 1;

    flags = IBV_QP_STATE | IBV_QP_TIMEOUT | IBV_QP_RETRY_CNT | IBV_QP_RNR_RETRY | IBV_QP_SQ_PSN | IBV_QP_MAX_QP_RD_ATOMIC;
    return ibv_modify_qp(qp, &attr, flags);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
leaq -0xa0(%rbp), %rdi
xorl %esi, %esi
movl $0x90, %edx
callq 0x10b0
movl $0x3, -0xa0(%rbp)
movb $0x12, -0x1e(%rbp)
movb $0x6, -0x1d(%rbp)
movb $0x0, -0x1c(%rbp)
movl $0x0, -0x88(%rbp)
movb $0x1, -0x22(%rbp)
movl $0x12e01, -0xc(%rbp)    # imm = 0x12E01
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
leaq -0xa0(%rbp), %rsi
callq 0x11b0
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax)
// File: jandoerntlein[P]wire/src/wire.h
// Function: void wire::DirectWire<>::connect<Light>(unsigned int, void (Light::*)(), Light*)
inline void connect( unsigned int idx, 
        void ( K::* pMemberFunc )( Args... args ), 
        K* pInstance ) 
    {
        if( m_fn.count( idx ) == 0 )
            connect_helper<K>( std::make_integer_sequence<int, sizeof...( Args )>{}, 
                idx, 
                pMemberFunc, 
                pInstance );
#ifdef WIRE_USE_EXCEPTIONS
        else
            throw std::runtime_error( "Requested index already in use." );
#endif
    }

// Assembly:
subq $0x58, %rsp
movq %rdx, 0x48(%rsp)
movq %rcx, 0x50(%rsp)
movq 0x48(%rsp), %rax
movq 0x50(%rsp), %rcx
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq %rcx, 0x30(%rsp)
movq %rax, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, (%rsp)
leaq 0x3c(%rsp), %rsi
callq 0x8950
cmpq $0x0, %rax
jne 0x2ce9
movq (%rsp), %rdi
movl 0x3c(%rsp), %esi
movq 0x28(%rsp), %rax
movq 0x30(%rsp), %rcx
movq 0x20(%rsp), %r8
movq %rcx, 0x10(%rsp)
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
callq 0x8980
addq $0x58, %rsp
retq
nop
// File: CominLab[P]QCluster/em.cc
// Function: initialize_cache(int)
void initialize_cache(int N){
	iterations = 0;
	best_assignment = new int[N];
	best_distortion = 1000000000000000;//infinite	
	for (int i=0; i<N; i++) best_assignment[i] = -1;
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x0, 0x962b(%rip)      # 0xf2a0
movslq -0x4(%rbp), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3030
movq %rax, 0x95ef(%rip)      # 0xf290
movsd 0x5ec7(%rip), %xmm0     # 0xbb70
movsd %xmm0, 0x95e7(%rip)     # 0xf298
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x5cdd
movq 0x95c9(%rip), %rax      # 0xf290
movslq -0x8(%rbp), %rcx
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x5cb8
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: CominLab[P]QCluster/em.cc
// Function: exceed_max_iterations(int, int, int*, double&)
bool exceed_max_iterations(int N, int K, int *assignment, double &distortion){
	iterations++;
	if (iterations>max_iterations){
		distortion = best_distortion;
		for(int n=0; n<N; n++) assignment[n] = best_assignment[n];	
		return true;
	}
	else{
		if (distortion < best_distortion){
			iterations = 0;
			for(int n=0; n<N; n++) best_assignment[n] = assignment[n];	
			best_distortion = distortion;
		}
	}	
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl 0x9598(%rip), %eax      # 0xf2a0
addl $0x1, %eax
movl %eax, 0x958f(%rip)      # 0xf2a0
movl 0x9589(%rip), %eax      # 0xf2a0
cmpl 0x955b(%rip), %eax      # 0xf278
jle 0x5d68
movsd 0x9571(%rip), %xmm0     # 0xf298
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x5d62
movq 0x954b(%rip), %rax      # 0xf290
movslq -0x24(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x5d36
movb $0x1, -0x1(%rbp)
jmp 0x5dd1
movq -0x20(%rbp), %rax
movsd (%rax), %xmm1
movsd 0x9520(%rip), %xmm0     # 0xf298
ucomisd %xmm1, %xmm0
jbe 0x5dcb
movl $0x0, 0x9518(%rip)      # 0xf2a0
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x5dbb
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq 0x94e7(%rip), %rax      # 0xf290
movslq -0x28(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x5d8f
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x94cd(%rip)     # 0xf298
jmp 0x5dcd
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
// File: CominLab[P]QCluster/em.cc
// Function: select_dists_cent(char, double (**)(double*, double*, int, double*, double*, double*, double*), void (**)(int, int, double**, int, double**, double*, double*, double**, double*, double**, double*))
void select_dists_cent(char dist_type, 
						double (**distf)(double*, double*, int,
						double*, double*, double*, double *), 
						void (**eval_centroid)(int, int, double**,
						int, double**, double*, double*, double **, double *, 
						double**, double*))
{
	switch (dist_type){
		case 'a':
			*distf = &d2ast_distance;
			*eval_centroid = &d2ast_centroid;
			break;
		case 'c':
			*distf = &chi2_distance;
			*eval_centroid = &mm_centroid;
			break;
		case 'd':
			*distf = &d2_distance;
			*eval_centroid = &d2_centroid;
			break;
		case 'k':
			*distf = &kl_distance;
			*eval_centroid = &kl_centroid;
			break;
		case 's':
			*distf = &symkl_distance;
			*eval_centroid = &kl_centroid;
			break;			
		case 'e': // fall through
		default:
			*distf = &euclidean_distance;
			*eval_centroid = &mean_centroid;
	}

	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movsbl -0x1(%rbp), %eax
addl $-0x61, %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x12, %eax
ja 0x5ee7
movq -0x20(%rbp), %rax
leaq 0x5d45(%rip), %rcx      # 0xbb88
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
leaq 0x1519(%rip), %rcx      # 0x7370
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
leaq 0x1c5b(%rip), %rcx      # 0x7ac0
movq %rcx, (%rax)
jmp 0x5f03
movq -0x10(%rbp), %rax
leaq 0x1428(%rip), %rcx      # 0x72a0
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
leaq 0x1a6a(%rip), %rcx      # 0x78f0
movq %rcx, (%rax)
jmp 0x5f03
movq -0x10(%rbp), %rax
leaq 0x132a(%rip), %rcx      # 0x71c0
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
leaq 0x17ec(%rip), %rcx      # 0x7690
movq %rcx, (%rax)
jmp 0x5f03
movq -0x10(%rbp), %rax
leaq 0x110c(%rip), %rcx      # 0x6fc0
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
leaq 0x190e(%rip), %rcx      # 0x77d0
movq %rcx, (%rax)
jmp 0x5f03
movq -0x10(%rbp), %rax
leaq 0x11ce(%rip), %rcx      # 0x70a0
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
leaq 0x18f0(%rip), %rcx      # 0x77d0
movq %rcx, (%rax)
jmp 0x5f03
jmp 0x5ee7
movq -0x10(%rbp), %rax
leaq 0x103e(%rip), %rcx      # 0x6f30
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
leaq 0x16b0(%rip), %rcx      # 0x75b0
movq %rcx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: CominLab[P]QCluster/em.cc
// Function: count_num_clusters(int, int const*)
static int count_num_clusters(int const N, const int * assignment)
{
	int max_id = 0;
	for (int n=0; n<N; n++){
		if (assignment[n] > max_id){
			max_id = assignment[n];
		}
	}
	max_id++; // increment to get the size of the index vector
	int *ix = new int[max_id];
	memset(ix, 0, max_id*sizeof(*ix));
	for (int n=0; n<N; n++) {
		ix[assignment[n]] = 1;
	}
	int  num_clusters=0;
	for (int k=0; k<max_id; k++) {
		num_clusters += ix[k];
	}
	delete[] ix;

	return num_clusters; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x6e60
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x14(%rbp), %eax
jle 0x6e53
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x14(%rbp)
jmp 0x6e55
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x6e2d
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movslq -0x14(%rbp), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3030
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rdx
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x3150
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x6ed6
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq -0x24(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl $0x1, (%rax,%rcx,4)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x6eac
movl $0x0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x6f08
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
addl -0x28(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x6ee4
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x6f1f
movq -0x38(%rbp), %rdi
callq 0x3350
movl -0x28(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: CominLab[P]QCluster/dists.cc
// Function: euclidean_distance(double*, double*, int, double*, double*, double*, double*)
double euclidean_distance(double *centroid, double *y, int L, double* xt, 
						  double *quality, double *expected_qual, double *expected_freq)
{
	double S = 0;
	double z;
	for(int i=0; i<L; i++){
		z = centroid[i] - quality[i];
		S += z*z;
	}
	return S;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x6fac
movq -0x8(%rbp), %rax
movslq -0x44(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x28(%rbp), %rax
movslq -0x44(%rbp), %rcx
subsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
movsd -0x40(%rbp), %xmm2
movsd -0x38(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x6f5e
movsd -0x38(%rbp), %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: CominLab[P]QCluster/dists.cc
// Function: kl_distance(double*, double*, int, double*, double*, double*, double*)
double kl_distance(double *centroid, double *p, int L, double* centroid_tilde, 
				   double *quality, double *expected_qual, double *expected_freq)
{
	double total_count = 0;
	for(int i=0; i<L; ++i){
		total_count += quality[i];
	}
	double S = 0;
	for(int i=0; i<L; i++){
		S += quality[i] * log(quality[i]/(total_count * centroid[i]));
	}
	return S;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x701c
movq -0x28(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
addsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x6ff2
xorps %xmm0, %xmm0
movsd %xmm0, -0x48(%rbp)
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x7092
movq -0x28(%rbp), %rax
movslq -0x4c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x58(%rbp)
movq -0x28(%rbp), %rax
movslq -0x4c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd -0x38(%rbp), %xmm1
movq -0x8(%rbp), %rax
movslq -0x4c(%rbp), %rcx
mulsd (%rax,%rcx,8), %xmm1
divsd %xmm1, %xmm0
callq 0x31f0
movaps %xmm0, %xmm2
movsd -0x58(%rbp), %xmm0
movsd -0x48(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x48(%rbp)
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x702b
movsd -0x48(%rbp), %xmm0
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)