LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/KellerMartins[P]PDS2-Pacman/source/graphics/ui.cpp
// Function: UI::GetImage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Texture2D& GetImage(std::string path){
        auto imageIt = _images.find(path);
        if(imageIt == _images.end()){
            Texture2D& imageTex = _images[path];

            imageTex = LoadTexture(path.c_str());
            SetTextureFilter(imageTex, FILTER_TRILINEAR);
            GenTextureMipmaps(&imageTex);
        }

        return _images[path];
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x2053f9(%rip), %rdi    # 0x2155a0
movq %rbx, %rsi
callq 0x10c58
leaq 0x2053f2(%rip), %rcx    # 0x2155a8
cmpq %rcx, %rax
jne 0x1021c
leaq 0x2053de(%rip), %rdi    # 0x2155a0
movq %rbx, %rsi
callq 0x10a02
movq %rax, %r14
movq (%rbx), %rsi
leaq -0x44(%rbp), %r15
movq %r15, %rdi
callq 0x6fb0d
movl 0x10(%r15), %eax
movl %eax, 0x10(%r14)
movups (%r15), %xmm0
movups %xmm0, (%r14)
movups (%r14), %xmm0
movaps %xmm0, -0x30(%rbp)
movl 0x10(%r14), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, 0x10(%rsp)
movaps -0x30(%rbp), %xmm0
movups %xmm0, (%rsp)
movl $0x2, %edi
callq 0x7702b
movq %r14, %rdi
callq 0x77011
leaq 0x20537d(%rip), %rdi    # 0x2155a0
movq %rbx, %rsi
callq 0x10a02
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/KellerMartins[P]PDS2-Pacman/source/graphics/ui.cpp
// Function: UI::SetFont(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void SetFont(std::string fontPath){
        if(_loadedFont)
            UnloadFont(_font);
        
        _loadedFont = true;
        _font = LoadFont(fontPath.c_str());
        SetTextureFilter(_font.texture, FILTER_TRILINEAR);
        GenTextureMipmaps(&_font.texture);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
