LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: aempirei[P]Chat-Art/calibration.cc
// Function: try_code(pnm const&, unsigned int, int, int, int)
bool try_code(const pnm& snapshot, code_t code, int x0, int y, int dx) {

	const rgb_t *c[2] = { NULL, NULL };

	for(int column = 0; column < code_sz; column++) {

		size_t x = x0 + column * dx;

		if(x >= snapshot.width)
			return false;

		const rgb_t *pixel = snapshot.pixel(y, x);

		int bit = BIT_ISSET(code, column);

		if(c[bit] == NULL) {

			c[bit] = pixel;

			if(c[0] != NULL && c[1] != NULL && rgb::equals(*c[0], *c[1]))
				return false;

		} else if(!rgb::equals(*pixel, *c[bit])) { 
			return false;
		}
	}

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x2100
movl $0x0, -0x34(%rbp)
cmpl $0x20, -0x34(%rbp)
jge 0x36c6
movl -0x18(%rbp), %eax
movl -0x34(%rbp), %ecx
imull -0x20(%rbp), %ecx
addl %ecx, %eax
cltq
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jb 0x3622
movb $0x0, -0x1(%rbp)
jmp 0x36ca
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x2c90
movq %rax, -0x48(%rbp)
movl -0x14(%rbp), %eax
movl -0x34(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4c(%rbp)
movslq -0x4c(%rbp), %rax
cmpq $0x0, -0x30(%rbp,%rax,8)
jne 0x3698
movq -0x48(%rbp), %rcx
movslq -0x4c(%rbp), %rax
movq %rcx, -0x30(%rbp,%rax,8)
cmpq $0x0, -0x30(%rbp)
je 0x3696
cmpq $0x0, -0x28(%rbp)
je 0x3696
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x4d20
testb $0x1, %al
jne 0x3690
jmp 0x3696
movb $0x0, -0x1(%rbp)
jmp 0x36ca
jmp 0x36b6
movq -0x48(%rbp), %rdi
movslq -0x4c(%rbp), %rax
movq -0x30(%rbp,%rax,8), %rsi
callq 0x4d20
testb $0x1, %al
jne 0x36b4
movb $0x0, -0x1(%rbp)
jmp 0x36ca
jmp 0x36b6
jmp 0x36b8
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x35f0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: aempirei[P]Chat-Art/calibration.cc
// Function: find_code(pnm const&, int, unsigned int, int*, int*)
bool find_code(const pnm& snapshot, int y0, code_t code, pos_t pos, int *tile_width) {

	size_t max_tile_width = snapshot.width / code_sz;

	for(int dx = max_tile_width; dx > 0; dx--) {

		size_t tile_columns = snapshot.width / dx;
		size_t x_offset = snapshot.width % dx;

		for(size_t column = 0; column + code_sz - 1 < tile_columns; column++) {

			for(size_t y = y0; y < snapshot.height; y++) {

				int x0 = column * dx + x_offset;

				if(try_code(snapshot, code, x0, y, dx)) {

					while(try_code(snapshot, code, x0 - 1, y, dx))
						x0--;

					pos[0] = x0;
					pos[1] = y;

					*tile_width = dx;

					return true;
				}
			}
		}
	}

	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
shrq $0x5, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jle 0x3836
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x34(%rbp), %rcx
xorl %edx, %edx
divq %rcx
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x34(%rbp), %rcx
xorl %edx, %edx
divq %rcx
movq %rdx, -0x48(%rbp)
movq $0x0, -0x50(%rbp)
movq -0x50(%rbp), %rax
addq $0x20, %rax
subq $0x1, %rax
cmpq -0x40(%rbp), %rax
jae 0x3826
movslq -0x14(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x3813
movq -0x50(%rbp), %rax
movslq -0x34(%rbp), %rcx
imulq %rcx, %rax
addq -0x48(%rbp), %rax
movl %eax, -0x5c(%rbp)
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
movl -0x5c(%rbp), %edx
movq -0x58(%rbp), %rax
movl %eax, %ecx
movl -0x34(%rbp), %r8d
callq 0x35c0
testb $0x1, %al
jne 0x37ac
jmp 0x3800
jmp 0x37ae
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
movl -0x5c(%rbp), %edx
subl $0x1, %edx
movq -0x58(%rbp), %rax
movl %eax, %ecx
movl -0x34(%rbp), %r8d
callq 0x35c0
testb $0x1, %al
jne 0x37d0
jmp 0x37db
movl -0x5c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x5c(%rbp)
jmp 0x37ae
movl -0x5c(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x58(%rbp), %rax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movl -0x34(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x383a
jmp 0x3802
movq -0x58(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x58(%rbp)
jmp 0x3768
jmp 0x3815
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
jmp 0x374a
jmp 0x3828
movl -0x34(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x3710
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: aempirei[P]Chat-Art/calibration.cc
// Function: assign_tiles(std::vector<tile, std::allocator<tile>>&, int, geometry::mode_type, int)
void assign_tiles(tiles& ts, int line, geometry::mode_type mode, int base) {

	for(size_t column = 0; column < ts.size(); column++) {

		const auto& code = column;
		tile& t = ts[column];

		t.move(line, column);
		t.set_status(mode, code, base);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4d80
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x38da
leaq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4db0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movslq -0xc(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x2e20
movq -0x30(%rbp), %rdi
movl -0x10(%rbp), %esi
movq -0x28(%rbp), %rax
movq (%rax), %rax
movl %eax, %edx
movl -0x14(%rbp), %ecx
callq 0x2df0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x386d
addq $0x40, %rsp
popq %rbp
retq
// File: aempirei[P]Chat-Art/calibration.cc
// Function: assign_symbolic_tiles(config&, std::__cxx11::list<std::vector<tile, std::allocator<tile>>, std::allocator<std::vector<tile, std::allocator<tile>>>>)
void assign_symbolic_tiles(config& cfg, std::list<tiles> tiles_list) {

	histogram seen;

	for(auto ts : tiles_list)
		for(auto t : ts)
			if(!seen[t.geo.ratio]++)
				cfg.symbols.push_back(t);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rsi, -0x100(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x4dd0
movq -0x100(%rbp), %rsi
movq %rsi, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x4df0
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rdi
callq 0x4e20
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x4e50
testb $0x1, %al
jne 0x393e
jmp 0x3a99
leaq -0x50(%rbp), %rdi
callq 0x4e80
movq %rax, %rsi
leaq -0x70(%rbp), %rdi
callq 0x4ea0
jmp 0x3955
leaq -0x70(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rdi
callq 0x4f90
movq %rax, -0x90(%rbp)
movq -0x88(%rbp), %rdi
callq 0x4fc0
movq %rax, -0x98(%rbp)
leaq -0x90(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x4ff0
testb $0x1, %al
jne 0x39a2
jmp 0x3a82
leaq -0x90(%rbp), %rdi
callq 0x5030
movq 0x50(%rax), %rcx
movq %rcx, -0xa0(%rbp)
movups 0x40(%rax), %xmm0
movaps %xmm0, -0xb0(%rbp)
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movups 0x30(%rax), %xmm3
movaps %xmm3, -0xc0(%rbp)
movaps %xmm2, -0xd0(%rbp)
movaps %xmm1, -0xe0(%rbp)
movaps %xmm0, -0xf0(%rbp)
movb -0xd4(%rbp), %al
movb %al, -0xf1(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0xf1(%rbp), %rsi
callq 0x5050
movq %rax, -0x108(%rbp)
jmp 0x3a14
movq -0x108(%rbp), %rcx
movl (%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, (%rcx)
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x3a32
jmp 0x3a6f
movq -0x8(%rbp), %rdi
addq $0x30, %rdi
leaq -0xf0(%rbp), %rsi
callq 0x5130
jmp 0x3a48
jmp 0x3a6f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x3aab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x51c0
jmp 0x3aab
jmp 0x3a71
leaq -0x90(%rbp), %rdi
callq 0x51a0
jmp 0x3986
leaq -0x70(%rbp), %rdi
callq 0x51c0
leaq -0x50(%rbp), %rdi
callq 0x5220
jmp 0x3928
leaq -0x40(%rbp), %rdi
callq 0x5240
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
leaq -0x40(%rbp), %rdi
callq 0x5240
movq -0x78(%rbp), %rdi
callq 0x2350
nopl (%rax)
// File: aempirei[P]Chat-Art/calibration.cc
// Function: process_calibration()
void process_calibration() {

	pnm snapshot(stdin);
	config cfg;

	if(snapshot.isloaded()) {

		pos_t prefix_pos;
		pos_t suffix_pos;

		int prefix_tile_width;
		int suffix_tile_width;

		if(	find_code(snapshot, 0, prefix_code, prefix_pos, &prefix_tile_width) &&
				find_code(snapshot, prefix_pos[1] + 1, suffix_code, suffix_pos, &suffix_tile_width))
		{

			int hn = suffix_pos[1] - prefix_pos[1];

			if(	(prefix_tile_width == suffix_tile_width) &&
					(prefix_pos[0] == suffix_pos[0]) &&
					(hn % (calibration_lines - 1) == 0))
			{

				pos_t tile_sz = { prefix_tile_width, hn / (calibration_lines - 1) };

				process_tiles(cfg, snapshot, tile_sz, prefix_pos);
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq 0xaca6(%rip), %rax      # 0xefc8
movq (%rax), %rsi
leaq -0x18(%rbp), %rdi
callq 0x2ab0
leaq -0x60(%rbp), %rdi
callq 0x55f0
leaq -0x18(%rbp), %rdi
callq 0x2c20
testb $0x1, %al
jne 0x4349
jmp 0x4453
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0xa55faced, %edx       # imm = 0xA55FACED
leaq -0x68(%rbp), %rcx
leaq -0x74(%rbp), %r8
callq 0x36e0
movb %al, -0x91(%rbp)
jmp 0x4369
movb -0x91(%rbp), %al
testb $0x1, %al
jne 0x4378
jmp 0x4451
movl -0x64(%rbp), %esi
incl %esi
leaq -0x18(%rbp), %rdi
movl $0x1deadfed, %edx       # imm = 0x1DEADFED
leaq -0x70(%rbp), %rcx
leaq -0x78(%rbp), %r8
callq 0x36e0
movb %al, -0x92(%rbp)
jmp 0x439b
movb -0x92(%rbp), %al
testb $0x1, %al
jne 0x43aa
jmp 0x4451
movl -0x6c(%rbp), %eax
subl -0x64(%rbp), %eax
movl %eax, -0x88(%rbp)
movl -0x74(%rbp), %eax
cmpl -0x78(%rbp), %eax
jne 0x444f
movl -0x68(%rbp), %eax
cmpl -0x70(%rbp), %eax
jne 0x444f
movl -0x88(%rbp), %eax
movl $0x7, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x444f
movl -0x74(%rbp), %eax
movl %eax, -0x90(%rbp)
movslq -0x88(%rbp), %rax
movl %eax, %ecx
imulq $-0x6db6db6d, %rax, %rax # imm = 0x92492493
shrq $0x20, %rax
addl %ecx, %eax
movl %eax, %ecx
shrl $0x1f, %ecx
sarl $0x2, %eax
addl %ecx, %eax
movl %eax, -0x8c(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x18(%rbp), %rsi
leaq -0x90(%rbp), %rdx
leaq -0x68(%rbp), %rcx
callq 0x3be0
jmp 0x442a
jmp 0x444f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x5630
leaq -0x18(%rbp), %rdi
callq 0x2c70
jmp 0x446e
jmp 0x4451
jmp 0x4453
leaq -0x60(%rbp), %rdi
callq 0x5630
leaq -0x18(%rbp), %rdi
callq 0x2c70
addq $0xa0, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x2350
nopw (%rax,%rax)
// File: aempirei[P]Chat-Art/calibration.cc
// Function: display_code(unsigned int)
void display_code(code_t code) {
	for(int bit_n = 0; bit_n < code_sz; bit_n++) {
		std::string bgcolor = ansi::bg(BIT_ISSET(code, bit_n) ? ansi::white : ansi::black);
		std::cout << bgcolor << ' ';
	}
	std::cout << ansi::clear << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
cmpl $0x20, -0x8(%rbp)
jge 0x4509
movl -0x4(%rbp), %eax
movl -0x8(%rbp), %ecx
xorl %esi, %esi
btl %ecx, %eax
movl $0x7, %eax
cmovbl %eax, %esi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x2880
movq -0x48(%rbp), %rsi
movq 0xab0d(%rip), %rdi      # 0xefd0
callq 0x21c0
movq %rax, -0x40(%rbp)
jmp 0x44ce
movq -0x40(%rbp), %rdi
movl $0x20, %esi
callq 0x2270
jmp 0x44de
leaq -0x28(%rbp), %rdi
callq 0x23a8
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x4492
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x23a8
jmp 0x4531
movq 0xaac0(%rip), %rdi      # 0xefd0
leaq 0xad61(%rip), %rsi      # 0xf278
callq 0x21c0
movq %rax, %rdi
movq 0xaa8a(%rip), %rsi      # 0xefb0
callq 0x2220
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x2350
nopw (%rax,%rax)
// File: aempirei[P]Chat-Art/calibration.cc
// Function: help(char const*)
void help(const char *prog) {
	std::cerr << "\nusage: " << prog << " [options]\n\n";
	std::cerr << "either display the calibration pattern to save a snapshot of, or process a snapshot.\n";
	std::cerr << "after displaying the calibration in your terminal, save a snapshot of the pattern.\n"; 
	std::cerr << "this can usually be done via the PRINT SCREEN button. afterward, convert it to the\n";
	std::cerr << "PNM file format.  netpbm, djpeg or imagemagick can usually do this. finally, pipe\n";
	std::cerr << "the PNM file into this program again using the '-p' option and then redirect output\n";
	std::cerr << "to a configuration file.\n\n";
	std::cerr << "\t-d   display the calibration pattern to stdout\n";
	std::cerr << "\t-p   process calibration pattern image snapshot from stdin\n";
	std::cerr << "\t-h   show this help\n\n";
	std::cerr << "example: djpeg screenshot.jpg | " << prog << " -p > conf.d/ubuntu-mono-12.conf\n\n";
	std::cerr << "report bugs to <aempirei@256.bz>\n\n";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0xa6bd(%rip), %rdi      # 0xeff0
leaq 0x58c9(%rip), %rsi      # 0xa203
callq 0x21e0
movq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x21e0
movq %rax, %rdi
leaq 0x58b7(%rip), %rsi      # 0xa20c
callq 0x21e0
movq 0xa68f(%rip), %rdi      # 0xeff0
leaq 0x58b1(%rip), %rsi      # 0xa219
callq 0x21e0
movq 0xa67c(%rip), %rdi      # 0xeff0
leaq 0x58f4(%rip), %rsi      # 0xa26f
callq 0x21e0
movq 0xa669(%rip), %rdi      # 0xeff0
leaq 0x5935(%rip), %rsi      # 0xa2c3
callq 0x21e0
movq 0xa656(%rip), %rdi      # 0xeff0
leaq 0x5976(%rip), %rsi      # 0xa317
callq 0x21e0
movq 0xa643(%rip), %rdi      # 0xeff0
leaq 0x59b6(%rip), %rsi      # 0xa36a
callq 0x21e0
movq 0xa630(%rip), %rdi      # 0xeff0
leaq 0x59f8(%rip), %rsi      # 0xa3bf
callq 0x21e0
movq 0xa61d(%rip), %rdi      # 0xeff0
leaq 0x5a00(%rip), %rsi      # 0xa3da
callq 0x21e0
movq 0xa60a(%rip), %rdi      # 0xeff0
leaq 0x5a1e(%rip), %rsi      # 0xa40b
callq 0x21e0
movq 0xa5f7(%rip), %rdi      # 0xeff0
leaq 0x5a48(%rip), %rsi      # 0xa448
callq 0x21e0
movq 0xa5e4(%rip), %rdi      # 0xeff0
leaq 0x5a4c(%rip), %rsi      # 0xa45f
callq 0x21e0
movq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x21e0
movq %rax, %rdi
leaq 0x5a52(%rip), %rsi      # 0xa480
callq 0x21e0
movq 0xa5b6(%rip), %rdi      # 0xeff0
leaq 0x5a62(%rip), %rsi      # 0xa4a3
callq 0x21e0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: aempirei[P]Chat-Art/calibration.cc
// Function: main
int main(int argc, char **argv) {

	int display = 0;
	int process = 0;
	int opt;

	while ((opt = getopt(argc, argv, "dph")) != -1) {
		switch (opt) {
			case 'd': display = 1; break;
			case 'p': process = 1; break;
			case 'h':
			default:
				  help(basename(*argv));
				  exit(EXIT_SUCCESS);
		}
	}

	if(display == process) {
		std::cerr << '\n' << ansi::bold;
		std::cerr << "error: please provide exactly one mode of operation, either -d or -p";
		std::cerr << ansi::clear << '\n';
		help(basename(*argv));
		exit(EXIT_SUCCESS);
	}

	if(display)
		display_calibration();

	if(process)
		process_calibration();


	exit(EXIT_SUCCESS);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq 0x5a44(%rip), %rdx      # 0xa4c6
callq 0x2090
movl %eax, -0x1c(%rbp)
cmpl $-0x1, %eax
je 0x4ae1
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
subl $0x64, %eax
je 0x4ab0
jmp 0x4a9c
movl -0x20(%rbp), %eax
subl $0x68, %eax
je 0x4ac2
jmp 0x4aa6
movl -0x20(%rbp), %eax
subl $0x70, %eax
je 0x4ab9
jmp 0x4ac4
movl $0x1, -0x14(%rbp)
jmp 0x4adf
movl $0x1, -0x18(%rbp)
jmp 0x4adf
jmp 0x4ac4
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x22d0
movq %rax, %rdi
callq 0x4920
xorl %edi, %edi
callq 0x2280
jmp 0x4a74
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jne 0x4b57
movq 0xa500(%rip), %rdi      # 0xeff0
movl $0xa, %esi
callq 0x2270
movq %rax, %rdi
leaq 0xa754(%rip), %rsi      # 0xf258
callq 0x21c0
movq 0xa4e0(%rip), %rdi      # 0xeff0
leaq 0x59b3(%rip), %rsi      # 0xa4ca
callq 0x21e0
movq 0xa4cd(%rip), %rdi      # 0xeff0
leaq 0xa74e(%rip), %rsi      # 0xf278
callq 0x21c0
movq %rax, %rdi
movl $0xa, %esi
callq 0x2270
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x22d0
movq %rax, %rdi
callq 0x4920
xorl %edi, %edi
callq 0x2280
cmpl $0x0, -0x14(%rbp)
je 0x4b62
callq 0x4540
cmpl $0x0, -0x18(%rbp)
je 0x4b6d
callq 0x4310
xorl %edi, %edi
callq 0x2280
nopw %cs:(%rax,%rax)
nop
// File: Chrom3D[P]Chrom3D/src/Util.cpp
// Function: util::repeatVector(boost::numeric::ublas::vector<double, boost::numeric::ublas::unbounded_array<double, std::allocator<double>>>, unsigned int)
CoordinateMatrix repeatVector(CoordinateVector vec, uint n) {  
  CoordinateMatrix mat(n, vec.size());
  for (uint i = 0; i < n; i++) {
    mat(i,0) = vec(0);
    mat(i,1) = vec(1);
    mat(i,2) = vec(2);
  }
  return mat;
}

// Assembly:
subq $0x98, %rsp
movq %rsi, 0x48(%rsp)
movq %rdi, %rax
movq 0x48(%rsp), %rdi
movq %rax, 0x58(%rsp)
movq %rax, %rcx
movq %rcx, 0x50(%rsp)
movq %rax, 0x90(%rsp)
movq %rdi, 0x88(%rsp)
movl %edx, 0x84(%rsp)
movb $0x0, 0x83(%rsp)
movl 0x84(%rsp), %eax
movq %rax, 0x60(%rsp)
callq 0xb190
movq 0x58(%rsp), %rdi
movq 0x60(%rsp), %rsi
movq %rax, %rdx
callq 0xb1a0
movl $0x0, 0x7c(%rsp)
movl 0x7c(%rsp), %eax
cmpl 0x84(%rsp), %eax
jae 0x8ec2
movq 0x48(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xb270
movq %rax, 0x40(%rsp)
jmp 0x8dc1
movq 0x58(%rsp), %rdi
movq 0x40(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x30(%rsp)
movl 0x7c(%rsp), %eax
movl %eax, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xb2a0
movq %rax, 0x38(%rsp)
jmp 0x8deb
movq 0x48(%rsp), %rdi
movq 0x38(%rsp), %rax
movsd 0x30(%rsp), %xmm0
movsd %xmm0, (%rax)
movl $0x1, %esi
callq 0xb270
movq %rax, 0x28(%rsp)
jmp 0x8e10
movq 0x58(%rsp), %rdi
movq 0x28(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x18(%rsp)
movl 0x7c(%rsp), %eax
movl %eax, %esi
movl $0x1, %edx
callq 0xb2a0
movq %rax, 0x20(%rsp)
jmp 0x8e3b
movq 0x48(%rsp), %rdi
movq 0x20(%rsp), %rax
movsd 0x18(%rsp), %xmm0
movsd %xmm0, (%rax)
movl $0x2, %esi
callq 0xb270
movq %rax, 0x10(%rsp)
jmp 0x8e60
movq 0x58(%rsp), %rdi
movq 0x10(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, (%rsp)
movl 0x7c(%rsp), %eax
movl %eax, %esi
movl $0x2, %edx
callq 0xb2a0
movq %rax, 0x8(%rsp)
jmp 0x8e8a
movq 0x8(%rsp), %rax
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
movl 0x7c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x7c(%rsp)
jmp 0x8d9b
movq 0x58(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
callq 0xb2d0
jmp 0x8eeb
movb $0x1, 0x83(%rsp)
testb $0x1, 0x83(%rsp)
jne 0x8ede
movq 0x58(%rsp), %rdi
callq 0xb2d0
movq 0x50(%rsp), %rax
addq $0x98, %rsp
retq
movq 0x70(%rsp), %rdi
callq 0x8870
nopw %cs:(%rax,%rax)
// File: Chrom3D[P]Chrom3D/src/Util.cpp
// Function: util::coordClash(boost::numeric::ublas::vector<double, boost::numeric::ublas::unbounded_array<double, std::allocator<double>>>, boost::numeric::ublas::matrix<double, boost::numeric::ublas::basic_row_major<unsigned long, long>, boost::numeric::ublas::unbounded_array<double, std::allocator<double>>>, double, std::vector<double, std::allocator<double>>)
bool coordClash(CoordinateVector vec, CoordinateMatrix mat, double radius, vector<double> radii) {
  for(uint i=0; i!=mat.size1(); i++) {
    
    if(coordClash(vec,ublas::row(mat,i), radius, radii[i])) {
      return true;
    }
  }
  return false;
}

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq %rdi, 0xa8(%rsp)
movq %rsi, 0xa0(%rsp)
movsd %xmm0, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movl $0x0, 0x8c(%rsp)
movq 0x28(%rsp), %rdi
movl 0x8c(%rsp), %eax
movq %rax, 0x18(%rsp)
callq 0xb5e0
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
je 0x9cfc
movq 0x20(%rsp), %rsi
leaq 0x70(%rsp), %rdi
callq 0xb710
movq 0x28(%rsp), %rsi
movl 0x8c(%rsp), %eax
movl %eax, %edx
leaq 0x48(%rsp), %rdi
callq 0xbc20
jmp 0x9c12
leaq 0x58(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0xbc60
jmp 0x9c23
movq 0x30(%rsp), %rdi
movsd 0x98(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movl 0x8c(%rsp), %eax
movl %eax, %esi
callq 0xbd40
movsd 0x8(%rsp), %xmm0
movsd (%rax), %xmm1
leaq 0x70(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x9aa0
movb %al, 0x17(%rsp)
jmp 0x9c64
leaq 0x58(%rsp), %rdi
callq 0xb5b0
leaq 0x48(%rsp), %rdi
callq 0xbd60
leaq 0x70(%rsp), %rdi
callq 0xb5b0
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x9c8c
jmp 0x9ce4
movb $0x1, 0xb7(%rsp)
jmp 0x9d04
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0x9cd8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0x9cce
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0xb5b0
leaq 0x48(%rsp), %rdi
callq 0xbd60
leaq 0x70(%rsp), %rdi
callq 0xb5b0
jmp 0x9d15
jmp 0x9ce6
movl 0x8c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8c(%rsp)
jmp 0x9bc2
movb $0x0, 0xb7(%rsp)
movb 0xb7(%rsp), %al
andb $0x1, %al
addq $0xb8, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x8870
nop
// File: Chrom3D[P]Chrom3D/src/Util.cpp
// Function: util::split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, 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>>>>&)
std::vector<std::string> &split(const std::string &s, char delim, std::vector<std::string> &elems) {
    std::stringstream ss(s);
    std::string item;
    while (std::getline(ss, item, delim)) {
        elems.push_back(item);
    }
    return elems;
}

// Assembly:
subq $0x1f8, %rsp            # imm = 0x1F8
movb %sil, %al
movq %rdi, 0x1f0(%rsp)
movb %al, 0x1ef(%rsp)
movq %rdx, 0x1e0(%rsp)
movq 0x1f0(%rsp), %rax
movq %rax, 0x20(%rsp)
movl $0x10, %edi
movl $0x8, %esi
callq 0xc4d0
movq 0x20(%rsp), %rsi
movl %eax, %edx
leaq 0x58(%rsp), %rdi
callq 0x8750
leaq 0x38(%rsp), %rdi
callq 0x8670
movsbl 0x1ef(%rsp), %edx
leaq 0x58(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x88e0
movq %rax, 0x18(%rsp)
jmp 0xaa56
movq 0x18(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x85e0
movb %al, 0x17(%rsp)
jmp 0xaa70
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0xaa7a
jmp 0xaab4
movq 0x1e0(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0xc4f0
jmp 0xaa8e
jmp 0xaa38
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x8998
leaq 0x58(%rsp), %rdi
callq 0x83c0
jmp 0xaae2
movq 0x1e0(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x8998
leaq 0x58(%rsp), %rdi
callq 0x83c0
movq 0x8(%rsp), %rax
addq $0x1f8, %rsp            # imm = 0x1F8
retq
movq 0x30(%rsp), %rdi
callq 0x8870
nopl (%rax)
// File: Chrom3D[P]Chrom3D/src/Util.cpp
// Function: util::splitDbl(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char, std::vector<double, std::allocator<double>>&)
std::vector<double> &splitDbl(const std::string &s, char delim, std::vector<double> &elems) {
    std::stringstream ss(s);
    std::string item;

    while (std::getline(ss, item, delim)) {
        elems.push_back(atof(item.c_str()));
    }
    return elems;
}

// Assembly:
subq $0x208, %rsp            # imm = 0x208
movb %sil, %al
movq %rdi, 0x200(%rsp)
movb %al, 0x1ff(%rsp)
movq %rdx, 0x1f0(%rsp)
movq 0x200(%rsp), %rax
movq %rax, 0x28(%rsp)
movl $0x10, %edi
movl $0x8, %esi
callq 0xc4d0
movq 0x28(%rsp), %rsi
movl %eax, %edx
leaq 0x68(%rsp), %rdi
callq 0x8750
leaq 0x48(%rsp), %rdi
callq 0x8670
movsbl 0x1ff(%rsp), %edx
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x88e0
movq %rax, 0x20(%rsp)
jmp 0xabf6
movq 0x20(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x85e0
movb %al, 0x1f(%rsp)
jmp 0xac10
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0xac1a
jmp 0xac76
movq 0x1f0(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x8220
movq %rax, %rdi
callq 0x85d0
movq 0x10(%rsp), %rdi
movsd %xmm0, 0x30(%rsp)
leaq 0x30(%rsp), %rsi
callq 0xc5d0
jmp 0xac50
jmp 0xabd8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x8998
leaq 0x68(%rsp), %rdi
callq 0x83c0
jmp 0xaca4
movq 0x1f0(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x8998
leaq 0x68(%rsp), %rdi
callq 0x83c0
movq 0x8(%rsp), %rax
addq $0x208, %rsp            # imm = 0x208
retq
movq 0x40(%rsp), %rdi
callq 0x8870
nop
// File: Chrom3D[P]Chrom3D/src/Util.cpp
// Function: util::makeMap(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>>>>, 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>>>>)
std::map<std::string, std::string> makeMap(std::vector<std::string> vec1, std::vector<std::string> vec2) { // Make a template function here!
  //assert(vec1.size() == vec2.size());
  if(vec1.size() != vec2.size())
  {
    throw std::runtime_error("Header is missing in the GTrack file");
  }
  std::map<string,string> res;
  for(uint i=0; i != vec1.size(); i++) {
    res[vec1[i]] = vec2[i];
  }
  return res;
}

// Assembly:
subq $0x78, %rsp
movq %rdx, 0x38(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdi, %rax
movq 0x20(%rsp), %rdi
movq %rax, 0x28(%rsp)
movq %rax, %rcx
movq %rcx, 0x30(%rsp)
movq %rax, 0x70(%rsp)
movq %rdi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
callq 0xc610
movq 0x38(%rsp), %rdi
movq %rax, 0x40(%rsp)
callq 0xc610
movq %rax, %rcx
movq 0x40(%rsp), %rax
cmpq %rcx, %rax
je 0xadeb
movl $0x10, %edi
callq 0x8280
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x18(%rsp)
leaq 0x44323(%rip), %rsi     # 0x4f0d2
callq 0x8200
jmp 0xadb6
movq 0x18(%rsp), %rdi
movq 0x5f22e(%rip), %rsi     # 0x69ff0
movq 0x5f1af(%rip), %rdx     # 0x69f78
callq 0x8820
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
callq 0x83a0
jmp 0xaeb3
movq 0x28(%rsp), %rdi
movb $0x0, 0x53(%rsp)
callq 0xc630
movl $0x0, 0x4c(%rsp)
movq 0x20(%rsp), %rdi
movl 0x4c(%rsp), %eax
movq %rax, 0x10(%rsp)
callq 0xc610
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
je 0xae93
movq 0x38(%rsp), %rdi
movl 0x4c(%rsp), %eax
movl %eax, %esi
callq 0xc640
movq 0x20(%rsp), %rdi
movq %rax, (%rsp)
movl 0x4c(%rsp), %eax
movl %eax, %esi
callq 0xc640
movq 0x28(%rsp), %rdi
movq %rax, %rsi
callq 0xc660
movq %rax, 0x8(%rsp)
jmp 0xae5a
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
callq 0x8060
jmp 0xae6a
jmp 0xae6c
movl 0x4c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
jmp 0xae02
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
callq 0xc750
jmp 0xaeb3
movb $0x1, 0x53(%rsp)
testb $0x1, 0x53(%rsp)
jne 0xaea9
movq 0x28(%rsp), %rdi
callq 0xc750
movq 0x30(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x58(%rsp), %rdi
callq 0x8870
nopl (%rax)
// File: Chrom3D[P]Chrom3D/src/Util.cpp
// Function: util::errorLine(unsigned int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string errorLine(uint line_counter, std::string filename)
{
  std::ostringstream oss;
  oss << "Error in the line #" << boost::lexical_cast<std::string>(line_counter) << " of the GTrack file " << filename << endl;
  std::string error_line = oss.str();
  return error_line;	
}

// Assembly:
subq $0x208, %rsp            # imm = 0x208
movq %rdx, 0x18(%rsp)
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0x200(%rsp)
movl %esi, 0x1fc(%rsp)
movq %rdx, 0x1f0(%rsp)
leaq 0x78(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x8640
movq 0x30(%rsp), %rdi
leaq 0x441ec(%rip), %rsi     # 0x4f0f7
callq 0x8480
movq %rax, 0x38(%rsp)
jmp 0xaf17
leaq 0x48(%rsp), %rdi
leaq 0x1fc(%rsp), %rsi
callq 0xc760
jmp 0xaf2b
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x8450
movq %rax, 0x10(%rsp)
jmp 0xaf41
movq 0x10(%rsp), %rdi
leaq 0x441be(%rip), %rsi     # 0x4f10b
callq 0x8480
movq %rax, 0x8(%rsp)
jmp 0xaf59
movq 0x18(%rsp), %rsi
movq 0x8(%rsp), %rdi
callq 0x8450
movq %rax, (%rsp)
jmp 0xaf6e
movq (%rsp), %rdi
movq 0x5efb7(%rip), %rsi     # 0x69f30
callq 0x84e0
jmp 0xaf80
leaq 0x48(%rsp), %rdi
callq 0x8998
movq 0x20(%rsp), %rdi
movb $0x0, 0x47(%rsp)
leaq 0x78(%rsp), %rsi
callq 0x84b0
jmp 0xafa0
movb $0x1, 0x47(%rsp)
testb $0x1, 0x47(%rsp)
jne 0xafe2
jmp 0xafd8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
jmp 0xaff9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x8998
jmp 0xaff9
movq 0x20(%rsp), %rdi
callq 0x8998
leaq 0x78(%rsp), %rdi
callq 0x8130
movq 0x28(%rsp), %rax
addq $0x208, %rsp            # imm = 0x208
retq
leaq 0x78(%rsp), %rdi
callq 0x8130
movq 0x70(%rsp), %rdi
callq 0x8870
nopl (%rax)
// File: Chrom3D[P]Chrom3D/src/Bead.cpp
// Function: Bead::Bead()
Bead::Bead() {
  start = 0;
  end = 0;
  radius  = 0;
  id = "NA";
  genomicPos = 0;
  hasCoord = false;
  color[0] = 0;
  color[1] = 0;
  color[2] = 0;  
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
addq $0x38, %rdi
movq %rdi, 0x8(%rsp)
callq 0x8670
movq (%rsp), %rax
movq 0x8(%rsp), %rdi
movl $0x0, 0x30(%rax)
movl $0x0, 0x34(%rax)
movq $0x0, 0x28(%rax)
leaq 0x3ab2e(%rip), %rsi     # 0x4f794
callq 0x8660
jmp 0x14c6d
movq (%rsp), %rax
movl $0x0, 0x5c(%rax)
movb $0x0, 0x58(%rax)
xorps %xmm0, %xmm0
movss %xmm0, (%rax)
xorps %xmm0, %xmm0
movss %xmm0, 0x4(%rax)
xorps %xmm0, %xmm0
movss %xmm0, 0x8(%rax)
addq $0x28, %rsp
retq
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
callq 0x8998
movq 0x18(%rsp), %rdi
callq 0x8870
nopw (%rax,%rax)
// File: Chrom3D[P]Chrom3D/src/Bead.cpp
// Function: Bead::Bead(int, int, double, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Bead::Bead(int startPosition, int endPosition, double beadRadius, std::string beadId) {
  assert(startPosition < endPosition);
  
  start = startPosition;
  end = endPosition;  
  radius = beadRadius;
  id = beadId;

  genomicPos = int((start + end)/2);
  hasCoord = false;

  color[0] = 1;
  color[1] = 1;
  color[2] = 0;
  
}

// Assembly:
subq $0x48, %rsp
movq %rcx, (%rsp)
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movl %edx, 0x38(%rsp)
movsd %xmm0, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x38, %rdi
movq %rdi, 0x10(%rsp)
callq 0x8670
movl 0x3c(%rsp), %eax
cmpl 0x38(%rsp), %eax
jge 0x14d04
jmp 0x14d23
leaq 0x3aa8c(%rip), %rdi     # 0x4f797
leaq 0x3aaa1(%rip), %rsi     # 0x4f7b3
movl $0x13, %edx
leaq 0x3aaa2(%rip), %rcx     # 0x4f7c0
callq 0x8340
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
movl 0x3c(%rsp), %eax
movl %eax, 0x30(%rdi)
movl 0x38(%rsp), %eax
movl %eax, 0x34(%rdi)
movsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x28(%rdi)
addq $0x38, %rdi
callq 0x8060
jmp 0x14d50
movq 0x8(%rsp), %rcx
movl 0x30(%rcx), %eax
addl 0x34(%rcx), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x5c(%rax)
movb $0x0, 0x58(%rax)
movss 0x3aa17(%rip), %xmm0    # 0x4f790
movss %xmm0, (%rax)
movss 0x3aa0b(%rip), %xmm0    # 0x4f790
movss %xmm0, 0x4(%rax)
xorps %xmm0, %xmm0
movss %xmm0, 0x8(%rax)
addq $0x48, %rsp
retq
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x8998
movq 0x20(%rsp), %rdi
callq 0x8870
nopl (%rax)
// File: Chrom3D[P]Chrom3D/src/Bead.cpp
// Function: Bead::setCoordinates(double, double, double)
void Bead::setCoordinates(double xCoord, double yCoord, double zCoord) {
  x = xCoord;
  y = yCoord;
  z = zCoord;
  hasCoord = true;  
}

// Assembly:
movq %rdi, -0x8(%rsp)
movsd %xmm0, -0x10(%rsp)
movsd %xmm1, -0x18(%rsp)
movsd %xmm2, -0x20(%rsp)
movq -0x8(%rsp), %rax
movsd -0x10(%rsp), %xmm0
movsd %xmm0, 0x10(%rax)
movsd -0x18(%rsp), %xmm0
movsd %xmm0, 0x18(%rax)
movsd -0x20(%rsp), %xmm0
movsd %xmm0, 0x20(%rax)
movb $0x1, 0x58(%rax)
retq
nopw %cs:(%rax,%rax)
// File: Chrom3D[P]Chrom3D/src/Chromosome.cpp
// Function: Chromosome::addBead(Bead)
void Chromosome::addBead(Bead bead) {
  assert(bead.hasCoordinates());
  boost::container::static_vector<Bead,MAXSIZE>::iterator pos;
  pos = lower_bound(beadList.begin(), beadList.end(), bead);
  assert(pos == beadList.end() or bead < *pos); // Bead must not be found allready on the chr
  beadList.insert(pos, bead);  
}

// Assembly:
subq $0x78, %rsp
movq %rsi, 0x18(%rsp)
movq %rdi, %rax
movq 0x18(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movq %rax, 0x70(%rsp)
movq %rdi, 0x68(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x28(%rsp)
callq 0x14e90
testb $0x1, %al
jne 0x15335
jmp 0x15337
jmp 0x15356
leaq 0x3a4ac(%rip), %rdi     # 0x4f7ea
leaq 0x3a4bb(%rip), %rsi     # 0x4f800
movl $0x1b, %edx
leaq 0x3a4c2(%rip), %rcx     # 0x4f813
callq 0x8340
leaq 0x60(%rsp), %rdi
callq 0x16890
movq 0x28(%rsp), %rsi
addq $0x28, %rsi
leaq 0x50(%rsp), %rdi
callq 0x16930
movq 0x28(%rsp), %rsi
addq $0x28, %rsi
leaq 0x48(%rsp), %rdi
callq 0x16970
movq 0x20(%rsp), %rcx
leaq 0x58(%rsp), %rdi
leaq 0x50(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0x168b0
leaq 0x60(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x16a00
movq 0x28(%rsp), %rsi
addq $0x28, %rsi
leaq 0x40(%rsp), %rdi
callq 0x16970
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x16a40
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0x17(%rsp)
jne 0x153f8
leaq 0x60(%rsp), %rdi
callq 0x16a60
movq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0x14fe0
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x15402
jmp 0x15404
jmp 0x15423
leaq 0x3a427(%rip), %rdi     # 0x4f832
leaq 0x3a3ee(%rip), %rsi     # 0x4f800
movl $0x1e, %edx
leaq 0x3a3f5(%rip), %rcx     # 0x4f813
callq 0x8340
movq 0x28(%rsp), %rax
addq $0x28, %rax
movq %rax, 0x8(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x16b00
movq 0x8(%rsp), %rsi
movq 0x20(%rsp), %rcx
leaq 0x30(%rsp), %rdi
leaq 0x38(%rsp), %rdx
callq 0x16ac0
addq $0x78, %rsp
retq
nop
// File: Chrom3D[P]Chrom3D/src/Chromosome.cpp
// Function: Chromosome::setColor(double, double, double)
void Chromosome::setColor(double r, double g, double b) {
  assert(r >= 0 and r <= 1);
  assert(g >= 0 and g <= 1);
  assert(b >= 0 and b <= 1);
  for(boost::container::static_vector<Bead,MAXSIZE>::iterator it = beadList.begin(); it != beadList.end(); it++) {
    it->setColor(r, g, b);
  }
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movsd %xmm0, 0x48(%rsp)
movsd %xmm1, 0x40(%rsp)
movsd %xmm2, 0x38(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movsd 0x48(%rsp), %xmm0
xorl %eax, %eax
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movb %al, 0x1f(%rsp)
jb 0x15a5f
movsd 0x395b6(%rip), %xmm0    # 0x4f008
ucomisd 0x48(%rsp), %xmm0
setae %al
movb %al, 0x1f(%rsp)
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0x15a69
jmp 0x15a6b
jmp 0x15a8a
leaq 0x39e4d(%rip), %rdi     # 0x4f8bf
leaq 0x39d87(%rip), %rsi     # 0x4f800
movl $0x56, %edx
leaq 0x39e4c(%rip), %rcx     # 0x4f8d1
callq 0x8340
movsd 0x40(%rsp), %xmm0
xorl %eax, %eax
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movb %al, 0xf(%rsp)
jb 0x15ab4
movsd 0x39561(%rip), %xmm0    # 0x4f008
ucomisd 0x40(%rsp), %xmm0
setae %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x15abe
jmp 0x15ac0
jmp 0x15adf
leaq 0x39e3c(%rip), %rdi     # 0x4f903
leaq 0x39d32(%rip), %rsi     # 0x4f800
movl $0x57, %edx
leaq 0x39df7(%rip), %rcx     # 0x4f8d1
callq 0x8340
movsd 0x38(%rsp), %xmm0
xorl %eax, %eax
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movb %al, 0xe(%rsp)
jb 0x15b09
movsd 0x3950c(%rip), %xmm0    # 0x4f008
ucomisd 0x38(%rsp), %xmm0
setae %al
movb %al, 0xe(%rsp)
movb 0xe(%rsp), %al
testb $0x1, %al
jne 0x15b13
jmp 0x15b15
jmp 0x15b34
leaq 0x39df9(%rip), %rdi     # 0x4f915
leaq 0x39cdd(%rip), %rsi     # 0x4f800
movl $0x58, %edx
leaq 0x39da2(%rip), %rcx     # 0x4f8d1
callq 0x8340
movq 0x10(%rsp), %rsi
addq $0x28, %rsi
leaq 0x30(%rsp), %rdi
callq 0x16930
movq 0x10(%rsp), %rsi
addq $0x28, %rsi
leaq 0x28(%rsp), %rdi
callq 0x16970
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x16b40
testb $0x1, %al
jne 0x15b6f
jmp 0x15bb2
leaq 0x30(%rsp), %rdi
callq 0x16ca0
movq %rax, %rdi
movsd 0x48(%rsp), %xmm0
cvtsd2ss %xmm0, %xmm0
movsd 0x40(%rsp), %xmm1
cvtsd2ss %xmm1, %xmm1
movsd 0x38(%rsp), %xmm2
cvtsd2ss %xmm2, %xmm2
callq 0x14ed0
leaq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rsi
xorl %edx, %edx
callq 0x16b60
jmp 0x15b47
addq $0x58, %rsp
retq
nopw (%rax,%rax)
// File: Chrom3D[P]Chrom3D/src/Chromosome.cpp
// Function: Chromosome::crankshaft(unsigned int, unsigned int, double)
CoordinateMatrix Chromosome::crankshaft(uint startPos, uint endPos, double theta) {
  // Add asserts here!
  CoordinateVector startPoint = this->getBeadCoordinates(startPos);
  CoordinateVector endPoint = this->getBeadCoordinates(endPos);
  CoordinateMatrix mat = this->getBeadCoordinates(startPos+1, endPos-1);
  CoordinateMatrix rotated = util::rotatePointsAroundArbitraryAxis(theta, startPoint, endPoint, mat);
  return rotated;
}

// Assembly:
subq $0x108, %rsp            # imm = 0x108
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x100(%rsp)
movq %rsi, 0xf8(%rsp)
movl %edx, 0xf4(%rsp)
movl %ecx, 0xf0(%rsp)
movsd %xmm0, 0xe8(%rsp)
movq 0xf8(%rsp), %rsi
movq %rsi, 0x18(%rsp)
movl 0xf4(%rsp), %edx
leaq 0xd0(%rsp), %rdi
callq 0x15880
movq 0x18(%rsp), %rsi
movl 0xf0(%rsp), %edx
leaq 0xb8(%rsp), %rdi
callq 0x15880
jmp 0x15c37
movq 0x18(%rsp), %rsi
movl 0xf4(%rsp), %edx
incl %edx
movl 0xf0(%rsp), %ecx
decl %ecx
leaq 0x80(%rsp), %rdi
callq 0x155a0
jmp 0x15c5d
movb $0x0, 0x7f(%rsp)
movsd 0xe8(%rsp), %xmm0
movsd %xmm0, (%rsp)
leaq 0x60(%rsp), %rdi
leaq 0xd0(%rsp), %rsi
callq 0xb710
jmp 0x15c84
leaq 0x48(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
callq 0xb710
jmp 0x15c98
leaq 0x20(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0xc450
jmp 0x15cac
movsd (%rsp), %xmm0
movq 0x8(%rsp), %rdi
leaq 0x60(%rsp), %rsi
leaq 0x48(%rsp), %rdx
leaq 0x20(%rsp), %rcx
callq 0x8fa0
jmp 0x15ccc
leaq 0x20(%rsp), %rdi
callq 0xb2d0
leaq 0x48(%rsp), %rdi
callq 0xb5b0
leaq 0x60(%rsp), %rdi
callq 0xb5b0
movb $0x1, 0x7f(%rsp)
testb $0x1, 0x7f(%rsp)
jne 0x15db4
jmp 0x15daa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
jmp 0x15e02
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
jmp 0x15df5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
jmp 0x15de8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
jmp 0x15d9e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
jmp 0x15d94
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
leaq 0x20(%rsp), %rdi
callq 0xb2d0
leaq 0x48(%rsp), %rdi
callq 0xb5b0
leaq 0x60(%rsp), %rdi
callq 0xb5b0
jmp 0x15de8
movq 0x8(%rsp), %rdi
callq 0xb2d0
leaq 0x80(%rsp), %rdi
callq 0xb2d0
leaq 0xb8(%rsp), %rdi
callq 0xb5b0
leaq 0xd0(%rsp), %rdi
callq 0xb5b0
movq 0x10(%rsp), %rax
addq $0x108, %rsp            # imm = 0x108
retq
leaq 0x80(%rsp), %rdi
callq 0xb2d0
leaq 0xb8(%rsp), %rdi
callq 0xb5b0
leaq 0xd0(%rsp), %rdi
callq 0xb5b0
movq 0xb0(%rsp), %rdi
callq 0x8870
nopl (%rax)
// File: Chrom3D[P]Chrom3D/src/Chromosome.cpp
// Function: Chromosome::rotation(unsigned int, unsigned int, double)
CoordinateMatrix Chromosome::rotation(uint startPos, uint endPos, double theta) {
  // Add asserts here!
  CoordinateVector startPoint = this->getBeadCoordinates(startPos);
  CoordinateVector endPoint = this->getBeadCoordinates(endPos);
  CoordinateMatrix mat = this->getBeadCoordinates(0, this->size()-1); // Full matrix is rotated
  CoordinateMatrix rotated = util::rotatePointsAroundArbitraryAxis(theta, startPoint, endPoint, mat);
  return rotated;
}

// Assembly:
subq $0x108, %rsp            # imm = 0x108
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x100(%rsp)
movq %rsi, 0xf8(%rsp)
movl %edx, 0xf4(%rsp)
movl %ecx, 0xf0(%rsp)
movsd %xmm0, 0xe8(%rsp)
movq 0xf8(%rsp), %rsi
movq %rsi, 0x18(%rsp)
movl 0xf4(%rsp), %edx
leaq 0xd0(%rsp), %rdi
callq 0x15880
movq 0x18(%rsp), %rsi
movl 0xf0(%rsp), %edx
leaq 0xb8(%rsp), %rdi
callq 0x15880
jmp 0x15e97
movq 0x18(%rsp), %rdi
callq 0x154f0
movq 0x18(%rsp), %rsi
movl %eax, %ecx
decl %ecx
leaq 0x80(%rsp), %rdi
xorl %edx, %edx
callq 0x155a0
jmp 0x15ebb
movb $0x0, 0x7f(%rsp)
movsd 0xe8(%rsp), %xmm0
movsd %xmm0, (%rsp)
leaq 0x60(%rsp), %rdi
leaq 0xd0(%rsp), %rsi
callq 0xb710
jmp 0x15ee2
leaq 0x48(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
callq 0xb710
jmp 0x15ef6
leaq 0x20(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0xc450
jmp 0x15f0a
movsd (%rsp), %xmm0
movq 0x8(%rsp), %rdi
leaq 0x60(%rsp), %rsi
leaq 0x48(%rsp), %rdx
leaq 0x20(%rsp), %rcx
callq 0x8fa0
jmp 0x15f2a
leaq 0x20(%rsp), %rdi
callq 0xb2d0
leaq 0x48(%rsp), %rdi
callq 0xb5b0
leaq 0x60(%rsp), %rdi
callq 0xb5b0
movb $0x1, 0x7f(%rsp)
testb $0x1, 0x7f(%rsp)
jne 0x16012
jmp 0x16008
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
jmp 0x16060
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
jmp 0x16053
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
jmp 0x16046
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
jmp 0x15ffc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
jmp 0x15ff2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
leaq 0x20(%rsp), %rdi
callq 0xb2d0
leaq 0x48(%rsp), %rdi
callq 0xb5b0
leaq 0x60(%rsp), %rdi
callq 0xb5b0
jmp 0x16046
movq 0x8(%rsp), %rdi
callq 0xb2d0
leaq 0x80(%rsp), %rdi
callq 0xb2d0
leaq 0xb8(%rsp), %rdi
callq 0xb5b0
leaq 0xd0(%rsp), %rdi
callq 0xb5b0
movq 0x10(%rsp), %rax
addq $0x108, %rsp            # imm = 0x108
retq
leaq 0x80(%rsp), %rdi
callq 0xb2d0
leaq 0xb8(%rsp), %rdi
callq 0xb5b0
leaq 0xd0(%rsp), %rdi
callq 0xb5b0
movq 0xb0(%rsp), %rdi
callq 0x8870
nopw (%rax,%rax)
// File: Chrom3D[P]Chrom3D/src/Randomizer.cpp
// Function: CrankShaftRandomizer::randomize(Chromosome&, boost::random::mersenne_twister_engine<unsigned int, 32ul, 624ul, 397ul, 31ul, 2567483615u, 11ul, 4294967295u, 7ul, 2636928640u, 15ul, 4022730752u, 18ul, 1812433253u>&)
Move CrankShaftRandomizer::randomize(Chromosome &chr, ENG &eng) {
  uint r1 = util::unif_int(0, chr.size()-3, eng);
  uint r2 = util::unif_int(r1+2, chr.size()-1, eng);
  double theta = util::unif_real(0.0, 2*util::PI-0.001, eng);
  CoordinateMatrix mat = chr.crankshaft(r1,r2,theta);
  Move mov(chr);
  mov.start = r1+1; // We return the positions of the start and end of the 
  mov.stop = r2-1;  //  beads that have their coords altered (so, r1 and r2 are not included in crankshaft)
  mov.mat = mat;
  return mov;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, (%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
movq 0x70(%rsp), %rdi
callq 0x154f0
movl %eax, %esi
addl $-0x3, %esi
movq 0x68(%rsp), %rdx
xorl %edi, %edi
callq 0x9980
movl %eax, 0x64(%rsp)
movl 0x64(%rsp), %eax
addl $0x2, %eax
movl %eax, 0xc(%rsp)
movq 0x70(%rsp), %rdi
callq 0x154f0
movl 0xc(%rsp), %edi
movl %eax, %esi
decl %esi
movq 0x68(%rsp), %rdx
callq 0x9980
movl %eax, 0x60(%rsp)
movq 0x68(%rsp), %rdi
xorps %xmm0, %xmm0
movsd 0x36d6c(%rip), %xmm1    # 0x50390
callq 0x9940
movsd %xmm0, 0x58(%rsp)
movq 0x70(%rsp), %rsi
movl 0x64(%rsp), %edx
movl 0x60(%rsp), %ecx
movsd 0x58(%rsp), %xmm0
leaq 0x30(%rsp), %rdi
callq 0x15bc0
movq 0x10(%rsp), %rdi
movb $0x0, 0x2f(%rsp)
movq 0x70(%rsp), %rsi
callq 0x192f0
jmp 0x19662
movq 0x10(%rsp), %rdi
movl 0x64(%rsp), %eax
incl %eax
movl %eax, 0x8(%rdi)
movl 0x60(%rsp), %eax
decl %eax
movl %eax, 0xc(%rdi)
addq $0x10, %rdi
leaq 0x30(%rsp), %rsi
callq 0x17400
jmp 0x19689
movb $0x1, 0x2f(%rsp)
testb $0x1, 0x2f(%rsp)
jne 0x196cb
jmp 0x196c1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x196e1
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x1a560
jmp 0x196e1
movq 0x10(%rsp), %rdi
callq 0x1a560
leaq 0x30(%rsp), %rdi
callq 0xb2d0
movq (%rsp), %rax
addq $0x88, %rsp
retq
leaq 0x30(%rsp), %rdi
callq 0xb2d0
movq 0x20(%rsp), %rdi
callq 0x8870
nopw %cs:(%rax,%rax)
// File: Chrom3D[P]Chrom3D/src/Randomizer.cpp
// Function: ArmRotateRandomizer::randomize(Chromosome&, boost::random::mersenne_twister_engine<unsigned int, 32ul, 624ul, 397ul, 31ul, 2567483615u, 11ul, 4294967295u, 7ul, 2636928640u, 15ul, 4022730752u, 18ul, 1812433253u>&)
Move ArmRotateRandomizer::randomize(Chromosome &chr, ENG &eng) {
  uint r1 = util::unif_int(1, chr.size()-2, eng);
  bool goRight = util::unif_int(0, 1, eng);
  double theta = util::unif_real(0.0, 2*util::PI-0.001, eng);
  
  CoordinateMatrix mat = chr.armRotate(r1, theta, goRight);
  Move mov(chr);
  if(goRight){
    mov.start = r1+1;
    mov.stop = chr.size()-1;
  } 
  else {
    mov.start = 0;
    mov.stop = r1-1;
  }
  mov.mat = mat;
  return mov;
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movq %rcx, 0x78(%rsp)
movq 0x80(%rsp), %rdi
callq 0x154f0
movl %eax, %esi
addl $-0x2, %esi
movq 0x78(%rsp), %rdx
movl $0x1, %edi
movl %edi, 0x1c(%rsp)
callq 0x9980
movl 0x1c(%rsp), %esi
movl %eax, 0x74(%rsp)
movq 0x78(%rsp), %rdx
xorl %edi, %edi
callq 0x9980
testl %eax, %eax
setne 0x73(%rsp)
movq 0x78(%rsp), %rdi
xorps %xmm0, %xmm0
movsd 0x362ef(%rip), %xmm1    # 0x50390
callq 0x9940
movsd %xmm0, 0x68(%rsp)
movq 0x80(%rsp), %rsi
movl 0x74(%rsp), %edx
movsd 0x68(%rsp), %xmm0
movzbl 0x73(%rsp), %ecx
andl $0x1, %ecx
leaq 0x40(%rsp), %rdi
callq 0x16080
movq 0x20(%rsp), %rdi
movb $0x0, 0x3f(%rsp)
movq 0x80(%rsp), %rsi
callq 0x192f0
jmp 0x1a0e9
testb $0x1, 0x73(%rsp)
je 0x1a14c
movq 0x20(%rsp), %rax
movl 0x74(%rsp), %ecx
incl %ecx
movl %ecx, 0x8(%rax)
movq 0x80(%rsp), %rdi
callq 0x154f0
movl %eax, 0xc(%rsp)
jmp 0x1a111
movq 0x20(%rsp), %rax
movl 0xc(%rsp), %ecx
subl $0x1, %ecx
movl %ecx, 0xc(%rax)
jmp 0x1a162
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x1a1a4
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0x1a560
jmp 0x1a1a4
movq 0x20(%rsp), %rax
movl $0x0, 0x8(%rax)
movl 0x74(%rsp), %ecx
subl $0x1, %ecx
movl %ecx, 0xc(%rax)
movq 0x20(%rsp), %rdi
addq $0x10, %rdi
leaq 0x40(%rsp), %rsi
callq 0x17400
jmp 0x1a177
movb $0x1, 0x3f(%rsp)
testb $0x1, 0x3f(%rsp)
jne 0x1a18d
movq 0x20(%rsp), %rdi
callq 0x1a560
leaq 0x40(%rsp), %rdi
callq 0xb2d0
movq 0x10(%rsp), %rax
addq $0x98, %rsp
retq
leaq 0x40(%rsp), %rdi
callq 0xb2d0
movq 0x30(%rsp), %rdi
callq 0x8870
nopl (%rax,%rax)