LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: rvthak[P]Makefile-Maker/input.cpp
// Function: printInputFormat()
void printInputFormat(void){
	printf("\n          ------ Argument Format ------ \n // Default values on ()\n");
	printf(" >> Set Executable Name:     -n < name (a.out) >\n");
	printf(" >> Set Source file Format:  -f < source file format (.cpp) >\n");
	printf(" >> Set Header file Format:  -h < header file format (.hpp) >\n");
	printf(" >> Set Compiler:            -c < compiler name (g++) >\n");
	printf(" >> Toggle gdb:                     -db  (1)\n");
	printf(" >> Toggle valgrind:                -vg  (1)\n");
	printf(" >> Toggle compilation parameters:  -p   (0)\n");
	printf(" >> Toggle execution parameters:    -e   (0)\n");
	printf(" >> Toggle auto project organizer:  -org (0)\n");
	printf(" >> Print help:                     --help\n");
	
	printf("\n (i)> The <...> fields are REQUIRED right after their corresponding parameter\n");
	printf(" (i)> Rogue Strings and Non-Supported parameters will cause termination\n");
	printf(" (i)> Give Format by writing just the last chars (example: file.c => -f c) \n");
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x30cf(%rip), %rdi      # 0x61ea
movb $0x0, %al
callq 0x2050
leaq 0x3105(%rip), %rdi      # 0x622e
movb $0x0, %al
callq 0x2050
leaq 0x3129(%rip), %rdi      # 0x6260
movb $0x0, %al
callq 0x2050
leaq 0x315a(%rip), %rdi      # 0x629f
movb $0x0, %al
callq 0x2050
leaq 0x318b(%rip), %rdi      # 0x62de
movb $0x0, %al
callq 0x2050
leaq 0x31b6(%rip), %rdi      # 0x6317
movb $0x0, %al
callq 0x2050
leaq 0x31d6(%rip), %rdi      # 0x6345
movb $0x0, %al
callq 0x2050
leaq 0x31f6(%rip), %rdi      # 0x6373
movb $0x0, %al
callq 0x2050
leaq 0x3216(%rip), %rdi      # 0x63a1
movb $0x0, %al
callq 0x2050
leaq 0x3236(%rip), %rdi      # 0x63cf
movb $0x0, %al
callq 0x2050
leaq 0x3256(%rip), %rdi      # 0x63fd
movb $0x0, %al
callq 0x2050
leaq 0x3274(%rip), %rdi      # 0x6429
movb $0x0, %al
callq 0x2050
leaq 0x32b6(%rip), %rdi      # 0x6479
movb $0x0, %al
callq 0x2050
leaq 0x32f1(%rip), %rdi      # 0x64c2
movb $0x0, %al
callq 0x2050
popq %rbp
retq
nopw (%rax,%rax)
// File: rvthak[P]Makefile-Maker/input.cpp
// Function: getDesision(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool getDesision(const string msg){
	string str;
	cout << msg << ": ";
	
	while(1){
		cout << " ";
		cin >> str;

		if (cin.fail()){
	    	cin.clear(); 
	    	cin.ignore(numeric_limits<streamsize>::max(), '\n');
	    	cout << " > Wrong input try again: (y/n)" << endl;
    	}
		else if(str=="y"){
			cin.get();
			return 1;
		}
		else if(str=="n"){
			cin.get();
			return 0;
		}
		else{
			cout << " > Wrong input try again: (y/n)" << endl;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x22c0
movq -0x50(%rbp), %rsi
movq 0x565c(%rip), %rdi      # 0x8fd0
callq 0x21b0
movq %rax, -0x48(%rbp)
jmp 0x397f
movq -0x48(%rbp), %rdi
leaq 0x2c6b(%rip), %rsi      # 0x65f5
callq 0x21e0
jmp 0x3991
jmp 0x3993
jmp 0x3995
movq 0x5634(%rip), %rdi      # 0x8fd0
leaq 0x2d19(%rip), %rsi      # 0x66bc
callq 0x21e0
jmp 0x39aa
movq 0x562f(%rip), %rdi      # 0x8fe0
leaq -0x30(%rbp), %rsi
callq 0x2280
jmp 0x39bc
movq 0x561d(%rip), %rdi      # 0x8fe0
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x2030
movb %al, -0x51(%rbp)
jmp 0x39d7
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x39e0
jmp 0x3a5f
movq 0x55f9(%rip), %rdi      # 0x8fe0
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
xorl %esi, %esi
callq 0x2340
jmp 0x39fa
callq 0x3c50
movq %rax, %rsi
movq 0x55d7(%rip), %rdi      # 0x8fe0
movl $0xa, %edx
callq 0x2130
jmp 0x3a15
movq 0x55b4(%rip), %rdi      # 0x8fd0
leaq 0x2bf7(%rip), %rsi      # 0x661a
callq 0x21e0
movq %rax, -0x60(%rbp)
jmp 0x3a2e
movq -0x60(%rbp), %rdi
movq 0x5587(%rip), %rsi      # 0x8fc0
callq 0x21f0
jmp 0x3a40
jmp 0x3b02
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2110
jmp 0x3b1b
leaq 0x2bd4(%rip), %rsi      # 0x663a
leaq -0x30(%rbp), %rdi
callq 0x3c60
movb %al, -0x61(%rbp)
jmp 0x3a74
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0x3a7d
jmp 0x3a98
movq 0x555c(%rip), %rdi      # 0x8fe0
callq 0x2250
jmp 0x3a8b
movb $0x1, -0x1(%rbp)
movl $0x1, -0x40(%rbp)
jmp 0x3b07
leaq 0x260e(%rip), %rsi      # 0x60ad
leaq -0x30(%rbp), %rdi
callq 0x3c60
movb %al, -0x62(%rbp)
jmp 0x3aad
movb -0x62(%rbp), %al
testb $0x1, %al
jne 0x3ab6
jmp 0x3ad1
movq 0x5523(%rip), %rdi      # 0x8fe0
callq 0x2250
jmp 0x3ac4
movb $0x0, -0x1(%rbp)
movl $0x1, -0x40(%rbp)
jmp 0x3b07
movq 0x54f8(%rip), %rdi      # 0x8fd0
leaq 0x2b3b(%rip), %rsi      # 0x661a
callq 0x21e0
movq %rax, -0x70(%rbp)
jmp 0x3aea
movq -0x70(%rbp), %rdi
movq 0x54cb(%rip), %rsi      # 0x8fc0
callq 0x21f0
jmp 0x3afc
jmp 0x3afe
jmp 0x3b00
jmp 0x3b02
jmp 0x3993
leaq -0x30(%rbp), %rdi
callq 0x2110
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x2360
nopw %cs:(%rax,%rax)
// File: rvthak[P]Makefile-Maker/input.cpp
// Function: changeFormat(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 changeFormat(string &str, const string frm){
	int pos=str.find_last_of(".");
	int len=str.length() - pos;
	str.erase(pos+1, len);
	str+=frm;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x2a08(%rip), %rsi      # 0x6557
movq $-0x1, %rdx
callq 0x21c0
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2300
movslq -0x14(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
movslq -0x18(%rbp), %rdx
callq 0x2090
movq -0x20(%rbp), %rsi
movq -0x8(%rbp), %rdi
callq 0x2290
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: rvthak[P]Makefile-Maker/main.cpp
// Function: main
int main(int argc, char const **argv){

	// Create a Makefile with default values
	Makefile mk;

	// Parse the user arguments and update Makefile values
	InputManager(argc, argv, mk);

	// Get a list of files from the targeted directory
	SystemInput(mk);

	// Create and write the actual makefile
	Output(mk);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x118(%rbp), %rdi
movq %rdi, -0x130(%rbp)
callq 0x4070
movq -0x130(%rbp), %rdx
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x25d0
jmp 0x3f71
leaq -0x118(%rbp), %rdi
callq 0x3220
jmp 0x3f7f
leaq -0x118(%rbp), %rdi
callq 0x4bd0
jmp 0x3f8d
movl $0x0, -0x4(%rbp)
leaq -0x118(%rbp), %rdi
callq 0x3fe0
movl -0x4(%rbp), %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x120(%rbp)
movl %eax, -0x124(%rbp)
leaq -0x118(%rbp), %rdi
callq 0x3fe0
movq -0x120(%rbp), %rdi
callq 0x2360
nopw %cs:(%rax,%rax)
// File: rvthak[P]Makefile-Maker/makefileS.cpp
// Function: Makefile::Makefile()
Makefile::Makefile(){
	Name=NAME;
	Compiler=COMP;
	SourceFormat=FRMT;
	HeaderFormat=HEAD;
	debugEnable=DEBG;
	valgrindEnable=VALG;
	installEnable=INST;
	parameterEnable=PARM;
	execParamEnable=EXEC;
	organizeEnable=ORGN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
callq 0x22c0
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x58(%rbp)
callq 0x22c0
movq -0x20(%rbp), %rdi
addq $0x40, %rdi
movq %rdi, -0x50(%rbp)
callq 0x22c0
movq -0x20(%rbp), %rdi
addq $0x60, %rdi
movq %rdi, -0x48(%rbp)
callq 0x22c0
movq -0x20(%rbp), %rdi
addq $0x88, %rdi
movq %rdi, -0x40(%rbp)
callq 0x22c0
movq -0x20(%rbp), %rdi
addq $0xa8, %rdi
movq %rdi, -0x38(%rbp)
callq 0x22c0
movq -0x20(%rbp), %rdi
addq $0xc8, %rdi
movq %rdi, -0x30(%rbp)
callq 0x22c0
movq -0x20(%rbp), %rdi
addq $0xe8, %rdi
movq %rdi, -0x28(%rbp)
callq 0x22c0
movq -0x20(%rbp), %rdi
leaq 0x255e(%rip), %rsi      # 0x667c
callq 0x22b0
jmp 0x4125
movq -0x60(%rbp), %rdi
addq $0x20, %rdi
leaq 0x254e(%rip), %rsi      # 0x6682
callq 0x22b0
jmp 0x413b
movq -0x60(%rbp), %rdi
addq $0x40, %rdi
leaq 0x253c(%rip), %rsi      # 0x6686
callq 0x22b0
jmp 0x4151
movq -0x60(%rbp), %rdi
addq $0x60, %rdi
leaq 0x252a(%rip), %rsi      # 0x668a
callq 0x22b0
jmp 0x4167
movq -0x60(%rbp), %rax
movb $0x1, 0x80(%rax)
movb $0x1, 0x81(%rax)
movb $0x1, 0x82(%rax)
movb $0x0, 0x83(%rax)
movb $0x0, 0x84(%rax)
movb $0x0, 0x85(%rax)
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x2110
movq -0x30(%rbp), %rdi
callq 0x2110
movq -0x38(%rbp), %rdi
callq 0x2110
movq -0x40(%rbp), %rdi
callq 0x2110
movq -0x48(%rbp), %rdi
callq 0x2110
movq -0x50(%rbp), %rdi
callq 0x2110
movq -0x58(%rbp), %rdi
callq 0x2110
movq -0x20(%rbp), %rdi
callq 0x2110
movq -0x10(%rbp), %rdi
callq 0x2360
nopl (%rax,%rax)
// File: rvthak[P]Makefile-Maker/makefileS.cpp
// Function: Makefile::Makefile(Makefile const&)
Makefile::Makefile(const Makefile &mkfl){
	Name=mkfl.Name;
	Compiler=mkfl.Compiler;
	SourceFormat=mkfl.SourceFormat;
	HeaderFormat=mkfl.HeaderFormat;
	debugEnable=mkfl.debugEnable;
	valgrindEnable=mkfl.valgrindEnable;
	installEnable=mkfl.installEnable;
	parameterEnable=mkfl.parameterEnable;
	execParamEnable=mkfl.execParamEnable;
	organizeEnable=mkfl.organizeEnable;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
callq 0x22c0
movq -0x28(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x60(%rbp)
callq 0x22c0
movq -0x28(%rbp), %rdi
addq $0x40, %rdi
movq %rdi, -0x58(%rbp)
callq 0x22c0
movq -0x28(%rbp), %rdi
addq $0x60, %rdi
movq %rdi, -0x50(%rbp)
callq 0x22c0
movq -0x28(%rbp), %rdi
addq $0x88, %rdi
movq %rdi, -0x48(%rbp)
callq 0x22c0
movq -0x28(%rbp), %rdi
addq $0xa8, %rdi
movq %rdi, -0x40(%rbp)
callq 0x22c0
movq -0x28(%rbp), %rdi
addq $0xc8, %rdi
movq %rdi, -0x38(%rbp)
callq 0x22c0
movq -0x28(%rbp), %rdi
addq $0xe8, %rdi
movq %rdi, -0x30(%rbp)
callq 0x22c0
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2040
jmp 0x42b6
movq -0x68(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
addq $0x20, %rdi
callq 0x2040
jmp 0x42cd
movq -0x68(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x40, %rsi
addq $0x40, %rdi
callq 0x2040
jmp 0x42e4
movq -0x68(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x60, %rsi
addq $0x60, %rdi
callq 0x2040
jmp 0x42fb
movq -0x68(%rbp), %rax
movq -0x10(%rbp), %rcx
movb 0x80(%rcx), %cl
andb $0x1, %cl
movb %cl, 0x80(%rax)
movq -0x10(%rbp), %rcx
movb 0x81(%rcx), %cl
andb $0x1, %cl
movb %cl, 0x81(%rax)
movq -0x10(%rbp), %rcx
movb 0x82(%rcx), %cl
andb $0x1, %cl
movb %cl, 0x82(%rax)
movq -0x10(%rbp), %rcx
movb 0x83(%rcx), %cl
andb $0x1, %cl
movb %cl, 0x83(%rax)
movq -0x10(%rbp), %rcx
movb 0x84(%rcx), %cl
andb $0x1, %cl
movb %cl, 0x84(%rax)
movq -0x10(%rbp), %rcx
movb 0x85(%rcx), %cl
andb $0x1, %cl
movb %cl, 0x85(%rax)
addq $0x70, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x2110
movq -0x38(%rbp), %rdi
callq 0x2110
movq -0x40(%rbp), %rdi
callq 0x2110
movq -0x48(%rbp), %rdi
callq 0x2110
movq -0x50(%rbp), %rdi
callq 0x2110
movq -0x58(%rbp), %rdi
callq 0x2110
movq -0x60(%rbp), %rdi
callq 0x2110
movq -0x28(%rbp), %rdi
callq 0x2110
movq -0x18(%rbp), %rdi
callq 0x2360
nopw %cs:(%rax,%rax)
// File: rvthak[P]Makefile-Maker/output.cpp
// Function: mkflBody[abi:cxx11]()
string mkflBody(void){
	string buf;
	buf+="\nall: $(OUT)\n\n";
	buf+="$(OUT): $(OBJS)\n";
	buf+="\t$(CXX) -o $(OUT) $(OBJS)\n\n";
	buf+="%.o: %.c\n";
	buf+="\t$(CXX) -c -o $@ $<\n\n";
	buf+="run: $(OUT)\n";
	buf+="\t./$(OUT) $(EXECUTION_PARAMETERS)\n\n";
	return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
callq 0x22c0
movq -0x28(%rbp), %rdi
leaq 0x1603(%rip), %rsi      # 0x686e
callq 0x21d0
jmp 0x5272
movq -0x28(%rbp), %rdi
leaq 0x1600(%rip), %rsi      # 0x687d
callq 0x21d0
jmp 0x5284
movq -0x28(%rbp), %rdi
leaq 0x15ff(%rip), %rsi      # 0x688e
callq 0x21d0
jmp 0x5296
movq -0x28(%rbp), %rdi
leaq 0x1609(%rip), %rsi      # 0x68aa
callq 0x21d0
jmp 0x52a8
movq -0x28(%rbp), %rdi
leaq 0x1601(%rip), %rsi      # 0x68b4
callq 0x21d0
jmp 0x52ba
movq -0x28(%rbp), %rdi
leaq 0x1605(%rip), %rsi      # 0x68ca
callq 0x21d0
jmp 0x52cc
movq -0x28(%rbp), %rdi
leaq 0x1600(%rip), %rsi      # 0x68d7
callq 0x21d0
jmp 0x52de
movb $0x1, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
jne 0x530a
jmp 0x5301
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x2110
jmp 0x5314
movq -0x28(%rbp), %rdi
callq 0x2110
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x2360
nopl (%rax)
// File: rvthak[P]Makefile-Maker/output.cpp
// Function: mkflInst[abi:cxx11]()
string mkflInst(void){
	string buf;
	buf+="\ninstall: $(OUT)\n";
	buf+="\tsudo cp $(OUT) /usr/local/bin\n";
	buf+="\t@echo Program Installed in /usr/local/bin\n";
	buf+="\t@echo You can now delete this folder safely\n\n";
	return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
callq 0x22c0
movq -0x28(%rbp), %rdi
leaq 0x15b0(%rip), %rsi      # 0x68fb
callq 0x21d0
jmp 0x5352
movq -0x28(%rbp), %rdi
leaq 0x15b0(%rip), %rsi      # 0x690d
callq 0x21d0
jmp 0x5364
movq -0x28(%rbp), %rdi
leaq 0x15be(%rip), %rsi      # 0x692d
callq 0x21d0
jmp 0x5376
movq -0x28(%rbp), %rdi
leaq 0x15d8(%rip), %rsi      # 0x6959
callq 0x21d0
jmp 0x5388
movb $0x1, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
jne 0x53b4
jmp 0x53ab
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x2110
jmp 0x53be
movq -0x28(%rbp), %rdi
callq 0x2110
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x2360
nopw (%rax,%rax)
// File: rvthak[P]Makefile-Maker/output.cpp
// Function: mkflDB[abi:cxx11]()
string mkflDB(void){
	string buf;
	buf+="db: clean param\n";
	buf+="param: CXXFLAGS += -g\n";
	buf+="param: $(OUT)\n\n";
	buf+="gdb: db\n";
	buf+="\tgdb $(OUT)\n\n";
	return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
callq 0x22c0
movq -0x28(%rbp), %rdi
leaq 0x158d(%rip), %rsi      # 0x6988
callq 0x21d0
jmp 0x5402
movq -0x28(%rbp), %rdi
leaq 0x158c(%rip), %rsi      # 0x6999
callq 0x21d0
jmp 0x5414
movq -0x28(%rbp), %rdi
leaq 0x1591(%rip), %rsi      # 0x69b0
callq 0x21d0
jmp 0x5426
movq -0x28(%rbp), %rdi
leaq 0x158f(%rip), %rsi      # 0x69c0
callq 0x21d0
jmp 0x5438
movq -0x28(%rbp), %rdi
leaq 0x1586(%rip), %rsi      # 0x69c9
callq 0x21d0
jmp 0x544a
movb $0x1, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
jne 0x5476
jmp 0x546d
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x2110
jmp 0x5480
movq -0x28(%rbp), %rdi
callq 0x2110
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x2360
nopl (%rax)
// File: rvthak[P]Makefile-Maker/output.cpp
// Function: mkflVal[abi:cxx11](bool)
string mkflVal(bool dbflag){
	string buf;

	if(!dbflag){
		buf+="db: clean param\n";
		buf+="param: CXXFLAGS += -g\n";
		buf+="param: $(OUT)\n\n";
	}
	
	buf+="vg: db\n";
	buf+="\tvalgrind $(EXECUTION_PARAMETERS) ./$(OUT)\n\n";

	buf+="vgleak: db\n";
	buf+="\tvalgrind --leak-check=full ./$(OUT) $(EXECUTION_PARAMETERS)\n\n";

	buf+="vgext: db\n";
	buf+="\tvalgrind --leak-check=full --show-leak-kinds=all --leak-resolution=high --track-origins=yes --vgdb=yes ./$(OUT) $(EXECUTION_PARAMETERS)\n\n";

	return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movb %sil, %al
movq %rdi, %rcx
movq %rcx, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movb $0x0, -0xa(%rbp)
callq 0x22c0
testb $0x1, -0x9(%rbp)
jne 0x5510
movq -0x30(%rbp), %rdi
leaq 0x14bf(%rip), %rsi      # 0x6988
callq 0x21d0
jmp 0x54d0
movq -0x30(%rbp), %rdi
leaq 0x14be(%rip), %rsi      # 0x6999
callq 0x21d0
jmp 0x54e2
movq -0x30(%rbp), %rdi
leaq 0x14c3(%rip), %rsi      # 0x69b0
callq 0x21d0
jmp 0x54f4
jmp 0x5510
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x2110
jmp 0x5599
movq -0x30(%rbp), %rdi
leaq 0x14bc(%rip), %rsi      # 0x69d7
callq 0x21d0
jmp 0x5522
movq -0x30(%rbp), %rdi
leaq 0x14b2(%rip), %rsi      # 0x69df
callq 0x21d0
jmp 0x5534
movq -0x30(%rbp), %rdi
leaq 0x14cd(%rip), %rsi      # 0x6a0c
callq 0x21d0
jmp 0x5546
movq -0x30(%rbp), %rdi
leaq 0x14c7(%rip), %rsi      # 0x6a18
callq 0x21d0
jmp 0x5558
movq -0x30(%rbp), %rdi
leaq 0x14f4(%rip), %rsi      # 0x6a57
callq 0x21d0
jmp 0x556a
movq -0x30(%rbp), %rdi
leaq 0x14ed(%rip), %rsi      # 0x6a62
callq 0x21d0
jmp 0x557c
movb $0x1, -0xa(%rbp)
testb $0x1, -0xa(%rbp)
jne 0x558f
movq -0x30(%rbp), %rdi
callq 0x2110
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x2360
nopw %cs:(%rax,%rax)
// File: rvthak[P]Makefile-Maker/output.cpp
// Function: mkflClean[abi:cxx11]()
string mkflClean(void){
	string buf;

	buf+=".PHONY: clean\n";
	buf+="clean:\n";
	buf+="\trm -f *.o\n";
	
	return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
callq 0x22c0
movq -0x28(%rbp), %rdi
leaq 0x1512(%rip), %rsi      # 0x6aed
callq 0x21d0
jmp 0x55e2
movq -0x28(%rbp), %rdi
leaq 0x150f(%rip), %rsi      # 0x6afc
callq 0x21d0
jmp 0x55f4
movq -0x28(%rbp), %rdi
leaq 0x1505(%rip), %rsi      # 0x6b04
callq 0x21d0
jmp 0x5606
movb $0x1, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
jne 0x5632
jmp 0x5629
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x2110
jmp 0x563c
movq -0x28(%rbp), %rdi
callq 0x2110
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x2360
// File: iZhangHui[P]CppPrimer/CH12_DynamicMemory/exercises/ex12_07.cc
// Function: populate(std::shared_ptr<std::vector<int, std::allocator<int>>>)
shared_ptr<vector<int>> populate(shared_ptr<vector<int>> vec)
{
	int item;

	while (cin >> item) {
		vec->push_back(item);
	}

	return vec;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x4cfa(%rip), %rdi      # 0x6fe0
leaq -0x14(%rbp), %rsi
callq 0x2080
movq %rax, %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x20f0
testb $0x1, %al
jne 0x2304
jmp 0x231b
movq -0x30(%rbp), %rdi
callq 0x2510
movq %rax, %rdi
leaq -0x14(%rbp), %rsi
callq 0x2530
jmp 0x22df
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdi
callq 0x25a0
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: night-shift[P]Srl/src/lib/Environment.cpp
// Function: (anonymous namespace)::conv_str(Srl::String const&, std::vector<unsigned char, std::allocator<unsigned char>>&, Srl::Encoding)
MemBlock conv_str(const String& in, vector<uint8_t>& buffer, Encoding encoding)
    {
        if(in.encoding() == encoding) {
            return MemBlock(in.data(), in.size());
        }
        auto size = Tools::conv_charset(encoding, in, buffer, true);

        return MemBlock(buffer.data(), size);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movb %al, -0x21(%rbp)
movq -0x18(%rbp), %rdi
callq 0x342c0
cmpb -0x21(%rbp), %al
jne 0x3d28b
movq -0x18(%rbp), %rdi
callq 0x33490
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x37f50
movq -0x38(%rbp), %rsi
movq %rax, %rdx
leaq -0x10(%rbp), %rdi
callq 0x33280
jmp 0x3d2c5
movb -0x21(%rbp), %al
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl $0x1, %ecx
xorl %edi, %edi
movl %edi, %r8d
movzbl %al, %edi
callq 0x37380
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x36f40
movq %rax, %rsi
movq -0x30(%rbp), %rdx
leaq -0x10(%rbp), %rdi
callq 0x33280
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: night-shift[P]Srl/src/lib/Environment.cpp
// Function: Srl::Lib::Environment::store_string(Srl::String const&)
pair<const String*, size_t> Environment::store_string(const String& str)
{
    if(str.size() < 1) {
        return { &Environment::EmptyString, EmptyStringHash };
    }

    auto conv = conv_str(str, this->str_buffer, Environment::Str_Encoding);
    auto hash = hash_fnc(conv);

    auto* str_ptr = this->str_table.get(conv);

    if(str_ptr) {
        return { str_ptr, hash };
    }

    String new_str(conv);

    if(!new_str.block.try_store_local()) {
        new_str.block.extern_data = Aux::copy(this->heap, conv).ptr;
    }

    str_ptr = this->str_table.insert(new_str, new_str).second;
    return { str_ptr, hash };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0x20(%rbp), %rdi
callq 0x37f50
cmpq $0x1, %rax
jae 0x3d391
movq 0x45bbc(%rip), %rax     # 0x82f30
movq %rax, -0x28(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq 0x493d9(%rip), %rdx     # 0x86760
callq 0x34550
jmp 0x3d4d4
movq -0xb0(%rbp), %rsi
movq -0x20(%rbp), %rdi
addq $0x220, %rsi            # imm = 0x220
movl $0x1, %edx
callq 0x3d240
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3d4f0
movq %rax, %rcx
movq -0xb0(%rbp), %rax
movq %rcx, -0x40(%rbp)
addq $0x58, %rax
movq %rax, -0xb8(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
leaq -0x58(%rbp), %rdi
movl $0x1, %ecx
callq 0x38280
movq -0xb8(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x358f0
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
je 0x3d42e
leaq -0x10(%rbp), %rdi
leaq -0x48(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x38350
jmp 0x3d4d4
movq -0x38(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdx
leaq -0x78(%rbp), %rdi
movl $0x1, %ecx
callq 0x38280
leaq -0x78(%rbp), %rdi
callq 0x35060
testb $0x1, %al
jne 0x3d494
movq -0xb0(%rbp), %rdi
addq $0x8, %rdi
leaq -0x38(%rbp), %rsi
callq 0x34650
movq %rax, -0x98(%rbp)
movq %rdx, -0x90(%rbp)
movq -0x98(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0xb0(%rbp), %rdi
addq $0x58, %rdi
leaq -0x78(%rbp), %rdx
movq %rdx, %rsi
callq 0x34a40
movb %al, -0xa8(%rbp)
movq %rdx, -0xa0(%rbp)
movq -0xa0(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x48(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x38350
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: night-shift[P]Srl/src/lib/Environment.cpp
// Function: Srl::Lib::Environment::create_node(Srl::Type, Srl::String const&)
Link<Node>* Environment::create_node(Type type, const String& name)
{
    auto strp = this->store_string(name);
    auto* link = this->heap.create<Link<Node>>(strp.second, Node(this->tree, type));
    link->field.name_ptr = strp.first;

    return link;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
movq -0x18(%rbp), %rsi
callq 0x34140
movq %rax, %rcx
movq -0xc0(%rbp), %rax
movq %rcx, -0x28(%rbp)
leaq -0x20(%rbp), %rcx
movq %rcx, -0xb0(%rbp)
movq %rdx, -0x20(%rbp)
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0xb8(%rbp)
movq (%rax), %rsi
movzbl -0x9(%rbp), %edx
leaq -0x88(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
movl $0x1, %ecx
callq 0x33fb0
movq -0xb8(%rbp), %rdi
movq -0xb0(%rbp), %rsi
movq -0xa8(%rbp), %rdx
callq 0x35b60
movq %rax, -0xa0(%rbp)
jmp 0x3da1a
leaq -0x88(%rbp), %rdi
callq 0x38bf0
movq -0xa0(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x30(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x38bf0
movq -0x90(%rbp), %rdi
callq 0x38210
nopw %cs:(%rax,%rax)
// File: night-shift[P]Srl/src/lib/Environment.cpp
// Function: Srl::Lib::Environment::store_value(Srl::Node&, Srl::Value const&, Srl::String const&)
Link<Value>* Environment::store_value(Node& parent, const Value& value, const String& name)
{
    auto* link = this->create_link(parent.values, value, name);
    auto& block = link->field.block;

    if(!block.stored_local && !block.try_store_local()) {
        block.extern_data = Aux::copy(this->heap, { block.extern_data, block.size }).ptr;
    }

    return link;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x37320
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x8, %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
testb $0x1, 0xe(%rax)
jne 0x3db25
movq -0x30(%rbp), %rdi
callq 0x35060
testb $0x1, %al
jne 0x3db25
movq -0x58(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x60(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rsi
movq -0x30(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, %edx
leaq -0x50(%rbp), %rdi
callq 0x33280
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x34650
movq %rax, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movq -0x40(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nop
// File: night-shift[P]Srl/src/lib/Environment.cpp
// Function: Srl::Lib::Environment::conv_type(Srl::Value const&)
Value Environment::conv_type(const Value& value)
{
    size_t data_size = 0;
    auto& buffer = this->type_buffer;

    if(value.type() == Type::String) {

        String wrap(value.data(), value.size(), value.encoding());
        data_size = Tools::conv_charset(Encoding::UTF8, wrap, buffer, true);

    } else if(TpTools::is_scalar(value.type())) {

        data_size = Tools::type_to_str(value, buffer);

    } else {

        assert(value.type() == Type::Binary && "Value type invalid.");

        data_size = Tools::bytes_to_base64(value.data(), value.size(), buffer);
    }

    return Value( { buffer.data(), data_size }, value.type());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, -0x48(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, -0x18(%rbp)
addq $0x238, %rax            # imm = 0x238
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x35b80
cmpb $0xc, %al
jne 0x3dea4
movq -0x10(%rbp), %rdi
callq 0x36770
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
callq 0x34510
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0x35830
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
leaq -0x30(%rbp), %rdi
movzbl %al, %ecx
callq 0x33a50
movq -0x20(%rbp), %rdx
movl $0x1, %ecx
leaq -0x30(%rbp), %rsi
xorl %eax, %eax
movl %eax, %r8d
movl %ecx, %edi
callq 0x37380
movq %rax, -0x18(%rbp)
jmp 0x3df40
movq -0x10(%rbp), %rdi
callq 0x35b80
movzbl %al, %edi
callq 0x345d0
testb $0x1, %al
jne 0x3debb
jmp 0x3dece
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x34d00
movq %rax, -0x18(%rbp)
jmp 0x3df3e
movq -0x10(%rbp), %rdi
callq 0x35b80
movb %al, %cl
xorl %eax, %eax
cmpb $0xd, %cl
movb %al, -0x61(%rbp)
jne 0x3deea
movb $0x1, %al
movb %al, -0x61(%rbp)
jmp 0x3deea
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0x3def3
jmp 0x3def5
jmp 0x3df14
leaq 0x2b1de(%rip), %rdi     # 0x690da
leaq 0x2b20d(%rip), %rsi     # 0x69110
movl $0xd4, %edx
leaq 0x2b219(%rip), %rcx     # 0x69128
callq 0x349a0
movq -0x10(%rbp), %rdi
callq 0x36770
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rdi
callq 0x34510
movq -0x70(%rbp), %rdi
movq %rax, %rsi
movq -0x20(%rbp), %rdx
callq 0x35330
movq %rax, -0x18(%rbp)
jmp 0x3df40
movq -0x20(%rbp), %rdi
callq 0x36f40
movq %rax, %rsi
movq -0x18(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x33280
movq -0x10(%rbp), %rdi
callq 0x35b80
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movzbl %al, %edx
callq 0x36df0
movq -0x48(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: night-shift[P]Srl/src/lib/Environment.cpp
// Function: Srl::Lib::Environment::clear()
void Environment::clear()
{
    this->heap.clear();
    this->str_table.clear();
    this->shared_table_store.clear();
    this->shared_table_restore.clear();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x8, %rdi
callq 0x34800
movq -0x10(%rbp), %rdi
addq $0x58, %rdi
callq 0x330e0
movq -0x10(%rbp), %rdi
addq $0xf0, %rdi
callq 0x33390
movq -0x10(%rbp), %rdi
addq $0x188, %rdi            # imm = 0x188
callq 0x38cb0
addq $0x10, %rsp
popq %rbp
retq
// File: night-shift[P]Srl/include/Srl/Hash.hpp
// Function: Srl::Lib::HTable<Srl::String, Srl::String, Srl::Lib::HashSrl<Srl::String, void>>::get(Srl::String const&)
V* HTable<K, V, H>::get(const K& key)
    {
        if(elements < 1) {
            return nullptr;
        }

        auto hash    = hash_fnc(key);
        auto bucket  = get_bucket(hash);
        Entry* entry = table[bucket];

        while(entry) {

            if(entry->hash == hash && entry->key == key) {
                return &entry->val;
            }

            entry = entry->next;
        }

        return nullptr;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x1, 0x18(%rax)
jae 0x3e31c
movq $0x0, -0x8(%rbp)
jmp 0x3e3a8
movq -0x38(%rbp), %rdi
addq $0x40, %rdi
movq -0x18(%rbp), %rsi
callq 0x35fc0
movq -0x38(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
callq 0x34490
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq 0x20(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x3e3a0
movq -0x30(%rbp), %rax
movq (%rax), %rax
cmpq -0x20(%rbp), %rax
jne 0x3e392
movq -0x30(%rbp), %rdi
addq $0x10, %rdi
movq -0x18(%rbp), %rsi
callq 0x33e90
testb $0x1, %al
jne 0x3e384
jmp 0x3e392
movq -0x30(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x8(%rbp)
jmp 0x3e3a8
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x3e359
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: night-shift[P]Srl/include/Srl/Blocks.h
// Function: Srl::Lib::PackedBlock::try_store_local()
bool try_store_local()
            {
                if(!can_store_local()) {
                    return false;
                }

                auto* tmp = this->extern_data;
                for(auto i = 0U; i < this->size; i++) {
                    this->local_data[i] = tmp[i];
                }

                return this->stored_local = true;
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x348a0
testb $0x1, %al
jne 0x3e413
movb $0x0, -0x1(%rbp)
jmp 0x3e45c
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x8(%rcx), %eax
jae 0x3e450
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movl -0x1c(%rbp), %edx
movb (%rcx,%rdx), %dl
movl -0x1c(%rbp), %ecx
movb %dl, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3e425
movq -0x28(%rbp), %rax
movb $0x1, 0xe(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: night-shift[P]Srl/include/Srl/Aux.h
// Function: Srl::Lib::Aux::copy(Srl::Lib::Heap&, Srl::Lib::MemBlock const&)
inline MemBlock copy (Heap& heap, const MemBlock& block)
    {
        if(block.size < 1) return block;

        auto* mem = heap.get_mem(block.size);
        memcpy(mem, block.ptr, block.size);

        return { mem, block.size };
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x1, 0x8(%rax)
jae 0x3e4a0
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x10(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x3e4e2
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x34730
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x35360
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdx
leaq -0x10(%rbp), %rdi
callq 0x33280
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x30, %rsp
popq %rbp
retq
// File: night-shift[P]Srl/src/lib/Environment.cpp
// Function: Srl::Lib::Link<Srl::Node>* Srl::Lib::Environment::create_link<Srl::Node>(std::__cxx11::list<Srl::Lib::Link<Srl::Node>, Srl::Lib::HeapAllocator<Srl::Lib::Link<Srl::Node>>>&, Srl::Node const&, Srl::String const&)
Link<T>* Environment::create_link(Lib::Items<T>& lst, const T& val, const String& name)
{
    auto strp = this->store_string(name);
    lst.emplace_back(strp.second, val);
    auto& link = lst.back();
    link.field.name_ptr = strp.first;

    return &link;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x34140
movq %rax, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
addq $0x8, %rsi
movq -0x18(%rbp), %rdx
callq 0x369b0
movq -0x10(%rbp), %rdi
callq 0x363c0
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: night-shift[P]Srl/include/Srl/Hash.hpp
// Function: Srl::Lib::HTable<Srl::String, Srl::String, Srl::Lib::HashSrl<Srl::String, void>>::clear()
void HTable<K, V, H>::clear()
    {
        if(this->elements < 1) {
            return;
        }

        this->destroy_all<K, V>();
        this->heap.clear();
        this->mem_cache.clear();
        this->elements = 0;
        this->limit    = 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x1, 0x18(%rax)
jae 0x3ec1d
jmp 0x3ec54
movq -0x10(%rbp), %rdi
callq 0x38860
movq -0x10(%rbp), %rdi
addq $0x48, %rdi
callq 0x34800
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
callq 0x35be0
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq $0x0, 0x10(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: night-shift[P]Srl/include/Srl/Heap.hpp
// Function: unsigned char* Srl::Lib::Heap::get_mem<unsigned char>(unsigned long)
T* Heap::get_mem(size_t n_elems)
    {
        auto sz = n_elems * sizeof(T);

        if(!this->crr_seg || this->crr_seg->left < sz + alignof(T) - 1) {
            this->crr_seg = this->alloc(sz, alignof(T));
        }

        auto* mem = this->crr_seg->pointer();

        auto rem    = (size_t)mem % alignof(T);
        auto offset = rem ? alignof(T) - rem : 0;

        mem += offset;
        this->crr_seg->dec(sz + offset);

        return reinterpret_cast<T*>(mem);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rcx
shlq $0x0, %rcx
movq %rcx, -0x18(%rbp)
cmpq $0x0, 0x8(%rax)
je 0x3edd7
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x8(%rax), %eax
movq -0x18(%rbp), %rcx
addq $0x1, %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x3edf4
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x1, %edx
callq 0x34c30
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x37a90
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
andq $0x0, %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x3ee27
movl $0x1, %eax
subq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x3ee2f
xorl %eax, %eax
movq %rax, -0x40(%rbp)
jmp 0x3ee2f
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movq -0x30(%rbp), %rcx
addq -0x20(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
addq -0x30(%rbp), %rsi
callq 0x33c00
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: night-shift[P]Srl/include/Srl/Hash.hpp
// Function: Srl::Lib::HTable<Srl::String, Srl::String, Srl::Lib::HashSrl<Srl::String, void>>::get_bucket(unsigned long)
uint64_t HTable<K, V, H>::get_bucket(uint64_t hash)
    {
        /* mix in the upper half bits of the hash unless table capacity is bigger 2 ^ (bits in word / 2) - 1 */
        const auto shift = sizeof(uint64_t) * 4;
        const auto lim   = ~(uint64_t)0 >> shift;

        return (this->cap <= lim ? hash ^ hash >> shift : hash) % this->cap;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x20, -0x18(%rbp)
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movq %rcx, -0x20(%rbp)
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rcx, 0x8(%rax)
ja 0x3ffd5
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
shrq $0x20, %rcx
xorq %rcx, %rax
movq %rax, -0x30(%rbp)
jmp 0x3ffdd
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
xorl %edx, %edx
divq 0x8(%rcx)
movq %rdx, %rax
popq %rbp
retq
// File: night-shift[P]Srl/include/Srl/String.hpp
// Function: Srl::String::operator==(Srl::String const&) const
inline bool String::operator== (const String& a) const
    {
        const auto cmp = [this](const uint8_t* mem, size_t sz) {

            return this->block.size == sz && memcmp(this->block.data(), mem, sz) == 0;
        };

        if(this->block.size == 0 && a.block.size == 0) {
            return true;
        }

        if(a.block.encoding == this->block.encoding) {
            return cmp(a.block.data(), a.block.size);

        } else {
            auto tmp = Tools::conv_charset(this->block.encoding, a, false);
            return cmp(tmp.data(), tmp.size());
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq %rax, -0x20(%rbp)
cmpl $0x0, 0x8(%rax)
jne 0x40025
movq -0x18(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x40025
movb $0x1, -0x1(%rbp)
jmp 0x400ca
movq -0x50(%rbp), %rcx
movq -0x18(%rbp), %rax
movb 0xd(%rax), %al
cmpb 0xd(%rcx), %al
jne 0x4005a
movq -0x18(%rbp), %rdi
callq 0x35580
movq %rax, %rsi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, %edx
leaq -0x20(%rbp), %rdi
callq 0x38990
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x400ca
movq -0x50(%rbp), %rax
movzbl 0xd(%rax), %esi
movq -0x18(%rbp), %rdx
leaq -0x38(%rbp), %rdi
movq %rdi, -0x68(%rbp)
xorl %ecx, %ecx
callq 0x38220
movq -0x68(%rbp), %rdi
callq 0x36f40
movq -0x68(%rbp), %rdi
movq %rax, -0x60(%rbp)
callq 0x37840
movq -0x60(%rbp), %rsi
movq %rax, %rdx
leaq -0x20(%rbp), %rdi
callq 0x38990
movb %al, -0x51(%rbp)
jmp 0x400a0
movb -0x51(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x33980
jmp 0x400ca
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x33980
jmp 0x400d5
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x38210
nop
// File: night-shift[P]Srl/include/Srl/Hash.hpp
// Function: Srl::Lib::HTable<Srl::String, Srl::String, Srl::Lib::HashSrl<Srl::String, void>>::redistribute()
void HTable<K, V, H>::redistribute()
    {
        if(this->limit == 0) {
            /* initial allocation */
            this->set_capacity(this->cap);
            this->table = this->alloc_table(this->cap);

            return;
        }

        auto old_dim = this->cap;
        this->set_capacity(this->cap * 2);

        auto* ntable = alloc_table(this->cap);

        for(auto i = 0U; i < old_dim; i++) {
            auto* entry = table[i];
            while(entry) {
                auto bucket = get_bucket(entry->hash);
                auto* slot = ntable[bucket];

                if(!slot) {
                    ntable[bucket] = entry;

                } else while(true) {
                    if(!slot->next) {
                        slot->next = entry;
                        break;
                    }
                    slot = slot->next;
                }

                auto* tmp = entry;
                entry = entry->next;
                tmp->next = nullptr;
            }
        }

        this->heap.put_mem((uint8_t*)this->table, old_dim * sizeof(nullptr));
        this->table = ntable;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, 0x10(%rax)
jne 0x405d5
movq -0x48(%rbp), %rdi
movq 0x8(%rdi), %rsi
callq 0x34410
movq -0x48(%rbp), %rdi
movq 0x8(%rdi), %rsi
callq 0x35690
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0x406f5
movq -0x48(%rbp), %rdi
movq 0x8(%rdi), %rax
movq %rax, -0x10(%rbp)
movq 0x8(%rdi), %rsi
shlq %rsi
callq 0x34410
movq -0x48(%rbp), %rdi
movq 0x8(%rdi), %rsi
callq 0x35690
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpq -0x10(%rbp), %rax
jae 0x406cd
movq -0x48(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x1c(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x406bd
movq -0x48(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rsi
callq 0x34490
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x4066d
movq -0x28(%rbp), %rdx
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x40698
jmp 0x4066f
movq -0x38(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x40688
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x40696
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x4066f
jmp 0x40698
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x40(%rbp), %rax
movq $0x0, 0x8(%rax)
jmp 0x40625
jmp 0x406bf
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x40605
movq -0x48(%rbp), %rax
movq %rax, %rdi
addq $0x48, %rdi
movq 0x20(%rax), %rsi
movq -0x10(%rbp), %rdx
shlq $0x3, %rdx
callq 0x341a0
movq -0x48(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x20(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: night-shift[P]Srl/include/Srl/Hash.hpp
// Function: Srl::Lib::HTable<unsigned long, std::shared_ptr<void>, Srl::Lib::HashSrl<unsigned long, void>>::foreach_break(std::function<bool (unsigned long const&, std::shared_ptr<void>&)> const&) const
void HTable<K, V, H>::foreach_break(const std::function<bool(const K&, V&)>& fnc) const
    {
        if(this->elements < 1) {
            return;
        }

        auto n = 0U;

        for(auto i = 0U; i < this->cap; i++) {

            auto* entry = table[i];

            while(entry) {

                auto abort = fnc(entry->key, entry->val);

                if(abort) {
                    return;
                }

                entry = entry->next;
                n++;
            }

            if(n >= this->elements) {
                break;
            }
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x1, 0x18(%rax)
jae 0x42384
jmp 0x42412
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x30(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpq 0x8(%rcx), %rax
jae 0x42412
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x18(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x423f6
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x10, %rsi
movq -0x20(%rbp), %rdx
addq $0x18, %rdx
callq 0x35370
andb $0x1, %al
movb %al, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
je 0x423df
jmp 0x42412
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x423b2
movq -0x30(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpq 0x18(%rcx), %rax
jb 0x42405
jmp 0x42412
jmp 0x42407
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x42392
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: night-shift[P]Srl/src/lib/Hash.cpp
// Function: (anonymous namespace)::fnv1a(unsigned char const*, unsigned long)
uint64_t fnv1a(const uint8_t* bytes, size_t nbytes)
    {
        auto hash = fnv1a_base;

        for(auto unroll = nbytes / 8; unroll > 0;
            unroll--, bytes += 8) {

            fnv1a_unfold<8>(bytes, hash);
        }

        auto rem = nbytes % 8;

        switch(rem) {
            case 0 : break;
            case 1 : fnv1a_unfold<1>(bytes, hash); break;
            case 2 : fnv1a_unfold<2>(bytes, hash); break;
            case 3 : fnv1a_unfold<3>(bytes, hash); break;
            case 4 : fnv1a_unfold<4>(bytes, hash); break;
            case 5 : fnv1a_unfold<5>(bytes, hash); break;
            case 6 : fnv1a_unfold<6>(bytes, hash); break;
            case 7 : fnv1a_unfold<7>(bytes, hash); break;
        }

        return hash;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movabsq $-0x340d631b7bdddcdb, %rax # imm = 0xCBF29CE484222325
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
shrq $0x3, %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jbe 0x430a8
movq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x43150
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
jmp 0x4307a
movq -0x10(%rbp), %rax
andl $0x7, %eax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
subq $0x7, %rax
ja 0x4313e
movq -0x30(%rbp), %rax
leaq 0x26240(%rip), %rcx     # 0x6930c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x4313e
movq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x431a0
jmp 0x4313e
movq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x431f0
jmp 0x4313e
movq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x43240
jmp 0x4313e
movq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x43290
jmp 0x4313e
movq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x432e0
jmp 0x4313e
movq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x43330
jmp 0x4313e
movq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x43380
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: night-shift[P]Srl/src/lib/Heap.cpp
// Function: Srl::Lib::Heap::Chain::get_link()
SegLink* Heap::Chain::get_link()
{
    auto* link = this->free_links.find_rm(Any());

    if(!link) {
        link = new ChainLink();
    }

    this->used_links.append(link);

    return &link->val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x30, %rdi
leaq -0x11(%rbp), %rsi
callq 0x436a0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x434bf
movl $0x28, %edi
callq 0x35c40
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
movq $0x0, 0x20(%rdi)
callq 0x347b0
jmp 0x43499
movq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x434bf
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x28, %esi
callq 0x35d30
jmp 0x434de
movq -0x30(%rbp), %rdi
addq $0x20, %rdi
movq -0x10(%rbp), %rsi
callq 0x38340
movq -0x10(%rbp), %rax
addq $0x8, %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x38210
nopw (%rax,%rax)