LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: yuansliu[P]HiRGC/hirgc.cpp
// Function: compressFile(char*, char*)
void compressFile(char *refFile, char *tarFile) {
	char res[100];
	char cmd[200];
	initial(); //important************* must initial before other operation

	sprintf(res, "%s_ref_%s", tarFile, refFile);
	compressFile(refFile, tarFile, res);
	sprintf(cmd, "./7za a %s.7z %s -m0=PPMd", res, res);
	system(cmd);
	sprintf(cmd, "rm %s", res);
	system(cmd);

	clear();
}

// Assembly:
subq $0x148, %rsp            # imm = 0x148
movq %rdi, 0x140(%rsp)
movq %rsi, 0x138(%rsp)
callq 0x52f0
leaq 0xd0(%rsp), %rdi
movq 0x138(%rsp), %rdx
movq 0x140(%rsp), %rcx
leaq 0x3e1e(%rip), %rsi      # 0x8079
movb $0x0, %al
callq 0x2060
movq 0x140(%rsp), %rdi
movq 0x138(%rsp), %rsi
leaq 0xd0(%rsp), %rdx
callq 0x53b0
movq %rsp, %rdi
leaq 0xd0(%rsp), %rdx
leaq 0xd0(%rsp), %rcx
leaq 0x3dea(%rip), %rsi      # 0x8083
movb $0x0, %al
callq 0x2060
movq %rsp, %rdi
callq 0x2140
movq %rsp, %rdi
leaq 0xd0(%rsp), %rdx
leaq 0x3de3(%rip), %rsi      # 0x809d
movb $0x0, %al
callq 0x2060
movq %rsp, %rdi
callq 0x2140
callq 0x53f0
addq $0x148, %rsp            # imm = 0x148
retq
nopw %cs:(%rax,%rax)
// File: yuansliu[P]HiRGC/hirgc.cpp
// Function: getList(char*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
bool getList(char *list_file, vector<string> &name_list) {
	FILE *fp = fopen(list_file, "r");
	if (fp == NULL) {
		printf("%s open fail!\n", list_file);
		return false;
	}
	char str[1024];
	while (fscanf(fp, "%s", str) != EOF) {
		name_list.push_back(string(str));
	}
	fclose(fp);
	if (name_list.size() == 0) {
		printf("%s is empty!\n", list_file);
		return false;
	}
	return true;
}

