LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4624(%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 0x3a0d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21d0
incl %ebp
cmpl $0x20, %ebp
jne 0x39b1
movq 0x482d(%rip), %rsi      # 0x8248
movq 0x482e(%rip), %rdx      # 0x8250
movq 0x45a7(%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 0x3a86
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21d0
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4158(%rip), %r14      # 0x7ff0
leaq 0x1355(%rip), %rsi      # 0x51f4
movl $0x8, %edx
movq %r14, %rdi
callq 0x21f0
testq %rbx, %rbx
je 0x3ecd
movq %rbx, %rdi
callq 0x20e0
movq 0x4130(%rip), %rdi      # 0x7ff0
movq %rbx, %rsi
movq %rax, %rdx
callq 0x21f0
jmp 0x3ee5
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x22e0
movq 0x4104(%rip), %r14      # 0x7ff0
leaq 0x130a(%rip), %rsi      # 0x51fd
movl $0xc, %edx
movq %r14, %rdi
callq 0x21f0
leaq 0x1303(%rip), %rsi      # 0x520a
movl $0x55, %edx
movq %r14, %rdi
callq 0x21f0
leaq 0x1345(%rip), %rsi      # 0x5260
movl $0x53, %edx
movq %r14, %rdi
callq 0x21f0
leaq 0x1385(%rip), %rsi      # 0x52b4
movl $0x53, %edx
movq %r14, %rdi
callq 0x21f0
leaq 0x13c5(%rip), %rsi      # 0x5308
movl $0x52, %edx
movq %r14, %rdi
callq 0x21f0
leaq 0x1404(%rip), %rsi      # 0x535b
movl $0x54, %edx
movq %r14, %rdi
callq 0x21f0
leaq 0x1445(%rip), %rsi      # 0x53b0
movl $0x1a, %edx
movq %r14, %rdi
callq 0x21f0
leaq 0x144c(%rip), %rsi      # 0x53cb
movl $0x30, %edx
movq %r14, %rdi
callq 0x21f0
leaq 0x1469(%rip), %rsi      # 0x53fc
movl $0x3c, %edx
movq %r14, %rdi
callq 0x21f0
leaq 0x1492(%rip), %rsi      # 0x5439
movl $0x16, %edx
movq %r14, %rdi
callq 0x21f0
leaq 0x1495(%rip), %rsi      # 0x5450
movl $0x20, %edx
movq %r14, %rdi
callq 0x21f0
testq %rbx, %rbx
je 0x3fe9
movq %rbx, %rdi
callq 0x20e0
movq 0x4014(%rip), %rdi      # 0x7ff0
movq %rbx, %rsi
movq %rax, %rdx
callq 0x21f0
jmp 0x4001
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x22e0
movq 0x3fe8(%rip), %rbx      # 0x7ff0
leaq 0x1462(%rip), %rsi      # 0x5471
movl $0x22, %edx
movq %rbx, %rdi
callq 0x21f0
leaq 0x1471(%rip), %rsi      # 0x5494
movl $0x22, %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x21f0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1463(%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 0x405a
cmpl $0x70, %eax
jne 0x4084
movl $0x1, %r12d
xorl %r15d, %r15d
jmp 0x4057
cmpl $-0x1, %eax
jne 0x40dc
cmpl %r12d, %r13d
jne 0x40f3
movq 0x3f5b(%rip), %r14      # 0x7ff0
movq %r14, %rdi
movl $0xa, %esi
callq 0x2200
leaq 0x417f(%rip), %rsi      # 0x8228
movq %rax, %rdi
callq 0x2190
leaq 0x1403(%rip), %rsi      # 0x54bb
movq %r14, %rdi
callq 0x21b0
leaq 0x4181(%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 0x3e8a
xorl %edi, %edi
callq 0x2210
testl %r13d, %r13d
je 0x40fd
callq 0x3a8e
testb $0x1, %r15b
jne 0x40ec
callq 0x3800
jmp 0x40ec
// File: /workspace/github_cpp_makefile_star2_O3/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 0x82e6
testl %ebp, %ebp
je 0x6c4a
leaq 0x10(%rbx), %r12
xorl %r13d, %r13d
movq %r14, %rdi
xorl %esi, %esi
callq 0x8fe2
movsd (%rax), %xmm0
movsd %xmm0, (%rsp)
movq (%rbx), %rsi
movq 0x8(%rbx), %rcx
movq %r13, %rdi
xorl %edx, %edx
callq 0x9124
movq %r12, %rdi
movq %rax, %rsi
callq 0x8fe2
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
movl $0x1, %esi
movq %r14, %rdi
callq 0x8fe2
movsd (%rax), %xmm0
movsd %xmm0, (%rsp)
movq (%rbx), %rsi
movq 0x8(%rbx), %rcx
movl $0x1, %edx
movq %r13, %rdi
callq 0x9124
movq %r12, %rdi
movq %rax, %rsi
callq 0x8fe2
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
movl $0x2, %esi
movq %r14, %rdi
callq 0x8fe2
movsd (%rax), %xmm0
movsd %xmm0, (%rsp)
movq (%rbx), %rsi
movq 0x8(%rbx), %rcx
movl $0x2, %edx
movq %r13, %rdi
callq 0x9124
movq %r12, %rdi
movq %rax, %rsi
callq 0x8fe2
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
incq %r13
cmpq %r13, %r15
jne 0x6b8a
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 0x6c75
movq 0x20(%rbx), %rdi
shlq $0x3, %rsi
callq 0x6310
movq %r14, %rdi
callq 0x65b0
// File: /workspace/github_cpp_makefile_star2_O3/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)
je 0x7517
movq %rsi, %r14
movl $0x1, %ebx
xorl %r15d, %r15d
leaq 0x30(%rsp), %r12
leaq 0x18(%rsp), %r13
movq %r12, %rdi
movq 0x10(%rsp), %rsi
callq 0x9478
movq %r14, 0x48(%rsp)
movq %r15, 0x50(%rsp)
movq %r13, %rdi
leaq 0x48(%rsp), %rsi
callq 0x8560
movq 0x8(%rsp), %rax
movq (%rax), %rax
movsd (%rax,%r15,8), %xmm1
movq %r12, %rdi
movq %r13, %rsi
movsd (%rsp), %xmm0
callq 0x7364
movl %eax, %ebp
movq 0x20(%rsp), %rsi
testq %rsi, %rsi
je 0x74ea
movq 0x28(%rsp), %rdi
shlq $0x3, %rsi
callq 0x6310
movq 0x38(%rsp), %rsi
testq %rsi, %rsi
je 0x7502
movq 0x40(%rsp), %rdi
shlq $0x3, %rsi
callq 0x6310
testb %bpl, %bpl
jne 0x7519
movl %ebx, %r15d
incl %ebx
cmpq %r15, (%r14)
jne 0x748e
jmp 0x7519
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x754a
movq %rax, %rbx
movq 0x20(%rsp), %rsi
testq %rsi, %rsi
je 0x754a
movq 0x28(%rsp), %rdi
shlq $0x3, %rsi
callq 0x6310
movq 0x38(%rsp), %rsi
testq %rsi, %rsi
je 0x7562
movq 0x40(%rsp), %rdi
shlq $0x3, %rsi
callq 0x6310
movq %rbx, %rdi
callq 0x65b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7e07
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8822
jmp 0x7ddf
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x7e1e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6310
movq 0x300eb(%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 0x7e69
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6310
movq 0x300a0(%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_O3/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 0x7f6e
movq 0x10(%rsp), %rdi
callq 0x63c0
movsd %xmm0, 0x8(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x7f61
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x7f1e
movq %rbx, %rdi
movq %r12, %rdx
callq 0xa598
jmp 0x7f1e
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x7f85
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x6310
movq 0x2ff84(%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 0x7fba
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x7fd4
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x6310
movq 0x2ff35(%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_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq (%rsi), %rsi
movq 0x8(%r15), %rax
movq %rax, %rcx
subq %rsi, %rcx
movq 0x8(%rdx), %rdx
subq (%r14), %rdx
cmpq %rdx, %rcx
jne 0x80e7
movq %rdi, %rbx
leaq 0x8(%rdi), %rcx
movl $0x0, 0x8(%rdi)
xorl %edx, %edx
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %rcx, 0x20(%rdi)
movq %rdx, 0x28(%rdi)
cmpq %rsi, %rax
je 0x80d5
movl $0x1, %ebp
xorl %r13d, %r13d
movq (%r14), %r12
shlq $0x5, %r13
addq %r13, %rsi
movq %rbx, %rdi
callq 0x88be
addq %r13, %r12
movq %rax, %rdi
movq %r12, %rsi
callq 0x61d0
movl %ebp, %r13d
movq (%r15), %rsi
movq 0x8(%r15), %rax
subq %rsi, %rax
sarq $0x5, %rax
incl %ebp
cmpq %r13, %rax
jne 0x809d
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x61a0
movq %rax, %rbx
leaq 0x21007(%rip), %rsi     # 0x29102
movq %rax, %rdi
callq 0x6150
movq 0x2fee6(%rip), %rsi     # 0x37ff0
movq 0x2fe57(%rip), %rdx     # 0x37f68
movq %rbx, %rdi
callq 0x6550
movq %rax, %r14
movq %rbx, %rdi
callq 0x6280
jmp 0x8131
movq %rax, %r14
movq %rbx, %rdi
callq 0x895c
movq %r14, %rdi
callq 0x65b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x20fc3(%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 0xaa3a
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 0x20f44(%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 0x8254
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6310
leaq 0x70(%rsp), %rsi
movq %rbx, %rdi
callq 0x64b0
movq 0x2fd08(%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 0x82b3
jmp 0x8299
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x82b3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6310
movq 0x2fcb6(%rip), %rsi     # 0x37f70
leaq 0x68(%rsp), %rdi
callq 0x61c0
leaq 0xd8(%rsp), %rdi
callq 0x6120
movq %rbx, %rdi
callq 0x65b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xad8c
testb %al, %al
je 0xb05c
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 0xc567
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 0xb038
testq %r12, %r12
je 0xb07b
movq %rbx, %rdi
movq %r12, %rsi
callq 0xae17
testb %al, %al
je 0xb09a
leaq 0x10(%rsp), %rdx
movq %r12, (%rdx)
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rcx
callq 0xc694
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x1e5dd(%rip), %rdi     # 0x29640
leaq 0x1e5ec(%rip), %rsi     # 0x29656
leaq 0x1e5f8(%rip), %rcx     # 0x29669
movl $0x1b, %edx
callq 0x6210
leaq 0x1e781(%rip), %rdi     # 0x29803
leaq 0x1e782(%rip), %rsi     # 0x2980b
leaq 0x1e8b2(%rip), %rcx     # 0x29942
movl $0x8e, %edx
callq 0x6210
leaq 0x1e5e7(%rip), %rdi     # 0x29688
leaq 0x1e5ae(%rip), %rsi     # 0x29656
leaq 0x1e5ba(%rip), %rcx     # 0x29669
movl $0x1e, %edx
callq 0x6210
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xb2d2
movl %ecx, %r12d
cmpq %r12, 0x75328(%r15)
jbe 0xb2f1
movl %edx, %ebp
movq %rdi, %rbx
incl %esi
movl $0x3, %edx
callq 0x82e6
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 0xb2c0
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 0xad6c
movsd %xmm0, (%rsp)
movl %ebp, %r12d
movq (%rbx), %rsi
movq 0x8(%rbx), %rcx
movq %r12, %rdi
xorl %edx, %edx
callq 0x9124
movq %r15, %rdi
movq %rax, %rsi
callq 0x8fe2
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
movq %r14, %rdi
callq 0xad72
movsd %xmm0, (%rsp)
movq (%rbx), %rsi
movq 0x8(%rbx), %rcx
movl $0x1, %edx
movq %r12, %rdi
callq 0x9124
movq %r15, %rdi
movq %rax, %rsi
callq 0x8fe2
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
movq %r14, %rdi
callq 0xad78
movsd %xmm0, (%rsp)
movq (%rbx), %rsi
movq 0x8(%rbx), %rcx
movl $0x2, %edx
movq %r12, %rdi
callq 0x9124
movq %r15, %rdi
movq %rax, %rsi
callq 0x8fe2
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
incl %ebp
addq $0x60, %r14
addq $-0x60, %r13
jne 0xb211
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1e3d4(%rip), %rdi     # 0x296ad
leaq 0x1e376(%rip), %rsi     # 0x29656
leaq 0x1e3d9(%rip), %rcx     # 0x296c0
movl $0x3b, %edx
callq 0x6210
leaq 0x1e404(%rip), %rdi     # 0x296fc
leaq 0x1e357(%rip), %rsi     # 0x29656
leaq 0x1e3ba(%rip), %rcx     # 0x296c0
movl $0x3c, %edx
callq 0x6210
movq %rax, %r14
movq 0x18(%rbx), %rsi
testq %rsi, %rsi
je 0xb329
movq 0x20(%rbx), %rdi
shlq $0x3, %rsi
callq 0x6310
movq %r14, %rdi
callq 0x65b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xb4f6
movsd 0x1dbbf(%rip), %xmm3    # 0x29008
ucomisd %xmm0, %xmm3
jb 0xb4f6
xorpd %xmm4, %xmm4
ucomisd %xmm4, %xmm1
jb 0xb515
ucomisd %xmm1, %xmm3
jb 0xb515
ucomisd %xmm4, %xmm2
jb 0xb534
ucomisd %xmm2, %xmm3
jb 0xb534
movq %rdi, %rbx
cmpq $0x0, 0x75328(%rdi)
je 0xb4ec
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 0xadb4
addq $0x60, %r14
movq 0x75328(%rbx), %rax
leaq (%rax,%rax,2), %rax
shlq $0x5, %rax
addq %r15, %rax
cmpq %rax, %r14
jne 0xb4b7
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1e218(%rip), %rdi     # 0x29715
leaq 0x1e152(%rip), %rsi     # 0x29656
leaq 0x1e21c(%rip), %rcx     # 0x29727
movl $0x56, %edx
callq 0x6210
leaq 0x1e23d(%rip), %rdi     # 0x29759
leaq 0x1e133(%rip), %rsi     # 0x29656
leaq 0x1e1fd(%rip), %rcx     # 0x29727
movl $0x57, %edx
callq 0x6210
leaq 0x1e230(%rip), %rdi     # 0x2976b
leaq 0x1e114(%rip), %rsi     # 0x29656
leaq 0x1e1de(%rip), %rcx     # 0x29727
movl $0x58, %edx
callq 0x6210
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xb332
leaq 0x40(%rsp), %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0xb332
incl %r14d
decl %ebp
leaq 0xa0(%rsp), %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
callq 0xb18e
leaq 0x28(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x9478
leaq 0x10(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x9478
leaq 0xb0(%rsp), %rsi
movaps -0x10(%rsi), %xmm0
leaq 0x80(%rsp), %rdi
movaps %xmm0, -0x10(%rdi)
callq 0x9478
leaq 0x28(%rsp), %rsi
leaq 0x10(%rsp), %rdx
leaq 0x70(%rsp), %rcx
movq %rbx, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x6cc6
movq 0x88(%rsp), %rsi
testq %rsi, %rsi
je 0xb61b
movq 0x90(%rsp), %rdi
shlq $0x3, %rsi
callq 0x6310
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0xb633
movq 0x20(%rsp), %rdi
shlq $0x3, %rsi
callq 0x6310
movq 0x30(%rsp), %rsi
testq %rsi, %rsi
je 0xb64b
movq 0x38(%rsp), %rdi
shlq $0x3, %rsi
callq 0x6310
movq 0xb8(%rsp), %rsi
testq %rsi, %rsi
je 0xb669
movq 0xc0(%rsp), %rdi
shlq $0x3, %rsi
callq 0x6310
movq 0x48(%rsp), %rsi
testq %rsi, %rsi
je 0xb681
movq 0x50(%rsp), %rdi
shlq $0x3, %rsi
callq 0x6310
movq 0x60(%rsp), %rsi
testq %rsi, %rsi
je 0xb699
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 0xb6d0
movq 0x90(%rsp), %rdi
shlq $0x3, %rsi
callq 0x6310
jmp 0xb6d0
movq %rax, %rbx
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0xb6ed
movq 0x20(%rsp), %rdi
shlq $0x3, %rsi
callq 0x6310
jmp 0xb6ed
movq %rax, %rbx
movq 0x30(%rsp), %rsi
testq %rsi, %rsi
je 0xb70a
movq 0x38(%rsp), %rdi
shlq $0x3, %rsi
callq 0x6310
jmp 0xb70a
movq %rax, %rbx
movq 0xb8(%rsp), %rsi
testq %rsi, %rsi
je 0xb72d
movq 0xc0(%rsp), %rdi
shlq $0x3, %rsi
callq 0x6310
jmp 0xb72d
movq %rax, %rbx
movq 0x48(%rsp), %rsi
testq %rsi, %rsi
je 0xb74a
movq 0x50(%rsp), %rdi
shlq $0x3, %rsi
callq 0x6310
jmp 0xb74a
movq %rax, %rbx
movq 0x60(%rsp), %rsi
testq %rsi, %rsi
je 0xb762
movq 0x68(%rsp), %rdi
shlq $0x3, %rsi
callq 0x6310
movq %rbx, %rdi
callq 0x65b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0xb332
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0xb332
movl 0x75328(%r14), %ecx
decl %ecx
leaq 0xa0(%rsp), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xb18e
leaq 0x28(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x9478
leaq 0x10(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x9478
leaq 0xb0(%rsp), %rsi
movaps -0x10(%rsi), %xmm0
leaq 0x80(%rsp), %rdi
movaps %xmm0, -0x10(%rdi)
callq 0x9478
leaq 0x28(%rsp), %rsi
leaq 0x10(%rsp), %rdx
leaq 0x70(%rsp), %rcx
movq %rbx, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x6cc6
movq 0x88(%rsp), %rsi
testq %rsi, %rsi
je 0xb82d
movq 0x90(%rsp), %rdi
shlq $0x3, %rsi
callq 0x6310
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0xb845
movq 0x20(%rsp), %rdi
shlq $0x3, %rsi
callq 0x6310
movq 0x30(%rsp), %rsi
testq %rsi, %rsi
je 0xb85d
movq 0x38(%rsp), %rdi
shlq $0x3, %rsi
callq 0x6310
movq 0xb8(%rsp), %rsi
testq %rsi, %rsi
je 0xb87b
movq 0xc0(%rsp), %rdi
shlq $0x3, %rsi
callq 0x6310
movq 0x48(%rsp), %rsi
testq %rsi, %rsi
je 0xb893
movq 0x50(%rsp), %rdi
shlq $0x3, %rsi
callq 0x6310
movq 0x60(%rsp), %rsi
testq %rsi, %rsi
je 0xb8ab
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 0xb8e0
movq 0x90(%rsp), %rdi
shlq $0x3, %rsi
callq 0x6310
jmp 0xb8e0
movq %rax, %rbx
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0xb8fd
movq 0x20(%rsp), %rdi
shlq $0x3, %rsi
callq 0x6310
jmp 0xb8fd
movq %rax, %rbx
movq 0x30(%rsp), %rsi
testq %rsi, %rsi
je 0xb91a
movq 0x38(%rsp), %rdi
shlq $0x3, %rsi
callq 0x6310
jmp 0xb91a
movq %rax, %rbx
movq 0xb8(%rsp), %rsi
testq %rsi, %rsi
je 0xb93d
movq 0xc0(%rsp), %rdi
shlq $0x3, %rsi
callq 0x6310
jmp 0xb93d
movq %rax, %rbx
movq 0x48(%rsp), %rsi
testq %rsi, %rsi
je 0xb95a
movq 0x50(%rsp), %rdi
shlq $0x3, %rsi
callq 0x6310
jmp 0xb95a
movq %rax, %rbx
movq 0x60(%rsp), %rsi
testq %rsi, %rsi
je 0xb972
movq 0x68(%rsp), %rdi
shlq $0x3, %rsi
callq 0x6310
movq %rbx, %rdi
callq 0x65b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0xb138
leal -0x3(%rax), %esi
xorl %edi, %edi
movq %r12, %rdx
callq 0x72ee
movl %eax, %r15d
leal 0x2(%r15), %ebp
movq %r14, %rdi
callq 0xb138
leal -0x1(%rax), %esi
movl %ebp, %edi
movq %r12, %rdx
callq 0x72ee
movl %eax, %ebp
movsd 0x1d0f6(%rip), %xmm1    # 0x2a058
xorps %xmm0, %xmm0
movq %r12, %rdi
callq 0x72c4
movq %rsp, %r12
movq %r12, %rdi
movq %r14, %rsi
movl %r15d, %edx
movl %ebp, %ecx
callq 0xb554
movq %r14, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%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 0xcfdf
leaq 0x28(%rbx), %r12
leaq 0x18(%rsp), %r14
movq (%r14), %rsi
xorps %xmm0, %xmm0
xorl %edx, %edx
callq 0xcbba
movq 0x18(%rsp), %rdx
testq %rdx, %rdx
je 0xcfdf
movq 0x20(%rsp), %rsi
shlq $0x3, %rdx
movq 0x30(%rbx), %rdi
callq 0x64e0
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0xcff7
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, %r15
movq (%r12), %rsi
testq %rsi, %rsi
je 0xd020
movq 0x30(%rbx), %rdi
shlq $0x3, %rsi
callq 0x6310
movq %rsp, %rsi
movq %r14, %rdi
callq 0x66c3
movq %r15, %rdi
callq 0x65b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xb138
leal -0x2(%rax), %esi
movl $0x1, %edi
movq %r15, %rdx
callq 0x72ee
movl %eax, %ebp
xorl %edi, %edi
movl $0x1, %esi
movq %r15, %rdx
callq 0x72ee
movl %eax, %r12d
xorl %r13d, %r13d
testl %eax, %eax
setne %r13b
movsd 0x1c926(%rip), %xmm1    # 0x2a058
xorps %xmm0, %xmm0
movq %r15, %rdi
callq 0x72c4
movq %rsp, %rdi
movq %r14, %rsi
movl %ebp, %edx
movl %r13d, %ecx
callq 0xb97a
leaq 0x28(%rbx), %r15
movq %r14, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx)
movups %xmm0, 0x10(%rbx)
testl %r12d, %r12d
je 0xd775
incl %ebp
movl %ebp, 0x8(%rbx)
movq %r14, %rdi
callq 0xb138
movl %eax, %ebp
jmp 0xd77c
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 0xd7c2
movq 0x18(%rsp), %rsi
xorps %xmm0, %xmm0
xorl %edx, %edx
callq 0xcbba
movq 0x18(%rsp), %rdx
testq %rdx, %rdx
je 0xd7c2
movq 0x20(%rsp), %rsi
shlq $0x3, %rdx
movq 0x30(%rbx), %rdi
callq 0x64e0
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0xd7da
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 0xd804
movq 0x30(%rbx), %rdi
shlq $0x3, %rsi
callq 0x6310
movq %rsp, %rdi
callq 0x66e1
movq %r14, %rdi
callq 0x65b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0xb138
leal -0x3(%rax), %esi
xorl %edi, %edi
movq %r15, %rdx
callq 0x72ee
movl %eax, %r12d
leal 0x2(%r12), %ebp
movsd 0x1c80a(%rip), %xmm1    # 0x2a058
xorps %xmm0, %xmm0
movq %r15, %rdi
callq 0x72c4
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
movl %r12d, %edx
movl %ebp, %ecx
callq 0xb554
movq %r14, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%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 0xd8c9
leaq 0x28(%rbx), %r12
leaq 0x18(%rsp), %r14
movq (%r14), %rsi
xorps %xmm0, %xmm0
xorl %edx, %edx
callq 0xcbba
movq 0x18(%rsp), %rdx
testq %rdx, %rdx
je 0xd8c9
movq 0x20(%rsp), %rsi
shlq $0x3, %rdx
movq 0x30(%rbx), %rdi
callq 0x64e0
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0xd8e1
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, %r15
movq (%r12), %rsi
testq %rsi, %rsi
je 0xd90a
movq 0x30(%rbx), %rdi
shlq $0x3, %rsi
callq 0x6310
movq %rsp, %rsi
movq %r14, %rdi
callq 0x66fd
movq %r15, %rdi
callq 0x65b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xb138
leal -0x2(%rax), %esi
xorl %edi, %edi
movq %r15, %rdx
callq 0x72ee
movl %eax, %r12d
leal 0x1(%r12), %ebp
movq %r14, %rdi
callq 0xb138
leal -0x1(%rax), %esi
movl %ebp, %edi
movq %r15, %rdx
callq 0x72ee
movl %eax, %ebp
movsd 0x1c6e9(%rip), %xmm1    # 0x2a058
xorps %xmm0, %xmm0
movq %r15, %rdi
callq 0x72c4
movq %rsp, %rdi
movq %r14, %rsi
movl %r12d, %edx
movl %ebp, %ecx
callq 0xb76a
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 0xb138
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 0xd9f1
movq 0x18(%rsp), %rsi
xorps %xmm0, %xmm0
xorl %edx, %edx
callq 0xcbba
movq 0x18(%rsp), %rdx
testq %rdx, %rdx
je 0xd9f1
movq 0x20(%rsp), %rsi
shlq $0x3, %rdx
movq 0x30(%rbx), %rdi
callq 0x64e0
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0xda09
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 0xda31
movq 0x30(%rbx), %rdi
shlq $0x3, %rsi
callq 0x6310
movq %rsp, %rdi
callq 0x671b
movq %r14, %rdi
callq 0x65b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xaddc
ucomisd 0x20(%rbx), %xmm0
xorpd %xmm1, %xmm1
jbe 0xdeb8
movsd 0x28(%rbx), %xmm2
ucomisd %xmm0, %xmm2
jbe 0xdeb8
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_O3/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 0xdee2
leaq 0x1c37f(%rip), %rcx     # 0x2a258
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1c3e8(%rip), %rsi     # 0x2a2d1
leaq 0x1c3e8(%rip), %rdx     # 0x2a2d8
jmp 0xdf83
leaq 0x1c3a2(%rip), %rsi     # 0x2a29e
leaq 0x1c3a3(%rip), %rdx     # 0x2a2a6
jmp 0xdf83
leaq 0x1c3b4(%rip), %rsi     # 0x2a2c0
leaq 0x1c3bd(%rip), %rdx     # 0x2a2d0
jmp 0xdf83
leaq 0x1c370(%rip), %rsi     # 0x2a28c
leaq 0x1c372(%rip), %rdx     # 0x2a295
jmp 0xdf83
leaq 0x1c36a(%rip), %rsi     # 0x2a296
leaq 0x1c36a(%rip), %rdx     # 0x2a29d
jmp 0xdf83
leaq 0x1c372(%rip), %rsi     # 0x2a2ae
leaq 0x1c37c(%rip), %rdx     # 0x2a2bf
jmp 0xdf83
leaq 0x1c334(%rip), %rsi     # 0x2a280
leaq 0x1c338(%rip), %rdx     # 0x2a28b
jmp 0xdf83
leaq 0x1c34b(%rip), %rsi     # 0x2a2a7
leaq 0x1c34a(%rip), %rdx     # 0x2a2ad
jmp 0xdf83
leaq 0x1c36d(%rip), %rsi     # 0x2a2d9
leaq 0x1c36f(%rip), %rdx     # 0x2a2e2
jmp 0xdf83
leaq 0x1c5b1(%rip), %rsi     # 0x2a52d
leaq 0x1c5bb(%rip), %rdx     # 0x2a53e
movq %rbx, %rdi
callq 0xdf94
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %rax
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x10(%rdi), %r13
movq %r13, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x20(%rdi), %r14
leaq 0x1d107(%rip), %rsi     # 0x2b164
movq %r14, %rdi
callq 0x165ee
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), %r15
movq %r15, %rdi
callq 0xac28
movq %rbx, %rdi
movq %r12, %rsi
callq 0x61d0
movl %ebp, (%r14)
movl $0x1, %eax
movl $0x9, %ecx
movl %ebp, %edx
shrl $0x1e, %edx
xorl %ebp, %edx
imull $0x6c078965, %edx, %edx # imm = 0x6C078965
leal (%rax,%rdx), %ebp
addl %ecx, %edx
addl $-0x8, %edx
movl %edx, (%rbx,%rcx,4)
incq %rax
incq %rcx
cmpq $0x278, %rcx            # imm = 0x278
jne 0xe128
movq $0x270, 0x9e0(%rbx) # imm = 0x270
movq %r14, %rdi
callq 0x173be
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
movq %r15, %rdi
callq 0xad52
movb $0x0, 0xa90(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, (%rsp)
jmp 0xe1ba
movq %rax, (%rsp)
jmp 0xe21d
movq %rax, (%rsp)
movq 0xb08(%rbx), %rdi
leaq 0xb18(%rbx), %rax
cmpq %rax, %rdi
je 0xe1ba
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 0x16d60
movq %rbp, %rdi
callq 0x16624
movq 0xa60(%rbx), %rdi
testq %rdi, %rdi
je 0xe205
movq 0xa70(%rbx), %rsi
subq %rdi, %rsi
callq 0x6310
movq %r14, %rdi
callq 0x16654
movq %r12, %rdi
callq 0x16dd8
movq %r15, %rdi
callq 0x16dd8
movq (%rbx), %rdi
cmpq %r13, %rdi
je 0xe231
movq (%r13), %rsi
incq %rsi
callq 0x6310
movq (%rsp), %rdi
callq 0x65b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x17406
movq 0xa78(%rbx), %r15
cmpq 0xa80(%rbx), %r15
je 0xe2f1
leaq 0x18(%rsp), %rbp
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0xb164
movq 0x8(%rsp), %r13
movq %r12, %rdi
movq %r15, %rsi
callq 0xb170
cmpq 0x8(%rsp), %r13
je 0xe2e1
testq %r13, %r13
je 0xe300
movq %r12, %rdi
movq %r13, %rsi
callq 0xad90
movq %r14, %rdi
movq %r12, %rsi
callq 0x166a0
movq %r13, (%rax)
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0xe2db
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6310
addq $0x60, %r13
jmp 0xe294
addq $0x75330, %r15          # imm = 0x75330
cmpq 0xa80(%rbx), %r15
jne 0xe284
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1b4fc(%rip), %rdi     # 0x29803
leaq 0x1b4fd(%rip), %rsi     # 0x2980b
leaq 0x1b62d(%rip), %rcx     # 0x29942
movl $0x8e, %edx
callq 0x6210
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0xe339
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6310
movq %rbx, %rdi
callq 0x65b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Chrom3D[P]Chrom3D/src/Model.cpp
// Function: Model::addChromosome(Chromosome)
void Model::addChromosome(Chromosome chr) {
  assert ( find(chromosomes.begin(), chromosomes.end(), chr) == chromosomes.end() ); // Chromosomes must be unique
  // Assert that all Bead IDS ARE UNIQUE HERE AND NOT FOUND ON ANY CHR HERE
  chromosomes.push_back(chr);  
  this->updateBeadMap();
  //hasUpdatedHashMap = false;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0xa78(%rdi), %rdi
movq 0xa80(%rbx), %rsi
movq %r14, %rdx
callq 0x17753
cmpq 0xa80(%rbx), %rax
jne 0xe389
leaq 0xa78(%rbx), %rdi
movq %r14, %rsi
callq 0x1671c
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xe24a
leaq 0x1bfd0(%rip), %rdi     # 0x2a360
leaq 0x1c010(%rip), %rsi     # 0x2a3a7
leaq 0x1c017(%rip), %rcx     # 0x2a3b5
movl $0x29, %edx
callq 0x6210
// File: /workspace/github_cpp_makefile_star2_O3/Chrom3D[P]Chrom3D/src/Model.cpp
// Function: Model::addConstraint(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double, ConstraintType, double, double, double)
void Model::addConstraint(string beadId1, string beadId2, double targetDistance, ConstraintType ct /*=REGULAR*/, double springConstant /*=1*/, double lowerBound /*=0*/, double upperBound /*=INF*/) {
  assert(getBead.find(beadId1) != getBead.end()); 
  assert(getBead.find(beadId2) != getBead.end()); 
  Bead* b1 = getBead[beadId1];
  Bead* b2 = getBead[beadId2];
  this->addConstraint(Constraint(b1, b2, targetDistance, ct, springConstant, lowerBound, upperBound));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movsd %xmm3, 0x58(%rsp)
movsd %xmm2, 0x50(%rsp)
movsd %xmm1, 0x48(%rsp)
movl %ecx, %ebp
movsd %xmm0, 0x40(%rsp)
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
leaq 0xaa0(%rdi), %r15
movq %r15, %rdi
callq 0x180e2
leaq 0xaa8(%rbx), %r13
cmpq %r13, %rax
je 0xe552
movq %r15, %rdi
movq %r14, %rsi
callq 0x180e2
cmpq %r13, %rax
je 0xe571
movq %r15, %rdi
movq %r12, %rsi
callq 0x167fa
movq (%rax), %r12
movq %r15, %rdi
movq %r14, %rsi
callq 0x167fa
movq (%rax), %rdx
leaq 0x60(%rsp), %r14
movq %r14, %rdi
movq %r12, %rsi
movsd 0x40(%rsp), %xmm0
movl %ebp, %ecx
movsd 0x48(%rsp), %xmm1
movsd 0x50(%rsp), %xmm2
movsd 0x58(%rsp), %xmm3
callq 0xdda0
movq 0x30(%r14), %rax
movq %rax, 0x30(%rsp)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0xe3a8
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1be82(%rip), %rdi     # 0x2a3db
leaq 0x1be47(%rip), %rsi     # 0x2a3a7
leaq 0x1be9b(%rip), %rcx     # 0x2a402
movl $0x37, %edx
callq 0x6210
leaq 0x1bee4(%rip), %rdi     # 0x2a45c
leaq 0x1be28(%rip), %rsi     # 0x2a3a7
leaq 0x1be7c(%rip), %rcx     # 0x2a402
movl $0x38, %edx
callq 0x6210