LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/KellerMartins[P]PDS2-Pacman/source/game/enemies/inky.cpp
// Function: Inky::SetGoal(int&, int&, int, int, int, int)
void Inky::SetGoal(int &goalX, int &goalY, int pacX, int pacY,int dirX, int dirY){
    if(_alive){
        if(!_scared){
           if(_scatter){
                goalX = 1;
                goalY = ALTURA - 2;
                if(_timerScatter > 0){
                    _timerScatter -= 5*GetFrameTime();
                }
            }
            else{
                //O goal esta uma posicao na frente do pacman
                //direita
                if(dirX == 1 && dirY == 0){
                    goalX = pacX + 3;
                    goalY = pacY;
                }
                //esquerda
                else if(dirX == -1 && dirY == 0){
                    goalX = pacX - 3;
                    goalY = pacY;
                }
                //cima
                else if(dirX == 0 && dirY == -1){
                    goalX = pacX;
                    goalY = pacY - 3;
                }
                //baixo
                else if(dirX == 0 && dirY == 1){
                    goalX = pacX;
                    goalY = pacY + 3;
                }
                
            }
        }else{
            goalX = 1;
            goalY = ALTURA - 2;
        }
    }else{
        goalX = 10;
        goalY = 10;
    }
    
}

// Assembly:
cmpb $0x1, 0x2d9(%rdi)
jne 0x109bd
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0xc849f(%rip), %rax     # 0xd8e49
cmpb $0x0, (%rax)
je 0x109c5
movl $0x1, (%rsi)
movl $0x19, (%rdx)
jmp 0x10a2f
pushq $0xa
popq %rax
movl %eax, (%rsi)
movl %eax, (%rdx)
retq
movq %rdi, %rbx
cmpb $0x1, 0x2d8(%rdi)
jne 0x10a0c
movl $0x1, (%rsi)
movl $0x19, (%rdx)
movss 0x2e8(%rbx), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x10a2f
callq 0x2e7fe
mulss 0x87de6(%rip), %xmm0    # 0x987e0
addss 0x2e8(%rbx), %xmm0
movss %xmm0, 0x2e8(%rbx)
jmp 0x10a2f
movl 0x10(%rbp), %eax
movl %r9d, %edi
xorl $0x1, %edi
orl %eax, %edi
jne 0x10a1e
addl $0x3, %ecx
jmp 0x10a2a
movl %r9d, %edi
notl %edi
orl %eax, %edi
jne 0x10a36
addl $-0x3, %ecx
movl %ecx, (%rsi)
movl %r8d, (%rdx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl %eax, %edi
notl %edi
orl %r9d, %edi
jne 0x10a47
movl %ecx, (%rsi)
addl $-0x3, %r8d
jmp 0x10a2c
xorl $0x1, %eax
orl %eax, %r9d
jne 0x10a2f
movl %ecx, (%rsi)
addl $0x3, %r8d
jmp 0x10a2c
nop
// File: /workspace/github_cpp_makefile_star2_O2/KellerMartins[P]PDS2-Pacman/source/game/enemies/pinky.cpp
// Function: Pinky::SetGoal(int&, int&, int, int, int, int)
void Pinky::SetGoal(int &goalX, int &goalY, int pacX, int pacY,int dirX, int dirY){
    if(_alive){
        if(!_scared){
           if(_scatter){
                goalX = LARGURA -2;
                goalY = 1;
                if(_timerScatter > 0){
                    _timerScatter -= 5*GetFrameTime();
                    
                }
            }
            else{
                //O goal esta duas posicoes na frente do pacman
                //direita
                if(dirX == 1 && dirY == 0){
                    goalX = pacX + 2;
                    goalY = pacY;
                }
                //esquerda
                else if(dirX == -1 && dirY == 0){
                    goalX = pacX - 2;
                    goalY = pacY;
                }
                //cima
                else if(dirX == 0 && dirY == -1){
                    goalX = pacX;
                    goalY = pacY - 2;
                }
                //baixo
                else if(dirX == 0 && dirY == 1){
                    goalX = pacX;
                    goalY = pacY + 2;
                }
            }
        }else{
            goalX = LARGURA - 2;
            goalY = 1;
        }
    }else{
        goalX = 10;
        goalY = 10;
    }
}

// Assembly:
cmpb $0x1, 0x2d9(%rdi)
jne 0x10ac9
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0xc8393(%rip), %rax     # 0xd8e49
cmpb $0x0, (%rax)
je 0x10ad1
movl $0x13, (%rsi)
movl $0x1, (%rdx)
jmp 0x10b3b
pushq $0xa
popq %rax
movl %eax, (%rsi)
movl %eax, (%rdx)
retq
movq %rdi, %rbx
cmpb $0x1, 0x2d8(%rdi)
jne 0x10b18
movl $0x13, (%rsi)
movl $0x1, (%rdx)
movss 0x2e8(%rbx), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x10b3b
callq 0x2e7fe
mulss 0x87cda(%rip), %xmm0    # 0x987e0
addss 0x2e8(%rbx), %xmm0
movss %xmm0, 0x2e8(%rbx)
jmp 0x10b3b
movl 0x10(%rbp), %eax
movl %r9d, %edi
xorl $0x1, %edi
orl %eax, %edi
jne 0x10b2a
addl $0x2, %ecx
jmp 0x10b36
movl %r9d, %edi
notl %edi
orl %eax, %edi
jne 0x10b42
addl $-0x2, %ecx
movl %ecx, (%rsi)
movl %r8d, (%rdx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl %eax, %edi
notl %edi
orl %r9d, %edi
jne 0x10b53
movl %ecx, (%rsi)
addl $-0x2, %r8d
jmp 0x10b38
xorl $0x1, %eax
orl %eax, %r9d
jne 0x10b3b
movl %ecx, (%rsi)
addl $0x2, %r8d
jmp 0x10b38
nop
// File: /workspace/github_cpp_makefile_star2_O2/JenTus[P]TCEM/src_TCEM/allocator.cc
// Function: Cide::allocator::tdem()
double allocator::tdem() {
        
        cout << "computation for lower bounding OPT started " << endl;

        clock_t common_begin = clock();
        double lb = lowerBoundOPT();
        cout << "lower bound identified: " << lb << endl;
        
        theta = (8 + 4/3.0 * epsilon) * n * (ell * log(n) + log(2) +  logP(n,k_r,tao)) / (epsilon * epsilon * lb);
        //theta = (2 + 2/3.0 * epsilon) * n * (ell * log(n) + log(2) +  logP(n,k_r,tao)) / (epsilon * epsilon * lb);
        
        cout << "final sample size " << theta << endl;
        generateRCSets(theta);
        
        clock_t common_end = clock();
        duration_common = double(common_end - common_begin) / CLOCKS_PER_SEC;

        double greedySolution = n * rcGreedy(theta, true);

        return greedySolution; 
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0xffd7(%rip), %r15      # 0x14fd8
leaq 0x91cb(%rip), %rsi      # 0xe1d3
movq %r15, %rdi
callq 0x32c0
movq %rax, %rdi
callq 0x3150
callq 0x31c0
movq %rax, %r14
movq %rbx, %rdi
callq 0x6eae
movsd %xmm0, 0x8(%rsp)
leaq 0x91ca(%rip), %rsi      # 0xe1ff
movq %r15, %rdi
callq 0x32c0
movq %rax, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x34d0
movq %rax, %rdi
callq 0x3150
movsd 0x90(%rbx), %xmm0
mulsd 0x90c5(%rip), %xmm0     # 0xe128
addsd 0x90c5(%rip), %xmm0     # 0xe130
movl 0x68(%rbx), %edi
cvtsi2sd %edi, %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x18(%rsp)
movsd 0xa0(%rbx), %xmm0
movsd %xmm0, 0x10(%rsp)
callq 0x8459
mulsd 0x10(%rsp), %xmm0
addsd 0x909b(%rip), %xmm0     # 0xe138
movsd %xmm0, 0x10(%rsp)
movl 0x68(%rbx), %edi
movl 0x78(%rbx), %esi
movl 0x80(%rbx), %edx
callq 0x8462
addsd 0x10(%rsp), %xmm0
mulsd 0x18(%rsp), %xmm0
movsd 0x90(%rbx), %xmm1
mulsd %xmm1, %xmm1
mulsd 0x8(%rsp), %xmm1
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
movq %rax, 0x10(%rbx)
leaq 0x9132(%rip), %rsi      # 0xe218
movq %r15, %rdi
callq 0x32c0
movq 0x10(%rbx), %rsi
movq %rax, %rdi
callq 0x30f0
movq %rax, %rdi
callq 0x3150
movq 0x10(%rbx), %rsi
movq %rbx, %rdi
callq 0x7014
callq 0x31c0
subq %r14, %rax
cvtsi2sd %rax, %xmm0
divsd 0x901d(%rip), %xmm0     # 0xe140
movsd %xmm0, 0x8(%rbx)
cvtsi2sdl 0x68(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x10(%rbx), %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x7220
mulsd 0x8(%rsp), %xmm0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/JenTus[P]TCEM/src_TCEM/allocator.cc
// Function: Cide::allocator::lowerBoundOPT()
double allocator::lowerBoundOPT() {

        double epsilon_1 = epsilon * 2.0; //

        for (int x = 1; x < log2(n); x++) {

            int64 theta_x = (2+2.0/3.0 * epsilon_1)* (ell * log(n) + logP(n,k_r,tao) + log(log2(n))) * pow(2.0,x) / (epsilon_1 * epsilon_1);
            //int64 theta_x =  (2+2.0/3.0 * epsilon_1)* (ell * log(n) + logcnk(n*(n-1), k_r*k_b) + log(log2(n))) * pow(2.0,x) / (epsilon_1 * epsilon_1);
            
//            std::cout << "theta_x " << theta_x << std::endl;
            generateRCSets(theta_x);
            
            double ept = rcGreedy(theta_x, false);

//            cout << "ept is: " << ept << endl;

            if (ept > ((1+epsilon_1) / pow(2.0, x))) {
                double lowerBound = ept * n / (1 + epsilon_1);
                // kontrol:
//                std:cout << "x and theta_x " << x << " " << theta_x << std::endl;
                return lowerBound;
            }
        }
        cout << "returning naive lower bound  " << endl;
        double naive = 1.0;
        return naive;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movsd 0x90(%rdi), %xmm0
addsd %xmm0, %xmm0
movsd 0x7283(%rip), %xmm1     # 0xe150
mulsd %xmm0, %xmm1
addsd 0x727f(%rip), %xmm1     # 0xe158
movsd %xmm1, 0x20(%rsp)
movapd %xmm0, %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x18(%rsp)
addsd 0x722b(%rip), %xmm0     # 0xe120
movsd %xmm0, 0x10(%rsp)
pushq $0x1
popq %rbp
cvtsi2sd %ebp, %xmm0
movsd %xmm0, 0x8(%rsp)
movl 0x68(%rbx), %edi
callq 0x8545
ucomisd 0x8(%rsp), %xmm0
jbe 0x6fe8
movsd 0xa0(%rbx), %xmm0
movsd %xmm0, 0x28(%rsp)
movl 0x68(%rbx), %edi
callq 0x8459
movsd %xmm0, (%rsp)
movl 0x68(%rbx), %edi
movl 0x78(%rbx), %esi
movl 0x80(%rbx), %edx
callq 0x8462
movsd (%rsp), %xmm1
mulsd 0x28(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movl 0x68(%rbx), %edi
callq 0x8545
callq 0x3220
addsd (%rsp), %xmm0
mulsd 0x20(%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x3280
mulsd (%rsp), %xmm0
divsd 0x18(%rsp), %xmm0
cvttsd2si %xmm0, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7014
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x7220
movsd %xmm0, (%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x3280
movsd 0x10(%rsp), %xmm1
divsd %xmm0, %xmm1
incl %ebp
movsd (%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x6efe
cvtsi2sdl 0x68(%rbx), %xmm1
mulsd %xmm1, %xmm0
divsd 0x10(%rsp), %xmm0
jmp 0x700b
movq 0xdfe9(%rip), %rdi      # 0x14fd8
leaq 0x7235(%rip), %rsi      # 0xe22b
callq 0x32c0
movq %rax, %rdi
callq 0x3150
movsd 0x7115(%rip), %xmm0     # 0xe120
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/JenTus[P]TCEM/src_TCEM/allocator.cc
// Function: Cide::allocator::createhyperGTPairs(long long)
double allocator::createhyperGTPairs(int64 newSize) {
        // use to create reverse rr pairs
        //update hyperG and hyper_degree
        //cout << "newSize is " << newSize << endl;
        for (int z = prevSize; z < newSize; ++z) {
            hyperGTpairs.emplace_back(std::vector<int>()); // init
        }

        for (int rcID = prevSize; rcID < newSize; ++rcID) {
            for (int i = 0; i < rcList->at(0)->hyperGT[rcID].size(); ++i) {
                for (int j = 0; j < rcList->at(1)->hyperGT[rcID].size(); ++j) {
                    //cout << "r: " << rcList->at(0)->hyperGT[rcID].size() << " b: " << rcList->at(1)->hyperGT[rcID].size()<< endl;
                   int t = rcList->at(0)->hyperGT[rcID][i]*n + rcList->at(1)->hyperGT[rcID][j];
                   hyperGTpairs[rcID].push_back(t);
                }
            }
        }

        return hyperGTpairs.size();
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r13
movq %rdi, %rbx
movslq 0xb20(%rdi), %r14
leaq 0xb28(%rdi), %r15
movq %rsp, %r12
cmpq %r13, %r14
jge 0x7d7b
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x8358
movq %r12, %rdi
callq 0x8e40
incq %r14
jmp 0x7d51
movslq 0xb20(%rbx), %rax
pushq $0x1
popq %r15
movq %r13, 0x18(%rsp)
cmpq %r13, %rax
jge 0x7e6e
movq %rax, 0x20(%rsp)
imulq $0x18, %rax, %rbp
xorl %r14d, %r14d
movq 0xae8(%rbx), %rdi
xorl %esi, %esi
callq 0x856c
movq (%rax), %rax
movq 0x18(%rax), %rax
movq 0x8(%rax,%rbp), %rcx
subq (%rax,%rbp), %rcx
sarq $0x2, %rcx
cmpq %r14, %rcx
jbe 0x7e5c
xorl %r13d, %r13d
movq 0xae8(%rbx), %rdi
movq %r15, %rsi
callq 0x856c
movq (%rax), %rax
movq 0x18(%rax), %rax
movq 0x8(%rax,%rbp), %rcx
subq (%rax,%rbp), %rcx
sarq $0x2, %rcx
cmpq %r13, %rcx
jbe 0x7e54
movq 0xae8(%rbx), %rdi
xorl %esi, %esi
callq 0x856c
movq (%rax), %rax
movq 0x18(%rax), %rax
movq (%rax,%rbp), %rax
movl 0x68(%rbx), %r12d
imull (%rax,%r14,4), %r12d
movq 0xae8(%rbx), %rdi
movq %r15, %rsi
callq 0x856c
movq (%rax), %rax
movq 0x18(%rax), %rax
movq (%rax,%rbp), %rax
addl (%rax,%r13,4), %r12d
movl %r12d, (%rsp)
movq 0xb28(%rbx), %rdi
addq %rbp, %rdi
movq %rsp, %rsi
callq 0x854e
incq %r13
jmp 0x7dce
incq %r14
jmp 0x7da0
movq 0x20(%rsp), %rax
incq %rax
movq 0x18(%rsp), %r13
jmp 0x7d8b
movq 0xb30(%rbx), %rax
subq 0xb28(%rbx), %rax
pushq $0x18
popq %rcx
cqto
idivq %rcx
movq %rax, %xmm1
punpckldq 0x626f(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x6277(%rip), %xmm1     # 0xe110
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x8e40
movq %rbx, %rdi
callq 0x3560
nop
// File: /workspace/github_cpp_makefile_star2_O2/JenTus[P]TCEM/src_TCEM/allocator.cc
// Function: Cide::allocator::writeInMasterOutputFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, float, float, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::set<int, std::less<int>, std::allocator<int>>, std::set<int, std::less<int>, std::allocator<int>>)
void allocator::writeInMasterOutputFile(const string& algorithm, float duration, float memory, string score, set<int> reds, set<int> blues) {
        // seed-node item mgScore totScore runTime(sec) memory(mb)
        outMasterStream << std::fixed<<std::setprecision(2) << algorithm << " & " << duration << " & " <<  memory << " & " << score <<  endl;
        set<int>::iterator it;

        outMasterStream << "red: ";
        for (it=reds.begin(); it!=reds.end(); ++it)
            outMasterStream << *it << " ";
        outMasterStream << endl;

        outMasterStream << "blue: ";
        for (it=blues.begin(); it!= blues.end(); ++it) {
            outMasterStream << *it << " ";
        }
        outMasterStream << endl;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movss %xmm1, 0xc(%rsp)
movss %xmm0, 0x8(%rsp)
leaq 0xb98(%rdi), %r14
movq 0xb98(%rdi), %rax
movq -0x18(%rax), %rcx
movl $0xfffffefb, %edx       # imm = 0xFFFFFEFB
andl 0xbb0(%rdi,%rcx), %edx
orl $0x4, %edx
movl %edx, 0xbb0(%rdi,%rcx)
movq -0x18(%rax), %rax
movq $0x2, 0xba0(%rdi,%rax)
movq %r14, %rdi
callq 0x3260
leaq 0x657c(%rip), %r13      # 0xe4ad
movq %rax, %rdi
movq %r13, %rsi
callq 0x32c0
movq %rax, %rdi
movss 0x8(%rsp), %xmm0
callq 0x31f0
movq %rax, %rdi
movq %r13, %rsi
callq 0x32c0
movq %rax, %rdi
movss 0xc(%rsp), %xmm0
callq 0x31f0
movq %rax, %rdi
movq %r13, %rsi
callq 0x32c0
movq %rax, %rdi
movq %r12, %rsi
callq 0x3260
movq %rax, %rdi
callq 0x3150
leaq 0x6529(%rip), %rsi      # 0xe4b1
movq %r14, %rdi
callq 0x32c0
movq 0x18(%r15), %r13
addq $0x8, %r15
leaq 0x62a8(%rip), %r12      # 0xe247
cmpq %r15, %r13
je 0x7fc8
movl 0x20(%r13), %esi
movq %r14, %rdi
callq 0x3530
movq %rax, %rdi
movq %r12, %rsi
callq 0x32c0
movq %r13, %rdi
callq 0x3320
movq %rax, %r13
jmp 0x7f9f
movq %r14, %rdi
callq 0x3150
leaq 0x64e0(%rip), %rsi      # 0xe4b7
movq %r14, %rdi
callq 0x32c0
movq 0x18(%rbx), %r12
addq $0x8, %rbx
leaq 0x6259(%rip), %r15      # 0xe247
cmpq %rbx, %r12
je 0x8018
movl 0x20(%r12), %esi
movq %r14, %rdi
callq 0x3530
movq %rax, %rdi
movq %r15, %rsi
callq 0x32c0
movq %r12, %rdi
callq 0x3320
movq %rax, %r12
jmp 0x7fee
movq %r14, %rdi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x3150
nop
// File: /workspace/github_cpp_makefile_star2_O2/JenTus[P]TCEM/src_TCEM/utils.h
// Function: strToInt(char const*)
inline int strToInt(const char* s) {

  int i;
  istringstream myStream(s);

  if (myStream >> i)
    return i;
  
  else {
    cout << "String " << s << " is not a number." << endl;
    return atoi(s);
    }
  
  return i;
}

// Assembly:
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdi, %rbx
leaq 0x10(%rsp), %rdi
leaq 0xb(%rsp), %rdx
movq %rbx, %rsi
callq 0x3100
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
pushq $0x8
popq %rdx
callq 0x3510
leaq 0x10(%rsp), %rdi
callq 0x3130
leaq 0x30(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x3180
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
je 0x8273
movq 0xcd9f(%rip), %rdi      # 0x14fd8
leaq 0x627e(%rip), %rsi      # 0xe4be
callq 0x32c0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x32c0
leaq 0x626f(%rip), %rsi      # 0xe4c6
movq %rax, %rdi
callq 0x32c0
movq %rax, %rdi
callq 0x3150
movq %rbx, %rdi
callq 0x3490
movl %eax, %ebx
jmp 0x8277
movl 0xc(%rsp), %ebx
leaq 0x30(%rsp), %rdi
callq 0x3140
movl %ebx, %eax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x3130
jmp 0x82ad
movq %rax, %rbx
jmp 0x82ad
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x3140
movq %rbx, %rdi
callq 0x3560
// File: /workspace/github_cpp_makefile_star2_O2/JenTus[P]TCEM/src_TCEM/utils.h
// Function: strToDouble(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
inline double strToDouble(string s) {	
// 	return std::stod(s);
	double a = 0; 
	stringstream ss;
	ss << s;
	ss >> a;
	return a;
}

// Assembly:
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rdi, %rbx
andq $0x0, 0x8(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x31e0
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq 0x3260
leaq 0x18(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x31b0
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x3200
movsd 0x10(%rsp), %xmm0
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x3200
movq %rbx, %rdi
callq 0x3560
// File: /workspace/github_cpp_makefile_star2_O2/JenTus[P]TCEM/src_TCEM/utils.h
// Function: logP(int, int, int)
inline double logP(int n, int k_r, int tau) {
    double ans = 0;
    
    // computes log of perm(n, k_r * (tau+1))
    for (int i = n - k_r *(tau+1) + 1; i <= n; i++)
    {
        ans += std::log(i);
    }
    
    // computes log of k_r!
    for (int i = 1; i <= k_r; i++)
    {
        ans -= std::log(i);
    }
    
    // computes log of tau!
    double t = 0;
    for (int i = 1; i <= tau; i++)
    {
        t += std::log(i);
    }
    ans -= k_r * t;
    return ans;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movl %esi, %ebx
movl %edi, %r14d
movl %edx, %r15d
notl %r15d
imull %esi, %r15d
addl %edi, %r15d
xorpd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
cmpl %r14d, %r15d
jge 0x84ac
incl %r15d
movl %r15d, %edi
callq 0x8459
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
jmp 0x848a
xorl %r15d, %r15d
testl %ebx, %ebx
cmovgl %ebx, %r15d
negl %r15d
pushq $0x1
popq %r14
leal (%r15,%r14), %eax
cmpl $0x1, %eax
je 0x84e2
movl %r14d, %edi
callq 0x8459
movsd 0x8(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
incl %r14d
jmp 0x84bc
xorl %r15d, %r15d
testl %ebp, %ebp
cmovgl %ebp, %r15d
negl %r15d
pushq $0x1
popq %r14
xorpd %xmm0, %xmm0
leal (%r15,%r14), %eax
cmpl $0x1, %eax
je 0x8528
movl %r14d, %edi
movsd %xmm0, 0x10(%rsp)
callq 0x8459
movsd 0x10(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
incl %r14d
jmp 0x84f6
cvtsi2sd %ebx, %xmm1
mulsd %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
subsd %xmm1, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/JenTus[P]TCEM/src_TCEM/utils.h
// Function: void split1<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
void split1(const std::string& str, Container& cont)
{
    std::istringstream iss(str);
    std::copy(std::istream_iterator<std::string>(iss),
              std::istream_iterator<std::string>(),
              std::back_inserter(cont));
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1e8, %rsp            # imm = 0x1E8
movq %rsi, %rbx
movq %rdi, %rsi
leaq 0x68(%rsp), %r14
pushq $0x8
popq %rdx
movq %r14, %rdi
callq 0x3510
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0xa932
leaq 0x40(%rsp), %r14
andq $0x0, -0x8(%r14)
leaq 0x50(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %ecx, %ecx
movb %cl, (%rax)
movb %cl, 0x10(%rax)
leaq 0x8(%rsp), %rdi
leaq 0x38(%rsp), %rsi
movq %rbx, %rdx
callq 0xa853
movq %r14, %rdi
callq 0x3130
leaq 0x10(%rsp), %rdi
callq 0x3130
leaq 0x68(%rsp), %rdi
callq 0x3140
addq $0x1e8, %rsp            # imm = 0x1E8
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x3130
leaq 0x10(%rsp), %rdi
callq 0x3130
jmp 0x893f
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x3140
movq %rbx, %rdi
callq 0x3560
// File: /workspace/github_cpp_makefile_star2_O2/JenTus[P]TCEM/src_TCEM/utils.h
// Function: strToInt(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
inline unsigned int strToInt(string s) {
  unsigned int i;
  istringstream myStream(s);

  if(myStream >> i) 
    return i;
  
  else {
    std::cout << "String " << s << " is not a number." << endl;
    return atoi(s.c_str());
  }
  
  return i;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
pushq $0x8
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3510
leaq 0x4(%rsp), %rsi
movq %r14, %rdi
callq 0x3550
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
je 0x89cd
movq 0xc645(%rip), %rdi      # 0x14fd8
leaq 0x5b24(%rip), %rsi      # 0xe4be
callq 0x32c0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3260
leaq 0x5b15(%rip), %rsi      # 0xe4c6
movq %rax, %rdi
callq 0x32c0
movq %rax, %rdi
callq 0x3150
movq (%rbx), %rdi
callq 0x3490
movl %eax, %ebx
jmp 0x89d1
movl 0x4(%rsp), %ebx
leaq 0x8(%rsp), %rdi
callq 0x3140
movl %ebx, %eax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3140
movq %rbx, %rdi
callq 0x3560
nop
// File: /workspace/github_cpp_makefile_star2_O2/JenTus[P]TCEM/src_TCEM/utils.cc
// Function: getCurrentMemoryUsage()
float getCurrentMemoryUsage() { //megabyte verii
	string pid = intToStr(unsigned(getpid()));
	string outfile = "temp/tmp_" + pid + ".txt";
	string command = "pmap " + pid + " | grep -i Total | awk '{print $2}' > " + outfile;	
	system(command.c_str());
	
	string mem_str;
	ifstream ifs(outfile.c_str());
	std::getline(ifs, mem_str);
	ifs.close();
	
	mem_str = mem_str.substr(0, mem_str.size()-1);
	float mem = (float)strToInt(mem_str);
	
	return mem/1024; // in MB
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x2d8, %rsp            # imm = 0x2D8
callq 0x3450
leaq 0x90(%rsp), %rbx
movq %rbx, %rdi
movl %eax, %esi
callq 0xb35d
leaq 0x3868(%rip), %rsi      # 0xe680
leaq 0xd0(%rsp), %rdi
movq %rbx, %rdx
callq 0xb3b4
leaq 0x3618(%rip), %rdx      # 0xe447
leaq 0x30(%rsp), %rdi
leaq 0xd0(%rsp), %rsi
callq 0x8a3e
leaq 0xd0(%rsp), %rdi
callq 0x3130
leaq 0x3835(%rip), %rsi      # 0xe68a
leaq 0x10(%rsp), %rdi
leaq 0x90(%rsp), %rdx
callq 0xb3b4
leaq 0x3822(%rip), %rdx      # 0xe690
leaq 0xd0(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x8a3e
leaq 0x70(%rsp), %rdi
leaq 0xd0(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x8a1f
leaq 0xd0(%rsp), %rdi
callq 0x3130
leaq 0x10(%rsp), %rdi
callq 0x3130
movq 0x70(%rsp), %rdi
callq 0x3240
leaq 0x20(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x30(%rsp), %rsi
leaq 0xd0(%rsp), %rdi
pushq $0x8
popq %rdx
callq 0x3580
leaq 0xd0(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x3080
leaq 0xd0(%rsp), %rdi
callq 0x3090
leaq 0x10(%rsp), %rsi
movq 0x8(%rsi), %rcx
decq %rcx
leaq 0xb0(%rsp), %rdi
xorl %edx, %edx
callq 0x32e0
leaq 0x10(%rsp), %rbx
leaq 0xb0(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3380
movq %r14, %rdi
callq 0x3130
leaq 0x50(%rsp), %rdi
movq %rbx, %rsi
callq 0x3410
leaq 0x50(%rsp), %rdi
callq 0x8951
movl %eax, %eax
cvtsi2ss %rax, %xmm0
movss %xmm0, 0xc(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x3130
movss 0xc(%rsp), %xmm0
mulss 0x3708(%rip), %xmm0     # 0xe67c
movss %xmm0, 0xc(%rsp)
leaq 0xd0(%rsp), %rdi
callq 0x30c0
leaq 0x10(%rsp), %rdi
callq 0x3130
leaq 0x70(%rsp), %rdi
callq 0x3130
leaq 0x30(%rsp), %rdi
callq 0x3130
leaq 0x90(%rsp), %rdi
callq 0x3130
movss 0xc(%rsp), %xmm0
addq $0x2d8, %rsp            # imm = 0x2D8
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x3130
jmp 0xb016
jmp 0xb013
jmp 0xb013
movq %rax, %rbx
jmp 0xb023
movq %rax, %rbx
jmp 0xb02d
movq %rax, %rbx
leaq 0xd0(%rsp), %rdi
callq 0x3130
jmp 0xaff5
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
jmp 0xb032
movq %rax, %rbx
jmp 0xb037
movq %rax, %rbx
leaq 0xd0(%rsp), %rdi
jmp 0xb03c
movq %rax, %rbx
jmp 0xb041
movq %rax, %rbx
leaq 0xd0(%rsp), %rdi
callq 0x30c0
leaq 0x10(%rsp), %rdi
callq 0x3130
leaq 0x70(%rsp), %rdi
callq 0x3130
leaq 0x30(%rsp), %rdi
callq 0x3130
leaq 0x90(%rsp), %rdi
callq 0x3130
movq %rbx, %rdi
callq 0x3560
// File: /workspace/github_cpp_makefile_star2_O2/JenTus[P]TCEM/src_TCEM/utils.cc
// Function: getRunningTime(long)
float getRunningTime(time_t startTime) {	//in seconds
	time_t curTime;
	time(&curTime);	
// 	float duration = ((float)(curTime - startTime))/60; //minutes icin
	float duration = ((float)(curTime - startTime)); // seconds icin
	return duration;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x3290
movq (%r14), %rax
subq %rbx, %rax
cvtsi2ss %rax, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/JenTus[P]TCEM/src_TCEM/utils.cc
// Function: stringTokenizer(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, float*, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void stringTokenizer(string& str, float *tokens, int size, string& delimiters) {
	//Skip delimiters at beginning.
	string::size_type lastPos = str.find_first_not_of(delimiters, 0);
	//Find first "non-delimiter".
	string::size_type pos = str.find_first_of(delimiters, lastPos);
	
	int i = 0;
	while (string::npos != pos || string::npos != lastPos)
	{
		if(i >= size) {
			cout << "something is wrong" << endl;
			exit(1);
		}
		
		tokens[i++] = strToFloat(str.substr(lastPos, pos - lastPos));
		lastPos = str.find_first_not_of(delimiters, pos);		
		pos = str.find_first_of(delimiters, lastPos);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %rbx
movl %edx, %r12d
movq %rsi, 0x8(%rsp)
movq %rdi, %r15
xorl %r14d, %r14d
movq %rcx, %rsi
xorl %edx, %edx
callq 0x3230
movq %rax, %rbp
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x3270
movq %rax, %r13
testl %r12d, %r12d
movl $0x0, %eax
cmovgl %r12d, %eax
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %r12
movq %r13, %rax
andq %rbp, %rax
cmpq $-0x1, %rax
je 0xb137
cmpq %r14, 0x10(%rsp)
je 0xb146
movq %r13, %rcx
subq %rbp, %rcx
movq %r12, %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0x32e0
movq %r12, %rdi
callq 0xb42a
movq 0x8(%rsp), %rax
movss %xmm0, (%rax,%r14,4)
incq %r14
movq %r12, %rdi
callq 0x3130
movq %r15, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x3230
movq %rax, %rbp
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x3270
movq %rax, %r13
jmp 0xb0ce
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x9e8b(%rip), %rdi      # 0x14fd8
leaq 0x3563(%rip), %rsi      # 0xe6b7
callq 0x32c0
movq %rax, %rdi
callq 0x3150
pushq $0x1
popq %rdi
callq 0x3360
// File: /workspace/github_cpp_makefile_star2_O2/JenTus[P]TCEM/src_TCEM/utils.cc
// Function: rtrim(char*)
void rtrim(char *str) {
	size_t n;
	n = strlen(str);
	while (n > 0 && isspace((unsigned char)str[n - 1])) {
		n--;
	}
	str[n] = '\0';
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x3120
movq %rax, %r14
movq %r14, %r15
subq $0x1, %r14
jb 0xb294
movzbl -0x1(%rbx,%r15), %edi
callq 0x3040
testl %eax, %eax
jne 0xb27c
movb $0x0, (%rbx,%r15)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/JenTus[P]TCEM/src_TCEM/utils.cc
// Function: intersection(std::vector<int, std::allocator<int>>&, std::vector<int, std::allocator<int>>&)
std::vector<int> intersection(std::vector<int> &v1,
                                      std::vector<int> &v2){
    std::vector<int> v3;

    std::sort(v1.begin(), v1.end());
    std::sort(v2.begin(), v2.end());

    std::set_intersection(v1.begin(),v1.end(),
                          v2.begin(),v2.end(),
                          back_inserter(v3));
    return v3;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq (%rsi), %rdi
movq 0x8(%rsi), %rsi
callq 0x9b85
movq (%r14), %rdi
movq 0x8(%r14), %rsi
callq 0x9b85
movq (%r15), %rdi
movq 0x8(%r15), %rsi
movq (%r14), %rdx
movq 0x8(%r14), %rcx
movq %rbx, %r8
callq 0xb439
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x8e40
movq %r14, %rdi
callq 0x3560
// File: /workspace/github_cpp_makefile_star2_O2/JenTus[P]TCEM/src_TCEM/itemGraph.cc
// Function: Cide::itemGraph::generateRRSample(std::vector<int, std::allocator<int>>&, long long, long long)
void itemGraph::generateRRSample(vector<int> &targetNodes, int64 prevSize, int64 newSize) {
        for (int64 z = prevSize; z < newSize; z++) {
            hyperGT.emplace_back(std::vector<int>());
            //hyperGT.push_back(std::vector<int>());
            BuildHypergraphNode(targetNodes[z], z);

        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x18(%rdi), %r13
movq %rsp, %rbp
cmpq %rbx, %r14
jge 0xb61f
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
movq %r13, %rdi
movq %rbp, %rsi
callq 0x8358
movq %rbp, %rdi
callq 0x8e40
movq (%r15), %rax
movl (%rax,%r14,4), %esi
movq %r12, %rdi
movq %r14, %rdx
callq 0xb642
incq %r14
jmp 0xb5e3
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x8e40
movq %rbx, %rdi
callq 0x3560
nop
// File: /workspace/github_cpp_makefile_star2_O2/JenTus[P]TCEM/src_TCEM/anyoption.cc
// Function: AnyOption::cleanup()
void
AnyOption::cleanup()
{
	free (options);
	free (optiontype);
	free (optionindex);	
	free (optionchars);
	free (optchartype);
	free (optcharindex);
	free (usage);
	if( values != NULL )
		free (values);
	if( new_argv != NULL )
		free (new_argv);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x38(%rdi), %rdi
callq 0x3350
movq 0x40(%rbx), %rdi
callq 0x3350
movq 0x48(%rbx), %rdi
callq 0x3350
movq 0x58(%rbx), %rdi
callq 0x3350
movq 0x60(%rbx), %rdi
callq 0x3350
movq 0x68(%rbx), %rdi
callq 0x3350
movq 0x88(%rbx), %rdi
callq 0x3350
movq 0x78(%rbx), %rdi
callq 0x3350
movq 0x20(%rbx), %rdi
popq %rbx
jmp 0x3350
nop
// File: /workspace/github_cpp_makefile_star2_O2/JenTus[P]TCEM/src_TCEM/anyoption.cc
// Function: AnyOption::alloc()
bool
AnyOption::alloc()
{
	int i = 0 ;
	int size = 0 ;

	if( mem_allocated )
		return true;

	size = (max_options+1) * sizeof(const char*);
	options = (const char**)malloc( size );	
	optiontype = (int*) malloc( (max_options+1)*sizeof(int) );	
	optionindex = (int*) malloc( (max_options+1)*sizeof(int) );	
	if( options == NULL || optiontype == NULL || optionindex == NULL )
		return false;
	else
		mem_allocated  = true;
	for( i = 0 ; i < max_options ; i++ ){
		options[i] = NULL;
		optiontype[i] = 0 ;
		optionindex[i] = -1 ;
	}
	optionchars = (char*) malloc( (max_char_options+1)*sizeof(char) );
	optchartype = (int*) malloc( (max_char_options+1)*sizeof(int) );	
	optcharindex = (int*) malloc( (max_char_options+1)*sizeof(int) );	
	if( optionchars == NULL || 
            optchartype == NULL || 
            optcharindex == NULL )
        {
		mem_allocated = false;
		return false;
	}
	for( i = 0 ; i < max_char_options ; i++ ){
		optionchars[i] = '0';
		optchartype[i] = 0 ;
		optcharindex[i] = -1 ;
	}

	size = (max_usage_lines+1) * sizeof(const char*) ;
	usage = (const char**) malloc( size );

	if( usage == NULL  ){
		mem_allocated = false;
		return false;
	}
	for( i = 0 ; i < max_usage_lines ; i++ )
		usage[i] = NULL;

	return true;
}

// Assembly:
cmpb $0x0, 0x9a(%rdi)
je 0xbf4e
movb $0x1, %al
retq
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movslq 0x30(%rdi), %r13
leal 0x8(,%r13,8), %eax
movslq %eax, %rdi
callq 0x33e0
movq %rax, %r15
movq %rax, 0x38(%rbx)
leaq 0x4(,%r13,4), %r12
movq %r12, %rdi
callq 0x33e0
movq %rax, %r14
movq %rax, 0x40(%rbx)
movq %r12, %rdi
callq 0x33e0
movq %rax, %rcx
movq %rax, 0x48(%rbx)
xorl %eax, %eax
testq %r15, %r15
je 0xc0b4
testq %r14, %r14
je 0xc0b4
testq %rcx, %rcx
je 0xc0b4
movb $0x1, 0x9a(%rbx)
xorl %eax, %eax
movslq %r13d, %rcx
cmpq %rcx, %rax
jge 0xbfeb
movq 0x38(%rbx), %rcx
andq $0x0, (%rcx,%rax,8)
movq 0x40(%rbx), %rcx
andl $0x0, (%rcx,%rax,4)
movq 0x48(%rbx), %rcx
orl $-0x1, (%rcx,%rax,4)
incq %rax
movl 0x30(%rbx), %r13d
jmp 0xbfc1
movslq 0x54(%rbx), %r13
leaq 0x1(%r13), %rdi
callq 0x33e0
movq %rax, %r14
movq %rax, 0x58(%rbx)
leaq 0x4(,%r13,4), %r15
movq %r15, %rdi
callq 0x33e0
movq %rax, %r12
movq %rax, 0x60(%rbx)
movq %r15, %rdi
callq 0x33e0
movq %rax, 0x68(%rbx)
testq %r14, %r14
sete %cl
testq %r12, %r12
sete %dl
orb %cl, %dl
testq %rax, %rax
sete %al
orb %dl, %al
jne 0xc0a7
xorl %eax, %eax
movslq %r13d, %rcx
cmpq %rcx, %rax
jge 0xc065
movq 0x58(%rbx), %rcx
movb $0x30, (%rcx,%rax)
movq 0x60(%rbx), %rcx
andl $0x0, (%rcx,%rax,4)
movq 0x68(%rbx), %rcx
orl $-0x1, (%rcx,%rax,4)
incq %rax
movl 0x54(%rbx), %r13d
jmp 0xc03c
movl 0x90(%rbx), %r14d
leal 0x8(,%r14,8), %eax
movslq %eax, %rdi
callq 0x33e0
movq %rax, 0x88(%rbx)
testq %rax, %rax
je 0xc0a7
xorl %eax, %eax
testl %r14d, %r14d
cmovlel %eax, %r14d
cmpq %rax, %r14
je 0xc0b2
movq 0x88(%rbx), %rcx
andq $0x0, (%rcx,%rax,8)
incq %rax
jmp 0xc091
movb $0x0, 0x9a(%rbx)
xorl %eax, %eax
jmp 0xc0b4
movb $0x1, %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/JenTus[P]TCEM/src_TCEM/anyoption.cc
// Function: AnyOption::doubleOptStorage()
bool
AnyOption::doubleOptStorage()
{
	options = (const char**)realloc( options,  
			((2*max_options)+1) * sizeof( const char*) );
	optiontype = (int*) realloc(  optiontype ,  
			((2 * max_options)+1)* sizeof(int) );	
	optionindex = (int*) realloc(  optionindex,  
			((2 * max_options)+1) * sizeof(int) );	
	if( options == NULL || optiontype == NULL || optionindex == NULL )
		return false;
	/* init new storage */
	for( int i = max_options ; i < 2*max_options ; i++ ){
		options[i] = NULL;
		optiontype[i] = 0 ;
		optionindex[i] = -1 ;
	}
	max_options = 2 * max_options ;
	return true;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x38(%rdi), %rdi
movslq 0x30(%rbx), %rsi
shlq $0x4, %rsi
orq $0x8, %rsi
callq 0x3500
movq %rax, 0x38(%rbx)
movq 0x40(%rbx), %rdi
movslq 0x30(%rbx), %rax
leaq 0x4(,%rax,8), %rsi
callq 0x3500
movq %rax, 0x40(%rbx)
movq 0x48(%rbx), %rdi
movslq 0x30(%rbx), %rax
leaq 0x4(,%rax,8), %rsi
callq 0x3500
movq %rax, 0x48(%rbx)
cmpq $0x0, 0x38(%rbx)
setne %cl
cmpq $0x0, 0x40(%rbx)
setne %dl
andb %cl, %dl
testq %rax, %rax
setne %al
andb %dl, %al
cmpb $0x1, %al
jne 0xc15f
movl 0x30(%rbx), %edx
movslq %edx, %rcx
addl %edx, %edx
movslq %edx, %rsi
cmpq %rsi, %rcx
jge 0xc15c
movq 0x38(%rbx), %rdx
andq $0x0, (%rdx,%rcx,8)
movq 0x40(%rbx), %rdx
andl $0x0, (%rdx,%rcx,4)
movq 0x48(%rbx), %rdx
orl $-0x1, (%rdx,%rcx,4)
incq %rcx
movl 0x30(%rbx), %edx
jmp 0xc131
movl %edx, 0x30(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/JenTus[P]TCEM/src_TCEM/anyoption.cc
// Function: AnyOption::doubleCharStorage()
bool
AnyOption::doubleCharStorage()
{
	optionchars = (char*) realloc( optionchars,  
			((2*max_char_options)+1)*sizeof(char) );
	optchartype = (int*) realloc( optchartype,  
			((2*max_char_options)+1)*sizeof(int) );	
	optcharindex = (int*) realloc( optcharindex,  
			((2*max_char_options)+1)*sizeof(int) );	
	if( optionchars == NULL || 
	    optchartype == NULL || 
	    optcharindex == NULL )
		return false;
	/* init new storage */
	for( int i = max_char_options ; i < 2*max_char_options ; i++ ){
		optionchars[i] = '0';
		optchartype[i] = 0 ;
		optcharindex[i] = -1 ;
	}
	max_char_options = 2 * max_char_options;	
	return true;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x58(%rdi), %rdi
movslq 0x54(%rbx), %rax
leaq 0x1(,%rax,2), %rsi
callq 0x3500
movq %rax, 0x58(%rbx)
movq 0x60(%rbx), %rdi
movslq 0x54(%rbx), %rax
leaq 0x4(,%rax,8), %rsi
callq 0x3500
movq %rax, 0x60(%rbx)
movq 0x68(%rbx), %rdi
movslq 0x54(%rbx), %rax
leaq 0x4(,%rax,8), %rsi
callq 0x3500
movq %rax, 0x68(%rbx)
cmpq $0x0, 0x58(%rbx)
setne %cl
cmpq $0x0, 0x60(%rbx)
setne %dl
andb %cl, %dl
testq %rax, %rax
setne %al
andb %dl, %al
cmpb $0x1, %al
jne 0xc202
movl 0x54(%rbx), %edx
movslq %edx, %rcx
addl %edx, %edx
movslq %edx, %rsi
cmpq %rsi, %rcx
jge 0xc1ff
movq 0x58(%rbx), %rdx
movb $0x30, (%rdx,%rcx)
movq 0x60(%rbx), %rdx
andl $0x0, (%rdx,%rcx,4)
movq 0x68(%rbx), %rdx
orl $-0x1, (%rdx,%rcx,4)
incq %rcx
movl 0x54(%rbx), %edx
jmp 0xc1d5
movl %edx, 0x54(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/JenTus[P]TCEM/src_TCEM/anyoption.cc
// Function: AnyOption::doubleUsageStorage()
bool
AnyOption::doubleUsageStorage()
{
	usage = (const char**)realloc( usage,  
			((2*max_usage_lines)+1) * sizeof( const char*) );
	if ( usage == NULL )
		return false;
	for( int i = max_usage_lines ; i < 2*max_usage_lines ; i++ )
		usage[i] = NULL;
	max_usage_lines = 2 * max_usage_lines ;
	return true;

}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x88(%rdi), %rdi
movslq 0x90(%rbx), %rsi
shlq $0x4, %rsi
orq $0x8, %rsi
callq 0x3500
movq %rax, 0x88(%rbx)
testq %rax, %rax
je 0xc256
movslq 0x90(%rbx), %rdx
leaq (%rdx,%rdx), %rcx
cmpq %rcx, %rdx
jge 0xc250
movq 0x88(%rbx), %rsi
andq $0x0, (%rsi,%rdx,8)
incq %rdx
jmp 0xc23a
movl %ecx, 0x90(%rbx)
testq %rax, %rax
setne %al
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/JenTus[P]TCEM/src_TCEM/anyoption.cc
// Function: AnyOption::useCommandArgs(int, char**)
void
AnyOption::useCommandArgs( int _argc, char **_argv )
{
	argc = _argc;
	argv = _argv;
	command_set = true;
	appname = argv[0];
	if(argc > 1) hasoptions = true;
}

// Assembly:
movl %esi, (%rdi)
movq %rdx, 0x8(%rdi)
movb $0x1, 0x98(%rdi)
movq (%rdx), %rax
movq %rax, 0x18(%rdi)
cmpl $0x2, %esi
jl 0xc360
movb $0x1, 0xac(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/JenTus[P]TCEM/src_TCEM/anyoption.cc
// Function: AnyOption::addOption(char const*, int)
void
AnyOption::addOption( const char *opt, int type )
{
	if( option_counter >= max_options ){
		if( doubleOptStorage() == false ){
			addOptionError( opt );
			return;
		}
	}
	options[ option_counter ] = opt ;
	optiontype[ option_counter ] =  type ;
	optionindex[ option_counter ] = g_value_counter; 
	option_counter++;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x50(%rdi), %eax
cmpl 0x30(%rdi), %eax
jl 0xc3a5
movq %rbx, %rdi
callq 0xc0be
testb %al, %al
je 0xc3cf
movl 0x50(%rbx), %eax
movq 0x38(%rbx), %rcx
cltq
movq %r14, (%rcx,%rax,8)
movq 0x40(%rbx), %rcx
movl %ebp, (%rcx,%rax,4)
movl 0x80(%rbx), %eax
movq 0x48(%rbx), %rcx
movslq 0x50(%rbx), %rdx
movl %eax, (%rcx,%rdx,4)
incl 0x50(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
movq %r14, %rsi
callq 0xc656
nop
// File: /workspace/github_cpp_makefile_star2_O2/JenTus[P]TCEM/src_TCEM/anyoption.cc
// Function: AnyOption::addOption(char, int)
void
AnyOption::addOption( char opt, int type )
{
	if( !POSIX() ){
		printVerbose("Ignoring the option character \"");
		printVerbose(  opt );
		printVerbose( "\" ( POSIX options are turned off )" );
		printVerbose();
		return;
	}


	if( optchar_counter >= max_char_options ){
		if( doubleCharStorage() == false ){
			addOptionError( opt );
			return;
		}
	}
	optionchars[ optchar_counter ] =  opt ;
	optchartype[ optchar_counter ] =  type ;
	optcharindex[ optchar_counter ] = g_value_counter; 
	optchar_counter++;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
cmpb $0x0, 0x9b(%rdi)
je 0xc447
movl %edx, %r14d
movl 0x70(%rbx), %eax
cmpl 0x54(%rbx), %eax
jl 0xc418
movq %rbx, %rdi
callq 0xc162
testb %al, %al
je 0xc47d
movl 0x70(%rbx), %eax
movq 0x58(%rbx), %rcx
cltq
movb %bpl, (%rcx,%rax)
movq 0x60(%rbx), %rax
movslq 0x70(%rbx), %rcx
movl %r14d, (%rax,%rcx,4)
movl 0x80(%rbx), %eax
movq 0x68(%rbx), %rcx
movslq 0x70(%rbx), %rdx
movl %eax, (%rcx,%rdx,4)
incl 0x70(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x2312(%rip), %rsi      # 0xe760
movq %rbx, %rdi
callq 0xc2ea
movsbl %bpl, %esi
movq %rbx, %rdi
callq 0xc316
leaq 0x2317(%rip), %rsi      # 0xe780
movq %rbx, %rdi
callq 0xc2ea
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xc2d4
movsbl %bpl, %esi
callq 0xc6da
// File: /workspace/github_cpp_makefile_star2_O2/JenTus[P]TCEM/src_TCEM/anyoption.cc
// Function: AnyOption::addOptionError(char const*)
void
AnyOption::addOptionError( const char *opt )
{
	cout << endl ;
	cout << "OPTIONS ERROR : Failed allocating extra memory " << endl ;
	cout << "While adding the option : \""<< opt << "\"" << endl;
	cout << "Exiting." << endl ;
	cout << endl ;
	exit(0);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq 0x8974(%rip), %rbx      # 0x14fd8
movq %rbx, %rdi
callq 0x3150
leaq 0x2130(%rip), %rsi      # 0xe7a3
movq %rbx, %rdi
callq 0x32c0
movq %rax, %rdi
callq 0x3150
leaq 0x2149(%rip), %rsi      # 0xe7d3
movq %rbx, %rdi
callq 0x32c0
movq %rax, %rdi
movq %r14, %rsi
callq 0x32c0
leaq 0x220d(%rip), %rsi      # 0xe8b1
movq %rax, %rdi
callq 0x32c0
movq %rax, %rdi
callq 0x3150
leaq 0x209c(%rip), %rsi      # 0xe757
movq %rbx, %rdi
callq 0x32c0
movq %rax, %rdi
callq 0x3150
movq %rbx, %rdi
callq 0x3150
xorl %edi, %edi
callq 0x3360
// File: /workspace/github_cpp_makefile_star2_O2/JenTus[P]TCEM/src_TCEM/anyoption.cc
// Function: AnyOption::addOptionError(char)
void
AnyOption::addOptionError( char opt )
{
	cout << endl ;
	cout << "OPTIONS ERROR : Failed allocating extra memory " << endl ;
	cout << "While adding the option: \""<< opt << "\"" << endl;
	cout << "Exiting." << endl ;
	cout << endl ;
	exit(0);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq 0x88f2(%rip), %rbx      # 0x14fd8
movq %rbx, %rdi
callq 0x3150
leaq 0x20ae(%rip), %rsi      # 0xe7a3
movq %rbx, %rdi
callq 0x32c0
movq %rax, %rdi
callq 0x3150
leaq 0x20e3(%rip), %rsi      # 0xe7ef
movq %rbx, %rdi
callq 0x32c0
movq %rax, %rdi
movl %ebp, %esi
callq 0x3340
leaq 0x218c(%rip), %rsi      # 0xe8b1
movq %rax, %rdi
callq 0x32c0
movq %rax, %rdi
callq 0x3150
leaq 0x201b(%rip), %rsi      # 0xe757
movq %rbx, %rdi
callq 0x32c0
movq %rax, %rdi
callq 0x3150
movq %rbx, %rdi
callq 0x3150
xorl %edi, %edi
callq 0x3360
nop
// File: /workspace/github_cpp_makefile_star2_O2/JenTus[P]TCEM/src_TCEM/anyoption.cc
// Function: AnyOption::valueStoreOK()
bool
AnyOption::valueStoreOK( )
{
	int size= 0;
	if( !set ){
		if( g_value_counter > 0 ){
			size = g_value_counter * sizeof(char*);
			values = (char**)malloc( size );	
			for( int i = 0 ; i < g_value_counter ; i++)
				values[i] = NULL;
			set = true;
		}
	}
	return  set;
}

// Assembly:
movb 0xaa(%rdi), %al
testb %al, %al
jne 0xc7b8
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq 0x80(%rdi), %r14
testq %r14, %r14
jle 0xc7b1
leal (,%r14,8), %eax
movslq %eax, %rdi
callq 0x33e0
movq %rax, 0x78(%rbx)
xorl %eax, %eax
cmpq %rax, %r14
je 0xc7a8
movq 0x78(%rbx), %rcx
andq $0x0, (%rcx,%rax,8)
incq %rax
jmp 0xc795
movb $0x1, 0xaa(%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/JenTus[P]TCEM/src_TCEM/anyoption.cc
// Function: AnyOption::parseGNU(char*)
int
AnyOption::parseGNU( char *arg )
{
	int split_at = 0;
	/* if has a '=' sign get value */
	for( unsigned int i = 0 ; i < strlen(arg) ; i++ ){
		if(arg[i] ==  equalsign ){
			split_at = i ; /* store index */
			i = strlen(arg); /* get out of loop */
		}
	}
	if( split_at > 0 ){ /* it is an option value pair */
		char* tmp = (char*) malloc(  (split_at+1)*sizeof(char) );
		for( int i = 0 ; i < split_at ; i++ )
			tmp[i] = arg[i];
		tmp[split_at] = '\0';

		if ( matchOpt( tmp ) >= 0 ){
			setValue( options[matchOpt(tmp)] , arg+split_at+1 );
			free (tmp);
		}else{
			printVerbose( "Unknown command argument option : " );
			printVerbose( arg );
			printVerbose( );
			printAutoUsage();
			free (tmp);
			return -1;
		}
	}else{ /* regular options with no '=' sign  */
		return  matchOpt(arg);
	}
	return -1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x3120
movb 0xa4(%rbx), %cl
xorl %r12d, %r12d
xorl %edx, %edx
movl %edx, %edx
cmpq %rdx, %rax
jbe 0xc9b0
cmpb %cl, (%r14,%rdx)
jne 0xc9ac
movl %edx, %r12d
movl %eax, %edx
incl %edx
jmp 0xc99a
testl %r12d, %r12d
jle 0xca14
leal 0x1(%r12), %edi
callq 0x33e0
movq %rax, %r15
movl %r12d, %r12d
xorl %eax, %eax
cmpq %rax, %r12
je 0xc9d9
movb (%r14,%rax), %cl
movb %cl, (%r15,%rax)
incq %rax
jmp 0xc9c7
movb $0x0, (%r15,%r12)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xccfe
testl %eax, %eax
js 0xca28
movq 0x38(%rbx), %r13
movq %rbx, %rdi
movq %r15, %rsi
callq 0xccfe
cltq
movq (%r13,%rax,8), %rsi
leaq (%r14,%r12), %rdx
incq %rdx
movq %rbx, %rdi
callq 0xca68
jmp 0xca52
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xccfe
leaq 0x1df5(%rip), %rsi      # 0xe824
movq %rbx, %rdi
callq 0xc2ea
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc300
movq %rbx, %rdi
callq 0xc2d4
movq %rbx, %rdi
callq 0xcc6a
movq %r15, %rdi
callq 0x3350
pushq $-0x1
popq %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/JenTus[P]TCEM/src_TCEM/anyoption.cc
// Function: AnyOption::setValue(char const*, char*)
bool
AnyOption::setValue( const char *option , char *value )
{
	if( !valueStoreOK() )
		return false;
        for( int i = 0 ; i < option_counter ; i++ ){
                if( strcmp( options[i], option ) == 0 ){
                        values[ optionindex[i] ] = (char*) malloc((strlen(value)+1)*sizeof(char));
                        strcpy( values[ optionindex[i] ], value );
			return true;
		}
        }
        return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
callq 0xc762
xorl %r14d, %r14d
testb %al, %al
je 0xcb04
movq %rbx, (%rsp)
movslq 0x50(%r15), %r13
movq 0x38(%r15), %rbp
testl %r13d, %r13d
movl $0x0, %ebx
cmovgl %r13d, %ebx
cmpq %r14, %rbx
je 0xcafd
movq (%rbp,%r14,8), %rdi
movq %r12, %rsi
callq 0x3420
incq %r14
testl %eax, %eax
jne 0xcaa0
movq (%rsp), %rbx
movq %rbx, %rdi
callq 0x3120
leaq 0x1(%rax), %rdi
callq 0x33e0
movq 0x48(%r15), %rcx
movq 0x78(%r15), %rdx
movslq -0x4(%rcx,%r14,4), %rcx
movq %rax, (%rdx,%rcx,8)
movq 0x48(%r15), %rax
movq 0x78(%r15), %rcx
movslq -0x4(%rax,%r14,4), %rax
movq (%rcx,%rax,8), %rdi
movq %rbx, %rsi
callq 0x32a0
movb $0x1, %r14b
jmp 0xcb04
cmpq %r13, %r14
setl %r14b
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq