LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/stonezwr[P]SpiKL-IP/parser.C
// Function: Parser::ParseNeuronGroup(char*, int, char*, double)
void Parser::ParseNeuronGroup(char * name, int num, char * e_i, double v_mem){
	cout<<std::string(name)<<endl;
    assert(_network->CheckExistence(name) == false);
    assert(num > 1);
    assert((strcmp(e_i,"excitatory")==0)||(strcmp(e_i,"inhibitory")==0));
    bool excitatory;
    if(strcmp(e_i,"excitatory") == 0) excitatory = true;
    else excitatory = false;
    _network->AddNeuronGroup(name, num, excitatory, v_mem);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movsd %xmm0, 0x10(%rsp)
movq %rcx, %r12
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x18(%rsp), %r13
leaq 0xf(%rsp), %rdx
movq %r13, %rdi
callq 0xaa0c
movq (%r13), %rsi
movq 0x8(%r13), %rdx
movq 0xe184(%rip), %rdi      # 0x20fd0
callq 0x3340
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x32b0
movsbl %al, %esi
movq %r13, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31e0
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x12e96
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x32f0
movq (%r15), %rdi
movq %r14, %rsi
callq 0xcf94
testb %al, %al
jne 0x12efb
cmpl $0x1, %ebx
jle 0x12f1a
leaq 0x4bed(%rip), %rsi      # 0x17a9e
movq %r12, %rdi
callq 0x33f0
movl %eax, %ebp
testl %eax, %eax
je 0x12ed2
leaq 0x4be3(%rip), %rsi      # 0x17aa9
movq %r12, %rdi
callq 0x33f0
testl %eax, %eax
jne 0x12f39
xorl %ecx, %ecx
testl %ebp, %ebp
sete %cl
movq (%r15), %rdi
movq %r14, %rsi
movl %ebx, %edx
movsd 0x10(%rsp), %xmm0
callq 0xd1fa
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6751(%rip), %rdi      # 0x19653
leaq 0x6616(%rip), %rsi      # 0x1951f
leaq 0x676b(%rip), %rcx      # 0x1967b
movl $0x71, %edx
callq 0x31b0
leaq 0x6795(%rip), %rdi      # 0x196b6
leaq 0x65f7(%rip), %rsi      # 0x1951f
leaq 0x674c(%rip), %rcx      # 0x1967b
movl $0x72, %edx
callq 0x31b0
leaq 0x677e(%rip), %rdi      # 0x196be
leaq 0x65d8(%rip), %rsi      # 0x1951f
leaq 0x672d(%rip), %rcx      # 0x1967b
movl $0x73, %edx
callq 0x31b0
movq %rax, %rbx
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x12f76
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x32f0
movq %rbx, %rdi
callq 0x3570
// File: /workspace/github_c_makefile_star2_O1/stonezwr[P]SpiKL-IP/parser.C
// Function: Parser::ParseLSMSynapse(char*, char*, int, int, int, int, char*)
void Parser::ParseLSMSynapse(char * from, char * to, int fromN, int toN, int value, int random, char * fixed_learning){
    bool fixed;
    if(strcmp(fixed_learning,"fixed") == 0) fixed = true;
    else if(strcmp(fixed_learning,"learning") == 0) fixed = false;
    else{
        cout<<fixed_learning<<endl;
        assert(0);
    }
    _network->LSMAddSynapse(from, to, fromN, toN, value, random, fixed);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, 0x4(%rsp)
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq 0x48(%rsp), %rdi
leaq 0x5589(%rip), %rsi      # 0x18532
callq 0x33f0
movl %eax, %ebx
testl %eax, %eax
je 0x12fc9
leaq 0x6740(%rip), %rsi      # 0x196fb
movq 0x48(%rsp), %rdi
callq 0x33f0
testl %eax, %eax
jne 0x13002
movl 0x40(%rsp), %eax
xorl %r10d, %r10d
testl %ebx, %ebx
sete %r10b
movq (%r13), %rdi
movq %r12, %rsi
movq %r15, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl 0x4(%rsp), %r9d
pushq %r10
pushq %rax
callq 0xde1a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xdfc7(%rip), %rdi      # 0x20fd0
movq 0x48(%rsp), %rsi
callq 0x32c0
movq %rax, %rdi
callq 0x3160
leaq 0x530e(%rip), %rdi      # 0x18330
leaq 0x64f6(%rip), %rsi      # 0x1951f
leaq 0x66d4(%rip), %rcx      # 0x19704
movl $0x81, %edx
callq 0x31b0
// File: /workspace/github_c_makefile_star2_O1/stonezwr[P]SpiKL-IP/simulator.C
// Function: Simulator::InitializeFile(char const*)
void Simulator::InitializeFile(const char * filename){
    FILE * Foutp = fopen(filename,"w");
    assert(Foutp != NULL);
    fprintf(Foutp,"%d\t%d\n",-1,-1);
    fclose(Foutp);
}

// Assembly:
pushq %rbx
movq %rsi, %rdi
leaq 0x5fb0(%rip), %rsi      # 0x198f3
callq 0x3360
testq %rax, %rax
je 0x13974
movq %rax, %rbx
leaq 0x5fd9(%rip), %rsi      # 0x19930
movq %rax, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
xorl %eax, %eax
callq 0x3420
movq %rbx, %rdi
popq %rbx
jmp 0x32d0
leaq 0x5f7a(%rip), %rdi      # 0x198f5
leaq 0x5e42(%rip), %rsi      # 0x197c4
leaq 0x5f7a(%rip), %rcx      # 0x19903
movl $0x6a, %edx
callq 0x31b0
nop
// File: /workspace/github_c_makefile_star2_O1/stonezwr[P]SpiKL-IP/readout.C
// Function: Readout::SetRefer(int)
void Readout::SetRefer(int flag){ // To set the reference array according the application
    if(flag == 0){
        for (int i = 0; i < 26; ++i)
        {
            if(i < 2) 
                refer.push_back(i);
            else if(i == 2)
                refer.push_back(10);
            else if(i < 12)
                refer.push_back(refer[i-1] + 1);
            else if(i == 12)
                refer.push_back(2);
            else if(i == 13)
                refer.push_back(20);
            else if(i < 19)
                refer.push_back(refer[i-1] + 1);
            else if(i == 19)
                refer.push_back(3);
            else
                refer.push_back(refer[i-1] + 1);
        }
        // for (int i = 0; i < 26; ++i)
        // {
        // 	cout<<refer[i]<<endl;
        // }
    }
    // refer = {0, 1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 2, 20, 21, 22, 23, 24, 25, 3, 4, 5, 6, 7, 8, 9};
    else{
        for (int i = 0; i < CLS; ++i)
        {
            refer.push_back(i);
        }
        //	refer = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
    }     


}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
leaq 0x4(%rsp), %r15
testl %esi, %esi
je 0x13abf
movl $0x0, (%r15)
xorl %eax, %eax
movq 0x10(%rbx), %rsi
cmpq 0x18(%rbx), %rsi
je 0x13a9f
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x10(%rbx)
jmp 0x13aaa
movq %r14, %rdi
movq %r15, %rdx
callq 0x4476
movl 0x4(%rsp), %ecx
leal 0x1(%rcx), %eax
movl %eax, 0x4(%rsp)
cmpl $0x19, %ecx
jl 0x13a89
jmp 0x13bb4
movl $0x0, (%r15)
xorl %eax, %eax
movq %rsp, %r12
cmpl $0x1, %eax
jg 0x13aea
movq 0x10(%rbx), %rsi
cmpq 0x18(%rbx), %rsi
jne 0x13b2a
movq %r14, %rdi
movq %r15, %rdx
callq 0x4476
jmp 0x13ba0
cmpl $0x2, %eax
jne 0x13b0c
movl $0xa, (%rsp)
movq 0x10(%rbx), %rsi
cmpq 0x18(%rbx), %rsi
je 0x13b95
movl $0xa, (%rsi)
jmp 0x13b2c
cmpl $0xb, %eax
jg 0x13b36
movq 0x8(%rbx), %rcx
movl %eax, %eax
movl -0x4(%rcx,%rax,4), %eax
incl %eax
movl %eax, (%rsp)
movq 0x10(%rbx), %rsi
cmpq 0x18(%rbx), %rsi
je 0x13b95
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x10(%rbx)
jmp 0x13ba0
cmpl $0xd, %eax
je 0x13b59
cmpl $0xc, %eax
jne 0x13b72
movl $0x2, (%rsp)
movq 0x10(%rbx), %rsi
cmpq 0x18(%rbx), %rsi
je 0x13b95
movl $0x2, (%rsi)
jmp 0x13b2c
movl $0x14, (%rsp)
movq 0x10(%rbx), %rsi
cmpq 0x18(%rbx), %rsi
je 0x13b95
movl $0x14, (%rsi)
jmp 0x13b2c
cmpl $0x12, %eax
jle 0x13b11
cmpl $0x13, %eax
jne 0x13b11
movl $0x3, (%rsp)
movq 0x10(%rbx), %rsi
cmpq 0x18(%rbx), %rsi
je 0x13b95
movl $0x3, (%rsi)
jmp 0x13b2c
movq %r14, %rdi
movq %r12, %rdx
callq 0x45b2
movl 0x4(%rsp), %ecx
leal 0x1(%rcx), %eax
movl %eax, 0x4(%rsp)
cmpl $0x19, %ecx
jl 0x13acb
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stonezwr[P]SpiKL-IP/readout.C
// Function: Readout::FindVal(std::vector<int, std::allocator<int>> const&, int)
int val){  //Find a specific value in the vector and return the indices of that value
    vector<int> v_out;
    for (size_t i = 0; i < v.size(); ++i)
    {
        if(v[i] == val){
            //cout<<v[i]<<"\t"<<val<<endl;
            v_out.push_back(i);
        }
    }
    return v_out;	
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rdx), %rax
cmpq %rax, 0x8(%rdx)
je 0x13e28
movl %ecx, %ebp
movq %rdx, %r14
xorl %r12d, %r12d
leaq 0xc(%rsp), %r15
cmpl %ebp, (%rax,%r12,4)
jne 0x13e12
movl %r12d, 0xc(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x13e07
movl %r12d, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x13e12
movq %rbx, %rdi
movq %r15, %rdx
callq 0x45b2
incq %r12
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %rcx, %r12
jb 0x13de5
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x13e4f
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x32f0
movq %r14, %rdi
callq 0x3570
nop
// File: /workspace/github_c_makefile_star2_O1/stonezwr[P]SpiKL-IP/util.C
// Function: Timer::Report(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Timer::Report(std::string str){
    timeval tmp;
    gettimeofday(&tmp, &m_zone);
    if(is_started){
        std::cout<<"Total time spent in "<<str<<" : "<<(tmp.tv_sec - m_cur.tv_sec) + double((tmp.tv_usec - m_cur.tv_usec)*1e-6)<<" seconds"<<std::endl;
    }
    else{
        std::cerr<<"Warning: the util Timer is not STARTED! Start the timer...."<<std::endl;
        Start();
        return;
    }
    m_cur = tmp;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x30(%rdi), %r14
movq %rsp, %rdi
movq %r14, %rsi
callq 0x3510
cmpb $0x1, 0x38(%rbx)
jne 0x13f86
movq 0xd0fb(%rip), %r14      # 0x20fd0
leaq 0x5afc(%rip), %rsi      # 0x199d8
movl $0x14, %edx
movq %r14, %rdi
callq 0x3340
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x3340
movq %rax, %r14
leaq 0x5473(%rip), %rsi      # 0x19375
movl $0x3, %edx
movq %rax, %rdi
callq 0x3340
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
subq 0x10(%rbx), %rax
cvtsi2sd %rax, %xmm1
subq 0x18(%rbx), %rcx
cvtsi2sd %rcx, %xmm0
mulsd 0x5a96(%rip), %xmm0     # 0x199c8
addsd %xmm1, %xmm0
movq %r14, %rdi
callq 0x34f0
movq %rax, %r14
leaq 0x5aa5(%rip), %rsi      # 0x199ed
movl $0x8, %edx
movq %rax, %rdi
callq 0x3340
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x32b0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31e0
movups (%rsp), %xmm0
movups %xmm0, 0x10(%rbx)
jmp 0x13fde
movq 0xd063(%rip), %r15      # 0x20ff0
leaq 0x5a62(%rip), %rsi      # 0x199f6
movl $0x3b, %edx
movq %r15, %rdi
callq 0x3340
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x32b0
movsbl %al, %esi
movq %r15, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31e0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3510
movups (%rbx), %xmm0
movups %xmm0, 0x10(%rbx)
movb $0x1, 0x38(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stonezwr[P]SpiKL-IP/util.C
// Function: Timer::End(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Timer::End(std::string str){
    timeval tmp;
    gettimeofday(&tmp, &m_zone);
    if(is_started && !str.empty()){
        std::cout<<"Total time spent in "<<str<<" : "<<(tmp.tv_sec - m_start.tv_sec) + double((tmp.tv_usec - m_start.tv_usec)*1e-6)<<" seconds"<<std::endl;
    }
    else if(!is_started){
        std::cerr<<"Warning: the util Timer is not STARTED! Start the timer...."<<std::endl;
        Start();
        return;
    }  
    m_cur = tmp;
    m_end = tmp;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x30(%rdi), %r14
movq %rsp, %rdi
movq %r14, %rsi
callq 0x3510
movb 0x38(%rbx), %al
cmpb $0x1, %al
jne 0x140e1
cmpq $0x0, 0x8(%r15)
je 0x140cb
movq 0xcfad(%rip), %r14      # 0x20fd0
leaq 0x59ae(%rip), %rsi      # 0x199d8
movl $0x14, %edx
movq %r14, %rdi
callq 0x3340
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x3340
movq %rax, %r14
leaq 0x5325(%rip), %rsi      # 0x19375
movl $0x3, %edx
movq %rax, %rdi
callq 0x3340
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
subq (%rbx), %rax
cvtsi2sd %rax, %xmm1
subq 0x8(%rbx), %rcx
cvtsi2sd %rcx, %xmm0
mulsd 0x5949(%rip), %xmm0     # 0x199c8
addsd %xmm1, %xmm0
movq %r14, %rdi
callq 0x34f0
movq %rax, %r14
leaq 0x5958(%rip), %rsi      # 0x199ed
movl $0x8, %edx
movq %rax, %rdi
callq 0x3340
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x32b0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31e0
jmp 0x140cf
testb %al, %al
je 0x140e1
movups (%rsp), %xmm0
movups %xmm0, 0x10(%rbx)
movups (%rsp), %xmm0
movups %xmm0, 0x20(%rbx)
jmp 0x14139
movq 0xcf08(%rip), %r15      # 0x20ff0
leaq 0x5907(%rip), %rsi      # 0x199f6
movl $0x3b, %edx
movq %r15, %rdi
callq 0x3340
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x32b0
movsbl %al, %esi
movq %r15, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31e0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3510
movups (%rbx), %xmm0
movups %xmm0, 0x10(%rbx)
movb $0x1, 0x38(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/stonezwr[P]SpiKL-IP/util.C
// Function: UnionFind::root(int)
int UnionFind::root(int ind){
    assert(exist(ind));
    while(ind != _id[ind]){
        _id[ind] = _id[_id[ind]]; // path compression
        ind = _id[ind];
    }
    return ind;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x14298
testb %al, %al
je 0x14279
movq 0x20(%r14), %rax
movslq %ebx, %rdx
movl (%rax,%rdx,4), %ecx
cmpl %ebx, %ecx
je 0x1426f
leaq (%rax,%rdx,4), %rdx
movslq %ecx, %rcx
movslq (%rax,%rcx,4), %rbx
movl %ebx, (%rdx)
leaq (%rax,%rbx,4), %rdx
movl (%rdx), %ecx
cmpl %ecx, %ebx
jne 0x1425c
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x57b2(%rip), %rdi      # 0x19a32
leaq 0x57b6(%rip), %rsi      # 0x19a3d
leaq 0x57b6(%rip), %rcx      # 0x19a44
movl $0x3f, %edx
callq 0x31b0
// File: /workspace/github_c_makefile_star2_O1/stonezwr[P]SpiKL-IP/util.C
// Function: UnionFind::exist(int)
bool UnionFind::exist(int ind){
    if(ind >= _n){
        std::cout<<"Warning: UnionFind::exist() index "<<ind<<" out of bound "<<_n<<std::endl;
        return -1;
    }
    return (_sz[ind] != -1);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
cmpl %esi, (%rdi)
jle 0x142b5
movslq %ebp, %rax
movq 0x8(%rbx), %rcx
cmpl $-0x1, (%rcx,%rax,4)
setne %al
jmp 0x14327
movq 0xcd14(%rip), %r14      # 0x20fd0
leaq 0x57c5(%rip), %rsi      # 0x19a88
movl $0x22, %edx
movq %r14, %rdi
callq 0x3340
movq %r14, %rdi
movl %ebp, %esi
callq 0x3560
movq %rax, %r14
leaq 0x5795(%rip), %rsi      # 0x19a79
movl $0xe, %edx
movq %rax, %rdi
callq 0x3340
movl (%rbx), %esi
movq %r14, %rdi
callq 0x3560
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x32b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31e0
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stonezwr[P]SpiKL-IP/util.C
// Function: UnionFind::individual(int)
bool UnionFind::individual(int ind){
    if(ind >= _n){
        std::cout<<"Warning: UnionFind:: index "<<ind<<" out of bound "<<_n<<std::endl;
        return false;
    }
    return _sz[ind] == 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
cmpl %esi, (%rdi)
jle 0x14349
movslq %ebp, %rax
movq 0x8(%rbx), %rcx
cmpl $0x1, (%rcx,%rax,4)
sete %al
jmp 0x143bb
movq 0xcc80(%rip), %r14      # 0x20fd0
leaq 0x5706(%rip), %rsi      # 0x19a5d
movl $0x1b, %edx
movq %r14, %rdi
callq 0x3340
movq %r14, %rdi
movl %ebp, %esi
callq 0x3560
movq %rax, %r14
leaq 0x5701(%rip), %rsi      # 0x19a79
movl $0xe, %edx
movq %rax, %rdi
callq 0x3340
movl (%rbx), %esi
movq %r14, %rdi
callq 0x3560
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x32b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31e0
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stonezwr[P]SpiKL-IP/util.C
// Function: UnionFind::add(int)
void UnionFind::add(int ind){
    if(ind >= _n){
        std::cout<<"Warning: UnionFind::add, index: "<<ind<<" out of bound "<<_n<<std::endl;
        return;
    }
    if(exist(ind))  return;
    _id[ind] = ind;
    _sz[ind] = 1;
    _count++;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
cmpl %esi, (%rdi)
jle 0x143f8
movq %rbx, %rdi
movl %ebp, %esi
callq 0x14298
testb %al, %al
jne 0x143f3
movslq %ebp, %rax
movq 0x20(%rbx), %rcx
movl %ebp, (%rcx,%rax,4)
movq 0x8(%rbx), %rcx
movl $0x1, (%rcx,%rax,4)
incl 0x4(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
movq 0xcbd1(%rip), %r14      # 0x20fd0
leaq 0x56a5(%rip), %rsi      # 0x19aab
movl $0x20, %edx
movq %r14, %rdi
callq 0x3340
movq %r14, %rdi
movl %ebp, %esi
callq 0x3560
movq %rax, %r14
leaq 0x5652(%rip), %rsi      # 0x19a79
movl $0xe, %edx
movq %rax, %rdi
callq 0x3340
movl (%rbx), %esi
movq %r14, %rdi
callq 0x3560
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x32b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x31e0
// File: /workspace/github_c_makefile_star2_O1/stonezwr[P]SpiKL-IP/util.C
// Function: UnionFind::unite(int, int)
void UnionFind::unite(int p, int q){
    int i = root(p);
    int j = root(q);
    if(_sz[i] >= _sz[j]){
        _sz[i] += _sz[j]; _id[j] = i; // always merge the smaller to the larger one
    }
    else{
        _sz[j] += _sz[i]; _id[i] = j;
    } 
    _count--;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rdi, %rbx
callq 0x14238
movl %eax, %r14d
movq %rbx, %rdi
movl %ebp, %esi
callq 0x14238
movslq %r14d, %rcx
movq 0x8(%rbx), %rdx
movl (%rdx,%rcx,4), %esi
cltq
movl (%rdx,%rax,4), %edi
cmpl %edi, %esi
movq %rcx, %r8
cmovlq %rax, %r8
leal (%rdi,%rsi), %esi
movq %rax, %rdi
cmovlq %rcx, %rdi
cmovgel %ecx, %eax
movl %esi, (%rdx,%r8,4)
movq 0x20(%rbx), %rcx
movl %eax, (%rcx,%rdi,4)
decl 0x4(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stonezwr[P]SpiKL-IP/util.C
// Function: ReadMnistLabel(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<int, std::allocator<int>>&)
int ReadMnistLabel(std::string filename, std::vector<int> &mat){
    std::ifstream file(filename.c_str(), std::ios::binary);
    if(!file.is_open()){
        std::cout<<"Cannot open the file: "<<filename<<std::endl;
        exit(EXIT_FAILURE);
    }
    int magic_number = 0;
    int number_of_images = 0;
    file.read((char*) &magic_number, sizeof(magic_number));
    magic_number = ReverseInt(magic_number);
    file.read((char*) &number_of_images,sizeof(number_of_images));
    number_of_images = ReverseInt(number_of_images);

    for(int i = 0; i < number_of_images; ++i){
        unsigned char temp = 0;
        file.read((char*) &temp, sizeof(temp));
        mat.push_back(temp);
    }
    return mat.size();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x220, %rsp            # imm = 0x220
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rsi
leaq 0x18(%rsp), %rdi
movl $0x4, %edx
callq 0x35d0
leaq 0x90(%rsp), %rdi
callq 0x30b0
testb %al, %al
je 0x1566f
xorl %eax, %eax
leaq 0x10(%rsp), %rsi
movl %eax, (%rsi)
movl %eax, 0xc(%rsp)
leaq 0x18(%rsp), %rdi
movl $0x4, %edx
callq 0x33b0
movl 0x10(%rsp), %eax
bswapl %eax
movl %eax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0xc(%rsp), %rsi
movl $0x4, %edx
callq 0x33b0
movl 0xc(%rsp), %eax
bswapl %eax
movl %eax, 0xc(%rsp)
testl %eax, %eax
jle 0x15647
xorl %ebp, %ebp
leaq 0x18(%rsp), %r14
leaq 0xb(%rsp), %r15
leaq 0x14(%rsp), %r12
movb $0x0, 0xb(%rsp)
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x33b0
movzbl 0xb(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x15634
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x1563f
movq %rbx, %rdi
movq %r12, %rdx
callq 0x45b2
incl %ebp
cmpl 0xc(%rsp), %ebp
jl 0x15600
movq 0x8(%rbx), %r14
subq (%rbx), %r14
shrq $0x2, %r14
leaq 0x18(%rsp), %rdi
callq 0x30d0
movl %r14d, %eax
addq $0x220, %rsp            # imm = 0x220
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0xb95a(%rip), %rdi      # 0x20fd0
leaq 0x44d5(%rip), %rsi      # 0x19b52
movl $0x16, %edx
callq 0x3340
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0xb93b(%rip), %rdi      # 0x20fd0
callq 0x3340
movq %rax, %rdi
callq 0x3160
movl $0x1, %edi
callq 0x3370
jmp 0x156b2
jmp 0x156b2
jmp 0x156b2
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x30d0
movq %rbx, %rdi
callq 0x3570
// File: /workspace/github_c_makefile_star2_O1/stonezwr[P]SpiKL-IP/util.C
// Function: ReadMnistData(std::vector<std::vector<std::vector<float, std::allocator<float>>, std::allocator<std::vector<float, std::allocator<float>>>>, std::allocator<std::vector<std::vector<float, std::allocator<float>>, std::allocator<std::vector<float, std::allocator<float>>>>>>&, std::vector<int, std::allocator<int>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
int  ReadMnistData(Matrices& x, std::vector<int>& y, std::string xpath, std::string ypath, int nums)
{
    //* read MNIST image
    int len = ReadMnistSample(xpath, x, nums);
    //* read MNIST label
    int t = ReadMnistLabel(ypath, y);
    return t;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r8d, %ebp
movq %rcx, %r14
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %r12
movq %r12, %rdi
callq 0xb78c
movq %r12, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x152a1
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x15725
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x32f0
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xb78c
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1556b
movl %eax, %ebx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x15769
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32f0
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
jmp 0x1578c
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x1579d
movq (%r13), %rsi
incq %rsi
callq 0x32f0
movq %rbx, %rdi
callq 0x3570
nop
// File: /workspace/github_c_makefile_star2_O1/stonezwr[P]SpiKL-IP/main.C
// Function: ParallelSim(void*)
void * ParallelSim(void * NTPargptr){

    NTParg * arg = (NTParg *)NTPargptr;
    Network * network = arg->network;
    long tid = arg->tid;
    delete arg;

    Simulator simulator(network);

    (network)->AnalogToSpike();   // application for speech
    simulator.LSMRun(tid);
    cout<<"Thread "<<tid<<" done!"<<endl;
    pthread_exit(NULL);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq (%rdi), %rbx
movq 0x8(%rdi), %r14
movl $0x10, %esi
callq 0x32f0
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x13314
movq %r14, %rdi
callq 0xfdf0
movq %r15, %rdi
movq %rbx, %rsi
callq 0x13386
movq 0xb0c6(%rip), %rdi      # 0x20fd0
leaq 0x3c8e(%rip), %rsi      # 0x19b9f
callq 0x32c0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x35c0
leaq 0x3c7f(%rip), %rsi      # 0x19ba7
movq %rax, %rdi
callq 0x32c0
movq %rax, %rdi
callq 0x3160
xorl %edi, %edi
callq 0x3580
// File: /workspace/github_c_makefile_star2_O1/josch[P]stride/escape.c
// Function: escape
int escape(int RetVal, char *format, ... ) {
va_list ptr;

va_start(ptr,format);
vfprintf(stderr,format,ptr);
va_end(ptr);
return(RetVal);
}

// Assembly:
pushq %rbx
subq $0xd0, %rsp
movl %edi, %ebx
leaq 0x20(%rsp), %rdi
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x247e
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rdx
movq %rdi, 0x10(%rdx)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rdx)
movq 0x1eb4b(%rip), %rax     # 0x20ff0
movq (%rax), %rdi
callq 0x21c0
movl %ebx, %eax
addq $0xd0, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/josch[P]stride/nsc.c
// Function: error
void error(const char *fmt, ...) {
  va_list args;
  fprintf(stderr,
    "\n---> ERROR when executing line %i in file %s !\n",
    __line__,__file__);
  va_start(args,fmt);
  vfprintf(stderr, fmt, args);
  va_end(args);
  fprintf(stderr, "\n---> Execution stopped !\n\n");
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movq %rsi, 0x8(%r14)
movq %rdx, 0x10(%r14)
movq %rcx, 0x18(%r14)
movq %r8, 0x20(%r14)
movq %r9, 0x28(%r14)
testb %al, %al
je 0x251b
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq 0x1eace(%rip), %r15     # 0x20ff0
movq (%r15), %rdi
movl 0x2010d(%rip), %edx     # 0x22638
movq 0x2010e(%rip), %rcx     # 0x22640
leaq 0x183a7(%rip), %rsi     # 0x1a8e0
xorl %eax, %eax
callq 0x2160
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rsp, %rdx
movq %rax, (%rdx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rdx)
movq %r14, 0x10(%rdx)
movq (%r15), %rdi
movq %rbx, %rsi
callq 0x21c0
movq (%r15), %rcx
leaq 0x1839c(%rip), %rdi     # 0x1a911
pushq $0x1b
popq %rsi
pushq $0x1
popq %rdx
callq 0x2240
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/josch[P]stride/nsc.c
// Function: warning
void warning(const char *fmt, ...) {
  va_list args;
  fprintf(stderr,
    "\n---> WARNING : line %i in file %s\n",
    __line__,__file__);
  va_start(args,fmt);
  vfprintf(stderr, fmt, args);
  va_end(args);
  fprintf(stderr, " ...!\n\n");
  fflush(stderr);
  fflush(stdout);
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r15
movq %rsi, 0x8(%r15)
movq %rdx, 0x10(%r15)
movq %rcx, 0x18(%r15)
movq %r8, 0x20(%r15)
movq %r9, 0x28(%r15)
testb %al, %al
je 0x25f0
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq 0x1e9f9(%rip), %r14     # 0x20ff0
movq (%r14), %rdi
movl 0x20038(%rip), %edx     # 0x22638
movq 0x20039(%rip), %rcx     # 0x22640
leaq 0x1831f(%rip), %rsi     # 0x1a92d
xorl %eax, %eax
callq 0x2160
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rsp, %rdx
movq %rax, (%rdx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rdx)
movq %r15, 0x10(%rdx)
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x21c0
movq (%r14), %rcx
leaq 0x18307(%rip), %rdi     # 0x1a951
pushq $0x7
popq %rsi
pushq $0x1
popq %rdx
callq 0x2240
movq (%r14), %rdi
callq 0x2190
movq 0x1e96c(%rip), %rax     # 0x20fd0
movq (%rax), %rdi
callq 0x2190
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/josch[P]stride/chkchain.c
// Function: NotValid
int NotValid(CHAIN *Chain, char *Message)
{
  
  fprintf(stderr,"IGNORED %s %c ",Chain->File,SpaceToDash(Chain->Id));
  fprintf(stderr,"(%s)\n",Message);
  Chain->Valid = NO;
  return(FAILURE);
  
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x1e867(%rip), %r13     # 0x20ff0
movq (%r13), %r15
movq 0x48(%rdi), %r12
movsbl 0x40(%rdi), %edi
callq 0x517a
movsbl %al, %ecx
leaq 0x1878a(%rip), %rsi     # 0x1af2e
movq %r15, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x2160
movq (%r13), %rdi
leaq 0x18781(%rip), %rsi     # 0x1af3d
movq %r14, %rdx
xorl %eax, %eax
callq 0x2160
andl $0x0, 0x58(%rbx)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/josch[P]stride/splitstr.c
// Function: SplitString
int SplitString(char *Buffer, char **Fields, int MaxField)
{
  int FieldCnt, SymbCnt, FieldFlag, BuffLen;
  static char LocalBuffer[BUFSZ];


  FieldCnt =0; FieldFlag = 0;
  BuffLen = (int)strlen(Buffer) - 1;

  strcpy(LocalBuffer,Buffer);

  for(SymbCnt=0; SymbCnt<BuffLen; SymbCnt++) {
    if( (isspace(LocalBuffer[SymbCnt])) && FieldFlag == 0 && SymbCnt != BuffLen-1 ) continue;
    if( (!isspace(LocalBuffer[SymbCnt])) && FieldFlag == 1 && SymbCnt == BuffLen-1 ) {
      LocalBuffer[SymbCnt+1] = '\0';
      return(FieldCnt);
    }
    else
    if( (isspace(LocalBuffer[SymbCnt])) && FieldFlag == 1 ) {
      LocalBuffer[SymbCnt] = '\0';
      FieldFlag = 0;
      if( FieldCnt == MaxField ) return(FieldCnt);
    }
    else
    if( (!isspace(LocalBuffer[SymbCnt])) && FieldFlag == 0 ) {
      FieldFlag = 1;
      Fields[FieldCnt] = LocalBuffer+SymbCnt;
      FieldCnt++;
    }
  }
  
     return(FieldCnt);
 }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r13
callq 0x20b0
movq %rax, %r12
leaq 0x1e4d8(%rip), %r15     # 0x21bb0
movq %r15, %rdi
movq %r13, %rsi
callq 0x2070
xorl %eax, %eax
cmpl $0x2, %r12d
jl 0x37cc
leal -0x1(%r12), %r13d
callq 0x2290
movq %rax, %rcx
movl $0xfffffffe, %edx       # imm = 0xFFFFFFFE
addl %r12d, %edx
xorl %edi, %edi
movq $-0x1, %rsi
xorl %eax, %eax
leaq (%rdx,%rsi), %r9
movq (%rcx), %r8
movsbq (%r15), %r10
movzwl (%r8,%r10,2), %r8d
cmpq $-0x1, %r9
je 0x3739
movl %r8d, %r10d
andl $0x2000, %r10d          # imm = 0x2000
je 0x3739
testl %edi, %edi
jne 0x3739
xorl %edi, %edi
jmp 0x37a6
cmpq $-0x1, %r9
setne %r9b
movl %r8d, %r10d
shrl $0xd, %r10d
andl $0x1, %r10d
cmpl $0x1, %edi
setne %r11b
orb %r9b, %r11b
orb %r10b, %r11b
je 0x37bf
cmpl $0x1, %edi
sete %r9b
movl %r8d, %r10d
shrl $0xd, %r10d
andb %r9b, %r10b
cmpb $0x1, %r10b
jne 0x3781
movb $0x0, (%r15)
movl $0x0, %edi
cmpl %ebx, %eax
jne 0x37a6
jmp 0x37cc
btl $0xd, %r8d
setae %r8b
testl %edi, %edi
sete %r9b
andb %r8b, %r9b
cmpb $0x1, %r9b
jne 0x37a6
cltq
movq %r15, (%r14,%rax,8)
incl %eax
movl $0x1, %edi
incq %r15
leaq (%rsi,%r13), %r8
decq %r8
decq %rsi
cmpq $-0x1, %r8
jne 0x370f
jmp 0x37cc
negl %esi
leaq 0x1e3e8(%rip), %rcx     # 0x21bb0
movb $0x0, (%rsi,%rcx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/josch[P]stride/initchn.c
// Function: InitChain
void InitChain(CHAIN **Chain)
{
  
  *Chain = (CHAIN *)ckalloc(sizeof(CHAIN));

  (*Chain)->NRes                = 0;
  (*Chain)->NHetRes             = 0;
  (*Chain)->NonStandRes         = 0;
  (*Chain)->NHet                = 0;
  (*Chain)->NonStandAtom        = 0;
  (*Chain)->NHelix              = 0;
  (*Chain)->NSheet              = -1;
  (*Chain)->NTurn               = 0;
  (*Chain)->NAssignedTurn       = 0;
  (*Chain)->NBond               = 0;
  (*Chain)->NHydrBond           = 0;
  (*Chain)->NHydrBondTotal      = 0;
  (*Chain)->NHydrBondInterchain = 0;
  (*Chain)->Method              = XRay;
  (*Chain)->Ter                 = 0;
  (*Chain)->Resolution          = 0.0;

  (*Chain)->File                = (char           *)ckalloc(BUFSZ*sizeof(char));
  (*Chain)->Rsd                 = (RESIDUE       **)ckalloc(MAX_RES*sizeof(RESIDUE *));
  (*Chain)->HetRsd              = (HETERORESIDUE **)ckalloc(MAX_HETRES*sizeof(HETERORESIDUE *));
  (*Chain)->Het                 = (HET           **)ckalloc(MAX_HET*sizeof(HET *));
  (*Chain)->Helix               = (HELIX         **)ckalloc(MAX_HELIX*sizeof(HELIX *));
  (*Chain)->Sheet               = (SHEET         **)ckalloc(MAX_SHEET*sizeof(SHEET *));
  (*Chain)->Turn                = (TURN          **)ckalloc(MAX_TURN*sizeof(TURN *));
  (*Chain)->AssignedTurn        = (TURN          **)ckalloc(MAX_TURN*sizeof(TURN *));
  (*Chain)->SSbond              = (SSBOND        **)ckalloc(MAX_BOND*sizeof(SSBOND *));
  (*Chain)->Info                = (char          **)ckalloc(MAX_INFO*sizeof(char *));

  (*Chain)->Valid               = YES;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0xb8, %edi
callq 0x595c
movq %rax, (%rbx)
movl $0x0, 0x10(%rax)
xorl %ecx, %ecx
movq %rcx, 0x18(%rax)
movl $0xffffffff, 0x20(%rax) # imm = 0xFFFFFFFF
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %rcx, 0x50(%rax)
movq %rcx, 0x34(%rax)
movups %xmm0, 0x24(%rax)
movl $0x400, %edi            # imm = 0x400
callq 0x595c
movq (%rbx), %rcx
movq %rax, 0x48(%rcx)
movl $0x27100, %edi          # imm = 0x27100
callq 0x595c
movq (%rbx), %rcx
movq %rax, 0x68(%rcx)
movl $0x27100, %edi          # imm = 0x27100
callq 0x595c
movq (%rbx), %rcx
movq %rax, 0x70(%rcx)
movl $0x640, %edi            # imm = 0x640
callq 0x595c
movq (%rbx), %rcx
movq %rax, 0x78(%rcx)
movl $0xfa0, %edi            # imm = 0xFA0
callq 0x595c
movq (%rbx), %rcx
movq %rax, 0x80(%rcx)
movl $0xfa0, %edi            # imm = 0xFA0
callq 0x595c
movq (%rbx), %rcx
movq %rax, 0x88(%rcx)
movl $0x960, %edi            # imm = 0x960
callq 0x595c
movq (%rbx), %rcx
movq %rax, 0x90(%rcx)
movl $0x960, %edi            # imm = 0x960
callq 0x595c
movq (%rbx), %rcx
movq %rax, 0x98(%rcx)
movl $0x320, %edi            # imm = 0x320
callq 0x595c
movq (%rbx), %rcx
movq %rax, 0xa0(%rcx)
movl $0x1f40, %edi           # imm = 0x1F40
callq 0x595c
movq (%rbx), %rcx
movq %rax, 0xa8(%rcx)
movq (%rbx), %rax
movl $0x1, 0x58(%rax)
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O1/josch[P]stride/geometry.c
// Function: Ang
float Ang(float *Coord1, float *Coord2, float *Coord3)
{
  float Vector1[3], Vector2[3];
  double A, B, C, D;

  Vector1[0] = Coord1[0] - Coord2[0];
  Vector1[1] = Coord1[1] - Coord2[1];
  Vector1[2] = Coord1[2] - Coord2[2];

  Vector2[0] = Coord3[0] - Coord2[0];
  Vector2[1] = Coord3[1] - Coord2[1];
  Vector2[2] = Coord3[2] - Coord2[2];

  A = Vector1[0]*Vector2[0]+Vector1[1]*Vector2[1]+Vector1[2]*Vector2[2];
  B = sqrt( Vector1[0]*Vector1[0]+Vector1[1]*Vector1[1]+Vector1[2]*Vector1[2]);
  C = sqrt( Vector2[0]*Vector2[0]+Vector2[1]*Vector2[1]+Vector2[2]*Vector2[2]);

  D = A/(B*C);
  if( D > 0.0 && fabs(D - 1.0) < Eps ) 
    D -= Eps;
  else
  if( D < 0.0 && fabs(D + 1.0) < Eps ) 
    D += Eps;
  
  return((float)(RADDEG*acos(D)));
}

// Assembly:
subq $0x18, %rsp
movss (%rdi), %xmm0
movss 0x4(%rdi), %xmm1
movss (%rsi), %xmm3
movss 0x4(%rsi), %xmm4
subss %xmm3, %xmm0
subss %xmm4, %xmm1
movss 0x8(%rdi), %xmm2
movss 0x8(%rsi), %xmm5
subss %xmm5, %xmm2
movss (%rdx), %xmm6
movss 0x4(%rdx), %xmm7
subss %xmm3, %xmm6
subss %xmm4, %xmm7
movss 0x8(%rdx), %xmm8
subss %xmm5, %xmm8
movaps %xmm1, %xmm3
mulss %xmm7, %xmm3
movaps %xmm0, %xmm4
mulss %xmm6, %xmm4
addss %xmm3, %xmm4
movaps %xmm2, %xmm3
mulss %xmm8, %xmm3
addss %xmm4, %xmm3
mulss %xmm1, %xmm1
mulss %xmm0, %xmm0
addss %xmm1, %xmm0
mulss %xmm2, %xmm2
addss %xmm0, %xmm2
xorps %xmm0, %xmm0
cvtss2sd %xmm2, %xmm0
xorps %xmm2, %xmm2
ucomisd %xmm2, %xmm0
jb 0x4199
xorps %xmm1, %xmm1
sqrtsd %xmm0, %xmm1
jmp 0x41d5
movss %xmm6, 0x8(%rsp)
movss %xmm7, (%rsp)
movss %xmm8, 0x14(%rsp)
movss %xmm3, 0x10(%rsp)
callq 0x2250
xorps %xmm2, %xmm2
movss 0x10(%rsp), %xmm3
movss 0x14(%rsp), %xmm8
movss (%rsp), %xmm7
movss 0x8(%rsp), %xmm6
movapd %xmm0, %xmm1
cvtss2sd %xmm3, %xmm3
mulss %xmm7, %xmm7
mulss %xmm6, %xmm6
addss %xmm7, %xmm6
mulss %xmm8, %xmm8
addss %xmm6, %xmm8
xorps %xmm0, %xmm0
cvtss2sd %xmm8, %xmm0
ucomisd %xmm2, %xmm0
jb 0x4203
sqrtsd %xmm0, %xmm0
jmp 0x421e
movsd %xmm3, 0x8(%rsp)
movsd %xmm1, (%rsp)
callq 0x2250
movsd (%rsp), %xmm1
movsd 0x8(%rsp), %xmm3
mulsd %xmm0, %xmm1
divsd %xmm1, %xmm3
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm3
jbe 0x425c
movsd 0x15620(%rip), %xmm1    # 0x19858
addsd %xmm3, %xmm1
andpd 0x1566c(%rip), %xmm1    # 0x198b0
movsd 0x15614(%rip), %xmm2    # 0x19860
ucomisd %xmm1, %xmm2
jbe 0x425c
addsd 0x15616(%rip), %xmm3    # 0x19870
jmp 0x428c
ucomisd %xmm3, %xmm0
jbe 0x428c
movsd 0x155fe(%rip), %xmm0    # 0x19868
addsd %xmm3, %xmm0
andpd 0x1563a(%rip), %xmm0    # 0x198b0
movsd 0x155e2(%rip), %xmm1    # 0x19860
ucomisd %xmm0, %xmm1
jbe 0x428c
addsd 0x155d4(%rip), %xmm3    # 0x19860
movapd %xmm3, %xmm0
callq 0x2120
mulsd 0x155db(%rip), %xmm0    # 0x19878
cvtsd2ss %xmm0, %xmm0
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/josch[P]stride/geometry.c
// Function: PHI
void PHI(CHAIN *Chain, int Res)
{

  int C_Prev, N_Curr, CA_Curr, C_Curr;
  RESIDUE *r, *rr;

  r = Chain->Rsd[Res];
  r->Prop->Phi = 360.0;

  if( Res == 0 )
    return;

  rr = Chain->Rsd[Res-1];

  if( FindAtom(Chain,Res-1,"C",&C_Prev) && FindAtom(Chain,Res,"N",&N_Curr)   &&
      FindAtom(Chain,Res,"CA",&CA_Curr) && FindAtom(Chain,Res,"C",&C_Curr)   &&
      Dist(rr->Coord[C_Prev],r->Coord[N_Curr]) < BREAKDIST ) {
    r->Prop->Phi = Torsion(rr->Coord[C_Prev],r->Coord[N_Curr],
			   r->Coord[CA_Curr],r->Coord[C_Curr]);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x68(%rdi), %rax
movslq %esi, %rcx
movq (%rax,%rcx,8), %r15
movq 0x768(%r15), %rdx
movl $0x43b40000, (%rdx)     # imm = 0x43B40000
testl %ecx, %ecx
je 0x4407
movl %esi, %ebx
movq %rdi, %r14
leal -0x1(%rcx), %esi
movq -0x8(%rax,%rcx,8), %r12
leaq 0x1630f(%rip), %rdx     # 0x1a5f4
leaq 0xc(%rsp), %rcx
callq 0x4f78
testl %eax, %eax
je 0x4407
leaq 0x15610(%rip), %rdx     # 0x1990e
leaq 0x8(%rsp), %rcx
movq %r14, %rdi
movl %ebx, %esi
callq 0x4f78
testl %eax, %eax
je 0x4407
leaq 0x16b2c(%rip), %rdx     # 0x1ae48
leaq 0x14(%rsp), %rcx
movq %r14, %rdi
movl %ebx, %esi
callq 0x4f78
testl %eax, %eax
je 0x4407
leaq 0x162ba(%rip), %rdx     # 0x1a5f4
leaq 0x10(%rsp), %rcx
movq %r14, %rdi
movl %ebx, %esi
callq 0x4f78
testl %eax, %eax
je 0x4407
movl $0x188, %ebx            # imm = 0x188
movslq 0xc(%rsp), %rax
leaq (%rax,%rax,2), %rax
leaq (%r12,%rax,4), %rax
addq $0x188, %rax            # imm = 0x188
addq %rbx, %r12
addq %r15, %rbx
movslq 0x8(%rsp), %rcx
leaq (%rcx,%rcx,2), %rcx
leaq (%r15,%rcx,4), %rcx
addq $0x188, %rcx            # imm = 0x188
xorps %xmm0, %xmm0
xorl %edx, %edx
movss (%rax,%rdx,4), %xmm1
subss (%rcx,%rdx,4), %xmm1
mulss %xmm1, %xmm1
addss %xmm1, %xmm0
incq %rdx
cmpq $0x3, %rdx
jne 0x4388
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x43b1
sqrtss %xmm0, %xmm0
jmp 0x43b6
callq 0x2170
movss 0x15532(%rip), %xmm1    # 0x198f0
ucomiss %xmm0, %xmm1
jbe 0x4407
movslq 0xc(%rsp), %rax
leaq (%rax,%rax,2), %rax
leaq (%r12,%rax,4), %rdi
movslq 0x8(%rsp), %rax
leaq (%rax,%rax,2), %rax
leaq (%rbx,%rax,4), %rsi
movslq 0x14(%rsp), %rax
leaq (%rax,%rax,2), %rax
leaq (%rbx,%rax,4), %rdx
movslq 0x10(%rsp), %rax
leaq (%rax,%rax,2), %rax
leaq (%rbx,%rax,4), %rcx
callq 0x3e9c
movq 0x768(%r15), %rax
movss %xmm0, (%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/josch[P]stride/geometry.c
// Function: PSI
void PSI(CHAIN *Chain, int Res)
{

  int N_Curr, CA_Curr, C_Curr, N_Next;
  RESIDUE *r, *rr;

  r = Chain->Rsd[Res];
  r->Prop->Psi = 360.0;

  if( Res == Chain->NRes-1 )
    return;

  rr = Chain->Rsd[Res+1];

  if( FindAtom(Chain,Res,"N",&N_Curr) && FindAtom(Chain,Res,"CA",&CA_Curr) &&
      FindAtom(Chain,Res,"C",&C_Curr) && FindAtom(Chain,Res+1,"N",&N_Next) &&
      Dist(r->Coord[C_Curr],rr->Coord[N_Next]) < BREAKDIST ){

    r->Prop->Psi = Torsion(r->Coord[N_Curr],r->Coord[CA_Curr],
			   r->Coord[C_Curr],rr->Coord[N_Next]);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x68(%rdi), %rax
movslq %esi, %rcx
movq (%rax,%rcx,8), %r15
movq 0x768(%r15), %rdx
movl $0x43b40000, 0x4(%rdx)  # imm = 0x43B40000
movl (%rdi), %edx
decl %edx
cmpl %ecx, %edx
je 0x457a
movl %esi, %ebx
movq %rdi, %r14
movq 0x8(%rax,%rcx,8), %r12
leaq 0x154ba(%rip), %rdx     # 0x1990e
leaq 0x14(%rsp), %rcx
callq 0x4f78
testl %eax, %eax
je 0x457a
leaq 0x169db(%rip), %rdx     # 0x1ae48
leaq 0x10(%rsp), %rcx
movq %r14, %rdi
movl %ebx, %esi
callq 0x4f78
testl %eax, %eax
je 0x457a
leaq 0x16169(%rip), %rdx     # 0x1a5f4
leaq 0xc(%rsp), %rcx
movq %r14, %rdi
movl %ebx, %esi
callq 0x4f78
testl %eax, %eax
je 0x457a
incl %ebx
leaq 0x15463(%rip), %rdx     # 0x1990e
leaq 0x8(%rsp), %rcx
movq %r14, %rdi
movl %ebx, %esi
callq 0x4f78
testl %eax, %eax
je 0x457a
movl $0x188, %ebx            # imm = 0x188
leaq (%r15,%rbx), %r14
movslq 0xc(%rsp), %rax
leaq (%rax,%rax,2), %rax
leaq (%r15,%rax,4), %rax
addq $0x188, %rax            # imm = 0x188
addq %r12, %rbx
movslq 0x8(%rsp), %rcx
leaq (%rcx,%rcx,2), %rcx
leaq (%r12,%rcx,4), %rcx
addq $0x188, %rcx            # imm = 0x188
xorps %xmm0, %xmm0
xorl %edx, %edx
movss (%rax,%rdx,4), %xmm1
subss (%rcx,%rdx,4), %xmm1
mulss %xmm1, %xmm1
addss %xmm1, %xmm0
incq %rdx
cmpq $0x3, %rdx
jne 0x44fa
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x4523
sqrtss %xmm0, %xmm0
jmp 0x4528
callq 0x2170
movss 0x153c0(%rip), %xmm1    # 0x198f0
ucomiss %xmm0, %xmm1
jbe 0x457a
movslq 0x14(%rsp), %rax
leaq (%rax,%rax,2), %rax
leaq (%r14,%rax,4), %rdi
movslq 0x10(%rsp), %rax
leaq (%rax,%rax,2), %rax
leaq (%r14,%rax,4), %rsi
movslq 0xc(%rsp), %rax
leaq (%rax,%rax,2), %rax
leaq (%r14,%rax,4), %rdx
movslq 0x8(%rsp), %rax
leaq (%rax,%rax,2), %rax
leaq (%rbx,%rax,4), %rcx
callq 0x3e9c
movq 0x768(%r15), %rax
movss %xmm0, 0x4(%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/josch[P]stride/geometry.c
// Function: OMEGA
void OMEGA(CHAIN *Chain, int Res)
{

  int CA_Prev, C_Prev, N_Curr, CA_Curr;
  RESIDUE *r, *rr;

  
  r = Chain->Rsd[Res];
  r->Prop->Omega = 360.0;

  if( Res == 0 )
    return;

  rr = Chain->Rsd[Res-1];

  if( FindAtom(Chain,Res-1,"CA",&CA_Prev) && FindAtom(Chain,Res-1,"C",&C_Prev)   &&
      FindAtom(Chain,Res,"N",&N_Curr)     && FindAtom(Chain,Res,"CA",&CA_Curr) ) {

    r->Prop->Omega = Torsion(rr->Coord[CA_Prev],rr->Coord[C_Prev],
			     r->Coord[N_Curr],r->Coord[CA_Curr]);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq 0x68(%rdi), %rax
movslq %esi, %rcx
movq (%rax,%rcx,8), %r15
movq 0x768(%r15), %rdx
movl $0x43b40000, 0x8(%rdx)  # imm = 0x43B40000
testl %ecx, %ecx
je 0x4685
movl %esi, %ebx
movq %rdi, %r14
leal -0x1(%rcx), %ebp
movq -0x8(%rax,%rcx,8), %r12
leaq 0x16881(%rip), %rdx     # 0x1ae48
leaq 0xc(%rsp), %rcx
movl %ebp, %esi
callq 0x4f78
testl %eax, %eax
je 0x4685
leaq 0x16012(%rip), %rdx     # 0x1a5f4
leaq 0x8(%rsp), %rcx
movq %r14, %rdi
movl %ebp, %esi
callq 0x4f78
testl %eax, %eax
je 0x4685
leaq 0x1530e(%rip), %rdx     # 0x1990e
leaq 0x4(%rsp), %rcx
movq %r14, %rdi
movl %ebx, %esi
callq 0x4f78
testl %eax, %eax
je 0x4685
leaq 0x1682e(%rip), %rdx     # 0x1ae48
movq %rsp, %rcx
movq %r14, %rdi
movl %ebx, %esi
callq 0x4f78
testl %eax, %eax
je 0x4685
movslq 0xc(%rsp), %rax
leaq (%rax,%rax,2), %rax
leaq (%r12,%rax,4), %rdi
addq $0x188, %rdi            # imm = 0x188
movslq 0x8(%rsp), %rax
leaq (%rax,%rax,2), %rax
leaq 0x188(%r12,%rax,4), %rsi
movslq 0x4(%rsp), %rax
leaq (%rax,%rax,2), %rax
leaq 0x188(%r15,%rax,4), %rdx
movslq (%rsp), %rax
leaq (%rax,%rax,2), %rax
leaq (%r15,%rax,4), %rcx
addq $0x188, %rcx            # imm = 0x188
callq 0x3e9c
movq 0x768(%r15), %rax
movss %xmm0, 0x8(%rax)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/josch[P]stride/geometry.c
// Function: VectorProduct
float VectorProduct(float *Vector1, float *Vector2, float *Product)
{

  int i, j, k;
  float ProductLength;

  ProductLength = 0.0; 

  for( i=0; i<3; i++ ) {
    j = (i+1)%3;
    k = (j+1)%3;
    Product[i] = Vector1[j]*Vector2[k] - Vector1[k]*Vector2[j];
    ProductLength += Product[i]*Product[i];
  }

  return(sqrt(ProductLength));
}

// Assembly:
xorps %xmm0, %xmm0
xorl %eax, %eax
movl $0xaaaaaaab, %ecx       # imm = 0xAAAAAAAB
xorl %r8d, %r8d
leaq 0x1(%r8), %r9
cmpq $0x2, %r8
movl %r9d, %r10d
cmovel %eax, %r10d
leal 0x1(%r10), %r11d
imulq %rcx, %r11
shrq $0x21, %r11
leal (%r11,%r11,2), %r11d
negl %r11d
addl %r10d, %r11d
incl %r11d
movss (%rdi,%r10,4), %xmm1
shll $0x2, %r11d
movss (%rsi,%r10,4), %xmm2
mulss (%rdi,%r11), %xmm2
mulss (%rsi,%r11), %xmm1
subss %xmm2, %xmm1
movss %xmm1, (%rdx,%r8,4)
mulss %xmm1, %xmm1
addss %xmm1, %xmm0
movq %r9, %r8
cmpq $0x3, %r9
jne 0x48c2
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x2170
sqrtss %xmm0, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O1/josch[P]stride/geometry.c
// Function: GetAtomRadius
double GetAtomRadius(char *AtomType)
{

  if( !strcmp(AtomType,"O") )
    return(1.40);
  else
  if( !strcmp(AtomType,"N") )
    return(1.65);
  else
  if( !strcmp(AtomType,"CA") )
    return(1.87);
  else
  if( !strcmp(AtomType,"C") )
    return(1.76);
  else
    return(1.80);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x14e01(%rip), %rsi     # 0x19932
callq 0x2150
testl %eax, %eax
je 0x4b84
leaq 0x14dcd(%rip), %rsi     # 0x1990e
movq %rbx, %rdi
callq 0x2150
testl %eax, %eax
je 0x4b8e
leaq 0x162f4(%rip), %rsi     # 0x1ae48
movq %rbx, %rdi
callq 0x2150
testl %eax, %eax
je 0x4b98
leaq 0x15a8d(%rip), %rsi     # 0x1a5f4
movq %rbx, %rdi
callq 0x2150
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
leaq 0x14d63(%rip), %rax     # 0x198e0
movsd (%rax,%rcx,8), %xmm0
jmp 0x4ba0
movsd 0x14d0c(%rip), %xmm0    # 0x19898
jmp 0x4ba0
movsd 0x14d0a(%rip), %xmm0    # 0x198a0
jmp 0x4ba0
movsd 0x14d08(%rip), %xmm0    # 0x198a8
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O1/josch[P]stride/filename.c
// Function: StripPathFromLastExtention
void StripPathFromLastExtention(char *Path, char *StrippedPath)
{
  int i;

  strcpy(StrippedPath,Path);

  for( i = (int)strlen(StrippedPath); i>=0; i-- )
    if( StrippedPath[i] == '.' ) {
      StrippedPath[i] = '\0';
      break;
    }
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movq %rdi, %rsi
movq %rbx, %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x20b0
testl %eax, %eax
js 0x4ebe
movl %eax, %ecx
cmpb $0x2e, (%rbx,%rcx)
je 0x4eba
leal -0x1(%rcx), %eax
testl %ecx, %ecx
jg 0x4ea9
jmp 0x4ebe
movb $0x0, (%rbx,%rcx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/josch[P]stride/tolostr.c
// Function: tolostr
char *tolostr(char *InputString)
{
  register int i;
  int Length;
  static char OutputString[BUFSZ];

  strcpy(OutputString,InputString);

  Length = (int)strlen(OutputString);

  for( i=0; i<Length; i++ )
    OutputString[i] = tolower(OutputString[i]);
  return(OutputString);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rsi
leaq 0x1d0e2(%rip), %rbx     # 0x21fb0
movq %rbx, %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x20b0
movq %rax, %r14
testl %r14d, %r14d
jle 0x4f0a
callq 0x2280
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
xorl %ecx, %ecx
movq (%rax), %rdx
movsbq (%rcx,%rbx), %rsi
movb (%rdx,%rsi,4), %dl
movb %dl, (%rcx,%rbx)
incq %rcx
cmpq %rcx, %r14
jne 0x4ef4
leaq 0x1d09f(%rip), %rax     # 0x21fb0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/josch[P]stride/strutil.c
// Function: PdbN2SeqN
int PdbN2SeqN(CHAIN *Chain, char *PdbN, int *SeqN)
{

  for( (*SeqN)=0; (*SeqN)<Chain->NRes; (*SeqN)++ )
    if( !strcmp(Chain->Rsd[(*SeqN)]->PDB_ResNumb,PdbN) ) 
      return(SUCCESS);

  return(FAILURE);
}

// Assembly:
movl $0x0, (%rdx)
cmpl $0x0, (%rdi)
jle 0x4f66
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x68(%rdi), %r12
xorl %r13d, %r13d
movq (%r12,%r13,8), %rdi
addq $0x4, %rdi
movq %r14, %rsi
callq 0x2150
testl %eax, %eax
je 0x4f69
incq %r13
movl %r13d, (%rbx)
movslq (%r15), %rax
cmpq %rax, %r13
jl 0x4f40
xorl %eax, %eax
jmp 0x4f6e
xorl %eax, %eax
retq
movl $0x1, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/josch[P]stride/strutil.c
// Function: FindAtom
int FindAtom(CHAIN *Chain, int ResNumb, char *Atom, int *AtNumb)
{

  for( (*AtNumb)=0; (*AtNumb)<Chain->Rsd[ResNumb]->NAtom; (*AtNumb)++ )
    if( !strcmp(Atom,Chain->Rsd[ResNumb]->AtomType[(*AtNumb)]) )
       return(SUCCESS);

  *AtNumb = ERR;
  return(FAILURE);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq 0x68(%rdi), %rax
movslq %esi, %rcx
movq (%rax,%rcx,8), %r12
movl $0x0, (%rbx)
cmpl $0x0, (%r12)
jle 0x4fc9
movq %rdx, %r14
leaq 0x10(%r12), %r15
xorl %r13d, %r13d
movq %r14, %rdi
movq %r15, %rsi
callq 0x2150
testl %eax, %eax
je 0x4fd3
incq %r13
movl %r13d, (%rbx)
movslq (%r12), %rax
addq $0x5, %r15
cmpq %rax, %r13
jl 0x4fa7
movl $0xffffffff, (%rbx)     # imm = 0xFFFFFFFF
xorl %eax, %eax
jmp 0x4fd8
movl $0x1, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq