LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 0x0584[P]scmin-plus/src/repl/token.cpp
// Function: token::next_special(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool token::next_special(string& e) {
    char c = e[0];

    if (c == '\'') {
        s = c, type = tok_quote;
        e.erase(0, 1);
        return true;
    } else if (c == '.') {
        s = c, type = tok_pair;
        e.erase(0, 1);
        return true;
    } else if (c == '`') {
        s = c, type = tok_quasi;
        e.erase(0, 1);
        return true;
    } else if (c == ',') {
        s = c, type = (e[1] == '@' ? tok_unquote_sp : tok_unquote);
        e.erase(0, 1 + (e[1] == '@'));
        return true;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3570
movb (%rax), %al
movb %al, -0x19(%rbp)
movsbl -0x19(%rbp), %eax
cmpl $0x27, %eax
jne 0x1dffc
movq -0x28(%rbp), %rdi
movb -0x19(%rbp), %al
addq $0x58, %rdi
movsbl %al, %esi
callq 0x34a0
movq -0x28(%rbp), %rax
movl $0x4, 0x7c(%rax)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
callq 0x30a0
movb $0x1, -0x1(%rbp)
jmp 0x1e10e
movsbl -0x19(%rbp), %eax
cmpl $0x2e, %eax
jne 0x1e03e
movq -0x28(%rbp), %rdi
movb -0x19(%rbp), %al
addq $0x58, %rdi
movsbl %al, %esi
callq 0x34a0
movq -0x28(%rbp), %rax
movl $0x8, 0x7c(%rax)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
callq 0x30a0
movb $0x1, -0x1(%rbp)
jmp 0x1e10e
movsbl -0x19(%rbp), %eax
cmpl $0x60, %eax
jne 0x1e080
movq -0x28(%rbp), %rdi
movb -0x19(%rbp), %al
addq $0x58, %rdi
movsbl %al, %esi
callq 0x34a0
movq -0x28(%rbp), %rax
movl $0x5, 0x7c(%rax)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
callq 0x30a0
movb $0x1, -0x1(%rbp)
jmp 0x1e10e
movsbl -0x19(%rbp), %eax
cmpl $0x2c, %eax
jne 0x1e104
movq -0x28(%rbp), %rdi
movb -0x19(%rbp), %al
addq $0x58, %rdi
movsbl %al, %esi
callq 0x34a0
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x3570
movq %rax, %rcx
movq -0x28(%rbp), %rax
movsbl (%rcx), %esi
movl $0x6, %ecx
movl $0x7, %edx
cmpl $0x40, %esi
cmovel %edx, %ecx
movl %ecx, 0x7c(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x3570
movq -0x30(%rbp), %rdi
movsbl (%rax), %eax
cmpl $0x40, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
addl $0x1, %eax
movslq %eax, %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x30a0
movb $0x1, -0x1(%rbp)
jmp 0x1e10e
jmp 0x1e106
jmp 0x1e108
jmp 0x1e10a
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 0x0584[P]scmin-plus/src/repl/token.cpp
// Function: token::next_symbol(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool token::next_symbol(string& e) {
    const string delim = "() \"";
    int j = 0;

    for (; e[j] and delim.find(e[j]) == string::npos; j++)
        s += e[j];
    if (not is_cons_flavor(s, this))
        type = (s == "lambda" ? tok_lambda : tok_num_or_symb);
    e.erase(0, j);
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x3500
movq -0x50(%rbp), %rdx
leaq 0x3828(%rip), %rsi      # 0x2197b
leaq -0x30(%rbp), %rdi
callq 0xc230
jmp 0x1e15e
leaq -0x31(%rbp), %rdi
callq 0x3310
movl $0x0, -0x48(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x48(%rbp), %rsi
callq 0x3570
movq %rax, -0x60(%rbp)
jmp 0x1e181
movq -0x60(%rbp), %rcx
xorl %eax, %eax
cmpb $0x0, (%rcx)
movb %al, -0x61(%rbp)
je 0x1e1c0
movq -0x10(%rbp), %rdi
movslq -0x48(%rbp), %rsi
callq 0x3570
movq %rax, -0x70(%rbp)
jmp 0x1e1a2
movq -0x70(%rbp), %rax
leaq -0x30(%rbp), %rdi
xorl %ecx, %ecx
movl %ecx, %edx
movsbl (%rax), %esi
callq 0x33a0
cmpq $-0x1, %rax
sete %al
movb %al, -0x61(%rbp)
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0x1e1c9
jmp 0x1e233
movq -0x10(%rbp), %rdi
movslq -0x48(%rbp), %rsi
callq 0x3570
movq %rax, -0x78(%rbp)
jmp 0x1e1dc
movq -0x58(%rbp), %rdi
movq -0x78(%rbp), %rax
movsbl (%rax), %esi
addq $0x58, %rdi
callq 0x31e0
jmp 0x1e1f2
jmp 0x1e1f4
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x1e16e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x3310
jmp 0x1e2af
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x31d0
jmp 0x1e2af
movq -0x58(%rbp), %rsi
movq %rsi, %rdi
addq $0x58, %rdi
callq 0x1e2c0
movb %al, -0x79(%rbp)
jmp 0x1e248
movb -0x79(%rbp), %al
testb $0x1, %al
jne 0x1e286
jmp 0x1e251
movq -0x58(%rbp), %rdi
addq $0x58, %rdi
leaq 0x35c0(%rip), %rsi      # 0x21820
callq 0x10e20
movb %al, -0x7a(%rbp)
jmp 0x1e26a
movq -0x58(%rbp), %rax
movb -0x7a(%rbp), %sil
movl $0x3, %ecx
movl $0x9, %edx
testb $0x1, %sil
cmovnel %edx, %ecx
movl %ecx, 0x7c(%rax)
movq -0x10(%rbp), %rdi
movslq -0x48(%rbp), %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x30a0
jmp 0x1e299
leaq -0x30(%rbp), %rdi
callq 0x31d0
movb $0x1, %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x34f0
nopl (%rax,%rax)
// File: 0x0584[P]scmin-plus/src/repl/token.cpp
// Function: is_cons_flavor(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, token*)
static bool is_cons_flavor(const string& s, token *tok) {
    const string t = "r!";
    size_t front, rear;

    if ((s.rfind("set-c", 0) == 0 and has_suffix(s, t)))
        front = 5, rear = s.length() - 2, tok->isset = true;
    else if (s.front() == 'c' and s.back() == 'r')
        front = 1, rear = s.length() - 1, tok->isset = false;
    else
        return false;
    for (auto i = front; i < rear; i++)
        if (s[i] == 'a' or s[i] == 'd') tok->cons_s.push(s[i]);
        else return false;
    tok->type = token::tok_cons_flavor;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x3500
movq -0x78(%rbp), %rdx
leaq 0x34ac(%rip), %rsi      # 0x21797
leaq -0x38(%rbp), %rdi
callq 0xc230
jmp 0x1e2f6
leaq -0x39(%rbp), %rdi
callq 0x3310
movq -0x10(%rbp), %rdi
leaq 0x3693(%rip), %rsi      # 0x2199d
xorl %eax, %eax
movl %eax, %edx
callq 0x34c0
movq %rax, -0x80(%rbp)
jmp 0x1e319
movq -0x80(%rbp), %rax
cmpq $0x0, %rax
jne 0x1e39e
movq -0x10(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x1e7f0
movb %al, -0x81(%rbp)
jmp 0x1e338
movb -0x81(%rbp), %al
testb $0x1, %al
jne 0x1e344
jmp 0x1e39e
movq $0x5, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3420
subq $0x2, %rax
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rax
movb $0x1, 0x50(%rax)
jmp 0x1e3f5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0x3310
jmp 0x1e4a6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x31d0
jmp 0x1e4a6
movq -0x10(%rbp), %rdi
callq 0x3380
movsbl (%rax), %eax
cmpl $0x63, %eax
jne 0x1e3e3
movq -0x10(%rbp), %rdi
callq 0x3150
movsbl (%rax), %eax
cmpl $0x72, %eax
jne 0x1e3e3
movq $0x1, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3420
subq $0x1, %rax
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rax
movb $0x0, 0x50(%rax)
jmp 0x1e3f3
movb $0x0, -0x1(%rbp)
movl $0x1, -0x64(%rbp)
jmp 0x1e48f
jmp 0x1e3f5
movq -0x58(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
cmpq -0x60(%rbp), %rax
jae 0x1e479
movq -0x10(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x3330
movsbl (%rax), %eax
cmpl $0x61, %eax
je 0x1e431
movq -0x10(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x3330
movsbl (%rax), %eax
cmpl $0x64, %eax
jne 0x1e45c
movq -0x18(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x10(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x3330
movq -0x90(%rbp), %rdi
movq %rax, %rsi
callq 0x1e870
jmp 0x1e45a
jmp 0x1e469
movb $0x0, -0x1(%rbp)
movl $0x1, -0x64(%rbp)
jmp 0x1e48f
jmp 0x1e46b
movq -0x70(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x70(%rbp)
jmp 0x1e3fd
movq -0x18(%rbp), %rax
movl $0xa, 0x7c(%rax)
movb $0x1, -0x1(%rbp)
movl $0x1, -0x64(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x31d0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x34f0
nop
// File: 0x0584[P]scmin-plus/src/repl/token.cpp
// Function: token::next_token(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, token&)
bool token::next_token(string& e, token& tok) {
    for (int i = 0; e[i] and isspace(e[i]); i++)
        e.erase(i--, 1);
    if (e.empty() or e[0] == ';')
        return false;
    return tok.next_paren(e) or tok.next_string(e)
        or tok.next_special(e) or tok.next_symbol(e);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x3570
movq %rax, %rcx
xorl %eax, %eax
cmpb $0x0, (%rcx)
movb %al, -0x1d(%rbp)
je 0x1e4ff
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x3570
movsbl (%rax), %edi
callq 0x3040
cmpl $0x0, %eax
setne %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x1e508
jmp 0x1e52f
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x1c(%rbp)
movslq %eax, %rsi
movl $0x1, %edx
callq 0x30a0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1e4c7
movq -0x10(%rbp), %rdi
callq 0x34b0
testb $0x1, %al
jne 0x1e551
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3570
movsbl (%rax), %eax
cmpl $0x3b, %eax
jne 0x1e557
movb $0x0, -0x1(%rbp)
jmp 0x1e5ba
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1ddb0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x1e(%rbp)
jne 0x1e5b2
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1dec0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x1e(%rbp)
jne 0x1e5b2
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1df90
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x1e(%rbp)
jne 0x1e5b2
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1e120
movb %al, -0x1e(%rbp)
movb -0x1e(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 0x0584[P]scmin-plus/src/repl/token.cpp
// Function: token::tokenize(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
queue<token> token::tokenize(string& s) {
    queue<token> tokens;
    token tok;

    paren = {};
    while (next_token(s, tok) and not tok.err)
        tokens.push(tok), tok = {};
    // TODO: implement more sophisticated error management ////////////////////
    if (tok.err or paren.size()) {
        cerr << "there was error while lexing" << endl;
        return {};
    }
    return tokens;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rdi, -0x1d8(%rbp)
movq %rdi, %rax
movq %rax, -0x1d0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x1baf0
leaq -0xe0(%rbp), %rdi
callq 0x1e8a0
jmp 0x1e60b
leaq -0x140(%rbp), %rdi
callq 0x16110
jmp 0x1e619
leaq 0xfd10(%rip), %rdi      # 0x2e330
leaq -0x140(%rbp), %rsi
callq 0x1e8e0
leaq -0x140(%rbp), %rdi
callq 0x16140
movq -0x10(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
callq 0x1e4b0
movb %al, -0x1d9(%rbp)
jmp 0x1e650
movb -0x1d9(%rbp), %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x1da(%rbp)
jne 0x1e665
jmp 0x1e670
movb -0x68(%rbp), %al
xorb $-0x1, %al
movb %al, -0x1da(%rbp)
movb -0x1da(%rbp), %al
testb $0x1, %al
jne 0x1e67f
jmp 0x1e725
leaq -0x60(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
callq 0x1e910
jmp 0x1e691
leaq -0x1c0(%rbp), %rdi
callq 0x16110
jmp 0x1e69f
movb $0x0, -0x170(%rbp)
leaq -0x1c0(%rbp), %rdi
addq $0x58, %rdi
callq 0x33d0
movb $0x0, -0x148(%rbp)
movl $0x0, -0x144(%rbp)
leaq -0xe0(%rbp), %rdi
leaq -0x1c0(%rbp), %rsi
callq 0x1e940
leaq -0x1c0(%rbp), %rdi
callq 0x1bac0
jmp 0x1e638
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe8(%rbp)
movl %eax, -0xec(%rbp)
jmp 0x1e7d9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe8(%rbp)
movl %eax, -0xec(%rbp)
leaq -0xe0(%rbp), %rdi
callq 0x1bac0
jmp 0x1e7d9
testb $0x1, -0x68(%rbp)
jne 0x1e74d
leaq 0xfbfe(%rip), %rdi      # 0x2e330
callq 0x1ba60
movq %rax, -0x1e8(%rbp)
jmp 0x1e740
movq -0x1e8(%rbp), %rax
cmpq $0x0, %rax
je 0x1e798
movq 0xf89c(%rip), %rdi      # 0x2dff0
leaq 0x3225(%rip), %rsi      # 0x21980
callq 0x32c0
movq %rax, -0x1f0(%rbp)
jmp 0x1e769
movq -0x1f0(%rbp), %rdi
movq 0xf819(%rip), %rsi      # 0x2df90
callq 0x32f0
jmp 0x1e77e
movq -0x1d8(%rbp), %rdi
callq 0x1baf0
jmp 0x1e78c
movl $0x1, -0x1c4(%rbp)
jmp 0x1e7b4
movq -0x1d8(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x1e9a0
jmp 0x1e7aa
movl $0x1, -0x1c4(%rbp)
leaq -0xe0(%rbp), %rdi
callq 0x1bac0
leaq -0x60(%rbp), %rdi
callq 0x1bb50
movq -0x1d0(%rbp), %rax
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
leaq -0x60(%rbp), %rdi
callq 0x1bb50
movq -0xe8(%rbp), %rdi
callq 0x34f0
nop
// File: iZhangHui[P]CppPrimer/CH02_VariablesAndBasicTypes/examples/compounddecls.cc
// Function: main
int main()
{
	// i is an int; p is a pointer to int; r is a reference to int
	int i = 1024, *p = &i, &r = i;
	
	// three ways to print the value of i
	std::cout << i << " " <<  *p <<  " " << r << std::endl;

	int j = 42, *p2 = &j;
	int *&pref = p2;  // pref is a reference to the pointer p2

	// prints the value of j, which is the int to which p2 points
	std::cout << *pref << std::endl;
	
	// pref refers to a pointer; assigning &i to pref makes p point to i
	pref = &i; 
	std::cout << *pref << std::endl; // prints the value of i

	// dereferencing pref yields i, the int to which p2 points; 
	*pref = 0;  // changes i to 0
	
	std::cout << i << " " << *pref << std::endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl $0x400, -0x8(%rbp)      # imm = 0x400
leaq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0x8(%rbp), %esi
movq 0x2de8(%rip), %rdi      # 0x3fd8
callq 0x1070
movq %rax, %rdi
leaq 0xe05(%rip), %rsi       # 0x2004
callq 0x1040
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl (%rax), %esi
callq 0x1070
movq %rax, %rdi
leaq 0xde8(%rip), %rsi       # 0x2004
callq 0x1040
movq %rax, %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
callq 0x1070
movq %rax, %rdi
movq 0x2d8f(%rip), %rsi      # 0x3fc8
callq 0x1050
movl $0x2a, -0x1c(%rbp)
leaq -0x1c(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movl (%rax), %esi
movq 0x2d73(%rip), %rdi      # 0x3fd8
callq 0x1070
movq %rax, %rdi
movq 0x2d54(%rip), %rsi      # 0x3fc8
callq 0x1050
movq -0x30(%rbp), %rax
leaq -0x8(%rbp), %rcx
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movl (%rax), %esi
movq 0x2d44(%rip), %rdi      # 0x3fd8
callq 0x1070
movq %rax, %rdi
movq 0x2d25(%rip), %rsi      # 0x3fc8
callq 0x1050
movq -0x30(%rbp), %rax
movq (%rax), %rax
movl $0x0, (%rax)
movl -0x8(%rbp), %esi
movq 0x2d19(%rip), %rdi      # 0x3fd8
callq 0x1070
movq %rax, %rdi
leaq 0xd36(%rip), %rsi       # 0x2004
callq 0x1040
movq %rax, %rdi
movq -0x30(%rbp), %rax
movq (%rax), %rax
movl (%rax), %esi
callq 0x1070
movq %rax, %rdi
movq 0x2cda(%rip), %rsi      # 0x3fc8
callq 0x1050
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
// File: eschwabe[P]interview-practice/src/random_median.cpp
// Function: GetMedian()
double GetMedian() {
    if(low.size() == 0 && high.size() == 0) {
        return 0.0;
    } else if(low.size() < high.size()) {
        return high.top();
    } else {
        return (static_cast<double>(low.top()) + static_cast<double>(high.top())) / 2;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x4dd1(%rip), %rdi      # 0x60c0
callq 0x1610
cmpq $0x0, %rax
jne 0x1316
leaq 0x4ddf(%rip), %rdi      # 0x60e0
callq 0x1630
cmpq $0x0, %rax
jne 0x1316
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x1394
leaq 0x4da3(%rip), %rdi      # 0x60c0
callq 0x1610
movq %rax, -0x10(%rbp)
leaq 0x4db3(%rip), %rdi      # 0x60e0
callq 0x1630
movq %rax, %rcx
movq -0x10(%rbp), %rax
cmpq %rcx, %rax
jae 0x1355
leaq 0x4d9b(%rip), %rdi      # 0x60e0
callq 0x1650
cvtsi2sdl (%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x1394
leaq 0x4d64(%rip), %rdi      # 0x60c0
callq 0x1670
cvtsi2sdl (%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
leaq 0x4d6f(%rip), %rdi      # 0x60e0
callq 0x1650
movsd -0x18(%rbp), %xmm0
cvtsi2sdl (%rax), %xmm1
addsd %xmm1, %xmm0
movsd 0x1c7d(%rip), %xmm1     # 0x3008
divsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: eschwabe[P]interview-practice/src/random_median.cpp
// Function: AddNumber(int)
void AddNumber(int num) {
    // always store extra in high heap
    if(high.size() == 0) {
        high.push(num);
        return;
    }

    if(low.size() != high.size()) {
        if(num < high.top()) {
            low.push(num);
        } else {
            low.push(high.top());
            high.pop();
            high.push(num);
        }
    } else {
        if(num < low.top()) {
            high.push(low.top());
            low.pop();
            low.push(num);
        } else {
            high.push(num);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
leaq 0x4d2e(%rip), %rdi      # 0x60e0
callq 0x1630
cmpq $0x0, %rax
jne 0x13d2
leaq 0x4d1c(%rip), %rdi      # 0x60e0
leaq -0x4(%rbp), %rsi
callq 0x1690
jmp 0x14c8
leaq 0x4ce7(%rip), %rdi      # 0x60c0
callq 0x1610
movq %rax, -0x10(%rbp)
leaq 0x4cf7(%rip), %rdi      # 0x60e0
callq 0x1630
movq %rax, %rcx
movq -0x10(%rbp), %rax
cmpq %rcx, %rax
je 0x1461
movl -0x4(%rbp), %eax
movl %eax, -0x14(%rbp)
leaq 0x4cd9(%rip), %rdi      # 0x60e0
callq 0x1650
movq %rax, %rcx
movl -0x14(%rbp), %eax
cmpl (%rcx), %eax
jge 0x1428
leaq 0x4ca3(%rip), %rdi      # 0x60c0
leaq -0x4(%rbp), %rsi
callq 0x16e0
jmp 0x145f
leaq 0x4cb1(%rip), %rdi      # 0x60e0
callq 0x1650
movq %rax, %rsi
leaq 0x4c82(%rip), %rdi      # 0x60c0
callq 0x16e0
leaq 0x4c96(%rip), %rdi      # 0x60e0
callq 0x1730
leaq 0x4c8a(%rip), %rdi      # 0x60e0
leaq -0x4(%rbp), %rsi
callq 0x1690
jmp 0x14c8
movl -0x4(%rbp), %eax
movl %eax, -0x18(%rbp)
leaq 0x4c52(%rip), %rdi      # 0x60c0
callq 0x1670
movq %rax, %rcx
movl -0x18(%rbp), %eax
cmpl (%rcx), %eax
jge 0x14b6
leaq 0x4c3c(%rip), %rdi      # 0x60c0
callq 0x1670
movq %rax, %rsi
leaq 0x4c4d(%rip), %rdi      # 0x60e0
callq 0x1690
leaq 0x4c21(%rip), %rdi      # 0x60c0
callq 0x1780
leaq 0x4c15(%rip), %rdi      # 0x60c0
leaq -0x4(%rbp), %rsi
callq 0x16e0
jmp 0x14c6
leaq 0x4c23(%rip), %rdi      # 0x60e0
leaq -0x4(%rbp), %rsi
callq 0x1690
jmp 0x14c8
addq $0x20, %rsp
popq %rbp
retq
nop
// File: eschwabe[P]interview-practice/src/random_median.cpp
// Function: main
int main()
{
    for(int i = 0; i < 10; i++) {
        int num = rand() % 30;
        AddNumber(num);
        cout << "Add: " << num << "  Median: " << GetMedian() << endl;
        //if(i > 1)
        //cout << "LOW: " << low.top() << "   HIGH: " << high.top() << endl;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
cmpl $0xa, -0x8(%rbp)
jge 0x155d
callq 0x1030
movl $0x1e, %ecx
cltd
idivl %ecx
movl %edx, -0xc(%rbp)
movl -0xc(%rbp), %edi
callq 0x13a0
movq 0x4acd(%rip), %rdi      # 0x5fd8
leaq 0x1afe(%rip), %rsi      # 0x3010
callq 0x10b0
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x1110
movq %rax, %rdi
leaq 0x1aea(%rip), %rsi      # 0x3016
callq 0x10b0
movq %rax, -0x18(%rbp)
callq 0x12e0
movq -0x18(%rbp), %rdi
callq 0x1120
movq %rax, %rdi
movq 0x4a7b(%rip), %rsi      # 0x5fc8
callq 0x10e0
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x14e6
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: oknenavin[P]cxon/examples/../src/cxon/lang/common/cio/../charconv.hxx
// Function: cxon::charconv::imp::from_chars_result cxon::charconv::imp::(anonymous namespace)::number_from_chars_<int, long (*)(char const*, char**, int)>(char const*, char const*, long (*)(char const*, char**, int), int&, int)
inline from_chars_result number_from_chars_(const char* first, const char*, Cv convert, T& value, int base) noexcept {
                CXON_ASSERT(base >= 2 && base <= 36, "invalid base");
                    if (is_sign_invalid_<T>(*first)) return { first, std::errc::invalid_argument };
                char* end;
                errno = 0; auto const v = clamp_<T>(convert(first, &end, base));
                return { end, end != first ? errno != ERANGE ? (value = v, std::errc{}) : std::errc::result_out_of_range : std::errc::invalid_argument };
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movl %r8d, -0x34(%rbp)
xorl %eax, %eax
cmpl $0x2, -0x34(%rbp)
movb %al, -0x45(%rbp)
jl 0x2a41
cmpl $0x24, -0x34(%rbp)
setle %al
movb %al, -0x45(%rbp)
movb -0x45(%rbp), %al
testb $0x1, %al
jne 0x2a4a
jmp 0x2a4c
jmp 0x2a6b
leaq 0x9c5a(%rip), %rdi      # 0xc6ad
leaq 0x9c6b(%rip), %rsi      # 0xc6c5
movl $0x4c, %edx
leaq 0xa03d(%rip), %rcx      # 0xcaa3
callq 0x2140
movq -0x18(%rbp), %rax
movsbl (%rax), %edi
callq 0x2b40
testb $0x1, %al
jne 0x2a7d
jmp 0x2a91
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x16, -0x8(%rbp)
jmp 0x2b1c
callq 0x2040
movl $0x0, (%rax)
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rdi
movl -0x34(%rbp), %edx
leaq -0x40(%rbp), %rsi
callq *%rax
movq %rax, -0x50(%rbp)
jmp 0x2ab3
movq -0x50(%rbp), %rdi
callq 0x2b60
movl %eax, -0x44(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x58(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0x2b09
callq 0x2040
cmpl $0x22, (%rax)
je 0x2af7
movl -0x44(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
xorl %eax, %eax
movl %eax, -0x5c(%rbp)
jmp 0x2b01
movl $0x22, %eax
movl %eax, -0x5c(%rbp)
jmp 0x2b01
movl -0x5c(%rbp), %eax
movl %eax, -0x60(%rbp)
jmp 0x2b13
movl $0x16, %eax
movl %eax, -0x60(%rbp)
jmp 0x2b13
movq -0x58(%rbp), %rax
movl -0x60(%rbp), %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl -0x8(%rbp), %edx
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x3830
nopw %cs:(%rax,%rax)
// File: oknenavin[P]cxon/examples/../src/cxon/lang/common/cio/numeric.hxx
// Function: std::enable_if<std::is_integral<int>::value && !cxon::json::format_traits::number::strict, bool>::type cxon::cio::num::imp::number_read__<cxon::json::format_traits, int, cxon::context<cxon::JSON<cxon::json::format_traits>>>(int&, char const*&, char const*, cxon::context<cxon::JSON<cxon::json::format_traits>>&)
inline auto number_read__(T& t, const char*& i, const char* e, Cx& cx)
                -> enable_if_t<std::is_integral<T>::value && !X::number::strict, bool>
            {
                constexpr auto base = integer_base::constant<napa_type<Cx>>(10);
                auto const r = charconv::from_chars(i, e, t, base);
                    if (r.ec != std::errc()) return cx/X::read_error::integral_invalid;
                return i = r.ptr, true;
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl $0xa, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
movl $0xa, %ecx
callq 0xa6f0
movq %rax, -0x40(%rbp)
movl %edx, -0x38(%rbp)
cmpl $0x0, -0x38(%rbp)
je 0xa6ca
movq -0x28(%rbp), %rdi
movl $0x3, %esi
callq 0x7dd0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xa6d9
movq -0x40(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: ekg[P]tsvtools/./join.h
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> join<char const [2], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, char const (&) [2])
std::string join(std::vector<T>& elems, S& delim) {
    std::stringstream ss;
    typename std::vector<T>::iterator e = elems.begin();
    ss << *e++;
    for (; e != elems.end(); ++e) {
        ss << delim << *e;
    }
    return ss.str();
}

// Assembly:
subq $0x1e8, %rsp            # imm = 0x1E8
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x1e0(%rsp)
movq %rsi, 0x1d8(%rsp)
movq %rdx, 0x1d0(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x2150
movq 0x1d8(%rsp), %rdi
callq 0x2f50
movq %rax, 0x40(%rsp)
leaq 0x58(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x40(%rsp), %rdi
xorl %esi, %esi
callq 0x6530
movq %rax, 0x38(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x30e0
movq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0x21c0
jmp 0x33cc
jmp 0x33ce
movq 0x1d8(%rsp), %rdi
callq 0x2fc0
movq %rax, 0x20(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x2f80
testb $0x1, %al
jne 0x33f5
jmp 0x344d
leaq 0x58(%rsp), %rdi
movq 0x1d0(%rsp), %rsi
callq 0x21f0
movq %rax, (%rsp)
jmp 0x340d
leaq 0x40(%rsp), %rdi
callq 0x30e0
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x21c0
jmp 0x3425
jmp 0x3427
leaq 0x40(%rsp), %rdi
callq 0x30f0
jmp 0x33ce
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x2170
jmp 0x3475
movq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x21e0
jmp 0x345e
leaq 0x48(%rsp), %rdi
callq 0x2170
movq 0x10(%rsp), %rax
addq $0x1e8, %rsp            # imm = 0x1E8
retq
movq 0x30(%rsp), %rdi
callq 0x2340
nop
// File: 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:
subq $0x1f8, %rsp            # imm = 0x1F8
movb %sil, %al
movq %rdi, 0x1f0(%rsp)
movb %al, 0x1ef(%rsp)
movq %rdx, 0x1e0(%rsp)
movq 0x1f0(%rsp), %rax
movq %rax, 0x20(%rsp)
movl $0x10, %edi
movl $0x8, %esi
callq 0x6940
movq 0x20(%rsp), %rsi
movl %eax, %edx
leaq 0x58(%rsp), %rdi
callq 0x2300
leaq 0x38(%rsp), %rdi
callq 0x22c0
movsbl 0x1ef(%rsp), %edx
leaq 0x58(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x2370
movq %rax, 0x18(%rsp)
jmp 0x6606
movq 0x18(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x22a0
movb %al, 0x17(%rsp)
jmp 0x6620
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x662a
jmp 0x6664
movq 0x1e0(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x31b0
jmp 0x663e
jmp 0x65e8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x2110
leaq 0x58(%rsp), %rdi
callq 0x2170
jmp 0x6692
movq 0x1e0(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x2110
leaq 0x58(%rsp), %rdi
callq 0x2170
movq 0x8(%rsp), %rax
addq $0x1f8, %rsp            # imm = 0x1F8
retq
movq 0x30(%rsp), %rdi
callq 0x2340
nopl (%rax)
// File: 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
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2140
movq %rax, %rdx
movq %rdx, %rcx
incq %rcx
movq %rsp, %rax
movq %rax, -0x28(%rbp)
addq $0x10, %rdx
andq $-0x10, %rdx
movq %rsp, %rax
subq %rdx, %rax
movq %rax, %rsp
movq %rcx, -0x30(%rbp)
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x8(%rbp), %rdi
callq 0x20b0
movq -0x80(%rbp), %rdi
movq %rax, %rsi
callq 0x21d0
movq -0x38(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20b0
movq -0x78(%rbp), %rdi
movq %rax, %rsi
callq 0x22f0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x6881
movq -0x18(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x59(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x2350
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdx
leaq -0x58(%rbp), %rdi
callq 0x2e40
jmp 0x6811
movq -0x98(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x2f10
jmp 0x6823
leaq -0x58(%rbp), %rdi
callq 0x2110
leaq -0x59(%rbp), %rdi
callq 0x2250
movq -0x10(%rbp), %rdi
callq 0x20b0
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x22f0
movq %rax, -0x20(%rbp)
jmp 0x67c7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x6876
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x2110
leaq -0x59(%rbp), %rdi
callq 0x2250
jmp 0x6891
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, %rsp
movq %rbp, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x2340
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3110
movq %rax, %rsi
leaq 0x1ab94(%rip), %rdi     # 0x33048
movb $0x0, %al
callq 0x3070
leaq 0x1abac(%rip), %rdi     # 0x3306e
movb $0x0, %al
callq 0x3070
leaq 0x1abe3(%rip), %rdi     # 0x330b3
movb $0x0, %al
callq 0x3070
movq -0x8(%rbp), %rdi
callq 0x3110
movq %rax, %rsi
leaq 0x1ac17(%rip), %rdi     # 0x33101
movb $0x0, %al
callq 0x3070
movsd -0x10(%rbp), %xmm0
leaq 0x1ac4b(%rip), %rdi     # 0x33148
movb $0x1, %al
callq 0x3070
leaq 0x1ab61(%rip), %rdi     # 0x3306c
movb $0x0, %al
callq 0x3070
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x1, (%rax)
movb $0x20, 0x9(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x18(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x28(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rax)
movq $0x0, 0x40(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x48(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x50(%rax)
movb $0x20, 0x58(%rax)
movb $0xa, 0x4(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x18(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rax)
movb $0xa, 0x38(%rax)
movb $0xa, 0x3b(%rax)
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, (%rdi)
movq -0x10(%rbp), %rax
movb 0x9(%rax), %al
movb %al, 0x9(%rdi)
movq -0x10(%rbp), %rax
movsd 0x18(%rax), %xmm0
movsd %xmm0, 0x10(%rdi)
movq -0x10(%rbp), %rax
movsd 0x20(%rax), %xmm0
movsd %xmm0, 0x18(%rdi)
movq -0x10(%rbp), %rax
movsd 0x28(%rax), %xmm0
movsd %xmm0, 0x20(%rdi)
movq -0x10(%rbp), %rax
movsd 0x30(%rax), %xmm0
movsd %xmm0, 0x28(%rdi)
movq -0x10(%rbp), %rax
movsd 0x38(%rax), %xmm0
movsd %xmm0, 0x30(%rdi)
movq $0x0, 0x40(%rdi)
movq -0x10(%rbp), %rax
movsd 0x50(%rax), %xmm0
movsd %xmm0, 0x48(%rdi)
movq -0x10(%rbp), %rax
movsd 0x58(%rax), %xmm0
movsd %xmm0, 0x50(%rdi)
movb $0x20, 0x58(%rdi)
addq $0x4, %rdi
movq -0x10(%rbp), %rsi
addq $0x4, %rsi
callq 0x3270
movq -0x18(%rbp), %rdi
addq $0x38, %rdi
movq -0x10(%rbp), %rsi
addq $0x45, %rsi
callq 0x3270
movq -0x18(%rbp), %rdi
addq $0x3b, %rdi
movq -0x10(%rbp), %rsi
addq $0x48, %rsi
callq 0x3270
movq -0x18(%rbp), %rdi
movq %rdi, %rsi
addq $0x4, %rsi
callq 0x18d80
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x58(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: gjoni[P]iPot/src/Atom.cpp
// Function: Atom::GetType(char*)
char Atom::GetType(char name[]) {

	if (name[0] == '0' || name[0] == '1' || name[0] == '2' || name[0] == '3'
			|| name[0] == '4' || name[0] == '5' || name[0] == '6'
			|| name[0] == '7' || name[0] == '8' || name[0] == '9') {

		/* first letter is a number */
		return name[1];

	} else {

		/* all other cases */
		return name[0];

	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
je 0x18e04
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x31, %eax
je 0x18e04
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x32, %eax
je 0x18e04
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x33, %eax
je 0x18e04
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x34, %eax
je 0x18e04
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x35, %eax
je 0x18e04
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x36, %eax
je 0x18e04
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x37, %eax
je 0x18e04
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x38, %eax
je 0x18e04
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x39, %eax
jne 0x18e10
movq -0x18(%rbp), %rax
movb 0x1(%rax), %al
movb %al, -0x1(%rbp)
jmp 0x18e19
movq -0x18(%rbp), %rax
movb (%rax), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, (%rdi)
movq -0x10(%rbp), %rax
movb 0x9(%rax), %al
movb %al, 0x9(%rdi)
addq $0x4, %rdi
movq -0x10(%rbp), %rsi
addq $0x4, %rsi
callq 0x3270
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movsd 0x10(%rax), %xmm0
movsd %xmm0, 0x10(%rdi)
movq -0x10(%rbp), %rax
movsd 0x18(%rax), %xmm0
movsd %xmm0, 0x18(%rdi)
movq -0x10(%rbp), %rax
movsd 0x20(%rax), %xmm0
movsd %xmm0, 0x20(%rdi)
movq -0x10(%rbp), %rax
movsd 0x28(%rax), %xmm0
movsd %xmm0, 0x28(%rdi)
movq -0x10(%rbp), %rax
movsd 0x30(%rax), %xmm0
movsd %xmm0, 0x30(%rdi)
addq $0x38, %rdi
movq -0x10(%rbp), %rsi
addq $0x38, %rsi
callq 0x3270
movq -0x18(%rbp), %rdi
addq $0x3b, %rdi
movq -0x10(%rbp), %rsi
addq $0x3b, %rsi
callq 0x3270
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x40(%rcx), %rcx
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rcx
movsd 0x48(%rcx), %xmm0
movsd %xmm0, 0x48(%rax)
movq -0x10(%rbp), %rcx
movsd 0x50(%rcx), %xmm0
movsd %xmm0, 0x50(%rax)
movq -0x10(%rbp), %rcx
movb 0x58(%rcx), %cl
movb %cl, 0x58(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsd 0x10(%rax), %xmm0
movq -0x10(%rbp), %rax
subsd 0x10(%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movsd 0x18(%rax), %xmm0
movq -0x10(%rbp), %rax
subsd 0x18(%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movsd 0x20(%rax), %xmm0
movq -0x10(%rbp), %rax
subsd 0x20(%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x18(%rbp), %xmm1
movsd -0x18(%rbp), %xmm2
movsd -0x20(%rbp), %xmm0
mulsd -0x20(%rbp), %xmm0
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd -0x28(%rbp), %xmm0
movsd -0x28(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
callq 0x3220
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x1bcb0
movl $0x0, -0xc(%rbp)
movq -0x28(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x48(%rcx), %eax
jge 0x19e26
movq -0x28(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x188, %rcx, %rcx      # imm = 0x188
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
movq -0x18(%rbp), %rdx
addq $0xc, %rdx
leaq -0x20(%rbp), %rdi
callq 0x1bdb0
movq -0x28(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x1bcd0
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x19dc0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x110(%rbp)
movq %rdi, %rax
movq %rax, -0x118(%rbp)
callq 0x1b880
movq -0x110(%rbp), %rax
movq $0x0, 0x30(%rax)
movl $0x0, 0x38(%rax)
movq $0x0, 0x40(%rax)
movl $0x0, 0x48(%rax)
movq $0x0, 0x50(%rax)
movq $0x0, 0x58(%rax)
movq $0x0, 0x60(%rax)
movq $0x0, 0x68(%rax)
movq -0x10(%rbp), %rdi
callq 0x1b9a0
movq %rax, -0x108(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x100(%rbp)
callq 0x1b9c0
movq -0x108(%rbp), %rsi
movq -0x100(%rbp), %rdx
leaq -0x28(%rbp), %rdi
callq 0x1b9e0
jmp 0x19edb
leaq -0x29(%rbp), %rdi
callq 0x1ba50
movl $0x0, -0x94(%rbp)
movl -0x94(%rbp), %eax
movq %rax, -0x120(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1b9a0
movq %rax, %rcx
movq -0x120(%rbp), %rax
cmpq %rcx, %rax
jae 0x19fc9
movq -0x10(%rbp), %rdi
movl -0x94(%rbp), %eax
movl %eax, %esi
callq 0x1ba70
movq %rax, %rdi
callq 0x3110
movq %rax, %rsi
leaq -0x90(%rbp), %rdi
movq %rdi, -0x128(%rbp)
callq 0x3270
movq -0x118(%rbp), %rsi
movq -0x128(%rbp), %rdx
leaq -0xf8(%rbp), %rdi
callq 0x19490
jmp 0x19f62
movl -0x94(%rbp), %eax
movl %eax, %esi
leaq -0x28(%rbp), %rdi
callq 0x1ba90
movq %rax, %rdi
leaq -0xf8(%rbp), %rsi
movl $0x60, %edx
callq 0x3240
movl -0x94(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x94(%rbp)
jmp 0x19eee
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x29(%rbp), %rdi
callq 0x1ba50
jmp 0x19ffb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1b920
jmp 0x19ffb
movq -0x118(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x196b0
jmp 0x19fdb
movq -0x118(%rbp), %rdi
callq 0x19da0
jmp 0x19fe9
leaq -0x28(%rbp), %rdi
callq 0x1b920
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
movq -0x110(%rbp), %rdi
callq 0x1b980
movq -0x38(%rbp), %rdi
callq 0x3460
// File: 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 %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x20(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0x48(%rcx), %eax
jge 0x1a0b4
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
movq 0x40(%rcx), %rcx
movslq -0x10(%rbp), %rdx
imulq $0x188, %rdx, %rdx      # imm = 0x188
addq %rdx, %rcx
cmpl 0x18(%rcx), %eax
jge 0x1a0a4
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rcx
movslq -0x10(%rbp), %rdx
imulq $0x188, %rdx, %rdx      # imm = 0x188
addq %rdx, %rcx
movq 0x10(%rcx), %rdx
movslq -0x14(%rbp), %rcx
imulq $0x60, %rcx, %rcx
addq %rcx, %rdx
movq 0x30(%rax), %rax
movslq -0xc(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1a041
jmp 0x1a0a6
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1a02e
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x1a63b
movq -0x18(%rbp), %rdi
callq 0x3380
movq -0x20(%rbp), %rax
movq $0x0, 0x30(%rax)
movq 0x40(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x1a6bf
movq -0x28(%rbp), %rcx
movq %rcx, %rax
addq $-0x8, %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rcx), %rax
movq %rax, -0x38(%rbp)
imulq $0x188, %rax, %rdx      # imm = 0x188
movq %rcx, %rax
addq %rdx, %rax
cmpq %rax, %rcx
movq %rax, -0x30(%rbp)
je 0x1a6a7
movq -0x30(%rbp), %rdi
addq $-0x188, %rdi           # imm = 0xFE78
movq %rdi, -0x48(%rbp)
callq 0x29280
movq -0x28(%rbp), %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x30(%rbp)
jne 0x1a682
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rax
imulq $0x188, %rax, %rsi      # imm = 0x188
addq $0x8, %rsi
callq 0x34a0
movq -0x20(%rbp), %rax
movq $0x0, 0x40(%rax)
cmpq $0x0, 0x50(%rax)
je 0x1a6e3
movq -0x20(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x31450
jmp 0x1a6e1
jmp 0x1a6e3
movq -0x20(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0x1a6ff
movq -0x20(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0x31450
jmp 0x1a6fd
jmp 0x1a6ff
movq -0x20(%rbp), %rax
cmpq $0x0, 0x60(%rax)
je 0x1a71b
movq -0x20(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x31450
jmp 0x1a719
jmp 0x1a71b
movq -0x20(%rbp), %rax
cmpq $0x0, 0x68(%rax)
je 0x1a766
movl $0x0, -0xc(%rbp)
movq -0x20(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x48(%rcx), %eax
jge 0x1a759
movq -0x20(%rbp), %rax
movq 0x68(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x3320
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1a72d
movq -0x20(%rbp), %rax
movq 0x68(%rax), %rdi
callq 0x3320
movq -0x20(%rbp), %rdi
callq 0x1b980
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x18ad0
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0x48(%rcx), %eax
jge 0x1b418
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0x10(%rbp), %rcx
imulq $0x188, %rcx, %rcx      # imm = 0x188
addq %rcx, %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
jl 0x1b3ff
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0x10(%rbp), %rcx
imulq $0x188, %rcx, %rcx      # imm = 0x188
addq %rcx, %rax
movsbl (%rax), %eax
cmpl $0x14, %eax
setl %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1b3ae
movl -0xc(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x33b0
movl $0x0, -0x18(%rbp)
movq -0x30(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0x48(%rcx), %eax
jge 0x1b4b1
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0x18(%rbp), %rcx
imulq $0x188, %rcx, %rcx      # imm = 0x188
movsbq (%rax,%rcx), %rax
leaq 0x1968e(%rip), %rcx     # 0x34b10
movsbl (%rax,%rcx), %esi
callq 0x31a0
jmp 0x1b48d
jmp 0x1b48f
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1b453
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x3190
jmp 0x1b4ce
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x1b4c4
movq -0x40(%rbp), %rdi
callq 0x3190
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x3460
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1bb70
movq -0x20(%rbp), %rcx
cmpl 0x48(%rcx), %eax
jne 0x1b50c
jmp 0x1b52b
leaq 0x1977e(%rip), %rdi     # 0x34c91
leaq 0x19674(%rip), %rsi     # 0x34b8e
movl $0x25b, %edx            # imm = 0x25B
leaq 0x19784(%rip), %rcx     # 0x34caa
callq 0x31b0
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x48(%rcx), %eax
jge 0x1b58a
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x1bde0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movl (%rcx), %edx
movq 0x40(%rax), %rcx
movslq -0x14(%rbp), %rsi
imulq $0x188, %rsi, %rsi      # imm = 0x188
addq %rsi, %rcx
movl %edx, 0x8(%rcx)
movq 0x40(%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x188, %rcx, %rcx      # imm = 0x188
addq %rcx, %rax
movb $0x20, 0xc(%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1b532
movq -0x20(%rbp), %rdi
callq 0x19da0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)