LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
subq $0x50, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
movss %xmm1, -0x18(%rbp)
movss %xmm2, -0x1c(%rbp)
movss %xmm3, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x18, %rdi
movq %rdi, -0x40(%rbp)
callq 0x9b50
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x9070
jmp 0x1b0dc
movq -0x48(%rbp), %rax
movl $0x2, (%rax)
movss -0x14(%rbp), %xmm0
movss %xmm0, 0x4(%rax)
movss -0x18(%rbp), %xmm0
movss %xmm0, 0x8(%rax)
movss -0x1c(%rbp), %xmm0
movss %xmm0, 0xc(%rax)
movss -0x20(%rbp), %xmm0
movss %xmm0, 0x10(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x9530
movq -0x28(%rbp), %rdi
callq 0x9f50
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x60, %rsp
movq %rsi, -0x48(%rbp)
movb %cl, %al
movl %edx, -0x4(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movss %xmm0, -0x1c(%rbp)
movss %xmm1, -0x20(%rbp)
movss %xmm2, -0x24(%rbp)
movss %xmm3, -0x28(%rbp)
andb $0x1, %al
movb %al, -0x29(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x58(%rbp)
addq $0x18, %rdi
movq %rdi, -0x50(%rbp)
callq 0x9b50
movq -0x58(%rbp), %rax
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movl -0x4(%rbp), %ecx
movl %ecx, 0x38(%rax)
callq 0x9070
jmp 0x1b1c0
movq -0x58(%rbp), %rax
movb -0x29(%rbp), %sil
xorl %ecx, %ecx
movl $0x1, %edx
testb $0x1, %sil
cmovnel %edx, %ecx
movl %ecx, (%rax)
movss -0x1c(%rbp), %xmm0
movss %xmm0, 0x4(%rax)
movss -0x20(%rbp), %xmm0
movss %xmm0, 0x8(%rax)
movss -0x28(%rbp), %xmm0
movss %xmm0, 0xc(%rax)
movss -0x24(%rbp), %xmm0
movss %xmm0, 0x10(%rax)
addq $0x60, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x9530
movq -0x38(%rbp), %rdi
callq 0x9f50
nopw %cs:(%rax,%rax)
nop
// File: KellerMartins[P]PDS2-Pacman/source/graphics/ui.cpp
// Function: UIElement::UIElement(float, float, float, float, Color)
UIElement(float X, float Y, float Width, float Height, Color ColorTint){
        colorTint = ColorTint;
        type = UIRect;
        x = X;
        y = Y;
        width = Width;
        height = Height;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %esi, -0x4(%rbp)
movq %rdi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
movss %xmm1, -0x18(%rbp)
movss %xmm2, -0x1c(%rbp)
movss %xmm3, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x18, %rdi
callq 0x9b50
movq -0x28(%rbp), %rax
movl -0x4(%rbp), %ecx
movl %ecx, 0x38(%rax)
movl $0x3, (%rax)
movss -0x14(%rbp), %xmm0
movss %xmm0, 0x4(%rax)
movss -0x18(%rbp), %xmm0
movss %xmm0, 0x8(%rax)
movss -0x1c(%rbp), %xmm0
movss %xmm0, 0xc(%rax)
movss -0x20(%rbp), %xmm0
movss %xmm0, 0x10(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
testb $0x1, 0x2d9(%rax)
je 0x1d19d
leaq 0xcdd7b(%rip), %rax     # 0xeae89
testb $0x1, (%rax)
jne 0x1d187
movq -0x30(%rbp), %rax
testb $0x1, 0x2d8(%rax)
je 0x1d173
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movl $0x1, (%rcx)
movq -0x18(%rbp), %rcx
movl $0x1, (%rcx)
movss 0x2e8(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x1d171
callq 0x3b476
movq -0x30(%rbp), %rax
movss 0x2e8(%rax), %xmm1
movss 0x88543(%rip), %xmm2    # 0xa56a4
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0x2e8(%rax)
jmp 0x1d185
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x20(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
jmp 0x1d19b
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
jmp 0x1d1b1
movq -0x10(%rbp), %rax
movl $0xa, (%rax)
movq -0x18(%rbp), %rax
movl $0xa, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
testb $0x1, 0x2d9(%rax)
je 0x1d374
leaq 0xcdbeb(%rip), %rax     # 0xeae89
testb $0x1, (%rax)
jne 0x1d35e
movq -0x30(%rbp), %rax
testb $0x1, 0x2d8(%rax)
je 0x1d307
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movl $0x13, (%rcx)
movq -0x18(%rbp), %rcx
movl $0x19, (%rcx)
movss 0x2e8(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x1d305
callq 0x3b476
movq -0x30(%rbp), %rax
movss 0x2e8(%rax), %xmm1
movss 0x883af(%rip), %xmm2    # 0xa56a4
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0x2e8(%rax)
jmp 0x1d35c
movq -0x30(%rbp), %rdx
movl -0x1c(%rbp), %eax
subl 0x2c8(%rdx), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movl -0x20(%rbp), %ecx
subl 0x2cc(%rdx), %ecx
movl %ecx, %edx
negl %edx
cmovnsl %edx, %ecx
addl %ecx, %eax
cmpl $0x8, %eax
jl 0x1d346
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x20(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
jmp 0x1d35a
movq -0x10(%rbp), %rax
movl $0x13, (%rax)
movq -0x18(%rbp), %rax
movl $0x19, (%rax)
jmp 0x1d35c
jmp 0x1d372
movq -0x10(%rbp), %rax
movl $0x13, (%rax)
movq -0x18(%rbp), %rax
movl $0x19, (%rax)
jmp 0x1d388
movq -0x10(%rbp), %rax
movl $0xa, (%rax)
movq -0x18(%rbp), %rax
movl $0xa, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x279fe(%rip), %rdi     # 0x2efd8
leaq 0x1cbd2(%rip), %rsi     # 0x241b3
callq 0x4370
movq %rax, %rdi
movq 0x279d8(%rip), %rsi     # 0x2efc8
callq 0x43c0
callq 0x4230
movq 0x20(%rsp), %rdi
movq %rax, 0x48(%rsp)
callq 0xb380
movsd %xmm0, 0x40(%rsp)
movq 0x279c2(%rip), %rdi     # 0x2efd8
leaq 0x1cbc2(%rip), %rsi     # 0x241df
callq 0x4370
movq %rax, %rdi
movsd 0x40(%rsp), %xmm0
callq 0x46d0
movq %rax, %rdi
movq 0x2798e(%rip), %rsi     # 0x2efc8
callq 0x43c0
movq 0x20(%rsp), %rax
movsd 0x90(%rax), %xmm0
movsd 0x1caac(%rip), %xmm1    # 0x24100
mulsd %xmm1, %xmm0
movsd 0x1caa8(%rip), %xmm1    # 0x24108
addsd %xmm1, %xmm0
cvtsi2sdl 0x68(%rax), %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0xa0(%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movl 0x68(%rax), %edi
callq 0xded0
movsd %xmm0, (%rsp)
movl $0x2, %edi
callq 0xded0
movsd (%rsp), %xmm2
movq 0x20(%rsp), %rax
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
movl 0x68(%rax), %edi
movl 0x78(%rax), %esi
movl 0x80(%rax), %edx
callq 0xdef0
movsd 0x10(%rsp), %xmm1
movq 0x20(%rsp), %rax
movaps %xmm0, %xmm2
movsd 0x18(%rsp), %xmm0
addsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
movsd 0x90(%rax), %xmm1
mulsd 0x90(%rax), %xmm1
mulsd 0x40(%rsp), %xmm1
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %rcx
movq %rcx, 0x10(%rax)
movq 0x278c8(%rip), %rdi     # 0x2efd8
leaq 0x1cae1(%rip), %rsi     # 0x241f8
callq 0x4370
movq %rax, %rdi
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x41a0
movq %rax, %rdi
movq 0x27891(%rip), %rsi     # 0x2efc8
callq 0x43c0
movq 0x20(%rsp), %rdi
movq 0x10(%rdi), %rsi
callq 0xb5d0
callq 0x4230
movq 0x20(%rsp), %rdi
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
subq 0x48(%rsp), %rax
cvtsi2sd %rax, %xmm0
movsd 0x1c988(%rip), %xmm1    # 0x240f8
divsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rdi)
cvtsi2sdl 0x68(%rdi), %xmm0
movsd %xmm0, 0x28(%rsp)
movq 0x10(%rdi), %rsi
movl $0x1, %edx
callq 0xb910
movaps %xmm0, %xmm1
movsd 0x28(%rsp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x30(%rsp), %xmm0
addq $0x58, %rsp
retq
// File: JenTus[P]TCEM/src_TCEM/sfmt/SFMT.h
// Function: sfmt_genrand_uint32(SFMT_T*)
inline static uint32_t sfmt_genrand_uint32(sfmt_t * sfmt) {
    uint32_t r;
    uint32_t * psfmt32 = &sfmt->state[0].u[0];

    if (sfmt->idx >= SFMT_N32) {
	sfmt_gen_rand_all(sfmt);
	sfmt->idx = 0;
    }
    r = psfmt32[sfmt->idx++];
    return r;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
cmpl $0x270, 0x9c0(%rax)     # imm = 0x270
jl 0xd0ac
movq 0x10(%rsp), %rdi
callq 0x21dd0
movq 0x10(%rsp), %rax
movl $0x0, 0x9c0(%rax)
movq (%rsp), %rax
movq 0x10(%rsp), %rdx
movl 0x9c0(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x9c0(%rdx)
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x208, %rsp            # imm = 0x208
movq %rdi, 0x1f8(%rsp)
movq 0x1f8(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x4f(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x4690
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
leaq 0x50(%rsp), %rdi
callq 0x44f0
jmp 0xd8b1
leaq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rsi
movl $0x8, %edx
callq 0x4610
jmp 0xd8c7
leaq 0x50(%rsp), %rdi
callq 0x41f0
leaq 0x4f(%rsp), %rdi
callq 0x43e0
leaq 0x70(%rsp), %rdi
leaq 0x1f4(%rsp), %rsi
callq 0x41e0
movq %rax, 0x20(%rsp)
jmp 0xd8f4
movq 0x20(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x4470
movb %al, 0x1f(%rsp)
jmp 0xd90e
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0xd918
jmp 0xd987
movl 0x1f4(%rsp), %eax
movl %eax, 0x204(%rsp)
movl $0x1, 0x38(%rsp)
jmp 0xd9ff
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0xd95b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x41f0
leaq 0x4f(%rsp), %rdi
callq 0x43e0
jmp 0xda18
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x4170
jmp 0xda18
movq 0x2164a(%rip), %rdi     # 0x2efd8
leaq 0x16b09(%rip), %rsi     # 0x2449e
callq 0x4370
movq %rax, 0x10(%rsp)
jmp 0xd9a1
movq 0x10(%rsp), %rdi
movq 0x1f8(%rsp), %rsi
callq 0x4370
movq %rax, 0x8(%rsp)
jmp 0xd9ba
movq 0x8(%rsp), %rdi
leaq 0x16ae0(%rip), %rsi     # 0x244a6
callq 0x4370
movq %rax, (%rsp)
jmp 0xd9d1
movq (%rsp), %rdi
movq 0x215ec(%rip), %rsi     # 0x2efc8
callq 0x43c0
jmp 0xd9e3
movq 0x1f8(%rsp), %rdi
callq 0x4580
movl %eax, 0x204(%rsp)
movl $0x1, 0x38(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x4170
movl 0x204(%rsp), %eax
addq $0x208, %rsp            # imm = 0x208
retq
movq 0x40(%rsp), %rdi
callq 0x4680
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rdi, 0x8(%rsp)
movq %rdi, 0x1b0(%rsp)
movq $0x0, 0x1a8(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x4260
movq 0x8(%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x4310
jmp 0xda6b
leaq 0x20(%rsp), %rdi
leaq 0x1a8(%rsp), %rsi
callq 0x42c0
jmp 0xda7f
movsd 0x1a8(%rsp), %xmm0
movsd %xmm0, (%rsp)
leaq 0x20(%rsp), %rdi
callq 0x4280
movsd (%rsp), %xmm0
addq $0x1b8, %rsp            # imm = 0x1B8
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x4280
movq 0x18(%rsp), %rdi
callq 0x4680
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movl %edi, 0x34(%rsp)
movl %esi, 0x30(%rsp)
movl %edx, 0x2c(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rsp)
movl 0x34(%rsp), %eax
movl 0x30(%rsp), %ecx
movl 0x2c(%rsp), %edx
addl $0x1, %edx
imull %edx, %ecx
subl %ecx, %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x34(%rsp), %eax
jg 0xdf50
movl 0x1c(%rsp), %edi
callq 0xded0
addsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0xdf24
movl $0x1, 0x18(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x30(%rsp), %eax
jg 0xdf8b
movl 0x18(%rsp), %edi
callq 0xded0
movaps %xmm0, %xmm1
movsd 0x20(%rsp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0xdf58
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rsp)
movl $0x1, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jg 0xdfc8
movl 0xc(%rsp), %edi
callq 0xded0
addsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0xdf9c
cvtsi2sdl 0x30(%rsp), %xmm0
movsd 0x10(%rsp), %xmm2
movsd 0x20(%rsp), %xmm1
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x20(%rsp), %xmm0
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x228, %rsp            # imm = 0x228
movq %rdi, 0x220(%rsp)
movq %rsi, 0x218(%rsp)
movq 0x220(%rsp), %rsi
leaq 0x98(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movl $0x8, %edx
callq 0x4610
movq 0x10(%rsp), %rsi
leaq 0x68(%rsp), %rdi
callq 0x1ada0
jmp 0xf117
leaq 0x28(%rsp), %rdi
callq 0x1ae10
jmp 0xf123
movq 0x218(%rsp), %rdi
callq 0x1ae50
movq %rax, 0x8(%rsp)
jmp 0xf137
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdx
leaq 0x68(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x1ac20
movq %rax, (%rsp)
jmp 0xf15b
movq (%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x1ae80
leaq 0x68(%rsp), %rdi
callq 0x1ae80
leaq 0x98(%rsp), %rdi
callq 0x4170
addq $0x228, %rsp            # imm = 0x228
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0xf1cf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0xf1c5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x1ae80
leaq 0x68(%rsp), %rdi
callq 0x1ae80
leaq 0x98(%rsp), %rdi
callq 0x4170
movq 0x60(%rsp), %rdi
callq 0x4680
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x1e8, %rsp            # imm = 0x1E8
movq %rdi, %rsi
movq %rsi, 0x28(%rsp)
movq %rsi, 0x1d8(%rsp)
leaq 0x50(%rsp), %rdi
movq %rdi, 0x30(%rsp)
movl $0x8, %edx
callq 0x4610
movq 0x30(%rsp), %rdi
leaq 0x1d4(%rsp), %rsi
callq 0x4060
movq %rax, 0x38(%rsp)
jmp 0xf234
movq 0x38(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x4470
movb %al, 0x27(%rsp)
jmp 0xf24e
movb 0x27(%rsp), %al
testb $0x1, %al
jne 0xf258
jmp 0xf290
movl 0x1d4(%rsp), %eax
movl %eax, 0x1e4(%rsp)
movl $0x1, 0x40(%rsp)
jmp 0xf30c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x4170
jmp 0xf325
movq 0x1fd41(%rip), %rdi     # 0x2efd8
leaq 0x15200(%rip), %rsi     # 0x2449e
callq 0x4370
movq %rax, 0x18(%rsp)
jmp 0xf2aa
movq 0x28(%rsp), %rsi
movq 0x18(%rsp), %rdi
callq 0x4310
movq %rax, 0x10(%rsp)
jmp 0xf2c0
movq 0x10(%rsp), %rdi
leaq 0x151da(%rip), %rsi     # 0x244a6
callq 0x4370
movq %rax, 0x8(%rsp)
jmp 0xf2d8
movq 0x8(%rsp), %rdi
movq 0x1fce4(%rip), %rsi     # 0x2efc8
callq 0x43c0
jmp 0xf2eb
movq 0x28(%rsp), %rdi
callq 0x4130
movq %rax, %rdi
callq 0x4580
movl %eax, 0x1e4(%rsp)
movl $0x1, 0x40(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x4170
movl 0x1e4(%rsp), %eax
addq $0x1e8, %rsp            # imm = 0x1E8
retq
movq 0x48(%rsp), %rdi
callq 0x4680
nop
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x4330
movq 0x8(%rsp), %rax
subq 0x10(%rsp), %rax
cvtsi2ss %rax, %xmm0
movss %xmm0, 0x4(%rsp)
movss 0x4(%rsp), %xmm0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movl %edx, 0x64(%rsp)
movq %rcx, 0x58(%rsp)
movq 0x70(%rsp), %rdi
movq 0x58(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x42e0
movq %rax, 0x50(%rsp)
movq 0x70(%rsp), %rdi
movq 0x58(%rsp), %rsi
movq 0x50(%rsp), %rdx
callq 0x4320
movq %rax, 0x48(%rsp)
movl $0x0, 0x44(%rsp)
movb $0x1, %al
movq $-0x1, %rcx
cmpq 0x48(%rsp), %rcx
movb %al, 0x13(%rsp)
jne 0x1c297
movq $-0x1, %rax
cmpq 0x50(%rsp), %rax
setne %al
movb %al, 0x13(%rsp)
movb 0x13(%rsp), %al
testb $0x1, %al
jne 0x1c2a4
jmp 0x1c386
movl 0x44(%rsp), %eax
cmpl 0x64(%rsp), %eax
jl 0x1c2da
movq 0x12d23(%rip), %rdi     # 0x2efd8
leaq 0x83db(%rip), %rsi      # 0x24697
callq 0x4370
movq %rax, %rdi
movq 0x12cfd(%rip), %rsi     # 0x2efc8
callq 0x43c0
movl $0x1, %edi
callq 0x4430
movq 0x70(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq 0x48(%rsp), %rcx
subq %rdx, %rcx
leaq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x43a0
movq (%rsp), %rdi
callq 0x1c9c0
movss %xmm0, 0xc(%rsp)
jmp 0x1c30b
movss 0xc(%rsp), %xmm0
movq 0x68(%rsp), %rax
movl 0x44(%rsp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x44(%rsp)
movslq %ecx, %rcx
movss %xmm0, (%rax,%rcx,4)
leaq 0x20(%rsp), %rdi
callq 0x41f0
movq 0x70(%rsp), %rdi
movq 0x58(%rsp), %rsi
movq 0x48(%rsp), %rdx
callq 0x42e0
movq %rax, 0x50(%rsp)
movq 0x70(%rsp), %rdi
movq 0x58(%rsp), %rsi
movq 0x50(%rsp), %rdx
callq 0x4320
movq %rax, 0x48(%rsp)
jmp 0x1c270
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x41f0
jmp 0x1c38b
addq $0x78, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x4680
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x4150
movq %rax, 0x8(%rsp)
xorl %eax, %eax
cmpq $0x0, 0x8(%rsp)
movb %al, 0x7(%rsp)
jbe 0x1c567
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
subq $0x1, %rcx
movzbl (%rax,%rcx), %edi
callq 0x4050
cmpl $0x0, %eax
setne %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x1c571
jmp 0x1c581
movq 0x8(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x1c538
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movb $0x0, (%rax,%rcx)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0x17(%rsp)
je 0x1c5e8
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
movzbl (%rax,%rcx), %edi
callq 0x4050
cmpl $0x0, %eax
setne %al
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x1c5f2
jmp 0x1c602
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x1c5b2
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rax
addq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x4150
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
subq 0x18(%rsp), %rdx
addq $0x1, %rdx
callq 0x45d0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0xa8, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movb $0x0, 0x8f(%rsp)
callq 0xd840
movq 0x98(%rsp), %rdi
callq 0xe890
movq %rax, 0x80(%rsp)
movq 0x98(%rsp), %rdi
callq 0xe8c0
movq %rax, 0x78(%rsp)
movq 0x80(%rsp), %rdi
movq 0x78(%rsp), %rsi
callq 0xe850
jmp 0x1c6e4
movq 0x90(%rsp), %rdi
callq 0xe890
movq %rax, 0x60(%rsp)
movq 0x90(%rsp), %rdi
callq 0xe8c0
movq %rax, 0x58(%rsp)
movq 0x60(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0xe850
jmp 0x1c719
movq 0x98(%rsp), %rdi
callq 0xe890
movq %rax, 0x50(%rsp)
movq 0x98(%rsp), %rdi
callq 0xe8c0
movq %rax, 0x48(%rsp)
movq 0x90(%rsp), %rdi
callq 0xe890
movq %rax, 0x40(%rsp)
movq 0x90(%rsp), %rdi
callq 0xe8c0
movq 0x18(%rsp), %rdi
movq %rax, 0x38(%rsp)
callq 0x1ca70
movq %rax, 0x10(%rsp)
jmp 0x1c772
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq 0x38(%rsp), %rcx
movq 0x30(%rsp), %r8
callq 0x1c9e0
movq %rax, 0x8(%rsp)
jmp 0x1c7a1
movq 0x8(%rsp), %rax
movq %rax, 0x28(%rsp)
movb $0x1, 0x8f(%rsp)
testb $0x1, 0x8f(%rsp)
jne 0x1c7e3
jmp 0x1c7d9
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
callq 0xdbe0
jmp 0x1c7f0
movq 0x18(%rsp), %rdi
callq 0xdbe0
movq 0x20(%rsp), %rax
addq $0xa8, %rsp
retq
movq 0x70(%rsp), %rdi
callq 0x4680
nopw (%rax,%rax)
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
cmpq 0x58(%rsp), %rax
jge 0x1cfe2
movq 0x18(%rsp), %rax
addq $0x18, %rax
movq %rax, 0x8(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movq $0x0, 0x40(%rsp)
leaq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xd840
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xdb70
jmp 0x1cf8b
leaq 0x30(%rsp), %rdi
callq 0xdbe0
movq 0x68(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0xe150
movq 0x18(%rsp), %rdi
movl (%rax), %esi
movq 0x50(%rsp), %rdx
callq 0x1d000
movq 0x50(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x50(%rsp)
jmp 0x1cf3c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xdbe0
jmp 0x1cfe7
addq $0x78, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x4680
nopw %cs:(%rax,%rax)
// File: JenTus[P]TCEM/src_TCEM/anyoption.cc
// Function: AnyOption::init(int, int)
void
AnyOption::init(int maxopt, int maxcharopt )
{

	max_options 	= maxopt;
	max_char_options = maxcharopt;
	max_usage_lines	= DEFAULT_MAXUSAGE;
	usage_lines	= 0 ;
	argc 		= 0;
	argv 		= NULL;
	posix_style	= true;
	verbose 	= false;
	filename 	= NULL;
	appname 	= NULL;	
	option_counter 	= 0;
	optchar_counter	= 0;
	new_argv 	= NULL;
	new_argc 	= 0 ;
	max_legal_args 	= 0 ;
	command_set 	= false;
	file_set 	= false;
	values 		= NULL;	
	g_value_counter = 0;
	mem_allocated 	= false;
	command_set 	= false;
	file_set	= false;
	opt_prefix_char     = '-';
	file_delimiter_char = ':';
	file_comment_char   = '#';
	equalsign 	= '=';
	comment       = '#' ;
	delimiter     = ':' ;
	endofline     = '\n';
	whitespace    = ' ' ;
	nullterminate = '\0';
	set = false;
	once = true;
	hasoptions = false;
	autousage = false;

	//strcpy( long_opt_prefix , "--" ); Here I change for the Wstringop-overflow
	strncpy(long_opt_prefix, "--", MAX_LONG_PREFIX_LENGTH);

	if( alloc() == false ){
		cout << endl << "OPTIONS ERROR : Failed allocating memory" ;
		cout << endl ;
		cout << "Exiting." << endl ;
		exit (0);
	}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x30(%rdi)
movl 0x8(%rsp), %eax
movl %eax, 0x54(%rdi)
movl $0x3, 0x90(%rdi)
movl $0x0, 0x94(%rdi)
movl $0x0, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x1, 0x9b(%rdi)
movb $0x0, 0x9c(%rdi)
movq $0x0, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
movl $0x0, 0x50(%rdi)
movl $0x0, 0x70(%rdi)
movq $0x0, 0x20(%rdi)
movl $0x0, 0x28(%rdi)
movl $0x0, 0x2c(%rdi)
movb $0x0, 0x98(%rdi)
movb $0x0, 0x99(%rdi)
movq $0x0, 0x78(%rdi)
movl $0x0, 0x80(%rdi)
movb $0x0, 0x9a(%rdi)
movb $0x0, 0x98(%rdi)
movb $0x0, 0x99(%rdi)
movb $0x2d, 0x9f(%rdi)
movb $0x3a, 0xa2(%rdi)
movb $0x23, 0xa3(%rdi)
movb $0x3d, 0xa4(%rdi)
movb $0x23, 0xa5(%rdi)
movb $0x3a, 0xa6(%rdi)
movb $0xa, 0xa7(%rdi)
movb $0x20, 0xa8(%rdi)
movb $0x0, 0xa9(%rdi)
movb $0x0, 0xaa(%rdi)
movb $0x1, 0xab(%rdi)
movb $0x0, 0xac(%rdi)
movb $0x0, 0xad(%rdi)
addq $0xa0, %rdi
leaq 0x5944(%rip), %rsi      # 0x2470e
movl $0x2, %edx
callq 0x4180
movq (%rsp), %rdi
callq 0x1ef70
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x1ee45
movq 0x101ea(%rip), %rdi     # 0x2efd8
movq 0x101d3(%rip), %rsi     # 0x2efc8
callq 0x43c0
movq %rax, %rdi
leaq 0x590d(%rip), %rsi      # 0x24711
callq 0x4370
movq 0x101c8(%rip), %rdi     # 0x2efd8
movq 0x101b1(%rip), %rsi     # 0x2efc8
callq 0x43c0
movq 0x101b5(%rip), %rdi     # 0x2efd8
leaq 0x5910(%rip), %rsi      # 0x2473a
callq 0x4370
movq %rax, %rdi
movq 0x1018f(%rip), %rsi     # 0x2efc8
callq 0x43c0
xorl %edi, %edi
callq 0x4430
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rax), %rdi
callq 0x4420
movq 0x8(%rsp), %rax
movq 0x40(%rax), %rdi
callq 0x4420
movq 0x8(%rsp), %rax
movq 0x48(%rax), %rdi
callq 0x4420
movq 0x8(%rsp), %rax
movq 0x58(%rax), %rdi
callq 0x4420
movq 0x8(%rsp), %rax
movq 0x60(%rax), %rdi
callq 0x4420
movq 0x8(%rsp), %rax
movq 0x68(%rax), %rdi
callq 0x4420
movq 0x8(%rsp), %rax
movq 0x88(%rax), %rdi
callq 0x4420
movq 0x8(%rsp), %rax
cmpq $0x0, 0x78(%rax)
je 0x1ef4d
movq 0x8(%rsp), %rax
movq 0x78(%rax), %rdi
callq 0x4420
movq 0x8(%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x1ef67
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x4420
addq $0x18, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rax), %rdi
movl 0x30(%rax), %eax
shll %eax
addl $0x1, %eax
movslq %eax, %rsi
shlq $0x3, %rsi
callq 0x45f0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x38(%rax)
movq 0x40(%rax), %rdi
movl 0x30(%rax), %eax
shll %eax
addl $0x1, %eax
movslq %eax, %rsi
shlq $0x2, %rsi
callq 0x45f0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x40(%rax)
movq 0x48(%rax), %rdi
movl 0x30(%rax), %eax
shll %eax
addl $0x1, %eax
movslq %eax, %rsi
shlq $0x2, %rsi
callq 0x45f0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x48(%rax)
cmpq $0x0, 0x38(%rax)
je 0x1f2ce
movq 0x8(%rsp), %rax
cmpq $0x0, 0x40(%rax)
je 0x1f2ce
movq 0x8(%rsp), %rax
cmpq $0x0, 0x48(%rax)
jne 0x1f2d5
movb $0x0, 0x27(%rsp)
jmp 0x1f348
movq 0x8(%rsp), %rax
movl 0x30(%rax), %eax
movl %eax, 0x14(%rsp)
movq 0x8(%rsp), %rcx
movl 0x14(%rsp), %eax
movl 0x30(%rcx), %ecx
shll %ecx
cmpl %ecx, %eax
jge 0x1f336
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rcx
movslq 0x14(%rsp), %rdx
movq $0x0, (%rcx,%rdx,8)
movq 0x40(%rax), %rcx
movslq 0x14(%rsp), %rdx
movl $0x0, (%rcx,%rdx,4)
movq 0x48(%rax), %rax
movslq 0x14(%rsp), %rcx
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x1f2e1
movq 0x8(%rsp), %rax
movl 0x30(%rax), %ecx
shll %ecx
movl %ecx, 0x30(%rax)
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x58(%rax), %rdi
movl 0x54(%rax), %eax
shll %eax
addl $0x1, %eax
movslq %eax, %rsi
shlq $0x0, %rsi
callq 0x45f0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x58(%rax)
movq 0x60(%rax), %rdi
movl 0x54(%rax), %eax
shll %eax
addl $0x1, %eax
movslq %eax, %rsi
shlq $0x2, %rsi
callq 0x45f0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x60(%rax)
movq 0x68(%rax), %rdi
movl 0x54(%rax), %eax
shll %eax
addl $0x1, %eax
movslq %eax, %rsi
shlq $0x2, %rsi
callq 0x45f0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x68(%rax)
cmpq $0x0, 0x58(%rax)
je 0x1f3fe
movq 0x8(%rsp), %rax
cmpq $0x0, 0x60(%rax)
je 0x1f3fe
movq 0x8(%rsp), %rax
cmpq $0x0, 0x68(%rax)
jne 0x1f405
movb $0x0, 0x27(%rsp)
jmp 0x1f474
movq 0x8(%rsp), %rax
movl 0x54(%rax), %eax
movl %eax, 0x14(%rsp)
movq 0x8(%rsp), %rcx
movl 0x14(%rsp), %eax
movl 0x54(%rcx), %ecx
shll %ecx
cmpl %ecx, %eax
jge 0x1f462
movq 0x8(%rsp), %rax
movq 0x58(%rax), %rcx
movslq 0x14(%rsp), %rdx
movb $0x30, (%rcx,%rdx)
movq 0x60(%rax), %rcx
movslq 0x14(%rsp), %rdx
movl $0x0, (%rcx,%rdx,4)
movq 0x68(%rax), %rax
movslq 0x14(%rsp), %rcx
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x1f411
movq 0x8(%rsp), %rax
movl 0x54(%rax), %ecx
shll %ecx
movl %ecx, 0x54(%rax)
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nop
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x88(%rax), %rdi
movl 0x90(%rax), %eax
shll %eax
addl $0x1, %eax
movslq %eax, %rsi
shlq $0x3, %rsi
callq 0x45f0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x88(%rax)
cmpq $0x0, 0x88(%rax)
jne 0x1f4d1
movb $0x0, 0x27(%rsp)
jmp 0x1f533
movq 0x8(%rsp), %rax
movl 0x90(%rax), %eax
movl %eax, 0x14(%rsp)
movq 0x8(%rsp), %rcx
movl 0x14(%rsp), %eax
movl 0x90(%rcx), %ecx
shll %ecx
cmpl %ecx, %eax
jge 0x1f51b
movq 0x8(%rsp), %rax
movq 0x88(%rax), %rax
movslq 0x14(%rsp), %rcx
movq $0x0, (%rax,%rcx,8)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x1f4e0
movq 0x8(%rsp), %rax
movl 0x90(%rax), %ecx
shll %ecx
movl %ecx, 0x90(%rax)
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nop
// File: 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:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x20(%rsp)
movl -0xc(%rsp), %ecx
movl %ecx, (%rax)
movq -0x18(%rsp), %rcx
movq %rcx, 0x8(%rax)
movb $0x1, 0x98(%rax)
movq 0x8(%rax), %rcx
movq (%rcx), %rcx
movq %rcx, 0x18(%rax)
cmpl $0x1, (%rax)
jle 0x1f81a
movq -0x20(%rsp), %rax
movb $0x1, 0xac(%rax)
retq
nopl (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movl 0x50(%rcx), %eax
cmpl 0x30(%rcx), %eax
jl 0x1f8cb
movq 0x8(%rsp), %rdi
callq 0x1f230
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x1f8c9
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x1fef0
jmp 0x1f90a
jmp 0x1f8cb
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rsi
movq 0x38(%rax), %rcx
movslq 0x50(%rax), %rdx
movq %rsi, (%rcx,%rdx,8)
movl 0x14(%rsp), %esi
movq 0x40(%rax), %rcx
movslq 0x50(%rax), %rdx
movl %esi, (%rcx,%rdx,4)
movl 0x80(%rax), %esi
movq 0x48(%rax), %rcx
movslq 0x50(%rax), %rdx
movl %esi, (%rcx,%rdx,4)
movl 0x50(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x50(%rax)
addq $0x28, %rsp
retq
nop
// File: 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:
subq $0x18, %rsp
movb %sil, %al
movq %rdi, 0x10(%rsp)
movb %al, 0xf(%rsp)
movl %edx, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x1f650
testb $0x1, %al
jne 0x1f9af
movq (%rsp), %rdi
leaq 0x4dc2(%rip), %rsi      # 0x24743
callq 0x1f6c0
movq (%rsp), %rdi
movsbl 0xf(%rsp), %esi
callq 0x1f740
movq (%rsp), %rdi
leaq 0x4dc4(%rip), %rsi      # 0x24763
callq 0x1f6c0
movq (%rsp), %rdi
callq 0x1f690
jmp 0x1fa1e
movq (%rsp), %rcx
movl 0x70(%rcx), %eax
cmpl 0x54(%rcx), %eax
jl 0x1f9e0
movq (%rsp), %rdi
callq 0x1f360
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x1f9de
movq (%rsp), %rdi
movsbl 0xf(%rsp), %esi
callq 0x1ffb0
jmp 0x1fa1e
jmp 0x1f9e0
movq (%rsp), %rax
movb 0xf(%rsp), %sil
movq 0x58(%rax), %rcx
movslq 0x70(%rax), %rdx
movb %sil, (%rcx,%rdx)
movl 0x8(%rsp), %esi
movq 0x60(%rax), %rcx
movslq 0x70(%rax), %rdx
movl %esi, (%rcx,%rdx,4)
movl 0x80(%rax), %esi
movq 0x68(%rax), %rcx
movslq 0x70(%rax), %rdx
movl %esi, (%rcx,%rdx,4)
movl 0x70(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x70(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0xf0d3(%rip), %rdi      # 0x2efd8
movq 0xf0bc(%rip), %rsi      # 0x2efc8
callq 0x43c0
movq 0xf0c0(%rip), %rdi      # 0x2efd8
leaq 0x4867(%rip), %rsi      # 0x24786
callq 0x4370
movq %rax, %rdi
movq 0xf09a(%rip), %rsi      # 0x2efc8
callq 0x43c0
movq 0xf09e(%rip), %rdi      # 0x2efd8
leaq 0x4875(%rip), %rsi      # 0x247b6
callq 0x4370
movq %rax, %rdi
movq 0x8(%rsp), %rsi
callq 0x4370
movq %rax, %rdi
leaq 0x4937(%rip), %rsi      # 0x24894
callq 0x4370
movq %rax, %rdi
movq 0xf05c(%rip), %rsi      # 0x2efc8
callq 0x43c0
movq 0xf060(%rip), %rdi      # 0x2efd8
leaq 0x47bb(%rip), %rsi      # 0x2473a
callq 0x4370
movq %rax, %rdi
movq 0xf03a(%rip), %rsi      # 0x2efc8
callq 0x43c0
movq 0xf03e(%rip), %rdi      # 0x2efd8
movq 0xf027(%rip), %rsi      # 0x2efc8
callq 0x43c0
xorl %edi, %edi
callq 0x4430
nopl (%rax)
// File: 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:
subq $0x18, %rsp
movb %sil, %al
movq %rdi, 0x10(%rsp)
movb %al, 0xf(%rsp)
movq 0xf011(%rip), %rdi      # 0x2efd8
movq 0xeffa(%rip), %rsi      # 0x2efc8
callq 0x43c0
movq 0xeffe(%rip), %rdi      # 0x2efd8
leaq 0x47a5(%rip), %rsi      # 0x24786
callq 0x4370
movq %rax, %rdi
movq 0xefd8(%rip), %rsi      # 0x2efc8
callq 0x43c0
movq 0xefdc(%rip), %rdi      # 0x2efd8
leaq 0x47cf(%rip), %rsi      # 0x247d2
callq 0x4370
movq %rax, %rdi
movsbl 0xf(%rsp), %esi
callq 0x4410
movq %rax, %rdi
leaq 0x4875(%rip), %rsi      # 0x24894
callq 0x4370
movq %rax, %rdi
movq 0xef9a(%rip), %rsi      # 0x2efc8
callq 0x43c0
movq 0xef9e(%rip), %rdi      # 0x2efd8
leaq 0x46f9(%rip), %rsi      # 0x2473a
callq 0x4370
movq %rax, %rdi
movq 0xef78(%rip), %rsi      # 0x2efc8
callq 0x43c0
movq 0xef7c(%rip), %rdi      # 0x2efd8
movq 0xef65(%rip), %rsi      # 0x2efc8
callq 0x43c0
xorl %edi, %edi
callq 0x4430
nop
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movl $0x0, 0xc(%rsp)
testb $0x1, 0xaa(%rax)
jne 0x2012f
movq (%rsp), %rax
cmpl $0x0, 0x80(%rax)
jle 0x2012d
movq (%rsp), %rax
movslq 0x80(%rax), %rax
shlq $0x3, %rax
movl %eax, 0xc(%rsp)
movslq 0xc(%rsp), %rdi
callq 0x44b0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x78(%rax)
movl $0x0, 0x8(%rsp)
movq (%rsp), %rcx
movl 0x8(%rsp), %eax
cmpl 0x80(%rcx), %eax
jge 0x20122
movq (%rsp), %rax
movq 0x78(%rax), %rax
movslq 0x8(%rsp), %rcx
movq $0x0, (%rax,%rcx,8)
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x200f0
movq (%rsp), %rax
movb $0x1, 0xaa(%rax)
jmp 0x2012f
movq (%rsp), %rax
movb 0xaa(%rax), %al
andb $0x1, %al
addq $0x18, %rsp
retq
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x2c(%rsp)
movl $0x0, 0x28(%rsp)
movl 0x28(%rsp), %eax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
callq 0x4150
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x2057a
movq 0x10(%rsp), %rcx
movq 0x30(%rsp), %rax
movl 0x28(%rsp), %edx
movsbl (%rax,%rdx), %eax
movsbl 0xa4(%rcx), %ecx
cmpl %ecx, %eax
jne 0x2056b
movl 0x28(%rsp), %eax
movl %eax, 0x2c(%rsp)
movq 0x30(%rsp), %rdi
callq 0x4150
movl %eax, 0x28(%rsp)
jmp 0x2056d
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x20518
cmpl $0x0, 0x2c(%rsp)
jle 0x2068d
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x0, %rdi
callq 0x44b0
movq %rax, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jge 0x205d6
movq 0x30(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movb (%rax,%rcx), %dl
movq 0x20(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movb %dl, (%rax,%rcx)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x205a5
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rax
movslq 0x2c(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq 0x20(%rsp), %rsi
callq 0x20b70
cmpl $0x0, %eax
jl 0x20643
movq 0x10(%rsp), %rdi
movq 0x38(%rdi), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rsi
callq 0x20b70
movq 0x10(%rsp), %rdi
movl %eax, %ecx
movq (%rsp), %rax
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rsi
movq 0x30(%rsp), %rdx
movslq 0x2c(%rsp), %rax
addq %rax, %rdx
addq $0x1, %rdx
callq 0x206c0
movq 0x20(%rsp), %rdi
callq 0x4420
jmp 0x2068b
movq 0x10(%rsp), %rdi
leaq 0x41b8(%rip), %rsi      # 0x24807
callq 0x1f6c0
movq 0x10(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x1f700
movq 0x10(%rsp), %rdi
callq 0x1f690
movq 0x10(%rsp), %rdi
callq 0x20a20
movq 0x20(%rsp), %rdi
callq 0x4420
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0x206aa
jmp 0x206a2
movq 0x10(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x20b70
movl %eax, 0x44(%rsp)
jmp 0x206aa
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)