LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
subq $0x80, %rsp
movq 0x472f(%rip), %rax      # 0x7fc8
movq (%rax), %rsi
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x280a
xorps %xmm0, %xmm0
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movq $0x0, 0x70(%rsp)
cmpq $0x0, 0x10(%rbx)
je 0x3991
cmpq $0x0, 0x10(%rsp)
je 0x3991
cmpq $0x0, 0x18(%rsp)
je 0x3991
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rcx
leaq 0x4(%rsp), %r8
xorl %esi, %esi
movl $0xa55faced, %edx       # imm = 0xA55FACED
callq 0x2f0c
testb %al, %al
je 0x3991
movl 0xc(%rsp), %ebx
leal 0x1(%rbx), %esi
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rcx
movq %rsp, %r8
movl $0x1deadfed, %edx       # imm = 0x1DEADFED
callq 0x2f0c
testb %al, %al
je 0x3991
movl 0x4(%rsp), %eax
cmpl (%rsp), %eax
jne 0x3991
movl 0x8(%rsp), %ecx
cmpl 0x28(%rsp), %ecx
jne 0x3991
movl 0x2c(%rsp), %ecx
subl %ebx, %ecx
movslq %ecx, %rdx
imulq $-0x6db6db6d, %rdx, %rcx # imm = 0x92492493
shrq $0x20, %rcx
addl %edx, %ecx
movl %ecx, %esi
shrl $0x1f, %esi
sarl $0x2, %ecx
addl %esi, %ecx
leal (,%rcx,8), %esi
movl %ecx, %edi
subl %esi, %edi
addl %edx, %edi
jne 0x3991
leaq 0x78(%rsp), %rdx
movl %eax, (%rdx)
movl %ecx, 0x4(%rdx)
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rcx
callq 0x32b8
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x39a8
movq 0x70(%rsp), %rsi
subq %rdi, %rsi
callq 0x21d0
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x39bf
movq 0x58(%rsp), %rsi
subq %rdi, %rsi
callq 0x21d0
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x39d6
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x21d0
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x39ee
callq 0x2220
movq $0x0, 0x20(%rsp)
addq $0x80, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x431a
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x3a1c
callq 0x2220
movq $0x0, 0x20(%rsp)
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edi, %ebx
xorl %ebp, %ebp
movl $0x28, %r13d
leaq 0x8(%rsp), %r14
movq 0x4588(%rip), %r15      # 0x7fd0
leaq 0x7(%rsp), %r12
btl %ebp, %ebx
movl $0x2f, %esi
cmovael %r13d, %esi
movq %r14, %rdi
movl $0x6d, %edx
callq 0x250c
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r15, %rdi
callq 0x21f0
movb $0x20, 0x7(%rsp)
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x21f0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x3aa9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21d0
incl %ebp
cmpl $0x20, %ebp
jne 0x3a4d
movq 0x4791(%rip), %rsi      # 0x8248
movq 0x4792(%rip), %rdx      # 0x8250
movq 0x450b(%rip), %rdi      # 0x7fd0
callq 0x21f0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2100
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x3b22
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21d0
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x40bc(%rip), %r14      # 0x7ff0
leaq 0x12b9(%rip), %rsi      # 0x51f4
movl $0x8, %edx
movq %r14, %rdi
callq 0x21f0
testq %rbx, %rbx
je 0x3f69
movq %rbx, %rdi
callq 0x20e0
movq 0x4094(%rip), %rdi      # 0x7ff0
movq %rbx, %rsi
movq %rax, %rdx
callq 0x21f0
jmp 0x3f81
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x22e0
movq 0x4068(%rip), %r14      # 0x7ff0
leaq 0x126e(%rip), %rsi      # 0x51fd
movl $0xc, %edx
movq %r14, %rdi
callq 0x21f0
leaq 0x1267(%rip), %rsi      # 0x520a
movl $0x55, %edx
movq %r14, %rdi
callq 0x21f0
leaq 0x12a9(%rip), %rsi      # 0x5260
movl $0x53, %edx
movq %r14, %rdi
callq 0x21f0
leaq 0x12e9(%rip), %rsi      # 0x52b4
movl $0x53, %edx
movq %r14, %rdi
callq 0x21f0
leaq 0x1329(%rip), %rsi      # 0x5308
movl $0x52, %edx
movq %r14, %rdi
callq 0x21f0
leaq 0x1368(%rip), %rsi      # 0x535b
movl $0x54, %edx
movq %r14, %rdi
callq 0x21f0
leaq 0x13a9(%rip), %rsi      # 0x53b0
movl $0x1a, %edx
movq %r14, %rdi
callq 0x21f0
leaq 0x13b0(%rip), %rsi      # 0x53cb
movl $0x30, %edx
movq %r14, %rdi
callq 0x21f0
leaq 0x13cd(%rip), %rsi      # 0x53fc
movl $0x3c, %edx
movq %r14, %rdi
callq 0x21f0
leaq 0x13f6(%rip), %rsi      # 0x5439
movl $0x16, %edx
movq %r14, %rdi
callq 0x21f0
leaq 0x13f9(%rip), %rsi      # 0x5450
movl $0x20, %edx
movq %r14, %rdi
callq 0x21f0
testq %rbx, %rbx
je 0x4085
movq %rbx, %rdi
callq 0x20e0
movq 0x3f78(%rip), %rdi      # 0x7ff0
movq %rbx, %rsi
movq %rax, %rdx
callq 0x21f0
jmp 0x409d
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x22e0
movq 0x3f4c(%rip), %rbx      # 0x7ff0
leaq 0x13c6(%rip), %rsi      # 0x5471
movl $0x22, %edx
movq %rbx, %rdi
callq 0x21f0
leaq 0x13d5(%rip), %rsi      # 0x5494
movl $0x22, %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x21f0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
xorl %r12d, %r12d
movb $0x1, %r15b
leaq 0x13c7(%rip), %r14      # 0x54b7
xorl %r13d, %r13d
movl %r13d, %ecx
movl %ecx, %r13d
movl %ebp, %edi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2090
movl $0x1, %ecx
cmpl $0x64, %eax
je 0x40f6
cmpl $0x70, %eax
jne 0x4120
movl $0x1, %r12d
xorl %r15d, %r15d
jmp 0x40f3
cmpl $-0x1, %eax
jne 0x4178
cmpl %r12d, %r13d
jne 0x418f
movq 0x3ebf(%rip), %r14      # 0x7ff0
movq %r14, %rdi
movl $0xa, %esi
callq 0x2200
leaq 0x40e3(%rip), %rsi      # 0x8228
movq %rax, %rdi
callq 0x2190
leaq 0x1367(%rip), %rsi      # 0x54bb
movq %r14, %rdi
callq 0x21b0
leaq 0x40e5(%rip), %rsi      # 0x8248
movq %r14, %rdi
callq 0x2190
movq %rax, %rdi
movl $0xa, %esi
callq 0x2200
movq (%rbx), %rdi
callq 0x2250
movq %rax, %rdi
callq 0x3f26
xorl %edi, %edi
callq 0x2210
testl %r13d, %r13d
je 0x4199
callq 0x3b2a
testb $0x1, %r15b
jne 0x4188
callq 0x388a
jmp 0x4188
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movl %edx, %r15d
movq 0x8(%rsi), %rdx
movq %r15, %rsi
callq 0x8326
testl %ebp, %ebp
je 0x6c2a
leaq 0x10(%rbx), %r12
xorl %r13d, %r13d
movq %r14, %rdi
xorl %esi, %esi
callq 0x901a
movsd (%rax), %xmm0
movsd %xmm0, (%rsp)
movq (%rbx), %rsi
movq 0x8(%rbx), %rcx
movq %r13, %rdi
xorl %edx, %edx
callq 0x915c
movq %r12, %rdi
movq %rax, %rsi
callq 0x901a
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
movl $0x1, %esi
movq %r14, %rdi
callq 0x901a
movsd (%rax), %xmm0
movsd %xmm0, (%rsp)
movq (%rbx), %rsi
movq 0x8(%rbx), %rcx
movl $0x1, %edx
movq %r13, %rdi
callq 0x915c
movq %r12, %rdi
movq %rax, %rsi
callq 0x901a
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
movl $0x2, %esi
movq %r14, %rdi
callq 0x901a
movsd (%rax), %xmm0
movsd %xmm0, (%rsp)
movq (%rbx), %rsi
movq 0x8(%rbx), %rcx
movl $0x2, %edx
movq %r13, %rdi
callq 0x915c
movq %r12, %rdi
movq %rax, %rsi
callq 0x901a
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
incq %r13
cmpq %r13, %r15
jne 0x6b6a
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x18(%rbx), %rsi
testq %rsi, %rsi
je 0x6c55
movq 0x20(%rbx), %rdi
shlq $0x3, %rsi
callq 0x6310
movq %r14, %rdi
callq 0x65b0
// File: /workspace/github_cpp_makefile_star2_O1/Chrom3D[P]Chrom3D/src/Util.cpp
// Function: util::coordClash(double, double, double, double, double, double, double, double)
bool coordClash(double x1, double y1, double z1, double x2, double y2, double z2, double radius1, double radius2) {
  /*cout.precision(16);
  cout << "Is " <<  (pow(x1-x2,2) + pow(y1-y2,2) + pow(z1-z2,2)) << " < " << pow(radius1+radius2,2) << endl;
  cout << ((pow(x1-x2,2) + pow(y1-y2,2) + pow(z1-z2,2)) < pow(radius1+radius2,2))  << endl;*/
  return (pow(x1-x2,2) + pow(y1-y2,2) + pow(z1-z2,2)) < pow(radius1+radius2,2)-PRECISIONCONST;
}