// Assembly:
subq $0x478, %rsp            # imm = 0x478
movq %rdi, 0x468(%rsp)
movq %rsi, 0x460(%rsp)
movq 0x468(%rsp), %rdi
leaq 0x374a(%rip), %rsi      # 0x8040
callq 0x21b0
movq %rax, 0x458(%rsp)
cmpq $0x0, 0x458(%rsp)
jne 0x4931
movq 0x468(%rsp), %rsi
leaq 0x388f(%rip), %rdi      # 0x81ac
movb $0x0, %al
callq 0x2040
movb $0x0, 0x477(%rsp)
jmp 0x4a2c
jmp 0x4933
movq 0x458(%rsp), %rdi
leaq 0x50(%rsp), %rdx
leaq 0x3759(%rip), %rsi      # 0x80a0
movb $0x0, %al
callq 0x22a0
cmpl $-0x1, %eax
je 0x49e4
movq 0x460(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x2f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x2290
movq 0x10(%rsp), %rdx
leaq 0x30(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x21e0
jmp 0x4989
movq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x5670
jmp 0x499a
leaq 0x30(%rsp), %rdi
callq 0x2100
leaq 0x2f(%rsp), %rdi
callq 0x21a0
jmp 0x4933
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x49d8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x2100
leaq 0x2f(%rsp), %rdi
callq 0x21a0
jmp 0x4a3d
movq 0x458(%rsp), %rdi
callq 0x2180
movq 0x460(%rsp), %rdi
callq 0x5520
cmpq $0x0, %rax
jne 0x4a24
movq 0x468(%rsp), %rsi
leaq 0x37a8(%rip), %rdi      # 0x81bb
movb $0x0, %al
callq 0x2040
movb $0x0, 0x477(%rsp)
jmp 0x4a2c
movb $0x1, 0x477(%rsp)
movb 0x477(%rsp), %al
andb $0x1, %al
addq $0x478, %rsp            # imm = 0x478
retq
movq 0x20(%rsp), %rdi
callq 0x2280
nopw (%rax,%rax)
// File: yuansliu[P]HiRGC/hirgc.cpp
// Function: show_usage()
void show_usage() {
    cout << "HiRGC v1.0\n";
	cout << "Usage: hirgc -m <mode> -r <reference> -t <target> -n <file>\n";
	cout << "  -m is the mode, three limited values <file, genome, set>, required\n";
    cout << "  -r is the reference, a FASTA file or a genome folder according to the mode, required\n";
	cout << "  -t is the target, a FASTA file or a genome folder or a file contains a list of genome folder, required\n";
    cout << "  -n is a file containing name of chromosomes or a string \"default\"\n";
	cout << "Examples:\n";
	cout << "  hirgc -m file -r YH_chr1.fa -t HG18_chr1.fa\n";
	cout << "  hirgc -m genome -r YH -t HG18 -n default\n";
	cout << "  hirgc -m genome -r YH -t HG18 -n chr_name.txt\n";
	cout << "  hirgc -m set -r YH -t genome_set.txt -n default\n";
	cout << "  hirgc -m set -r YH -t genome_set.txt -n chr_name.txt\n";
}

// Assembly:
pushq %rax
movq 0x6510(%rip), %rdi      # 0xafd8
leaq 0x36fa(%rip), %rsi      # 0x81c9
callq 0x2170
movq 0x64fd(%rip), %rdi      # 0xafd8
leaq 0x36f3(%rip), %rsi      # 0x81d5
callq 0x2170
movq 0x64ea(%rip), %rdi      # 0xafd8
leaq 0x371d(%rip), %rsi      # 0x8212
callq 0x2170
movq 0x64d7(%rip), %rdi      # 0xafd8
leaq 0x3750(%rip), %rsi      # 0x8258
callq 0x2170
movq 0x64c4(%rip), %rdi      # 0xafd8
leaq 0x3795(%rip), %rsi      # 0x82b0
callq 0x2170
movq 0x64b1(%rip), %rdi      # 0xafd8
leaq 0x37ec(%rip), %rsi      # 0x831a
callq 0x2170
movq 0x649e(%rip), %rdi      # 0xafd8
leaq 0x381e(%rip), %rsi      # 0x835f
callq 0x2170
movq 0x648b(%rip), %rdi      # 0xafd8
leaq 0x3816(%rip), %rsi      # 0x836a
callq 0x2170
movq 0x6478(%rip), %rdi      # 0xafd8
leaq 0x3832(%rip), %rsi      # 0x8399
callq 0x2170
movq 0x6465(%rip), %rdi      # 0xafd8
leaq 0x384b(%rip), %rsi      # 0x83c5
callq 0x2170
movq 0x6452(%rip), %rdi      # 0xafd8
leaq 0x3869(%rip), %rsi      # 0x83f6
callq 0x2170
movq 0x643f(%rip), %rdi      # 0xafd8
leaq 0x3889(%rip), %rsi      # 0x8429
callq 0x2170
popq %rax
retq
nopw (%rax,%rax)
// File: yuansliu[P]HiRGC/hirgc.cpp
// Function: initial()
inline void initial() { // malloc momories
	meta_data = new char[1024];
	pos_vec = new POSITION_RANGE[min_size];
	line_break_vec = new int[1<<23];
	n_vec = new  POSITION_RANGE[min_size];
	other_char_vec = new POSITION_OTHER_CHAR[min_size];

	tar_seq_code = new int[MAX_CHAR_NUM];
	ref_seq_code = new int[MAX_CHAR_NUM];

	loc = new int[MAX_CHAR_NUM];
	point = new int[max_arr_num];

	dismatched_str = new char[min_size];
}

// Assembly:
pushq %rax
movl $0x400, %edi            # imm = 0x400
callq 0x2030
movq %rax, 0x5e86(%rip)      # 0xb188
movl $0x800000, %edi         # imm = 0x800000
callq 0x2030
movq %rax, 0x5e7d(%rip)      # 0xb190
movl $0x2000000, %edi        # imm = 0x2000000
callq 0x2030
movq %rax, 0x5e84(%rip)      # 0xb1a8
movl $0x800000, %edi         # imm = 0x800000
callq 0x2030
movq %rax, 0x5e63(%rip)      # 0xb198
movl $0x800000, %edi         # imm = 0x800000
callq 0x2030
movq %rax, 0x5e5a(%rip)      # 0xb1a0
movl $0x40000000, %edi       # imm = 0x40000000
callq 0x2030
movq %rax, 0x5e59(%rip)      # 0xb1b0
movl $0x40000000, %edi       # imm = 0x40000000
callq 0x2030
movq %rax, 0x5e50(%rip)      # 0xb1b8
movl $0x40000000, %edi       # imm = 0x40000000
callq 0x2030
movq %rax, 0x5e67(%rip)      # 0xb1e0
movabsq $0x100000000, %rdi      # imm = 0x100000000
callq 0x2030
movq %rax, 0x5e59(%rip)      # 0xb1e8
movl $0x100000, %edi         # imm = 0x100000
callq 0x2030
movq %rax, 0x5e50(%rip)      # 0xb1f0
popq %rax
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: yuansliu[P]HiRGC/hirgc.cpp
// Function: compressFile(char*, char*, char*)
inline void compressFile(char *refFile, char *tarFile, char *resFile) {
	readRefFile(refFile);
	preProcessRef();
	readTarFile(tarFile);
	searchMatch(resFile);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x10(%rsp), %rdi
callq 0x31c0
callq 0x3d10
movq 0x8(%rsp), %rdi
callq 0x3310
movq (%rsp), %rdi
callq 0x3e90
addq $0x18, %rsp
retq
nopl (%rax)
// File: yuansliu[P]HiRGC/hirgc.cpp
// Function: clear()
inline void clear() { // free
	delete[] meta_data;
	delete[] pos_vec;
	delete[] line_break_vec;
	delete[] n_vec;
	delete[] other_char_vec;
	delete[] tar_seq_code;
	delete[] ref_seq_code;
	delete[] loc;
	delete[] point;
	delete[] dismatched_str;
}

// Assembly:
subq $0x58, %rsp
movq 0x5d8d(%rip), %rax      # 0xb188
movq %rax, 0x50(%rsp)
cmpq $0x0, %rax
je 0x5410
movq 0x50(%rsp), %rdi
callq 0x21c0
movq 0x5d79(%rip), %rax      # 0xb190
movq %rax, 0x48(%rsp)
cmpq $0x0, %rax
je 0x542c
movq 0x48(%rsp), %rdi
callq 0x21c0
movq 0x5d75(%rip), %rax      # 0xb1a8
movq %rax, 0x40(%rsp)
cmpq $0x0, %rax
je 0x5448
movq 0x40(%rsp), %rdi
callq 0x21c0
movq 0x5d49(%rip), %rax      # 0xb198
movq %rax, 0x38(%rsp)
cmpq $0x0, %rax
je 0x5464
movq 0x38(%rsp), %rdi
callq 0x21c0
movq 0x5d35(%rip), %rax      # 0xb1a0
movq %rax, 0x30(%rsp)
cmpq $0x0, %rax
je 0x5480
movq 0x30(%rsp), %rdi
callq 0x21c0
movq 0x5d29(%rip), %rax      # 0xb1b0
movq %rax, 0x28(%rsp)
cmpq $0x0, %rax
je 0x549c
movq 0x28(%rsp), %rdi
callq 0x21c0
movq 0x5d15(%rip), %rax      # 0xb1b8
movq %rax, 0x20(%rsp)
cmpq $0x0, %rax
je 0x54b8
movq 0x20(%rsp), %rdi
callq 0x21c0
movq 0x5d21(%rip), %rax      # 0xb1e0
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x54d4
movq 0x18(%rsp), %rdi
callq 0x21c0
movq 0x5d0d(%rip), %rax      # 0xb1e8
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x54f0
movq 0x10(%rsp), %rdi
callq 0x21c0
movq 0x5cf9(%rip), %rax      # 0xb1f0
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x550c
movq 0x8(%rsp), %rdi
callq 0x21c0
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: stevedonovan[P]outstreams/conversions.cpp
// Function: test(char const*)
void test(const char *str) {
   Reader::Error err;
   int res = 0;
   double x = 0;
   string s;
   short b = 0;

   outs("input")(str)();
   //~ Writer("/tmp/tmp.tmp")(str);
   //~ Reader s1("/tmp/tmp.tmp");
   StrReader s1(str);
   s1 (res)(x)(s)(b)(err);
   outs("output")(res)(x)(s)(b)();
   outs("error")(err.msg)();

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movq %rdi, -0x8(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3b50
movl $0x0, -0x3c(%rbp)
movq $0x0, -0x48(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x32c0
movw $0x0, -0x6a(%rbp)
leaq 0x6ad3(%rip), %rdi      # 0xa2d0
leaq 0x382e(%rip), %rsi      # 0x7032
xorl %eax, %eax
movl %eax, %edx
callq 0x3b70
movq %rax, -0xd8(%rbp)
jmp 0x3816
movq -0xd8(%rbp), %rdi
movq -0x8(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x3b70
movq %rax, -0xe0(%rbp)
jmp 0x3833
movq -0xe0(%rbp), %rdi
callq 0x6770
jmp 0x3841
movq -0x8(%rbp), %rsi
leaq -0xd0(%rbp), %rdi
callq 0x5830
jmp 0x3853
xorl %eax, %eax
movl %eax, %edx
leaq -0xd0(%rbp), %rdi
leaq -0x3c(%rbp), %rsi
callq 0x4fb0
movq %rax, -0xe8(%rbp)
jmp 0x3870
movq -0xe8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
leaq -0x48(%rbp), %rsi
callq 0x4e70
movq %rax, -0xf0(%rbp)
jmp 0x388d
movq -0xf0(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
leaq -0x68(%rbp), %rsi
callq 0x4910
movq %rax, -0xf8(%rbp)
jmp 0x38aa
movq -0xf8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
leaq -0x6a(%rbp), %rsi
callq 0x50d0
movq %rax, -0x100(%rbp)
jmp 0x38c7
movq -0x100(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x4e20
jmp 0x38d9
leaq 0x69f0(%rip), %rdi      # 0xa2d0
leaq 0x3751(%rip), %rsi      # 0x7038
xorl %eax, %eax
movl %eax, %edx
callq 0x3b70
movq %rax, -0x108(%rbp)
jmp 0x38f9
movq -0x108(%rbp), %rdi
movl -0x3c(%rbp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x3bb0
movq %rax, -0x110(%rbp)
jmp 0x3915
movq -0x110(%rbp), %rdi
movsd -0x48(%rbp), %xmm0
xorl %eax, %eax
movl %eax, %esi
callq 0x3bf0
movq %rax, -0x118(%rbp)
jmp 0x3933
movq -0x118(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
leaq -0x68(%rbp), %rsi
callq 0x3c30
movq %rax, -0x120(%rbp)
jmp 0x3950
movq -0x120(%rbp), %rdi
movswl -0x6a(%rbp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x3bb0
movq %rax, -0x128(%rbp)
jmp 0x396d
movq -0x128(%rbp), %rdi
callq 0x6770
jmp 0x397b
leaq 0x694e(%rip), %rdi      # 0xa2d0
leaq 0x36b6(%rip), %rsi      # 0x703f
xorl %eax, %eax
movl %eax, %edx
callq 0x3b70
movq %rax, -0x130(%rbp)
jmp 0x399b
movq -0x130(%rbp), %rdi
leaq -0x30(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x3c30
movq %rax, -0x138(%rbp)
jmp 0x39b8
movq -0x138(%rbp), %rdi
callq 0x6770
jmp 0x39c6
leaq -0xd0(%rbp), %rdi
callq 0x3c70
leaq -0x68(%rbp), %rdi
callq 0x33c8
leaq -0x38(%rbp), %rdi
callq 0x3c90
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x3a13
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0x3c70
leaq -0x68(%rbp), %rdi
callq 0x33c8
leaq -0x38(%rbp), %rdi
callq 0x3c90
movq -0x78(%rbp), %rdi
callq 0x3330
nop
// File: stevedonovan[P]outstreams/conversions.cpp
// Function: main
int main()
{
   outs.sep(' '); // DEFAULT

   test("10 4.2 boo 34");
   test("10 4.2 boo 344455555");
   test("10 x4.2 boo 23");
   test("x10 4.2 boo 52");
   test("10 4.2");

   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
leaq 0x688a(%rip), %rdi      # 0xa2d0
movl $0x20, %esi
callq 0x66d0
leaq 0x35ee(%rip), %rdi      # 0x7045
callq 0x37c0
leaq 0x35f0(%rip), %rdi      # 0x7053
callq 0x37c0
leaq 0x35f9(%rip), %rdi      # 0x7068
callq 0x37c0
leaq 0x35fc(%rip), %rdi      # 0x7077
callq 0x37c0
leaq 0x35ff(%rip), %rdi      # 0x7086
callq 0x37c0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: stevedonovan[P]outstreams/instream.cpp
// Function: stream::Reader::open(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*)
bool Reader::open(const std::string& file, const char *how) {
    in = fopen(file.c_str(),how);
    bad = errno;
    if (bad) {
        err_msg = strerror(errno);
    }
    return ! bad;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x30d0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x3240
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
callq 0x3050
movq %rax, %rcx
movq -0x20(%rbp), %rax
movl (%rcx), %ecx
movl %ecx, 0x1c(%rax)
cmpl $0x0, 0x1c(%rax)
je 0x40ff
callq 0x3050
movl (%rax), %edi
callq 0x30b0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
addq $0x20, %rdi
callq 0x32b0
movq -0x20(%rbp), %rax
cmpl $0x0, 0x1c(%rax)
setne %al
xorb $-0x1, %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: stevedonovan[P]outstreams/instream.cpp
// Function: stream::Reader::set(_IO_FILE*, bool)
void Reader::set(FILE *new_in, bool own) {
  close();
  in = new_in;
  owner = own;
  pos = 0;
  bad = in == nullptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x41f0
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movb -0x11(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x10(%rax)
movl $0x0, 0x18(%rax)
cmpq $0x0, 0x8(%rax)
sete %cl
andb $0x1, %cl
movzbl %cl, %ecx
movl %ecx, 0x1c(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: stevedonovan[P]outstreams/instream.cpp
// Function: stream::Reader::operator()(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char const*)
Reader& Reader::operator() (std::string &s,const char *fmt) {
  if (fail()) return *this;
  char buff[line_size];
  if (! formatted_read("string","%s%n",fmt,buff,&fpos)) return *this;
  s = buff;
  return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x128(%rbp)
callq 0x4230
testb $0x1, %al
jne 0x493d
jmp 0x494a
movq -0x128(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x49ac
movq -0x128(%rbp), %rdi
movq -0x20(%rbp), %rcx
leaq -0x120(%rbp), %r8
movq %rdi, %r9
addq $0x14, %r9
leaq 0x27e5(%rip), %rsi      # 0x714f
leaq 0x27e5(%rip), %rdx      # 0x7156
movb $0x0, %al
callq 0x4440
movq %rax, %rdi
callq 0x4250
testb $0x1, %al
jne 0x4991
movq -0x128(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x49ac
leaq -0x120(%rbp), %rsi
movq -0x18(%rbp), %rdi
callq 0x32b0
movq -0x128(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopl (%rax)
// File: stevedonovan[P]outstreams/instream.cpp
// Function: stream::Reader::conversion_error(char const*, unsigned long, bool)
Reader& Reader::conversion_error(const char *kind, uint64_t val, bool was_unsigned) {
   bad = ERANGE;
   std::string msg = "error converting " + std::string(kind) + " out of range ";
   if (was_unsigned) {
      msg += std::to_string(val);
   } else {
      msg += std::to_string((int64_t)val);
   }
   set_error(msg,1);
   return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xf0(%rbp)
movl $0x22, 0x1c(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0xe8(%rbp)
leaq -0x81(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x3340
movq -0xe8(%rbp), %rsi
movq -0xe0(%rbp), %rdx
leaq -0x80(%rbp), %rdi
callq 0x3aa0
jmp 0x4a27
leaq 0x26b8(%rip), %rsi      # 0x70e6
leaq -0x60(%rbp), %rdi
leaq -0x80(%rbp), %rdx
callq 0x5a40
jmp 0x4a3d
leaq 0x26b4(%rip), %rdx      # 0x70f8
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x5a90
jmp 0x4a53
leaq -0x60(%rbp), %rdi
callq 0x33c8
leaq -0x80(%rbp), %rdi
callq 0x33c8
leaq -0x81(%rbp), %rdi
callq 0x31e0
testb $0x1, -0x19(%rbp)
je 0x4b47
movq -0x18(%rbp), %rsi
leaq -0xb8(%rbp), %rdi
callq 0x5b30
jmp 0x4a8d
leaq -0x40(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x3270
jmp 0x4a9f
leaq -0xb8(%rbp), %rdi
callq 0x33c8
jmp 0x4b99
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x4afc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x4af3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x33c8
leaq -0x80(%rbp), %rdi
callq 0x33c8
leaq -0x81(%rbp), %rdi
callq 0x31e0
jmp 0x4bd2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x4bc9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x33c8
jmp 0x4bc9
movq -0x18(%rbp), %rsi
leaq -0xd8(%rbp), %rdi
callq 0x5c10
jmp 0x4b59
leaq -0x40(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
callq 0x3270
jmp 0x4b6b
leaq -0xd8(%rbp), %rdi
callq 0x33c8
jmp 0x4b99
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0x33c8
jmp 0x4bc9
movq -0xf0(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movl $0x1, %edx
callq 0x4400
jmp 0x4bb0
leaq -0x40(%rbp), %rdi
callq 0x33c8
movq -0xf0(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
leaq -0x40(%rbp), %rdi
callq 0x33c8
movq -0x90(%rbp), %rdi
callq 0x3330
nop
// File: stevedonovan[P]outstreams/instream.cpp
// Function: stream::Reader::setpos(long, char)
void Reader::setpos(long p, char end) {
  int whence = SEEK_SET;
  if (end == '$') {
     whence = SEEK_END;
  } else
  if (end == '.') {
     whence = SEEK_CUR;
  }
  fseek(in,p,whence);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $0x24, %eax
jne 0x4c36
movl $0x2, -0x18(%rbp)
jmp 0x4c48
movsbl -0x11(%rbp), %eax
cmpl $0x2e, %eax
jne 0x4c46
movl $0x1, -0x18(%rbp)
jmp 0x4c48
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
movl -0x18(%rbp), %edx
callq 0x3210
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: stevedonovan[P]outstreams/instream.cpp
// Function: stream::Reader::read_line(char*, int)
int Reader::read_line(char *buff, int buffsize) {
  char *res = read_raw_line(buff,buffsize);
  if (res == nullptr) {
     set_error("EOF",EOF);
     return 0;
  }
  int sz = res != nullptr ? strlen(res) : 0;
  pos += sz;
  return sz;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x68(%rbp)
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x4d2a
leaq -0x49(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x3340
movq -0x70(%rbp), %rdx
leaq 0x2445(%rip), %rsi      # 0x7107
leaq -0x48(%rbp), %rdi
callq 0x3aa0
jmp 0x4ccd
movq -0x68(%rbp), %rdi
leaq -0x48(%rbp), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x4400
jmp 0x4ce1
leaq -0x48(%rbp), %rdi
callq 0x33c8
leaq -0x49(%rbp), %rdi
callq 0x31e0
movl $0x0, -0x4(%rbp)
jmp 0x4d62
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x4d1f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x33c8
leaq -0x49(%rbp), %rdi
callq 0x31e0
jmp 0x4d6e
cmpq $0x0, -0x28(%rbp)
je 0x4d40
movq -0x28(%rbp), %rdi
callq 0x30f0
movq %rax, -0x78(%rbp)
jmp 0x4d48
xorl %eax, %eax
movq %rax, -0x78(%rbp)
jmp 0x4d48
movq -0x68(%rbp), %rax
movq -0x78(%rbp), %rcx
movl %ecx, -0x60(%rbp)
movl -0x60(%rbp), %ecx
addl 0x18(%rax), %ecx
movl %ecx, 0x18(%rax)
movl -0x60(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x3330
nopw (%rax,%rax)
// File: stevedonovan[P]outstreams/instream.cpp
// Function: stream::Reader::readall(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool Reader::readall (std::string& s) {
  char buff[512];
  size_t sz;
  s.clear();
  while ((sz = read(buff,sizeof(buff))) > 0) {
     s.append(buff,sz);
  }
  return errno != 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp            # imm = 0x220
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x220(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3290
movq -0x220(%rbp), %rdi
leaq -0x210(%rbp), %rsi
movq (%rdi), %rax
movl $0x200, %edx            # imm = 0x200
callq *0x18(%rax)
movq %rax, -0x218(%rbp)
cmpq $0x0, %rax
jbe 0x4de6
movq -0x10(%rbp), %rdi
leaq -0x210(%rbp), %rsi
movq -0x218(%rbp), %rdx
callq 0x3060
jmp 0x4da7
callq 0x3050
cmpl $0x0, (%rax)
setne %al
andb $0x1, %al
addq $0x220, %rsp            # imm = 0x220
popq %rbp
retq
nopl (%rax)
// File: stevedonovan[P]outstreams/instream.cpp
// Function: stream::Reader::operator()(stream::Reader::Error&)
Reader& Reader::operator() (Reader::Error& err) {
  err.errcode = bad;
  err.msg = err_msg;
  err.pos = pos;
  return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x18(%rbp)
movl 0x1c(%rsi), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
addq $0x20, %rsi
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x3040
movq -0x18(%rbp), %rax
movslq 0x18(%rax), %rdx
movq -0x10(%rbp), %rcx
movq %rdx, 0x28(%rcx)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: stevedonovan[P]outstreams/instream.cpp
// Function: stream::Reader::operator()(int&, char const*)
Reader& Reader::operator() (int32_t &i,const char *fmt) {
   int64_t val;
   if (! (*this)(val)) return *this;
   if (val < INT32_MIN || val > INT32_MAX) return conversion_error("int32",val,false);
   i = (int16_t)val;
   return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
leaq -0x28(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x4f10
movq %rax, %rdi
callq 0x4250
testb $0x1, %al
jne 0x4fef
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5034
cmpq $-0x80000000, -0x28(%rbp) # imm = 0x80000000
jl 0x5003
cmpq $0x7fffffff, -0x28(%rbp) # imm = 0x7FFFFFFF
jle 0x501f
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq 0x2125(%rip), %rsi      # 0x7137
xorl %ecx, %ecx
callq 0x49c0
movq %rax, -0x8(%rbp)
jmp 0x5034
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movswl %cx, %edx
movq -0x18(%rbp), %rcx
movl %edx, (%rcx)
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: stevedonovan[P]outstreams/instream.cpp
// Function: stream::Reader::operator()(unsigned int&, char const*)
Reader& Reader::operator() (uint32_t &i,const char *fmt) {
   uint64_t val;
   if (! (*this)(val)) return *this;
   if (val > UINT32_MAX) return conversion_error("uint32",val,true);
   i = (uint32_t)val;
   return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
leaq -0x28(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x4f60
movq %rax, %rdi
callq 0x4250
testb $0x1, %al
jne 0x507f
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x50bd
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, -0x28(%rbp)
jbe 0x50a9
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq 0x209d(%rip), %rsi      # 0x7136
movl $0x1, %ecx
callq 0x49c0
movq %rax, -0x8(%rbp)
jmp 0x50bd
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movl %ecx, %edx
movq -0x18(%rbp), %rcx
movl %edx, (%rcx)
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: stevedonovan[P]outstreams/instream.cpp
// Function: stream::Reader::operator()(short&, char const*)
Reader& Reader::operator() (int16_t &i,const char *fmt) {
   int64_t val;
   if (! (*this)(val)) return *this;
   if (val < INT16_MIN || val > INT16_MAX) return conversion_error("int16",val,false);
   i = (int16_t)val;
   return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
leaq -0x28(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x4f10
movq %rax, %rdi
callq 0x4250
testb $0x1, %al
jne 0x510f
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5155
cmpq $-0x8000, -0x28(%rbp)   # imm = 0x8000
jl 0x5123
cmpq $0x7fff, -0x28(%rbp)    # imm = 0x7FFF
jle 0x513f
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq 0x200c(%rip), %rsi      # 0x713e
xorl %ecx, %ecx
callq 0x49c0
movq %rax, -0x8(%rbp)
jmp 0x5155
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movw %cx, %dx
movq -0x18(%rbp), %rcx
movw %dx, (%rcx)
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: stevedonovan[P]outstreams/instream.cpp
// Function: stream::Reader::operator()(unsigned short&, char const*)
Reader& Reader::operator() (uint16_t &i,const char *fmt) {
   uint64_t val;
   if (! (*this)(val)) return *this;
   if (val > UINT16_MAX) return conversion_error("uint16",val,true);
   i = (uint16_t)val;
   return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
leaq -0x28(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x4f60
movq %rax, %rdi
callq 0x4250
testb $0x1, %al
jne 0x519f
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x51de
cmpq $0xffff, -0x28(%rbp)    # imm = 0xFFFF
jbe 0x51c8
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq 0x1f85(%rip), %rsi      # 0x713d
movl $0x1, %ecx
callq 0x49c0
movq %rax, -0x8(%rbp)
jmp 0x51de
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movw %cx, %dx
movq -0x18(%rbp), %rcx
movw %dx, (%rcx)
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: stevedonovan[P]outstreams/instream.cpp
// Function: stream::Reader::operator()(unsigned char&, char const*)
Reader& Reader::operator() (uint8_t &i,const char *fmt) {
   uint64_t val;
   if (! (*this)(val)) return *this;
   if (val > UINT8_MAX) return conversion_error("uchar",val,true);
   i = (uint8_t)val;
   return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
leaq -0x28(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x4f60
movq %rax, %rdi
callq 0x4250
testb $0x1, %al
jne 0x527f
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x52bc
cmpq $0xff, -0x28(%rbp)
jbe 0x52a8
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq 0x1eb1(%rip), %rsi      # 0x7149
movl $0x1, %ecx
callq 0x49c0
movq %rax, -0x8(%rbp)
jmp 0x52bc
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movb %cl, %dl
movq -0x18(%rbp), %rcx
movb %dl, (%rcx)
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: stevedonovan[P]outstreams/instream.cpp
// Function: stream::Reader::operator()(char const*)
Reader& Reader::operator() (const char *extra) {
  char buff[line_size];
  strcpy(buff,extra);
  strcat(buff,"%n");
  return formatted_read("S",extra,nullptr,&fpos);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x118(%rbp)
leaq -0x110(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x31a0
leaq -0x110(%rbp), %rdi
leaq 0x1e3a(%rip), %rsi      # 0x7146
callq 0x3350
movq -0x118(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq %rdi, %r8
addq $0x14, %r8
leaq 0x1e31(%rip), %rsi      # 0x715b
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x4440
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nop
// File: stevedonovan[P]outstreams/instream.cpp
// Function: stream::Reader::skip(int)
Reader& Reader::skip(int lines) {
  if (fail()) return *this;
  int i = 0;
  char buff[line_size];
  while (i < lines && read_line(buff,line_size) > 0) {
     ++i;
  }
  return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x128(%rbp)
callq 0x4230
testb $0x1, %al
jne 0x5388
jmp 0x5395
movq -0x128(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x53f2
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %ecx
xorl %eax, %eax
cmpl -0x14(%rbp), %ecx
movb %al, -0x129(%rbp)
jge 0x53d0
movq -0x128(%rbp), %rdi
leaq -0x120(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x4c70
cmpl $0x0, %eax
setg %al
movb %al, -0x129(%rbp)
movb -0x129(%rbp), %al
testb $0x1, %al
jne 0x53dc
jmp 0x53e7
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x539c
movq -0x128(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nop
// File: stevedonovan[P]outstreams/instream.cpp
// Function: stream::Reader::getline(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
Reader& Reader::getline(std::string& s) {
  if (fail()) return *this;
  char buff[line_size];
  s.clear();
  int n = read_line(buff,line_size);
  while (n > 1) {
    if (buff[n-1]=='\n') {
       --n;
       buff[n] = 0; // trim \n
       s.append(buff,n);
       break;
    } else {
       s.append(buff,n);
    }
    n = read_line(buff,line_size);
  }
  return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x130(%rbp)
callq 0x4230
testb $0x1, %al
jne 0x5429
jmp 0x5439
movq -0x130(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5501
movq -0x18(%rbp), %rdi
callq 0x3290
movq -0x130(%rbp), %rdi
leaq -0x120(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x4c70
movl %eax, -0x124(%rbp)
cmpl $0x1, -0x124(%rbp)
jle 0x54f6
movl -0x124(%rbp), %eax
subl $0x1, %eax
cltq
movsbl -0x120(%rbp,%rax), %eax
cmpl $0xa, %eax
jne 0x54bc
movl -0x124(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x124(%rbp)
movslq -0x124(%rbp), %rax
movb $0x0, -0x120(%rbp,%rax)
movq -0x18(%rbp), %rdi
leaq -0x120(%rbp), %rsi
movslq -0x124(%rbp), %rdx
callq 0x3060
jmp 0x54f6
movq -0x18(%rbp), %rdi
leaq -0x120(%rbp), %rsi
movslq -0x124(%rbp), %rdx
callq 0x3060
movq -0x130(%rbp), %rdi
leaq -0x120(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x4c70
movl %eax, -0x124(%rbp)
jmp 0x5460
movq -0x130(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nop
// File: stevedonovan[P]outstreams/instream.cpp
// Function: stream::Reader::getlineinfo(long)
Reader::LineInfo Reader::getlineinfo (long p) {
    if (p == -1)
        p = pos;
    setpos(0,'^');
    pos = 0;
    char buff[line_size];
    int last_pos, lineno = 1;
    read_line(buff,line_size);
    while (pos < p) {
        lineno++;
        last_pos = pos;
        read_line(buff,line_size);
    }
    int col = p - last_pos;
    setpos(p,'^');
    return {lineno, col};
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x138(%rbp)
cmpq $-0x1, -0x18(%rbp)
jne 0x5544
movq -0x138(%rbp), %rax
movslq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x138(%rbp), %rdi
movq (%rdi), %rax
xorl %ecx, %ecx
movl %ecx, %esi
movl $0x5e, %edx
callq *0x28(%rax)
movq -0x138(%rbp), %rdi
movl $0x0, 0x18(%rdi)
movl $0x1, -0x128(%rbp)
leaq -0x120(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x4c70
movq -0x138(%rbp), %rax
movslq 0x18(%rax), %rax
cmpq -0x18(%rbp), %rax
jge 0x55c6
movq -0x138(%rbp), %rdi
movl -0x128(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x128(%rbp)
movl 0x18(%rdi), %eax
movl %eax, -0x124(%rbp)
leaq -0x120(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x4c70
jmp 0x5583
movq -0x138(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq -0x124(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x12c(%rbp)
movq -0x18(%rbp), %rsi
movq (%rdi), %rax
movl $0x5e, %edx
callq *0x28(%rax)
movl -0x128(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x12c(%rbp), %eax
movl %eax, -0x4(%rbp)
movq -0x8(%rbp), %rax
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
nop
// File: stevedonovan[P]outstreams/instream.cpp
// Function: stream::StrReader::read_raw_line(char*, int)
char *StrReader::read_raw_line(char *buff, int buffsize) {
    char *P = buff;
    const char *Q = pc+pos;
    int i = 1;
    while (*Q != '\n' && i < buffsize && *Q != 0) {
        *P++ = *Q++;
        ++i;
    }
    *P = 0;
    return buff;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x40(%rcx), %rax
movslq 0x18(%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movl $0x1, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0xa, %ecx
movb %al, -0x2d(%rbp)
je 0x595f
movl -0x2c(%rbp), %ecx
xorl %eax, %eax
cmpl -0x14(%rbp), %ecx
movb %al, -0x2d(%rbp)
jge 0x595f
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x2d(%rbp)
movb -0x2d(%rbp), %al
testb $0x1, %al
jne 0x5968
jmp 0x5995
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movb (%rax), %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x5931
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: stevedonovan[P]outstreams/instream.cpp
// Function: stream::StrReader::setpos(long, char)
void StrReader::setpos(long p, char end) {
    if (end == '^') {
        pos = p;
    } else
    if (end == '.') {
        pos += p;
    } else
    if (end == '$') {
        pos = size + p;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $0x5e, %eax
jne 0x59ff
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movl %ecx, 0x18(%rax)
jmp 0x5a38
movsbl -0x11(%rbp), %eax
cmpl $0x2e, %eax
jne 0x5a1c
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rdx
movslq 0x18(%rax), %rcx
addq %rdx, %rcx
movl %ecx, 0x18(%rax)
jmp 0x5a36
movsbl -0x11(%rbp), %eax
cmpl $0x24, %eax
jne 0x5a34
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rcx
addq -0x10(%rbp), %rcx
movl %ecx, 0x18(%rax)
jmp 0x5a36
jmp 0x5a38
popq %rbp
retq
nopw (%rax,%rax)
// File: stevedonovan[P]outstreams/outstream.cpp
// Function: stream::Writer::fmt(char const*, ...)
Writer& Writer::fmt(const char *fmtstr,...) {
    va_list ap;
    va_start(ap,fmtstr);
    write_out(fmtstr,ap);
    va_end(ap);
    return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x6198
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
leaq -0xe0(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x30, -0x2c(%rbp)
movl $0x10, -0x30(%rbp)
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
movq 0x8(%rax), %rax
leaq -0x30(%rbp), %rdx
callq *%rax
movq -0xe8(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
nopl (%rax)
// File: stevedonovan[P]outstreams/outstream.cpp
// Function: stream::Writer::sep_out()
void Writer::sep_out() {
    if (eoln) {
        eoln = false;
    } else {
        if (sepc != next_sepc) {
            next_sepc = sepc;
        }
        if (next_sepc) {
            write_char(next_sepc);
        }
        next_sepc = sepc;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
testb $0x1, 0x11(%rax)
je 0x6234
movq -0x10(%rbp), %rax
movb $0x0, 0x11(%rax)
jmp 0x6271
movq -0x10(%rbp), %rcx
movsbl 0x10(%rcx), %eax
movsbl 0x14(%rcx), %ecx
cmpl %ecx, %eax
je 0x624e
movq -0x10(%rbp), %rax
movb 0x10(%rax), %cl
movb %cl, 0x14(%rax)
movq -0x10(%rbp), %rax
cmpb $0x0, 0x14(%rax)
je 0x6267
movq -0x10(%rbp), %rdi
movb 0x14(%rdi), %cl
movq (%rdi), %rax
movsbl %cl, %esi
callq *(%rax)
movq -0x10(%rbp), %rax
movb 0x10(%rax), %cl
movb %cl, 0x14(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: stevedonovan[P]outstreams/outstream.cpp
// Function: stream::Writer::sep(int)
Writer& Writer::sep(int ch) {
    if (ch == -1) {
        sepc = old_sepc;
    } else {
        old_sepc = sepc;
        sepc = ch;
    }
    return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $-0x1, -0xc(%rbp)
jne 0x66f5
movq -0x18(%rbp), %rax
movb 0x13(%rax), %cl
movb %cl, 0x10(%rax)
jmp 0x6705
movq -0x18(%rbp), %rax
movb 0x10(%rax), %cl
movb %cl, 0x13(%rax)
movl -0xc(%rbp), %ecx
movb %cl, 0x10(%rax)
movq -0x18(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: stevedonovan[P]outstreams/outstream.cpp
// Function: stream::Writer::reset_sep(char)
char Writer::reset_sep(char sep) {
    char res = sepc;
    sepc = sep;
    eoln=true;
    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movb 0x10(%rax), %cl
movb %cl, -0xa(%rbp)
movb -0x9(%rbp), %cl
movb %cl, 0x10(%rax)
movb $0x1, 0x11(%rax)
movb -0xa(%rbp), %al
popq %rbp
retq
nopw (%rax,%rax)
// File: stevedonovan[P]outstreams/outstream.cpp
// Function: stream::Writer::operator()()
Writer& Writer::operator() () {
    eoln = true;
    put_eoln();
    next_sepc = 0;
    return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movb $0x1, 0x11(%rdi)
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x14(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: stevedonovan[P]outstreams/outstream.cpp
// Function: stream::Writer::setpos(long, char)
void Writer::setpos(long p, char end) {
    int whence = SEEK_SET;
    if (end == '$') {
        whence = SEEK_END;
    } else
    if (end == '.') {
        whence = SEEK_CUR;
    }
    fseek(out,p,whence);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $0x24, %eax
jne 0x6826
movl $0x2, -0x18(%rbp)
jmp 0x6838
movsbl -0x11(%rbp), %eax
cmpl $0x2e, %eax
jne 0x6836
movl $0x1, -0x18(%rbp)
jmp 0x6838
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
movl -0x18(%rbp), %edx
callq 0x3210
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: stevedonovan[P]outstreams/outstream.cpp
// Function: stream::BufWriter::write_out(char const*, __va_list_tag*)
void BufWriter::write_out(const char *fmt, va_list ap) {
    int nch = vsnprintf(P,sizeof(buf),fmt,ap);
    char *next = P + nch;
    if (next < P_end) {
        P = next;
    } else {
        out = nullptr;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl $0x80, %esi
callq 0x3120
movq -0x30(%rbp), %rcx
movl %eax, -0x1c(%rbp)
movq 0x18(%rcx), %rax
movslq -0x1c(%rbp), %rdx
addq %rdx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq 0x20(%rcx), %rax
jae 0x6ae0
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x18(%rax)
jmp 0x6aec
movq -0x30(%rbp), %rax
movq $0x0, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: wichtounet[P]articles/src/threads/part2/Unsafe.cpp
// Function: main
int main(){
    Counter counter;

    std::vector<std::thread> threads;
    for(int i = 0; i < 5; ++i){
        threads.push_back(std::thread([&counter](){
            for(int i = 0; i < 100; ++i){
                counter.increment();
            }
        }));
    }

    for(auto& thread : threads){
        thread.join();
    }

    std::cout << counter.value << std::endl;

    return 0;
}

// Assembly:
subq $0x78, %rsp
movl $0x0, 0x74(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x16f0
movl $0x0, 0x54(%rsp)
cmpl $0x5, 0x54(%rsp)
jge 0x12f8
leaq 0x70(%rsp), %rax
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x13c0
jmp 0x12a0
leaq 0x58(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x1700
jmp 0x12b1
leaq 0x48(%rsp), %rdi
callq 0x1730
movl 0x54(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x54(%rsp)
jmp 0x127e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x13a3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x1730
jmp 0x13a3
leaq 0x58(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x1750
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x1780
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x17b0
testb $0x1, %al
jne 0x1335
jmp 0x135e
leaq 0x20(%rsp), %rdi
callq 0x17f0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x10f0
jmp 0x1350
jmp 0x1352
leaq 0x20(%rsp), %rdi
callq 0x1800
jmp 0x1320
movl 0x70(%rsp), %esi
movq 0x4c6f(%rip), %rdi      # 0x5fd8
callq 0x1100
movq %rax, 0x8(%rsp)
jmp 0x1375
movq 0x8(%rsp), %rdi
movq 0x4c3f(%rip), %rsi      # 0x5fc0
callq 0x10d0
jmp 0x1388
movl $0x0, 0x74(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x1820
movl 0x74(%rsp), %eax
addq $0x78, %rsp
retq
leaq 0x58(%rsp), %rdi
callq 0x1820
movq 0x38(%rsp), %rdi
callq 0x1110
nopw (%rax,%rax)
// File: superblocks[P]superblocks/next.cpp
// Function: main
int main( int argc, char **argv ) 
{

	Superblocks s;
	s.init();	

	if( !argv[1] ) 
	{
		cout << "usage: " << argv[0];
		switch( s.seed_type[1] ) { 
			default: cout << " <input>"; break;
			case 1: cout << " <block height>"; break;
			case 2: cout << " <block hash>"; break;
		}
		cout << " [debug]" << endl;
		return 0; 
	}

	s.debug = 0;
	if( argv[2] ) { s.debug = 1; }

	int reward = s.getnextblockreward( argv[1] );

	cout << reward << endl;

	return 0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0xf0(%rbp), %rdi
movq %rdi, -0x110(%rbp)
callq 0x3160
movq -0x110(%rbp), %rdi
callq 0x4650
jmp 0x2d4a
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x2e59
movq 0x5278(%rip), %rdi      # 0x7fd8
leaq 0x2610(%rip), %rsi      # 0x5377
callq 0x2110
movq %rax, -0x118(%rbp)
jmp 0x2d75
movq -0x118(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x2110
jmp 0x2d8a
movl -0x90(%rbp), %eax
movl %eax, -0x11c(%rbp)
subl $0x1, %eax
je 0x2de4
jmp 0x2d9d
movl -0x11c(%rbp), %eax
subl $0x2, %eax
je 0x2dfb
jmp 0x2dcd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf8(%rbp)
movl %eax, -0xfc(%rbp)
leaq -0xf0(%rbp), %rdi
callq 0x3190
jmp 0x2ef9
movq 0x5204(%rip), %rdi      # 0x7fd8
leaq 0x25a4(%rip), %rsi      # 0x537f
callq 0x2110
jmp 0x2de2
jmp 0x2e12
movq 0x51ed(%rip), %rdi      # 0x7fd8
leaq 0x2596(%rip), %rsi      # 0x5388
callq 0x2110
jmp 0x2df9
jmp 0x2e12
movq 0x51d6(%rip), %rdi      # 0x7fd8
leaq 0x258f(%rip), %rsi      # 0x5398
callq 0x2110
jmp 0x2e10
jmp 0x2e12
movq 0x51bf(%rip), %rdi      # 0x7fd8
leaq 0x2586(%rip), %rsi      # 0x53a6
callq 0x2110
movq %rax, -0x128(%rbp)
jmp 0x2e2e
movq -0x128(%rbp), %rdi
movq 0x518c(%rip), %rsi      # 0x7fc8
callq 0x2130
jmp 0x2e43
movl $0x0, -0x4(%rbp)
movl $0x1, -0x100(%rbp)
jmp 0x2ee1
movl $0x0, -0xf0(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x2e78
movl $0x1, -0xf0(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
leaq -0xf0(%rbp), %rdi
callq 0x2410
movl %eax, -0x12c(%rbp)
jmp 0x2e94
movl -0x12c(%rbp), %eax
movl %eax, -0x104(%rbp)
movl -0x104(%rbp), %esi
movq 0x512b(%rip), %rdi      # 0x7fd8
callq 0x21f0
movq %rax, -0x138(%rbp)
jmp 0x2ebb
movq -0x138(%rbp), %rdi
movq 0x50ff(%rip), %rsi      # 0x7fc8
callq 0x2130
jmp 0x2ed0
movl $0x0, -0x4(%rbp)
movl $0x1, -0x100(%rbp)
leaq -0xf0(%rbp), %rdi
callq 0x3190
movl -0x4(%rbp), %eax
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
movq -0xf8(%rbp), %rdi
callq 0x2200
nopw %cs:(%rax,%rax)
nop
// File: superblocks[P]superblocks/./superblocks.hpp
// Function: Superblocks::getlucktype[abi:cxx11](int)
string getlucktype( int type ) 
	{
		switch( type ) {
			case 1: return "LUCK_WITH_LESS_THAN_X";
			case 2: return "LUCK_WITH_MORE_THAN_X";
			case 3: return "LUCK_WITH_MORE_THAN_X_AND_LESS_THAN_Y";
			default: return "error";
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x2c(%rbp)
subl $0x1, %eax
je 0x2f56
jmp 0x2f3b
movl -0x2c(%rbp), %eax
subl $0x2, %eax
je 0x2fa1
jmp 0x2f45
movl -0x2c(%rbp), %eax
subl $0x3, %eax
je 0x2fec
jmp 0x3031
leaq -0x15(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x2210
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rdx
leaq 0x243d(%rip), %rsi      # 0x53af
callq 0x31c0
jmp 0x2f79
leaq -0x15(%rbp), %rdi
callq 0x2150
jmp 0x3076
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x15(%rbp), %rdi
callq 0x2150
jmp 0x3080
leaq -0x25(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x2210
movq -0x40(%rbp), %rdi
movq -0x50(%rbp), %rdx
leaq 0x2408(%rip), %rsi      # 0x53c5
callq 0x31c0
jmp 0x2fc4
leaq -0x25(%rbp), %rdi
callq 0x2150
jmp 0x3076
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x25(%rbp), %rdi
callq 0x2150
jmp 0x3080
leaq -0x26(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x2210
movq -0x40(%rbp), %rdi
movq -0x58(%rbp), %rdx
leaq 0x23d3(%rip), %rsi      # 0x53db
callq 0x31c0
jmp 0x300f
leaq -0x26(%rbp), %rdi
callq 0x2150
jmp 0x3076
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x26(%rbp), %rdi
callq 0x2150
jmp 0x3080
leaq -0x27(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x2210
movq -0x40(%rbp), %rdi
movq -0x60(%rbp), %rdx
leaq 0x23b4(%rip), %rsi      # 0x5401
callq 0x31c0
jmp 0x3054
leaq -0x27(%rbp), %rdi
callq 0x2150
jmp 0x3076
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x27(%rbp), %rdi
callq 0x2150
jmp 0x3080
movq -0x38(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x2200
nopl (%rax)