LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/yw14218[P]C-Compiler/include/block/compoundstat.hpp
// Function: compoundstatement::treeprint(std::ostream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const
virtual void treeprint(std::ostream &dst, std::string indent)const override {
		dst<<indent<<"<Compound statement> ["<<'\n';
		if(left != NULL)
		{
		for(int i=0;i<left->size();i++)
		{
			(left->at(i))->treeprint(dst, indent+"  ");
		}
		}	
		if(right != NULL)
		{
		for(int i=0;i<right->size();i++)
		{
			(right->at(i))->treeprint(dst, indent+"  ");
		}
		}
      		dst << indent << "]"<<'\n';
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
movq %rbx, %rdi
callq 0x9250
movq %rax, %r12
leaq 0x70a4(%rip), %rsi      # 0x1dd9e
movl $0x16, %edx
movq %rax, %rdi
callq 0x9250
leaq 0x7(%rsp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %r12, %rdi
callq 0x9250
cmpq $0x0, 0x8(%r15)
je 0x16da9
movq 0x8(%r15), %rcx
movq (%rcx), %rax
cmpq %rax, 0x8(%rcx)
je 0x16da9
xorl %r13d, %r13d
leaq 0x28(%rsp), %r12
movq (%rax,%r13,8), %rbp
leaq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x18f32
movq %r12, %rdi
leaq 0x702c(%rip), %rsi      # 0x1dd92
callq 0x93e0
movq (%rbp), %rax
movq %rbp, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq *0x18(%rax)
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x16d8f
callq 0x91b0
incq %r13
movq 0x8(%r15), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r13, %rcx
ja 0x16d3c
cmpq $0x0, 0x10(%r15)
je 0x16e36
movq 0x10(%r15), %rcx
movq (%rcx), %rax
cmpq %rax, 0x8(%rcx)
je 0x16e36
xorl %r13d, %r13d
leaq 0x8(%rsp), %r12
movq (%rax,%r13,8), %rbp
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x18f32
movq %r12, %rdi
leaq 0x6f9f(%rip), %rsi      # 0x1dd92
callq 0x93e0
movq (%rbp), %rax
movq %rbp, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq *0x18(%rax)
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x16e1c
callq 0x91b0
incq %r13
movq 0x10(%r15), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r13, %rcx
ja 0x16dc9
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x9250
movq %rax, %rbx
leaq 0x6706(%rip), %rsi      # 0x1d555
movl $0x1, %edx
movq %rax, %rdi
callq 0x9250
leaq 0x7(%rsp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x9250
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x16e82
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
jmp 0x16ea0
jmp 0x16e93
movq %rax, %rbx
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x16eaa
callq 0x91b0
movq %rbx, %rdi
callq 0x93a0
// File: /workspace/github_cpp_makefile_star2_O1/yw14218[P]C-Compiler/include/block/compoundstat.hpp
// Function: compoundstatement::compile(Context&, int) const
virtual void compile(Context &input, int p = 2)const override{
		if(left != NULL)
		{
		for(int i=0;i<left->size();i++)
		{
			(left->at(i))->compile(input,p);
		}
		}	
		if(right != NULL)
		{
		for(int i=0;i<right->size();i++)
		{
			(right->at(i))->compile(input,p);
		}
		}
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
cmpq $0x0, 0x8(%rdi)
je 0x16f02
movq 0x8(%r15), %rcx
movq (%rcx), %rax
cmpq %rax, 0x8(%rcx)
je 0x16f02
xorl %r12d, %r12d
movq (%rax,%r12,8), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movl %ebx, %edx
callq *0x20(%rax)
incq %r12
movq 0x8(%r15), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r12, %rcx
ja 0x16ed9
cmpq $0x0, 0x10(%r15)
je 0x16f42
movq 0x10(%r15), %rcx
movq (%rcx), %rax
cmpq %rax, 0x8(%rcx)
je 0x16f42
xorl %r12d, %r12d
movq (%rax,%r12,8), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movl %ebx, %edx
callq *0x20(%rax)
incq %r12
movq 0x10(%r15), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r12, %rcx
ja 0x16f19
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/yw14218[P]C-Compiler/include/Statements/ifelsestatement.hpp
// Function: ifelsestatement::treeprint(std::ostream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const
virtual void treeprint(std::ostream &dst, std::string indent)const override {
		dst<<indent<<"<ifelse statement> ["<<'\n';
		left->treeprint(dst,indent+"  ");
		mid->treeprint(dst,indent+"  ");
		if(right != NULL)
			{right->treeprint(dst, indent+"  ");}
		dst<<indent<<"]"<<'\n';
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
movq %rbx, %rdi
callq 0x9250
movq %rax, %r12
leaq 0x6c10(%rip), %rsi      # 0x1ddc0
movl $0x14, %edx
movq %rax, %rdi
callq 0x9250
leaq 0x7(%rsp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %r12, %rdi
callq 0x9250
movq 0x8(%r15), %r12
leaq 0x58(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x48(%rsp), %r13
movq %r13, %rdi
callq 0x18f32
leaq 0x6b95(%rip), %rsi      # 0x1dd92
movq %r13, %rdi
callq 0x93e0
movq (%r12), %rax
leaq 0x48(%rsp), %rdx
movq %r12, %rdi
movq %rbx, %rsi
callq *0x18(%rax)
movq 0x48(%rsp), %rdi
cmpq %rbp, %rdi
je 0x17226
callq 0x91b0
movq 0x10(%r15), %r12
leaq 0x38(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %r13
movq %r13, %rdi
callq 0x18f32
leaq 0x6b41(%rip), %rsi      # 0x1dd92
movq %r13, %rdi
callq 0x93e0
movq (%r12), %rax
leaq 0x28(%rsp), %rdx
movq %r12, %rdi
movq %rbx, %rsi
callq *0x18(%rax)
movq 0x28(%rsp), %rdi
cmpq %rbp, %rdi
je 0x1727a
callq 0x91b0
movq 0x18(%r15), %r15
testq %r15, %r15
je 0x172d2
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x18f32
leaq 0x6ae8(%rip), %rsi      # 0x1dd92
movq %r12, %rdi
callq 0x93e0
movq (%r15), %rax
leaq 0x8(%rsp), %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq *0x18(%rax)
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x172d2
callq 0x91b0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x9250
movq %rax, %rbx
leaq 0x626a(%rip), %rsi      # 0x1d555
movl $0x1, %edx
movq %rax, %rdi
callq 0x9250
leaq 0x7(%rsp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x9250
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1731e
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
jne 0x17348
jmp 0x1734d
jmp 0x1732f
movq %rax, %rbx
movq 0x28(%rsp), %rdi
jmp 0x17343
jmp 0x1733b
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %rbp, %rdi
je 0x1734d
callq 0x91b0
movq %rbx, %rdi
callq 0x93a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/yw14218[P]C-Compiler/include/Statements/whiledoforstatement.hpp
// Function: whilestatement::treeprint(std::ostream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const
virtual void treeprint(std::ostream &dst, std::string indent)const override {
		dst<<indent<<"While Statement> ["<<'\n';
		left->treeprint(dst,indent+"  ");
		right->treeprint(dst,indent+"  ");
		dst<<indent<<"]"<<'\n';
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
movq %rbx, %rdi
callq 0x9250
movq %rax, %r12
leaq 0x678d(%rip), %rsi      # 0x1ddf1
movl $0x12, %edx
movq %rax, %rdi
callq 0x9250
leaq 0x7(%rsp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %r12, %rdi
callq 0x9250
movq 0x8(%r15), %r12
leaq 0x38(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %r13
movq %r13, %rdi
callq 0x18f32
leaq 0x66e1(%rip), %rsi      # 0x1dd92
movq %r13, %rdi
callq 0x93e0
movq (%r12), %rax
leaq 0x28(%rsp), %rdx
movq %r12, %rdi
movq %rbx, %rsi
callq *0x18(%rax)
movq 0x28(%rsp), %rdi
cmpq %rbp, %rdi
je 0x176da
callq 0x91b0
movq 0x10(%r15), %r15
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x18f32
leaq 0x668d(%rip), %rsi      # 0x1dd92
movq %r12, %rdi
callq 0x93e0
movq (%r15), %rax
leaq 0x8(%rsp), %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq *0x18(%rax)
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x1772d
callq 0x91b0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x9250
movq %rax, %rbx
leaq 0x5e0f(%rip), %rsi      # 0x1d555
movl $0x1, %edx
movq %rax, %rdi
callq 0x9250
leaq 0x7(%rsp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x9250
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x17779
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
jne 0x17797
jmp 0x1779c
jmp 0x1778a
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %rbp, %rdi
je 0x1779c
callq 0x91b0
movq %rbx, %rdi
callq 0x93a0
// File: /workspace/github_cpp_makefile_star2_O1/yw14218[P]C-Compiler/include/Statements/jumpstatement.hpp
// Function: returnstatement::treeprint(std::ostream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const
virtual void treeprint(std::ostream &dst, std::string indent)const override {
		dst<<indent<<"<return statement> [ "<<'\n';
		if(left != NULL)
			{left->treeprint(dst, indent+"  ");}
		dst<<indent<<"]"<<'\n';
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
movq %rbx, %rdi
callq 0x9250
movq %rax, %r12
leaq 0x615d(%rip), %rsi      # 0x1de66
movl $0x15, %edx
movq %rax, %rdi
callq 0x9250
leaq 0xf(%rsp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %r12, %rdi
callq 0x9250
movq 0x8(%r15), %r15
testq %r15, %r15
je 0x17d83
leaq 0x20(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %r12
movq %r12, %rdi
callq 0x18f32
leaq 0x6037(%rip), %rsi      # 0x1dd92
movq %r12, %rdi
callq 0x93e0
movq (%r15), %rax
leaq 0x10(%rsp), %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq *0x18(%rax)
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x17d83
callq 0x91b0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x9250
movq %rax, %rbx
leaq 0x57b9(%rip), %rsi      # 0x1d555
movl $0x1, %edx
movq %rax, %rdi
callq 0x9250
leaq 0xf(%rsp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x9250
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x17dce
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x17de0
callq 0x91b0
movq %rbx, %rdi
callq 0x93a0
// File: /workspace/github_cpp_makefile_star2_O1/yw14218[P]C-Compiler/include/Statements/jumpstatement.hpp
// Function: returnstatement::compile(Context&, int) const
virtual void compile(Context &input, int p = 2)const override{
		left->compile(input,p);
		//int val = left->evaluate();
		//input.print() << "\tli\t" << "$2," << val << std::endl;
		input.print() << "\tmove\t$2, $t1" << std::endl;
	}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq 0xd0(%rbx), %rbx
leaq 0x6078(%rip), %rsi      # 0x1de7c
movl $0xd, %edx
movq %rbx, %rdi
callq 0x9250
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x91c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x9030
movq %rax, %rdi
popq %rbx
jmp 0x9140
nop
// File: /workspace/github_cpp_makefile_star2_O1/yw14218[P]C-Compiler/include/Function_call/functioncall.hpp
// Function: functiondefinition::treeprint(std::ostream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const
virtual void treeprint(std::ostream &dst, std::string indent)const override {
		dst<<indent<<"<Function definition>"<<" ["<<'\n';
		if(left != NULL)		
		{left->treeprint(dst, indent+"  ");}
		mid->treeprint(dst, indent+"  ");
		right->treeprint(dst, indent+"  ");
		dst<<indent<<"]"<<'\n';
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
movq %rbx, %rdi
callq 0x9250
movq %rax, %r12
leaq 0x5c7a(%rip), %rsi      # 0x1deae
movl $0x15, %edx
movq %rax, %rdi
callq 0x9250
leaq 0x539a(%rip), %rsi      # 0x1d5e2
movl $0x2, %edx
movq %r12, %rdi
callq 0x9250
leaq 0x7(%rsp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %r12, %rdi
callq 0x9250
movq 0x8(%r15), %r12
testq %r12, %r12
je 0x182c3
leaq 0x58(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x48(%rsp), %r13
movq %r13, %rdi
callq 0x18f32
leaq 0x5af8(%rip), %rsi      # 0x1dd92
movq %r13, %rdi
callq 0x93e0
movq (%r12), %rax
leaq 0x48(%rsp), %rdx
movq %r12, %rdi
movq %rbx, %rsi
callq *0x18(%rax)
movq 0x48(%rsp), %rdi
cmpq %rbp, %rdi
je 0x182c3
callq 0x91b0
movq 0x10(%r15), %r12
leaq 0x38(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %r13
movq %r13, %rdi
callq 0x18f32
leaq 0x5aa4(%rip), %rsi      # 0x1dd92
movq %r13, %rdi
callq 0x93e0
movq (%r12), %rax
leaq 0x28(%rsp), %rdx
movq %r12, %rdi
movq %rbx, %rsi
callq *0x18(%rax)
movq 0x28(%rsp), %rdi
cmpq %rbp, %rdi
je 0x18317
callq 0x91b0
movq 0x18(%r15), %r15
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x18f32
leaq 0x5a50(%rip), %rsi      # 0x1dd92
movq %r12, %rdi
callq 0x93e0
movq (%r15), %rax
leaq 0x8(%rsp), %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq *0x18(%rax)
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x1836a
callq 0x91b0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x9250
movq %rax, %rbx
leaq 0x51d2(%rip), %rsi      # 0x1d555
movl $0x1, %edx
movq %rax, %rdi
callq 0x9250
leaq 0x7(%rsp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x9250
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x183b6
movq %rax, %rbx
movq 0x48(%rsp), %rdi
jmp 0x183db
jmp 0x183c2
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
jne 0x183e0
jmp 0x183e5
jmp 0x183d3
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %rbp, %rdi
je 0x183e5
callq 0x91b0
movq %rbx, %rdi
callq 0x93a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/XuhuiSun95[P]My-OpenGL/myGL.cpp
// Function: myInit(int, int)
void myInit(int length, int width){
    dimx = length;
    dimy = width;
    frameBuffer = new int[dimx*dimy];
    depthBuffer = new double[dimx*dimy];
    myLoadIdentity();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x6caf(%rip), %rax      # 0xa228
movl %edi, (%rax)
leaq 0x6caa(%rip), %rax      # 0xa22c
movl %esi, (%rax)
imull %edi, %esi
movslq %esi, %rax
leaq (,%rax,4), %rdi
testl %eax, %eax
movq $-0x1, %rcx
cmovsq %rcx, %rdi
leaq (,%rax,8), %rbx
cmovsq %rcx, %rbx
callq 0x1030
leaq 0x6c61(%rip), %rcx      # 0xa218
movq %rax, (%rcx)
movq %rbx, %rdi
callq 0x1030
leaq 0x6c57(%rip), %rcx      # 0xa220
movq %rax, (%rcx)
leaq 0x6b8d(%rip), %rax      # 0xa160
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
movq %rcx, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movups %xmm0, 0x18(%rax)
movq %rcx, 0x28(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x40(%rax)
movq %rcx, 0x50(%rax)
movups %xmm0, 0x58(%rax)
movups %xmm0, 0x68(%rax)
movq %rcx, 0x78(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/XuhuiSun95[P]My-OpenGL/myGL.cpp
// Function: myLoadIdentity()
void myLoadIdentity(){
    modelMatrix[0][0] = 1; modelMatrix[0][1] = 0; modelMatrix[0][2] = 0; modelMatrix[0][3] = 0;
    modelMatrix[1][0] = 0; modelMatrix[1][1] = 1; modelMatrix[1][2] = 0; modelMatrix[1][3] = 0;
    modelMatrix[2][0] = 0; modelMatrix[2][1] = 0; modelMatrix[2][2] = 1; modelMatrix[2][3] = 0;
    modelMatrix[3][0] = 0; modelMatrix[3][1] = 0; modelMatrix[3][2] = 0; modelMatrix[3][3] = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x6b47(%rip), %rax      # 0xa160
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
movq %rcx, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movups %xmm0, 0x18(%rax)
movq %rcx, 0x28(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x40(%rax)
movq %rcx, 0x50(%rax)
movups %xmm0, 0x58(%rax)
movups %xmm0, 0x68(%rax)
movq %rcx, 0x78(%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/XuhuiSun95[P]My-OpenGL/myGL.cpp
// Function: myFrustum(double, double, double, double, double, double)
void myFrustum(double left, double right, double bottom, double top, double zNear, double zFar){
    frustumLeft = left;
    frustumRight = right;
    frustumBottom = bottom;
    frustumTop = top;
    frustumNear = zNear;
    frustumFar = zFar;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x6b86(%rip), %rax      # 0xa1e0
movsd %xmm0, (%rax)
leaq 0x6b83(%rip), %rax      # 0xa1e8
movsd %xmm1, (%rax)
leaq 0x6b80(%rip), %rax      # 0xa1f0
movsd %xmm2, (%rax)
leaq 0x6b7d(%rip), %rax      # 0xa1f8
movsd %xmm3, (%rax)
leaq 0x6b7a(%rip), %rax      # 0xa200
movsd %xmm4, (%rax)
leaq 0x6b77(%rip), %rax      # 0xa208
movsd %xmm5, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/XuhuiSun95[P]My-OpenGL/myGL.cpp
// Function: myTranslated(double, double, double)
void myTranslated(double x, double y, double z){
    double matrix[4][4], omatrix[4][4];
    matrix[0][0] = 1; matrix[0][1] = 0; matrix[0][2] = 0; matrix[0][3] = x;
    matrix[1][0] = 0; matrix[1][1] = 1; matrix[1][2] = 0; matrix[1][3] = y;
    matrix[2][0] = 0; matrix[2][1] = 0; matrix[2][2] = 1; matrix[2][3] = z;
    matrix[3][0] = 0; matrix[3][1] = 0; matrix[3][2] = 0; matrix[3][3] = 1;
    multiMatrix(modelMatrix, matrix, omatrix);
    for(int i = 0; i < 4; i ++){
        for(int j = 0; j < 4; j ++)
            modelMatrix[i][j] = omatrix[i][j];
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
leaq -0x110(%rbp), %rsi
movq %rax, (%rsi)
xorps %xmm3, %xmm3
movups %xmm3, 0x8(%rsi)
movsd %xmm0, 0x18(%rsi)
xorl %r14d, %r14d
movq %r14, 0x20(%rsi)
movq %rax, 0x28(%rsi)
movq %r14, 0x30(%rsi)
movsd %xmm1, 0x38(%rsi)
movaps %xmm3, 0x40(%rsi)
movq %rax, 0x50(%rsi)
movsd %xmm2, 0x58(%rsi)
movaps %xmm3, 0x60(%rsi)
movq %r14, 0x70(%rsi)
movq %rax, 0x78(%rsi)
leaq 0x6771(%rip), %rbx      # 0xa160
leaq -0x90(%rbp), %rdx
movq %rbx, %rdi
callq 0x4cdc
movaps -0x90(%rbp,%r14), %xmm0
movaps -0x80(%rbp,%r14), %xmm1
movaps %xmm1, 0x10(%rbx,%r14)
movaps %xmm0, (%rbx,%r14)
addq $0x20, %r14
cmpq $0x80, %r14
jne 0x39fe
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/XuhuiSun95[P]My-OpenGL/myGL.cpp
// Function: myScaled(double, double, double)
void myScaled(double x, double y, double z){
    double matrix[4][4], omatrix[4][4];
    matrix[0][0] = x; matrix[0][1] = 0; matrix[0][2] = 0; matrix[0][3] = 0;
    matrix[1][0] = 0; matrix[1][1] = y; matrix[1][2] = 0; matrix[1][3] = 0;
    matrix[2][0] = 0; matrix[2][1] = 0; matrix[2][2] = z; matrix[2][3] = 0;
    matrix[3][0] = 0; matrix[3][1] = 0; matrix[3][2] = 0; matrix[3][3] = 1;
    multiMatrix(modelMatrix, matrix, omatrix);
    for(int i = 0; i < 4; i ++){
        for(int j = 0; j < 4; j ++)
            modelMatrix[i][j] = omatrix[i][j];
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
leaq -0x110(%rbp), %rsi
movsd %xmm0, (%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rsi)
movups %xmm0, 0x18(%rsi)
movsd %xmm1, 0x28(%rsi)
movaps %xmm0, 0x30(%rsi)
movaps %xmm0, 0x40(%rsi)
movsd %xmm2, 0x50(%rsi)
movups %xmm0, 0x58(%rsi)
movups %xmm0, 0x68(%rsi)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x78(%rsi)
leaq 0x6681(%rip), %rbx      # 0xa160
leaq -0x90(%rbp), %rdx
movq %rbx, %rdi
callq 0x4cdc
xorl %eax, %eax
movaps -0x90(%rbp,%rax), %xmm0
movaps -0x80(%rbp,%rax), %xmm1
movaps %xmm1, 0x10(%rbx,%rax)
movaps %xmm0, (%rbx,%rax)
addq $0x20, %rax
cmpq $0x80, %rax
jne 0x3af0
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/XuhuiSun95[P]My-OpenGL/myGL.cpp
// Function: myPushMatrix()
void myPushMatrix(){
    double** matrix = new double*[4];
    matrix[0] = new double[4];
    matrix[1] = new double[4];
    matrix[2] = new double[4];
    matrix[3] = new double[4];
    for(int i = 0; i < 4; i ++){
        for(int j = 0; j < 4; j ++)
            matrix[i][j] = modelMatrix[i][j];
    }
    modelMatrixStack.push(matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl $0x20, %edi
callq 0x1030
movq %rax, %rbx
movq %rax, -0x10(%rbp)
movl $0x20, %edi
callq 0x1030
movq %rax, (%rbx)
movl $0x20, %edi
callq 0x1030
movq %rax, 0x8(%rbx)
movl $0x20, %edi
callq 0x1030
movq %rax, 0x10(%rbx)
movl $0x20, %edi
callq 0x1030
movq %rax, 0x18(%rbx)
leaq 0x5fb4(%rip), %rax      # 0xa160
xorl %ecx, %ecx
movq (%rbx,%rcx,8), %rdx
xorl %esi, %esi
movsd (%rax,%rsi,8), %xmm0
movsd %xmm0, (%rdx,%rsi,8)
incq %rsi
cmpq $0x4, %rsi
jne 0x41b4
incq %rcx
addq $0x20, %rax
cmpq $0x4, %rcx
jne 0x41ae
leaq 0x5f2d(%rip), %rax      # 0xa108
movq 0x30(%rax), %rcx
movq 0x40(%rax), %rdx
addq $-0x8, %rdx
cmpq %rdx, %rcx
je 0x41f6
movq %rbx, (%rcx)
addq $0x8, 0x30(%rax)
jmp 0x4206
leaq 0x5f0b(%rip), %rdi      # 0xa108
leaq -0x10(%rbp), %rsi
callq 0x4946
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/XuhuiSun95[P]My-OpenGL/myGL.cpp
// Function: mySwapBuffers()
void mySwapBuffers(){
    char s[10];
    sprintf(s, "%03d.ppm", frame);
    FILE *fp = fopen(s, "wb");
    (void) fprintf(fp, "P1\n%d %d\n", dimx, dimy);
    for(int i = 0; i < dimx*dimy; i++){
        (void) fprintf(fp, "%d", frameBuffer[i]);
    }
    frame++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0x5f9a(%rip), %rax      # 0xa230
movl (%rax), %edx
leaq 0x30c1(%rip), %rsi      # 0x7360
leaq -0x32(%rbp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1040
leaq 0x30b5(%rip), %rsi      # 0x7369
movq %rbx, %rdi
callq 0x1120
movq %rax, %rbx
leaq 0x5f62(%rip), %r14      # 0xa228
movl (%r14), %edx
leaq 0x5f5c(%rip), %r15      # 0xa22c
movl (%r15), %ecx
leaq 0x3092(%rip), %rsi      # 0x736c
movq %rax, %rdi
xorl %eax, %eax
callq 0x1130
movl (%r15), %eax
imull (%r14), %eax
testl %eax, %eax
jle 0x4330
movq %r14, %rdx
leaq 0x307d(%rip), %r14      # 0x7376
xorl %r12d, %r12d
leaq 0x5f15(%rip), %rax      # 0xa218
movq (%rax), %rax
movq %rdx, %r13
movl (%rax,%r12,4), %edx
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x1130
movq %r13, %rdx
incq %r12
movslq (%r13), %rax
movslq (%r15), %rcx
imulq %rax, %rcx
cmpq %rcx, %r12
jl 0x42fc
leaq 0x5ef9(%rip), %rax      # 0xa230
incl (%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/XuhuiSun95[P]My-OpenGL/primitive.cpp
// Function: modelTransform(vertex)
vertex modelTransform(vertex v){
    double ox = modelMatrix[0][0] * v.x + modelMatrix[0][1] * v.y + modelMatrix[0][2] * v.z + modelMatrix[0][3];
    double oy = modelMatrix[1][0] * v.x + modelMatrix[1][1] * v.y + modelMatrix[1][2] * v.z + modelMatrix[1][3];
    double oz = modelMatrix[2][0] * v.x + modelMatrix[2][1] * v.y + modelMatrix[2][2] * v.z + modelMatrix[2][3];
    double oc = modelMatrix[3][0] * v.x + modelMatrix[3][1] * v.y + modelMatrix[3][2] * v.z + modelMatrix[3][3];
    return vertex(ox/oc, oy/oc, oz/oc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd 0x10(%rbp), %xmm0
movsd 0x18(%rbp), %xmm3
movsd 0x5586(%rip), %xmm1     # 0xa168
mulsd %xmm3, %xmm1
movsd 0x5572(%rip), %xmm4     # 0xa160
mulsd %xmm0, %xmm4
addsd %xmm1, %xmm4
movsd 0x20(%rbp), %xmm2
movsd 0x556d(%rip), %xmm1     # 0xa170
mulsd %xmm2, %xmm1
addsd %xmm4, %xmm1
addsd 0x5565(%rip), %xmm1     # 0xa178
movsd 0x556d(%rip), %xmm4     # 0xa188
mulsd %xmm3, %xmm4
movsd 0x5559(%rip), %xmm5     # 0xa180
mulsd %xmm0, %xmm5
addsd %xmm4, %xmm5
movsd 0x5559(%rip), %xmm4     # 0xa190
mulsd %xmm2, %xmm4
addsd %xmm5, %xmm4
addsd 0x5551(%rip), %xmm4     # 0xa198
movsd 0x5559(%rip), %xmm5     # 0xa1a8
mulsd %xmm3, %xmm5
movsd 0x5545(%rip), %xmm6     # 0xa1a0
mulsd %xmm0, %xmm6
addsd %xmm5, %xmm6
movsd 0x5545(%rip), %xmm5     # 0xa1b0
mulsd %xmm2, %xmm5
addsd %xmm6, %xmm5
addsd 0x553d(%rip), %xmm5     # 0xa1b8
mulsd 0x5545(%rip), %xmm3     # 0xa1c8
mulsd 0x5535(%rip), %xmm0     # 0xa1c0
mulsd 0x553d(%rip), %xmm2     # 0xa1d0
addsd %xmm3, %xmm0
addsd %xmm0, %xmm2
addsd 0x5535(%rip), %xmm2     # 0xa1d8
movq %rdi, %rax
divsd %xmm2, %xmm1
divsd %xmm2, %xmm4
divsd %xmm2, %xmm5
movsd %xmm1, (%rdi)
movsd %xmm4, 0x8(%rdi)
movsd %xmm5, 0x10(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/XuhuiSun95[P]My-OpenGL/primitive.cpp
// Function: multiMatrix(double (*) [4], double (*) [4], double (*) [4])
void multiMatrix(double imat1[4][4], double imat2[4][4], double omat[4][4]){
    for(int i = 0; i < 4; i++){
        for(int j = 0; j < 4; j++){
            omat[i][j] = 0;
            for(int k = 0; k < 4; k++)
                omat[i][j] += imat1[i][k] * imat2[k][j];
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
movq %rax, %rcx
shlq $0x5, %rcx
addq %rdx, %rcx
movq %rsi, %r8
xorl %r9d, %r9d
leaq (%rcx,%r9,8), %r10
movq $0x0, (%r10)
xorpd %xmm0, %xmm0
xorl %r11d, %r11d
movsd (%rdi,%r11), %xmm1
mulsd (%r8,%r11,4), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, (%r10)
addq $0x8, %r11
cmpq $0x20, %r11
jne 0x4d04
incq %r9
addq $0x8, %r8
cmpq $0x4, %r9
jne 0x4cf2
incq %rax
addq $0x20, %rdi
cmpq $0x4, %rax
jne 0x4ce2
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/XuhuiSun95[P]My-OpenGL/primitive.cpp
// Function: inputBuffer(int, int, double)
void inputBuffer(int x, int y, double zDepth){
    int pixel = (y - 1) * dimx + x;
    if(x > 0 && x <= dimx && y > 0 && y <= dimy && zDepth >= depthBuffer[pixel - 1]){
        frameBuffer[(pixel - 1)] = 0;
        depthBuffer[pixel - 1] = zDepth;
    }
}

// Assembly:
testl %edi, %edi
jle 0x4d8a
testl %esi, %esi
jle 0x4d8a
movl 0x54db(%rip), %eax      # 0xa228
cmpl %edi, %eax
jl 0x4d8a
cmpl %esi, 0x54d5(%rip)      # 0xa22c
jl 0x4d8a
pushq %rbp
movq %rsp, %rbp
decl %esi
imull %esi, %eax
movq 0x54b7(%rip), %rcx      # 0xa220
addl %edi, %eax
decl %eax
cltq
ucomisd (%rcx,%rax,8), %xmm0
jb 0x4d89
movq 0x549b(%rip), %rdx      # 0xa218
movl $0x0, (%rdx,%rax,4)
movsd %xmm0, (%rcx,%rax,8)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/XuhuiSun95[P]My-OpenGL/primitive.cpp
// Function: hidenSurface(int, int, double)
void hidenSurface(int x, int y, double zDepth){
    int pixel = (y - 1) * dimx + x;
    if(x > 0 && x <= dimx && y > 0 && y <= dimy && zDepth >= depthBuffer[pixel - 1]){
        frameBuffer[(pixel - 1)] = 1;
        depthBuffer[pixel - 1] = zDepth;
    }
}

// Assembly:
testl %edi, %edi
jle 0x4dd6
testl %esi, %esi
jle 0x4dd6
movl 0x548f(%rip), %eax      # 0xa228
cmpl %edi, %eax
jl 0x4dd6
cmpl %esi, 0x5489(%rip)      # 0xa22c
jl 0x4dd6
pushq %rbp
movq %rsp, %rbp
decl %esi
imull %esi, %eax
movq 0x546b(%rip), %rcx      # 0xa220
addl %edi, %eax
decl %eax
cltq
ucomisd (%rcx,%rax,8), %xmm0
jb 0x4dd5
movq 0x544f(%rip), %rdx      # 0xa218
movl $0x1, (%rdx,%rax,4)
movsd %xmm0, (%rcx,%rax,8)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/thunlp[P]KB2E/TransE/Test_TransE.cpp
// Function: main
int main(int argc,char**argv)
{
    if (argc<2)
        return 0;
    else
    {
        version = argv[1];
        prepare();
        test.run();
    }
}

// Assembly:
cmpl $0x2, %edi
jl 0x354d
pushq %r15
pushq %r14
pushq %rbx
movq 0x8(%rsi), %rbx
movq 0x8c7b(%rip), %r14      # 0xc190
leaq 0x8c6c(%rip), %r15      # 0xc188
movq %rbx, %rdi
callq 0x20b0
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
movq %rbx, %rcx
movq %rax, %r8
callq 0x21f0
callq 0x28de
leaq 0x39bad(%rip), %rdi     # 0x3d0f0
callq 0x393c
popq %rbx
popq %r14
popq %r15
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/thunlp[P]KB2E/TransE/Test_TransE.cpp
// Function: Test::calc_sum(int, int, int)
double calc_sum(int e1,int e2,int rel)
    {
        double sum=0;
        if (L1_flag)
        	for (int ii=0; ii<n; ii++)
            sum+=-fabs(entity_vec[e2][ii]-entity_vec[e1][ii]-relation_vec[rel][ii]);
        else
        for (int ii=0; ii<n; ii++)
            sum+=-sqr(entity_vec[e2][ii]-entity_vec[e1][ii]-relation_vec[rel][ii]);
        return sum;
    }

// Assembly:
movl 0x6d78(%rip), %eax      # 0xc15c
cmpb $0x0, 0x6d6d(%rip)      # 0xc158
je 0x544c
testl %eax, %eax
jle 0x549e
movslq %edx, %rdx
movq (%rdi), %r8
movq 0x18(%rdi), %rdi
leaq (%rdx,%rdx,2), %rdx
movq (%rdi,%rdx,8), %rdx
movslq %esi, %rsi
leaq (%rsi,%rsi,2), %rsi
movq (%rdi,%rsi,8), %rsi
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
movq (%r8,%rcx,8), %rcx
xorpd %xmm0, %xmm0
xorl %edi, %edi
movapd 0x2c25(%rip), %xmm1     # 0x8050
movsd (%rdx,%rdi,8), %xmm2
subsd (%rsi,%rdi,8), %xmm2
subsd (%rcx,%rdi,8), %xmm2
andpd %xmm1, %xmm2
subsd %xmm2, %xmm0
incq %rdi
cmpq %rdi, %rax
jne 0x542b
jmp 0x549d
testl %eax, %eax
jle 0x549e
movslq %edx, %rdx
movq (%rdi), %r8
movq 0x18(%rdi), %rdi
leaq (%rdx,%rdx,2), %rdx
movq (%rdi,%rdx,8), %rdx
movslq %esi, %rsi
leaq (%rsi,%rsi,2), %rsi
movq (%rdi,%rsi,8), %rsi
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
movq (%r8,%rcx,8), %rcx
xorpd %xmm0, %xmm0
xorl %edi, %edi
movsd (%rdx,%rdi,8), %xmm1
subsd (%rsi,%rdi,8), %xmm1
subsd (%rcx,%rdi,8), %xmm1
mulsd %xmm1, %xmm1
subsd %xmm1, %xmm0
incq %rdi
cmpq %rdi, %rax
jne 0x547e
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/shreyas-gopalakrishna[P]Concurrent-Skip-list/unit_test_3.cpp
// Function: skiplist_combined_operations()
void skiplist_combined_operations(){

    int start = (rand() % static_cast<int>(numbers_insert.size() + 1));
    int end = start + (rand() % static_cast<int>(numbers_insert.size() - start + 1));
    // cout << "Add Index: " << start << " " << end << endl;
    skiplist_add(start, end);

    start = (rand() % static_cast<int>(numbers_delete.size() + 1));
    end = start + (rand() % static_cast<int>(numbers_delete.size() - start + 1));
    // cout << "Remove Index: " << start << " " << end << endl;
    skiplist_remove(start, end);

    start = (rand() % static_cast<int>(numbers_get.size() + 1));
    end = start + (rand() % static_cast<int>(numbers_get.size() - start + 1));
    // cout << "Searching Index: " << start << " " << end << endl;
    skiplist_search(start, end);

    start = (rand() % static_cast<int>(numbers_insert.size() + 1));
    end = start + (rand() % static_cast<int>(numbers_insert.size() - start + 1));
    // cout << "Range: " << start << " " << end << endl;
    skiplist_range(start, end);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
callq 0x2060
movq 0x6738(%rip), %rcx      # 0x91b0
subq 0x6729(%rip), %rcx      # 0x91a8
shrq $0x2, %rcx
incl %ecx
cltd
idivl %ecx
movl %edx, %ebx
callq 0x2060
movq 0x671a(%rip), %rcx      # 0x91b0
subq 0x670b(%rip), %rcx      # 0x91a8
shrq $0x2, %rcx
movslq %ebx, %rdi
subl %edi, %ecx
incl %ecx
cltd
idivl %ecx
addl %edi, %edx
movslq %edx, %rsi
callq 0x2705
callq 0x2060
movq 0x6707(%rip), %rcx      # 0x91c8
subq 0x66f8(%rip), %rcx      # 0x91c0
shrq $0x2, %rcx
incl %ecx
cltd
idivl %ecx
movl %edx, %ebx
callq 0x2060
movq 0x66e9(%rip), %rcx      # 0x91c8
subq 0x66da(%rip), %rcx      # 0x91c0
shrq $0x2, %rcx
movslq %ebx, %rdi
subl %edi, %ecx
incl %ecx
cltd
idivl %ecx
addl %edi, %edx
movslq %edx, %rsi
callq 0x294d
callq 0x2060
movq 0x66d6(%rip), %rcx      # 0x91e0
subq 0x66c7(%rip), %rcx      # 0x91d8
shrq $0x2, %rcx
incl %ecx
cltd
idivl %ecx
movl %edx, %ebx
callq 0x2060
movq 0x66b8(%rip), %rcx      # 0x91e0
subq 0x66a9(%rip), %rcx      # 0x91d8
shrq $0x2, %rcx
movslq %ebx, %rdi
subl %edi, %ecx
incl %ecx
cltd
idivl %ecx
addl %edi, %edx
movslq %edx, %rsi
callq 0x29b1
callq 0x2060
movq 0x665d(%rip), %rcx      # 0x91b0
subq 0x664e(%rip), %rcx      # 0x91a8
shrq $0x2, %rcx
incl %ecx
cltd
idivl %ecx
movl %edx, %ebx
callq 0x2060
movq 0x663f(%rip), %rcx      # 0x91b0
subq 0x6630(%rip), %rcx      # 0x91a8
shrq $0x2, %rcx
subl %ebx, %ecx
incl %ecx
cltd
idivl %ecx
leal (%rdx,%rbx), %ecx
leaq 0x660b(%rip), %rsi      # 0x9198
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl %ebx, %edx
callq 0x5182
movq %r14, %rdi
callq 0x3a1c
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/kaityo256[P]cps/cps.cpp
// Function: worker(int)
void worker(const int rank) {
  while (true) {
    int send = 10;
    int len = 0;
    MPI_Status st;
    // Sends dummy data to notify that communication is ready.
    MPI_Send(&send, 1, MPI_INT, 0, 0, MPI_COMM_WORLD);
    // Recieve the length of a command
    MPI_Recv(&len, 1, MPI_INT, 0, 0, MPI_COMM_WORLD, &st);
    // If the length is zero, all tasks are completed.
    if (len == 0) {
      debug_printf("Finish OK: %d\n", rank);
      break;
    }
    std::unique_ptr<char[]> buf(new char[len]);
    MPI_Recv(buf.get(), len, MPI_CHAR, 0, 0, MPI_COMM_WORLD, &st);
    std::string recv_string = buf.get();
    debug_printf("%d: Recieved %s\n", rank, recv_string.c_str());
    std::system(recv_string.c_str());
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq 0x3328(%rip), %rbx      # 0x5fc8
movq 0x32f9(%rip), %r14      # 0x5fa0
leaq -0x70(%rbp), %r13
movl $0xa, -0x34(%rbp)
movl $0x0, -0x30(%rbp)
leaq -0x34(%rbp), %rdi
movl $0x1, %esi
movq %rbx, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %r14, %r9
callq 0x2090
movq %r13, (%rsp)
leaq -0x30(%rbp), %rdi
movl $0x1, %esi
movq %rbx, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %r14, %r9
callq 0x2130
movl -0x30(%rbp), %r12d
testl %r12d, %r12d
je 0x2d66
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovnsl %r12d, %eax
movslq %eax, %rdi
callq 0x2030
movq %rax, %r15
movq %r13, (%rsp)
movq %rax, %rdi
movl %r12d, %esi
movq 0x3273(%rip), %rdx      # 0x5f90
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %r14, %r9
callq 0x2130
leaq -0x58(%rbp), %rdi
movq %r15, %rsi
leaq -0x29(%rbp), %rdx
callq 0x20b0
movq -0x58(%rbp), %rdi
callq 0x2160
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x2d55
callq 0x2180
movq %r15, %rdi
callq 0x21f0
testl %r12d, %r12d
jne 0x2cab
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2d8e
movq %rax, %rbx
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x2d91
callq 0x2180
jmp 0x2d91
movq %rax, %rbx
movq %r15, %rdi
callq 0x21f0
movq %rbx, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O1/kaityo256[P]cps/cps.cpp
// Function: main
int main(int argc, char **argv) {
  MPI_Init(&argc, &argv);
  int rank, procs;
  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
  MPI_Comm_size(MPI_COMM_WORLD, &procs);

  if (argc < 2 || procs < 2) {
    if (rank == 0) {
      fprintf(stderr, "Usage: mpirun -np num_procs ./cps tasklist\n");
      fprintf(stderr, "num_procs must be 2 or more.\n");
    }
    MPI_Finalize();
    return 1;
  }

  int is_ready = loadfile(argc, argv);
  int all_ready = 0;
  MPI_Allreduce(&is_ready, &all_ready, 1, MPI_INT, MPI_LAND, MPI_COMM_WORLD);

  if (all_ready) {
    if (rank == 0) {
      manager(procs);
    } else {
      worker(rank);
    }
  }

  MPI_Finalize();
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
leaq -0x2c(%rbp), %rbx
movl %edi, (%rbx)
leaq -0x20(%rbp), %rax
movq %rsi, (%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2210
movq 0x2fa5(%rip), %r14      # 0x5fa0
leaq -0x18(%rbp), %rsi
movq %r14, %rdi
callq 0x2200
leaq -0x14(%rbp), %rsi
movq %r14, %rdi
callq 0x21d0
movl (%rbx), %edi
cmpl $0x2, %edi
jl 0x306d
cmpl $0x1, -0x14(%rbp)
jle 0x306d
movq -0x20(%rbp), %rsi
callq 0x2da1
leaq -0x28(%rbp), %rdi
movl %eax, (%rdi)
leaq -0x24(%rbp), %rbx
movl $0x0, (%rbx)
movq 0x2f88(%rip), %rcx      # 0x5fc8
movq 0x2f61(%rip), %r8       # 0x5fa8
movq 0x2f52(%rip), %r9       # 0x5fa0
movq %rbx, %rsi
movl $0x1, %edx
callq 0x21e0
cmpl $0x0, (%rbx)
je 0x3087
cmpl $0x0, -0x18(%rbp)
je 0x307f
callq 0x2c88
jmp 0x3087
cmpl $0x0, -0x18(%rbp)
je 0x3097
callq 0x2110
movl $0x1, %eax
jmp 0x308e
movl -0x14(%rbp), %edi
callq 0x258c
callq 0x2110
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x22f0
jmp 0x3073
// File: /workspace/github_cpp_makefile_star2_O1/king1600[P]cordpp/src/base64.cc
// Function: cordpp::b64_encode(char const*, unsigned long)
char* cordpp::b64_encode(const char *src, const size_t length) {
  // (length * 4 / 3) rounded up to nearest multiple of 4
  const size_t encoded_length = ((length<<2)/3+3)&-4;
  char *buffer = new char[encoded_length + 1];

  // perform base64 calculation
  size_t i;
  char *p = buffer;
  for(i = 0; i < length-2; i += 3) {
      *p++ = B64_CHARSET[(src[i] >> 2) & 0x3F];
      *p++ = B64_CHARSET[((uint8_t)src[i] << 4 | (uint8_t)src[i+1] >> 4) & 0x3F];
      *p++ = B64_CHARSET[((uint8_t)src[i+1] << 2 | (uint8_t)src[i+2] >> 6) & 0x3F];
      *p++ = B64_CHARSET[(uint8_t)src[i+2] & 0x3F];
  }

  // this returns 3 instead of 0 if we need no padding but
  // if we need no padding we dont need to do anything
  int padding = (length % 3)^3;
  if (padding == 1) {
      *p++ = B64_CHARSET[(src[i] >> 2) & 0x3F];
      *p++ = B64_CHARSET[(src[i] << 4 | src[i+1] >> 4) & 0x3F];
      *p++ = B64_CHARSET[(src[i+1] << 2) & 0x3F];
      *p++ = '=';
  } else if (padding == 2) {
      *p++ = B64_CHARSET[(src[i] >> 2) & 0x3F];
      *p++ = B64_CHARSET[(src[i] << 4) & 0x3F];
      *p++ = '=';
      *p++ = '=';
  }

  // add null terminator and return constructed buffer
  *p = '\0';
  return buffer;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq (,%rsi,4), %rax
movabsq $-0x5555555555555555, %r15 # imm = 0xAAAAAAAAAAAAAAAB
mulq %r15
shrq %rdx
leaq 0x3(%rdx), %rdi
andq $-0x4, %rdi
incq %rdi
callq 0xa040
movq %rax, %rcx
movq %r14, %rax
xorl %edi, %edi
addq $-0x2, %rax
je 0xc802
leaq 0x2f87c(%rip), %rdx     # 0x3c010
movq %rcx, %rsi
movzbl (%rbx,%rdi), %r8d
movl %r8d, %r9d
shrl $0x2, %r9d
movb (%r9,%rdx), %r9b
movb %r9b, (%rsi)
shll $0x4, %r8d
movzbl 0x1(%rbx,%rdi), %r9d
movl %r9d, %r10d
shrl $0x4, %r10d
andl $0x30, %r8d
orl %r10d, %r8d
movb (%r8,%rdx), %r8b
movb %r8b, 0x1(%rsi)
movzbl 0x2(%rbx,%rdi), %r8d
movl %r8d, %r10d
shrl $0x6, %r10d
andl $0xf, %r9d
leal (%r10,%r9,4), %r9d
movb (%r9,%rdx), %r9b
movb %r9b, 0x2(%rsi)
andl $0x3f, %r8d
movb (%r8,%rdx), %r8b
movb %r8b, 0x3(%rsi)
addq $0x4, %rsi
addq $0x3, %rdi
cmpq %rax, %rdi
jb 0xc797
jmp 0xc805
movq %rcx, %rsi
movq %r14, %rax
mulq %r15
shrq %rdx
leaq (%rdx,%rdx,2), %rax
subq %rax, %r14
cmpq $0x1, %r14
je 0xc861
cmpq $0x2, %r14
jne 0xc88e
movzbl (%rbx,%rdi), %eax
movl %eax, %edx
shrl $0x2, %edx
leaq 0x2f7df(%rip), %r8      # 0x3c010
movb (%rdx,%r8), %dl
movb %dl, (%rsi)
shll $0x4, %eax
movzbl 0x1(%rbx,%rdi), %edx
movl %edx, %edi
sarb $0x4, %dil
movzbl %dil, %edi
orl %eax, %edi
andl $0x3f, %edi
movb (%rdi,%r8), %al
movb %al, 0x1(%rsi)
andl $0xf, %edx
movb (%r8,%rdx,4), %al
movb %al, 0x2(%rsi)
jmp 0xc886
movzbl (%rbx,%rdi), %eax
movl %eax, %edx
shrl $0x2, %edx
leaq 0x2f79f(%rip), %rdi     # 0x3c010
movb (%rdx,%rdi), %dl
movb %dl, (%rsi)
shll $0x4, %eax
andl $0x30, %eax
movb (%rax,%rdi), %al
movb %al, 0x1(%rsi)
movb $0x3d, 0x2(%rsi)
movb $0x3d, 0x3(%rsi)
addq $0x4, %rsi
movb $0x0, (%rsi)
movq %rcx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/king1600[P]cordpp/src/base64.cc
// Function: cordpp::b64_decode(char const*)
char* cordpp::b64_decode(const char *src) {
  // The input is invalid or not properly padded
  const size_t src_len = std::strlen(src);
  if (src_len % 4 != 0)
    return nullptr;

  // instead of figuring out exactly how long the decoded string should be
  // allocate enough. at most this is an extra 2 bytes
  char *buffer = new char[(src_len * 3 >> 2) + 1];

  // decode content with lookup table
  size_t i;
  char *p = buffer;
  for(i = 0; i < src_len - 4; i += 4) {
    *p++ = (B64_LOOKUP[(uint8_t)src[i]] << 2 | B64_LOOKUP[(uint8_t)src[i+1]] >> 4) & 0xff;
    *p++ = (B64_LOOKUP[(uint8_t)src[i+1]] << 4 | B64_LOOKUP[(uint8_t)src[i+2]] >> 2) & 0xff;
    *p++ = (B64_LOOKUP[(uint8_t)src[i+2]] << 6 | B64_LOOKUP[(uint8_t)src[i+3]]) & 0xff;
  }

  // decode padding
  *p++ = (B64_LOOKUP[(uint8_t)src[i]] << 2 | B64_LOOKUP[(uint8_t)src[i+1]] >> 4) & 0xff;

  // decode rest of padding
  if (src[i+2] != '=') {
    *p++ = (B64_LOOKUP[(uint8_t)src[i+1]] << 4 | B64_LOOKUP[(uint8_t)src[i+2]] >> 2) & 0xff;
    if (src[i+3] != '=')
      *p++ = (B64_LOOKUP[(uint8_t)src[i+2]] << 6 | B64_LOOKUP[(uint8_t)src[i+3]]) & 0xff;
    else
      *p++ = B64_LOOKUP[(uint8_t)src[i+2]] << 6 & 0xff;
  } else {
    *p++ = B64_LOOKUP[(uint8_t)src[i+1]] << 4 & 0xff;
  }

  // add null terminator and return constructed buffer
  *p = '\0';
  return buffer;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xa2a0
movq %rax, %r14
testb $0x3, %r14b
je 0xc8b6
xorl %eax, %eax
jmp 0xc9ad
leaq (%r14,%r14,2), %rdi
shrq $0x2, %rdi
incq %rdi
callq 0xa040
xorl %edx, %edx
addq $-0x4, %r14
je 0xc937
leaq 0x2f78b(%rip), %rsi     # 0x3c060
movq %rax, %rcx
movzbl (%rbx,%rdx), %edi
movb (%rdi,%rsi), %dil
shlb $0x2, %dil
movzbl 0x1(%rbx,%rdx), %r8d
movb (%r8,%rsi), %r8b
movl %r8d, %r9d
shrb $0x4, %r9b
orb %dil, %r9b
movb %r9b, (%rcx)
shlb $0x4, %r8b
movzbl 0x2(%rbx,%rdx), %edi
movb (%rdi,%rsi), %dil
movl %edi, %r9d
shrb $0x2, %r9b
orb %r8b, %r9b
movb %r9b, 0x1(%rcx)
shlb $0x6, %dil
movzbl 0x3(%rbx,%rdx), %r8d
orb (%r8,%rsi), %dil
movb %dil, 0x2(%rcx)
addq $0x3, %rcx
addq $0x4, %rdx
cmpq %r14, %rdx
jb 0xc8d8
jmp 0xc93a
movq %rax, %rcx
movzbl (%rbx,%rdx), %edi
leaq 0x2f71b(%rip), %rsi     # 0x3c060
movb (%rdi,%rsi), %r8b
shlb $0x2, %r8b
movzbl 0x1(%rbx,%rdx), %edi
movb (%rdi,%rsi), %dil
movl %edi, %r9d
shrb $0x4, %r9b
orb %r8b, %r9b
movb %r9b, (%rcx)
movzbl 0x2(%rbx,%rdx), %r8d
shlb $0x4, %dil
cmpq $0x3d, %r8
jne 0xc97d
movb %dil, 0x1(%rcx)
addq $0x2, %rcx
jmp 0xc9aa
movb (%r8,%rsi), %r8b
movl %r8d, %r9d
shrb $0x2, %r9b
orb %dil, %r9b
movb %r9b, 0x1(%rcx)
movzbl 0x3(%rbx,%rdx), %edx
shlb $0x6, %r8b
cmpq $0x3d, %rdx
je 0xc9a2
orb (%rdx,%rsi), %r8b
movb %r8b, 0x2(%rcx)
addq $0x3, %rcx
movb $0x0, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/king1600[P]cordpp/./include/collection.h
// Function: cordpp::Collection<cordpp::Overwrite>::Collection()
Collection() {
      pos = 0;
      marking = 0;
      csize = 10;
      frag_rate = 3;
      frag_count = 0;
      list = new CollectionItem[csize];
      for (slot = 0; slot < csize; slot++)
        list[slot] = {nullptr, slot, 0};
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movq %r14, (%rdi)
movq %r14, 0x18(%rdi)
movq $0xa, 0x10(%rdi)
movq $0x3, 0x20(%rdi)
movq %r14, 0x28(%rdi)
movl $0xf0, %edi
callq 0xa040
movq %rax, 0x30(%rbx)
movq %r14, 0x8(%rbx)
cmpq %r14, 0x10(%rbx)
je 0xcc72
xorl %eax, %eax
xorl %ecx, %ecx
movq 0x30(%rbx), %rdx
leaq (%rcx,%rcx,2), %rsi
movq %rax, (%rdx,%rsi,8)
movq %rcx, 0x8(%rdx,%rsi,8)
movq %rax, 0x10(%rdx,%rsi,8)
movq 0x8(%rbx), %rcx
incq %rcx
movq %rcx, 0x8(%rbx)
cmpq 0x10(%rbx), %rcx
jb 0xcc4b
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/king1600[P]cordpp/./include/collection.h
// Function: cordpp::Collection<cordpp::Overwrite>::cache_size(unsigned long)
const size_t cache_size(const size_t new_size = 0) {
      if (new_size < 1)
        return csize;
      CollectionItem *new_list = new CollectionItem[new_size];
      for (slot = 0; slot < new_size; slot++)
        new_list[slot] = slot <= csize ? 
          list[csize - slot] : CollectionItem{nullptr, slot, 0};
      csize = new_size;
      delete list;
      list = new_list;
      return csize;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rsi, %rsi
je 0xcd29
movq %rsi, %r14
movl $0x18, %ecx
movq %rsi, %rax
mulq %rcx
movq $-0x1, %rdi
cmovnoq %rax, %rdi
callq 0xa040
movq %rax, %r15
movq 0x10(%rbx), %rax
movq 0x30(%rbx), %rcx
movq $0x0, 0x8(%rbx)
leaq (%rax,%rax,2), %rdx
leaq (%rcx,%rdx,8), %rcx
addq $0x10, %rcx
movq %r15, %rdx
addq $0x10, %rdx
xorl %esi, %esi
movl $0x0, %edi
movq %rsi, %r8
movl $0x0, %r9d
cmpq %rax, %rsi
ja 0xccef
movq -0x10(%rcx), %r9
movq -0x8(%rcx), %r8
movq (%rcx), %rdi
movq %r9, -0x10(%rdx)
movq %r8, -0x8(%rdx)
movq %rdi, (%rdx)
incq %rsi
movq %rsi, 0x8(%rbx)
addq $-0x18, %rcx
addq $0x18, %rdx
cmpq %rsi, %r14
jne 0xccd1
movq %r14, 0x10(%rbx)
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0xcd25
movl $0x18, %esi
callq 0xa5d0
movq %r15, 0x30(%rbx)
addq $0x10, %rbx
movq (%rbx), %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/king1600[P]cordpp/./include/collection.h
// Function: cordpp::Collection<cordpp::Emoji>::clear()
void clear() {
      pos = 0;
      for (slot = 0; slot < csize; slot++) {
        if (list[slot].item != nullptr) {
          delete list[slot].item;
          list[slot].marker = 0;
        }
      }
    }

// Assembly:
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
cmpq $0x0, 0x10(%rdi)
je 0x21494
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %eax, %eax
movq 0x30(%rbx), %rcx
leaq (%rax,%rax,2), %rax
movq (%rcx,%rax,8), %r14
testq %r14, %r14
je 0x2147c
leaq 0x38(%r14), %rdi
callq 0x21378
movq 0x10(%r14), %rdi
leaq 0x20(%r14), %rax
cmpq %rax, %rdi
je 0x2145a
movq (%rax), %rsi
incq %rsi
callq 0xa5d0
movl $0x78, %esi
movq %r14, %rdi
callq 0xa5d0
movq 0x8(%rbx), %rax
movq 0x30(%rbx), %rcx
leaq (%rax,%rax,2), %rax
movq $0x0, 0x10(%rcx,%rax,8)
movq 0x8(%rbx), %rax
incq %rax
movq %rax, 0x8(%rbx)
cmpq 0x10(%rbx), %rax
jb 0x21428
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/king1600[P]cordpp/src/client.cc
// Function: cordpp::Client::login(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Client::login(const std::string &_token) {
  // set the bot token
  token = _token;
  _api->set_token(token);

  // fetch the gateway url
  _api->get("/gateway/bot", "", {}, [this](const Json &data) {
    max_shards = (max_shards < 1) ? data["shards"].get<uint8_t>() : max_shards;
    std::string url = data["url"].get<std::string>();
    url = url.substr(url.find("://") + 3);
    _gateway = std::make_unique<Gateway>(this, url, shard_id, max_shards);
  });

  // run the event loop
  service.run();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
leaq 0x50(%rdi), %r14
movq %r14, %rdi
callq 0xa340
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x21568
movq 0x8(%rbx), %r14
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x2f1fb(%rip), %rsi     # 0x3c1c0
leaq 0x2f200(%rip), %rdx     # 0x3c1cc
leaq 0x20(%rsp), %rdi
callq 0xf09e
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x32817(%rip), %rdx     # 0x3f7fd
movq %rsp, %rdi
movq %rdx, %rsi
callq 0xf09e
leaq 0x40(%rsp), %r15
movb $0x0, (%r15)
movq %r15, %rdi
callq 0xf20e
movq %r15, %rdi
callq 0xf20e
xorps %xmm0, %xmm0
leaq 0x50(%rsp), %r8
movaps %xmm0, (%r8)
movaps %xmm0, 0x10(%r8)
movq %rbx, (%r8)
leaq 0x111(%rip), %rax       # 0xd136
movq %rax, 0x18(%r8)
leaq 0x27c(%rip), %rax       # 0xd2ac
movq %rax, 0x10(%r8)
leaq 0x20(%rsp), %rsi
movq %rsp, %rdx
movq %r14, %rdi
movq %r15, %rcx
callq 0x21572
movq 0x60(%rsp), %rax
testq %rax, %rax
je 0xd060
leaq 0x50(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0x40(%rsp), %rdi
callq 0xd48e
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0xd080
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa5d0
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0xd097
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xa5d0
addq $0x18, %rbx
movq %rbx, %rdi
callq 0x25daa
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0xd0f1
movq %rax, %rbx
movq 0x60(%rsp), %rax
testq %rax, %rax
je 0xd0cf
leaq 0x50(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0x40(%rsp), %rdi
callq 0xd48e
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0xd0fc
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa5d0
jmp 0xd0fc
movq %rax, %rdi
callq 0xd3bb
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0xd113
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xa5d0
movq %rbx, %rdi
callq 0xaa30
nop