cmpb $0x1, 0x205337(%rip)    # 0x215580
jne 0x10273
movq 0x205326(%rip), %rax    # 0x215578
movq %rax, 0x20(%rsp)
movups 0x20530a(%rip), %xmm0   # 0x215568
movups %xmm0, 0x10(%rsp)
movups 0x2052ee(%rip), %xmm0   # 0x215558
movups %xmm0, (%rsp)
callq 0x5ce6d
movb $0x1, 0x205306(%rip)    # 0x215580
movq (%rbx), %rsi
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x5bb05
movq 0x20(%rbx), %rax
movq %rax, 0x2052e4(%rip)    # 0x215578
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups %xmm1, 0x2052c6(%rip)   # 0x215568
movups %xmm0, 0x2052af(%rip)   # 0x215558
leaq 0x2052a8(%rip), %rbx    # 0x215558
movl 0x2052b2(%rip), %eax    # 0x215568
movl %eax, 0x10(%rsp)
movups 0x205297(%rip), %xmm0   # 0x215558
movups %xmm0, (%rsp)
movl $0x2, %edi
callq 0x7702b
movq %rbx, %rdi
callq 0x77011
addq $0x58, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/KellerMartins[P]PDS2-Pacman/source/graphics/ui.cpp
// Function: UIElement::UIElement(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, float, float, float, float)
UIElement(std::string ImagePath, float X, float Y, float Width, float Height){
        string = ImagePath;
        type = ElementType::UIImage;
        x = X;
        y = Y;
        width = Width;
        height = Height;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movss %xmm3, -0x28(%rbp)
movss %xmm2, -0x24(%rbp)
movss %xmm1, -0x20(%rbp)
movss %xmm0, -0x1c(%rbp)
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
leaq 0x28(%rdi), %r15
movq %r15, 0x18(%rdi)
movq $0x0, 0x20(%rdi)
movb $0x0, 0x28(%rdi)
movq %r14, %rdi
callq 0x8470
movl $0x2, (%rbx)
movss -0x1c(%rbp), %xmm0
movss %xmm0, 0x4(%rbx)
movss -0x20(%rbp), %xmm0
movss %xmm0, 0x8(%rbx)
movss -0x24(%rbp), %xmm0
movss %xmm0, 0xc(%rbx)
movss -0x28(%rbp), %xmm0
movss %xmm0, 0x10(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%r14), %rdi
cmpq %r15, %rdi
je 0x10b15
movq (%r15), %rsi
incq %rsi
callq 0x8880
movq %rbx, %rdi
callq 0x8ea0
nop
// File: /workspace/github_cpp_makefile_star2_O1/KellerMartins[P]PDS2-Pacman/source/graphics/ui.cpp
// Function: UIElement::UIElement(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, float, float, float, float, Color, bool)
UIElement(std::string Text, float X, float Y, float Size, float Spacing, Color ColorTint, bool Centered){
        colorTint = ColorTint;
        string = Text;
        type = Centered? ElementType::UITextCentered : ElementType::UIText;
        x = X;
        y = Y;
        width = Spacing;
        height = Size;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebx
movss %xmm3, -0x2c(%rbp)
movss %xmm2, -0x30(%rbp)
movss %xmm1, -0x28(%rbp)
movss %xmm0, -0x24(%rbp)
movq %rdi, %r14
leaq 0x18(%rdi), %r15
leaq 0x28(%rdi), %r12
movq %r12, 0x18(%rdi)
movq $0x0, 0x20(%rdi)
movb $0x0, 0x28(%rdi)
movl %edx, 0x38(%rdi)
movq %r15, %rdi
callq 0x8470
movzbl %bl, %eax
movl %eax, (%r14)
movss -0x24(%rbp), %xmm0
movss %xmm0, 0x4(%r14)
movss -0x28(%rbp), %xmm0
movss %xmm0, 0x8(%r14)
movss -0x2c(%rbp), %xmm0
movss %xmm0, 0xc(%r14)
movss -0x30(%rbp), %xmm0
movss %xmm0, 0x10(%r14)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x10bbf
movq (%r12), %rsi
incq %rsi
callq 0x8880
movq %rbx, %rdi
callq 0x8ea0
nop
// File: /workspace/github_cpp_makefile_star2_O1/KellerMartins[P]PDS2-Pacman/source/game/enemies/blinky.cpp
// Function: Blinky::SetGoal(int&, int&, int, int, int, int)
void Blinky::SetGoal(int &goalX, int &goalY, int pacX, int pacY,int dirX, int dirY){
    if(_alive){
        if(!_scared){
            //Depois de um tempo o fantasma vai para o seu canto
            if(_scatter){
                goalX = 1;
                goalY = 1;
                if(_timerScatter > 0){
                    _timerScatter -= 5*GetFrameTime();
                    
                }
            }else{
                //segue o pacman
                goalX = pacX;
                goalY = pacY;
            }
        }else{
            //Quando ele esta com medo ele tambem vai para o seu canto
            goalX = 1;
            goalY = 1;
        }
    }else{
        goalX = 10;
        goalY = 10;
    }
}

// Assembly:
cmpb $0x1, 0x2d9(%rdi)
jne 0x11342
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0xc8af7(%rip), %rax     # 0xd9e29
cmpb $0x0, (%rax)
je 0x1134c
movl $0x1, %eax
movl %eax, (%rsi)
movl %eax, (%rdx)
jmp 0x11395
movl $0xa, %eax
movl %eax, (%rsi)
movl %eax, (%rdx)
retq
movq %rdi, %rbx
cmpb $0x1, 0x2d8(%rdi)
jne 0x11390
movl $0x1, %eax
movl %eax, (%rsi)
movl %eax, (%rdx)
movss 0x2e8(%rbx), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x11395
callq 0x2f3b6
mulss 0x88442(%rip), %xmm0    # 0x997c0
addss 0x2e8(%rbx), %xmm0
movss %xmm0, 0x2e8(%rbx)
jmp 0x11395
movl %ecx, (%rsi)
movl %r8d, (%rdx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/KellerMartins[P]PDS2-Pacman/source/game/enemies/clyde.cpp
// Function: Clyde::SetGoal(int&, int&, int, int, int, int)
void Clyde::SetGoal(int &goalX, int &goalY, int pacX, int pacY,int dirX, int dirY){
    if(_alive){
        if(!_scared){
            if(_scatter){
                goalX = LARGURA - 2;
                goalY = ALTURA - 2;
                if(_timerScatter > 0){
                    _timerScatter -= 5*GetFrameTime();
                    
                }
            }//Se a distancia entre o Clyde e o pacman for menor que 8 ele volta pro cantinho dele
            else if(abs(pacX - _x) + abs(pacY - _y) >= 8){
                goalX = pacX;
                goalY = pacY;
            }
            else{
                goalX = LARGURA - 2;
                goalY = ALTURA - 2;    
            }
        }else{
            goalX = LARGURA - 2;
            goalY = ALTURA - 2;
        }
    }else{
        goalX = 10;
        goalY = 10;
    }
}

// Assembly:
cmpb $0x1, 0x2d9(%rdi)
jne 0x1142a
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0xc8a17(%rip), %rax     # 0xd9e29
cmpb $0x0, (%rax)
je 0x11434
movl $0x13, (%rsi)
movl $0x19, (%rdx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl $0xa, %eax
movl %eax, (%rsi)
movl %eax, (%rdx)
retq
movq %rdi, %rbx
cmpb $0x1, 0x2d8(%rdi)
jne 0x1147b
movl $0x13, (%rsi)
movl $0x19, (%rdx)
movss 0x2e8(%rbx), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x11423
callq 0x2f3b6
mulss 0x88357(%rip), %xmm0    # 0x997c0
addss 0x2e8(%rbx), %xmm0
movss %xmm0, 0x2e8(%rbx)
jmp 0x11423
movl %ecx, %eax
subl 0x2c8(%rbx), %eax
movl %eax, %edi
negl %edi
cmovsl %eax, %edi
movl %r8d, %eax
subl 0x2cc(%rbx), %eax
movl %eax, %r9d
negl %r9d
cmovsl %eax, %r9d
addl %edi, %r9d
cmpl $0x8, %r9d
jb 0x11417
movl %ecx, (%rsi)
movl %r8d, (%rdx)
jmp 0x11423
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1153d
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0xc88ff(%rip), %rax     # 0xd9e29
cmpb $0x0, (%rax)
je 0x11547
movl $0x1, (%rsi)
movl $0x19, (%rdx)
jmp 0x115b1
movl $0xa, %eax
movl %eax, (%rsi)
movl %eax, (%rdx)
retq
movq %rdi, %rbx
cmpb $0x1, 0x2d8(%rdi)
jne 0x1158e
movl $0x1, (%rsi)
movl $0x19, (%rdx)
movss 0x2e8(%rbx), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x115b1
callq 0x2f3b6
mulss 0x88244(%rip), %xmm0    # 0x997c0
addss 0x2e8(%rbx), %xmm0
movss %xmm0, 0x2e8(%rbx)
jmp 0x115b1
movl 0x10(%rbp), %eax
movl %r9d, %edi
xorl $0x1, %edi
orl %eax, %edi
jne 0x115a0
addl $0x3, %ecx
jmp 0x115ac
movl %r9d, %edi
notl %edi
orl %eax, %edi
jne 0x115b8
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 0x115c9
movl %ecx, (%rsi)
addl $-0x3, %r8d
jmp 0x115ae
xorl $0x1, %eax
orl %eax, %r9d
jne 0x115b1
movl %ecx, (%rsi)
addl $0x3, %r8d
jmp 0x115ae
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x11665
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0xc87d7(%rip), %rax     # 0xd9e29
cmpb $0x0, (%rax)
je 0x1166f
movl $0x13, (%rsi)
movl $0x1, (%rdx)
jmp 0x116d9
movl $0xa, %eax
movl %eax, (%rsi)
movl %eax, (%rdx)
retq
movq %rdi, %rbx
cmpb $0x1, 0x2d8(%rdi)
jne 0x116b6
movl $0x13, (%rsi)
movl $0x1, (%rdx)
movss 0x2e8(%rbx), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x116d9
callq 0x2f3b6
mulss 0x8811c(%rip), %xmm0    # 0x997c0
addss 0x2e8(%rbx), %xmm0
movss %xmm0, 0x2e8(%rbx)
jmp 0x116d9
movl 0x10(%rbp), %eax
movl %r9d, %edi
xorl $0x1, %edi
orl %eax, %edi
jne 0x116c8
addl $0x2, %ecx
jmp 0x116d4
movl %r9d, %edi
notl %edi
orl %eax, %edi
jne 0x116e0
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 0x116f1
movl %ecx, (%rsi)
addl $-0x2, %r8d
jmp 0x116d6
xorl $0x1, %eax
orl %eax, %r9d
jne 0x116d9
movl %ecx, (%rsi)
addl $0x2, %r8d
jmp 0x116d6
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
leaq 0x3(%rsp), %rdx
movq %rbx, %rsi
callq 0x3110
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movl $0x8, %edx
callq 0x3540
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa9eb
callq 0x32c0
leaq 0x28(%rsp), %rdi
leaq 0x4(%rsp), %rsi
callq 0x3190
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
je 0xaa44
movq 0xd5c9(%rip), %r14      # 0x17fd8
leaq 0x7ad8(%rip), %rsi      # 0x124ee
movl $0x7, %edx
movq %r14, %rdi
callq 0x3340
testq %rbx, %rbx
je 0xaa4a
movq %rbx, %rdi
callq 0x3130
movq 0xd5a1(%rip), %rdi      # 0x17fd8
movq %rbx, %rsi
movq %rax, %rdx
callq 0x3340
jmp 0xaa62
movl 0x4(%rsp), %ebx
jmp 0xaab2
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x3560
movq 0xd56f(%rip), %r14      # 0x17fd8
leaq 0x7a86(%rip), %rsi      # 0x124f6
movl $0x11, %edx
movq %r14, %rdi
callq 0x3340
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x32d0
movsbl %al, %esi
movq 0xd53d(%rip), %rdi      # 0x17fd8
callq 0x3030
movq %rax, %rdi
callq 0x31e0
movq %rbx, %rdi
callq 0x34d0
movl %eax, %ebx
movq 0xd50f(%rip), %rsi      # 0x17fc8
leaq 0x28(%rsp), %rdi
callq 0x3450
leaq 0xa0(%rsp), %rdi
callq 0x30e0
movl %ebx, %eax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xab1b
callq 0x32c0
jmp 0xab1b
movq %rax, %rbx
jmp 0xab1b
movq %rax, %rbx
movq 0xd4c4(%rip), %rsi      # 0x17fc8
leaq 0x28(%rsp), %rdi
callq 0x3450
leaq 0xa0(%rsp), %rdi
callq 0x30e0
movq %rbx, %rdi
callq 0x35c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %r14, %rdi
movl $0x8, %edx
callq 0x3540
leaq 0x38(%rsp), %rdi
movq %r14, %rsi
callq 0xce54
xorl %eax, %eax
leaq 0x20(%rsp), %r14
movq %rax, -0x18(%r14)
movq %r14, -0x10(%r14)
movq %rax, -0x8(%r14)
movb %al, (%r14)
movb %al, 0x10(%r14)
leaq 0x38(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movq %rbx, %rdx
callq 0xccb4
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0xb26d
callq 0x32c0
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb280
callq 0x32c0
movq 0xcd41(%rip), %rsi      # 0x17fc8
leaq 0x68(%rsp), %rdi
callq 0x3450
leaq 0xe0(%rsp), %rdi
callq 0x30e0
addq $0x1e8, %rsp            # imm = 0x1E8
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0xb2bb
callq 0x32c0
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb2d3
callq 0x32c0
jmp 0xb2d3
movq %rax, %rbx
movq 0xccee(%rip), %rsi      # 0x17fc8
leaq 0x68(%rsp), %rdi
callq 0x3450
leaq 0xe0(%rsp), %rdi
callq 0x30e0
movq %rbx, %rdi
callq 0x35c0
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %r14, %rdi
movq %rbx, %rsi
movl $0x8, %edx
callq 0x3540
leaq 0x4(%rsp), %rsi
movq %r14, %rdi
callq 0x35b0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
je 0xb3ab
movq 0xcc9b(%rip), %rdi      # 0x17fd8
leaq 0x71aa(%rip), %rsi      # 0x124ee
movl $0x7, %edx
callq 0x3340
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0xcc7c(%rip), %rdi      # 0x17fd8
callq 0x3340
movq %rax, %r14
leaq 0x718b(%rip), %rsi      # 0x124f6
movl $0x11, %edx
movq %rax, %rdi
callq 0x3340
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x32d0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31e0
movq (%rbx), %rdi
callq 0x34d0
movl %eax, %ebx
jmp 0xb3af
movl 0x4(%rsp), %ebx
movq 0xcc12(%rip), %rsi      # 0x17fc8
leaq 0x8(%rsp), %rdi
callq 0x3450
leaq 0x80(%rsp), %rdi
callq 0x30e0
movl %ebx, %eax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0xcbe4(%rip), %rsi      # 0x17fc8
leaq 0x8(%rsp), %rdi
callq 0x3450
leaq 0x80(%rsp), %rdi
callq 0x30e0
movq %rbx, %rdi
callq 0x35c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x32a0
movq (%r14), %rax
subq %rbx, %rax
cvtsi2ss %rax, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x28, %rsp
movq %rcx, %rbx
movl %edx, %r14d
movq %rsi, (%rsp)
movq %rdi, %r12
movq (%rcx), %rsi
movq 0x8(%rcx), %rcx
xorl %r15d, %r15d
xorl %edx, %edx
callq 0x3550
movq %rax, %r13
movq (%rbx), %rsi
movq 0x8(%rbx), %rcx
movq %r12, %rdi
movq %rax, %rdx
callq 0x34a0
movq %rax, %rbp
andq %r13, %rax
cmpq $-0x1, %rax
je 0xda2e
testl %r14d, %r14d
cmovlel %r15d, %r14d
cmpq %r15, %r14
je 0xda3d
movq %rbp, %rcx
subq %r13, %rcx
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x3300
movq 0x8(%rsp), %r13
movq %r13, %rdi
callq 0x33c0
cvtsd2ss %xmm0, %xmm0
movq (%rsp), %rax
movss %xmm0, (%rax,%r15,4)
leaq 0x18(%rsp), %rax
cmpq %rax, %r13
je 0xd9f4
movq %r13, %rdi
callq 0x32c0
movq (%rbx), %rsi
movq 0x8(%rbx), %rcx
movq %r12, %rdi
movq %rbp, %rdx
callq 0x3550
movq %rax, %r13
movq (%rbx), %rsi
movq 0x8(%rbx), %rcx
movq %r12, %rdi
movq %rax, %rdx
callq 0x34a0
movq %rax, %rbp
andq %r13, %rax
incq %r15
cmpq $-0x1, %rax
jne 0xd9a8
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xa594(%rip), %rdi      # 0x17fd8
leaq 0x4ccc(%rip), %rsi      # 0x12717
callq 0x32e0
movq %rax, %rdi
callq 0x3150
movl $0x1, %edi
callq 0x3390
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x3130
movq %rax, %r14
testq %rax, %rax
je 0xdc46
movzbl -0x1(%rbx,%r14), %edi
callq 0x3050
testl %eax, %eax
je 0xdc46
decq %r14
jne 0xdc2f
xorl %r14d, %r14d
movb $0x0, (%rbx,%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/JenTus[P]TCEM/src_TCEM/utils.cc
// Function: ltrim(char*)
void ltrim(char *str) {
	size_t n;
	n = 0;
	while (str[n] != '\0' && isspace((unsigned char)str[n])) {
		n++;
	}
	memmove(str, str + n, strlen(str) - n + 1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movb (%rdi), %al
xorl %r15d, %r15d
testb %al, %al
je 0xdc7a
movzbl %al, %edi
callq 0x3050
testl %eax, %eax
je 0xdc7a
movb 0x1(%rbx,%r15), %al
incq %r15
jmp 0xdc60
leaq (%rbx,%r15), %r14
movq %rbx, %rdi
callq 0x3130
subq %r15, %rax
leaq 0x1(%rax), %rdx
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x3510
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rsi), %r12
movq 0x8(%rsi), %r13
cmpq %r13, %r12
je 0xdd08
movq %r13, %rax
subq %r12, %rax
sarq $0x2, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r12, %rdi
movq %r13, %rsi
callq 0xc229
movq %r12, %rdi
movq %r13, %rsi
callq 0xc30c
movq (%r14), %r12
movq 0x8(%r14), %r13
cmpq %r13, %r12
je 0xdd41
movq %r13, %rax
subq %r12, %rax
sarq $0x2, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r12, %rdi
movq %r13, %rsi
callq 0xc229
movq %r12, %rdi
movq %r13, %rsi
callq 0xc30c
movq (%r15), %rdi
movq 0x8(%r15), %rsi
movq (%r14), %rdx
movq 0x8(%r14), %rcx
movq %rbx, %r8
callq 0xddfd
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xdd74
callq 0x32c0
movq %r14, %rdi
callq 0x35c0
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpq %rcx, %rdx
jge 0xe0a1
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x18(%rdi), %r13
movq %rsp, %rbp
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq %r13, %rdi
movq %rbp, %rsi
callq 0xab56
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xe087
callq 0x32c0
movq (%r15), %rax
movl (%rax,%r14,4), %esi
movq %r12, %rdi
movq %r14, %rdx
callq 0xe0ca
incq %r14
cmpq %r14, %rbx
jne 0xe05e
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xe0c1
callq 0x32c0
movq %rbx, %rdi
callq 0x35c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3380
movq 0x40(%rbx), %rdi
callq 0x3380
movq 0x48(%rbx), %rdi
callq 0x3380
movq 0x58(%rbx), %rdi
callq 0x3380
movq 0x60(%rbx), %rdi
callq 0x3380
movq 0x68(%rbx), %rdi
callq 0x3380
movq 0x88(%rbx), %rdi
callq 0x3380
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0xeaa0
callq 0x3380
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0xeaaf
popq %rbx
jmp 0x3380
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xeabe
movb $0x1, %al
retq
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq 0x30(%rdi), %r14
leal 0x8(,%r14,8), %eax
movslq %eax, %rdi
callq 0x3400
movq %rax, %r15
movq %rax, 0x38(%rbx)
leaq 0x4(,%r14,4), %r12
movq %r12, %rdi
callq 0x3400
movq %rax, %r14
movq %rax, 0x40(%rbx)
movq %r12, %rdi
callq 0x3400
movq %rax, %rcx
movq %rax, 0x48(%rbx)
xorl %eax, %eax
testq %r15, %r15
je 0xec33
testq %r14, %r14
je 0xec33
testq %rcx, %rcx
je 0xec33
movb $0x1, 0x9a(%rbx)
cmpl $0x0, 0x30(%rbx)
jle 0xeb64
xorl %eax, %eax
movq 0x38(%rbx), %rcx
movq $0x0, (%rcx,%rax,8)
movq 0x40(%rbx), %rcx
movl $0x0, (%rcx,%rax,4)
movq 0x48(%rbx), %rcx
movl $0xffffffff, (%rcx,%rax,4) # imm = 0xFFFFFFFF
incq %rax
movslq 0x30(%rbx), %rcx
cmpq %rcx, %rax
jl 0xeb36
movslq 0x54(%rbx), %r15
leaq 0x1(%r15), %rdi
callq 0x3400
movq %rax, %r14
movq %rax, 0x58(%rbx)
leaq 0x4(,%r15,4), %r15
movq %r15, %rdi
callq 0x3400
movq %rax, %r12
movq %rax, 0x60(%rbx)
movq %r15, %rdi
callq 0x3400
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 0xec2a
cmpl $0x0, 0x54(%rbx)
jle 0xebe5
xorl %eax, %eax
movq 0x58(%rbx), %rcx
movb $0x30, (%rcx,%rax)
movq 0x60(%rbx), %rcx
movl $0x0, (%rcx,%rax,4)
movq 0x68(%rbx), %rcx
movl $0xffffffff, (%rcx,%rax,4) # imm = 0xFFFFFFFF
incq %rax
movslq 0x54(%rbx), %rcx
cmpq %rcx, %rax
jl 0xebbb
movl 0x90(%rbx), %r14d
leal 0x8(,%r14,8), %eax
movslq %eax, %rdi
callq 0x3400
movq %rax, 0x88(%rbx)
testq %rax, %rax
je 0xec2a
testl %r14d, %r14d
jle 0xec26
xorl %eax, %eax
movq 0x88(%rbx), %rcx
movq $0x0, (%rcx,%rax,8)
incq %rax
cmpq %rax, %r14
jne 0xec0f
movb $0x1, %al
jmp 0xec33
movb $0x0, 0x9a(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3530
movq %rax, 0x38(%rbx)
movq 0x40(%rbx), %rdi
movslq 0x30(%rbx), %rax
leaq 0x4(,%rax,8), %rsi
callq 0x3530
movq %rax, 0x40(%rbx)
movq 0x48(%rbx), %rdi
movslq 0x30(%rbx), %rax
leaq 0x4(,%rax,8), %rsi
callq 0x3530
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 0xecec
movslq 0x30(%rbx), %rcx
leal (%rcx,%rcx), %edx
cmpl %edx, %ecx
jge 0xece9
movq 0x38(%rbx), %rdx
movq $0x0, (%rdx,%rcx,8)
movq 0x40(%rbx), %rdx
movl $0x0, (%rdx,%rcx,4)
movq 0x48(%rbx), %rdx
movl $0xffffffff, (%rdx,%rcx,4) # imm = 0xFFFFFFFF
incq %rcx
movslq 0x30(%rbx), %rdx
addq %rdx, %rdx
cmpq %rdx, %rcx
jl 0xecb8
movl %edx, 0x30(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3530
movq %rax, 0x58(%rbx)
movq 0x60(%rbx), %rdi
movslq 0x54(%rbx), %rax
leaq 0x4(,%rax,8), %rsi
callq 0x3530
movq %rax, 0x60(%rbx)
movq 0x68(%rbx), %rdi
movslq 0x54(%rbx), %rax
leaq 0x4(,%rax,8), %rsi
callq 0x3530
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 0xed96
movslq 0x54(%rbx), %rcx
leal (%rcx,%rcx), %edx
cmpl %edx, %ecx
jge 0xed93
movq 0x58(%rbx), %rdx
movb $0x30, (%rdx,%rcx)
movq 0x60(%rbx), %rdx
movl $0x0, (%rdx,%rcx,4)
movq 0x68(%rbx), %rdx
movl $0xffffffff, (%rdx,%rcx,4) # imm = 0xFFFFFFFF
incq %rcx
movslq 0x54(%rbx), %rdx
addq %rdx, %rdx
cmpq %rdx, %rcx
jl 0xed66
movl %edx, 0x54(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3530
movq %rax, 0x88(%rbx)
testq %rax, %rax
je 0xedef
movslq 0x90(%rbx), %rcx
leaq (%rcx,%rcx), %rdx
cmpl %edx, %ecx
jge 0xede9
movq 0x88(%rbx), %rsi
movq $0x0, (%rsi,%rcx,8)
incq %rcx
cmpq %rcx, %rdx
jne 0xedd2
movl %edx, 0x90(%rbx)
testq %rax, %rax
setne %al
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xefa0
movb $0x1, 0xac(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xefe4
movq %rbx, %rdi
callq 0xec40
testb %al, %al
je 0xf010
movq 0x38(%rbx), %rax
movslq 0x50(%rbx), %rcx
movq %r14, (%rax,%rcx,8)
movq 0x40(%rbx), %rax
movl %ebp, (%rax,%rcx,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 0xf2ec
// File: /workspace/github_cpp_makefile_star2_O1/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
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %rbx
cmpb $0x0, 0x9b(%rdi)
je 0xf089
movl %edx, %r14d
movl 0x70(%rbx), %eax
cmpl 0x54(%rbx), %eax
jl 0xf05b
movq %rbx, %rdi
callq 0xecee
testb %al, %al
je 0xf0da
movq 0x58(%rbx), %rax
movslq 0x70(%rbx), %rcx
movb %bpl, (%rax,%rcx)
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)
jmp 0xf0d1
leaq 0x3730(%rip), %rsi      # 0x127c0
movq %rbx, %rdi
callq 0xeea8
cmpb $0x1, 0x9c(%rbx)
jne 0xf0ba
leaq 0xf(%rsp), %rsi
movb %bpl, (%rsi)
movq 0x8f28(%rip), %rdi      # 0x17fd8
movl $0x1, %edx
callq 0x3340
leaq 0x371f(%rip), %rsi      # 0x127e0
movq %rbx, %rdi
callq 0xeea8
movq %rbx, %rdi
callq 0xee6e
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movsbl %bpl, %esi
callq 0xf370
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8cde(%rip), %rbx      # 0x17fd8
movq %rbx, %rdi
callq 0x3150
leaq 0x34fa(%rip), %rsi      # 0x12803
movq %rbx, %rdi
callq 0x32e0
movq %rax, %rdi
callq 0x3150
leaq 0x3513(%rip), %rsi      # 0x12833
movq %rbx, %rdi
callq 0x32e0
movq %rax, %rdi
movq %r14, %rsi
callq 0x32e0
leaq 0x35d7(%rip), %rsi      # 0x12911
movq %rax, %rdi
callq 0x32e0
movq %rax, %rdi
callq 0x3150
leaq 0x3466(%rip), %rsi      # 0x127b7
movq %rbx, %rdi
callq 0x32e0
movq %rax, %rdi
callq 0x3150
movq %rbx, %rdi
callq 0x3150
xorl %edi, %edi
callq 0x3390
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8c5c(%rip), %rbx      # 0x17fd8
movq %rbx, %rdi
callq 0x3150
leaq 0x3478(%rip), %rsi      # 0x12803
movq %rbx, %rdi
callq 0x32e0
movq %rax, %rdi
callq 0x3150
leaq 0x34ad(%rip), %rsi      # 0x1284f
movq %rbx, %rdi
callq 0x32e0
movq %rax, %rdi
movl %ebp, %esi
callq 0x3370
leaq 0x3556(%rip), %rsi      # 0x12911
movq %rax, %rdi
callq 0x32e0
movq %rax, %rdi
callq 0x3150
leaq 0x33e5(%rip), %rsi      # 0x127b7
movq %rbx, %rdi
callq 0x32e0
movq %rax, %rdi
callq 0x3150
movq %rbx, %rdi
callq 0x3150
xorl %edi, %edi
callq 0x3390
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x0, 0xaa(%rdi)
jne 0xf445
movslq 0x80(%rbx), %r14
testq %r14, %r14
jle 0xf445
leal (,%r14,8), %eax
movslq %eax, %rdi
callq 0x3400
movq %rax, 0x78(%rbx)
xorl %eax, %eax
movq 0x78(%rbx), %rcx
movq $0x0, (%rcx,%rax,8)
incq %rax
cmpq %rax, %r14
jne 0xf42a
movb $0x1, 0xaa(%rbx)
movb 0xaa(%rbx), %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3130
testq %rax, %rax
je 0xf68b
movb 0xa4(%rbx), %cl
xorl %edx, %edx
xorl %r12d, %r12d
cmpb %cl, (%r14,%rdx)
jne 0xf682
movl %edx, %r12d
movl %eax, %edx
incl %edx
cmpq %rdx, %rax
ja 0xf677
jmp 0xf68e
xorl %r12d, %r12d
testl %r12d, %r12d
jle 0xf6ec
leal 0x1(%r12), %edi
callq 0x3400
movq %rax, %r15
movl %r12d, %r12d
movq %rax, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x3250
movb $0x0, (%r15,%r12)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xfa92
testl %eax, %eax
js 0xf700
movq 0x38(%rbx), %r13
movq %rbx, %rdi
movq %r15, %rsi
callq 0xfa92
cltq
movq (%r13,%rax,8), %rsi
leaq (%r14,%r12), %rdx
incq %rdx
movq %rbx, %rdi
callq 0xf74a
jmp 0xf733
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xfa92
leaq 0x317d(%rip), %rsi      # 0x12884
movq %rbx, %rdi
callq 0xeea8
movq %rbx, %rdi
movq %r14, %rsi
callq 0xeef6
movq %rbx, %rdi
callq 0xee6e
cmpb $0x1, 0xad(%rbx)
jne 0xf733
movq %rbx, %rdi
callq 0x10650
movq %r15, %rdi
callq 0x3380
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, %r15
movq %rdi, %r14
callq 0xf3f8
testb %al, %al
je 0xf7b9
movslq 0x50(%r14), %r13
testq %r13, %r13
setg %bpl
jle 0xf803
movq %rbx, (%rsp)
movq 0x38(%r14), %rbx
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x3430
testl %eax, %eax
je 0xf7bd
movl $0x1, %r12d
cmpq %r12, %r13
je 0xf7ff
movq (%rbx,%r12,8), %rdi
movq %r15, %rsi
callq 0x3430
incq %r12
testl %eax, %eax
jne 0xf795
decq %r12
cmpq %r13, %r12
setb %bpl
jmp 0xf7c0
xorl %ebp, %ebp
jmp 0xf803
xorl %r12d, %r12d
movq (%rsp), %rbx
movq %rbx, %rdi
callq 0x3130
leaq 0x1(%rax), %rdi
callq 0x3400
movq 0x48(%r14), %rcx
movq 0x78(%r14), %rdx
movslq (%rcx,%r12,4), %rcx
movq %rax, (%rdx,%rcx,8)
movq 0x48(%r14), %rax
movq 0x78(%r14), %rcx
movslq (%rax,%r12,4), %rax
movq (%rcx,%rax,8), %rdi
movq %rbx, %rsi
callq 0x32b0
jmp 0xf803
seta %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/JenTus[P]TCEM/src_TCEM/anyoption.cc
// Function: AnyOption::parsePOSIX(char*)
char 
AnyOption::parsePOSIX( char* arg )
{

	for( unsigned int i = 0 ; i < strlen(arg) ; i++ ){ 
		char ch = arg[i] ;
		if( matchChar(ch) ) { /* keep matching flags till an option */
			/*if last char argv[++i] is the value */
			if( i == strlen(arg)-1 ){ 
				return ch;
			}else{/* else the rest of arg is the value */
				i++; /* skip any '=' and ' ' */
				while( arg[i] == whitespace 
			    		|| arg[i] == equalsign )
					i++;	
				setValue( ch , arg+i );
				return '0';
			}
		}
	}
	printVerbose( "Unknown command argument option : " );
	printVerbose( arg );
	printVerbose( );
	printAutoUsage();
	return '0';
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
cmpb $0x0, (%rsi)
setne %r13b
movq %rdi, 0x10(%rsp)
je 0xf8b1
xorl %ebp, %ebp
movb (%r14,%rbp), %bl
movsbl %bl, %r12d
movl %r12d, %esi
callq 0xf9bc
movl %eax, %r15d
testb %al, %al
je 0xf892
movq %r14, %rdi
callq 0x3130
decq %rax
cmpq %rbp, %rax
jne 0xf862
movb %bl, 0xf(%rsp)
jmp 0xf892
movq 0x10(%rsp), %rdi
movb 0xa4(%rdi), %al
movb 0xa8(%rdi), %cl
incl %ebp
movb (%r14,%rbp), %dl
cmpb %cl, %dl
je 0xf873
cmpb %al, %dl
je 0xf873
leaq (%r14,%rbp), %rdx
movl %r12d, %esi
callq 0xf90a
movb $0x30, 0xf(%rsp)
testb %r15b, %r15b
jne 0xf8b1
incl %ebp
movq %r14, %rdi
callq 0x3130
cmpq %rbp, %rax
seta %r13b
movq 0x10(%rsp), %rdi
ja 0xf835
jmp 0xf8b1
testb $0x1, %r13b
movb 0xf(%rsp), %bl
jne 0xf8f8
leaq 0x2fc2(%rip), %rsi      # 0x12884
movq 0x10(%rsp), %rdi
callq 0xeea8
movq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0xeef6
movq 0x10(%rsp), %rdi
callq 0xee6e
movq 0x10(%rsp), %rdi
movb $0x30, %bl
cmpb $0x1, 0xad(%rdi)
jne 0xf8f8
callq 0x10650
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/JenTus[P]TCEM/src_TCEM/anyoption.cc
// Function: AnyOption::setValue(char, char*)
bool
AnyOption::setValue( char option , char *value )
{
	if( !valueStoreOK() )
		return false;
        for( int i = 0 ; i < optchar_counter ; i++ ){
                if( optionchars[i] == option ){
                        values[ optcharindex[i] ] = (char*) malloc((strlen(value)+1)*sizeof(char));
                        strcpy( values[ optcharindex[i] ],  value );
			return true;
		}
        }
        return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movl %esi, %r15d
movq %rdi, %r14
callq 0xf3f8
testb %al, %al
je 0xf93f
movslq 0x70(%r14), %rax
testq %rax, %rax
setg %bpl
jle 0xf9a3
movq 0x58(%r14), %rcx
cmpb %r15b, (%rcx)
jne 0xf943
xorl %r12d, %r12d
jmp 0xf964
xorl %ebp, %ebp
jmp 0xf9a3
movl $0x1, %edx
cmpq %rdx, %rax
je 0xf99f
leaq 0x1(%rdx), %r12
cmpb %r15b, (%rcx,%rdx)
movq %r12, %rdx
jne 0xf948
decq %r12
cmpq %rax, %r12
setb %bpl
movq %rbx, %rdi
callq 0x3130
leaq 0x1(%rax), %rdi
callq 0x3400
movq 0x68(%r14), %rcx
movq 0x78(%r14), %rdx
movslq (%rcx,%r12,4), %rcx
movq %rax, (%rdx,%rcx,8)
movq 0x68(%r14), %rax
movq 0x78(%r14), %rcx
movslq (%rax,%r12,4), %rax
movq (%rcx,%rax,8), %rdi
movq %rbx, %rsi
callq 0x32b0
jmp 0xf9a3
seta %bpl
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/JenTus[P]TCEM/src_TCEM/anyoption.cc
// Function: AnyOption::matchChar(char)
bool
AnyOption::matchChar( char c )
{
	for( int i = 0 ; i < optchar_counter ; i++ ){
		if( optionchars[i] == c ) { /* found match */
			if(optchartype[i] == COMMON_OPT ||
			     optchartype[i] == COMMAND_OPT )
			{ /* an option store and stop scanning */
				return true;	
			}else if( optchartype[i] == COMMON_FLAG || 
				  optchartype[i] == COMMAND_FLAG ) { /* a flag store and keep scanning */
				setFlagOn( c );
				return false;
			}
		}
	}
	printVerbose( "Unknown command argument option : " );
	printVerbose( c ) ;
	printVerbose( );
	printAutoUsage();
	return false;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movslq 0x70(%rdi), %rax
testq %rax, %rax
setg %r14b
jle 0xfa24
movq 0x58(%rbx), %rcx
movq 0x60(%rbx), %rdx
movq %rax, %rsi
negq %rsi
movl $0x1, %edi
cmpb %bpl, -0x1(%rcx,%rdi)
jne 0xfa09
movl -0x4(%rdx,%rdi,4), %r8d
leal -0x1(%r8), %r9d
cmpl $0x2, %r9d
jb 0xfa20
addl $-0x4, %r8d
cmpl $0x1, %r8d
jbe 0xfa26
cmpq %rax, %rdi
setb %r14b
leaq (%rsi,%rdi), %r8
incq %r8
incq %rdi
cmpq $0x1, %r8
jne 0xf9e9
movb $0x1, %al
jmp 0xfa34
jmp 0xfa34
movsbl %bpl, %esi
movq %rbx, %rdi
callq 0xfc14
xorl %eax, %eax
testb $0x1, %r14b
jne 0xfa86
leaq 0x2e43(%rip), %rsi      # 0x12884
movq %rbx, %rdi
callq 0xeea8
cmpb $0x1, 0x9c(%rbx)
jne 0xfa6b
leaq 0xf(%rsp), %rsi
movb %bpl, (%rsi)
movq 0x8577(%rip), %rdi      # 0x17fd8
movl $0x1, %edx
callq 0x3340
movq %rbx, %rdi
callq 0xee6e
cmpb $0x1, 0xad(%rbx)
jne 0xfa84
movq %rbx, %rdi
callq 0x10650
xorl %eax, %eax
andb $0x1, %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop