LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/gjoni[P]iPot/src/Chain.cpp
// Function: Chain::ReadAtomRecordPQR(char*)
AtomRecord Chain::ReadAtomRecordPQR(char* str) {

	AtomRecord A;

	/*
	 * reading PDB ATOM string in the reverse direction
	 */

	/* fields missing from PQR files */
	A.segId[0] = '\0';
	A.element[0] = '\0';
	A.charge[0] = '\0';

	/* save atom charge and radius in Temperature factor
	 * and Occupancy respectively */
	str[80] = '\0';
	sscanf(str + 54, "%lf %lf", &(A.q), &(A.r));
	A.temp = A.q;
	A.occup = A.r;

	/* Z coordinate */
	str[54] = '\0';
	A.z = atof(str + 46);

	/* Y coordinate */
	str[46] = '\0';
	A.y = atof(str + 38);

	/* X coordinate */
	str[38] = '\0';
	A.x = atof(str + 30);

	/* Code for insertion of residues */
	A.insCode = str[26];

	/* Residue sequence number */
	str[26] = '\0';
	A.resNum = atoi(str + 22);

	/* Chain identifier */
	A.chainId = str[21];

	/* Residue name */
	str[20] = '\0';
	//strncpy(A.resName, str + 17, 4);
	sscanf(str + 17, "%s", A.resName); /* no spaces in residue name */

	/* Alternate location indicator */
	A.altLoc = str[16];

	/* Atom name */
	str[16] = '\0';
	//strncpy(A.atomName, str + 12, 5);
	sscanf(str + 12, "%s", A.atomName);

	/* Atom serial number */
	str[11] = '\0';
	A.atomNum = atoi(str + 6);

	A.charge[0] = A.element[0] = '\0';

	return A;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
xorl %ebp, %ebp
movb %bpl, 0x40(%rdi)
movb %bpl, 0x45(%rdi)
movb %bpl, 0x48(%rdi)
movb %bpl, 0x50(%rdx)
leaq 0x36(%rdx), %rdi
leaq 0x50(%rbx), %rdx
leaq 0x58(%rbx), %rcx
leaq 0xc1bf(%rip), %rsi      # 0x1abcd
xorl %eax, %eax
callq 0x2200
movsd 0x50(%rbx), %xmm0
movsd 0x58(%rbx), %xmm1
movsd %xmm0, 0x38(%rbx)
movsd %xmm1, 0x30(%rbx)
movb %bpl, 0x36(%r14)
leaq 0x2e(%r14), %rdi
callq 0x22b0
movsd %xmm0, 0x28(%rbx)
movb %bpl, 0x2e(%r14)
leaq 0x26(%r14), %rdi
callq 0x22b0
movsd %xmm0, 0x20(%rbx)
movb %bpl, 0x26(%r14)
leaq 0x1e(%r14), %rdi
callq 0x22b0
movsd %xmm0, 0x18(%rbx)
movb 0x1a(%r14), %al
movb %al, 0x14(%rbx)
movb %bpl, 0x1a(%r14)
leaq 0x16(%r14), %rdi
callq 0x2340
movl %eax, 0x10(%rbx)
movb 0x15(%r14), %al
movb %al, 0xe(%rbx)
movb %bpl, 0x14(%r14)
leaq 0x11(%r14), %rdi
leaq 0xa(%rbx), %rdx
leaq 0xe437(%rip), %r15      # 0x1cec7
movq %r15, %rsi
xorl %eax, %eax
callq 0x2200
movb 0x10(%r14), %al
movb %al, 0x9(%rbx)
movb %bpl, 0x10(%r14)
leaq 0xc(%r14), %rdi
leaq 0x4(%rbx), %rdx
movq %r15, %rsi
xorl %eax, %eax
callq 0x2200
movb %bpl, 0xb(%r14)
addq $0x6, %r14
movq %r14, %rdi
callq 0x2340
movl %eax, (%rbx)
movb %bpl, 0x45(%rbx)
movb %bpl, 0x48(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/gjoni[P]iPot/src/Chain.cpp
// Function: Chain::SetResMap()
void Chain::SetResMap() {

	resmap.clear();
	for (int i = 0; i < nRes; i++) {
		Residue *R = residue + i;
		resmap[ { R->seqNum, R->insCode }] = R;
	}

}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x10966
cmpl $0x0, 0x48(%rbx)
jle 0xf175
xorl %r15d, %r15d
leaq 0x8(%rsp), %r14
xorl %r12d, %r12d
movq 0x40(%rbx), %rax
leaq (%rax,%r15), %r13
movl 0x8(%rax,%r15), %ecx
movl %ecx, 0x8(%rsp)
movb 0xc(%rax,%r15), %al
movb %al, 0xc(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x100ec
movq %r13, (%rax)
incq %r12
movslq 0x48(%rbx), %rax
addq $0x188, %r15            # imm = 0x188
cmpq %rax, %r12
jl 0xf13a
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/gjoni[P]iPot/src/Chain.cpp
// Function: Chain::Chain(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>>>> const&)
Chain::Chain(const std::vector<std::string> &atoms_str) :
		atom(NULL), nAtoms(0), residue(NULL), nRes(0), kd(NULL), kdCA(
		NULL), kdCent(NULL), ca_trace(NULL) {

	std::vector<AtomRecord> atomRecordVector(atoms_str.size());
	char buf[81];
	for (unsigned i = 0; i < atoms_str.size(); i++) {
		strcpy(buf, atoms_str[i].c_str());
		atomRecordVector[i] = ReadAtomRecord(buf);
	}

	InitChain(atomRecordVector);

	SetResMap();

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
xorl %ecx, %ecx
movl %ecx, 0x8(%rdi)
movq %rcx, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rcx, 0x40(%rdi)
movl %ecx, 0x48(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rdi)
movl %ecx, 0x38(%rdi)
movups %xmm0, 0x50(%rdi)
movups %xmm0, 0x60(%rdi)
movq 0x8(%rsi), %rsi
subq (%r14), %rsi
sarq $0x5, %rsi
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x1001e
movq (%r14), %rax
cmpq %rax, 0x8(%r14)
je 0xf256
movl $0x1, %ebp
xorl %r13d, %r13d
leaq 0x80(%rsp), %r15
leaq 0x20(%rsp), %r12
movq %r13, %rcx
shlq $0x5, %rcx
movq (%rax,%rcx), %rsi
movq %r15, %rdi
callq 0x21f0
movq %r12, %rdi
movq %r15, %rdx
callq 0xeae0
leaq (,%r13,2), %rdi
addq %r13, %rdi
shlq $0x5, %rdi
addq 0x8(%rsp), %rdi
movl $0xc, %ecx
movq %r12, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq (%r14), %rax
movq 0x8(%r14), %rcx
movl %ebp, %r13d
subq %rax, %rcx
sarq $0x5, %rcx
incl %ebp
cmpq %r13, %rcx
ja 0xf201
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xec4c
movq %rbx, %rdi
callq 0xf114
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xf282
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x2230
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0xf2b3
movq %rax, %r14
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xf2b3
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x2230
movq %rbx, %rdi
callq 0x1017a
movq %r14, %rdi
callq 0x2390
nop
// File: /workspace/github_cpp_makefile_star2_O1/gjoni[P]iPot/src/Chain.cpp
// Function: Chain::SetAtomPointers()
void Chain::SetAtomPointers() {

	int idx = 0;
	for (int i = 0; i < nRes; i++) {
		for (int j = 0; j < residue[i].nAtoms; j++) {
			atom[idx] = &(residue[i].atom[j]);
			idx++;
		}
	}

}

// Assembly:
movslq 0x48(%rdi), %rax
testq %rax, %rax
jle 0xf326
pushq %rbx
xorl %ecx, %ecx
xorl %edx, %edx
movq 0x40(%rdi), %r11
imulq $0x188, %rcx, %rsi      # imm = 0x188
cmpl $0x0, 0x18(%r11,%rsi)
jle 0xf31d
movslq %edx, %r8
shlq $0x3, %r8
xorl %r10d, %r10d
xorl %r9d, %r9d
movq 0x10(%r11,%rsi), %r11
addq %r10, %r11
movq 0x30(%rdi), %rbx
addq %r8, %rbx
movq %r11, (%rbx,%r9,8)
incq %r9
movq 0x40(%rdi), %r11
movslq 0x18(%r11,%rsi), %rbx
addq $0x60, %r10
cmpq %rbx, %r9
jl 0xf2f2
addl %r9d, %edx
incq %rcx
cmpq %rax, %rcx
jne 0xf2d2
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/gjoni[P]iPot/src/Chain.cpp
// Function: Chain::SetKD()
void Chain::SetKD() {

	if (kd != NULL) {
		kd_free(kd);
	}

	if (kdCA != NULL) {
		kd_free(kdCA);
	}

	if (kdCent != NULL) {
		kd_free(kdCent);
	}

	kd = kd_create(3);
	kdCA = kd_create(3);
	kdCent = kd_create(3);

	Atom *A;
	int idx = 0;
	for (int i = 0; i < nRes; i++) {

		/* kd */
		for (int j = 0; j < residue[i].nAtoms; j++) {
			A = &(residue[i].atom[j]);

			kd_insert3(kd, A->x, A->y, A->z, atom + idx);
			idx++;
		}

		A = residue[i].CA;
		if (A != NULL) {

			/* kdCA */
			kd_insert3(kdCA, A->x, A->y, A->z, A);

			/* kdCent - GLY */
			if (residue[i].type == 7 /* GLY */) {
				kd_insert3(kdCent, A->x, A->y, A->z, residue[i].atom);
			}

		} else {
			//printf("WARNING: Missing CA atom in %s-%d\n", residues[i].name,
			//		residues[i].seqNum);
		}

		/* kdCent - all other residues */
		if (residue[i].type != 7) {
			kd_insert(kdCent, residue[i].centroid, residue[i].atom);
		}

	}

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x50(%rdi), %rdi
testq %rdi, %rdi
je 0xf344
callq 0x1770d
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0xf352
callq 0x1770d
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0xf360
callq 0x1770d
movl $0x3, %edi
callq 0x176e4
movq %rax, 0x50(%rbx)
movl $0x3, %edi
callq 0x176e4
movq %rax, 0x58(%rbx)
movl $0x3, %edi
callq 0x176e4
movq %rax, 0x60(%rbx)
cmpl $0x0, 0x48(%rbx)
jle 0xf490
xorl %r15d, %r15d
xorl %ebp, %ebp
movq 0x40(%rbx), %rax
imulq $0x188, %r15, %r12      # imm = 0x188
cmpl $0x0, 0x18(%rax,%r12)
jle 0xf409
movl %ebp, 0x4(%rsp)
movslq %ebp, %r14
shlq $0x3, %r14
movl $0x4, %r13d
xorl %ebp, %ebp
movq 0x10(%rax,%r12), %rax
movq 0x50(%rbx), %rdi
movsd -0x10(%rax,%r13,8), %xmm0
movsd -0x8(%rax,%r13,8), %xmm1
movsd (%rax,%r13,8), %xmm2
movq 0x30(%rbx), %rsi
addq %r14, %rsi
callq 0x17a69
incq %rbp
movq 0x40(%rbx), %rax
movslq 0x18(%rax,%r12), %rcx
addq $0x8, %r14
addq $0xc, %r13
cmpq %rcx, %rbp
jl 0xf3bf
movl 0x4(%rsp), %ecx
addl %ebp, %ecx
movl %ecx, %ebp
movq 0x168(%rax,%r12), %r14
testq %r14, %r14
je 0xf461
movq 0x58(%rbx), %rdi
movsd 0x10(%r14), %xmm0
movsd 0x18(%r14), %xmm1
movsd 0x20(%r14), %xmm2
movq %r14, %rsi
callq 0x17a69
movq 0x40(%rbx), %rax
cmpb $0x7, (%rax,%r12)
jne 0xf461
addq %r12, %rax
movq 0x60(%rbx), %rdi
movsd 0x10(%r14), %xmm0
movsd 0x18(%r14), %xmm1
movsd 0x20(%r14), %xmm2
movq 0x10(%rax), %rsi
callq 0x17a69
movq 0x40(%rbx), %rsi
cmpb $0x7, (%rsi,%r12)
je 0xf480
addq %r12, %rsi
movq 0x60(%rbx), %rdi
movq 0x10(%rsi), %rdx
addq $0x20, %rsi
callq 0x177c2
incq %r15
movslq 0x48(%rbx), %rax
cmpq %rax, %r15
jl 0xf399
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/gjoni[P]iPot/src/Chain.cpp
// Function: Chain::Chain(Chain const&)
Chain::Chain(const Chain & source) :
		resmap(source.resmap), atom(NULL), nAtoms(source.nAtoms), residue(NULL), nRes(
				source.nRes), kd(
		NULL), kdCA(NULL), kdCent(NULL), ca_trace(
		NULL) {

	/* copy residues */
	residue = new Residue[nRes];
	for (int i = 0; i < nRes; i++) {
		residue[i] = source.residue[i];
	}

	/* set pointers to atoms */
	atom = new Atom*[nAtoms];

	SetAtomPointers();

	SetKD();

	/* initialize CA trace */
	ca_trace = (double**) malloc(nRes * sizeof(double*));
	for (int i = 0; i < nRes; i++) {
		ca_trace[i] = (double*) malloc(3 * sizeof(double));
		memcpy(ca_trace[i], source.ca_trace[i], 3 * sizeof(double));
	}

	SetResMap();

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x101ca
xorl %eax, %eax
movq %rax, 0x30(%rbx)
movl 0x38(%r14), %ecx
movl %ecx, 0x38(%rbx)
movq %rax, 0x40(%rbx)
movslq 0x48(%r14), %r13
movl $0x188, %ecx            # imm = 0x188
movq %r13, %rax
mulq %rcx
movq %rax, %r15
seto %al
addq $0x8, %r15
movq $-0x1, %rcx
cmovbq %rcx, %r15
testb %al, %al
cmovneq %rcx, %r15
movl %r13d, 0x48(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rbx)
movups %xmm0, 0x60(%rbx)
movq %r15, %rdi
callq 0x2030
movq %r13, (%rax)
movq %rax, 0x8(%rsp)
addq $0x8, %rax
movq %rax, 0x10(%rsp)
testl %r13d, %r13d
je 0xf54a
imulq $-0x188, %r13, %r12     # imm = 0xFE78
xorl %ebp, %ebp
movq 0x10(%rsp), %r13
movq %r13, %rdi
callq 0x13cd0
addq $-0x188, %rbp           # imm = 0xFE78
addq $0x188, %r13            # imm = 0x188
cmpq %rbp, %r12
jne 0xf52f
movq 0x10(%rsp), %rax
movq %rax, 0x40(%rbx)
cmpl $0x0, 0x48(%rbx)
jle 0xf585
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x40(%r14), %rsi
addq %r15, %rsi
movq 0x40(%rbx), %rdi
addq %r15, %rdi
callq 0x14ad0
incq %r12
movslq 0x48(%rbx), %rax
addq $0x188, %r15            # imm = 0x188
cmpq %rax, %r12
jl 0xf55f
movslq 0x38(%rbx), %rax
leaq (,%rax,8), %rcx
testq %rax, %rax
movq $-0x1, %rdi
cmovnsq %rcx, %rdi
callq 0x2030
movq %rax, 0x30(%rbx)
movq %rbx, %rdi
callq 0xf2c4
movq %rbx, %rdi
callq 0xf328
movslq 0x48(%rbx), %r15
leaq (,%r15,8), %rdi
callq 0x22d0
movq %rax, 0x68(%rbx)
testq %r15, %r15
jle 0xf611
xorl %r15d, %r15d
movl $0x18, %edi
callq 0x22d0
movq 0x68(%rbx), %rcx
movq %rax, (%rcx,%r15,8)
movq 0x68(%rbx), %rax
movq (%rax,%r15,8), %rax
movq 0x68(%r14), %rcx
movq (%rcx,%r15,8), %rcx
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movups (%rcx), %xmm0
movups %xmm0, (%rax)
incq %r15
movslq 0x48(%rbx), %rax
cmpq %rax, %r15
jl 0xf5d5
movq %rbx, %rdi
callq 0xf114
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xf62a
movq %rax, %r14
jmp 0xf665
movq %rax, %r14
testq %rbp, %rbp
je 0xf658
negq %rbp
movq 0x8(%rsp), %r12
addq $-0x180, %r12           # imm = 0xFE80
leaq (%r12,%rbp), %rdi
callq 0x14a50
addq $-0x188, %rbp           # imm = 0xFE78
jne 0xf646
movq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x23d0
movq %rbx, %rdi
callq 0x1017a
movq %r14, %rdi
callq 0x2390
nop
// File: /workspace/github_cpp_makefile_star2_O1/gjoni[P]iPot/src/Chain.cpp
// Function: Chain::~Chain()
Chain::~Chain() {

	delete[] atom;
	atom = NULL;

	delete[] residue;
	residue = NULL;

	if (kd != NULL) {
		kd_free(kd);
	}

	if (kdCA != NULL) {
		kd_free(kdCA);
	}

	if (kdCent != NULL) {
		kd_free(kdCent);
	}

	if (ca_trace != NULL) {
		for (int i = 0; i < nRes; i++) {
			free(ca_trace[i]);
		}
		free(ca_trace);
	}

}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
testq %rdi, %rdi
je 0xf690
callq 0x22c0
movq $0x0, 0x30(%rbx)
movq 0x40(%rbx), %r15
testq %r15, %r15
je 0xf6e1
leaq -0x8(%r15), %r14
movq -0x8(%r15), %r12
testq %r12, %r12
je 0xf6ce
addq $-0x188, %r15           # imm = 0xFE78
imulq $0x188, %r12, %r13      # imm = 0x188
leaq (%r15,%r13), %rdi
callq 0x14a50
addq $-0x188, %r13           # imm = 0xFE78
jne 0xf6bc
imulq $0x188, %r12, %rsi      # imm = 0x188
addq $0x8, %rsi
movq %r14, %rdi
callq 0x23d0
movq $0x0, 0x40(%rbx)
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0xf6f7
callq 0x1770d
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0xf705
callq 0x1770d
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0xf713
callq 0x1770d
cmpq $0x0, 0x68(%rbx)
je 0xf745
cmpl $0x0, 0x48(%rbx)
jle 0xf73c
xorl %r14d, %r14d
movq 0x68(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x2270
incq %r14
movslq 0x48(%rbx), %rax
cmpq %rax, %r14
jl 0xf723
movq 0x68(%rbx), %rdi
callq 0x2270
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1017a
movq %rax, %rdi
callq 0x100e1
// File: /workspace/github_cpp_makefile_star2_O1/gjoni[P]iPot/src/Chain.cpp
// Function: Chain::SetTermini()
void Chain::SetTermini() {

	/* first residue is N-terminal */
	residue[0].ntFlag = true;

	/* last residue is C-terminal */
	residue[nRes - 1].ctFlag = true;

	/* check residues in between */
	double x, y, z, d;
	for (int i = 1; i < nRes; i++) {
		if (residue[i - 1].CA != NULL && residue[i].CA != NULL) {
			x = residue[i - 1].CA->x - residue[i].CA->x;
			y = residue[i - 1].CA->y - residue[i].CA->y;
			z = residue[i - 1].CA->z - residue[i].CA->z;
			d = sqrt(x * x + y * y + z * z);
			if (d > 4.25) { /* as in TM-align */
				residue[i - 1].ctFlag = true;
				residue[i].ntFlag = true;
			}
		}
	}

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x40(%rdi), %rax
movb $0x1, %bpl
movb %bpl, 0x158(%rax)
movslq 0x48(%rdi), %rcx
imulq $0x188, %rcx, %rdx      # imm = 0x188
movb %bpl, -0x2f(%rax,%rdx)
cmpq $0x2, %rcx
jl 0xfa8b
movq %rdi, %rbx
movl $0x1, %r14d
xorl %r15d, %r15d
xorpd %xmm3, %xmm3
movsd 0x9813(%rip), %xmm4     # 0x19200
movq 0x40(%rbx), %rcx
movq 0x168(%rcx,%r15), %rax
testq %rax, %rax
je 0xfa74
movq 0x2f0(%rcx,%r15), %rcx
testq %rcx, %rcx
je 0xfa74
movsd 0x10(%rax), %xmm1
movsd 0x18(%rax), %xmm2
subsd 0x10(%rcx), %xmm1
subsd 0x18(%rcx), %xmm2
movsd 0x20(%rax), %xmm0
subsd 0x20(%rcx), %xmm0
mulsd %xmm2, %xmm2
mulsd %xmm1, %xmm1
addsd %xmm2, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
ucomisd %xmm3, %xmm0
jb 0xfa49
sqrtsd %xmm0, %xmm0
jmp 0xfa5a
callq 0x21b0
movsd 0x97aa(%rip), %xmm4     # 0x19200
xorpd %xmm3, %xmm3
ucomisd %xmm4, %xmm0
jbe 0xfa74
movq 0x40(%rbx), %rax
movb %bpl, 0x159(%rax,%r15)
movb %bpl, 0x2e0(%rax,%r15)
incq %r14
movslq 0x48(%rbx), %rax
addq $0x188, %r15            # imm = 0x188
cmpq %rax, %r14
jl 0xf9ed
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/gjoni[P]iPot/src/Chain.cpp
// Function: Chain::Transform(double*, double (*) [3])
void Chain::Transform(double t[3], double u[3][3]) {

	for (int i = 0; i < nRes; i++) {

		for (int j = 0; j < residue[i].nAtoms; j++) {

			Atom *A = &(residue[i].atom[j]);

			double x = A->x;
			double y = A->y;
			double z = A->z;

			A->x = u[0][0] * x + u[0][1] * y + u[0][2] * z + t[0];
			A->y = u[1][0] * x + u[1][1] * y + u[1][2] * z + t[1];
			A->z = u[2][0] * x + u[2][1] * y + u[2][2] * z + t[2];

		}

		residue[i].SetCentroid();

	}

	SetKD();

	for (int i = 0; i < nRes; i++) {
		ca_trace[i][0] = residue[i].CA->x;
		ca_trace[i][1] = residue[i].CA->y;
		ca_trace[i][2] = residue[i].CA->z;
	}

}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x48(%rdi)
jle 0xfb9b
movq %rdx, %r14
movq %rsi, %r15
xorl %r12d, %r12d
movq 0x40(%rbx), %rax
imulq $0x188, %r12, %rcx      # imm = 0x188
leaq (%rax,%rcx), %rdi
movslq 0x18(%rax,%rcx), %rcx
testq %rcx, %rcx
jle 0xfb86
movq 0x10(%rdi), %rax
shlq $0x5, %rcx
leaq (%rcx,%rcx,2), %rcx
xorl %edx, %edx
movsd 0x10(%rax,%rdx), %xmm1
movsd 0x18(%rax,%rdx), %xmm2
movsd 0x20(%rax,%rdx), %xmm0
movsd 0x8(%r14), %xmm3
mulsd %xmm2, %xmm3
movsd (%r14), %xmm4
mulsd %xmm1, %xmm4
addsd %xmm3, %xmm4
movsd 0x10(%r14), %xmm3
mulsd %xmm0, %xmm3
addsd %xmm4, %xmm3
addsd (%r15), %xmm3
movsd %xmm3, 0x10(%rax,%rdx)
movsd 0x20(%r14), %xmm3
mulsd %xmm2, %xmm3
movsd 0x18(%r14), %xmm4
mulsd %xmm1, %xmm4
addsd %xmm3, %xmm4
movsd 0x28(%r14), %xmm3
mulsd %xmm0, %xmm3
addsd %xmm4, %xmm3
addsd 0x8(%r15), %xmm3
movsd %xmm3, 0x18(%rax,%rdx)
mulsd 0x38(%r14), %xmm2
mulsd 0x30(%r14), %xmm1
mulsd 0x40(%r14), %xmm0
addsd %xmm2, %xmm1
addsd %xmm1, %xmm0
addsd 0x10(%r15), %xmm0
movsd %xmm0, 0x20(%rax,%rdx)
addq $0x60, %rdx
cmpq %rdx, %rcx
jne 0xfadf
callq 0x143ac
incq %r12
movslq 0x48(%rbx), %rax
cmpq %rax, %r12
jl 0xfab4
movq %rbx, %rdi
callq 0xf328
movslq 0x48(%rbx), %rax
testq %rax, %rax
jle 0xfbf1
movq 0x68(%rbx), %rcx
movl $0x168, %edx            # imm = 0x168
addq 0x40(%rbx), %rdx
xorl %esi, %esi
movq (%rdx), %rdi
movsd 0x10(%rdi), %xmm0
movq (%rcx,%rsi,8), %r8
movsd %xmm0, (%r8)
movsd 0x18(%rdi), %xmm0
movsd %xmm0, 0x8(%r8)
movsd 0x20(%rdi), %xmm0
movsd %xmm0, 0x10(%r8)
incq %rsi
addq $0x188, %rdx            # imm = 0x188
cmpq %rsi, %rax
jne 0xfbbb
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/gjoni[P]iPot/src/Chain.cpp
// Function: Chain::Save(char const*)
void Chain::Save(const char *name) {

	FILE *F = fopen(name, "w");
	if (F == NULL) {
		fprintf(stderr, "ERROR: Cannot write to file '%s'\n", name);
		return;
	}
	Atom *A;
	for (int i = 0; i < nRes; ++i) {
		for (int j = 0; j < residue[i].nAtoms; j++) {
			A = &(residue[i].atom[j]);
			if (strlen(A->name) == 4 || A->name[0] == '1' || A->name[0] == '2'
					|| A->name[0] == '3' || A->name[0] == '4') {
				fprintf(F,
						"ATOM  %5d %-4s%c%3s %c%4d%c   %8.3f%8.3f%8.3f%6.2f%6.2f          %2s%2s\n",
						A->atomNum, A->name, A->altLoc, residue[i].name,
						residue[i].chainId, residue[i].seqNum,
						residue[i].insCode, A->x, A->y, A->z, A->occup, A->temp,
						A->element, A->charge);
			} else {
				fprintf(F,
						"ATOM  %5d  %-3s%c%3s %c%4d%c   %8.3f%8.3f%8.3f%6.2f%6.2f          %2s%2s\n",
						A->atomNum, A->name, A->altLoc, residue[i].name,
						residue[i].chainId, residue[i].seqNum,
						residue[i].insCode, A->x, A->y, A->z, A->occup, A->temp,
						A->element, A->charge);
			}
		}
	}
	fprintf(F, "TER\n");
	fclose(F);

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0xaf72(%rip), %rsi      # 0x1abd5
movq %r15, %rdi
callq 0x2260
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0xfdc1
cmpl $0x0, 0x48(%r14)
jle 0xfd8d
xorl %ecx, %ecx
movq %r14, 0x20(%rsp)
movq 0x40(%r14), %rbx
movq %rcx, 0x18(%rsp)
imulq $0x188, %rcx, %rax      # imm = 0x188
movq %rax, 0x10(%rsp)
cmpl $0x0, 0x18(%rbx,%rax)
jle 0xfd78
addq 0x10(%rsp), %rbx
movl $0x3b, %r12d
xorl %r13d, %r13d
movq 0x10(%rbx), %r14
leaq (%r14,%r12), %r15
addq $-0x37, %r15
movq %r15, %rdi
callq 0x2100
leaq 0xaf25(%rip), %rsi      # 0x1abf9
cmpq $0x4, %rax
je 0xfcf1
movb (%r15), %al
addb $-0x31, %al
leaq 0xaf13(%rip), %rsi      # 0x1abf9
cmpb $0x4, %al
jb 0xfcf1
leaq 0xaf51(%rip), %rsi      # 0x1ac42
leaq (%r14,%r12), %r11
addq $-0x3, %r11
addq %r12, %r14
movl -0x38(%r11), %edx
movsbl -0x2f(%r11), %r8d
leaq 0x1(%rbx), %r9
movsbl 0x1c(%rbx), %r10d
movl 0x8(%rbx), %ebp
movsbl 0xc(%rbx), %ebx
movsd -0x28(%r11), %xmm0
movsd -0x20(%r11), %xmm1
movsd -0x18(%r11), %xmm2
movsd -0x10(%r11), %xmm3
movsd -0x8(%r11), %xmm4
subq $0x8, %rsp
movq 0x10(%rsp), %rdi
movq %r15, %rcx
movb $0x5, %al
pushq %r14
pushq %r11
pushq %rbx
pushq %rbp
pushq %r10
callq 0x2300
addq $0x30, %rsp
incq %r13
movq 0x20(%rsp), %r14
movq 0x40(%r14), %rbx
movq 0x10(%rsp), %rcx
movslq 0x18(%rbx,%rcx), %rax
addq %rcx, %rbx
addq $0x60, %r12
cmpq %rax, %r13
jl 0xfcb9
movq 0x18(%rsp), %rcx
incq %rcx
movslq 0x48(%r14), %rax
cmpq %rax, %rcx
jl 0xfc8b
leaq 0xaef8(%rip), %rdi      # 0x1ac8c
movl $0x4, %esi
movl $0x1, %edx
movq 0x8(%rsp), %rbx
movq %rbx, %rcx
callq 0x23c0
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2210
movq 0x1d218(%rip), %rax     # 0x2cfe0
movq (%rax), %rdi
leaq 0xae05(%rip), %rsi      # 0x1abd7
movq %r15, %rdx
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2300
// File: /workspace/github_cpp_makefile_star2_O1/gjoni[P]iPot/src/Chain.cpp
// Function: Chain::IfProtein()
int Chain::IfProtein() {

	int n = 0;
	for (int i = 0; i < nRes; i++) {
		n += (residue[i].type >= 0 && residue[i].type < 20);
	}
	return n;

}

// Assembly:
movslq 0x48(%rdi), %rax
testq %rax, %rax
jle 0xfe16
movq 0x40(%rdi), %rcx
imulq $0x188, %rax, %rdx      # imm = 0x188
xorl %esi, %esi
xorl %eax, %eax
cmpb $0x14, (%rcx,%rsi)
adcl $0x0, %eax
addq $0x188, %rsi            # imm = 0x188
cmpq %rsi, %rdx
jne 0xfe02
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/gjoni[P]iPot/src/Chain.cpp
// Function: Chain::GetSequence[abi:cxx11]()
std::string Chain::GetSequence() {

	std::string seq;
	for (int i = 0; i < nRes; i++) {
		seq += AAA1[(int) residue[i].type];
	}

	return seq;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
cmpl $0x0, 0x48(%rsi)
jle 0xfe79
movq %rsi, %r14
xorl %r12d, %r12d
leaq 0xacc2(%rip), %r13      # 0x1ab10
xorl %ebp, %ebp
movq 0x40(%r14), %rax
movsbq (%rax,%r12), %rax
movsbl (%rax,%r13), %esi
movq %rbx, %rdi
callq 0x21d0
incq %rbp
movslq 0x48(%r14), %rax
addq $0x188, %r12            # imm = 0x188
cmpq %rax, %rbp
jl 0xfe50
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0xfea1
movq (%r15), %rsi
incq %rsi
callq 0x2230
movq %r14, %rdi
callq 0x2390
nop
// File: /workspace/github_cpp_makefile_star2_O1/gjoni[P]iPot/src/Chain.cpp
// Function: Chain::Renumber(std::vector<int, std::allocator<int>> const&)
void Chain::Renumber(const std::vector<int> &num) {

	assert((int )num.size() == nRes);

	for (int i = 0; i < nRes; i++) {
		residue[i].seqNum = num[i];
		residue[i].insCode = ' ';
	}

	SetResMap();

}

// Assembly:
pushq %rax
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
subq %rax, %rdx
shrq $0x2, %rdx
movl 0x48(%rdi), %ecx
cmpl %edx, %ecx
jne 0xfeee
testl %ecx, %ecx
jle 0xfee8
movq 0x40(%rdi), %rdx
addq $0xc, %rdx
xorl %esi, %esi
movl (%rax,%rsi,4), %r8d
movl %r8d, -0x4(%rdx)
movb $0x20, (%rdx)
incq %rsi
addq $0x188, %rdx            # imm = 0x188
cmpq %rsi, %rcx
jne 0xfece
popq %rax
jmp 0xf114
leaq 0xad9c(%rip), %rdi      # 0x1ac91
leaq 0xac92(%rip), %rsi      # 0x1ab8e
leaq 0xada7(%rip), %rcx      # 0x1acaa
movl $0x25b, %edx            # imm = 0x25B
callq 0x2160
nop
// File: /workspace/github_cpp_makefile_star2_O1/gjoni[P]iPot/src/Chain.cpp
// Function: Chain::GetResidue(int, char) const
Residue* Chain::GetResidue(int n, char ins) const {

	std::map<std::pair<int, char>, Residue*>::const_iterator it;
	it = resmap.find( { n, ins });
	if (it == resmap.end()) {
		return NULL;
	} else {
		return it->second;
	}

}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rax
movl %esi, (%rax)
movb %dl, 0x4(%rax)
movq %rax, %rsi
callq 0x10c30
addq $0x8, %rbx
cmpq %rbx, %rax
je 0xff37
movq 0x28(%rax), %rax
jmp 0xff39
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/gjoni[P]iPot/src/AACE.cpp
// Function: AACE::ReadGroups(std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>> const&)
int AACE::ReadGroups(const GROUPS_TYPE &GROUPS) {

	int n = 0;

	for (auto g: GROUPS) {
		std::map<std::string, int>::const_iterator it;
		it = TYPE_IDX.find(g.second);
		int t;
		if (it == TYPE_IDX.end()) {
			TYPE_IDX[g.second] = n;
			//printf("%s %d\n", g.second.c_str(), n);
			t = n++;
		} else {
			t = it->second;
		}
		ATOM_IDX[g.first] = t;
	}

	return TYPE_IDX.size();

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movq (%rsi), %r14
movq 0x8(%rsi), %rax
movq %rax, 0x10(%rsp)
cmpq %rax, %r14
je 0x10f24
leaq 0x30(%rbx), %r15
leaq 0x38(%rbx), %rax
movq %rax, 0x8(%rsp)
xorl %r12d, %r12d
leaq 0x18(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x12716
movq %r15, %rdi
leaq 0x38(%rsp), %rsi
callq 0x12fd2
cmpq 0x8(%rsp), %rax
je 0x10eb7
movl %r12d, %ebp
movl 0x40(%rax), %eax
movl %eax, %r12d
jmp 0x10ecc
movq %r15, %rdi
leaq 0x38(%rsp), %rsi
callq 0x12778
movl %r12d, (%rax)
leal 0x1(%r12), %ebp
movq %rbx, %rdi
movq %r13, %rsi
callq 0x12778
movl %r12d, (%rax)
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x10ef6
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x2230
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x10f12
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x2230
addq $0x40, %r14
movl %ebp, %r12d
cmpq 0x10(%rsp), %r14
jne 0x10e8d
movl 0x58(%rbx), %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x10f38
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x1227a
movq %rbx, %rdi
callq 0x2390
nop
// File: /workspace/github_cpp_makefile_star2_O1/gjoni[P]iPot/src/AACE.cpp
// Function: AACE::Allocate(int)
void AACE::Allocate(int N) {

	h = (double*) malloc(N * sizeof(double));
	J = (double**) malloc(N * sizeof(double*));
	for (int i = 0; i < N; i++) {
		J[i] = (double*) malloc(N * sizeof(double));
	}

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movslq %esi, %r15
leaq (,%r15,8), %r14
movq %r14, %rdi
callq 0x22d0
movq %rax, 0x60(%rbx)
movq %r14, %rdi
callq 0x22d0
movq %rax, 0x68(%rbx)
testl %r15d, %r15d
jle 0x10fa1
movl %ebp, %r15d
xorl %r12d, %r12d
movq %r14, %rdi
callq 0x22d0
movq 0x68(%rbx), %rcx
movq %rax, (%rcx,%r12,8)
incq %r12
cmpq %r12, %r15
jne 0x10f89
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/gjoni[P]iPot/src/AACE.cpp
// Function: AACE::ReadCouplings(char const*)
int AACE::ReadCouplings(const char *name) {

	FILE *F = fopen(name, "r");
	if (F == NULL) {
		printf("Error: cannot open %s file\n", name);
		exit(1);
	}

	const int STRMAX = 10000;
	char buf[STRMAX];

	int N = TYPE_IDX.size();

	for (int i = 0; i < N; i++) {
		fgets(buf, STRMAX, F);
		char * pch;
		pch = strtok(buf, " "); /* label */
		pch = strtok(NULL, " "); /* local field */
		h[i] = atof(pch);
		for (int j = 0; j < N; j++) {
			pch = strtok(NULL, " ");
			J[i][j] = atof(pch);
		}
	}
	fclose(F);

	return 0;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2728, %rsp           # imm = 0x2728
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x9575(%rip), %rsi      # 0x1ab4d
movq %r15, %rdi
callq 0x2260
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x11699
movq 0x58(%rbx), %r13
testl %r13d, %r13d
jle 0x1167b
andl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
xorl %ebp, %ebp
leaq 0x10(%rsp), %r15
leaq 0xb72e(%rip), %r12      # 0x1cd3e
movq %r15, %rdi
movl $0x2710, %esi           # imm = 0x2710
movq 0x8(%rsp), %rdx
callq 0x2360
movq %r15, %rdi
movq %r12, %rsi
callq 0x2350
xorl %edi, %edi
movq %r12, %rsi
callq 0x2350
movq %rax, %rdi
callq 0x22b0
movq 0x60(%rbx), %rax
movsd %xmm0, (%rax,%rbp,8)
xorl %r14d, %r14d
xorl %edi, %edi
movq %r12, %rsi
callq 0x2350
movq %rax, %rdi
callq 0x22b0
movq 0x68(%rbx), %rax
movq (%rax,%rbp,8), %rax
movsd %xmm0, (%rax,%r14,8)
incq %r14
cmpq %r14, %r13
jne 0x1164b
incq %rbp
cmpq %r13, %rbp
jne 0x11610
movq 0x8(%rsp), %rdi
callq 0x2210
xorl %eax, %eax
addq $0x2728, %rsp           # imm = 0x2728
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xb808(%rip), %rdi      # 0x1cea8
movq %r15, %rsi
xorl %eax, %eax
callq 0x2050
movl $0x1, %edi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O1/gjoni[P]iPot/src/AACE.cpp
// Function: AACE::AACE(AACE const&)
AACE::AACE(const AACE &source) :
		ATOM_IDX(source.ATOM_IDX), TYPE_IDX(source.TYPE_IDX), h(NULL), J(NULL), dmax(
				source.dmax), name(source.name) {

	int N = TYPE_IDX.size();

	Allocate(N);

	memcpy(h, source.h, N * sizeof(double));
	for (int i = 0; i < N; i++) {
		memcpy(J[i], source.J[i], N * sizeof(double));
	}

}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x128f6
leaq 0x30(%rbx), %r15
leaq 0x30(%r14), %rsi
movq %r15, %rdi
callq 0x128f6
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%rbx)
movsd 0x70(%r14), %xmm0
movsd %xmm0, 0x70(%rbx)
leaq 0x78(%rbx), %rdi
leaq 0x88(%rbx), %rax
movq %rax, 0x78(%rbx)
movq 0x78(%r14), %rsi
movq 0x80(%r14), %rdx
addq %rsi, %rdx
callq 0x12f42
movq 0x58(%rbx), %r15
movq %rbx, %rdi
movl %r15d, %esi
callq 0x10f4e
movq 0x60(%rbx), %rdi
movq 0x60(%r14), %rsi
movslq %r15d, %r13
leaq (,%r13,8), %r12
movq %r12, %rdx
callq 0x21c0
testl %r13d, %r13d
jle 0x11765
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
xorl %r13d, %r13d
movq 0x68(%rbx), %rax
movq (%rax,%r13,8), %rdi
movq 0x68(%r14), %rax
movq (%rax,%r13,8), %rsi
movq %r12, %rdx
callq 0x21c0
incq %r13
cmpq %r13, %r15
jne 0x11745
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %r15, %rdi
callq 0x1287e
jmp 0x1177f
movq %rax, %r14
movq %rbx, %rdi
callq 0x1287e
movq %r14, %rdi
callq 0x2390
nop
// File: /workspace/github_cpp_makefile_star2_O1/gjoni[P]iPot/src/AACE.cpp
// Function: AACE::Free(int)
void AACE::Free(int N) {

	if (J != NULL) {
		for (int i = 0; i < N; i++) {
			free(J[i]);
		}
		free(J);
	}
	free(h);

}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x68(%rdi)
je 0x11881
testl %esi, %esi
jle 0x11878
movl %esi, %r14d
xorl %r15d, %r15d
movq 0x68(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x2270
incq %r15
cmpq %r15, %r14
jne 0x11863
movq 0x68(%rbx), %rdi
callq 0x2270
movq 0x60(%rbx), %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2270
nop
// File: /workspace/github_cpp_makefile_star2_O1/gjoni[P]iPot/src/AACE.cpp
// Function: AACE::operator=(AACE const&)
AACE & AACE::operator =(const AACE & source) {

	assert(this != &source); /* an attempt to assign Residue to itself */

	Free(TYPE_IDX.size());

	ATOM_IDX = source.ATOM_IDX;
	TYPE_IDX = source.TYPE_IDX;
	dmax = source.dmax;
	name = source.name;

	int N = TYPE_IDX.size();
	Allocate(N);

	memcpy(h, source.h, N * sizeof(double));
	for (int i = 0; i < N; i++) {
		memcpy(J[i], source.J[i], N * sizeof(double));
	}

	return *this;

}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpq %rsi, %rdi
je 0x11949
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x30(%rdi), %r15
movl 0x58(%rdi), %esi
callq 0x1184a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x12b1c
leaq 0x30(%r14), %rsi
movq %r15, %rdi
callq 0x12b1c
movsd 0x70(%r14), %xmm0
movsd %xmm0, 0x70(%rbx)
leaq 0x78(%r14), %rsi
leaq 0x78(%rbx), %rdi
callq 0x2140
movq 0x58(%rbx), %r15
movq %rbx, %rdi
movl %r15d, %esi
callq 0x10f4e
movq 0x60(%rbx), %rdi
movq 0x60(%r14), %rsi
movslq %r15d, %r13
leaq (,%r13,8), %r12
movq %r12, %rdx
callq 0x21c0
testl %r13d, %r13d
jle 0x1193c
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
xorl %r13d, %r13d
movq 0x68(%rbx), %rax
movq (%rax,%r13,8), %rdi
movq 0x68(%r14), %rax
movq (%rax,%r13,8), %rsi
movq %r12, %rdx
callq 0x21c0
incq %r13
cmpq %r13, %r15
jne 0x1191c
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0xb524(%rip), %rdi      # 0x1ce74
leaq 0xb2bf(%rip), %rsi      # 0x1cc16
leaq 0xb526(%rip), %rcx      # 0x1ce84
movl $0xa5, %edx
callq 0x2160
// File: /workspace/github_cpp_makefile_star2_O1/gjoni[P]iPot/src/AACE.cpp
// Function: AACE::GetEnergy(Chain const&, std::vector<int, std::allocator<int>> const&)
double AACE::GetEnergy(const Chain &C, const std::vector<int> &t) {

	double E = 0.0;

	for (int i = 0; i < C.nAtoms; i++) {

		if (t[i] < 0) {
			continue;
		}

		Atom *A = C.atom[i];

		kdres *res = kd_nearest_range3f(C.kd, A->x, A->y, A->z, dmax);
		double pos[3];

		while (!kd_res_end(res)) {

			int j = ((Atom**) kd_res_item(res, pos)) - C.atom;
			if (t[j] >= 0 && i > j
			/* && C.atom[i]->residue != C.atom[j]->residue */) {
				E += J[t[i]][t[j]];
			}
			kd_res_next(res);
		}
		kd_res_free(res);
	}

	return E;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpl $0x0, 0x38(%rsi)
jle 0x11dec
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
xorl %ebp, %ebp
leaq 0x10(%rsp), %r12
movq (%rbx), %rax
cmpl $0x0, (%rax,%rbp,4)
js 0x11dda
movq 0x30(%r14), %rax
movq (%rax,%rbp,8), %rax
xorps %xmm0, %xmm0
cvtsd2ss 0x10(%rax), %xmm0
xorps %xmm1, %xmm1
cvtsd2ss 0x18(%rax), %xmm1
xorps %xmm2, %xmm2
cvtsd2ss 0x20(%rax), %xmm2
movq 0x50(%r14), %rdi
xorps %xmm3, %xmm3
cvtsd2ss 0x70(%r15), %xmm3
callq 0x181ac
movq %rax, %r13
movq %rax, %rdi
callq 0x181e8
testl %eax, %eax
jne 0x11dd2
movq %r13, %rdi
movq %r12, %rsi
callq 0x18208
subq 0x30(%r14), %rax
shrq $0x3, %rax
movslq %eax, %rdx
movq (%rbx), %rcx
movslq (%rcx,%rdx,4), %rax
testq %rax, %rax
js 0x11dc5
cmpq %rdx, %rbp
jle 0x11dc5
movq 0x68(%r15), %rdx
movslq (%rcx,%rbp,4), %rcx
movq (%rdx,%rcx,8), %rcx
movsd 0x8(%rsp), %xmm0
addsd (%rcx,%rax,8), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %r13, %rdi
callq 0x181f3
movq %r13, %rdi
jmp 0x11d78
movq %r13, %rdi
callq 0x17c0b
incq %rbp
movslq 0x38(%r14), %rax
cmpq %rax, %rbp
jl 0x11d33
jmp 0x11df5
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/gjoni[P]iPot/src/AACE.cpp
// Function: AACE::GetEnergy(Complex const&, std::vector<int, std::allocator<int>> const&, std::vector<int, std::allocator<int>> const&)
double AACE::GetEnergy(const Complex &C, const std::vector<int> &tRec,
		const std::vector<int> &tLig) {

	double E = 0;

	for (int i = 0; i < C.Receptor.nAtoms; i++) {

		if (tRec[i] < 0) {
			continue;
		}

		Atom *A = C.Receptor.atom[i];

		/* check whether the current atom is within the bounding box
		 * of the Receptor */
		kdtree *kd = C.Ligand.kd;
		if (A->x < kd->rect->min[0] - dmax || A->y < kd->rect->min[1] - dmax
				|| A->z < kd->rect->min[2] - dmax
				|| A->x > kd->rect->max[0] + dmax
				|| A->y > kd->rect->max[1] + dmax
				|| A->z > kd->rect->max[2] + dmax) {

			continue;

		}

		kdres *res = kd_nearest_range3f(kd, A->x, A->y, A->z, dmax);
		double pos[3];

		while (!kd_res_end(res)) {

			int j = ((Atom**) kd_res_item(res, pos)) - C.Ligand.atom;
			if (tLig[j] >= 0) {
				E += J[tRec[i]][tLig[j]];
			}
			kd_res_next(res);
		}
		kd_res_free(res);
	}

	return E;

}

// Assembly:
cmpl $0x0, 0x68(%rsi)
jle 0x12010
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
xorpd %xmm0, %xmm0
xorl %r13d, %r13d
movq (%r14), %rax
cmpl $0x0, (%rax,%r13,4)
js 0x11ff1
movq 0x60(%r15), %rax
movq 0xf0(%r15), %rdi
movq (%rax,%r13,8), %rcx
movsd 0x10(%rcx), %xmm5
movq 0x10(%rdi), %rax
movq 0x8(%rax), %rdx
movsd (%rdx), %xmm1
movsd 0x70(%r12), %xmm3
subsd %xmm3, %xmm1
ucomisd %xmm5, %xmm1
ja 0x11ff1
movsd 0x18(%rcx), %xmm1
movsd 0x8(%rdx), %xmm2
subsd %xmm3, %xmm2
ucomisd %xmm1, %xmm2
ja 0x11ff1
movsd 0x20(%rcx), %xmm2
movsd 0x10(%rdx), %xmm4
subsd %xmm3, %xmm4
ucomisd %xmm2, %xmm4
ja 0x11ff1
movq 0x10(%rax), %rax
movsd (%rax), %xmm4
addsd %xmm3, %xmm4
ucomisd %xmm4, %xmm5
ja 0x11ff1
movsd 0x8(%rax), %xmm4
addsd %xmm3, %xmm4
ucomisd %xmm4, %xmm1
ja 0x11ff1
movsd 0x10(%rax), %xmm4
addsd %xmm3, %xmm4
ucomisd %xmm4, %xmm2
ja 0x11ff1
movsd %xmm0, 0x8(%rsp)
xorps %xmm0, %xmm0
cvtsd2ss %xmm5, %xmm0
cvtsd2ss %xmm1, %xmm1
cvtsd2ss %xmm2, %xmm2
cvtsd2ss %xmm3, %xmm3
callq 0x181ac
movq %rax, %rbp
movq %rax, %rdi
callq 0x181e8
testl %eax, %eax
jne 0x11fe3
movq %rbp, %rdi
leaq 0x10(%rsp), %rsi
callq 0x18208
subq 0xd0(%r15), %rax
shrq $0x3, %rax
cltq
movq (%rbx), %rcx
movslq (%rcx,%rax,4), %rax
testq %rax, %rax
js 0x11fd6
movq 0x68(%r12), %rcx
movq (%r14), %rdx
movslq (%rdx,%r13,4), %rdx
movq (%rcx,%rdx,8), %rcx
movsd 0x8(%rsp), %xmm0
addsd (%rcx,%rax,8), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %rbp, %rdi
callq 0x181f3
movq %rbp, %rdi
jmp 0x11f86
movq %rbp, %rdi
callq 0x17c0b
movsd 0x8(%rsp), %xmm0
incq %r13
movslq 0x68(%r15), %rax
cmpq %rax, %r13
jl 0x11eb3
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/gjoni[P]iPot/src/RRCE.cpp
// Function: RRCE::RRCE(RRCE::RRCE_TYPE, double, int)
RRCE::RRCE(RRCE_TYPE type, double d, int k) :
		h(NULL), J(NULL), dmax(d) {

	char *DATADIR = getenv("TMDOCKDAT");
	if (DATADIR == NULL) {
		printf("Error: environment variable 'TMDOCKDAT' not set\n");
		exit(1);
	}

	const int STRMAX = 1000;
	char tname[STRMAX], rrce_name[STRMAX];

	switch (type) {

	case RRCE20RC:
		sprintf(tname, "%s/RRCE20RC/table.%.1fA_k%d", DATADIR, dmax, k);
		sprintf(rrce_name, "RRCE20RC_%.1fA_k%d", dmax, k);
		break;

	case RRCE20SCC:
		sprintf(tname, "%s/RRCE20SCC/table.%.1fA_k%d", DATADIR, dmax, k);
		sprintf(rrce_name, "RRCE20SCC_%.1fA_k%d", dmax, k);
		break;

	case RRCE20CB:
		sprintf(tname, "%s/RRCE20CB/table.%.1fA_k%d", DATADIR, dmax, k);
		sprintf(rrce_name, "RRCE20CB_%.1fA_k%d", dmax, k);
		break;

	default:
		printf("Error: wrong RRCE type (%d)\n", type);
		exit(1);
		break;

	}

	Allocate(20);

	ReadCouplings(tname);

	name = rrce_name;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x7e8, %rsp            # imm = 0x7E8
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
xorps %xmm1, %xmm1
movups %xmm1, (%rdi)
movsd %xmm0, 0x8(%rsp)
movsd %xmm0, 0x10(%rdi)
leaq 0x28(%rdi), %r15
movq %r15, 0x18(%rdi)
movq $0x0, 0x20(%rdi)
movb $0x0, 0x28(%rdi)
leaq 0x98ab(%rip), %rdi      # 0x1cd40
callq 0x2290
testq %rax, %rax
je 0x13555
movq %r15, (%rsp)
leal -0x1(%r14), %ecx
cmpl $0x3, %ecx
jae 0x13563
leaq 0x18(%rbx), %r14
movl %ecx, %ecx
leaq 0xc07f(%rip), %rdx      # 0x1f540
movslq (%rdx,%rcx,4), %rsi
addq %rdx, %rsi
leaq 0xc07d(%rip), %rdx      # 0x1f54c
movslq (%rdx,%rcx,4), %r12
addq %rdx, %r12
leaq 0x400(%rsp), %r13
movq %r13, %rdi
movq %rax, %rdx
movsd 0x8(%rsp), %xmm0
movl %ebp, %ecx
movb $0x1, %al
callq 0x2080
movsd 0x10(%rbx), %xmm0
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
movl %ebp, %edx
movb $0x1, %al
callq 0x2080
movq %rbx, %rdi
movl $0x14, %esi
callq 0x135a2
movq %rbx, %rdi
movq %r13, %rsi
callq 0x135fe
movq 0x20(%rbx), %rbx
movq %r15, %rdi
callq 0x2100
movq %r14, %rdi
xorl %esi, %esi
movq %rbx, %rdx
movq %r15, %rcx
movq %rax, %r8
callq 0x2330
addq $0x7e8, %rsp            # imm = 0x7E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x998e(%rip), %rdi      # 0x1ceea
callq 0x2320
jmp 0x13574
leaq 0xc07d(%rip), %rdi      # 0x1f5e7
movl %r14d, %esi
xorl %eax, %eax
callq 0x2050
movl $0x1, %edi
callq 0x2280
movq %rax, %rbx
movq (%r14), %rdi
cmpq (%rsp), %rdi
je 0x13599
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x2230
movq %rbx, %rdi
callq 0x2390
nop
// File: /workspace/github_cpp_makefile_star2_O1/gjoni[P]iPot/src/RRCE.cpp
// Function: RRCE::RRCE(RRCE const&)
RRCE::RRCE(const RRCE &source) :
		h(NULL), J(NULL), dmax(source.dmax), name(source.name) {

	const int N = 20;

	Allocate(N);

	memcpy(h, source.h, N * sizeof(double));
	for (int i = 0; i < N; i++) {
		memcpy(J[i], source.J[i], N * sizeof(double));
	}

}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movsd 0x10(%rsi), %xmm0
movsd %xmm0, 0x10(%rdi)
addq $0x18, %rdi
leaq 0x28(%r14), %rax
movq %rax, 0x18(%r14)
movq 0x18(%rsi), %rsi
movq 0x20(%rbx), %rdx
addq %rsi, %rdx
callq 0x12f42
movq %r14, %rdi
movl $0x14, %esi
callq 0x135a2
movq (%r14), %rdi
movq (%rbx), %rsi
movl $0xa0, %edx
callq 0x21c0
xorl %r15d, %r15d
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rdi
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rsi
movl $0xa0, %edx
callq 0x21c0
incq %r15
cmpq $0x14, %r15
jne 0x13735
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/gjoni[P]iPot/src/RRCE.cpp
// Function: RRCE::operator=(RRCE const&)
RRCE & RRCE::operator =(const RRCE & source) {

	assert(this != &source);

	const int N = 20;

	Free(N);

	dmax = source.dmax;
	name = source.name;

	Allocate(N);

	memcpy(h, source.h, N * sizeof(double));
	for (int i = 0; i < N; i++) {
		memcpy(J[i], source.J[i], N * sizeof(double));
	}

	return *this;

}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpq %rsi, %rdi
je 0x139b6
movq %rsi, %r14
movq %rdi, %rbx
movl $0x14, %esi
callq 0x138f4
movsd 0x10(%r14), %xmm0
movsd %xmm0, 0x10(%rbx)
leaq 0x18(%r14), %rsi
leaq 0x18(%rbx), %rdi
callq 0x2140
movq %rbx, %rdi
movl $0x14, %esi
callq 0x135a2
movq (%rbx), %rdi
movq (%r14), %rsi
movl $0xa0, %edx
callq 0x21c0
xorl %r15d, %r15d
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rdi
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rsi
movl $0xa0, %edx
callq 0x21c0
incq %r15
cmpq $0x14, %r15
jne 0x1398a
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x94b7(%rip), %rdi      # 0x1ce74
leaq 0xbc4f(%rip), %rsi      # 0x1f613
leaq 0xbc55(%rip), %rcx      # 0x1f620
movl $0x87, %edx
callq 0x2160
nop
// File: /workspace/github_cpp_makefile_star2_O1/gjoni[P]iPot/src/RRCE.cpp
// Function: RRCE::GetEnergy(Chain const&)
double RRCE::GetEnergy(const Chain &C) {

	double E = 0.0;

	for (int i = 0; i < C.nRes; i++) {

		char ti = C.residue[i].type;
		if (ti < 0 || ti > 19) {
			continue;
		}

		Residue *R = &(C.residue[i]);

		kdres *res = kd_nearest_range3f(C.kdCent, R->centroid[0],
				R->centroid[1], R->centroid[2], dmax);
		double pos[3];

		while (!kd_res_end(res)) {

			Atom *Aj = (Atom*) kd_res_item(res, pos);
			int j = Aj->residue - C.residue;
			char tj = Aj->residue->type;
			if (tj >= 0 && tj < 20 && i < j) {
				E += J[(int) ti][(int) tj];
			}
			kd_res_next(res);
		}
		kd_res_free(res);
	}

	return E;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpl $0x0, 0x48(%rsi)
jle 0x13b38
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
xorl %r13d, %r13d
leaq 0x10(%rsp), %r15
movq 0x40(%rbx), %rax
imulq $0x188, %r13, %rcx      # imm = 0x188
movsbq (%rax,%rcx), %rbp
cmpq $0x13, %rbp
ja 0x13b26
addq %rcx, %rax
xorps %xmm0, %xmm0
cvtsd2ss 0x20(%rax), %xmm0
xorps %xmm1, %xmm1
cvtsd2ss 0x28(%rax), %xmm1
xorps %xmm2, %xmm2
cvtsd2ss 0x30(%rax), %xmm2
movq 0x60(%rbx), %rdi
xorps %xmm3, %xmm3
cvtsd2ss 0x10(%r14), %xmm3
callq 0x181ac
movq %rax, %r12
movq %rax, %rdi
callq 0x181e8
testl %eax, %eax
jne 0x13b1e
movq %r12, %rdi
movq %r15, %rsi
callq 0x18208
movq 0x40(%rax), %rcx
movsbq (%rcx), %rax
cmpq $0x13, %rax
ja 0x13b11
subq 0x40(%rbx), %rcx
shrq $0x3, %rcx
imull $0x1a1f58d1, %ecx, %ecx # imm = 0x1A1F58D1
movslq %ecx, %rcx
cmpq %rcx, %r13
jge 0x13b11
movq 0x8(%r14), %rcx
movq (%rcx,%rbp,8), %rcx
movsd 0x8(%rsp), %xmm0
addsd (%rcx,%rax,8), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %r12, %rdi
callq 0x181f3
movq %r12, %rdi
jmp 0x13ac0
movq %r12, %rdi
callq 0x17c0b
incq %r13
movslq 0x48(%rbx), %rax
cmpq %rax, %r13
jl 0x13a73
jmp 0x13b41
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/gjoni[P]iPot/src/RRCE.cpp
// Function: RRCE::GetEnergy(Complex const&)
double RRCE::GetEnergy(const Complex &C) {

	double E = 0;

	for (int i = 0; i < C.Receptor.nRes; i++) {

		char ti = C.Receptor.residue[i].type;
		if (ti < 0 || ti > 19) {
			continue;
		}

		Residue *R = &(C.Receptor.residue[i]);
		double *ci = R->centroid;

		/* check whether the current atom is within the bounding box
		 * of the Receptor */
		kdtree *kd = C.Ligand.kdCent;
		if (ci[0] < kd->rect->min[0] - dmax || ci[1] < kd->rect->min[1] - dmax
				|| ci[2] < kd->rect->min[2] - dmax
				|| ci[0] > kd->rect->max[0] + dmax
				|| ci[1] > kd->rect->max[1] + dmax
				|| ci[2] > kd->rect->max[2] + dmax) {

			continue;

		}

		kdres *res = kd_nearest_range3f(kd, ci[0], ci[1], ci[2], dmax);
		double pos[3];

		while (!kd_res_end(res)) {

			Atom *Aj = (Atom*) kd_res_item(res, pos);
			char tj = Aj->residue->type;

			if (tj >= 0 && tj < 20) {
				E += J[(int) ti][(int) tj];
			}
			kd_res_next(res);
		}
		kd_res_free(res);
	}

	return E;

}

// Assembly:
cmpl $0x0, 0x78(%rsi)
jle 0x13cc9
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorpd %xmm0, %xmm0
xorl %r13d, %r13d
leaq 0x10(%rsp), %r15
movq 0x70(%rbx), %rax
imulq $0x188, %r13, %rcx      # imm = 0x188
movsbq (%rax,%rcx), %rbp
cmpq $0x13, %rbp
ja 0x13caa
addq %rcx, %rax
movq 0x100(%rbx), %rdi
movsd 0x20(%rax), %xmm5
movq 0x10(%rdi), %rcx
movq 0x8(%rcx), %rdx
movsd (%rdx), %xmm1
movsd 0x10(%r14), %xmm3
subsd %xmm3, %xmm1
ucomisd %xmm5, %xmm1
ja 0x13caa
movsd 0x28(%rax), %xmm1
movsd 0x8(%rdx), %xmm2
subsd %xmm3, %xmm2
ucomisd %xmm1, %xmm2
ja 0x13caa
movsd 0x30(%rax), %xmm2
movsd 0x10(%rdx), %xmm4
subsd %xmm3, %xmm4
ucomisd %xmm2, %xmm4
ja 0x13caa
movq 0x10(%rcx), %rax
movsd (%rax), %xmm4
addsd %xmm3, %xmm4
ucomisd %xmm4, %xmm5
ja 0x13caa
movsd 0x8(%rax), %xmm4
addsd %xmm3, %xmm4
ucomisd %xmm4, %xmm1
ja 0x13caa
movsd 0x10(%rax), %xmm4
addsd %xmm3, %xmm4
ucomisd %xmm4, %xmm2
ja 0x13caa
movsd %xmm0, 0x8(%rsp)
xorps %xmm0, %xmm0
cvtsd2ss %xmm5, %xmm0
cvtsd2ss %xmm1, %xmm1
cvtsd2ss %xmm2, %xmm2
cvtsd2ss %xmm3, %xmm3
callq 0x181ac
movq %rax, %r12
movq %rax, %rdi
callq 0x181e8
testl %eax, %eax
jne 0x13c9c
movq %r12, %rdi
movq %r15, %rsi
callq 0x18208
movq 0x40(%rax), %rax
movzbl (%rax), %eax
cmpq $0x13, %rax
ja 0x13c8f
movq 0x8(%r14), %rcx
movq (%rcx,%rbp,8), %rcx
movsd 0x8(%rsp), %xmm0
addsd (%rcx,%rax,8), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %r12, %rdi
callq 0x181f3
movq %r12, %rdi
jmp 0x13c55
movq %r12, %rdi
callq 0x17c0b
movsd 0x8(%rsp), %xmm0
incq %r13
movslq 0x78(%rbx), %rax
cmpq %rax, %r13
jl 0x13b80
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorps %xmm0, %xmm0
retq
nopl (%rax)