// Assembly:
unpcklpd %xmm2, %xmm0            # xmm0 = xmm0[0],xmm2[0]
unpcklpd %xmm5, %xmm3            # xmm3 = xmm3[0],xmm5[0]
subpd %xmm3, %xmm0
subsd %xmm4, %xmm1
mulpd %xmm0, %xmm0
addsd %xmm7, %xmm6
unpcklpd %xmm6, %xmm1            # xmm1 = xmm1[0],xmm6[0]
mulpd %xmm1, %xmm1
movapd %xmm0, %xmm2
movhpd 0x21ce4(%rip), %xmm2    # xmm2 = xmm2[0],mem[0]
addpd %xmm1, %xmm2
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm2, %xmm0
unpckhpd %xmm2, %xmm2            # xmm2 = xmm2[1,1]
ucomisd %xmm0, %xmm2
seta %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, 0x8(%rsp)
movsd %xmm0, (%rsp)
movq %rdi, 0x10(%rsp)
cmpq $0x0, (%rsi)
setne %bpl
je 0x74fc
movq %rsi, %r14
movl $0x1, %r15d
xorl %ebx, %ebx
leaq 0x30(%rsp), %r12
leaq 0x18(%rsp), %r13
movq %r12, %rdi
movq 0x10(%rsp), %rsi
callq 0x94b0
movq %r14, 0x48(%rsp)
movq %rbx, 0x50(%rsp)
movq %r13, %rdi
leaq 0x48(%rsp), %rsi
callq 0x859e
movq 0x8(%rsp), %rax
movq (%rax), %rax
movsd (%rax,%rbx,8), %xmm1
movq %r12, %rdi
movq %r13, %rsi
movsd (%rsp), %xmm0
callq 0x7344
movl %eax, %ebx
movq 0x20(%rsp), %rsi
testq %rsi, %rsi
je 0x74cd
movq 0x28(%rsp), %rdi
shlq $0x3, %rsi
callq 0x6310
movq 0x38(%rsp), %rsi
testq %rsi, %rsi
je 0x74e5
movq 0x40(%rsp), %rdi
shlq $0x3, %rsi
callq 0x6310
testb %bl, %bl
jne 0x74fc
movl %r15d, %ebx
incl %r15d
cmpq %rbx, (%r14)
setne %bpl
jne 0x7472
andb $0x1, %bpl
movl %ebp, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x7531
movq %rax, %rbx
movq 0x20(%rsp), %rsi
testq %rsi, %rsi
je 0x7531
movq 0x28(%rsp), %rdi
shlq $0x3, %rsi
callq 0x6310
movq 0x38(%rsp), %rsi
testq %rsi, %rsi
je 0x7549
movq 0x40(%rsp), %rdi
shlq $0x3, %rsi
callq 0x6310
movq %rbx, %rdi
callq 0x65b0
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %rsi
leaq 0x28(%rsp), %r14
movq %r14, %rdi
movl $0x18, %edx
callq 0x64c0
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
movsbl %bpl, %ebp
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x6600
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x7e46
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8860
jmp 0x7e1e
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x7e5d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6310
movq 0x300ac(%rip), %rsi     # 0x37f10
leaq 0x28(%rsp), %rdi
callq 0x6290
leaq 0xa8(%rsp), %rdi
callq 0x6120
movq %rbx, %rax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x7ea8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6310
movq 0x30061(%rip), %rsi     # 0x37f10
leaq 0x28(%rsp), %rdi
callq 0x6290
leaq 0xa8(%rsp), %rdi
callq 0x6120
movq %rbx, %rdi
callq 0x65b0
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %rsi
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movl $0x18, %edx
callq 0x64c0
leaq 0x20(%rsp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
movsbl %bpl, %ebp
leaq 0x10(%rsp), %r15
leaq 0x8(%rsp), %r12
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x6600
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x7fad
movq 0x10(%rsp), %rdi
callq 0x63c0
movsd %xmm0, 0x8(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x7fa0
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x7f5d
movq %rbx, %rdi
movq %r12, %rdx
callq 0xa62a
jmp 0x7f5d
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x7fc4
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x6310
movq 0x2ff45(%rip), %rsi     # 0x37f10
leaq 0x30(%rsp), %rdi
callq 0x6290
leaq 0xb0(%rsp), %rdi
callq 0x6120
movq %rbx, %rax
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7ff9
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x8013
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x6310
movq 0x2fef6(%rip), %rsi     # 0x37f10
leaq 0x30(%rsp), %rdi
callq 0x6290
leaq 0xb0(%rsp), %rdi
callq 0x6120
movq %rbx, %rdi
callq 0x65b0
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x68(%rsp), %r15
movq %r15, %rdi
callq 0x63e0
leaq 0x20f82(%rip), %rsi     # 0x29127
movl $0x13, %edx
movq %r15, %rdi
callq 0x6370
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
leaq 0x2a(%rsp), %rax
movq %rax, 0x16(%rax)
leaq 0x3e(%rsp), %r15
movq %r15, 0xa(%r15)
leaq 0x50(%rsp), %rdi
movl %ebp, (%rdi)
movq %r15, 0x8(%rdi)
movb $0x30, 0x10(%rdi)
movl $0x30, 0x14(%rdi)
callq 0xaacc
movq %rax, 0x40(%rsp)
movq %r15, 0x48(%rsp)
leaq 0x8(%rsp), %rdi
movq 0x8(%rdi), %rdx
subq %rax, %r15
xorl %esi, %esi
movq %rax, %rcx
movq %r15, %r8
callq 0x6350
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0x68(%rsp), %rdi
callq 0x6370
movq %rax, %r15
leaq 0x20f03(%rip), %rsi     # 0x2913b
movl $0x14, %edx
movq %rax, %rdi
callq 0x6370
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r15, %rdi
callq 0x6370
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x62f0
movsbl %al, %esi
movq %r14, %rdi
callq 0x6030
movq %rax, %rdi
callq 0x6240
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x8295
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6310
leaq 0x70(%rsp), %rsi
movq %rbx, %rdi
callq 0x64b0
movq 0x2fcc7(%rip), %rsi     # 0x37f70
leaq 0x68(%rsp), %rdi
callq 0x61c0
leaq 0xd8(%rsp), %rdi
callq 0x6120
movq %rbx, %rax
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x82f4
jmp 0x82da
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x82f4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6310
movq 0x2fc75(%rip), %rsi     # 0x37f70
leaq 0x68(%rsp), %rdi
callq 0x61c0
leaq 0xd8(%rsp), %rdi
callq 0x6120
movq %rbx, %rdi
callq 0x65b0
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x38(%rdi), %r14
leaq 0x48(%rdi), %r15
movq %r15, 0x38(%rdi)
movq $0x0, 0x40(%rdi)
movb $0x0, 0x48(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rdi)
leaq 0x1e8e3(%rip), %rcx     # 0x295d0
xorl %r12d, %r12d
movl $0x2, %r8d
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x6480
movl %r12d, 0x5c(%rbx)
movb $0x0, 0x58(%rbx)
movq $0x0, (%rbx)
movl %r12d, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%r14), %rdi
cmpq %r15, %rdi
je 0xad37
movq (%r15), %rsi
incq %rsi
callq 0x6310
movq %rbx, %rdi
callq 0x65b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
movsd %xmm0, 0x10(%rdi)
movsd %xmm1, 0x18(%rdi)
movsd %xmm2, 0x20(%rdi)
movb $0x1, 0x58(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq %rsi, %rdi
callq 0xae20
testb %al, %al
je 0xb100
leaq 0x28(%r15), %r14
movq 0x75328(%r15), %rax
leaq (%rax,%rax,2), %rax
shlq $0x5, %rax
addq %r15, %rax
addq $0x28, %rax
leaq 0x8(%rsp), %rsi
movq %r14, (%rsi)
leaq 0x20(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x18(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rcx
callq 0xc605
movq (%r12), %r12
movq 0x75328(%r15), %rax
leaq (%rax,%rax,2), %rax
shlq $0x5, %rax
addq %r15, %rax
addq $0x28, %rax
cmpq %rax, %r12
je 0xb0dc
testq %r12, %r12
je 0xb11f
movq %rbx, %rdi
movq %r12, %rsi
callq 0xaeb9
testb %al, %al
je 0xb13e
leaq 0x10(%rsp), %rdx
movq %r12, (%rdx)
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rcx
callq 0xc728
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x1e539(%rip), %rdi     # 0x29640
leaq 0x1e548(%rip), %rsi     # 0x29656
leaq 0x1e554(%rip), %rcx     # 0x29669
movl $0x1b, %edx
callq 0x6210
leaq 0x1e6dd(%rip), %rdi     # 0x29803
leaq 0x1e6de(%rip), %rsi     # 0x2980b
leaq 0x1e80e(%rip), %rcx     # 0x29942
movl $0x8e, %edx
callq 0x6210
leaq 0x1e543(%rip), %rdi     # 0x29688
leaq 0x1e50a(%rip), %rsi     # 0x29656
leaq 0x1e516(%rip), %rcx     # 0x29669
movl $0x1e, %edx
callq 0x6210
nop
// File: /workspace/github_cpp_makefile_star2_O1/Chrom3D[P]Chrom3D/src/Chromosome.cpp
// Function: Chromosome::getBeadCoordinates(unsigned int, unsigned int)
CoordinateMatrix Chromosome::getBeadCoordinates(uint startPos, uint endPos) {
  assert(startPos <= endPos);
  assert(endPos < beadList.size());
  CoordinateMatrix mat((endPos-startPos)+1,3);
  uint i=0;
  for(boost::container::static_vector<Bead,MAXSIZE>::iterator it = beadList.begin() + startPos; it != beadList.begin() + endPos+1; it++) {
    mat(i,0) = it->getX();
    mat(i,1) = it->getY();
    mat(i,2) = it->getZ();
    i++;
  }
  return mat;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movl %ecx, %esi
subl %edx, %esi
jb 0xb376
movl %ecx, %r12d
cmpq %r12, 0x75328(%r15)
jbe 0xb395
movl %edx, %ebp
movq %rdi, %rbx
incl %esi
movl $0x3, %edx
callq 0x8326
movl %ebp, %eax
leaq (%rax,%rax,2), %rcx
shlq $0x5, %rcx
leaq (%r15,%rcx), %r14
addq $0x28, %r14
leaq (%r12,%r12,2), %rcx
shlq $0x5, %rcx
addq %r15, %rcx
addq $0x88, %rcx
cmpq %rcx, %r14
je 0xb364
leaq 0x10(%rbx), %r15
shlq $0x5, %r12
leaq (%r12,%r12,2), %r13
shlq $0x5, %rax
leaq (%rax,%rax,2), %rax
subq %rax, %r13
addq $0x60, %r13
xorl %ebp, %ebp
movq %r14, %rdi
callq 0xae00
movsd %xmm0, (%rsp)
movl %ebp, %r12d
movq (%rbx), %rsi
movq 0x8(%rbx), %rcx
movq %r12, %rdi
xorl %edx, %edx
callq 0x915c
movq %r15, %rdi
movq %rax, %rsi
callq 0x901a
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
movq %r14, %rdi
callq 0xae06
movsd %xmm0, (%rsp)
movq (%rbx), %rsi
movq 0x8(%rbx), %rcx
movl $0x1, %edx
movq %r12, %rdi
callq 0x915c
movq %r15, %rdi
movq %rax, %rsi
callq 0x901a
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
movq %r14, %rdi
callq 0xae0c
movsd %xmm0, (%rsp)
movq (%rbx), %rsi
movq 0x8(%rbx), %rcx
movl $0x2, %edx
movq %r12, %rdi
callq 0x915c
movq %r15, %rdi
movq %rax, %rsi
callq 0x901a
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
incl %ebp
addq $0x60, %r14
addq $-0x60, %r13
jne 0xb2b5
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1e330(%rip), %rdi     # 0x296ad
leaq 0x1e2d2(%rip), %rsi     # 0x29656
leaq 0x1e335(%rip), %rcx     # 0x296c0
movl $0x3b, %edx
callq 0x6210
leaq 0x1e360(%rip), %rdi     # 0x296fc
leaq 0x1e2b3(%rip), %rsi     # 0x29656
leaq 0x1e316(%rip), %rcx     # 0x296c0
movl $0x3c, %edx
callq 0x6210
movq %rax, %r14
movq 0x18(%rbx), %rsi
testq %rsi, %rsi
je 0xb3cd
movq 0x20(%rbx), %rdi
shlq $0x3, %rsi
callq 0x6310
movq %r14, %rdi
callq 0x65b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
xorpd %xmm3, %xmm3
ucomisd %xmm3, %xmm0
jb 0xb59a
movsd 0x1db1b(%rip), %xmm3    # 0x29008
ucomisd %xmm0, %xmm3
jb 0xb59a
xorpd %xmm4, %xmm4
ucomisd %xmm4, %xmm1
jb 0xb5b9
ucomisd %xmm1, %xmm3
jb 0xb5b9
ucomisd %xmm4, %xmm2
jb 0xb5d8
ucomisd %xmm2, %xmm3
jb 0xb5d8
movq %rdi, %rbx
cmpq $0x0, 0x75328(%rdi)
je 0xb590
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
movss %xmm0, 0x8(%rsp)
leaq 0x28(%rbx), %r15
xorps %xmm0, %xmm0
cvtsd2ss %xmm2, %xmm0
movss %xmm0, 0x4(%rsp)
movq %r15, %r14
movq %r14, %rdi
movss 0xc(%rsp), %xmm0
movss 0x8(%rsp), %xmm1
movss 0x4(%rsp), %xmm2
callq 0xae48
addq $0x60, %r14
movq 0x75328(%rbx), %rax
leaq (%rax,%rax,2), %rax
shlq $0x5, %rax
addq %r15, %rax
cmpq %rax, %r14
jne 0xb55b
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1e174(%rip), %rdi     # 0x29715
leaq 0x1e0ae(%rip), %rsi     # 0x29656
leaq 0x1e178(%rip), %rcx     # 0x29727
movl $0x56, %edx
callq 0x6210
leaq 0x1e199(%rip), %rdi     # 0x29759
leaq 0x1e08f(%rip), %rsi     # 0x29656
leaq 0x1e159(%rip), %rcx     # 0x29727
movl $0x57, %edx
callq 0x6210
leaq 0x1e18c(%rip), %rdi     # 0x2976b
leaq 0x1e070(%rip), %rsi     # 0x29656
leaq 0x1e13a(%rip), %rcx     # 0x29727
movl $0x58, %edx
callq 0x6210
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xc8, %rsp
movsd %xmm0, 0x8(%rsp)
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x58(%rsp), %rdi
callq 0xb3d6
leaq 0x40(%rsp), %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0xb3d6
incl %r14d
decl %ebp
leaq 0xa0(%rsp), %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
callq 0xb232
leaq 0x28(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x94b0
leaq 0x10(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x94b0
leaq 0xb0(%rsp), %rsi
movaps -0x10(%rsi), %xmm0
leaq 0x80(%rsp), %rdi
movaps %xmm0, -0x10(%rdi)
callq 0x94b0
leaq 0x28(%rsp), %rsi
leaq 0x10(%rsp), %rdx
leaq 0x70(%rsp), %rcx
movq %rbx, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x6ca6
movq 0x88(%rsp), %rsi
testq %rsi, %rsi
je 0xb6bf
movq 0x90(%rsp), %rdi
shlq $0x3, %rsi
callq 0x6310
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0xb6d7
movq 0x20(%rsp), %rdi
shlq $0x3, %rsi
callq 0x6310
movq 0x30(%rsp), %rsi
testq %rsi, %rsi
je 0xb6ef
movq 0x38(%rsp), %rdi
shlq $0x3, %rsi
callq 0x6310
movq 0xb8(%rsp), %rsi
testq %rsi, %rsi
je 0xb70d
movq 0xc0(%rsp), %rdi
shlq $0x3, %rsi
callq 0x6310
movq 0x48(%rsp), %rsi
testq %rsi, %rsi
je 0xb725
movq 0x50(%rsp), %rdi
shlq $0x3, %rsi
callq 0x6310
movq 0x60(%rsp), %rsi
testq %rsi, %rsi
je 0xb73d
movq 0x68(%rsp), %rdi
shlq $0x3, %rsi
callq 0x6310
movq %rbx, %rax
addq $0xc8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x88(%rsp), %rsi
testq %rsi, %rsi
je 0xb774
movq 0x90(%rsp), %rdi
shlq $0x3, %rsi
callq 0x6310
jmp 0xb774
movq %rax, %rbx
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0xb791
movq 0x20(%rsp), %rdi
shlq $0x3, %rsi
callq 0x6310
jmp 0xb791
movq %rax, %rbx
movq 0x30(%rsp), %rsi
testq %rsi, %rsi
je 0xb7ae
movq 0x38(%rsp), %rdi
shlq $0x3, %rsi
callq 0x6310
jmp 0xb7ae
movq %rax, %rbx
movq 0xb8(%rsp), %rsi
testq %rsi, %rsi
je 0xb7d1
movq 0xc0(%rsp), %rdi
shlq $0x3, %rsi
callq 0x6310
jmp 0xb7d1
movq %rax, %rbx
movq 0x48(%rsp), %rsi
testq %rsi, %rsi
je 0xb7ee
movq 0x50(%rsp), %rdi
shlq $0x3, %rsi
callq 0x6310
jmp 0xb7ee
movq %rax, %rbx
movq 0x60(%rsp), %rsi
testq %rsi, %rsi
je 0xb806
movq 0x68(%rsp), %rdi
shlq $0x3, %rsi
callq 0x6310
movq %rbx, %rdi
callq 0x65b0
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movsd %xmm0, 0x8(%rsp)
movl %ecx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x58(%rsp), %rdi
callq 0xb3d6
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0xb3d6
movl 0x75328(%r14), %ecx
decl %ecx
leaq 0xa0(%rsp), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xb232
leaq 0x28(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x94b0
leaq 0x10(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x94b0
leaq 0xb0(%rsp), %rsi
movaps -0x10(%rsi), %xmm0
leaq 0x80(%rsp), %rdi
movaps %xmm0, -0x10(%rdi)
callq 0x94b0
leaq 0x28(%rsp), %rsi
leaq 0x10(%rsp), %rdx
leaq 0x70(%rsp), %rcx
movq %rbx, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x6ca6
movq 0x88(%rsp), %rsi
testq %rsi, %rsi
je 0xb8d1
movq 0x90(%rsp), %rdi
shlq $0x3, %rsi
callq 0x6310
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0xb8e9
movq 0x20(%rsp), %rdi
shlq $0x3, %rsi
callq 0x6310
movq 0x30(%rsp), %rsi
testq %rsi, %rsi
je 0xb901
movq 0x38(%rsp), %rdi
shlq $0x3, %rsi
callq 0x6310
movq 0xb8(%rsp), %rsi
testq %rsi, %rsi
je 0xb91f
movq 0xc0(%rsp), %rdi
shlq $0x3, %rsi
callq 0x6310
movq 0x48(%rsp), %rsi
testq %rsi, %rsi
je 0xb937
movq 0x50(%rsp), %rdi
shlq $0x3, %rsi
callq 0x6310
movq 0x60(%rsp), %rsi
testq %rsi, %rsi
je 0xb94f
movq 0x68(%rsp), %rdi
shlq $0x3, %rsi
callq 0x6310
movq %rbx, %rax
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq 0x88(%rsp), %rsi
testq %rsi, %rsi
je 0xb984
movq 0x90(%rsp), %rdi
shlq $0x3, %rsi
callq 0x6310
jmp 0xb984
movq %rax, %rbx
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0xb9a1
movq 0x20(%rsp), %rdi
shlq $0x3, %rsi
callq 0x6310
jmp 0xb9a1
movq %rax, %rbx
movq 0x30(%rsp), %rsi
testq %rsi, %rsi
je 0xb9be
movq 0x38(%rsp), %rdi
shlq $0x3, %rsi
callq 0x6310
jmp 0xb9be
movq %rax, %rbx
movq 0xb8(%rsp), %rsi
testq %rsi, %rsi
je 0xb9e1
movq 0xc0(%rsp), %rdi
shlq $0x3, %rsi
callq 0x6310
jmp 0xb9e1
movq %rax, %rbx
movq 0x48(%rsp), %rsi
testq %rsi, %rsi
je 0xb9fe
movq 0x50(%rsp), %rdi
shlq $0x3, %rsi
callq 0x6310
jmp 0xb9fe
movq %rax, %rbx
movq 0x60(%rsp), %rsi
testq %rsi, %rsi
je 0xba16
movq 0x68(%rsp), %rdi
shlq $0x3, %rsi
callq 0x6310
movq %rbx, %rdi
callq 0x65b0
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rcx, %r12
movq %rdx, %r14
movq %rdi, %rbx
movq %rdx, %rdi
callq 0xb1dc
leal -0x3(%rax), %esi
xorl %edi, %edi
movq %r12, %rdx
callq 0x72ce
movl %eax, %r15d
leal 0x2(%r15), %ebp
movq %r14, %rdi
callq 0xb1dc
leal -0x1(%rax), %esi
movl %ebp, %edi
movq %r12, %rdx
callq 0x72ce
movl %eax, %ebp
movsd 0x1d072(%rip), %xmm1    # 0x2a058
xorps %xmm0, %xmm0
movq %r12, %rdi
callq 0x72a4
movq %rsp, %r12
movq %r12, %rdi
movq %r14, %rsi
movl %r15d, %edx
movl %ebp, %ecx
callq 0xb5f8
movq %r14, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx)
movups %xmm0, 0x10(%rbx)
incl %r15d
movl %r15d, 0x8(%rbx)
decl %ebp
movl %ebp, 0xc(%rbx)
movaps (%r12), %xmm0
movups %xmm0, 0x10(%rbx)
leaq 0x10(%rsp), %rax
leaq 0x20(%rbx), %rdi
cmpq %rax, %rdi
je 0xd064
leaq 0x28(%rbx), %r15
movq 0x18(%rsp), %rsi
xorps %xmm0, %xmm0
xorl %edx, %edx
callq 0xcc46
movq 0x18(%rsp), %rdx
testq %rdx, %rdx
je 0xd064
movq 0x20(%rsp), %rsi
shlq $0x3, %rdx
movq 0x30(%rbx), %rdi
callq 0x64e0
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0xd07c
movq 0x20(%rsp), %rdi
shlq $0x3, %rsi
callq 0x6310
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%r15), %rsi
testq %rsi, %rsi
je 0xd0a4
movq 0x30(%rbx), %rdi
shlq $0x3, %rsi
callq 0x6310
movq %rsp, %rdi
callq 0x66c3
movq %r14, %rdi
callq 0x65b0
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r15
movq %rdx, %r14
movq %rdi, %rbx
movq %rdx, %rdi
callq 0xb1dc
leal -0x2(%rax), %esi
movl $0x1, %edi
movq %r15, %rdx
callq 0x72ce
movl %eax, %ebp
xorl %edi, %edi
movl $0x1, %esi
movq %r15, %rdx
callq 0x72ce
movl %eax, %r12d
xorl %r13d, %r13d
testl %eax, %eax
setne %r13b
movsd 0x1c8a4(%rip), %xmm1    # 0x2a058
xorps %xmm0, %xmm0
movq %r15, %rdi
callq 0x72a4
movq %rsp, %rdi
movq %r14, %rsi
movl %ebp, %edx
movl %r13d, %ecx
callq 0xba1e
leaq 0x28(%rbx), %r15
movq %r14, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx)
movups %xmm0, 0x10(%rbx)
testl %r12d, %r12d
je 0xd7f7
incl %ebp
movl %ebp, 0x8(%rbx)
movq %r14, %rdi
callq 0xb1dc
movl %eax, %ebp
jmp 0xd7fe
movl $0x0, 0x8(%rbx)
decl %ebp
movl %ebp, 0xc(%rbx)
leaq 0x10(%rsp), %rax
movaps -0x10(%rax), %xmm0
movups %xmm0, 0x10(%rbx)
leaq 0x20(%rbx), %rdi
cmpq %rax, %rdi
je 0xd844
movq 0x18(%rsp), %rsi
xorps %xmm0, %xmm0
xorl %edx, %edx
callq 0xcc46
movq 0x18(%rsp), %rdx
testq %rdx, %rdx
je 0xd844
movq 0x20(%rsp), %rsi
shlq $0x3, %rdx
movq 0x30(%rbx), %rdi
callq 0x64e0
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0xd85c
movq 0x20(%rsp), %rdi
shlq $0x3, %rsi
callq 0x6310
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%r15), %rsi
testq %rsi, %rsi
je 0xd886
movq 0x30(%rbx), %rdi
shlq $0x3, %rsi
callq 0x6310
movq %rsp, %rdi
callq 0x66df
movq %r14, %rdi
callq 0x65b0
// File: /workspace/github_cpp_makefile_star2_O1/Chrom3D[P]Chrom3D/src/Randomizer.cpp
// Function: MicroCrankShaftRandomizer::randomize(Chromosome&, boost::random::mersenne_twister_engine<unsigned int, 32ul, 624ul, 397ul, 31ul, 2567483615u, 11ul, 4294967295u, 7ul, 2636928640u, 15ul, 4022730752u, 18ul, 1812433253u>&)
Move MicroCrankShaftRandomizer::randomize(Chromosome &chr, ENG &eng) {
  uint r1 = util::unif_int(0, chr.size()-3, eng);
  uint r2 = r1+2;
  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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rcx, %r15
movq %rdx, %r14
movq %rdi, %rbx
movq %rdx, %rdi
callq 0xb1dc
leal -0x3(%rax), %esi
xorl %edi, %edi
movq %r15, %rdx
callq 0x72ce
movl %eax, %r12d
leal 0x2(%r12), %ebp
movsd 0x1c788(%rip), %xmm1    # 0x2a058
xorps %xmm0, %xmm0
movq %r15, %rdi
callq 0x72a4
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
movl %r12d, %edx
movl %ebp, %ecx
callq 0xb5f8
movq %r14, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx)
movups %xmm0, 0x10(%rbx)
incl %r12d
movl %r12d, 0x8(%rbx)
movl %r12d, 0xc(%rbx)
movaps (%r15), %xmm0
movups %xmm0, 0x10(%rbx)
leaq 0x10(%rsp), %rax
leaq 0x20(%rbx), %rdi
cmpq %rax, %rdi
je 0xd94c
leaq 0x28(%rbx), %r15
movq 0x18(%rsp), %rsi
xorps %xmm0, %xmm0
xorl %edx, %edx
callq 0xcc46
movq 0x18(%rsp), %rdx
testq %rdx, %rdx
je 0xd94c
movq 0x20(%rsp), %rsi
shlq $0x3, %rdx
movq 0x30(%rbx), %rdi
callq 0x64e0
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0xd964
movq 0x20(%rsp), %rdi
shlq $0x3, %rsi
callq 0x6310
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%r15), %rsi
testq %rsi, %rsi
je 0xd98c
movq 0x30(%rbx), %rdi
shlq $0x3, %rsi
callq 0x6310
movq %rsp, %rdi
callq 0x66fb
movq %r14, %rdi
callq 0x65b0
// File: /workspace/github_cpp_makefile_star2_O1/Chrom3D[P]Chrom3D/src/Randomizer.cpp
// Function: RotationRandomizer::randomize(Chromosome&, boost::random::mersenne_twister_engine<unsigned int, 32ul, 624ul, 397ul, 31ul, 2567483615u, 11ul, 4294967295u, 7ul, 2636928640u, 15ul, 4022730752u, 18ul, 1812433253u>&)
Move RotationRandomizer::randomize(Chromosome &chr, ENG &eng) {
  uint r1 = util::unif_int(0, chr.size()-2, eng);
  uint r2 = util::unif_int(r1+1, chr.size()-1, eng);
  double theta = util::unif_real(0.0, 2*util::PI-0.001, eng);
  CoordinateMatrix mat = chr.rotation(r1,r2,theta);
  Move mov(chr);
  mov.start = 0; // We return the positions of the start and end of the 
  mov.stop = chr.size()-1;  //  beads that have their coords altered (so, r1 and r2 are not included in crankshaft)
  mov.mat = mat;
  return mov;


}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rcx, %r15
movq %rdx, %r14
movq %rdi, %rbx
movq %rdx, %rdi
callq 0xb1dc
leal -0x2(%rax), %esi
xorl %edi, %edi
movq %r15, %rdx
callq 0x72ce
movl %eax, %r12d
leal 0x1(%r12), %ebp
movq %r14, %rdi
callq 0xb1dc
leal -0x1(%rax), %esi
movl %ebp, %edi
movq %r15, %rdx
callq 0x72ce
movl %eax, %ebp
movsd 0x1c66b(%rip), %xmm1    # 0x2a058
xorps %xmm0, %xmm0
movq %r15, %rdi
callq 0x72a4
movq %rsp, %rdi
movq %r14, %rsi
movl %r12d, %edx
movl %ebp, %ecx
callq 0xb80e
movq %r14, (%rbx)
leaq 0x28(%rbx), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx)
movups %xmm0, 0x10(%rbx)
movl $0x0, 0x8(%rbx)
movq %r14, %rdi
callq 0xb1dc
decl %eax
movl %eax, 0xc(%rbx)
leaq 0x10(%rsp), %rax
movaps -0x10(%rax), %xmm0
movups %xmm0, 0x10(%rbx)
leaq 0x20(%rbx), %rdi
cmpq %rax, %rdi
je 0xda6f
movq 0x18(%rsp), %rsi
xorps %xmm0, %xmm0
xorl %edx, %edx
callq 0xcc46
movq 0x18(%rsp), %rdx
testq %rdx, %rdx
je 0xda6f
movq 0x20(%rsp), %rsi
shlq $0x3, %rdx
movq 0x30(%rbx), %rdi
callq 0x64e0
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0xda87
movq 0x20(%rsp), %rdi
shlq $0x3, %rsi
callq 0x6310
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%r15), %rsi
testq %rsi, %rsi
je 0xdaaf
movq 0x30(%rbx), %rdi
shlq $0x3, %rsi
callq 0x6310
movq %rsp, %rdi
callq 0x6717
movq %r14, %rdi
callq 0x65b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/Chrom3D[P]Chrom3D/src/Constraint.cpp
// Function: Constraint::Constraint(Bead*, Bead*, double, ConstraintType, double, double, double)
Constraint::Constraint(Bead* b1, Bead* b2, double targetDistance, ConstraintType ct/* = REGULAR */, double springConstant /*=1*/, double lowerBound /*=0*/, double upperBound /*=INF*/) {
  bead1 = b1;
  bead2 = b2;
  k = springConstant;
  distance = targetDistance;
  constType = ct;
  lower = lowerBound;
  upper = upperBound;
}

// Assembly:
movq %rsi, (%rdi)
movq %rdx, 0x8(%rdi)
movsd %xmm1, 0x18(%rdi)
movsd %xmm0, 0x30(%rdi)
movl %ecx, 0x10(%rdi)
movsd %xmm2, 0x20(%rdi)
movsd %xmm3, 0x28(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Chrom3D[P]Chrom3D/src/Constraint.cpp
// Function: Constraint::eval()
double Constraint::eval() {
  double beadDist=(*bead1) - (*bead2);
  if(beadDist > this->lower and beadDist < this->upper) {
    return this->k * pow(beadDist - this->distance,2);
  }
  return 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x8(%rbx), %rsi
callq 0xae70
ucomisd 0x20(%rbx), %xmm0
xorpd %xmm1, %xmm1
jbe 0xdf5e
movsd 0x28(%rbx), %xmm2
ucomisd %xmm0, %xmm2
jbe 0xdf5e
subsd 0x30(%rbx), %xmm0
mulsd %xmm0, %xmm0
mulsd 0x18(%rbx), %xmm0
movapd %xmm0, %xmm1
movapd %xmm1, %xmm0
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/Chrom3D[P]Chrom3D/src/Constraint.cpp
// Function: Constraint::getConstraintType[abi:cxx11]()
string Constraint::getConstraintType(){

  switch(this->constType){
    case INTERACTION: return "INTERACTION";
    case PERIPHERY: return "PERIPHERY";
    case NUCLEUS: return "NUCLEUS";
    case BOUNDARY: return "BOUNDARY";
    case CENTER: return "CENTER";
    case INTERACTION_INTRA: return "INTERACTION_INTRA";
    case INTERACTION_INTER: return "INTERACTION_INTER";
    case INTERACTION_DIST: return "INTERACTION_DIST";
    case REGULAR: return "REGULAR";
    case C_T_COUNT: return "C_T_COUNT";
   }
   return "REGULAR";
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x10(%rsi), %eax
leaq 0x10(%rdi), %rcx
movq %rcx, (%rdi)
cmpq $0x9, %rax
ja 0xdf88
leaq 0x1c2d9(%rip), %rcx     # 0x2a258
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1c342(%rip), %rsi     # 0x2a2d1
leaq 0x1c342(%rip), %rdx     # 0x2a2d8
jmp 0xe029
leaq 0x1c2fc(%rip), %rsi     # 0x2a29e
leaq 0x1c2fd(%rip), %rdx     # 0x2a2a6
jmp 0xe029
leaq 0x1c30e(%rip), %rsi     # 0x2a2c0
leaq 0x1c317(%rip), %rdx     # 0x2a2d0
jmp 0xe029
leaq 0x1c2ca(%rip), %rsi     # 0x2a28c
leaq 0x1c2cc(%rip), %rdx     # 0x2a295
jmp 0xe029
leaq 0x1c2c4(%rip), %rsi     # 0x2a296
leaq 0x1c2c4(%rip), %rdx     # 0x2a29d
jmp 0xe029
leaq 0x1c2cc(%rip), %rsi     # 0x2a2ae
leaq 0x1c2d6(%rip), %rdx     # 0x2a2bf
jmp 0xe029
leaq 0x1c28e(%rip), %rsi     # 0x2a280
leaq 0x1c292(%rip), %rdx     # 0x2a28b
jmp 0xe029
leaq 0x1c2a5(%rip), %rsi     # 0x2a2a7
leaq 0x1c2a4(%rip), %rdx     # 0x2a2ad
jmp 0xe029
leaq 0x1c2c7(%rip), %rsi     # 0x2a2d9
leaq 0x1c2c9(%rip), %rdx     # 0x2a2e2
jmp 0xe029
leaq 0x1c50b(%rip), %rsi     # 0x2a52d
leaq 0x1c515(%rip), %rdx     # 0x2a53e
movq %rbx, %rdi
callq 0xe03a
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/Chrom3D[P]Chrom3D/src/Model.cpp
// Function: Model::Model(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned int)
Model::Model(string modelName, uint seed /*=1234*/) {
  name=modelName;
  randEngine.seed(seed);
  centerBead.setCoordinates(0,0,0);
  hasNucleus=false;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movl %edx, 0x14(%rsp)
leaq 0x10(%rdi), %r13
movq %r13, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x20(%rdi), %r14
leaq 0x1d062(%rip), %rsi     # 0x2b164
movq %r14, %rdi
callq 0x1698e
leaq 0x9f0(%rbx), %rax
xorl %ecx, %ecx
movl %ecx, 0x9f0(%rbx)
movq %rcx, 0x9f8(%rbx)
movq %rax, 0xa00(%rbx)
movq %rax, 0xa08(%rbx)
movq %rcx, 0xa10(%rbx)
leaq 0xa20(%rbx), %rax
movl %ecx, 0xa20(%rbx)
movq %rcx, 0xa28(%rbx)
movq %rax, 0xa30(%rbx)
movq %rax, 0xa38(%rbx)
leaq 0xaa8(%rbx), %rax
movl %ecx, 0xaa8(%rbx)
movq %rcx, 0xab0(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0xa40(%rbx)
movups %xmm0, 0xa50(%rbx)
movups %xmm0, 0xa60(%rbx)
movups %xmm0, 0xa70(%rbx)
movups %xmm0, 0xa80(%rbx)
movq %rax, 0xab8(%rbx)
movq %rax, 0xac0(%rbx)
movq %rcx, 0xac8(%rbx)
leaq 0xad0(%rbx), %r12
movq %r12, %rdi
callq 0xacbc
movq %rbx, %rdi
movq %r15, %rsi
callq 0x61d0
leaq 0x14(%rsp), %rsi
movq %r14, %rdi
callq 0x1698e
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
movq %r12, %rdi
callq 0xade6
movb $0x0, 0xa90(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, 0x8(%rsp)
jmp 0xe228
movq %rax, 0x8(%rsp)
jmp 0xe28b
movq %rax, 0x8(%rsp)
movq 0xb08(%rbx), %rdi
leaq 0xb18(%rbx), %rax
cmpq %rax, %rdi
je 0xe228
movq (%rax), %rsi
incq %rsi
callq 0x6310
leaq 0x9e8(%rbx), %r15
leaq 0xa18(%rbx), %r12
leaq 0xa48(%rbx), %r14
leaq 0xa78(%rbx), %rbp
leaq 0xaa0(%rbx), %rdi
callq 0x1709c
movq %rbp, %rdi
callq 0x169c4
movq 0xa60(%rbx), %rdi
testq %rdi, %rdi
je 0xe273
movq 0xa70(%rbx), %rsi
subq %rdi, %rsi
callq 0x6310
movq %r14, %rdi
callq 0x169f4
movq %r12, %rdi
callq 0x17144
movq %r15, %rdi
callq 0x17144
movq (%rbx), %rdi
cmpq %r13, %rdi
je 0xe29f
movq (%r13), %rsi
incq %rsi
callq 0x6310
movq 0x8(%rsp), %rdi
callq 0x65b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/Chrom3D[P]Chrom3D/src/Model.cpp
// Function: Model::updateBeadMap()
void Model::updateBeadMap() {
  this->getBead.clear();
  vector<Chromosome>::iterator chriter;
  boost::container::static_vector<Bead,MAXSIZE>::iterator beaditer; 
  for(chriter = chromosomes.begin(); chriter != chromosomes.end(); chriter++) {
    for(beaditer = chriter->begin(); beaditer != chriter->end(); beaditer++) {
      getBead[beaditer->getID()] = &(*beaditer);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0xaa0(%rdi), %r14
movq %r14, %rdi
callq 0x17778
movq 0xa78(%rbx), %r15
cmpq 0xa80(%rbx), %r15
je 0xe361
leaq 0x18(%rsp), %rbp
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0xb208
movq 0x8(%rsp), %r13
movq %r12, %rdi
movq %r15, %rsi
callq 0xb214
cmpq 0x8(%rsp), %r13
je 0xe351
testq %r13, %r13
je 0xe370
movq %r12, %rdi
movq %r13, %rsi
callq 0xae24
movq %r14, %rdi
movq %r12, %rsi
callq 0x16a1c
movq %r13, (%rax)
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0xe34b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6310
addq $0x60, %r13
jmp 0xe304
addq $0x75330, %r15          # imm = 0x75330
cmpq 0xa80(%rbx), %r15
jne 0xe2f4
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1b48c(%rip), %rdi     # 0x29803
leaq 0x1b48d(%rip), %rsi     # 0x2980b
leaq 0x1b5bd(%rip), %rcx     # 0x29942
movl $0x8e, %edx
callq 0x6210
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0xe3a9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6310
movq %rbx, %rdi
callq 0x65b0
nop