LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/luigix25[P]SSLP/library/DHManager.cpp
// Function: DHManager::computeSimmetricKey(char const*, unsigned int, int&)
char * DHManager::computeSimmetricKey(const char *received_data,uint32_t len,int &key_len){

	BIGNUM *opponent_pubkey = BN_bin2bn((const unsigned char*)received_data,len,NULL);
	unsigned char* key = new unsigned char[DH_size(this->session)];
	key_len = DH_compute_key(key,opponent_pubkey,this->session);

	BN_free(opponent_pubkey);

	if(key_len <=0)
		return NULL;

	return (char*)key;

}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdi, %r14
xorl %r13d, %r13d
movq %rsi, %rdi
movl %edx, %esi
xorl %edx, %edx
callq 0x4120
movq %rax, %r15
movq (%r14), %rdi
callq 0x4310
movslq %eax, %rdi
callq 0x4030
movq %rax, %r12
movq (%r14), %rdx
movq %rax, %rdi
movq %r15, %rsi
callq 0x4490
movl %eax, (%rbx)
movq %r15, %rdi
callq 0x4620
cmpl $0x0, (%rbx)
cmovleq %r13, %r12
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/luigix25[P]SSLP/library/HashManager.cpp
// Function: HashManager::HashFinal()
char* HashManager::HashFinal(){
  unsigned int hash_size = EVP_MD_size(EVP_sha256());
  char *digest = new char [HASH_SIZE];

  if(!EVP_DigestFinal(mdctx, (unsigned char*) digest,&hash_size)){
    perror("Error in EVP_DigestFinal");
    return NULL;
  }

  return digest;

}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
callq 0x4760
movq %rax, %rdi
callq 0x4170
leaq 0xc(%rsp), %r15
movl %eax, (%r15)
pushq $0x20
popq %rdi
callq 0x4030
movq %rax, %rbx
movq (%r14), %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x4670
testl %eax, %eax
je 0x932d
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1683(%rip), %rdi      # 0xa9b7
callq 0x43a0
xorl %ebx, %ebx
jmp 0x9320
nop
// File: /workspace/github_cpp_makefile_star2_O2/luigix25[P]SSLP/library/Chunk.cpp
// Function: Chunk::clean()
void Chunk::clean(){
	if(plaintext != NULL && shouldFree){
		delete[] plaintext;
		plaintext = NULL;
		shouldFree = false;
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x93df
cmpb $0x1, (%rbx)
jne 0x93df
callq 0x45a0
andq $0x0, 0x8(%rbx)
movb $0x0, (%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/luigix25[P]SSLP/library/Chunk.cpp
// Function: EncryptedChunk::clean()
void EncryptedChunk::clean(){
	if(ciphertext != NULL && shouldFree){
		delete[] ciphertext;
		ciphertext = NULL;
		shouldFree = false;
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x9493
cmpb $0x1, (%rbx)
jne 0x9493
callq 0x45a0
andq $0x0, 0x8(%rbx)
movb $0x0, (%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH12_DynamicMemory/exercises/ex12_10.cc
// Function: main
int main(int argc, char const *argv[])
{
	shared_ptr<int> p(new int(42));

	cout << p.use_count() << endl;
	process(shared_ptr<int>(p));
	cout << p.use_count() << endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
pushq $0x4
popq %rdi
callq 0x1090
movl $0x2a, (%rax)
leaq -0x20(%rbp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x141c
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x12aa
movl 0x8(%rax), %eax
movslq %eax, %rsi
jmp 0x12ac
xorl %esi, %esi
leaq -0x18(%rbp), %rbx
movq 0x2d21(%rip), %rdi      # 0x3fd8
callq 0x1070
movq %rax, %rdi
callq 0x1050
leaq -0x30(%rbp), %r14
leaq -0x20(%rbp), %rsi
movq %r14, %rdi
callq 0x1340
movq %r14, %rdi
callq 0x122c
leaq -0x28(%rbp), %rdi
callq 0x138c
movq -0x18(%rbp), %rax
testq %rax, %rax
je 0x12f6
movl 0x8(%rax), %eax
movslq %eax, %rsi
jmp 0x12f8
xorl %esi, %esi
movq 0x2cd9(%rip), %rdi      # 0x3fd8
callq 0x1070
movq %rax, %rdi
callq 0x1050
movq %rbx, %rdi
callq 0x138c
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
leaq -0x28(%rbp), %rdi
callq 0x138c
jmp 0x1330
movq %rax, %r14
movq %rbx, %rdi
callq 0x138c
movq %r14, %rdi
callq 0x10e0
// File: /workspace/github_cpp_makefile_star2_O2/aempirei[P]Chat-Art/include/ansi.hh
// Function: ansi::esc(std::__cxx11::list<int, std::allocator<int>> const&, char)
std::string esc(const std::list<int>& args, char mode) {

		std::stringstream ss;
		auto iter = args.begin();

		ss << start;

		if(iter != args.end()) {
			ss << *iter;

			for(iter++; iter != args.end(); iter++) {
				ss << ';' << *iter;

			}
		}

		ss << mode;

		return ss.str();
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x2100
movq (%r14), %r13
leaq 0x10(%rsp), %r15
leaq 0x5c9c(%rip), %rsi      # 0x81d8
movq %r15, %rdi
callq 0x2170
cmpq %r14, %r13
je 0x257b
movl 0x10(%r13), %esi
movq %r15, %rdi
callq 0x22a0
pushq $0x3b
popq %r12
movq (%r13), %r13
cmpq %r14, %r13
je 0x257b
movq %r15, %rdi
movl %r12d, %esi
callq 0x21c0
movl 0x10(%r13), %esi
movq %rax, %rdi
callq 0x22a0
jmp 0x2559
movsbl %bpl, %esi
movq %r15, %rdi
callq 0x21c0
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x2260
movq %rsp, %rdi
callq 0x2120
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x25b3
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2120
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O2/aempirei[P]Chat-Art/include/geometry.hh
// Function: geometry::to_string[abi:cxx11]() const
std::string geometry::to_string() const {

	char buf[128];
	char modebuf[128];

	switch(mode) {

		case geometry::BGCOLOR: 
		case geometry::FGCOLOR: 

			snprintf(modebuf, sizeof(modebuf), " color %3d %3d %3d   # %s%s", color[0], color[1], color[2],
					base ? "bold " : "", ansi::color_name[code]
					);
			break;

		case geometry::SYMBOL:

			snprintf(modebuf, sizeof(modebuf), " ratio %2d %2d size %d %d   # (%c)",
					ratio, ratio_max - ratio,
					(int)size[1], (int)size[0], base + code
				);
			break;

		case geometry::NOP:
		default:
			*modebuf = '\0';
	}



	snprintf(buf, sizeof(buf), "mcb %2d %2d %2d%s", mode, code, base, modebuf);

	return std::string(buf);

}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
movq %rsi, %r14
movq %rdi, %rbx
movl 0x18(%rsi), %eax
leal -0x1(%rax), %ecx
cmpl $0x2, %ecx
jae 0x2652
movl 0x8(%r14), %ecx
movl 0xc(%r14), %r8d
movl 0x10(%r14), %r9d
cmpl $0x0, 0x20(%r14)
leaq 0x2daa(%rip), %rax      # 0x53cd
leaq 0x2a5c(%rip), %r10      # 0x5086
cmoveq %rax, %r10
movslq 0x1c(%r14), %r11
leaq 0x5b47(%rip), %r15      # 0x8180
leaq 0x2a2a(%rip), %rdx      # 0x506a
leaq 0x10(%rsp), %rdi
movl $0x80, %esi
xorl %eax, %eax
pushq (%r15,%r11,8)
jmp 0x2686
cmpl $0x3, %eax
jne 0x2691
movl 0x14(%r14), %ecx
pushq $0x3f
popq %r8
subl %ecx, %r8d
movl (%r14), %r10d
movl 0x4(%r14), %r9d
movl 0x1c(%r14), %r11d
addl 0x20(%r14), %r11d
leaq 0x2a14(%rip), %rdx      # 0x508c
leaq 0x10(%rsp), %rdi
movl $0x80, %esi
xorl %eax, %eax
pushq %r11
pushq %r10
callq 0x2270
popq %rcx
popq %rdx
jmp 0x2696
movb $0x0, 0x10(%rsp)
movl 0x18(%r14), %ecx
movl 0x1c(%r14), %r8d
movl 0x20(%r14), %r9d
subq $0x8, %rsp
leaq 0x18(%rsp), %r10
leaq 0x29fd(%rip), %rdx      # 0x50af
leaq 0x98(%rsp), %r14
movl $0x80, %esi
movq %r14, %rdi
xorl %eax, %eax
pushq %r10
callq 0x2270
popq %rcx
popq %rdx
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x394a
movq %rbx, %rax
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/aempirei[P]Chat-Art/include/pnm.hh
// Function: pnm::pnm(_IO_FILE*)
pnm::pnm(FILE *fp) {

	const unsigned int expected_mv = 255;

	unsigned int w;
	unsigned int h;
	unsigned int mv;

	if(fscanf(fp, "P6 %u %u %u", &w, &h, &mv) == 3) {

		int ch = fgetc(fp);

		if(isspace(ch) && mv == expected_mv) {

			data = new rgb_t[w * h];

			if(fread(data, sizeof(rgb_t), w * h, fp) == w * h) {
				width = w;
				height = h;
			} else {
				free();
			}
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x29b2(%rip), %rsi      # 0x50c1
leaq 0x8(%rsp), %rdx
leaq 0x4(%rsp), %rcx
leaq 0xc(%rsp), %r8
movq %r14, %rdi
xorl %eax, %eax
callq 0x22d0
cmpl $0x3, %eax
jne 0x2796
movq %r14, %rdi
callq 0x2250
movl %eax, %edi
callq 0x2060
testl %eax, %eax
je 0x2796
cmpl $0xff, 0xc(%rsp)
jne 0x2796
movl 0x4(%rsp), %r15d
imull 0x8(%rsp), %r15d
leaq (%r15,%r15,2), %rdi
callq 0x2030
movq %rax, 0x10(%rbx)
pushq $0x3
popq %rsi
movq %rax, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0x2220
movl 0x8(%rsp), %ecx
movl 0x4(%rsp), %edx
movl %edx, %esi
imull %ecx, %esi
cmpq %rsi, %rax
jne 0x278e
movq %rcx, (%rbx)
movq %rdx, 0x8(%rbx)
jmp 0x2796
movq %rbx, %rdi
callq 0x27a0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/aempirei[P]Chat-Art/include/pnm.hh
// Function: pnm::free()
bool pnm::free() {
	if(data != NULL) {
		delete data;
		data = NULL;
		return true;
	}
	return false;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x10(%rdi), %rbx
testq %rbx, %rbx
je 0x27bd
movq %rdi, %r14
movq %rbx, %rdi
callq 0x21e0
andq $0x0, 0x10(%r14)
testq %rbx, %rbx
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/aempirei[P]Chat-Art/include/tile.hh
// Function: tile::move(long, long)
const pos_t& tile::move(ssize_t lines, ssize_t columns) {

	pos[1] += lines * geo.size[1];
	pos[0] += columns * geo.size[0];

	sum(rgb_sum);
	mean(rgb_mean);
	stdev(rgb_stdev);

	set_color_lum();

	return pos;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
imull 0xc(%rdi), %esi
addl %esi, 0x30(%rdi)
leaq 0x2c(%rdi), %r14
imull 0x8(%rdi), %edx
addl %edx, 0x2c(%rdi)
leaq 0x40(%rdi), %rsi
callq 0x28aa
leaq 0x34(%rbx), %rsi
movq %rbx, %rdi
callq 0x2914
leaq 0x4c(%rbx), %rsi
movq %rbx, %rdi
callq 0x2942
movq %rbx, %rdi
callq 0x2a1a
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/aempirei[P]Chat-Art/include/tile.hh
// Function: tile::sum(int (&) [3]) const
const rgb_sum_t& tile::sum(rgb_sum_t& v) const {

	v[0] = v[1] = v[2] = 0;

	for(int y = 0; y < geo.size[1]; y++) {
		for(int x = 0; x < geo.size[0]; x++) {

			const rgb_t& w = *pixel(y,x);

			for(int i = 0; i < 3; i++)
				v[i] += w[i];
		}
	}

	return v;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
andl $0x0, 0x8(%rsi)
andq $0x0, (%rsi)
xorl %r15d, %r15d
movslq 0xc(%r14), %rax
cmpq %rax, %r15
jge 0x2904
xorl %r12d, %r12d
movslq 0x8(%r14), %rax
cmpq %rax, %r12
jge 0x28ff
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x2a6a
xorl %ecx, %ecx
cmpq $0x3, %rcx
je 0x28fa
movzbl (%rax,%rcx), %edx
addl %edx, (%rbx,%rcx,4)
incq %rcx
jmp 0x28e8
incq %r12
jmp 0x28cf
incq %r15
jmp 0x28c3
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/aempirei[P]Chat-Art/include/tile.hh
// Function: tile::stdev(int (&) [3]) const
const rgb_sum_t& tile::stdev(rgb_sum_t& v) const {

	v[0] = v[1] = v[2] = 0;

	for(int y = 0; y < geo.size[1]; y++) {
		for(int x = 0; x < geo.size[0]; x++) {

			const rgb_t& w = *pixel(y,x);

			for(int i = 0; i < 3; i++) {
				int32_t xx = w[i] - rgb_mean[i];
				v[i] += xx * xx;
			}
		}
	}

	for(int i = 0; i < 3; i++)
		v[i] = (int32_t)rint(sqrt((double)v[i] / n()));

	return v;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
andl $0x0, 0x8(%rsi)
andq $0x0, (%rsi)
xorl %r15d, %r15d
movslq 0xc(%r14), %rax
cmpq %rax, %r15
jge 0x29a4
xorl %r12d, %r12d
movslq 0x8(%r14), %rax
cmpq %rax, %r12
jge 0x299f
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x2a6a
xorl %ecx, %ecx
cmpq $0x3, %rcx
je 0x299a
movzbl (%rax,%rcx), %edx
subl 0x34(%r14,%rcx,4), %edx
imull %edx, %edx
addl %edx, (%rbx,%rcx,4)
incq %rcx
jmp 0x2980
incq %r12
jmp 0x2967
incq %r15
jmp 0x295b
xorl %r15d, %r15d
cmpq $0x3, %r15
je 0x2a0b
cvtsi2sdl (%rbx,%r15,4), %xmm0
movslq 0x8(%r14), %rax
movslq 0xc(%r14), %rcx
imulq %rax, %rcx
movq %rcx, %xmm1
punpckldq 0x2644(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x264c(%rip), %xmm1     # 0x5020
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
divsd %xmm2, %xmm0
ucomisd 0x2644(%rip), %xmm0     # 0x5030
jb 0x29f4
sqrtsd %xmm0, %xmm0
jmp 0x29f9
callq 0x2140
callq 0x21f0
cvttsd2si %xmm0, %eax
movl %eax, (%rbx,%r15,4)
incq %r15
jmp 0x29a7
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/aempirei[P]Chat-Art/include/tile.hh
// Function: tile::set_color_lum()
void tile::set_color_lum() {
	geo.ratio = 0;
	for(int i = 0; i < 3; i++) {
		uint8_t level = (uint8_t)(rgb_sum[i] / n()) >> geometry::ratio_shift;
		geo.color[i] = rgb_mean[i] & mean_mask;
		if(level > geo.ratio)
			geo.ratio = level;
	}
}

// Assembly:
andl $0x0, 0x1c(%rdi)
movslq 0x8(%rdi), %rax
movslq 0xc(%rdi), %rcx
imulq %rax, %rcx
pushq $-0xc
popq %rsi
testq %rsi, %rsi
je 0x2a5b
movslq 0x4c(%rdi,%rsi), %rax
xorl %edx, %edx
divq %rcx
shrl $0x2, %eax
movl 0x40(%rdi,%rsi), %edx
andl $-0x2, %edx
movl %edx, 0x1c(%rdi,%rsi)
andl $0x3f, %eax
cmpl 0x1c(%rdi), %eax
jle 0x2a55
movl %eax, 0x1c(%rdi)
addq $0x4, %rsi
jmp 0x2a2d
retq
// File: /workspace/github_cpp_makefile_star2_O2/aempirei[P]Chat-Art/calibration.cc
// Function: try_code(pnm const&, unsigned int, int, int, int)
bool try_code(const pnm& snapshot, code_t code, int x0, int y, int dx) {

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

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

		size_t x = x0 + column * dx;

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

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

		int bit = BIT_ISSET(code, column);

		if(c[bit] == NULL) {

			c[bit] = pixel;

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

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

	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, 0xc(%rsp)
movq %rdi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movslq %ecx, %rax
movq %rax, 0x20(%rsp)
movslq %r8d, %r12
movslq %edx, %r13
leaq (,%r13,2), %rbp
addq %r13, %rbp
leaq (%r12,%r12,2), %r15
xorl %ebx, %ebx
cmpq $0x20, %rbx
je 0x2d33
movq (%r14), %rax
cmpq %r13, %rax
jbe 0x2d33
imulq 0x20(%rsp), %rax
leaq (%rax,%rax,2), %rdi
addq 0x10(%r14), %rdi
addq %rbp, %rdi
xorl %eax, %eax
movl 0xc(%rsp), %ecx
btl %ebx, %ecx
setb %al
movq 0x10(%rsp,%rax,8), %rsi
testq %rsi, %rsi
je 0x2cfd
callq 0x3986
testb %al, %al
jne 0x2d28
jmp 0x2d33
movq %rdi, 0x10(%rsp,%rax,8)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
testq %rdi, %rdi
setne %al
testq %rsi, %rsi
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x2d28
callq 0x3986
testb %al, %al
jne 0x2d33
incq %rbx
addq %r12, %r13
addq %r15, %rbp
jmp 0x2cbd
cmpq $0x20, %rbx
setae %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/aempirei[P]Chat-Art/calibration.cc
// Function: find_code(pnm const&, int, unsigned int, int*, int*)
bool find_code(const pnm& snapshot, int y0, code_t code, pos_t pos, int *tile_width) {

	size_t max_tile_width = snapshot.width / code_sz;

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

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

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

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

				int x0 = column * dx + x_offset;

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

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

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

					*tile_width = dx;

					return true;
				}
			}
		}
	}

	return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, 0x8(%rsp)
movq %rcx, (%rsp)
movl %edx, %ebp
movq %rdi, %r15
movq (%rdi), %rax
shrq $0x5, %rax
movslq %esi, %r14
movl %eax, %r12d
movq %r14, 0x10(%rsp)
testl %r12d, %r12d
jle 0x2e11
movq (%r15), %rax
xorl %edx, %edx
divq %r12
movq %rdx, 0x20(%rsp)
xorl %r13d, %r13d
movq %rax, 0x18(%rsp)
leaq 0x1f(%r13), %rcx
cmpq %rax, %rcx
jae 0x2dd9
movl %r13d, %ebx
imull %r12d, %ebx
addl 0x20(%rsp), %ebx
cmpq 0x8(%r15), %r14
jae 0x2dca
movq %r15, %rdi
movl %ebp, %esi
movl %ebx, %edx
movl %r14d, %ecx
movl %r12d, %r8d
callq 0x2c81
incq %r14
testb %al, %al
je 0x2da9
jmp 0x2dde
incq %r13
movq 0x10(%rsp), %r14
movq 0x18(%rsp), %rax
jmp 0x2d95
decq %r12
jmp 0x2d77
decl %r14d
movl %ebx, %r13d
leal -0x1(%r13), %ebx
movq %r15, %rdi
movl %ebp, %esi
movl %ebx, %edx
movl %r14d, %ecx
movl %r12d, %r8d
callq 0x2c81
testb %al, %al
jne 0x2de1
movq (%rsp), %rax
movl %r13d, (%rax)
movl %r14d, 0x4(%rax)
movq 0x8(%rsp), %rax
movl %r12d, (%rax)
testl %r12d, %r12d
setg %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/aempirei[P]Chat-Art/calibration.cc
// Function: assign_tiles(std::vector<tile, std::allocator<tile>>&, int, geometry::mode_type, int)
void assign_tiles(tiles& ts, int line, geometry::mode_type mode, int base) {

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, 0x4(%rsp)
movl %edx, %ebp
movq %rdi, %r14
movslq %esi, %r15
xorl %r13d, %r13d
xorl %r12d, %r12d
movq (%r14), %rbx
movq 0x8(%r14), %rax
subq %rbx, %rax
cqto
pushq $0x58
popq %rcx
idivq %rcx
cmpq %rax, %r12
jae 0x2e85
leaq (%rbx,%r13), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x285c
movl %ebp, 0x20(%rbx,%r13)
movl %r12d, 0x24(%rbx,%r13)
movl 0x4(%rsp), %eax
movl %eax, 0x28(%rbx,%r13)
incq %r12
addq $0x58, %r13
jmp 0x2e43
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x90, %rsp
movq 0x4c4c(%rip), %rax      # 0x7fc8
movq (%rax), %rsi
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x26ee
xorps %xmm0, %xmm0
movaps %xmm0, 0x70(%rsp)
movaps %xmm0, 0x60(%rsp)
andq $0x0, 0x80(%rsp)
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
cmpq $0x0, 0x10(%rbx)
je 0x3454
cmpq $0x0, 0x20(%rsp)
je 0x3454
cmpq $0x0, 0x28(%rsp)
je 0x3454
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rcx
leaq 0xc(%rsp), %r8
xorl %esi, %esi
movl $0xa55faced, %edx       # imm = 0xA55FACED
callq 0x2d49
testb %al, %al
je 0x3454
movl 0x14(%rsp), %ebx
leal 0x1(%rbx), %esi
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rcx
leaq 0x8(%rsp), %r8
movl $0x1deadfed, %edx       # imm = 0x1DEADFED
callq 0x2d49
testb %al, %al
je 0x3454
movl 0xc(%rsp), %ecx
cmpl 0x8(%rsp), %ecx
jne 0x3454
movl 0x1c(%rsp), %eax
subl %ebx, %eax
movl 0x10(%rsp), %esi
pushq $0x7
popq %rdi
cltd
idivl %edi
cmpl 0x18(%rsp), %esi
jne 0x3454
testl %edx, %edx
jne 0x3454
leaq 0x38(%rsp), %rdx
movl %ecx, (%rdx)
movl %eax, 0x4(%rdx)
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
leaq 0x10(%rsp), %rcx
callq 0x301e
leaq 0x40(%rsp), %rdi
callq 0x3b48
leaq 0x20(%rsp), %rdi
callq 0x27a0
addq $0x90, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x3b48
leaq 0x20(%rsp), %rdi
callq 0x27a0
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x7
popq %r13
leaq 0x8(%rsp), %r14
movq 0x4b20(%rip), %r15      # 0x7fd0
pushq $0x20
popq %rbp
xorl %r12d, %r12d
cmpl $0x20, %r12d
je 0x34f5
btl %r12d, %ebx
movl %r13d, %esi
movl $0x0, %eax
cmovael %eax, %esi
movq %r14, %rdi
callq 0x25c6
movq %r15, %rdi
movq %r14, %rsi
callq 0x2170
movq %rax, %rdi
movl %ebp, %esi
callq 0x21c0
movq %r14, %rdi
callq 0x22e8
incl %r12d
jmp 0x34b6
movq 0x4ad4(%rip), %rdi      # 0x7fd0
leaq 0x4d15(%rip), %rsi      # 0x8218
callq 0x2170
movq %rax, %rdi
callq 0x20d0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x22e8
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14
movq 0x486d(%rip), %rbx      # 0x7ff0
leaq 0x1a6d(%rip), %rsi      # 0x51f7
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
movq %r14, %rsi
callq 0x2180
leaq 0x1a5c(%rip), %rsi      # 0x5200
movq %rax, %rdi
callq 0x2180
leaq 0x1a5a(%rip), %rsi      # 0x520d
movq %rbx, %rdi
callq 0x2180
leaq 0x1aa1(%rip), %rsi      # 0x5263
movq %rbx, %rdi
callq 0x2180
leaq 0x1ae6(%rip), %rsi      # 0x52b7
movq %rbx, %rdi
callq 0x2180
leaq 0x1b2b(%rip), %rsi      # 0x530b
movq %rbx, %rdi
callq 0x2180
leaq 0x1b6f(%rip), %rsi      # 0x535e
movq %rbx, %rdi
callq 0x2180
leaq 0x1bb5(%rip), %rsi      # 0x53b3
movq %rbx, %rdi
callq 0x2180
leaq 0x1bc1(%rip), %rsi      # 0x53ce
movq %rbx, %rdi
callq 0x2180
leaq 0x1be3(%rip), %rsi      # 0x53ff
movq %rbx, %rdi
callq 0x2180
leaq 0x1c11(%rip), %rsi      # 0x543c
movq %rbx, %rdi
callq 0x2180
leaq 0x1c19(%rip), %rsi      # 0x5453
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
movq %r14, %rsi
callq 0x2180
leaq 0x1c20(%rip), %rsi      # 0x5474
movq %rax, %rdi
callq 0x2180
leaq 0x1c34(%rip), %rsi      # 0x5497
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2180
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15d, %r15d
movb $0x1, %al
movl %eax, 0x4(%rsp)
leaq 0x1c28(%rip), %r14      # 0x54ba
pushq $0x1
popq %r13
xorl %r12d, %r12d
movl %r12d, %ecx
movl %ecx, %r12d
movl %ebp, %edi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2080
movl %r13d, %ecx
cmpl $0x64, %eax
je 0x389c
cmpl $0x70, %eax
jne 0x38c6
movl $0x0, 0x4(%rsp)
movl %r13d, %r15d
jmp 0x3899
cmpl $-0x1, %eax
jne 0x391b
cmpl %r15d, %r12d
jne 0x3932
movq 0x4719(%rip), %r14      # 0x7ff0
pushq $0xa
popq %rbp
movq %r14, %rdi
movl %ebp, %esi
callq 0x21c0
leaq 0x490d(%rip), %rsi      # 0x81f8
movq %rax, %rdi
callq 0x2170
leaq 0x1bc4(%rip), %rsi      # 0x54be
movq %r14, %rdi
callq 0x2180
leaq 0x490f(%rip), %rsi      # 0x8218
movq %r14, %rdi
callq 0x2170
movq %rax, %rdi
movl %ebp, %esi
callq 0x21c0
movq (%rbx), %rdi
callq 0x2210
movq %rax, %rdi
callq 0x3775
xorl %edi, %edi
callq 0x21d0
testl %r12d, %r12d
je 0x393c
callq 0x3534
testb $0x1, 0x4(%rsp)
jne 0x392b
callq 0x336d
jmp 0x392b
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rsi, %r14
movq %rdi, %rbx
movl %edx, %r15d
movq 0x8(%rsi), %rdx
movq %r15, %rsi
callq 0x7af6
xorl %r12d, %r12d
pushq $0x1
popq %r13
pushq $0x2
popq %rbp
cmpq %r12, %r15
je 0x6a13
movq %r14, %rdi
xorl %esi, %esi
callq 0x8638
movsd (%rax), %xmm0
movsd %xmm0, (%rsp)
movq %rbx, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x8614
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
movq %r14, %rdi
movq %r13, %rsi
callq 0x8638
movsd (%rax), %xmm0
movsd %xmm0, (%rsp)
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x8614
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
movq %r14, %rdi
movq %rbp, %rsi
callq 0x8638
movsd (%rax), %xmm0
movsd %xmm0, (%rsp)
movq %rbx, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x8614
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
incq %r12
jmp 0x6983
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
addq $0x10, %rbx
movq %rbx, %rdi
callq 0x8012
movq %r14, %rdi
callq 0x65d0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rsi, %r14
movq %rdi, 0x10(%rsp)
xorl %eax, %eax
leaq 0x40(%rsp), %r12
leaq 0x28(%rsp), %r13
movl %eax, %ebx
movq (%r14), %r15
cmpq %rbx, %r15
je 0x70b1
movq %r12, %rdi
movq 0x10(%rsp), %rsi
callq 0x8932
movq %r14, 0x18(%rsp)
movq %rbx, 0x20(%rsp)
movq %r13, %rdi
leaq 0x18(%rsp), %rsi
callq 0x7cfa
movq 0x8(%rsp), %rax
movq (%rax), %rax
movsd (%rax,%rbx,8), %xmm1
movq %r12, %rdi
movq %r13, %rsi
movsd (%rsp), %xmm0
callq 0x6f2a
movl %eax, %ebp
movq %r13, %rdi
callq 0x8012
movq %r12, %rdi
callq 0x8012
leal 0x1(%rbx), %eax
testb %bpl, %bpl
je 0x704c
cmpq %rbx, %r15
setne %al
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x8012
jmp 0x70d8
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x8012
movq %rbx, %rdi
callq 0x65d0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %rsi
leaq 0x20(%rsp), %r14
pushq $0x18
popq %rdx
movq %r14, %rdi
callq 0x64e0
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movsbl %bpl, %ebp
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x6620
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x77a2
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7efe
jmp 0x777a
movq %rsp, %rdi
callq 0x66d0
leaq 0x20(%rsp), %rdi
callq 0x62d0
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x66d0
leaq 0x20(%rsp), %rdi
callq 0x62d0
movq %rbx, %rdi
callq 0x65d0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %rsi
leaq 0x28(%rsp), %r14
pushq $0x18
popq %rdx
movq %r14, %rdi
callq 0x64e0
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movsbl %bpl, %ebp
leaq 0x8(%rsp), %r15
movq %rsp, %r12
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x6620
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x789a
movq 0x8(%rsp), %rdi
callq 0x63e0
movsd %xmm0, (%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x97f6
jmp 0x7863
leaq 0x8(%rsp), %rdi
callq 0x66d0
leaq 0x28(%rsp), %rdi
callq 0x62d0
movq %rbx, %rax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x78c3
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x66d0
leaq 0x28(%rsp), %rdi
callq 0x62d0
movq %rbx, %rdi
callq 0x65d0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x79b9
movq %rdi, %rbx
andl $0x0, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x8(%rdi), %rcx
movq %rcx, 0x18(%rdi)
movq %rcx, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
xorl %r13d, %r13d
movl %r13d, %r13d
subq %rsi, %rax
sarq $0x5, %rax
cmpq %r13, %rax
je 0x79a7
movq (%r14), %r12
movq %r13, %rbp
shlq $0x5, %rbp
addq %rbp, %rsi
movq %rbx, %rdi
callq 0x7f4c
addq %rbp, %r12
movq %rax, %rdi
movq %r12, %rsi
callq 0x6200
incl %r13d
movq (%r15), %rsi
movq 0x8(%r15), %rax
jmp 0x7969
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x61e0
movq %rax, %rbx
leaq 0x18707(%rip), %rsi     # 0x200d2
movq %rax, %rdi
callq 0x6170
movq 0x2a616(%rip), %rsi     # 0x31ff0
movq 0x2a587(%rip), %rdx     # 0x31f68
movq %rbx, %rdi
callq 0x6580
movq %rax, %r14
movq %rbx, %rdi
callq 0x62b0
jmp 0x7a01
movq %rax, %r14
movq %rbx, %rdi
callq 0x8034
movq %r14, %rdi
callq 0x65d0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rdx, %r14
movq %rdi, %rbx
movl %esi, 0x4(%rsp)
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x6410
leaq 0x186c4(%rip), %rsi     # 0x200f7
movq %r15, %rdi
callq 0x6330
movq %rax, %r15
leaq 0x8(%rsp), %rdi
leaq 0x4(%rsp), %rsi
callq 0x7fb2
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x6320
leaq 0x186aa(%rip), %rsi     # 0x2010b
movq %rax, %rdi
callq 0x6330
movq %rax, %rdi
movq %r14, %rsi
callq 0x6320
movq %rax, %rdi
callq 0x61d0
leaq 0x8(%rsp), %rdi
callq 0x66d0
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0x64d0
leaq 0x28(%rsp), %rdi
callq 0x60d0
movq %rbx, %rax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %r15
retq
jmp 0x7aaf
movq %rax, %rbx
jmp 0x7ac1
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x66d0
leaq 0x28(%rsp), %rdi
callq 0x60d0
movq %rbx, %rdi
callq 0x65d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x48(%rdi), %rax
movq %rax, 0x38(%rdi)
andq $0x0, 0x40(%rdi)
leaq 0x38(%rdi), %r14
movb $0x0, 0x48(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rdi)
leaq 0x1637a(%rip), %rsi     # 0x20670
movq %r14, %rdi
callq 0x6660
andl $0x0, 0x5c(%rbx)
movb $0x0, 0x58(%rbx)
andq $0x0, (%rbx)
andl $0x0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x66d0
movq %rbx, %rdi
callq 0x65d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xa3f6
testb %al, %al
je 0xa6b1
leaq 0x28(%r15), %r14
leaq 0x20(%rsp), %rsi
movq %r14, (%rsi)
imulq $0x60, 0x75328(%r15), %rax
addq %r15, %rax
addq $0x28, %rax
leaq 0x18(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rcx
callq 0xb19a
movq (%r12), %rax
movq %rax, (%rsp)
imulq $0x60, 0x75328(%r15), %rcx
addq %r15, %rcx
addq $0x28, %rcx
cmpq %rcx, %rax
je 0xa68d
movq %rsp, %rdi
callq 0xb1c4
movq %rbx, %rdi
movq %rax, %rsi
callq 0xa468
testb %al, %al
je 0xa6ca
movq (%rsp), %rax
leaq 0x10(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rcx
callq 0xb73c
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x1600e(%rip), %rdi     # 0x206c6
leaq 0x1601d(%rip), %rsi     # 0x206dc
leaq 0x16029(%rip), %rcx     # 0x206ef
pushq $0x1b
jmp 0xa6e1
leaq 0x1603d(%rip), %rdi     # 0x2070e
leaq 0x16004(%rip), %rsi     # 0x206dc
leaq 0x16010(%rip), %rcx     # 0x206ef
pushq $0x1e
popq %rdx
callq 0x6250
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
subq $0x38, %rsp
movq %rsi, %r14
movl %ecx, %esi
subl %edx, %esi
jb 0xa8dc
movl %ecx, %eax
movq %rax, 0x18(%rsp)
cmpq %rax, 0x75328(%r14)
jbe 0xa8f5
movl %edx, %ebp
movq %rdi, %rbx
addq $0x28, %r14
incl %esi
pushq $0x3
popq %rdx
callq 0x7af6
leaq 0x28(%rsp), %r15
movq %r14, 0x10(%rsp)
movq %r14, (%r15)
movl %ebp, %edx
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0xb224
xorl %r14d, %r14d
leaq 0x30(%rsp), %rbp
pushq $0x1
popq %r13
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
movq %rbp, %rdi
leaq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0xb224
movq %r15, %r12
movq %r15, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0xb224
movq 0x8(%rsp), %rdi
cmpq 0x28(%rsp), %rdi
je 0xa8ca
callq 0xa3d6
movsd %xmm0, (%rsp)
movl %r14d, %r15d
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x8614
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
movq 0x8(%rsp), %rdi
callq 0xa3dc
movsd %xmm0, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x8614
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
movq 0x8(%rsp), %rdi
callq 0xa3e2
movsd %xmm0, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
pushq $0x2
popq %rdx
callq 0x8614
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
incl %r14d
movq %r12, %r15
movq %r12, %rdi
leaq 0x8(%rsp), %rsi
xorl %edx, %edx
callq 0xb1ee
jmp 0xa804
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x15e50(%rip), %rdi     # 0x20733
leaq 0x15df2(%rip), %rsi     # 0x206dc
leaq 0x15e55(%rip), %rcx     # 0x20746
pushq $0x3b
jmp 0xa90c
leaq 0x15e86(%rip), %rdi     # 0x20782
leaq 0x15dd9(%rip), %rsi     # 0x206dc
leaq 0x15e3c(%rip), %rcx     # 0x20746
pushq $0x3c
popq %rdx
callq 0x6250
movq %rax, %r14
addq $0x10, %rbx
movq %rbx, %rdi
callq 0x8012
movq %r14, %rdi
callq 0x65d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x28, %rsp
xorpd %xmm3, %xmm3
ucomisd %xmm3, %xmm0
jb 0xaab9
movsd 0x15601(%rip), %xmm3    # 0x20008
ucomisd %xmm0, %xmm3
jb 0xaab9
xorpd %xmm4, %xmm4
ucomisd %xmm4, %xmm1
jb 0xaad2
ucomisd %xmm1, %xmm3
jb 0xaad2
ucomisd %xmm4, %xmm2
jb 0xaaeb
ucomisd %xmm2, %xmm3
jb 0xaaeb
movq %rdi, %rbx
leaq 0x28(%rdi), %r12
leaq 0x18(%rsp), %r14
movq %r12, (%r14)
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x14(%rsp)
cvtsd2ss %xmm1, %xmm0
movss %xmm0, 0x10(%rsp)
cvtsd2ss %xmm2, %xmm0
movss %xmm0, 0xc(%rsp)
leaq 0x20(%rsp), %r15
movq %r12, %rdi
imulq $0x60, 0x75328(%rbx), %rax
addq %r12, %rax
cmpq %rax, %rdi
je 0xaaad
movss 0x14(%rsp), %xmm0
movss 0x10(%rsp), %xmm1
movss 0xc(%rsp), %xmm2
callq 0xa40c
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xb1ee
movq 0x18(%rsp), %rdi
jmp 0xaa72
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x15cdb(%rip), %rdi     # 0x2079b
leaq 0x15c15(%rip), %rsi     # 0x206dc
leaq 0x15cdf(%rip), %rcx     # 0x207ad
pushq $0x56
jmp 0xab02
leaq 0x15d06(%rip), %rdi     # 0x207df
leaq 0x15bfc(%rip), %rsi     # 0x206dc
leaq 0x15cc6(%rip), %rcx     # 0x207ad
pushq $0x57
jmp 0xab02
leaq 0x15cff(%rip), %rdi     # 0x207f1
leaq 0x15be3(%rip), %rsi     # 0x206dc
leaq 0x15cad(%rip), %rcx     # 0x207ad
pushq $0x58
popq %rdx
callq 0x6250
// File: /workspace/github_cpp_makefile_star2_O2/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 $0xb8, %rsp
movsd %xmm0, (%rsp)
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x50(%rsp), %rdi
callq 0xa92a
leaq 0x38(%rsp), %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0xa92a
incl %r14d
decl %ebp
leaq 0x90(%rsp), %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
callq 0xa79a
leaq 0x20(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x8932
leaq 0x8(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x8932
leaq 0x68(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x7eea
leaq 0x20(%rsp), %rsi
leaq 0x8(%rsp), %rdx
leaq 0x68(%rsp), %rcx
movq %rbx, %rdi
movsd (%rsp), %xmm0
callq 0x6a77
leaq 0x78(%rsp), %rdi
callq 0x8012
leaq 0x8(%rsp), %rdi
callq 0x8012
leaq 0x20(%rsp), %rdi
callq 0x8012
leaq 0xa0(%rsp), %rdi
callq 0x8012
leaq 0x38(%rsp), %rdi
callq 0x8012
leaq 0x50(%rsp), %rdi
callq 0x8012
movq %rbx, %rax
addq $0xb8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0x8012
jmp 0xac06
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x8012
jmp 0xac15
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x8012
jmp 0xac24
movq %rax, %rbx
leaq 0xa0(%rsp), %rdi
callq 0x8012
jmp 0xac36
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x8012
leaq 0x50(%rsp), %rdi
callq 0x8012
movq %rbx, %rdi
callq 0x65d0
movq %rax, %rbx
jmp 0xac40
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0xc0, %rsp
movsd %xmm0, 0x8(%rsp)
movl %ecx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x58(%rsp), %rdi
callq 0xa92a
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0xa92a
movl 0x75328(%r14), %ecx
decl %ecx
leaq 0x98(%rsp), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xa79a
leaq 0x28(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x8932
leaq 0x10(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x8932
leaq 0x70(%rsp), %rdi
leaq 0x98(%rsp), %rsi
callq 0x7eea
leaq 0x28(%rsp), %rsi
leaq 0x10(%rsp), %rdx
leaq 0x70(%rsp), %rcx
movq %rbx, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x6a77
leaq 0x80(%rsp), %rdi
callq 0x8012
leaq 0x10(%rsp), %rdi
callq 0x8012
leaq 0x28(%rsp), %rdi
callq 0x8012
leaq 0xa8(%rsp), %rdi
callq 0x8012
leaq 0x40(%rsp), %rdi
callq 0x8012
leaq 0x58(%rsp), %rdi
callq 0x8012
movq %rbx, %rax
addq $0xc0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0x8012
jmp 0xad58
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x8012
jmp 0xad67
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x8012
jmp 0xad76
movq %rax, %rbx
leaq 0xa8(%rsp), %rdi
callq 0x8012
jmp 0xad88
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x8012
leaq 0x58(%rsp), %rdi
callq 0x8012
movq %rbx, %rdi
callq 0x65d0
movq %rax, %rbx
jmp 0xad92
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xa75e
leal -0x3(%rax), %esi
xorl %edi, %edi
movq %r12, %rdx
callq 0x6ebd
movl %eax, %r15d
leal 0x2(%r15), %ebp
movq %r14, %rdi
callq 0xa75e
leal -0x1(%rax), %esi
movl %ebp, %edi
movq %r12, %rdx
callq 0x6ebd
movl %eax, %ebp
movsd 0x1536a(%rip), %xmm1    # 0x211e8
xorps %xmm0, %xmm0
movq %r12, %rdi
callq 0x6e93
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movl %r15d, %edx
movl %ebp, %ecx
callq 0xab08
movq %r14, (%rbx)
leaq 0x10(%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx)
movups %xmm0, 0x10(%rbx)
incl %r15d
movl %r15d, 0x8(%rbx)
decl %ebp
movl %ebp, 0xc(%rbx)
movq %r12, %rsi
callq 0xb528
leaq 0x18(%rsp), %rdi
callq 0x8012
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
addq $0x20, %rbx
movq %rbx, %rdi
callq 0x8012
leaq 0x18(%rsp), %rdi
callq 0x8012
movq %r14, %rdi
callq 0x65d0
nop