LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movb $0x0, -0x1d(%rbp)
callq 0x5550
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5600
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jae 0x2d092
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x2d0f0
movl (%rax), %eax
cmpl -0x1c(%rbp), %eax
jne 0x2d082
movq -0x50(%rbp), %rdi
movl -0x28(%rbp), %eax
movl %eax, -0x2c(%rbp)
leaq -0x2c(%rbp), %rsi
callq 0x5830
jmp 0x2d069
jmp 0x2d082
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x9550
jmp 0x2d0af
jmp 0x2d084
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x2d023
movb $0x1, -0x1d(%rbp)
testb $0x1, -0x1d(%rbp)
jne 0x2d0a5
movq -0x50(%rbp), %rdi
callq 0x9550
movq -0x48(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x46d0
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x28(%rbp)
addq $0x30, %rsi
leaq -0x20(%rbp), %rdi
callq 0x4650
movq -0x28(%rbp), %rax
testb $0x1, 0x38(%rax)
je 0x2d23b
movq 0x1fe0a(%rip), %rdi     # 0x4cfc8
leaq 0x984b(%rip), %rsi      # 0x36a10
callq 0x4360
movq -0x30(%rbp), %rsi
movq %rax, %rdi
callq 0x4300
movq %rax, %rdi
leaq 0x917d(%rip), %rsi      # 0x3635d
callq 0x4360
movq -0x28(%rbp), %rcx
movq %rax, %rdi
movq -0x20(%rbp), %rax
subq 0x10(%rcx), %rax
cvtsi2sd %rax, %xmm1
movq -0x18(%rbp), %rax
subq 0x18(%rcx), %rax
cvtsi2sd %rax, %xmm0
movsd 0x97f2(%rip), %xmm2     # 0x36a00
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
callq 0x4770
movq %rax, %rdi
leaq 0x9800(%rip), %rsi      # 0x36a25
callq 0x4360
movq %rax, %rdi
movq 0x1fd84(%rip), %rsi     # 0x4cfb8
callq 0x43b0
jmp 0x2d268
movq 0x1fdae(%rip), %rdi     # 0x4cff0
leaq 0x97e5(%rip), %rsi      # 0x36a2e
callq 0x4360
movq %rax, %rdi
movq 0x1fd60(%rip), %rsi     # 0x4cfb8
callq 0x43b0
movq -0x28(%rbp), %rdi
callq 0x2d140
jmp 0x2d27c
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x18(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x28(%rbp)
addq $0x30, %rsi
leaq -0x20(%rbp), %rdi
callq 0x4650
movq -0x28(%rbp), %rax
testb $0x1, 0x38(%rax)
je 0x2d35b
movq -0x30(%rbp), %rdi
callq 0x4690
testb $0x1, %al
jne 0x2d35b
movq 0x1fce9(%rip), %rdi     # 0x4cfc8
leaq 0x972a(%rip), %rsi      # 0x36a10
callq 0x4360
movq -0x30(%rbp), %rsi
movq %rax, %rdi
callq 0x4300
movq %rax, %rdi
leaq 0x905c(%rip), %rsi      # 0x3635d
callq 0x4360
movq -0x28(%rbp), %rcx
movq %rax, %rdi
movq -0x20(%rbp), %rax
subq (%rcx), %rax
cvtsi2sd %rax, %xmm1
movq -0x18(%rbp), %rax
subq 0x8(%rcx), %rax
cvtsi2sd %rax, %xmm0
movsd 0x96d2(%rip), %xmm2     # 0x36a00
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
callq 0x4770
movq %rax, %rdi
leaq 0x96e0(%rip), %rsi      # 0x36a25
callq 0x4360
movq %rax, %rdi
movq 0x1fc64(%rip), %rsi     # 0x4cfb8
callq 0x43b0
jmp 0x2d394
movq -0x28(%rbp), %rax
testb $0x1, 0x38(%rax)
jne 0x2d392
movq 0x1fc84(%rip), %rdi     # 0x4cff0
leaq 0x96bb(%rip), %rsi      # 0x36a2e
callq 0x4360
movq %rax, %rdi
movq 0x1fc36(%rip), %rsi     # 0x4cfb8
callq 0x43b0
movq -0x28(%rbp), %rdi
callq 0x2d140
jmp 0x2d3b8
jmp 0x2d394
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x28(%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movl -0xc(%rbp), %esi
callq 0x2d600
testb $0x1, %al
jne 0x2d555
jmp 0x2d557
jmp 0x2d576
leaq 0x950c(%rip), %rdi      # 0x36a6a
leaq 0x9510(%rip), %rsi      # 0x36a75
movl $0x3f, %edx
leaq 0x950b(%rip), %rcx      # 0x36a7c
callq 0x4210
jmp 0x2d578
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
addq $0x20, %rdi
movslq -0xc(%rbp), %rsi
callq 0x5620
movq %rax, %rcx
movl -0x1c(%rbp), %eax
cmpl (%rcx), %eax
je 0x2d5f4
movq -0x18(%rbp), %rdi
movq %rdi, %rax
addq $0x20, %rax
movq %rax, -0x28(%rbp)
addq $0x20, %rdi
movslq -0xc(%rbp), %rsi
callq 0x5620
movq -0x28(%rbp), %rdi
movslq (%rax), %rsi
callq 0x5620
movq -0x18(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x20(%rbp)
addq $0x20, %rdi
movslq -0xc(%rbp), %rsi
callq 0x5620
movl -0x20(%rbp), %ecx
movq -0x18(%rbp), %rdi
movl %ecx, (%rax)
addq $0x20, %rdi
movslq -0xc(%rbp), %rsi
callq 0x5620
movl (%rax), %eax
movl %eax, -0xc(%rbp)
jmp 0x2d578
movl -0xc(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movl -0x14(%rbp), %eax
cmpl (%rcx), %eax
jl 0x2d66e
movq 0x1f9a3(%rip), %rdi     # 0x4cfc8
leaq 0x9494(%rip), %rsi      # 0x36ac0
callq 0x4360
movq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0x46c0
movq %rax, %rdi
leaq 0x946b(%rip), %rsi      # 0x36ab1
callq 0x4360
movq %rax, %rdi
movq -0x20(%rbp), %rax
movl (%rax), %esi
callq 0x46c0
movq %rax, %rdi
movq 0x1f955(%rip), %rsi     # 0x4cfb8
callq 0x43b0
movb $0x1, -0x1(%rbp)
jmp 0x2d68a
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movslq -0x14(%rbp), %rsi
callq 0x5620
cmpl $-0x1, (%rax)
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movl -0x14(%rbp), %eax
cmpl (%rcx), %eax
jl 0x2d70e
movq 0x1f903(%rip), %rdi     # 0x4cfc8
leaq 0x93c9(%rip), %rsi      # 0x36a95
callq 0x4360
movq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0x46c0
movq %rax, %rdi
leaq 0x93cb(%rip), %rsi      # 0x36ab1
callq 0x4360
movq %rax, %rdi
movq -0x20(%rbp), %rax
movl (%rax), %esi
callq 0x46c0
movq %rax, %rdi
movq 0x1f8b5(%rip), %rsi     # 0x4cfb8
callq 0x43b0
movb $0x0, -0x1(%rbp)
jmp 0x2d72a
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movslq -0x14(%rbp), %rsi
callq 0x5620
cmpl $0x1, (%rax)
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movl -0xc(%rbp), %eax
cmpl (%rcx), %eax
jl 0x2d7aa
movq 0x1f863(%rip), %rdi     # 0x4cfc8
leaq 0x9377(%rip), %rsi      # 0x36ae3
callq 0x4360
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x46c0
movq %rax, %rdi
leaq 0x932b(%rip), %rsi      # 0x36ab1
callq 0x4360
movq %rax, %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
callq 0x46c0
movq %rax, %rdi
movq 0x1f815(%rip), %rsi     # 0x4cfb8
callq 0x43b0
jmp 0x2d801
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x2d600
testb $0x1, %al
jne 0x2d7bc
jmp 0x2d7be
jmp 0x2d801
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
addq $0x20, %rdi
movslq -0xc(%rbp), %rsi
callq 0x5620
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rdi
movl %ecx, (%rax)
addq $0x8, %rdi
movslq -0xc(%rbp), %rsi
callq 0x5620
movq %rax, %rcx
movq -0x18(%rbp), %rax
movl $0x1, (%rcx)
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movl -0xc(%rbp), %esi
callq 0x2d530
movq -0x28(%rbp), %rdi
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %esi
callq 0x2d530
movq -0x28(%rbp), %rdi
movl %eax, -0x18(%rbp)
addq $0x8, %rdi
movslq -0x14(%rbp), %rsi
callq 0x5620
movq -0x28(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
addq $0x8, %rdi
movslq -0x18(%rbp), %rsi
callq 0x5620
movq %rax, %rcx
movl -0x1c(%rbp), %eax
cmpl (%rcx), %eax
jl 0x2d911
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
movslq -0x18(%rbp), %rsi
callq 0x5620
movq -0x28(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x30(%rbp)
addq $0x8, %rdi
movslq -0x14(%rbp), %rsi
callq 0x5620
movl -0x30(%rbp), %ecx
movq -0x28(%rbp), %rdi
addl (%rax), %ecx
movl %ecx, (%rax)
movl -0x14(%rbp), %eax
movl %eax, -0x2c(%rbp)
addq $0x20, %rdi
movslq -0x18(%rbp), %rsi
callq 0x5620
movl -0x2c(%rbp), %ecx
movl %ecx, (%rax)
jmp 0x2d95b
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
movslq -0x14(%rbp), %rsi
callq 0x5620
movq -0x28(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x38(%rbp)
addq $0x8, %rdi
movslq -0x18(%rbp), %rsi
callq 0x5620
movl -0x38(%rbp), %ecx
movq -0x28(%rbp), %rdi
addl (%rax), %ecx
movl %ecx, (%rax)
movl -0x18(%rbp), %eax
movl %eax, -0x34(%rbp)
addq $0x20, %rdi
movslq -0x14(%rbp), %rsi
callq 0x5620
movl -0x34(%rbp), %ecx
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
movl 0x4(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x4(%rax)
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stonezwr[P]SpiKL-IP/util.C
// Function: GetSpeechIndexClass(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int&, int&)
void GetSpeechIndexClass(std::string filename, int& cls, int& index){
    size_t pos = filename.find_last_of("_");
    if(pos == std::string::npos){
        std::cout<<"Invalid spike response filename: "<<filename<<std::endl;
        exit(EXIT_FAILURE);
    }
    cls = std::stoi(filename.substr(pos + 1));
    
    filename = filename.substr(0, pos);
    pos = filename.find_last_of("_");
    if(pos == std::string::npos){
        std::cout<<"Invalid spike response filename: "<<filename<<std::endl;
        std::cout<<"Cannot find the index before the class id!"<<std::endl;
        exit(EXIT_FAILURE);
    }
    index = std::stoi(filename.substr(pos + 1));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x5cd8(%rip), %rsi      # 0x3432d
movq $-0x1, %rdx
callq 0x4340
movq %rax, -0x20(%rbp)
cmpq $-0x1, -0x20(%rbp)
jne 0x2e6a7
movq 0x1e955(%rip), %rdi     # 0x4cfc8
leaq 0x84c3(%rip), %rsi      # 0x36b3d
callq 0x4360
movq -0x98(%rbp), %rsi
movq %rax, %rdi
callq 0x4300
movq %rax, %rdi
movq 0x1e920(%rip), %rsi     # 0x4cfb8
callq 0x43b0
movl $0x1, %edi
callq 0x4440
movq -0x98(%rbp), %rsi
movq -0x20(%rbp), %rdx
incq %rdx
leaq -0x40(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
movq $-0x1, %rcx
callq 0x43a0
movq -0xa8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x2f2e0
movl %eax, -0x9c(%rbp)
jmp 0x2e6e9
movl -0x9c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
leaq -0x40(%rbp), %rdi
callq 0x4200
movq -0x98(%rbp), %rsi
movq -0x20(%rbp), %rcx
leaq -0x70(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
callq 0x43a0
movq -0x98(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x4470
leaq -0x70(%rbp), %rdi
callq 0x4200
movq -0x98(%rbp), %rdi
leaq 0x5bf0(%rip), %rsi      # 0x3432d
movq $-0x1, %rdx
callq 0x4340
movq %rax, -0x20(%rbp)
cmpq $-0x1, -0x20(%rbp)
jne 0x2e7c8
movq 0x1e86d(%rip), %rdi     # 0x4cfc8
leaq 0x83db(%rip), %rsi      # 0x36b3d
callq 0x4360
movq -0x98(%rbp), %rsi
movq %rax, %rdi
callq 0x4300
movq %rax, %rdi
movq 0x1e838(%rip), %rsi     # 0x4cfb8
callq 0x43b0
movq 0x1e83c(%rip), %rdi     # 0x4cfc8
leaq 0x83cc(%rip), %rsi      # 0x36b5f
callq 0x4360
movq %rax, %rdi
movq 0x1e816(%rip), %rsi     # 0x4cfb8
callq 0x43b0
movl $0x1, %edi
callq 0x4440
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x4200
jmp 0x2e846
movq -0x98(%rbp), %rsi
movq -0x20(%rbp), %rdx
incq %rdx
leaq -0x90(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
movq $-0x1, %rcx
callq 0x43a0
movq -0xb8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x2f2e0
movl %eax, -0xac(%rbp)
jmp 0x2e80d
movl -0xac(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
leaq -0x90(%rbp), %rdi
callq 0x4200
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x4200
movq -0x48(%rbp), %rdi
callq 0x46d0
nop
// File: /workspace/github_c_makefile_star2_O0/stonezwr[P]SpiKL-IP/util.C
// Function: ReverseInt(int)
int ReverseInt (int i){
	unsigned char ch1, ch2, ch3, ch4;
	ch1 = i & 255;
	ch2 = (i >> 8) & 255;
	ch3 = (i >> 16) & 255;
	ch4 = (i >> 24) & 255;
	return((int) ch1 << 24) | ((int)ch2 << 16) | ((int)ch3 << 8) | ch4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
andl $0xff, %eax
movb %al, -0x5(%rbp)
movl -0x4(%rbp), %eax
sarl $0x8, %eax
andl $0xff, %eax
movb %al, -0x6(%rbp)
movl -0x4(%rbp), %eax
sarl $0x10, %eax
andl $0xff, %eax
movb %al, -0x7(%rbp)
movl -0x4(%rbp), %eax
sarl $0x18, %eax
andl $0xff, %eax
movb %al, -0x8(%rbp)
movzbl -0x5(%rbp), %eax
shll $0x18, %eax
movzbl -0x6(%rbp), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movzbl -0x7(%rbp), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movzbl -0x8(%rbp), %ecx
orl %ecx, %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x270, %rsp            # imm = 0x270
movq %rdi, -0x250(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x4160
movq %rax, %rsi
leaq -0x218(%rbp), %rdi
movq %rdi, -0x248(%rbp)
movl $0x4, %edx
callq 0x4750
movq -0x248(%rbp), %rdi
callq 0x4620
movb %al, -0x239(%rbp)
jmp 0x2edbe
movb -0x239(%rbp), %al
testb $0x1, %al
jne 0x2ee44
jmp 0x2edca
movq 0x1e1f7(%rip), %rdi     # 0x4cfc8
leaq 0x7db2(%rip), %rsi      # 0x36b8a
callq 0x4360
movq %rax, -0x258(%rbp)
jmp 0x2ede6
movq -0x250(%rbp), %rsi
movq -0x258(%rbp), %rdi
callq 0x4300
movq %rax, -0x260(%rbp)
jmp 0x2ee02
movq -0x260(%rbp), %rdi
movq 0x1e1a8(%rip), %rsi     # 0x4cfb8
callq 0x43b0
jmp 0x2ee17
movl $0x1, %edi
callq 0x4440
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x40f0
jmp 0x2ef43
movl $0x0, -0x228(%rbp)
movl $0x0, -0x22c(%rbp)
leaq -0x218(%rbp), %rdi
leaq -0x228(%rbp), %rsi
movl $0x4, %edx
callq 0x44b0
jmp 0x2ee72
movl -0x228(%rbp), %edi
callq 0x2e850
movl %eax, -0x228(%rbp)
leaq -0x218(%rbp), %rdi
leaq -0x22c(%rbp), %rsi
movl $0x4, %edx
callq 0x44b0
jmp 0x2ee9d
movl -0x22c(%rbp), %edi
callq 0x2e850
movl %eax, -0x22c(%rbp)
movl $0x0, -0x230(%rbp)
movl -0x230(%rbp), %eax
cmpl -0x22c(%rbp), %eax
jge 0x2ef19
movb $0x0, -0x231(%rbp)
leaq -0x218(%rbp), %rdi
leaq -0x231(%rbp), %rsi
movl $0x1, %edx
callq 0x44b0
jmp 0x2eee7
movq -0x10(%rbp), %rdi
movzbl -0x231(%rbp), %eax
movl %eax, -0x238(%rbp)
leaq -0x238(%rbp), %rsi
callq 0x5830
jmp 0x2ef06
jmp 0x2ef08
movl -0x230(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x230(%rbp)
jmp 0x2eeb8
movq -0x10(%rbp), %rdi
callq 0x5600
movl %eax, -0x264(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x40f0
movl -0x264(%rbp), %eax
addq $0x270, %rsp            # imm = 0x270
popq %rbp
retq
movq -0x220(%rbp), %rdi
callq 0x46d0
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdx, -0x98(%rbp)
movq %rsi, %rax
movq -0x98(%rbp), %rsi
movq %rcx, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x4170
movq -0x88(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0x2e8b0
movl %eax, -0x7c(%rbp)
jmp 0x2efaf
leaq -0x48(%rbp), %rdi
callq 0x4200
movl -0x7c(%rbp), %eax
movq -0x90(%rbp), %rsi
movl %eax, -0x28(%rbp)
leaq -0x78(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x4170
movq -0xa8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2ed70
movl %eax, -0x9c(%rbp)
jmp 0x2efed
leaq -0x78(%rbp), %rdi
callq 0x4200
movl -0x9c(%rbp), %eax
movl %eax, -0x58(%rbp)
movl -0x58(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x4200
jmp 0x2f037
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x4200
movq -0x50(%rbp), %rdi
callq 0x46d0
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x31d97
movq -0x48(%rbp), %rdi
movl $0x10, %esi
callq 0x4390
movq -0x18(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x2bef0
movq -0x18(%rbp), %rdi
callq 0x21490
movq -0x20(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x2bfe0
movq 0x1b207(%rip), %rdi     # 0x4cfc8
leaq 0x4e0f(%rip), %rsi      # 0x36bd7
callq 0x4360
movq %rax, %rdi
movq -0x20(%rbp), %rsi
callq 0x4740
movq %rax, %rdi
leaq 0x4dfc(%rip), %rsi      # 0x36bdf
callq 0x4360
movq %rax, %rdi
movq 0x1b1c6(%rip), %rsi     # 0x4cfb8
callq 0x43b0
xorl %eax, %eax
movl %eax, %edi
callq 0x46e0
// File: /workspace/github_c_makefile_star2_O0/stonezwr[P]SpiKL-IP/main.C
// Function: PrintTestErrorToFile(std::vector<double, std::allocator<double>> const&, int)
void PrintTestErrorToFile(const vector<double>& test_errors, int num_speeches){
    assert(!test_errors.empty());
    ofstream f_out("outputs/test_errors.txt");
    for(double e : test_errors) f_out<<e/num_speeches<<endl;
    f_out.close();
}


void CollectTestErrorFromNetwork(Network array_network[]){
    int num_speeches = array_network[0].NumSpeech();
    int num_iters = array_network[0].NumIteration();
    vector<double> test_errors(num_iters, 0);
    for(int i = 0; i < NUM_THREADS; ++i)
        array_network[i].MergeTestErrors(test_errors);
    PrintTestErrorToFile(test_errors, num_speeches);        
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x250, %rsp            # imm = 0x250
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x24990
xorb $-0x1, %al
testb $0x1, %al
jne 0x32b33
jmp 0x32b35
jmp 0x32b54
leaq 0x42e0(%rip), %rdi      # 0x36e1c
leaq 0x40dd(%rip), %rsi      # 0x36c20
movl $0x62, %edx
leaq 0x42e2(%rip), %rcx      # 0x36e31
callq 0x4210
leaq -0x210(%rbp), %rdi
leaq 0x4306(%rip), %rsi      # 0x36e68
movl $0x10, %edx
callq 0x43e0
movq -0x8(%rbp), %rax
movq %rax, -0x218(%rbp)
movq -0x218(%rbp), %rdi
callq 0x1b3e0
movq %rax, -0x220(%rbp)
movq -0x218(%rbp), %rdi
callq 0x1b410
movq %rax, -0x228(%rbp)
leaq -0x220(%rbp), %rdi
leaq -0x228(%rbp), %rsi
callq 0x24760
testb $0x1, %al
jne 0x32bb9
jmp 0x32c3c
leaq -0x220(%rbp), %rdi
callq 0x247a0
movsd (%rax), %xmm0
movsd %xmm0, -0x230(%rbp)
movsd -0x230(%rbp), %xmm0
cvtsi2sdl -0xc(%rbp), %xmm1
divsd %xmm1, %xmm0
leaq -0x210(%rbp), %rdi
callq 0x4770
movq %rax, -0x248(%rbp)
jmp 0x32bf7
movq -0x248(%rbp), %rdi
movq 0x1a3b3(%rip), %rsi     # 0x4cfb8
callq 0x43b0
jmp 0x32c0c
jmp 0x32c0e
leaq -0x220(%rbp), %rdi
callq 0x247c0
jmp 0x32b9d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x238(%rbp)
movl %eax, -0x23c(%rbp)
leaq -0x210(%rbp), %rdi
callq 0x4570
jmp 0x32c5f
leaq -0x210(%rbp), %rdi
callq 0x4530
jmp 0x32c4a
leaq -0x210(%rbp), %rdi
callq 0x4570
addq $0x250, %rsp            # imm = 0x250
popq %rbp
retq
movq -0x238(%rbp), %rdi
callq 0x46d0
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/josch[P]stride/geometry.c
// Function: Dist
float Dist(float *Coord1, float *Coord2)
{
  register int i;
  float Dist=0;

  for( i=0; i<3; i++ ) 
    Dist += (Coord1[i]-Coord2[i])*(Coord1[i]-Coord2[i]);

  return( sqrt(Dist) );
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, (%rsp)
movl $0x0, 0x4(%rsp)
cmpl $0x3, 0x4(%rsp)
jge 0x4ab0
movq 0x10(%rsp), %rax
movslq 0x4(%rsp), %rcx
movss (%rax,%rcx,4), %xmm0
movq 0x8(%rsp), %rax
movslq 0x4(%rsp), %rcx
subss (%rax,%rcx,4), %xmm0
movq 0x10(%rsp), %rax
movslq 0x4(%rsp), %rcx
movss (%rax,%rcx,4), %xmm2
movq 0x8(%rsp), %rax
movslq 0x4(%rsp), %rcx
subss (%rax,%rcx,4), %xmm2
movss (%rsp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, (%rsp)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x4a4e
movss (%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x2220
cvtsd2ss %xmm0, %xmm0
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq 0x30(%rsp), %rax
movq 0x68(%rax), %rax
movslq 0x2c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x768(%rax), %rax
movss 0x26a1c(%rip), %xmm0    # 0x2b774
movss %xmm0, (%rax)
cmpl $0x0, 0x2c(%rsp)
jne 0x4d68
jmp 0x4ecf
movq 0x30(%rsp), %rax
movq 0x68(%rax), %rax
movl 0x2c(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
subl $0x1, %esi
leaq 0x276f7(%rip), %rdx     # 0x2c48e
leaq 0x28(%rsp), %rcx
callq 0x6140
cmpl $0x0, %eax
je 0x4ecf
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
leaq 0x26ac0(%rip), %rdx     # 0x2b87a
leaq 0x24(%rsp), %rcx
callq 0x6140
cmpl $0x0, %eax
je 0x4ecf
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
leaq 0x27e63(%rip), %rdx     # 0x2cc40
leaq 0x20(%rsp), %rcx
callq 0x6140
cmpl $0x0, %eax
je 0x4ecf
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
leaq 0x2768e(%rip), %rdx     # 0x2c48e
leaq 0x1c(%rsp), %rcx
callq 0x6140
cmpl $0x0, %eax
je 0x4ecf
movq 0x8(%rsp), %rdi
addq $0x188, %rdi            # imm = 0x188
movslq 0x28(%rsp), %rax
imulq $0xc, %rax, %rax
addq %rax, %rdi
movq 0x10(%rsp), %rsi
addq $0x188, %rsi            # imm = 0x188
movslq 0x24(%rsp), %rax
imulq $0xc, %rax, %rax
addq %rax, %rsi
callq 0x4a30
cvtss2sd %xmm0, %xmm1
movsd 0x269b4(%rip), %xmm0    # 0x2b808
ucomisd %xmm1, %xmm0
jbe 0x4ecf
movq 0x8(%rsp), %rdi
addq $0x188, %rdi            # imm = 0x188
movslq 0x28(%rsp), %rax
imulq $0xc, %rax, %rax
addq %rax, %rdi
movq 0x10(%rsp), %rsi
addq $0x188, %rsi            # imm = 0x188
movslq 0x24(%rsp), %rax
imulq $0xc, %rax, %rax
addq %rax, %rsi
movq 0x10(%rsp), %rdx
addq $0x188, %rdx            # imm = 0x188
movslq 0x20(%rsp), %rax
imulq $0xc, %rax, %rax
addq %rax, %rdx
movq 0x10(%rsp), %rcx
addq $0x188, %rcx            # imm = 0x188
movslq 0x1c(%rsp), %rax
imulq $0xc, %rax, %rax
addq %rax, %rcx
callq 0x45b0
movq 0x10(%rsp), %rax
movq 0x768(%rax), %rax
movss %xmm0, (%rax)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq 0x30(%rsp), %rax
movq 0x68(%rax), %rax
movslq 0x2c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x768(%rax), %rax
movss 0x2685c(%rip), %xmm0    # 0x2b774
movss %xmm0, 0x4(%rax)
movl 0x2c(%rsp), %eax
movq 0x30(%rsp), %rcx
movl (%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0x4f34
jmp 0x509c
movq 0x30(%rsp), %rax
movq 0x68(%rax), %rax
movl 0x2c(%rsp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
leaq 0x2691a(%rip), %rdx     # 0x2b87a
leaq 0x28(%rsp), %rcx
callq 0x6140
cmpl $0x0, %eax
je 0x509c
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
leaq 0x27cbd(%rip), %rdx     # 0x2cc40
leaq 0x24(%rsp), %rcx
callq 0x6140
cmpl $0x0, %eax
je 0x509c
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
leaq 0x274e8(%rip), %rdx     # 0x2c48e
leaq 0x20(%rsp), %rcx
callq 0x6140
cmpl $0x0, %eax
je 0x509c
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
addl $0x1, %esi
leaq 0x268ae(%rip), %rdx     # 0x2b87a
leaq 0x1c(%rsp), %rcx
callq 0x6140
cmpl $0x0, %eax
je 0x509c
movq 0x10(%rsp), %rdi
addq $0x188, %rdi            # imm = 0x188
movslq 0x20(%rsp), %rax
imulq $0xc, %rax, %rax
addq %rax, %rdi
movq 0x8(%rsp), %rsi
addq $0x188, %rsi            # imm = 0x188
movslq 0x1c(%rsp), %rax
imulq $0xc, %rax, %rax
addq %rax, %rsi
callq 0x4a30
cvtss2sd %xmm0, %xmm1
movsd 0x267e8(%rip), %xmm0    # 0x2b808
ucomisd %xmm1, %xmm0
jbe 0x509c
movq 0x10(%rsp), %rdi
addq $0x188, %rdi            # imm = 0x188
movslq 0x28(%rsp), %rax
imulq $0xc, %rax, %rax
addq %rax, %rdi
movq 0x10(%rsp), %rsi
addq $0x188, %rsi            # imm = 0x188
movslq 0x24(%rsp), %rax
imulq $0xc, %rax, %rax
addq %rax, %rsi
movq 0x10(%rsp), %rdx
addq $0x188, %rdx            # imm = 0x188
movslq 0x20(%rsp), %rax
imulq $0xc, %rax, %rax
addq %rax, %rdx
movq 0x8(%rsp), %rcx
addq $0x188, %rcx            # imm = 0x188
movslq 0x1c(%rsp), %rax
imulq $0xc, %rax, %rax
addq %rax, %rcx
callq 0x45b0
movq 0x10(%rsp), %rax
movq 0x768(%rax), %rax
movss %xmm0, 0x4(%rax)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq 0x30(%rsp), %rax
movq 0x68(%rax), %rax
movslq 0x2c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x768(%rax), %rax
movss 0x2668c(%rip), %xmm0    # 0x2b774
movss %xmm0, 0x8(%rax)
cmpl $0x0, 0x2c(%rsp)
jne 0x50f9
jmp 0x5219
movq 0x30(%rsp), %rax
movq 0x68(%rax), %rax
movl 0x2c(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
subl $0x1, %esi
leaq 0x27b18(%rip), %rdx     # 0x2cc40
leaq 0x28(%rsp), %rcx
callq 0x6140
cmpl $0x0, %eax
je 0x5219
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
subl $0x1, %esi
leaq 0x27340(%rip), %rdx     # 0x2c48e
leaq 0x24(%rsp), %rcx
callq 0x6140
cmpl $0x0, %eax
je 0x5219
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
leaq 0x26709(%rip), %rdx     # 0x2b87a
leaq 0x20(%rsp), %rcx
callq 0x6140
cmpl $0x0, %eax
je 0x5219
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
leaq 0x27aac(%rip), %rdx     # 0x2cc40
leaq 0x1c(%rsp), %rcx
callq 0x6140
cmpl $0x0, %eax
je 0x5219
movq 0x8(%rsp), %rdi
addq $0x188, %rdi            # imm = 0x188
movslq 0x28(%rsp), %rax
imulq $0xc, %rax, %rax
addq %rax, %rdi
movq 0x8(%rsp), %rsi
addq $0x188, %rsi            # imm = 0x188
movslq 0x24(%rsp), %rax
imulq $0xc, %rax, %rax
addq %rax, %rsi
movq 0x10(%rsp), %rdx
addq $0x188, %rdx            # imm = 0x188
movslq 0x20(%rsp), %rax
imulq $0xc, %rax, %rax
addq %rax, %rdx
movq 0x10(%rsp), %rcx
addq $0x188, %rcx            # imm = 0x188
movslq 0x1c(%rsp), %rax
imulq $0xc, %rax, %rax
addq %rax, %rcx
callq 0x45b0
movq 0x10(%rsp), %rax
movq 0x768(%rax), %rax
movss %xmm0, 0x8(%rax)
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, (%rsp)
movl $0x0, 0xc(%rsp)
cmpl $0x3, 0xc(%rsp)
jge 0x55c4
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl $0x3, %ecx
cltd
idivl %ecx
movl %edx, 0x8(%rsp)
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl $0x3, %ecx
cltd
idivl %ecx
movl %edx, 0x4(%rsp)
movq 0x20(%rsp), %rax
movslq 0x8(%rsp), %rcx
movss (%rax,%rcx,4), %xmm0
movq 0x18(%rsp), %rax
movslq 0x4(%rsp), %rcx
movss (%rax,%rcx,4), %xmm2
movq 0x20(%rsp), %rax
movslq 0x4(%rsp), %rcx
movss (%rax,%rcx,4), %xmm1
movq 0x18(%rsp), %rax
movslq 0x8(%rsp), %rcx
mulss (%rax,%rcx,4), %xmm1
movd %xmm1, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
movss %xmm0, (%rax,%rcx,4)
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
movss (%rax,%rcx,4), %xmm0
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
movss (%rax,%rcx,4), %xmm2
movss (%rsp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, (%rsp)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x54f3
movss (%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x2220
cvtsd2ss %xmm0, %xmm0
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
leaq 0x25f59(%rip), %rsi     # 0x2b89e
callq 0x2130
cmpl $0x0, %eax
jne 0x5962
movsd 0x25ed1(%rip), %xmm0    # 0x2b828
movsd %xmm0, 0x10(%rsp)
jmp 0x59e2
movq 0x8(%rsp), %rdi
leaq 0x25f0c(%rip), %rsi     # 0x2b87a
callq 0x2130
cmpl $0x0, %eax
jne 0x5988
movsd 0x25eb0(%rip), %xmm0    # 0x2b830
movsd %xmm0, 0x10(%rsp)
jmp 0x59e2
movq 0x8(%rsp), %rdi
leaq 0x272ac(%rip), %rsi     # 0x2cc40
callq 0x2130
cmpl $0x0, %eax
jne 0x59ae
movsd 0x25e92(%rip), %xmm0    # 0x2b838
movsd %xmm0, 0x10(%rsp)
jmp 0x59e2
movq 0x8(%rsp), %rdi
leaq 0x26ad4(%rip), %rsi     # 0x2c48e
callq 0x2130
cmpl $0x0, %eax
jne 0x59d4
movsd 0x25e74(%rip), %xmm0    # 0x2b840
movsd %xmm0, 0x10(%rsp)
jmp 0x59e2
movsd 0x25e6c(%rip), %xmm0    # 0x2b848
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/josch[P]stride/filename.c
// Function: GetFileNameFromPath
void GetFileNameFromPath(char *Path, char *FileName)
{

  int i;
  static char DirDelim[5] = { ':','/','\\',']','\0'};

  for( i = (int)strlen(Path)-1; i>=0; i-- )
    if( strchr(DirDelim,Path[i]) ) break;

  strcpy(FileName,Path+i+1);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x20b0
subl $0x1, %eax
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jl 0x5f97
movq 0x10(%rsp), %rax
movslq 0x4(%rsp), %rcx
movsbl (%rax,%rcx), %esi
leaq 0x2a1c5(%rip), %rdi     # 0x30140
callq 0x20c0
cmpq $0x0, %rax
je 0x5f88
jmp 0x5f97
jmp 0x5f8a
movl 0x4(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x5f5f
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movslq 0x4(%rsp), %rax
addq %rax, %rsi
addq $0x1, %rsi
callq 0x2060
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x2060
movq 0x8(%rsp), %rdi
callq 0x20b0
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jl 0x6024
movq 0x8(%rsp), %rax
movslq 0x4(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2e, %eax
jne 0x6015
movq 0x8(%rsp), %rax
movslq 0x4(%rsp), %rcx
movb $0x0, (%rax,%rcx)
jmp 0x6024
jmp 0x6017
movl 0x4(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x5feb
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rsi
leaq 0x2b7bb(%rip), %rdi     # 0x31800
callq 0x2060
leaq 0x2b7af(%rip), %rdi     # 0x31800
callq 0x20b0
movl %eax, 0x8(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x8(%rsp), %eax
jge 0x609f
movslq 0xc(%rsp), %rcx
leaq 0x2b788(%rip), %rax     # 0x31800
movsbl (%rax,%rcx), %edi
callq 0x2150
movb %al, %dl
movslq 0xc(%rsp), %rcx
leaq 0x2b771(%rip), %rax     # 0x31800
movb %dl, (%rax,%rcx)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x6062
leaq 0x2b75a(%rip), %rax     # 0x31800
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl $0x0, (%rax)
movq 0x8(%rsp), %rax
movl (%rax), %eax
movq 0x18(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x6120
movq 0x18(%rsp), %rax
movq 0x68(%rax), %rax
movq 0x8(%rsp), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rdi
addq $0x4, %rdi
movq 0x10(%rsp), %rsi
callq 0x2130
cmpl $0x0, %eax
jne 0x6110
movl $0x1, 0x24(%rsp)
jmp 0x6128
jmp 0x6112
movq 0x8(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x60ce
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq %rdx, 0x8(%rsp)
movq %rcx, (%rsp)
movq (%rsp), %rax
movl $0x0, (%rax)
movq (%rsp), %rax
movl (%rax), %eax
movq 0x18(%rsp), %rcx
movq 0x68(%rcx), %rcx
movslq 0x14(%rsp), %rdx
movq (%rcx,%rdx,8), %rcx
cmpl (%rcx), %eax
jge 0x61c8
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x68(%rax), %rax
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
addq $0x10, %rsi
movq (%rsp), %rax
movslq (%rax), %rax
imulq $0x5, %rax, %rax
addq %rax, %rsi
callq 0x2130
cmpl $0x0, %eax
jne 0x61b9
movl $0x1, 0x24(%rsp)
jmp 0x61da
jmp 0x61bb
movq (%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x6160
movq (%rsp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
movb %dl, %al
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movb %al, -0xd(%rsp)
movq %rcx, -0x18(%rsp)
movl $0x0, -0x20(%rsp)
movl $0x0, -0x24(%rsp)
movl $0x0, -0x1c(%rsp)
movl -0x1c(%rsp), %eax
cmpl -0xc(%rsp), %eax
jge 0x62bd
movq -0x8(%rsp), %rax
movslq -0x1c(%rsp), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0xd(%rsp), %ecx
cmpl %ecx, %eax
jne 0x6263
cmpl $0x0, -0x24(%rsp)
jne 0x6263
movl $0x1, -0x24(%rsp)
movl -0x1c(%rsp), %edx
movq -0x18(%rsp), %rax
movslq -0x20(%rsp), %rcx
movl %edx, (%rax,%rcx,8)
jmp 0x62ab
movq -0x8(%rsp), %rax
movslq -0x1c(%rsp), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0xd(%rsp), %ecx
cmpl %ecx, %eax
je 0x62a9
cmpl $0x1, -0x24(%rsp)
jne 0x62a9
movl $0x0, -0x24(%rsp)
movl -0x1c(%rsp), %edx
subl $0x1, %edx
movq -0x18(%rsp), %rax
movl -0x20(%rsp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x20(%rsp)
movslq %ecx, %rcx
movl %edx, 0x4(%rax,%rcx,8)
jmp 0x62ab
jmp 0x62ad
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0x621c
movl -0x20(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/josch[P]stride/strutil.c
// Function: FindChain
int FindChain(CHAIN **Chain, int NChain, char ChainId)
{
  register int i;

  for( i=0; i<NChain; i++ )
    if( Chain[i]->Id == ChainId )
      return(i);

  return(ERR);
}

// Assembly:
movb %dl, %al
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
movb %al, -0x15(%rsp)
movl $0x0, -0x1c(%rsp)
movl -0x1c(%rsp), %eax
cmpl -0x14(%rsp), %eax
jge 0x6325
movq -0x10(%rsp), %rax
movslq -0x1c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movsbl 0x40(%rax), %eax
movsbl -0x15(%rsp), %ecx
cmpl %ecx, %eax
jne 0x6316
movl -0x1c(%rsp), %eax
movl %eax, -0x4(%rsp)
jmp 0x632d
jmp 0x6318
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0x62e7
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/josch[P]stride/strutil.c
// Function: IsHydrogen
BOOLEAN IsHydrogen(char *AtomName) 
{

  if( ( isdigit(AtomName[0]) &&
       ( AtomName[1] == 'H' || AtomName[1] == 'D' || 
	AtomName[1] == 'T' || AtomName[1] == 'Q' ) ) ||
     AtomName[0] == 'H' || AtomName[0] == 'D' || 
     AtomName[0] == 'T' || AtomName[0] == 'Q' )
    return(SUCCESS);
  else
    return(FAILURE);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
callq 0x2250
movq (%rax), %rax
movq 0x8(%rsp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0x63a2
movq 0x8(%rsp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x48, %eax
je 0x63d6
movq 0x8(%rsp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x44, %eax
je 0x63d6
movq 0x8(%rsp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x54, %eax
je 0x63d6
movq 0x8(%rsp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x51, %eax
je 0x63d6
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x48, %eax
je 0x63d6
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x44, %eax
je 0x63d6
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x54, %eax
je 0x63d6
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x51, %eax
jne 0x63e0
movl $0x1, 0x14(%rsp)
jmp 0x63e8
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/josch[P]stride/strutil.c
// Function: Translate
char *Translate(char Code)
{

  static char *Dictionary[18] = {
    "AlphaHelix","310Helix","PiHelix","Strand","Bridge","Coil","TurnI","TurnI'",
    "TurnII","TurnII'","TurnVIa","TurnVIb","TurnVIII","TurnIV","GammaClassic",
    "GammaInv","Turn","Unknown" };

  switch(Code) {
  case 'H': return(Dictionary[0]);
  case 'G': return(Dictionary[1]); 
  case 'I': return(Dictionary[2]); 
  case 'E': return(Dictionary[3]);
  case 'B': 
  case 'b': 
            return(Dictionary[4]);
  case 'C': return(Dictionary[5]);
  case '1': return(Dictionary[6]);
  case '2': return(Dictionary[7]);
  case '3': return(Dictionary[8]);
  case '4': return(Dictionary[9]);
  case '5': return(Dictionary[10]);
  case '6': return(Dictionary[11]);
  case '7': return(Dictionary[12]);
  case '8': return(Dictionary[13]); 
  case '@': return(Dictionary[14]); 
  case '&': return(Dictionary[15]); 
  case 'T': return(Dictionary[16]); 
  default:  return(Dictionary[17]);
  }

}

// Assembly:
movb %dil, %al
movb %al, -0x9(%rsp)
movsbl -0x9(%rsp), %eax
addl $-0x26, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rsp)
subl $0x3c, %eax
ja 0x653a
movq -0x18(%rsp), %rax
leaq 0x25495(%rip), %rcx     # 0x2b8c0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x29d15(%rip), %rax     # 0x30150
movq %rax, -0x8(%rsp)
jmp 0x6546
movq 0x29d0c(%rip), %rax     # 0x30158
movq %rax, -0x8(%rsp)
jmp 0x6546
movq 0x29d03(%rip), %rax     # 0x30160
movq %rax, -0x8(%rsp)
jmp 0x6546
movq 0x29cfa(%rip), %rax     # 0x30168
movq %rax, -0x8(%rsp)
jmp 0x6546
movq 0x29cf1(%rip), %rax     # 0x30170
movq %rax, -0x8(%rsp)
jmp 0x6546
movq 0x29ce8(%rip), %rax     # 0x30178
movq %rax, -0x8(%rsp)
jmp 0x6546
movq 0x29cdf(%rip), %rax     # 0x30180
movq %rax, -0x8(%rsp)
jmp 0x6546
movq 0x29cd6(%rip), %rax     # 0x30188
movq %rax, -0x8(%rsp)
jmp 0x6546
movq 0x29ccd(%rip), %rax     # 0x30190
movq %rax, -0x8(%rsp)
jmp 0x6546
movq 0x29cc7(%rip), %rax     # 0x30198
movq %rax, -0x8(%rsp)
jmp 0x6546
movq 0x29cc1(%rip), %rax     # 0x301a0
movq %rax, -0x8(%rsp)
jmp 0x6546
movq 0x29cbb(%rip), %rax     # 0x301a8
movq %rax, -0x8(%rsp)
jmp 0x6546
movq 0x29cb5(%rip), %rax     # 0x301b0
movq %rax, -0x8(%rsp)
jmp 0x6546
movq 0x29caf(%rip), %rax     # 0x301b8
movq %rax, -0x8(%rsp)
jmp 0x6546
movq 0x29ca9(%rip), %rax     # 0x301c0
movq %rax, -0x8(%rsp)
jmp 0x6546
movq 0x29ca3(%rip), %rax     # 0x301c8
movq %rax, -0x8(%rsp)
jmp 0x6546
movq 0x29c9d(%rip), %rax     # 0x301d0
movq %rax, -0x8(%rsp)
jmp 0x6546
movq 0x29c97(%rip), %rax     # 0x301d8
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/josch[P]stride/strutil.c
// Function: SpaceToDash
char SpaceToDash(char Id)
{
  static char NewId;

  if( Id == ' ' )
    NewId = '-';
  else
    NewId = Id;

  return(NewId);
}

// Assembly:
movb %dil, %al
movb %al, -0x1(%rsp)
movsbl -0x1(%rsp), %eax
cmpl $0x20, %eax
jne 0x656a
movb $0x2d, 0x2b698(%rip)    # 0x31c00
jmp 0x6574
movb -0x1(%rsp), %al
movb %al, 0x2b68c(%rip)      # 0x31c00
movb 0x2b686(%rip), %al      # 0x31c00
retq
nopl (%rax,%rax)