LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x13c22
movq 0xd45f(%rip), %r14      # 0x20fd0
leaq 0x5f18(%rip), %rsi      # 0x19a90
movl $0x14, %edx
movq %r14, %rdi
callq 0x3340
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x3340
movq %rax, %r14
leaq 0x5877(%rip), %rsi      # 0x19415
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 0x5e9a(%rip), %xmm0     # 0x19a68
addsd %xmm1, %xmm0
movq %r14, %rdi
callq 0x34f0
movq %rax, %r14
leaq 0x5ec1(%rip), %rsi      # 0x19aa5
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 0x13c7a
movq 0xd3c7(%rip), %r15      # 0x20ff0
leaq 0x5e7e(%rip), %rsi      # 0x19aae
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_O3/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
cmpb $0x1, 0x38(%rbx)
jne 0x13d76
cmpq $0x0, 0x8(%r15)
je 0x13d64
movq 0xd312(%rip), %r14      # 0x20fd0
leaq 0x5dcb(%rip), %rsi      # 0x19a90
movl $0x14, %edx
movq %r14, %rdi
callq 0x3340
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x3340
movq %rax, %r14
leaq 0x572a(%rip), %rsi      # 0x19415
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 0x5d4e(%rip), %xmm0     # 0x19a68
addsd %xmm1, %xmm0
movq %r14, %rdi
callq 0x34f0
movq %rax, %r14
leaq 0x5d75(%rip), %rsi      # 0x19aa5
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)
movups (%rsp), %xmm0
movups %xmm0, 0x20(%rbx)
jmp 0x13dce
movq 0xd273(%rip), %r15      # 0x20ff0
leaq 0x5d2a(%rip), %rsi      # 0x19aae
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_O3/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 0x13f72
testb %al, %al
je 0x13f53
movq 0x20(%r14), %rax
movslq %ebx, %rdx
movl (%rax,%rdx,4), %ecx
cmpl %ebx, %ecx
je 0x13f49
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 0x13f36
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x5b90(%rip), %rdi      # 0x19aea
leaq 0x5b94(%rip), %rsi      # 0x19af5
leaq 0x5b94(%rip), %rcx      # 0x19afc
movl $0x3f, %edx
callq 0x31b0
// File: /workspace/github_c_makefile_star2_O3/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 0x13f8f
movslq %ebp, %rax
movq 0x8(%rbx), %rcx
cmpl $-0x1, (%rcx,%rax,4)
setne %al
jmp 0x14001
movq 0xd03a(%rip), %r14      # 0x20fd0
leaq 0x5ba3(%rip), %rsi      # 0x19b40
movl $0x22, %edx
movq %r14, %rdi
callq 0x3340
movq %r14, %rdi
movl %ebp, %esi
callq 0x3560
movq %rax, %r14
leaq 0x5b73(%rip), %rsi      # 0x19b31
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_O3/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 0x14023
movslq %ebp, %rax
movq 0x8(%rbx), %rcx
cmpl $0x1, (%rcx,%rax,4)
sete %al
jmp 0x14095
movq 0xcfa6(%rip), %r14      # 0x20fd0
leaq 0x5ae4(%rip), %rsi      # 0x19b15
movl $0x1b, %edx
movq %r14, %rdi
callq 0x3340
movq %r14, %rdi
movl %ebp, %esi
callq 0x3560
movq %rax, %r14
leaq 0x5adf(%rip), %rsi      # 0x19b31
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_O3/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 0x140d2
movq %rbx, %rdi
movl %ebp, %esi
callq 0x13f72
testb %al, %al
jne 0x140cd
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 0xcef7(%rip), %r14      # 0x20fd0
leaq 0x5a83(%rip), %rsi      # 0x19b63
movl $0x20, %edx
movq %r14, %rdi
callq 0x3340
movq %r14, %rdi
movl %ebp, %esi
callq 0x3560
movq %rax, %r14
leaq 0x5a30(%rip), %rsi      # 0x19b31
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_O3/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 0x13f12
movl %eax, %r14d
movq %rbx, %rdi
movl %ebp, %esi
callq 0x13f12
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_O3/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 0x1533f
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 0x15317
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 0x15304
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x1530f
movq %rbx, %rdi
movq %r12, %rdx
callq 0x463c
incl %ebp
cmpl 0xc(%rsp), %ebp
jl 0x152d0
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 0xbc8a(%rip), %rdi      # 0x20fd0
leaq 0x48bd(%rip), %rsi      # 0x19c0a
movl $0x16, %edx
callq 0x3340
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0xbc6b(%rip), %rdi      # 0x20fd0
callq 0x3340
movq %rax, %rdi
callq 0x3160
movl $0x1, %edi
callq 0x3370
jmp 0x15382
jmp 0x15382
jmp 0x15382
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x30d0
movq %rbx, %rdi
callq 0x3570
// File: /workspace/github_c_makefile_star2_O3/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 0xb50c
movq %r12, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x14f70
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x153f5
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 0xb50c
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1523b
movl %eax, %ebx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x15439
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 0x1545c
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x1546d
movq (%r13), %rsi
incq %rsi
callq 0x32f0
movq %rbx, %rdi
callq 0x3570
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x12fa8
movq %r14, %rdi
callq 0xfb52
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1301a
movq 0xb1fa(%rip), %rdi      # 0x20fd0
leaq 0x3e7a(%rip), %rsi      # 0x19c57
callq 0x32c0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x35c0
leaq 0x3e6b(%rip), %rsi      # 0x19c5f
movq %rax, %rdi
callq 0x32c0
movq %rax, %rdi
callq 0x3160
xorl %edi, %edi
callq 0x3580
// File: /workspace/github_c_makefile_star2_O3/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 0x18397(%rip), %rsi     # 0x1a8d0
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 0x1838c(%rip), %rdi     # 0x1a901
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_O3/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 0x50a2
movsbl %al, %ecx
leaq 0x1877a(%rip), %rsi     # 0x1af1e
movq %r15, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x2160
movq (%r13), %rdi
leaq 0x18771(%rip), %rsi     # 0x1af2d
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_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r13
callq 0x20b0
movq %rax, %r14
leaq 0x1e4ca(%rip), %r12     # 0x21bb0
movq %r12, %rdi
movq %r13, %rsi
callq 0x2070
xorl %eax, %eax
cmpl $0x2, %r14d
jl 0x37c9
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
leal (%r14,%r13), %ebp
callq 0x2290
movq %rax, %rcx
leal -0x2(%r14), %edx
xorl %esi, %esi
xorl %edi, %edi
xorl %eax, %eax
movq (%rcx), %r8
movsbq (%rsi,%r12), %r9
movzwl (%r8,%r9,2), %r8d
cmpq %rsi, %rdx
je 0x373f
movl %r8d, %r9d
andl $0x2000, %r9d           # imm = 0x2000
je 0x373f
testl %edi, %edi
jne 0x373f
xorl %edi, %edi
jmp 0x37af
cmpq %rsi, %rdx
setne %r9b
movl %r8d, %r10d
shrl $0xd, %r10d
andl $0x1, %r10d
cmpl $0x1, %edi
setne %r11b
orb %r9b, %r11b
orb %r10b, %r11b
je 0x37bd
leaq (%r12,%rsi), %r9
cmpl $0x1, %edi
sete %r10b
movl %r8d, %r11d
shrl $0xd, %r11d
andb %r10b, %r11b
cmpb $0x1, %r11b
jne 0x378a
movb $0x0, (%r9)
movl $0x0, %edi
cmpl %ebx, %eax
jne 0x37af
jmp 0x37c7
btl $0xd, %r8d
setae %r8b
testl %edi, %edi
sete %r10b
andb %r8b, %r10b
cmpb $0x1, %r10b
jne 0x37af
cltq
movq %r9, (%r15,%rax,8)
incl %eax
movl $0x1, %edi
incq %rsi
cmpq %rsi, %rbp
jne 0x3719
jmp 0x37c9
addl %r13d, %r14d
movb $0x0, (%r14,%r12)
jmp 0x37c9
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x5880
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 0x5880
movq (%rbx), %rcx
movq %rax, 0x48(%rcx)
movl $0x27100, %edi          # imm = 0x27100
callq 0x5880
movq (%rbx), %rcx
movq %rax, 0x68(%rcx)
movl $0x27100, %edi          # imm = 0x27100
callq 0x5880
movq (%rbx), %rcx
movq %rax, 0x70(%rcx)
movl $0x640, %edi            # imm = 0x640
callq 0x5880
movq (%rbx), %rcx
movq %rax, 0x78(%rcx)
movl $0xfa0, %edi            # imm = 0xFA0
callq 0x5880
movq (%rbx), %rcx
movq %rax, 0x80(%rcx)
movl $0xfa0, %edi            # imm = 0xFA0
callq 0x5880
movq (%rbx), %rcx
movq %rax, 0x88(%rcx)
movl $0x960, %edi            # imm = 0x960
callq 0x5880
movq (%rbx), %rcx
movq %rax, 0x90(%rcx)
movl $0x960, %edi            # imm = 0x960
callq 0x5880
movq (%rbx), %rcx
movq %rax, 0x98(%rcx)
movl $0x320, %edi            # imm = 0x320
callq 0x5880
movq (%rbx), %rcx
movq %rax, 0xa0(%rcx)
movl $0x1f40, %edi           # imm = 0x1F40
callq 0x5880
movq (%rbx), %rcx
movq %rax, 0xa8(%rcx)
movq (%rbx), %rax
movl $0x1, 0x58(%rax)
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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:
movss (%rdx), %xmm0
movss 0x4(%rdx), %xmm2
movss 0x8(%rdx), %xmm4
movss (%rdi), %xmm1
unpcklps %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movss 0x4(%rdi), %xmm3
unpcklps %xmm2, %xmm3            # xmm3 = xmm3[0],xmm2[0],xmm3[1],xmm2[1]
movss 0x8(%rdi), %xmm2
unpcklps %xmm4, %xmm2            # xmm2 = xmm2[0],xmm4[0],xmm2[1],xmm4[1]
movss (%rsi), %xmm0
movss 0x4(%rsi), %xmm4
movss 0x8(%rsi), %xmm5
shufps $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
subps %xmm0, %xmm1
shufps $0x0, %xmm4, %xmm4      # xmm4 = xmm4[0,0,0,0]
subps %xmm4, %xmm3
shufps $0x0, %xmm5, %xmm5      # xmm5 = xmm5[0,0,0,0]
subps %xmm5, %xmm2
movaps %xmm3, %xmm0
shufps $0x55, %xmm3, %xmm0     # xmm0 = xmm0[1,1],xmm3[1,1]
mulss %xmm3, %xmm0
movaps %xmm1, %xmm4
shufps $0x55, %xmm1, %xmm4     # xmm4 = xmm4[1,1],xmm1[1,1]
mulss %xmm1, %xmm4
addss %xmm0, %xmm4
movaps %xmm2, %xmm0
shufps $0x55, %xmm2, %xmm0     # xmm0 = xmm0[1,1],xmm2[1,1]
mulss %xmm2, %xmm0
addss %xmm4, %xmm0
cvtss2sd %xmm0, %xmm0
mulps %xmm3, %xmm3
mulps %xmm1, %xmm1
addps %xmm3, %xmm1
mulps %xmm2, %xmm2
addps %xmm1, %xmm2
cvtps2pd %xmm2, %xmm1
sqrtpd %xmm1, %xmm1
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
mulsd %xmm1, %xmm2
divsd %xmm2, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x41c5
movsd 0x156b7(%rip), %xmm2    # 0x19858
addsd %xmm0, %xmm2
andpd 0x15713(%rip), %xmm2    # 0x198c0
movsd 0x156ab(%rip), %xmm3    # 0x19860
ucomisd %xmm2, %xmm3
jbe 0x41c5
addsd 0x156ad(%rip), %xmm0    # 0x19870
jmp 0x41f5
ucomisd %xmm0, %xmm1
jbe 0x41f5
movsd 0x15695(%rip), %xmm1    # 0x19868
addsd %xmm0, %xmm1
andpd 0x156e1(%rip), %xmm1    # 0x198c0
movsd 0x15679(%rip), %xmm2    # 0x19860
ucomisd %xmm1, %xmm2
jbe 0x41f5
addsd 0x1566b(%rip), %xmm0    # 0x19860
pushq %rax
callq 0x2120
mulsd 0x15675(%rip), %xmm0    # 0x19878
cvtsd2ss %xmm0, %xmm0
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x436a
movl %esi, %ebx
movq %rdi, %r14
leal -0x1(%rcx), %esi
movq -0x8(%rax,%rcx,8), %r12
leaq 0x1639c(%rip), %rdx     # 0x1a5e4
leaq 0xc(%rsp), %rcx
callq 0x4ea0
testl %eax, %eax
je 0x436a
leaq 0x156bd(%rip), %rdx     # 0x1991e
leaq 0x8(%rsp), %rcx
movq %r14, %rdi
movl %ebx, %esi
callq 0x4ea0
testl %eax, %eax
je 0x436a
leaq 0x16bb9(%rip), %rdx     # 0x1ae38
leaq 0x14(%rsp), %rcx
movq %r14, %rdi
movl %ebx, %esi
callq 0x4ea0
testl %eax, %eax
je 0x436a
leaq 0x16347(%rip), %rdx     # 0x1a5e4
leaq 0x10(%rsp), %rcx
movq %r14, %rdi
movl %ebx, %esi
callq 0x4ea0
testl %eax, %eax
je 0x436a
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 0x42eb
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x4314
sqrtss %xmm0, %xmm0
jmp 0x4319
callq 0x2170
movss 0x155df(%rip), %xmm1    # 0x19900
ucomiss %xmm0, %xmm1
jbe 0x436a
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_O3/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 0x44dd
movl %esi, %ebx
movq %rdi, %r14
movq 0x8(%rax,%rcx,8), %r12
leaq 0x15567(%rip), %rdx     # 0x1991e
leaq 0x14(%rsp), %rcx
callq 0x4ea0
testl %eax, %eax
je 0x44dd
leaq 0x16a68(%rip), %rdx     # 0x1ae38
leaq 0x10(%rsp), %rcx
movq %r14, %rdi
movl %ebx, %esi
callq 0x4ea0
testl %eax, %eax
je 0x44dd
leaq 0x161f6(%rip), %rdx     # 0x1a5e4
leaq 0xc(%rsp), %rcx
movq %r14, %rdi
movl %ebx, %esi
callq 0x4ea0
testl %eax, %eax
je 0x44dd
incl %ebx
leaq 0x15510(%rip), %rdx     # 0x1991e
leaq 0x8(%rsp), %rcx
movq %r14, %rdi
movl %ebx, %esi
callq 0x4ea0
testl %eax, %eax
je 0x44dd
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 0x445d
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x4486
sqrtss %xmm0, %xmm0
jmp 0x448b
callq 0x2170
movss 0x1546d(%rip), %xmm1    # 0x19900
ucomiss %xmm0, %xmm1
jbe 0x44dd
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_O3/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 0x45e8
movl %esi, %ebx
movq %rdi, %r14
leal -0x1(%rcx), %ebp
movq -0x8(%rax,%rcx,8), %r12
leaq 0x1690e(%rip), %rdx     # 0x1ae38
leaq 0xc(%rsp), %rcx
movl %ebp, %esi
callq 0x4ea0
testl %eax, %eax
je 0x45e8
leaq 0x1609f(%rip), %rdx     # 0x1a5e4
leaq 0x8(%rsp), %rcx
movq %r14, %rdi
movl %ebp, %esi
callq 0x4ea0
testl %eax, %eax
je 0x45e8
leaq 0x153bb(%rip), %rdx     # 0x1991e
leaq 0x4(%rsp), %rcx
movq %r14, %rdi
movl %ebx, %esi
callq 0x4ea0
testl %eax, %eax
je 0x45e8
leaq 0x168bb(%rip), %rdx     # 0x1ae38
movq %rsp, %rcx
movq %r14, %rdi
movl %ebx, %esi
callq 0x4ea0
testl %eax, %eax
je 0x45e8
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_O3/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
xorl %ecx, %ecx
leaq 0x1(%rcx), %r8
cmpq $0x2, %rcx
movl %r8d, %r9d
cmovel %eax, %r9d
xorl %r10d, %r10d
cmpl $0x2, %r9d
setb %r10b
leal (%r10,%r10,2), %r10d
leal -0x2(%r9,%r10), %r10d
movl %r9d, %r9d
movss (%rdi,%r9,4), %xmm1
movss (%rsi,%r9,4), %xmm2
mulss (%rdi,%r10,4), %xmm2
mulss (%rsi,%r10,4), %xmm1
subss %xmm2, %xmm1
movss %xmm1, (%rdx,%rcx,4)
mulss %xmm1, %xmm1
addss %xmm1, %xmm0
movq %r8, %rcx
cmpq $0x3, %r8
jne 0x481f
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x2170
sqrtss %xmm0, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4de6
movl %eax, %ecx
cmpb $0x2e, (%rbx,%rcx)
je 0x4de2
leal -0x1(%rcx), %eax
testl %ecx, %ecx
jg 0x4dd1
jmp 0x4de6
movb $0x0, (%rbx,%rcx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1d1ba(%rip), %rbx     # 0x21fb0
movq %rbx, %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x20b0
movq %rax, %r14
testl %r14d, %r14d
jle 0x4e32
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 0x4e1c
leaq 0x1d177(%rip), %rax     # 0x21fb0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0x4e8e
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 0x4e91
incq %r13
movl %r13d, (%rbx)
movslq (%r15), %rax
cmpq %rax, %r13
jl 0x4e68
xorl %eax, %eax
jmp 0x4e96
xorl %eax, %eax
retq
movl $0x1, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4ef1
movq %rdx, %r14
leaq 0x10(%r12), %r15
xorl %r13d, %r13d
movq %r14, %rdi
movq %r15, %rsi
callq 0x2150
testl %eax, %eax
je 0x4efb
incq %r13
movl %r13d, (%rbx)
movslq (%r12), %rax
addq $0x5, %r15
cmpq %rax, %r13
jl 0x4ecf
movl $0xffffffff, (%rbx)     # imm = 0xFFFFFFFF
xorl %eax, %eax
jmp 0x4f00
movl $0x1, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/josch[P]stride/strutil.c
// Function: Boundaries
int Boundaries(char *Asn, int L, char SecondStr, int (*Bound)[2])
{
  register int Res;
  int NStr = 0, Flag = 0;
  
  for( Res=0; Res<L; Res++ ) {
    if( Asn[Res] == SecondStr && Flag == 0 ) {
      Flag = 1; 
      Bound[NStr][0] = Res;
    }
    else
    if( Asn[Res] != SecondStr && Flag == 1 ) {
      Flag = 0; 
      Bound[NStr++][1] = Res-1;
    }
  }
  return(NStr);
}

// Assembly:
testl %esi, %esi
jle 0x4f74
pushq %rbx
movl %esi, %esi
xorl %r8d, %r8d
xorl %r9d, %r9d
xorl %eax, %eax
movb (%rdi,%r8), %r10b
cmpb %dl, %r10b
sete %r11b
testl %r9d, %r9d
sete %bl
andb %r11b, %bl
cmpb $0x1, %bl
jne 0x4f41
movslq %eax, %r9
movl %r8d, (%rcx,%r9,8)
movl $0x1, %r9d
jmp 0x4f6a
cmpb %dl, %r10b
setne %r10b
cmpl $0x1, %r9d
sete %r11b
andb %r10b, %r11b
cmpb $0x1, %r11b
jne 0x4f6a
movslq %eax, %r9
incl %eax
leal -0x1(%r8), %r10d
movl %r10d, 0x4(%rcx,%r9,8)
xorl %r9d, %r9d
incq %r8
cmpq %r8, %rsi
jne 0x4f19
popq %rbx
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/josch[P]stride/strutil.c
// Function: ExistsSecStr
BOOLEAN ExistsSecStr(CHAIN **Chain, int NChain)
{
  register int i, Cn;
  
  for( Cn=0; Cn<NChain; Cn++ )
    for( i=0; i<Chain[Cn]->NRes; i++ )
      if( Chain[Cn]->Rsd[i]->Prop->Asn != 'C' )
	return(YES);

  return(NO);
}

// Assembly:
testl %esi, %esi
jle 0x51f4
movl %esi, %eax
xorl %ecx, %ecx
movq (%rdi,%rcx,8), %rsi
movslq (%rsi), %rdx
testq %rdx, %rdx
jle 0x51ec
movq 0x68(%rsi), %rsi
xorl %r8d, %r8d
movq (%rsi,%r8,8), %r9
movq 0x768(%r9), %r9
cmpb $0x43, 0x1c(%r9)
jne 0x51f7
incq %r8
cmpq %r8, %rdx
jne 0x51d2
incq %rcx
cmpq %rax, %rcx
jne 0x51bf
xorl %eax, %eax
retq
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/josch[P]stride/strutil.c
// Function: SecStrContent
float SecStrContent(CHAIN *Chain, int *HelAlp, int *HelPI, int *Hel310, int *Sheet, int *Turn)
{

  int Res;
  float Content = 0.0;

  *HelAlp = 0; *HelPI = 0; *Hel310 = 0; *Sheet = 0; *Turn = 0;
  
  for( Res=0; Res<Chain->NRes; Res++ ) {
    switch( Chain->Rsd[Res]->Prop->PdbAsn ) {
    case 'H' : (*HelAlp)++;
               break;
    case 'G' : (*Hel310)++;
               break;
    case 'I' : (*HelPI)++;
               break;
    case 'E' : (*Sheet)++;
               break;
    case 'T' : (*Turn)++;
               break;
    }
  }

  Content = ( (float)( (*HelAlp)+(*HelPI)+(*Hel310)+(*Sheet)+(*Turn) ) )/(float)Chain->NRes;

  return(Content);
}

// Assembly:
pushq %r14
pushq %rbx
xorl %eax, %eax
movl %eax, (%rsi)
movl %eax, (%rdx)
movl %eax, (%rcx)
movl %eax, (%r8)
movl %eax, (%r9)
movl (%rdi), %ebx
testl %ebx, %ebx
jle 0x526f
movq 0x68(%rdi), %rax
xorl %r10d, %r10d
leaq 0x1483a(%rip), %r11     # 0x19a5c
movq (%rax,%r10,8), %rbx
movq 0x768(%rbx), %rbx
movzbl 0x1d(%rbx), %ebx
leal -0x45(%rbx), %r14d
cmpl $0x4, %r14d
ja 0x524d
movslq (%r11,%r14,4), %r14
addq %r11, %r14
movq %rsi, %rbx
jmpq *%r14
movq %r8, %rbx
jmp 0x525f
cmpl $0x54, %ebx
jne 0x5261
movq %r9, %rbx
jmp 0x525f
movq %rcx, %rbx
jmp 0x525f
movq %rdx, %rbx
incl (%rbx)
incq %r10
movslq (%rdi), %rbx
cmpq %rbx, %r10
jl 0x5222
movl (%r9), %eax
movl (%rdx), %edx
addl (%rsi), %edx
addl (%rcx), %edx
addl (%r8), %edx
addl %eax, %edx
cvtsi2ss %edx, %xmm0
cvtsi2ss %ebx, %xmm1
divss %xmm1, %xmm0
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O3/josch[P]stride/memory.c
// Function: FloatMatrix
float **FloatMatrix(int M, int N)
{
  int m;
  float **Matrix;

  Matrix = (float **)ckalloc(M*sizeof(float *));

  for( m=0; m<M; m++ ) Matrix[m] = (float *)ckalloc(N*sizeof(float));

  return(Matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r14d
movl %edi, %ebp
movslq %edi, %rdi
shlq $0x3, %rdi
callq 0x2180
movq %rax, %rbx
testq %rax, %rax
jne 0x58d3
leaq 0x142c4(%rip), %rdi     # 0x19b90
xorl %eax, %eax
callq 0x87c8
testl %ebp, %ebp
jle 0x5910
movslq %r14d, %r14
shlq $0x2, %r14
movl %ebp, %r13d
leaq 0x142a8(%rip), %r15     # 0x19b90
xorl %ebp, %ebp
movq %r14, %rdi
callq 0x2180
movq %rax, %r12
testq %rax, %rax
jne 0x5904
movq %r15, %rdi
xorl %eax, %eax
callq 0x87c8
movq %r12, (%rbx,%rbp,8)
incq %rbp
cmpq %rbp, %r13
jne 0x58ea
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/josch[P]stride/memory.c
// Function: FloatCube
float ***FloatCube(int M, int N, int K)
{
  int m, n, k;
  float ***Cube;

  Cube = (float ***)ckalloc(M*sizeof(float **));

  for( m=0; m<M; m++ ) {
    Cube[m] = (float **)ckalloc(N*sizeof(float *));
    for( n=0; n<N; n++ )
      Cube[m][n] = (float *)ckalloc(K*sizeof(float));
  }

  for( m=0; m<M; m++ )
    for( n=0; n<N; n++ )
      for( k=0; k<K; k++ )
	Cube[m][n][k] = 0.0;

  return(Cube);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebx
movl %esi, 0x4(%rsp)
movl %edi, %ebp
movslq %edi, %rdi
shlq $0x3, %rdi
callq 0x2180
movq %rax, %r13
testq %rax, %rax
jne 0x595a
leaq 0x1423d(%rip), %rdi     # 0x19b90
xorl %eax, %eax
callq 0x87c8
testl %ebp, %ebp
jle 0x5a48
movq %r13, 0x10(%rsp)
movslq 0x4(%rsp), %rax
leaq (,%rax,8), %rcx
movq %rcx, 0x20(%rsp)
movl %ebx, 0xc(%rsp)
movslq %ebx, %r13
shlq $0x2, %r13
movl %ebp, 0x8(%rsp)
movl %ebp, %ecx
movq %rcx, 0x18(%rsp)
movl %eax, %r14d
xorl %r15d, %r15d
movq 0x20(%rsp), %rdi
callq 0x2180
movq %rax, %rbp
testq %rax, %rax
jne 0x59b5
leaq 0x141e2(%rip), %rdi     # 0x19b90
xorl %eax, %eax
callq 0x87c8
movq 0x10(%rsp), %rax
movq %rbp, (%rax,%r15,8)
cmpl $0x0, 0x4(%rsp)
jle 0x59f2
xorl %ebx, %ebx
movq %r13, %rdi
callq 0x2180
movq %rax, %r12
testq %rax, %rax
jne 0x59e5
leaq 0x141b2(%rip), %rdi     # 0x19b90
xorl %eax, %eax
callq 0x87c8
movq %r12, (%rbp,%rbx,8)
incq %rbx
cmpq %rbx, %r14
jne 0x59c7
incq %r15
cmpq 0x18(%rsp), %r15
jne 0x5995
cmpl $0x0, 0x8(%rsp)
movl 0xc(%rsp), %ebp
movq 0x10(%rsp), %r13
jle 0x5a48
movl %ebp, %r15d
shlq $0x2, %r15
xorl %r12d, %r12d
cmpl $0x0, 0x4(%rsp)
jle 0x5a3e
xorl %ebx, %ebx
testl %ebp, %ebp
jle 0x5a36
movq (%r13,%r12,8), %rax
movq (%rax,%rbx,8), %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x20f0
incq %rbx
cmpq %rbx, %r14
jne 0x5a1f
incq %r12
cmpq 0x18(%rsp), %r12
jne 0x5a16
movq %r13, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/josch[P]stride/memory.c
// Function: Float4Dim
float ****Float4Dim(int M, int N, int K, int L)
{
  int m, n, k, l;
  float ****FourDim;

  FourDim = (float ****)ckalloc(M*sizeof(float ***));


  for( m=0; m<M; m++ ) {
    FourDim[m] = (float ***)ckalloc(N*sizeof(float **));
    for( n=0; n<N; n++ ) {
      FourDim[m][n] = (float **)ckalloc(K*sizeof(float*));
      for( k=0; k<K; k++ )
	FourDim[m][n][k] = (float *)ckalloc(L*sizeof(float));
    }
  }

  for( m=0; m<M; m++ )
    for( n=0; n<N; n++ )
      for( k=0; k<K; k++ )
	for( l=0; l<L; l++ )
	  FourDim[m][n][k][l] = 0.0;

  return(FourDim);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %ecx, %ebx
movl %edx, 0xc(%rsp)
movl %esi, 0x8(%rsp)
movl %edi, %ebp
movslq %edi, %rdi
shlq $0x3, %rdi
callq 0x2180
movq %rax, 0x10(%rsp)
testq %rax, %rax
jne 0x5a98
leaq 0x140ff(%rip), %rdi     # 0x19b90
xorl %eax, %eax
callq 0x87c8
testl %ebp, %ebp
jle 0x5bfb
movslq 0x8(%rsp), %rax
leaq (,%rax,8), %rcx
movq %rcx, 0x30(%rsp)
movslq 0xc(%rsp), %rcx
leaq (,%rcx,8), %rdx
movq %rdx, 0x40(%rsp)
movl %ebx, 0x1c(%rsp)
movslq %ebx, %r14
shlq $0x2, %r14
movl %ebp, 0x18(%rsp)
movl %ebp, %edx
movq %rdx, 0x20(%rsp)
movl %eax, %eax
movq %rax, 0x28(%rsp)
movl %ecx, %r13d
xorl %ebx, %ebx
movq 0x30(%rsp), %rdi
callq 0x2180
movq %rax, %rbp
testq %rax, %rax
jne 0x5b06
leaq 0x14091(%rip), %rdi     # 0x19b90
xorl %eax, %eax
callq 0x87c8
movq 0x10(%rsp), %rax
movq %rbx, 0x38(%rsp)
movq %rbp, (%rax,%rbx,8)
cmpl $0x0, 0x8(%rsp)
jle 0x5b85
xorl %r15d, %r15d
movq 0x40(%rsp), %rdi
callq 0x2180
movq %rax, %r12
testq %rax, %rax
jne 0x5b3e
leaq 0x14059(%rip), %rdi     # 0x19b90
xorl %eax, %eax
callq 0x87c8
movq %r12, (%rbp,%r15,8)
cmpl $0x0, 0xc(%rsp)
jle 0x5b7b
xorl %ebx, %ebx
movq %r14, %rdi
callq 0x2180
movq %rax, %r12
testq %rax, %rax
jne 0x5b6a
leaq 0x1402d(%rip), %rdi     # 0x19b90
xorl %eax, %eax
callq 0x87c8
movq (%rbp,%r15,8), %rax
movq %r12, (%rax,%rbx,8)
incq %rbx
cmpq %rbx, %r13
jne 0x5b4c
incq %r15
cmpq 0x28(%rsp), %r15
jne 0x5b1e
movq 0x38(%rsp), %rbx
incq %rbx
cmpq 0x20(%rsp), %rbx
jne 0x5ae6
cmpl $0x0, 0x18(%rsp)
movl 0x1c(%rsp), %ebp
jle 0x5bfb
movl %ebp, %r14d
shlq $0x2, %r14
xorl %r15d, %r15d
cmpl $0x0, 0x8(%rsp)
jle 0x5bf1
xorl %r12d, %r12d
cmpl $0x0, 0xc(%rsp)
jle 0x5be7
xorl %ebx, %ebx
testl %ebp, %ebp
jle 0x5bdf
movq 0x10(%rsp), %rax
movq (%rax,%r15,8), %rax
movq (%rax,%r12,8), %rax
movq (%rax,%rbx,8), %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x20f0
incq %rbx
cmpq %rbx, %r13
jne 0x5bc0
incq %r12
cmpq 0x28(%rsp), %r12
jne 0x5bb7
incq %r15
cmpq 0x20(%rsp), %r15
jne 0x5bad
movq 0x10(%rsp), %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/josch[P]stride/memory.c
// Function: IntCube
int ***IntCube(int M, int N, int K)
{
  int m, n, k;
  int ***Cube;

  Cube = (int ***)ckalloc(M*sizeof(int **));

  for( m=0; m<M; m++ ) {
    Cube[m] = (int **)ckalloc(N*sizeof(int *));
    for( n=0; n<N; n++ ) Cube[m][n] = (int *)ckalloc(K*sizeof(int));
  }
  
  for( m=0; m<M; m++ )
    for( n=0; n<N; n++ )
      for( k=0; k<K; k++ )
	Cube[m][n][k] = 0;

  return(Cube);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebx
movl %esi, 0x4(%rsp)
movl %edi, %ebp
movslq %edi, %rdi
shlq $0x3, %rdi
callq 0x2180
movq %rax, %r13
testq %rax, %rax
jne 0x5c77
leaq 0x13f20(%rip), %rdi     # 0x19b90
xorl %eax, %eax
callq 0x87c8
testl %ebp, %ebp
jle 0x5d65
movq %r13, 0x10(%rsp)
movslq 0x4(%rsp), %rax
leaq (,%rax,8), %rcx
movq %rcx, 0x20(%rsp)
movl %ebx, 0xc(%rsp)
movslq %ebx, %r13
shlq $0x2, %r13
movl %ebp, 0x8(%rsp)
movl %ebp, %ecx
movq %rcx, 0x18(%rsp)
movl %eax, %r14d
xorl %r15d, %r15d
movq 0x20(%rsp), %rdi
callq 0x2180
movq %rax, %rbp
testq %rax, %rax
jne 0x5cd2
leaq 0x13ec5(%rip), %rdi     # 0x19b90
xorl %eax, %eax
callq 0x87c8
movq 0x10(%rsp), %rax
movq %rbp, (%rax,%r15,8)
cmpl $0x0, 0x4(%rsp)
jle 0x5d0f
xorl %ebx, %ebx
movq %r13, %rdi
callq 0x2180
movq %rax, %r12
testq %rax, %rax
jne 0x5d02
leaq 0x13e95(%rip), %rdi     # 0x19b90
xorl %eax, %eax
callq 0x87c8
movq %r12, (%rbp,%rbx,8)
incq %rbx
cmpq %rbx, %r14
jne 0x5ce4
incq %r15
cmpq 0x18(%rsp), %r15
jne 0x5cb2
cmpl $0x0, 0x8(%rsp)
movl 0xc(%rsp), %ebp
movq 0x10(%rsp), %r13
jle 0x5d65
movl %ebp, %r15d
shlq $0x2, %r15
xorl %r12d, %r12d
cmpl $0x0, 0x4(%rsp)
jle 0x5d5b
xorl %ebx, %ebx
testl %ebp, %ebp
jle 0x5d53
movq (%r13,%r12,8), %rax
movq (%rax,%rbx,8), %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x20f0
incq %rbx
cmpq %rbx, %r14
jne 0x5d3c
incq %r12
cmpq 0x18(%rsp), %r12
jne 0x5d33
movq %r13, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/josch[P]stride/memory.c
// Function: IntMatrix
int **IntMatrix(int M, int N)
{
  int m;
  int **Matrix;

  Matrix = (int **)ckalloc(M*sizeof(int *));

  for( m=0; m<M; m++ ) Matrix[m] = (int *)ckalloc(N*sizeof(int));

  return(Matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r14d
movl %edi, %ebp
movslq %edi, %rdi
shlq $0x3, %rdi
callq 0x2180
movq %rax, %rbx
testq %rax, %rax
jne 0x5da9
leaq 0x13dee(%rip), %rdi     # 0x19b90
xorl %eax, %eax
callq 0x87c8
testl %ebp, %ebp
jle 0x5de6
movslq %r14d, %r14
shlq $0x2, %r14
movl %ebp, %r13d
leaq 0x13dd2(%rip), %r15     # 0x19b90
xorl %ebp, %ebp
movq %r14, %rdi
callq 0x2180
movq %rax, %r12
testq %rax, %rax
jne 0x5dda
movq %r15, %rdi
xorl %eax, %eax
callq 0x87c8
movq %r12, (%rbx,%rbp,8)
incq %rbp
cmpq %rbp, %r13
jne 0x5dc0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq