LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/ekg[P]tsvtools/split.cpp
// Function: split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
std::vector<std::string> &split(const std::string &s, char delim, std::vector<std::string> &elems) {
    std::stringstream ss(s);
    std::string item;
    while(std::getline(ss, item, delim)) {
        elems.push_back(item);
    }
    return elems;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %rsi
leaq 0x20(%rsp), %r14
pushq $0x18
popq %rdx
movq %r14, %rdi
callq 0x2230
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movsbl %bpl, %ebp
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x2280
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x3425
movq %rbx, %rdi
movq %r15, %rsi
callq 0x28b4
jmp 0x33fd
movq %rsp, %rdi
callq 0x20c0
leaq 0x20(%rsp), %rdi
callq 0x2120
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x20c0
leaq 0x20(%rsp), %rdi
callq 0x2120
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/ekg[P]tsvtools/split.cpp
// Function: split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
std::vector<std::string> &split(const std::string &s, const std::string& delims, std::vector<std::string> &elems) {
    char* tok;
    char cchars [s.size()+1];
    char* cstr = &cchars[0];
    strcpy(cstr, s.c_str());
    tok = strtok(cstr, delims.c_str());
    while (tok != NULL) {
        elems.push_back(tok);
        tok = strtok(NULL, delims.c_str());
    }
    return elems;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq 0x8(%rdi), %rax
movq %rsp, %r15
addq $0x10, %rax
andq $-0x10, %rax
subq %rax, %r15
movq %r15, %rsp
movq (%rdi), %rsi
movq %r15, %rdi
callq 0x2170
movq (%r14), %rsi
movq %r15, %rdi
callq 0x2210
leaq -0x48(%rbp), %r15
leaq -0x21(%rbp), %r12
testq %rax, %rax
je 0x3531
movq %r15, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0x280a
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2b48
movq %r15, %rdi
callq 0x20c0
movq (%r14), %rsi
xorl %edi, %edi
callq 0x2210
jmp 0x34ff
movq %rbx, %rax
leaq -0x20(%rbp), %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x20c0
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/gjoni[P]iPot/src/Options.cpp
// Function: PrintOpts(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, double)
void PrintOpts(const std::string &exec, const double DMAX) {

	printf("\nUsage:   ./%s [-option] [argument]\n\n", exec.c_str());
	printf("Options:  -r receptor.pdb \\  # PDB file with receptor's coordinates\n");
	printf("          -l ligand.pdb \\    # (optional) PDB file with ligand's coordinates\n");
	printf("          -t table.txt \\     # (optional) %s contact potential table \n", exec.c_str());
	printf("          -d dmax            # (optional) contact distance, default dmax=%.1fA\n", DMAX);
	printf("\n");

}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
movq (%rdi), %rsi
leaq 0x95d4(%rip), %rdi      # 0x17028
xorl %eax, %eax
callq 0x2050
leaq 0x96b9(%rip), %rdi      # 0x1711b
callq 0x2330
leaq 0x96f1(%rip), %rdi      # 0x1715f
callq 0x2330
movq (%rbx), %rsi
leaq 0x95d1(%rip), %rdi      # 0x1704e
xorl %eax, %eax
callq 0x2050
leaq 0x960a(%rip), %rdi      # 0x17095
movsd 0x8(%rsp), %xmm0
movb $0x1, %al
callq 0x2050
pushq $0xa
popq %rdi
addq $0x10, %rsp
popq %rbx
jmp 0x22f0
// File: /workspace/github_cpp_makefile_star2_O2/gjoni[P]iPot/src/Options.cpp
// Function: GetOpts(int, char**, OPTS&)
bool GetOpts(int argc, char *argv[], OPTS &opts) {

	char tmp;
	while ((tmp = getopt(argc, argv, "hs:r:l:t:d:")) != -1) {
		switch (tmp) {
		case 'h': /* help */
			printf("!!! HELP !!!\n");
			return false;
			break;
		case 'r': /* receptor file */
			opts.rec = std::string(optarg);
			break;
		case 'l': /* ligand file */
			opts.lig = std::string(optarg);
			break;
		case 't': /* table file */
			opts.table = std::string(optarg);
			break;
		case 'd': /* distance cutoff */
			opts.dmax = atof(optarg);
			break;
		default:
			return false;
			break;
		}
	}

	if (opts.rec == "") {
		printf("Error: receptor file not specified ('-r')\n");
		return false;
	}

	return true;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
leaq 0x40(%rdx), %rax
movq %rax, 0x10(%rsp)
leaq 0x20(%rdx), %rax
movq %rax, 0x8(%rsp)
leaq 0x9611(%rip), %r13      # 0x170e5
leaq 0x9529(%rip), %r12      # 0x17004
leaq 0x18(%rsp), %r15
movl %ebp, %edi
movq %r14, %rsi
movq %r13, %rdx
callq 0x2090
shll $0x18, %eax
cmpl $0xff000000, %eax       # imm = 0xFF000000
je 0xdb96
sarl $0x18, %eax
addl $-0x64, %eax
rorl %eax
cmpl $0x8, %eax
ja 0xdbc2
movslq (%r12,%rax,4), %rax
addq %r12, %rax
jmpq *%rax
movq 0x1e4b4(%rip), %rax     # 0x2bfd0
movq (%rax), %rdi
callq 0x22a0
movsd %xmm0, 0x60(%rbx)
jmp 0xdae0
movq 0x1e49e(%rip), %rax     # 0x2bfd0
movq (%rax), %rsi
movq %r15, %rdi
leaq 0x7(%rsp), %rdx
callq 0xdbd4
movq %rbx, %rdi
jmp 0xdb81
movq 0x1e482(%rip), %rax     # 0x2bfd0
movq (%rax), %rsi
movq %r15, %rdi
leaq 0x7(%rsp), %rdx
callq 0xdbd4
movq 0x8(%rsp), %rdi
jmp 0xdb81
movq 0x1e464(%rip), %rax     # 0x2bfd0
movq (%rax), %rsi
movq %r15, %rdi
leaq 0x7(%rsp), %rdx
callq 0xdbd4
movq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x2290
movq %r15, %rdi
callq 0x2100
jmp 0xdae0
leaq 0x94b0(%rip), %rsi      # 0x1704d
movq %rbx, %rdi
callq 0xdc0f
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
je 0xdbc4
leaq 0x95f8(%rip), %rdi      # 0x171ac
jmp 0xdbbd
leaq 0x9619(%rip), %rdi      # 0x171d6
callq 0x2330
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/gjoni[P]iPot/src/Atom.cpp
// Function: Atom::Atom()
Atom::Atom() :
		atomNum(1), altLoc(' '), x(0.0), y(0.0), z(0.0), occup(0.0), temp(0.0), residue(
		NULL), q(0.0), r(0.0), type(' ') {

	name[0] = '\n';
	x = y = z = 0.0;
	element[0] = '\n';
	charge[0] = '\n';

}

// Assembly:
movl $0x1, (%rdi)
movb $0x20, %al
movb %al, 0x9(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rdi)
andq $0x0, 0x50(%rdi)
movups %xmm0, 0x40(%rdi)
movb %al, 0x58(%rdi)
movb $0xa, %al
movb %al, 0x4(%rdi)
andq $0x0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movb %al, 0x38(%rdi)
movb %al, 0x3b(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/gjoni[P]iPot/src/Atom.cpp
// Function: Atom::Atom(AtomRecord const&)
Atom::Atom(const AtomRecord &source) :
		atomNum(source.atomNum), altLoc(source.altLoc), x(source.x), y(
				source.y), z(source.z), occup(source.occup), temp(source.temp), residue(
		NULL), q(source.q), r(source.r), type(' ') {

	strcpy(name, source.atomName);
	strcpy(element, source.element);
	strcpy(charge, source.charge);
	type = GetType(name);

}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %eax
movl %eax, (%rdi)
movb 0x9(%rsi), %al
movb %al, 0x9(%rdi)
movups 0x18(%rsi), %xmm0
movups %xmm0, 0x10(%rdi)
movups 0x28(%rsi), %xmm0
movups %xmm0, 0x20(%rdi)
movsd 0x38(%rsi), %xmm0
movsd %xmm0, 0x30(%rdi)
andq $0x0, 0x40(%rdi)
movups 0x50(%rsi), %xmm0
movups %xmm0, 0x48(%rdi)
movb $0x20, 0x58(%rdi)
addq $0x4, %rdi
addq $0x4, %rsi
callq 0x21e0
leaq 0x38(%rbx), %rdi
leaq 0x45(%r14), %rsi
callq 0x21e0
leaq 0x3b(%rbx), %rdi
addq $0x48, %r14
movq %r14, %rsi
callq 0x21e0
movl 0x4(%rbx), %eax
leal -0x30(%rax), %ecx
cmpb $0xa, %cl
movzbl 0x5(%rbx), %ecx
cmovael %eax, %ecx
movb %cl, 0x58(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/gjoni[P]iPot/src/Atom.cpp
// Function: Atom::operator=(Atom const&)
Atom& Atom::operator =(const Atom& source) {

	atomNum = source.atomNum;
	altLoc = source.altLoc;
	strcpy(name, source.name);
	x = source.x;
	y = source.y;
	z = source.z;
	occup = source.occup;
	temp = source.temp;
	strcpy(element, source.element);
	strcpy(charge, source.charge);
	residue = source.residue;
	q = source.q;
	r = source.r;
	type = source.type;

	return *this;

}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %eax
movl %eax, (%rdi)
movb 0x9(%rsi), %al
movb %al, 0x9(%rdi)
addq $0x4, %rdi
addq $0x4, %rsi
callq 0x21e0
movups 0x10(%r14), %xmm0
movups %xmm0, 0x10(%rbx)
movups 0x20(%r14), %xmm0
movups %xmm0, 0x20(%rbx)
movsd 0x30(%r14), %xmm0
movsd %xmm0, 0x30(%rbx)
leaq 0x38(%rbx), %rdi
leaq 0x38(%r14), %rsi
callq 0x21e0
leaq 0x3b(%rbx), %rdi
leaq 0x3b(%r14), %rsi
callq 0x21e0
movq 0x40(%r14), %rax
movq %rax, 0x40(%rbx)
movups 0x48(%r14), %xmm0
movups %xmm0, 0x48(%rbx)
movb 0x58(%r14), %al
movb %al, 0x58(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/gjoni[P]iPot/src/Atom.cpp
// Function: Atom::Dist(Atom const&, Atom const&)
double Atom::Dist(const Atom &A, const Atom &B) {

	double x = A.x - B.x;
	double y = A.y - B.y;
	double z = A.z - B.z;

	return sqrt(x * x + y * y + z * z);

}

// Assembly:
movsd 0x10(%rdi), %xmm0
movsd 0x18(%rdi), %xmm1
subsd 0x10(%rsi), %xmm0
subsd 0x18(%rsi), %xmm1
movsd 0x20(%rdi), %xmm2
subsd 0x20(%rsi), %xmm2
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
mulsd %xmm2, %xmm2
addsd %xmm0, %xmm2
sqrtsd %xmm2, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/gjoni[P]iPot/src/Chain.cpp
// Function: Chain::Chain(char const*)
Chain::Chain(const char *name) :
		atom(NULL), nAtoms(0), residue(NULL), nRes(0), kd(NULL), kdCA(
		NULL), kdCent(NULL), ca_trace(NULL) {

	/* open file */
	FILE *F;
	F = fopen(name, "r");
	if (F == NULL) {
		fprintf(stderr, "ERROR: Can't open PDB file '%s'\n", name);
		exit(1);
	}

	/* read file */
	char buf[81];
	std::vector<AtomRecord> atomRecordVector;

	/* read according to type */
	if (strncmp(name + strlen(name) - 4, ".pqr", 4) == 0) {

		/* read as PQR */
		while (fgets(buf, 81, F) != NULL) {
			if ((buf[0] == 'A') && (buf[1] == 'T')) {
				atomRecordVector.push_back(ReadAtomRecordPQR(buf));
			}
		}

	} else {

		/* read as PDB (in all other cases) */
		while (fgets(buf, 81, F) != NULL) {
			if ((buf[0] == 'A') && (buf[1] == 'T')) {
				atomRecordVector.push_back(ReadAtomRecord(buf));
			}
		}

	}
	fclose(F);

	if (atomRecordVector.size() == 0) {
		fprintf(stderr, "ERROR: No atoms were read from %s\n", name);
		exit(1);
	}

	InitChain(atomRecordVector);

	SetResMap();

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
andl $0x0, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
andq $0x0, 0x40(%rdi)
andl $0x0, 0x48(%rdi)
movq %rsi, %r14
andl $0x0, 0x38(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x50(%rdi)
movups %xmm0, 0x60(%rdi)
leaq 0xac1c(%rip), %rsi      # 0x18b4d
movq %r14, %rdi
callq 0x2250
testq %rax, %rax
je 0xe042
movq %rax, %r15
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
movq %r14, %rdi
callq 0x20f0
movq %r14, 0x18(%rsp)
leaq (%r14,%rax), %rdi
addq $-0x4, %rdi
leaq 0xabdc(%rip), %rsi      # 0x18b4a
pushq $0x4
popq %rdx
callq 0x2110
leaq 0x20(%rsp), %r12
pushq $0x51
popq %rbp
testl %eax, %eax
je 0xdfc2
leaq 0x78(%rsp), %r13
movq %rsp, %r14
movq %r12, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x2360
testq %rax, %rax
je 0xe002
cmpb $0x41, 0x20(%rsp)
jne 0xdf8a
cmpb $0x54, 0x21(%rsp)
jne 0xdf8a
movq %r13, %rdi
movq %r12, %rdx
callq 0xe198
movq %r14, %rdi
movq %r13, %rsi
callq 0xfb24
jmp 0xdf8a
leaq 0x78(%rsp), %r14
movq %rsp, %r13
movq %r12, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x2360
testq %rax, %rax
je 0xe002
cmpb $0x41, 0x20(%rsp)
jne 0xdfca
cmpb $0x54, 0x21(%rsp)
jne 0xdfca
movq %r14, %rdi
movq %r12, %rdx
callq 0xe09c
movq %r13, %rdi
movq %r14, %rsi
callq 0xfb24
jmp 0xdfca
movq %r15, %rdi
callq 0x2200
movq 0x8(%rsp), %rax
cmpq (%rsp), %rax
je 0xe058
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xe2f0
movq %rbx, %rdi
callq 0xe706
movq %rsp, %rdi
callq 0xfae8
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x1df97(%rip), %rax     # 0x2bfe0
movq (%rax), %rdi
leaq 0xaad6(%rip), %rsi      # 0x18b29
movq %r14, %rdx
jmp 0xe06e
movq 0x1df81(%rip), %rax     # 0x2bfe0
movq (%rax), %rdi
leaq 0xaae6(%rip), %rsi      # 0x18b4f
movq 0x18(%rsp), %rdx
xorl %eax, %eax
callq 0x2310
pushq $0x1
popq %rdi
callq 0x2270
jmp 0xe081
jmp 0xe081
movq %rax, %r14
movq %rsp, %rdi
callq 0xfae8
movq %rbx, %rdi
callq 0xf5ac
movq %r14, %rdi
callq 0x23a0
// File: /workspace/github_cpp_makefile_star2_O2/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 0xaaff(%rip), %rsi      # 0x18bcd
xorl %eax, %eax
callq 0x21f0
movups 0x50(%rbx), %xmm0
shufps $0x4e, %xmm0, %xmm0     # xmm0 = xmm0[2,3,0,1]
movups %xmm0, 0x30(%rbx)
movb %bpl, 0x36(%r14)
leaq 0x2e(%r14), %rdi
callq 0x22a0
movsd %xmm0, 0x28(%rbx)
movb %bpl, 0x2e(%r14)
leaq 0x26(%r14), %rdi
callq 0x22a0
movsd %xmm0, 0x20(%rbx)
movb %bpl, 0x26(%r14)
leaq 0x1e(%r14), %rdi
callq 0x22a0
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 0xcd7f(%rip), %r15      # 0x1aec7
movq %r15, %rsi
xorl %eax, %eax
callq 0x21f0
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 0x21f0
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_O2/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 0xfff2
xorl %r15d, %r15d
leaq 0x8(%rsp), %r14
xorl %r12d, %r12d
movslq 0x48(%rbx), %rax
cmpq %rax, %r12
jge 0xe763
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 0xf546
movq %r13, (%rax)
incq %r12
addq $0x188, %r15            # imm = 0x188
jmp 0xe726
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rdi, %rbx
leaq 0x8(%rdi), %rax
andl $0x0, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
andq $0x0, 0x40(%rdi)
andl $0x0, 0x48(%rdi)
movq %rsi, %r14
andl $0x0, 0x38(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%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 0xf4ca
xorl %eax, %eax
leaq 0x80(%rsp), %r15
leaq 0x20(%rsp), %r12
pushq $0xc
popq %r13
movl %eax, %ebp
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
cmpq %rbp, %rcx
jbe 0xe831
movq %rbp, %rcx
shlq $0x5, %rcx
movq (%rax,%rcx), %rsi
movq %r15, %rdi
callq 0x21e0
movq %r12, %rdi
movq %r15, %rdx
callq 0xe198
imulq $0x60, %rbp, %rdi
addq 0x8(%rsp), %rdi
movq %r13, %rcx
movq %r12, %rsi
rep  movsq (%rsi), %es:(%rdi)
leal 0x1(%rbp), %eax
jmp 0xe7e7
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xe2f0
movq %rbx, %rdi
callq 0xe706
leaq 0x8(%rsp), %rdi
callq 0xfae8
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0xe874
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xfae8
movq %rbx, %rdi
callq 0xf5ac
movq %r14, %rdi
callq 0x23a0
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbx
movl 0x48(%rdi), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
xorl %edx, %edx
cmpq %rax, %rcx
je 0xe8e1
movslq %edx, %rdx
leaq (,%rdx,8), %r8
imulq $0x188, %rcx, %r9       # imm = 0x188
xorl %r10d, %r10d
xorl %esi, %esi
movq 0x40(%rdi), %r11
movslq 0x18(%r11,%r9), %rbx
cmpq %rbx, %rsi
jge 0xe8d9
addq %r9, %r11
movq 0x10(%r11), %r11
addq %r10, %r11
movq 0x30(%rdi), %rbx
addq %r8, %rbx
movq %r11, (%rbx,%rsi,8)
incq %rsi
addq $0x60, %r10
jmp 0xe8ad
incq %rcx
addq %rsi, %rdx
jmp 0xe891
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xe900
callq 0x1634c
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0xe90e
callq 0x1634c
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0xe91c
callq 0x1634c
pushq $0x3
popq %rbp
movl %ebp, %edi
callq 0x1632c
movq %rax, 0x50(%rbx)
movl %ebp, %edi
callq 0x1632c
movq %rax, 0x58(%rbx)
movl %ebp, %edi
callq 0x1632c
movq %rax, 0x60(%rbx)
xorl %ecx, %ecx
xorl %r13d, %r13d
movslq 0x48(%rbx), %rax
cmpq %rax, %rcx
jge 0xea3a
movslq %r13d, %r13
leaq (,%r13,8), %r14
movq %rcx, (%rsp)
imulq $0x188, %rcx, %r12      # imm = 0x188
pushq $0x4
popq %r15
xorl %ebp, %ebp
movq 0x40(%rbx), %rsi
leaq (%rsi,%r12), %rax
movslq 0x18(%rsi,%r12), %rcx
cmpq %rcx, %rbp
jge 0xe9b5
movq 0x10(%rax), %rax
movq 0x50(%rbx), %rdi
movsd -0x10(%rax,%r15,8), %xmm0
movsd -0x8(%rax,%r15,8), %xmm1
movsd (%rax,%r15,8), %xmm2
movq 0x30(%rbx), %rsi
addq %r14, %rsi
callq 0x1667c
incq %rbp
addq $0xc, %r15
addq $0x8, %r14
jmp 0xe96e
movq 0x168(%rax), %r14
testq %r14, %r14
je 0xea10
movq 0x58(%rbx), %rdi
movsd 0x10(%r14), %xmm0
movsd 0x18(%r14), %xmm1
movsd 0x20(%r14), %xmm2
movq %r14, %rsi
callq 0x1667c
movq 0x40(%rbx), %rsi
cmpb $0x7, (%rsi,%r12)
jne 0xea10
addq %r12, %rsi
movq 0x60(%rbx), %rdi
movsd 0x10(%r14), %xmm0
movsd 0x18(%r14), %xmm1
movsd 0x20(%r14), %xmm2
movq 0x10(%rsi), %rsi
callq 0x1667c
movq 0x40(%rbx), %rsi
cmpb $0x7, (%rsi,%r12)
je 0xea2b
addq %r12, %rsi
movq 0x60(%rbx), %rdi
movq 0x10(%rsi), %rdx
addq $0x20, %rsi
callq 0x163fb
addq %rbp, %r13
movq (%rsp), %rcx
incq %rcx
jmp 0xe945
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xf604
andq $0x0, 0x30(%rbx)
movl 0x38(%r14), %eax
movl %eax, 0x38(%rbx)
andq $0x0, 0x40(%rbx)
movslq 0x48(%r14), %r13
movl $0x188, %ecx            # imm = 0x188
movq %r13, %rax
mulq %rcx
movq %rax, %r15
seto %al
addq $0x8, %r15
pushq $-0x1
popq %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 0xeaf0
imulq $-0x188, %r13, %r12     # imm = 0xFE78
xorl %ebp, %ebp
movq 0x10(%rsp), %r13
movq %r13, %rdi
callq 0x12d0c
addq $-0x188, %rbp           # imm = 0xFE78
addq $0x188, %r13            # imm = 0x188
cmpq %rbp, %r12
jne 0xead5
movq 0x10(%rsp), %rax
movq %rax, 0x40(%rbx)
xorl %r15d, %r15d
xorl %r12d, %r12d
movslq 0x48(%rbx), %rax
cmpq %rax, %r12
jge 0xeb27
movq 0x40(%r14), %rsi
addq %r15, %rsi
movq 0x40(%rbx), %rdi
addq %r15, %rdi
callq 0x138e4
incq %r12
addq $0x188, %r15            # imm = 0x188
jmp 0xeaff
movslq 0x38(%rbx), %rax
leaq (,%rax,8), %rdi
testq %rax, %rax
pushq $-0x1
popq %rax
cmovsq %rax, %rdi
callq 0x2030
movq %rax, 0x30(%rbx)
movq %rbx, %rdi
callq 0xe884
movq %rbx, %rdi
callq 0xe8e4
movslq 0x48(%rbx), %r13
movq %r13, %rdi
shlq $0x3, %rdi
callq 0x22d0
movq %rax, 0x68(%rbx)
xorl %r12d, %r12d
pushq $0x18
popq %r15
movslq %r13d, %rax
cmpq %rax, %r12
jge 0xebb0
movq %r15, %rdi
callq 0x22d0
movq 0x68(%rbx), %rcx
movq %rax, (%rcx,%r12,8)
movq 0x68(%rbx), %rax
movq (%rax,%r12,8), %rax
movq 0x68(%r14), %rcx
movq (%rcx,%r12,8), %rcx
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movups (%rcx), %xmm0
movups %xmm0, (%rax)
incq %r12
movl 0x48(%rbx), %r13d
jmp 0xeb71
movq %rbx, %rdi
callq 0xe706
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xec01
movq %rax, %r14
testq %rbp, %rbp
je 0xebf2
negq %rbp
movq 0x8(%rsp), %r12
addq $-0x180, %r12           # imm = 0xFE80
leaq (%r12,%rbp), %rdi
callq 0x13872
addq $-0x188, %rbp           # imm = 0xFE78
jne 0xebe0
movq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x23f0
jmp 0xec04
movq %rax, %r14
movq %rbx, %rdi
callq 0xf5ac
movq %r14, %rdi
callq 0x23a0
// File: /workspace/github_cpp_makefile_star2_O2/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 0xec2e
callq 0x22b0
andq $0x0, 0x30(%rbx)
movq 0x40(%rbx), %r15
testq %r15, %r15
je 0xec7c
leaq -0x8(%r15), %r14
movq -0x8(%r15), %r12
testq %r12, %r12
je 0xec69
addq $-0x188, %r15           # imm = 0xFE78
imulq $0x188, %r12, %r13      # imm = 0x188
leaq (%r15,%r13), %rdi
callq 0x13872
addq $-0x188, %r13           # imm = 0xFE78
jne 0xec57
imulq $0x188, %r12, %rsi      # imm = 0x188
addq $0x8, %rsi
movq %r14, %rdi
callq 0x23f0
andq $0x0, 0x40(%rbx)
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0xec8f
callq 0x1634c
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0xec9d
callq 0x1634c
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0xecab
callq 0x1634c
cmpq $0x0, 0x68(%rbx)
je 0xecd5
xorl %r14d, %r14d
movslq 0x48(%rbx), %rax
movq 0x68(%rbx), %rdi
cmpq %rax, %r14
jge 0xecd0
movq (%rdi,%r14,8), %rdi
callq 0x2260
incq %r14
jmp 0xecb5
callq 0x2260
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xf5ac
movq %rax, %rdi
callq 0xf53a
// File: /workspace/github_cpp_makefile_star2_O2/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), %rdx
movb $0x1, %al
movb %al, 0x158(%rdx)
movslq 0x48(%rdi), %rcx
imulq $0x188, %rcx, %rsi      # imm = 0x188
movb %al, -0x2f(%rdx,%rsi)
movl $0x2f0, %edx            # imm = 0x2F0
addq 0x40(%rdi), %rdx
pushq $0x1
popq %rsi
movsd 0x82a7(%rip), %xmm0     # 0x17200
cmpq %rcx, %rsi
jge 0xefc6
movq -0x188(%rdx), %rdi
testq %rdi, %rdi
je 0xefba
movq (%rdx), %r8
testq %r8, %r8
je 0xefba
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
sqrtsd %xmm3, %xmm1
ucomisd %xmm0, %xmm1
jbe 0xefba
movb %al, -0x197(%rdx)
movb %al, -0x10(%rdx)
incq %rsi
addq $0x188, %rdx            # imm = 0x188
jmp 0xef59
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorl %r12d, %r12d
xorl %r13d, %r13d
movslq 0x48(%rbx), %rax
cmpq %rax, %r13
jge 0xf0c9
movq 0x40(%rbx), %rax
imulq $0x188, %r13, %rcx      # imm = 0x188
leaq (%rax,%rcx), %rdi
movl 0x18(%rax,%rcx), %eax
testl %eax, %eax
cmovlel %r12d, %eax
imulq $0x60, %rax, %rax
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0xf0bc
movq 0x10(%rdi), %rdx
movsd 0x10(%rdx,%rcx), %xmm1
movsd 0x18(%rdx,%rcx), %xmm2
movsd 0x20(%rdx,%rcx), %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(%rdx,%rcx)
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(%rdx,%rcx)
mulsd 0x38(%r14), %xmm2
mulsd 0x30(%r14), %xmm1
addsd %xmm2, %xmm1
mulsd 0x40(%r14), %xmm0
addsd %xmm1, %xmm0
addsd 0x10(%r15), %xmm0
movsd %xmm0, 0x20(%rdx,%rcx)
addq $0x60, %rcx
jmp 0xf00c
callq 0x13350
incq %r13
jmp 0xefe0
movq %rbx, %rdi
callq 0xe8e4
movslq 0x48(%rbx), %rax
movq 0x68(%rbx), %rcx
movl $0x168, %edx            # imm = 0x168
addq 0x40(%rbx), %rdx
xorl %esi, %esi
cmpq %rax, %rsi
jge 0xf11c
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
jmp 0xf0e4
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, 0x10(%rsp)
leaq 0x9a48(%rip), %rsi      # 0x18bd5
movq %r15, %rdi
callq 0x2250
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0xf2d2
xorl %ecx, %ecx
movq 0x10(%rsp), %rax
movslq 0x48(%rax), %rax
cmpq %rax, %rcx
jge 0xf2a2
movq %rcx, 0x18(%rsp)
imulq $0x188, %rcx, %rcx      # imm = 0x188
pushq $0x3b
popq %r13
xorl %ebp, %ebp
movq %rcx, 0x20(%rsp)
movq 0x10(%rsp), %rax
movq 0x40(%rax), %r14
movslq 0x18(%r14,%rcx), %rax
cmpq %rax, %rbp
jge 0xf295
addq %rcx, %r14
movq 0x10(%r14), %rbx
leaq (%rbx,%r13), %r15
addq $-0x37, %r15
movq %r15, %rdi
callq 0x20f0
leaq 0x99f6(%rip), %rsi      # 0x18bf9
cmpq $0x4, %rax
je 0xf220
movb (%r15), %al
addb $-0x31, %al
leaq 0x99e4(%rip), %rsi      # 0x18bf9
cmpb $0x4, %al
jb 0xf220
leaq 0x9a22(%rip), %rsi      # 0x18c42
leaq (%rbx,%r13), %r11
addq $-0x3, %r11
addq %r13, %rbx
movl -0x38(%r11), %edx
movsbl -0x2f(%r11), %r8d
leaq 0x1(%r14), %r9
movsbl 0x1c(%r14), %r10d
movl 0x8(%r14), %r12d
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 %r12
pushq %r10
callq 0x2310
addq $0x30, %rsp
incq %rbp
addq $0x60, %r13
movq 0x20(%rsp), %rcx
jmp 0xf1ce
movq 0x18(%rsp), %rcx
incq %rcx
jmp 0xf1a5
leaq 0x99e3(%rip), %rdi      # 0x18c8c
pushq $0x4
popq %rsi
pushq $0x1
popq %rdx
movq 0x8(%rsp), %rbx
movq %rbx, %rcx
callq 0x23e0
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2200
movq 0x1cd07(%rip), %rax     # 0x2bfe0
movq (%rax), %rdi
leaq 0x98f4(%rip), %rsi      # 0x18bd7
movq %r15, %rdx
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
movl 0x48(%rdi), %eax
movq 0x40(%rdi), %rcx
xorl %edx, %edx
testl %eax, %eax
cmovlel %edx, %eax
imulq $0x188, %rax, %rsi      # imm = 0x188
xorl %eax, %eax
cmpq %rdx, %rsi
je 0xf328
cmpb $0x14, (%rcx,%rdx)
adcl $0x0, %eax
addq $0x188, %rdx            # imm = 0x188
jmp 0xf313
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
xorl %r15d, %r15d
leaq 0x97bd(%rip), %r12      # 0x18b10
xorl %r13d, %r13d
movslq 0x48(%r14), %rax
cmpq %rax, %r13
jge 0xf381
movq 0x40(%r14), %rax
movsbq (%rax,%r15), %rax
movsbl (%rax,%r12), %esi
movq %rbx, %rdi
callq 0x21c0
incq %r13
addq $0x188, %r15            # imm = 0x188
jmp 0xf356
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x2100
movq %r14, %rdi
callq 0x23a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xf3e7
movq 0x40(%rdi), %rdx
xorl %esi, %esi
testl %ecx, %ecx
cmovlel %esi, %ecx
addq $0xc, %rdx
cmpq %rsi, %rcx
je 0xf3e1
movl (%rax,%rsi,4), %r8d
movl %r8d, -0x4(%rdx)
movb $0x20, (%rdx)
incq %rsi
addq $0x188, %rdx            # imm = 0x188
jmp 0xf3c5
popq %rax
jmp 0xe706
leaq 0x98a3(%rip), %rdi      # 0x18c91
leaq 0x9799(%rip), %rsi      # 0x18b8e
leaq 0x98ae(%rip), %rcx      # 0x18caa
movl $0x25b, %edx            # imm = 0x25B
callq 0x2160
// File: /workspace/github_cpp_makefile_star2_O2/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 0x10304
addq $0x8, %rbx
cmpq %rbx, %rax
je 0xf42f
movq 0x28(%rax), %rax
jmp 0xf431
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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)
leaq 0x30(%rdi), %r15
leaq 0x38(%rdi), %rax
movq %rax, 0x8(%rsp)
xorl %r12d, %r12d
leaq 0x18(%rsp), %r13
cmpq 0x10(%rsp), %r14
je 0x105ad
movq %r13, %rdi
movq %r14, %rsi
callq 0x11792
movq %r15, %rdi
leaq 0x38(%rsp), %rsi
callq 0x11fdc
cmpq 0x8(%rsp), %rax
je 0x10579
movl %r12d, %ebp
movl 0x40(%rax), %eax
movl %eax, %r12d
jmp 0x1058e
movq %r15, %rdi
leaq 0x38(%rsp), %rsi
callq 0x117cc
movl %r12d, (%rax)
leal 0x1(%r12), %ebp
movq %rbx, %rdi
movq %r13, %rsi
callq 0x117cc
movl %r12d, (%rax)
movq %r13, %rdi
callq 0x114fa
addq $0x40, %r14
movl %ebp, %r12d
jmp 0x10548
movl 0x58(%rbx), %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x105c1
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x114fa
movq %rbx, %rdi
callq 0x23a0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
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)
xorl %r12d, %r12d
testl %r15d, %r15d
cmovlel %r12d, %r15d
cmpq %r12, %r15
je 0x10628
movq %r14, %rdi
callq 0x22d0
movq 0x68(%rbx), %rcx
movq %rax, (%rcx,%r12,8)
incq %r12
jmp 0x1060e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/gjoni[P]iPot/src/AACE.cpp
// Function: AACE::ReadGroups(char const*)
int AACE::ReadGroups(const char *name) {

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

	const int STRMAX = 1000;
	char atom[10], type[10], buf[STRMAX];
	int n = 0;

	while (fgets(buf, STRMAX, F)) {
		if (buf[0] != '#') {
			if (sscanf(buf, "%s %s", atom, type) == 2) {
				std::map<std::string, int>::const_iterator it;
				it = TYPE_IDX.find(type);
				int t;
				if (it == TYPE_IDX.end()) {
					TYPE_IDX[type] = n;
					//printf("%s %d\n", type, n);
					t = n++;
				} else {
					t = it->second;
				}
				ATOM_IDX[atom] = t;
			}
		}
	}
	fclose(F);

	return TYPE_IDX.size();

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x458, %rsp            # imm = 0x458
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8199(%rip), %rsi      # 0x18b4d
movq %r15, %rdi
callq 0x2250
testq %rax, %rax
je 0x10b1a
movq %rax, %r14
leaq 0x30(%rbx), %rax
movq %rax, 0x20(%rsp)
movq %rbx, 0x28(%rsp)
leaq 0x38(%rbx), %rax
movq %rax, 0x30(%rsp)
leaq 0x70(%rsp), %r12
leaq 0xa4d9(%rip), %r13      # 0x1aec4
leaq 0x66(%rsp), %rbp
leaq 0x5c(%rsp), %r15
leaq 0x38(%rsp), %rbx
movq $0x0, 0x10(%rsp)
movq %r12, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
movq %r14, %rdx
callq 0x2360
testq %rax, %rax
je 0x10af8
cmpb $0x23, 0x70(%rsp)
je 0x10a03
movq %r12, %rdi
movq %r13, %rsi
movq %rbp, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x21f0
cmpl $0x2, %eax
jne 0x10a03
movq %rbx, %rdi
movq %r15, %rsi
leaq 0xf(%rsp), %rdx
callq 0xdbd4
movq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x11fdc
movq %rbx, %rdi
movq %rax, %rbx
callq 0x2100
cmpq 0x30(%rsp), %rbx
je 0x10a82
movq 0x10(%rsp), %rax
movl %eax, 0x1c(%rsp)
movl 0x40(%rbx), %eax
movq %rax, 0x10(%rsp)
leaq 0x38(%rsp), %rbx
jmp 0x10abe
leaq 0x38(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
leaq 0xf(%rsp), %rdx
callq 0xdbd4
movq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x1172c
movq 0x10(%rsp), %rcx
movl %ecx, (%rax)
movq %rbx, %rdi
callq 0x2100
movq 0x10(%rsp), %rax
incl %eax
movl %eax, 0x1c(%rsp)
movq %rbx, %rdi
movq %rbp, %rsi
leaq 0xf(%rsp), %rdx
callq 0xdbd4
movq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq 0x1172c
movq 0x10(%rsp), %rcx
movl %ecx, (%rax)
movq %rbx, %rdi
callq 0x2100
movl 0x1c(%rsp), %eax
movq %rax, 0x10(%rsp)
jmp 0x10a03
movq %r14, %rdi
callq 0x2200
movq 0x28(%rsp), %rax
movl 0x58(%rax), %eax
addq $0x458, %rsp            # imm = 0x458
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xa387(%rip), %rdi      # 0x1aea8
movq %r15, %rsi
xorl %eax, %eax
callq 0x2050
pushq $0x1
popq %rdi
callq 0x2270
jmp 0x10b3b
jmp 0x10b4a
jmp 0x10b3b
jmp 0x10b4a
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x2100
jmp 0x10b4d
movq %rax, %rbx
movq %rbx, %rdi
callq 0x23a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7fd9(%rip), %rsi      # 0x18b4d
movq %r15, %rdi
callq 0x2250
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x10c35
movq 0x58(%rbx), %r13
movl %r13d, %ebp
xorl %r14d, %r14d
testl %r13d, %r13d
cmovlel %r14d, %r13d
leaq 0xa19c(%rip), %r12      # 0x1ad3e
cmpq %r13, %r14
je 0x10c17
leaq 0x10(%rsp), %r15
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 0x22a0
movq 0x60(%rbx), %rax
movsd %xmm0, (%rax,%r14,8)
xorl %r15d, %r15d
cmpq %r15, %rbp
je 0x10c12
xorl %edi, %edi
movq %r12, %rsi
callq 0x2350
movq %rax, %rdi
callq 0x22a0
movq 0x68(%rbx), %rax
movq (%rax,%r14,8), %rax
movsd %xmm0, (%rax,%r15,8)
incq %r15
jmp 0x10be8
incq %r14
jmp 0x10ba2
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 0xa26c(%rip), %rdi      # 0x1aea8
movq %r15, %rsi
xorl %eax, %eax
callq 0x2050
pushq $0x1
popq %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O2/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 0x11986
leaq 0x30(%rbx), %r15
leaq 0x30(%r14), %rsi
movq %r15, %rdi
callq 0x11986
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%rbx)
movsd 0x70(%r14), %xmm0
movsd %xmm0, 0x70(%rbx)
leaq 0x78(%rbx), %rdi
leaq 0x78(%r14), %rsi
callq 0x22e0
movq 0x58(%rbx), %r15
movq %rbx, %rdi
movl %r15d, %esi
callq 0x105d6
movq 0x60(%rbx), %rdi
movq 0x60(%r14), %rsi
movslq %r15d, %r12
leaq (,%r12,8), %r15
movq %r15, %rdx
callq 0x21b0
xorl %r13d, %r13d
testl %r12d, %r12d
cmovlel %r13d, %r12d
cmpq %r13, %r12
je 0x10ce7
movq 0x68(%rbx), %rax
movq (%rax,%r13,8), %rdi
movq 0x68(%r14), %rax
movq (%rax,%r13,8), %rsi
movq %r15, %rdx
callq 0x21b0
incq %r13
jmp 0x10cc5
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %r15, %rdi
callq 0x11922
jmp 0x10d01
movq %rax, %r14
movq %rbx, %rdi
callq 0x11922
movq %r14, %rdi
callq 0x23a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x10df7
movl %esi, %r14d
xorl %r15d, %r15d
testl %esi, %esi
cmovlel %r15d, %r14d
movq 0x68(%rbx), %rdi
cmpq %r15, %r14
je 0x10df2
movq (%rdi,%r15,8), %rdi
callq 0x2260
incq %r15
jmp 0x10ddb
callq 0x2260
movq 0x60(%rbx), %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x10ebc
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x30(%rdi), %r15
movl 0x58(%rdi), %esi
callq 0x10dc0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x11bd8
leaq 0x30(%r14), %rsi
movq %r15, %rdi
callq 0x11bd8
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 0x105d6
movq 0x60(%rbx), %rdi
movq 0x60(%r14), %rsi
movslq %r15d, %r12
leaq (,%r12,8), %r15
movq %r15, %rdx
callq 0x21b0
xorl %r13d, %r13d
testl %r12d, %r12d
cmovlel %r13d, %r12d
cmpq %r13, %r12
je 0x10eaf
movq 0x68(%rbx), %rax
movq (%rax,%r13,8), %rdi
movq 0x68(%r14), %rax
movq (%rax,%r13,8), %rsi
movq %r15, %rdx
callq 0x21b0
incq %r13
jmp 0x10e8d
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x9fb1(%rip), %rdi      # 0x1ae74
leaq 0x9d4c(%rip), %rsi      # 0x1ac16
leaq 0x9fb3(%rip), %rcx      # 0x1ae84
movl $0xa5, %edx
callq 0x2160
nop