LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x107a2
cmpl $0x0, 0x48(%rbx)
jle 0xefdb
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 0xff38
movq %r13, (%rax)
incq %r12
movslq 0x48(%rbx), %rax
addq $0x188, %r15            # imm = 0x188
cmpq %rax, %r12
jl 0xefa0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xfe5a
movq (%r14), %rax
cmpq %rax, 0x8(%r14)
je 0xf0bc
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 0x21e0
movq %r12, %rdi
movq %r15, %rdx
callq 0xe954
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 0xf067
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xeac0
movq %rbx, %rdi
callq 0xef7a
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xf0e8
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x2220
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0xf119
movq %rax, %r14
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xf119
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x2220
movq %rbx, %rdi
callq 0xffc2
movq %r14, %rdi
callq 0x2380
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xf18c
pushq %rbx
movq 0x40(%rdi), %rsi
xorl %ecx, %ecx
xorl %edx, %edx
imulq $0x188, %rcx, %r8       # imm = 0x188
cmpl $0x0, 0x18(%rsi,%r8)
jle 0xf183
movslq %edx, %r9
shlq $0x3, %r9
xorl %r11d, %r11d
xorl %r10d, %r10d
movq 0x10(%rsi,%r8), %rsi
addq %r11, %rsi
movq 0x30(%rdi), %rbx
addq %r9, %rbx
movq %rsi, (%rbx,%r10,8)
incq %r10
movq 0x40(%rdi), %rsi
movslq 0x18(%rsi,%r8), %rbx
addq $0x60, %r11
cmpq %rbx, %r10
jl 0xf158
addl %r10d, %edx
incq %rcx
cmpq %rax, %rcx
jne 0xf13c
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xf1aa
callq 0x17545
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0xf1b8
callq 0x17545
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0xf1c6
callq 0x17545
movl $0x3, %edi
callq 0x17520
movq %rax, 0x50(%rbx)
movl $0x3, %edi
callq 0x17520
movq %rax, 0x58(%rbx)
movl $0x3, %edi
callq 0x17520
movq %rax, 0x60(%rbx)
cmpl $0x0, 0x48(%rbx)
jle 0xf2f6
xorl %r15d, %r15d
xorl %ebp, %ebp
movq 0x40(%rbx), %rsi
imulq $0x188, %r15, %r12      # imm = 0x188
cmpl $0x0, 0x18(%rsi,%r12)
jle 0xf26f
movl %ebp, 0x4(%rsp)
movslq %ebp, %r14
shlq $0x3, %r14
movl $0x4, %r13d
xorl %ebp, %ebp
movq 0x10(%rsi,%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 0x178a6
incq %rbp
movq 0x40(%rbx), %rsi
movslq 0x18(%rsi,%r12), %rax
addq $0x8, %r14
addq $0xc, %r13
cmpq %rax, %rbp
jl 0xf225
movl 0x4(%rsp), %eax
addl %ebp, %eax
movl %eax, %ebp
movq 0x168(%rsi,%r12), %r14
testq %r14, %r14
je 0xf2cb
movq 0x58(%rbx), %rdi
movsd 0x10(%r14), %xmm0
movsd 0x18(%r14), %xmm1
movsd 0x20(%r14), %xmm2
movq %r14, %rsi
callq 0x178a6
movq 0x40(%rbx), %rsi
cmpb $0x7, (%rsi,%r12)
jne 0xf2cb
addq %r12, %rsi
movq 0x60(%rbx), %rdi
movsd 0x10(%r14), %xmm0
movsd 0x18(%r14), %xmm1
movsd 0x20(%r14), %xmm2
movq 0x10(%rsi), %rsi
callq 0x178a6
movq 0x40(%rbx), %rsi
cmpb $0x7, (%rsi,%r12)
je 0xf2e6
addq %r12, %rsi
movq 0x60(%rbx), %rdi
movq 0x10(%rsi), %rdx
addq $0x20, %rsi
callq 0x175fa
incq %r15
movslq 0x48(%rbx), %rax
cmpq %rax, %r15
jl 0xf1ff
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x10012
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)
leaq 0x8(%rax), %rcx
testl %r13d, %r13d
je 0xf3eb
movq %rax, 0x8(%rsp)
imulq $-0x188, %r13, %r12     # imm = 0xFE78
xorl %ebp, %ebp
movq %rcx, 0x10(%rsp)
movq %rcx, %r13
movq %r13, %rdi
callq 0x13ae8
addq $-0x188, %rbp           # imm = 0xFE78
addq $0x188, %r13            # imm = 0x188
cmpq %rbp, %r12
jne 0xf393
cmpl $0x0, 0x48(%rbx)
movq 0x10(%rsp), %rax
movq %rax, 0x40(%rbx)
jle 0xf3ef
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x40(%r14), %rsi
addq %r15, %rsi
movq 0x40(%rbx), %rdi
addq %r15, %rdi
callq 0x148ee
incq %r12
movslq 0x48(%rbx), %rax
addq $0x188, %r15            # imm = 0x188
cmpq %rax, %r12
jl 0xf3c3
jmp 0xf3ef
movq %rcx, 0x40(%rbx)
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 0xf12a
movq %rbx, %rdi
callq 0xf18e
movslq 0x48(%rbx), %r15
leaq (,%r15,8), %rdi
callq 0x22c0
movq %rax, 0x68(%rbx)
testq %r15, %r15
jle 0xf47b
xorl %r15d, %r15d
movl $0x18, %edi
callq 0x22c0
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 0xf43f
movq %rbx, %rdi
callq 0xef7a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xf494
movq %rax, %r14
jmp 0xf4cf
movq %rax, %r14
testq %rbp, %rbp
je 0xf4c2
negq %rbp
movq 0x8(%rsp), %r12
addq $-0x180, %r12           # imm = 0xFE80
leaq (%r12,%rbp), %rdi
callq 0x1486e
addq $-0x188, %rbp           # imm = 0xFE78
jne 0xf4b0
movq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x23c0
movq %rbx, %rdi
callq 0xffc2
movq %r14, %rdi
callq 0x2380
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xf4fa
callq 0x22b0
movq $0x0, 0x30(%rbx)
movq 0x40(%rbx), %r15
testq %r15, %r15
je 0xf54b
leaq -0x8(%r15), %r14
movq -0x8(%r15), %r12
testq %r12, %r12
je 0xf538
addq $-0x188, %r15           # imm = 0xFE78
imulq $0x188, %r12, %r13      # imm = 0x188
leaq (%r15,%r13), %rdi
callq 0x1486e
addq $-0x188, %r13           # imm = 0xFE78
jne 0xf526
imulq $0x188, %r12, %rsi      # imm = 0x188
addq $0x8, %rsi
movq %r14, %rdi
callq 0x23c0
movq $0x0, 0x40(%rbx)
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0xf561
callq 0x17545
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0xf56f
callq 0x17545
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0xf57d
callq 0x17545
movq 0x68(%rbx), %rdi
testq %rdi, %rdi
je 0xf5b1
cmpl $0x0, 0x48(%rbx)
jle 0xf5ac
xorl %r14d, %r14d
movq 0x68(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x2260
incq %r14
movslq 0x48(%rbx), %rax
cmpq %rax, %r14
jl 0xf58f
movq 0x68(%rbx), %rdi
callq 0x2260
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xffc2
movq %rax, %rdi
callq 0xff2c
// File: /workspace/github_cpp_makefile_star2_O3/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:
movq 0x40(%rdi), %rax
movb $0x1, %cl
movb %cl, 0x158(%rax)
movslq 0x48(%rdi), %rsi
imulq $0x188, %rsi, %rdx      # imm = 0x188
movb %cl, -0x2f(%rax,%rdx)
cmpq $0x2, %rsi
jl 0xf8c0
addq $-0x188, %rdx           # imm = 0xFE78
xorl %esi, %esi
movsd 0x99b6(%rip), %xmm0     # 0x19200
movq 0x168(%rax,%rsi), %rdi
testq %rdi, %rdi
je 0xf8b4
movq 0x2f0(%rax,%rsi), %r8
testq %r8, %r8
je 0xf8b4
movsd 0x10(%rdi), %xmm1
movsd 0x18(%rdi), %xmm2
subsd 0x10(%r8), %xmm1
subsd 0x18(%r8), %xmm2
movsd 0x20(%rdi), %xmm3
subsd 0x20(%r8), %xmm3
mulsd %xmm2, %xmm2
mulsd %xmm1, %xmm1
addsd %xmm2, %xmm1
mulsd %xmm3, %xmm3
addsd %xmm1, %xmm3
xorps %xmm1, %xmm1
sqrtsd %xmm3, %xmm1
ucomisd %xmm0, %xmm1
jbe 0xf8b4
movb %cl, 0x159(%rax,%rsi)
movb %cl, 0x2e0(%rax,%rsi)
addq $0x188, %rsi            # imm = 0x188
cmpq %rsi, %rdx
jne 0xf84a
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xf9c7
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 0xf9b2
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 0xf90b
callq 0x141d0
incq %r12
movslq 0x48(%rbx), %rax
cmpq %rax, %r12
jl 0xf8e0
movq %rbx, %rdi
callq 0xf18e
movslq 0x48(%rbx), %rax
testq %rax, %rax
jle 0xfa1d
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 0xf9e7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, %rbx
leaq 0xb146(%rip), %rsi      # 0x1abd5
movq %r15, %rdi
callq 0x2250
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0xfbf3
movl 0x48(%rbx), %ecx
testl %ecx, %ecx
jle 0xfbbf
movq 0x40(%rbx), %rax
xorl %esi, %esi
movq %rbx, 0x18(%rsp)
imulq $0x188, %rsi, %rdx      # imm = 0x188
cmpl $0x0, 0x18(%rax,%rdx)
jle 0xfbb0
movq %rsi, 0x10(%rsp)
addq %rdx, %rax
movl $0x3b, %r12d
xorl %r13d, %r13d
movq %rax, %r14
movq %rdx, 0x20(%rsp)
movq 0x10(%r14), %rbx
leaq (%rbx,%r12), %r15
addq $-0x37, %r15
movq %r15, %rdi
callq 0x2100
leaq 0xb0f8(%rip), %rsi      # 0x1abf9
cmpq $0x4, %rax
je 0xfb1e
movb (%r15), %al
addb $-0x31, %al
leaq 0xb0e6(%rip), %rsi      # 0x1abf9
cmpb $0x4, %al
jb 0xfb1e
leaq 0xb124(%rip), %rsi      # 0x1ac42
leaq (%rbx,%r12), %r11
addq $-0x3, %r11
addq %r12, %rbx
movl -0x38(%r11), %edx
movsbl -0x2f(%r11), %r8d
leaq 0x1(%r14), %r9
movsbl 0x1c(%r14), %r10d
movl 0x8(%r14), %ebp
movsbl 0xc(%r14), %r14d
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 %rbx
pushq %r11
pushq %r14
pushq %rbp
pushq %r10
callq 0x22f0
addq $0x30, %rsp
incq %r13
movq 0x18(%rsp), %rbx
movq 0x40(%rbx), %rax
movq 0x20(%rsp), %rdx
leaq (%rax,%rdx), %r14
movslq 0x18(%rax,%rdx), %rcx
addq $0x60, %r12
cmpq %rcx, %r13
jl 0xfae6
movl 0x48(%rbx), %ecx
movq 0x10(%rsp), %rsi
incq %rsi
movslq %ecx, %rdx
cmpq %rdx, %rsi
jl 0xfabb
leaq 0xb0c6(%rip), %rdi      # 0x1ac8c
movl $0x4, %esi
movl $0x1, %edx
movq 0x8(%rsp), %rbx
movq %rbx, %rcx
callq 0x23b0
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2200
movq 0x1d3e6(%rip), %rax     # 0x2cfe0
movq (%rax), %rdi
leaq 0xafd3(%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 0x22f0
// File: /workspace/github_cpp_makefile_star2_O3/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 0xfc48
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 0xfc34
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xfcab
movq %rsi, %r14
xorl %r12d, %r12d
leaq 0xae90(%rip), %r13      # 0x1ab10
xorl %ebp, %ebp
movq 0x40(%r14), %rax
movsbq (%rax,%r12), %rax
movsbl (%rax,%r13), %esi
movq %rbx, %rdi
callq 0x21c0
incq %rbp
movslq 0x48(%r14), %rax
addq $0x188, %r12            # imm = 0x188
cmpq %rax, %rbp
jl 0xfc82
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 0xfcd3
movq (%r15), %rsi
incq %rsi
callq 0x2220
movq %r14, %rdi
callq 0x2380
nop
// File: /workspace/github_cpp_makefile_star2_O3/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), %rcx
subq %rax, %rcx
shrq $0x2, %rcx
cmpl %ecx, 0x48(%rdi)
jne 0xfd24
testl %ecx, %ecx
jle 0xfd1e
movq 0x40(%rdi), %rdx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
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 0xfd04
popq %rax
jmp 0xef7a
leaq 0xaf66(%rip), %rdi      # 0x1ac91
leaq 0xae5c(%rip), %rsi      # 0x1ab8e
leaq 0xaf71(%rip), %rcx      # 0x1acaa
movl $0x25b, %edx            # imm = 0x25B
callq 0x2160
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x10a50
addq $0x8, %rbx
cmpq %rbx, %rax
je 0xfd6d
movq 0x28(%rax), %rax
jmp 0xfd6f
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x10d3c
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 0x12520
movq %r15, %rdi
leaq 0x38(%rsp), %rsi
callq 0x12de2
cmpq 0x8(%rsp), %rax
je 0x10ccf
movl %r12d, %ebp
movl 0x40(%rax), %eax
movl %eax, %r12d
jmp 0x10ce4
movq %r15, %rdi
leaq 0x38(%rsp), %rsi
callq 0x12582
movl %r12d, (%rax)
leal 0x1(%r12), %ebp
movq %rbx, %rdi
movq %r13, %rsi
callq 0x12582
movl %r12d, (%rax)
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x10d0e
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x2220
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x10d2a
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x2220
addq $0x40, %r14
movl %ebp, %r12d
cmpq 0x10(%rsp), %r14
jne 0x10ca5
movl 0x58(%rbx), %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x10d50
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x12084
movq %rbx, %rdi
callq 0x2380
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x22c0
movq %rax, 0x60(%rbx)
movq %r14, %rdi
callq 0x22c0
movq %rax, 0x68(%rbx)
testl %r15d, %r15d
jle 0x10db9
movl %ebp, %r15d
xorl %r12d, %r12d
movq %r14, %rdi
callq 0x22c0
movq 0x68(%rbx), %rcx
movq %rax, (%rcx,%r12,8)
incq %r12
cmpq %r12, %r15
jne 0x10da1
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x9773(%rip), %rsi      # 0x1ab4d
movq %r15, %rdi
callq 0x2250
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x1149b
movq 0x58(%rbx), %r13
testl %r13d, %r13d
jle 0x1147d
andl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
xorl %ebp, %ebp
leaq 0x10(%rsp), %r15
leaq 0xb92c(%rip), %r12      # 0x1cd3e
movq %r15, %rdi
movl $0x2710, %esi           # imm = 0x2710
movq 0x8(%rsp), %rdx
callq 0x2350
movq %r15, %rdi
movq %r12, %rsi
callq 0x2340
xorl %edi, %edi
movq %r12, %rsi
callq 0x2340
movq %rax, %rdi
callq 0x22a0
movq 0x60(%rbx), %rax
movsd %xmm0, (%rax,%rbp,8)
xorl %r14d, %r14d
xorl %edi, %edi
movq %r12, %rsi
callq 0x2340
movq %rax, %rdi
callq 0x22a0
movq 0x68(%rbx), %rax
movq (%rax,%rbp,8), %rax
movsd %xmm0, (%rax,%r14,8)
incq %r14
cmpq %r14, %r13
jne 0x1144d
incq %rbp
cmpq %r13, %rbp
jne 0x11412
movq 0x8(%rsp), %rdi
callq 0x2200
xorl %eax, %eax
addq $0x2728, %rsp           # imm = 0x2728
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xba06(%rip), %rdi      # 0x1cea8
movq %r15, %rsi
xorl %eax, %eax
callq 0x2050
movl $0x1, %edi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O3/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 0x12702
leaq 0x30(%rbx), %r15
leaq 0x30(%r14), %rsi
movq %r15, %rdi
callq 0x12702
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 0x12d4c
movq 0x58(%rbx), %r15
movq %rbx, %rdi
movl %r15d, %esi
callq 0x10d66
movq 0x60(%rbx), %rdi
movq 0x60(%r14), %rsi
movslq %r15d, %r13
leaq (,%r13,8), %r12
movq %r12, %rdx
callq 0x21b0
testl %r13d, %r13d
jle 0x11567
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 0x21b0
incq %r13
cmpq %r13, %r15
jne 0x11547
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %r15, %rdi
callq 0x1268a
jmp 0x11581
movq %rax, %r14
movq %rbx, %rdi
callq 0x1268a
movq %r14, %rdi
callq 0x2380
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movq 0x68(%rdi), %rdi
testq %rdi, %rdi
je 0x11685
testl %esi, %esi
jle 0x11680
movl %esi, %r14d
xorl %r15d, %r15d
movq 0x68(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x2260
incq %r15
cmpq %r15, %r14
jne 0x11667
movq 0x68(%rbx), %rdi
callq 0x2260
movq 0x60(%rbx), %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1174d
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x30(%rdi), %r15
movl 0x58(%rdi), %esi
callq 0x1164c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x12928
leaq 0x30(%r14), %rsi
movq %r15, %rdi
callq 0x12928
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 0x10d66
movq 0x60(%rbx), %rdi
movq 0x60(%r14), %rsi
movslq %r15d, %r13
leaq (,%r13,8), %r12
movq %r12, %rdx
callq 0x21b0
testl %r13d, %r13d
jle 0x11740
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 0x21b0
incq %r13
cmpq %r13, %r15
jne 0x11720
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0xb720(%rip), %rdi      # 0x1ce74
leaq 0xb4bb(%rip), %rsi      # 0x1cc16
leaq 0xb722(%rip), %rcx      # 0x1ce84
movl $0xa5, %edx
callq 0x2160
// File: /workspace/github_cpp_makefile_star2_O3/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
movl 0x38(%rsi), %eax
testl %eax, %eax
jle 0x11bf2
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), %rcx
cmpl $0x0, (%rcx,%rbp,4)
js 0x11be1
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 0x17fd5
movq %rax, %r13
movq %rax, %rdi
callq 0x18006
testl %eax, %eax
jne 0x11bd5
movq %r13, %rdi
movq %r12, %rsi
callq 0x18026
subq 0x30(%r14), %rax
shrq $0x3, %rax
movslq %eax, %rdx
movq (%rbx), %rcx
movslq (%rcx,%rdx,4), %rax
testq %rax, %rax
js 0x11bc8
cmpq %rdx, %rbp
jle 0x11bc8
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 0x18011
movq %r13, %rdi
jmp 0x11b7b
movq %r13, %rdi
callq 0x17a3c
movl 0x38(%r14), %eax
incq %rbp
movslq %eax, %rcx
cmpq %rcx, %rbp
jl 0x11b36
jmp 0x11bfb
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_O3/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:
movl 0x68(%rsi), %eax
testl %eax, %eax
jle 0x11e1a
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), %rcx
cmpl $0x0, (%rcx,%r13,4)
js 0x11dfc
movq 0x60(%r15), %rcx
movq 0xf0(%r15), %rdi
movq (%rcx,%r13,8), %rdx
movsd 0x10(%rdx), %xmm5
movq 0x10(%rdi), %rcx
movq 0x8(%rcx), %rsi
movsd (%rsi), %xmm1
movsd 0x70(%r12), %xmm3
subsd %xmm3, %xmm1
ucomisd %xmm5, %xmm1
ja 0x11dfc
movsd 0x18(%rdx), %xmm1
movsd 0x8(%rsi), %xmm2
subsd %xmm3, %xmm2
ucomisd %xmm1, %xmm2
ja 0x11dfc
movsd 0x20(%rdx), %xmm2
movsd 0x10(%rsi), %xmm4
subsd %xmm3, %xmm4
ucomisd %xmm2, %xmm4
ja 0x11dfc
movq 0x10(%rcx), %rcx
movsd (%rcx), %xmm4
addsd %xmm3, %xmm4
ucomisd %xmm4, %xmm5
ja 0x11dfc
movsd 0x8(%rcx), %xmm4
addsd %xmm3, %xmm4
ucomisd %xmm4, %xmm1
ja 0x11dfc
movsd 0x10(%rcx), %xmm4
addsd %xmm3, %xmm4
ucomisd %xmm4, %xmm2
ja 0x11dfc
movsd %xmm0, 0x8(%rsp)
xorps %xmm0, %xmm0
cvtsd2ss %xmm5, %xmm0
cvtsd2ss %xmm1, %xmm1
cvtsd2ss %xmm2, %xmm2
cvtsd2ss %xmm3, %xmm3
callq 0x17fd5
movq %rax, %rbp
movq %rax, %rdi
callq 0x18006
testl %eax, %eax
jne 0x11dea
movq %rbp, %rdi
leaq 0x10(%rsp), %rsi
callq 0x18026
subq 0xd0(%r15), %rax
shrq $0x3, %rax
cltq
movq (%rbx), %rcx
movslq (%rcx,%rax,4), %rax
testq %rax, %rax
js 0x11ddd
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 0x18011
movq %rbp, %rdi
jmp 0x11d8d
movq %rbp, %rdi
callq 0x17a3c
movl 0x68(%r15), %eax
movsd 0x8(%rsp), %xmm0
incq %r13
movslq %eax, %rcx
cmpq %rcx, %r13
jl 0x11cba
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_O3/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 0x9a9b(%rip), %rdi      # 0x1cd40
callq 0x2280
testq %rax, %rax
je 0x13365
movq %r15, (%rsp)
leal -0x1(%r14), %ecx
cmpl $0x3, %ecx
jae 0x13373
leaq 0x18(%rbx), %r14
movl %ecx, %ecx
leaq 0xc26f(%rip), %rdx      # 0x1f540
movslq (%rdx,%rcx,4), %rsi
addq %rdx, %rsi
leaq 0xc26d(%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 0x133b2
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1340e
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 0x2320
addq $0x7e8, %rsp            # imm = 0x7E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x9b7e(%rip), %rdi      # 0x1ceea
callq 0x2310
jmp 0x13384
leaq 0xc26d(%rip), %rdi      # 0x1f5e7
movl %r14d, %esi
xorl %eax, %eax
callq 0x2050
movl $0x1, %edi
callq 0x2270
movq %rax, %rbx
movq (%r14), %rdi
cmpq (%rsp), %rdi
je 0x133a9
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x2220
movq %rbx, %rdi
callq 0x2380
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x12d4c
movq %r14, %rdi
movl $0x14, %esi
callq 0x133b2
movq (%r14), %rdi
movq (%rbx), %rsi
movl $0xa0, %edx
callq 0x21b0
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 0x21b0
incq %r15
cmpq $0x14, %r15
jne 0x13545
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x137c8
movq %rsi, %r14
movq %rdi, %rbx
movl $0x14, %esi
callq 0x13704
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 0x133b2
movq (%rbx), %rdi
movq (%r14), %rsi
movl $0xa0, %edx
callq 0x21b0
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 0x21b0
incq %r15
cmpq $0x14, %r15
jne 0x1379c
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x96a5(%rip), %rdi      # 0x1ce74
leaq 0xbe3d(%rip), %rsi      # 0x1f613
leaq 0xbe43(%rip), %rcx      # 0x1f620
movl $0x87, %edx
callq 0x2160
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movl 0x48(%rsi), %eax
testl %eax, %eax
jle 0x1394d
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
xorl %r13d, %r13d
leaq 0x10(%rsp), %r15
movq 0x40(%rbx), %rcx
imulq $0x188, %r13, %rdx      # imm = 0x188
movsbq (%rcx,%rdx), %rbp
cmpq $0x13, %rbp
ja 0x1393c
addq %rdx, %rcx
xorps %xmm0, %xmm0
cvtsd2ss 0x20(%rcx), %xmm0
xorps %xmm1, %xmm1
cvtsd2ss 0x28(%rcx), %xmm1
xorps %xmm2, %xmm2
cvtsd2ss 0x30(%rcx), %xmm2
movq 0x60(%rbx), %rdi
xorps %xmm3, %xmm3
cvtsd2ss 0x10(%r14), %xmm3
callq 0x17fd5
movq %rax, %r12
movq %rax, %rdi
callq 0x18006
testl %eax, %eax
jne 0x13931
movq %r12, %rdi
movq %r15, %rsi
callq 0x18026
movq 0x40(%rax), %rcx
movsbq (%rcx), %rax
cmpq $0x13, %rax
ja 0x13924
subq 0x40(%rbx), %rcx
shrq $0x3, %rcx
imull $0x1a1f58d1, %ecx, %ecx # imm = 0x1A1F58D1
movslq %ecx, %rcx
cmpq %rcx, %r13
jge 0x13924
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 0x18011
movq %r12, %rdi
jmp 0x138d3
movq %r12, %rdi
callq 0x17a3c
movl 0x48(%rbx), %eax
incq %r13
movslq %eax, %rcx
cmpq %rcx, %r13
jl 0x13886
jmp 0x13956
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
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
movl 0x78(%rsi), %eax
testl %eax, %eax
jle 0x13ae2
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), %rcx
imulq $0x188, %r13, %rdx      # imm = 0x188
movsbq (%rcx,%rdx), %rbp
cmpq $0x13, %rbp
ja 0x13ac4
addq %rdx, %rcx
movq 0x100(%rbx), %rdi
movsd 0x20(%rcx), %xmm5
movq 0x10(%rdi), %rdx
movq 0x8(%rdx), %rsi
movsd (%rsi), %xmm1
movsd 0x10(%r14), %xmm3
subsd %xmm3, %xmm1
ucomisd %xmm5, %xmm1
ja 0x13ac4
movsd 0x28(%rcx), %xmm1
movsd 0x8(%rsi), %xmm2
subsd %xmm3, %xmm2
ucomisd %xmm1, %xmm2
ja 0x13ac4
movsd 0x30(%rcx), %xmm2
movsd 0x10(%rsi), %xmm4
subsd %xmm3, %xmm4
ucomisd %xmm2, %xmm4
ja 0x13ac4
movq 0x10(%rdx), %rcx
movsd (%rcx), %xmm4
addsd %xmm3, %xmm4
ucomisd %xmm4, %xmm5
ja 0x13ac4
movsd 0x8(%rcx), %xmm4
addsd %xmm3, %xmm4
ucomisd %xmm4, %xmm1
ja 0x13ac4
movsd 0x10(%rcx), %xmm4
addsd %xmm3, %xmm4
ucomisd %xmm4, %xmm2
ja 0x13ac4
movsd %xmm0, 0x8(%rsp)
xorps %xmm0, %xmm0
cvtsd2ss %xmm5, %xmm0
cvtsd2ss %xmm1, %xmm1
cvtsd2ss %xmm2, %xmm2
cvtsd2ss %xmm3, %xmm3
callq 0x17fd5
movq %rax, %r12
movq %rax, %rdi
callq 0x18006
testl %eax, %eax
jne 0x13ab3
movq %r12, %rdi
movq %r15, %rsi
callq 0x18026
movq 0x40(%rax), %rax
movzbl (%rax), %eax
cmpq $0x13, %rax
ja 0x13aa6
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 0x18011
movq %r12, %rdi
jmp 0x13a6c
movq %r12, %rdi
callq 0x17a3c
movl 0x78(%rbx), %eax
movsd 0x8(%rsp), %xmm0
incq %r13
movslq %eax, %rcx
cmpq %rcx, %r13
jl 0x13997
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorps %xmm0, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/gjoni[P]iPot/src/Residue.cpp
// Function: Residue::Residue(Residue const&)
Residue::Residue(const Residue &source) :
		type(source.type), seqNum(source.seqNum), insCode(source.insCode), atom(
		NULL), nAtoms(source.nAtoms), chainId(source.chainId), ntFlag(
				source.ntFlag), ctFlag(source.ctFlag), N(NULL), CA(NULL), O(
		NULL), CB(NULL) {

	assert(nAtoms > 0); /* pedantic check */

	strcpy(name, source.name);

	atom = new Atom[nAtoms];
	for (int i = 0; i < nAtoms; i++) {
		atom[i] = source.atom[i];
		atom[i].residue = this;
	}

	SetBBAtoms(); /* N, CA, C, O, CB are pointers - they need  to be reinitialized */

	memcpy(centroid, source.centroid, 3 * sizeof(double));

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movb (%rsi), %al
movb %al, (%rdi)
movl 0x8(%rsi), %eax
movl %eax, 0x8(%rdi)
movb 0xc(%rsi), %al
movb %al, 0xc(%rdi)
movq $0x0, 0x10(%rdi)
movl 0x18(%rsi), %eax
movl %eax, 0x18(%rdi)
movb 0x1c(%rsi), %al
movb %al, 0x1c(%rdi)
leaq 0x38(%rdi), %r15
xorl %r12d, %r12d
movq %r15, %rdi
callq 0xe404
addq $-0x60, %r12
addq $0x60, %r15
cmpq $-0x120, %r12           # imm = 0xFEE0
jne 0x13bc9
movb 0x158(%r14), %al
movb %al, 0x158(%rbx)
movb 0x159(%r14), %al
movb %al, 0x159(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x160(%rbx)
movups %xmm0, 0x178(%rbx)
cmpl $0x0, 0x18(%rbx)
jle 0x13cfa
leaq 0x1(%rbx), %rdi
leaq 0x1(%r14), %rsi
callq 0x21e0
movslq 0x18(%rbx), %rbp
movl $0x60, %ecx
movq %rbp, %rax
mulq %rcx
seto %cl
orq $0x8, %rax
movq $-0x1, %r15
testb %cl, %cl
cmoveq %rax, %r15
movq %r15, %rdi
callq 0x2030
movq %rbp, (%rax)
leaq 0x8(%rax), %r12
testl %ebp, %ebp
je 0x13cce
movq %rax, 0x8(%rsp)
movq %r15, 0x10(%rsp)
shlq $0x5, %rbp
leaq (,%rbp,2), %r15
addq %rbp, %r15
negq %r15
xorl %r13d, %r13d
movq %r12, %rbp
movq %rbp, %rdi
callq 0xe404
addq $-0x60, %r13
addq $0x60, %rbp
cmpq %r13, %r15
jne 0x13c7c
cmpl $0x0, 0x18(%rbx)
movq %r12, 0x10(%rbx)
jle 0x13cd2
xorl %r15d, %r15d
xorl %r13d, %r13d
movq 0x10(%r14), %rsi
addq %r15, %rsi
addq %r15, %r12
movq %r12, %rdi
callq 0xe548
movq 0x10(%rbx), %r12
movq %rbx, 0x40(%r12,%r15)
incq %r13
movslq 0x18(%rbx), %rax
addq $0x60, %r15
cmpq %rax, %r13
jl 0x13ca1
jmp 0x13cd2
movq %r12, 0x10(%rbx)
movq %rbx, %rdi
callq 0x13d94
movups 0x20(%r14), %xmm0
movups %xmm0, 0x20(%rbx)
movq 0x30(%r14), %rax
movq %rax, 0x30(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xd2b3(%rip), %rdi      # 0x20fb4
leaq 0xd2b7(%rip), %rsi      # 0x20fbf
leaq 0xd2c0(%rip), %rcx      # 0x20fcf
movl $0x23, %edx
callq 0x2160
jmp 0x13d1b
movq %rax, %r14
jmp 0x13d52
movq %rax, %r14
testq %r13, %r13
je 0x13d43
negq %r13
movq 0x8(%rsp), %r15
addq $-0x58, %r15
leaq (%r15,%r13), %rdi
callq 0xe546
addq $-0x60, %r13
jne 0x13d34
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x23c0
movl $0xf8, %r15d
leaq (%rbx,%r15), %rdi
callq 0xe546
addq $-0x60, %r15
cmpq $-0x28, %r15
jne 0x13d58
jmp 0x13d8b
movq %rax, %r14
testq %r12, %r12
je 0x13d8b
negq %r12
addq $-0x28, %rbx
leaq (%rbx,%r12), %rdi
callq 0xe546
addq $-0x60, %r12
jne 0x13d7c
movq %r14, %rdi
callq 0x2380
nop