LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa979
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 0xa9d2
movq 0xd63b(%rip), %r14      # 0x17fd8
leaq 0x7b42(%rip), %rsi      # 0x124e6
movl $0x7, %edx
movq %r14, %rdi
callq 0x3340
testq %rbx, %rbx
je 0xa9d8
movq %rbx, %rdi
callq 0x3130
movq 0xd613(%rip), %rdi      # 0x17fd8
movq %rbx, %rsi
movq %rax, %rdx
callq 0x3340
jmp 0xa9f0
movl 0x4(%rsp), %ebx
jmp 0xaa40
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x3560
movq 0xd5e1(%rip), %r14      # 0x17fd8
leaq 0x7af0(%rip), %rsi      # 0x124ee
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 0xd5af(%rip), %rdi      # 0x17fd8
callq 0x3030
movq %rax, %rdi
callq 0x31e0
movq %rbx, %rdi
callq 0x34d0
movl %eax, %ebx
movq 0xd581(%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 0xaaa9
callq 0x32c0
jmp 0xaaa9
movq %rax, %rbx
jmp 0xaaa9
movq %rax, %rbx
movq 0xd536(%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_O3/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 0xcdb6
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 0xcc16
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0xb20f
callq 0x32c0
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb222
callq 0x32c0
movq 0xcd9f(%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 0xb25d
callq 0x32c0
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb275
callq 0x32c0
jmp 0xb275
movq %rax, %rbx
movq 0xcd4c(%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_O3/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 0xb34d
movq 0xccf9(%rip), %rdi      # 0x17fd8
leaq 0x7200(%rip), %rsi      # 0x124e6
movl $0x7, %edx
callq 0x3340
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0xccda(%rip), %rdi      # 0x17fd8
callq 0x3340
movq %rax, %r14
leaq 0x71e1(%rip), %rsi      # 0x124ee
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 0xb351
movl 0x4(%rsp), %ebx
movq 0xcc70(%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 0xcc42(%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_O3/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 0xd952
testl %r14d, %r14d
cmovlel %r15d, %r14d
cmpq %r15, %r14
je 0xd961
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 0xd918
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 0xd8cc
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xa670(%rip), %rdi      # 0x17fd8
leaq 0x4da8(%rip), %rsi      # 0x12717
callq 0x32e0
movq %rax, %rdi
callq 0x3150
movl $0x1, %edi
callq 0x3390
// File: /workspace/github_cpp_makefile_star2_O3/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
testq %rax, %rax
je 0xdb67
movq %rax, %r14
movzbl -0x1(%rbx,%r14), %edi
callq 0x3050
testl %eax, %eax
je 0xdb6a
decq %r14
jne 0xdb53
xorl %r14d, %r14d
movb $0x0, (%rbx,%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xdb9e
movzbl %al, %edi
callq 0x3050
testl %eax, %eax
je 0xdb9e
movb 0x1(%rbx,%r15), %al
incq %r15
jmp 0xdb84
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_O3/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, %r15
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rsi), %r12
movq 0x8(%rsi), %r13
cmpq %r13, %r12
je 0xdc2c
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 0xc1e6
movq %r12, %rdi
movq %r13, %rsi
callq 0xc2c9
movq (%r15), %r13
movq 0x8(%r15), %r12
cmpq %r12, %r13
je 0xdc6c
movq %r12, %rax
subq %r13, %rax
sarq $0x2, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r13, %rdi
movq %r12, %rsi
callq 0xc1e6
movq %r13, %rdi
movq %r12, %rsi
callq 0xc2c9
movq (%r15), %r13
movq 0x8(%r15), %r12
movq (%r14), %rdi
movq 0x8(%r14), %rsi
movq %r13, %rdx
movq %r12, %rcx
movq %rbx, %r8
callq 0xdd27
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xdc9e
callq 0x32c0
movq %r14, %rdi
callq 0x35c0
// File: /workspace/github_cpp_makefile_star2_O3/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 0xdfa9
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 0xaae4
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xdf8f
callq 0x32c0
movq (%r15), %rax
movl (%rax,%r14,4), %esi
movq %r12, %rdi
movq %r14, %rdx
callq 0xdfd2
incq %r14
cmpq %r14, %rbx
jne 0xdf66
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 0xdfc9
callq 0x32c0
movq %rbx, %rdi
callq 0x35c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xe9ac
callq 0x3380
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0xe9bb
popq %rbx
jmp 0x3380
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xe9ca
movb $0x1, %al
retq
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movslq 0x30(%rdi), %r13
leal 0x8(,%r13,8), %eax
movslq %eax, %rdi
callq 0x3400
movq %rax, %r15
movq %rax, 0x38(%rbx)
leaq 0x4(,%r13,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 0xeb3e
testq %r14, %r14
je 0xeb3e
testq %rcx, %rcx
je 0xeb3e
movb $0x1, 0x9a(%rbx)
testl %r13d, %r13d
jle 0xea70
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 0xea42
movslq 0x54(%rbx), %r13
leaq 0x1(%r13), %rdi
callq 0x3400
movq %rax, %r14
movq %rax, 0x58(%rbx)
leaq 0x4(,%r13,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 0xeb35
testl %r13d, %r13d
jle 0xeaf0
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 0xeac6
movl 0x90(%rbx), %r14d
leal 0x8(,%r14,8), %eax
movslq %eax, %rdi
callq 0x3400
movq %rax, 0x88(%rbx)
testq %rax, %rax
je 0xeb35
testl %r14d, %r14d
jle 0xeb31
xorl %eax, %eax
movq 0x88(%rbx), %rcx
movq $0x0, (%rcx,%rax,8)
incq %rax
cmpq %rax, %r14
jne 0xeb1a
movb $0x1, %al
jmp 0xeb3e
movb $0x0, 0x9a(%rbx)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xec9e
movslq 0x54(%rbx), %rcx
leal (%rcx,%rcx), %edx
cmpl %edx, %ecx
jge 0xec9b
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 0xec6e
movl %edx, 0x54(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xecf7
movslq 0x90(%rbx), %rcx
leaq (%rcx,%rcx), %rdx
cmpl %edx, %ecx
jge 0xecf1
movq 0x88(%rbx), %rsi
movq $0x0, (%rsi,%rcx,8)
incq %rcx
cmpq %rcx, %rdx
jne 0xecda
movl %edx, 0x90(%rbx)
testq %rax, %rax
setne %al
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xeea8
movb $0x1, 0xac(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xeeef
movq %rbx, %rdi
callq 0xeb48
testb %al, %al
je 0xef19
movl 0x50(%rbx), %eax
movq 0x38(%rbx), %rcx
cltq
movq %r14, (%rcx,%rax,8)
movq 0x40(%rbx), %rcx
movl %ebp, (%rcx,%rax,4)
movl 0x80(%rbx), %eax
movq 0x48(%rbx), %rcx
movslq 0x50(%rbx), %rdx
movl %eax, (%rcx,%rdx,4)
incl 0x50(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
movq %r14, %rsi
callq 0xf1fa
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xef98
movl %edx, %r14d
movl 0x70(%rbx), %eax
cmpl 0x54(%rbx), %eax
jl 0xef6c
movq %rbx, %rdi
callq 0xebf6
testb %al, %al
je 0xefe9
movl 0x70(%rbx), %eax
movq 0x58(%rbx), %rcx
cltq
movb %bpl, (%rcx,%rax)
movq 0x60(%rbx), %rax
movslq 0x70(%rbx), %rcx
movl %r14d, (%rax,%rcx,4)
movl 0x80(%rbx), %eax
movq 0x68(%rbx), %rcx
movslq 0x70(%rbx), %rdx
movl %eax, (%rcx,%rdx,4)
incl 0x70(%rbx)
jmp 0xefe0
leaq 0x3821(%rip), %rsi      # 0x127c0
movq %rbx, %rdi
callq 0xedb0
cmpb $0x1, 0x9c(%rbx)
jne 0xefc9
leaq 0xf(%rsp), %rsi
movb %bpl, (%rsi)
movq 0x9019(%rip), %rdi      # 0x17fd8
movl $0x1, %edx
callq 0x3340
leaq 0x3810(%rip), %rsi      # 0x127e0
movq %rbx, %rdi
callq 0xedb0
movq %rbx, %rdi
callq 0xed76
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movsbl %bpl, %esi
callq 0xf27e
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8dd0(%rip), %rbx      # 0x17fd8
movq %rbx, %rdi
callq 0x3150
leaq 0x35ec(%rip), %rsi      # 0x12803
movq %rbx, %rdi
callq 0x32e0
movq %rax, %rdi
callq 0x3150
leaq 0x3605(%rip), %rsi      # 0x12833
movq %rbx, %rdi
callq 0x32e0
movq %rax, %rdi
movq %r14, %rsi
callq 0x32e0
leaq 0x36c9(%rip), %rsi      # 0x12911
movq %rax, %rdi
callq 0x32e0
movq %rax, %rdi
callq 0x3150
leaq 0x3558(%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_O3/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 0x8d4e(%rip), %rbx      # 0x17fd8
movq %rbx, %rdi
callq 0x3150
leaq 0x356a(%rip), %rsi      # 0x12803
movq %rbx, %rdi
callq 0x32e0
movq %rax, %rdi
callq 0x3150
leaq 0x359f(%rip), %rsi      # 0x1284f
movq %rbx, %rdi
callq 0x32e0
movq %rax, %rdi
movl %ebp, %esi
callq 0x3370
leaq 0x3648(%rip), %rsi      # 0x12911
movq %rax, %rdi
callq 0x32e0
movq %rax, %rdi
callq 0x3150
leaq 0x34d7(%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_O3/JenTus[P]TCEM/src_TCEM/anyoption.cc
// Function: AnyOption::valueStoreOK()
bool
AnyOption::valueStoreOK( )
{
	int size= 0;
	if( !set ){
		if( g_value_counter > 0 ){
			size = g_value_counter * sizeof(char*);
			values = (char**)malloc( size );	
			for( int i = 0 ; i < g_value_counter ; i++)
				values[i] = NULL;
			set = true;
		}
	}
	return  set;
}

// Assembly:
movb 0xaa(%rdi), %al
testb %al, %al
jne 0xf35d
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq 0x80(%rdi), %r14
testq %r14, %r14
jle 0xf356
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 0xf339
movb $0x1, 0xaa(%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xf5f1
movb 0xa4(%rbx), %cl
xorl %edx, %edx
xorl %r12d, %r12d
cmpb %cl, (%r14,%rdx)
jne 0xf58c
movl %edx, %r12d
movl %eax, %edx
incl %edx
cmpq %rdx, %rax
ja 0xf581
testl %r12d, %r12d
jle 0xf5f1
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 0xf8ec
testl %eax, %eax
js 0xf605
movq 0x38(%rbx), %r13
movq %rbx, %rdi
movq %r15, %rsi
callq 0xf8ec
cltq
movq (%r13,%rax,8), %rsi
leaq (%r14,%r12), %rdx
incq %rdx
movq %rbx, %rdi
callq 0xf650
jmp 0xf638
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xf8ec
leaq 0x3278(%rip), %rsi      # 0x12884
movq %rbx, %rdi
callq 0xedb0
movq %rbx, %rdi
movq %r14, %rsi
callq 0xedfe
movq %rbx, %rdi
callq 0xed76
cmpb $0x1, 0xad(%rbx)
jne 0xf638
movq %rbx, %rdi
callq 0x102fa
movq %r15, %rdi
callq 0x3380
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xf306
testb %al, %al
je 0xf696
movslq 0x50(%r14), %r13
testq %r13, %r13
jle 0xf696
movq 0x38(%r14), %rbp
xorl %r12d, %r12d
movq (%rbp,%r12,8), %rdi
movq %r15, %rsi
callq 0x3430
testl %eax, %eax
je 0xf6a7
incq %r12
cmpq %r12, %r13
jne 0xf67d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
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
movb $0x1, %al
jmp 0xf698
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x0, (%rsi)
je 0xf72c
movl $0x1, %r12d
xorl %r13d, %r13d
movb (%r14,%r13), %r15b
movsbl %r15b, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0xf848
testb %al, %al
jne 0xf764
movl %r12d, %r13d
movq %r14, %rdi
callq 0x3130
incl %r12d
cmpq %r13, %rax
ja 0xf703
leaq 0x3151(%rip), %rsi      # 0x12884
movq %rbx, %rdi
callq 0xedb0
movq %rbx, %rdi
movq %r14, %rsi
callq 0xedfe
movq %rbx, %rdi
callq 0xed76
movb $0x30, %r15b
cmpb $0x1, 0xad(%rbx)
jne 0xf7a7
movq %rbx, %rdi
callq 0x102fa
jmp 0xf7a7
movq %r14, %rdi
callq 0x3130
decq %rax
cmpq %r13, %rax
je 0xf7a7
movb 0xa4(%rbx), %al
movb 0xa8(%rbx), %cl
movl %r12d, %edx
movb (%r14,%rdx), %sil
incl %r12d
cmpb %cl, %sil
je 0xf780
cmpb %al, %sil
je 0xf780
addq %rdx, %r14
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0xf7ba
movb $0x30, %r15b
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
callq 0xf306
testb %al, %al
je 0xf7f0
movslq 0x70(%r14), %rax
testq %rax, %rax
jle 0xf7f0
movq 0x58(%r14), %rcx
xorl %r15d, %r15d
cmpb %bpl, (%rcx,%r15)
je 0xf7fd
incq %r15
cmpq %r15, %rax
jne 0xf7e2
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x3130
leaq 0x1(%rax), %rdi
callq 0x3400
movq 0x68(%r14), %rcx
movq 0x78(%r14), %rdx
movslq (%rcx,%r15,4), %rcx
movq %rax, (%rdx,%rcx,8)
movq 0x68(%r14), %rax
movq 0x78(%r14), %rcx
movslq (%rax,%r15,4), %rax
movq (%rcx,%rax,8), %rdi
movq %rbx, %rsi
callq 0x32b0
movb $0x1, %al
jmp 0xf7f2
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movslq 0x70(%rdi), %rax
testq %rax, %rax
jle 0xf886
movq 0x58(%rbx), %rcx
movq 0x60(%rbx), %rdx
xorl %esi, %esi
cmpb %bpl, (%rcx,%rsi)
jne 0xf87e
movl (%rdx,%rsi,4), %edi
leal -0x1(%rdi), %r8d
cmpl $0x2, %r8d
jb 0xf8d2
addl $-0x4, %edi
cmpl $0x1, %edi
jbe 0xf8d6
incq %rsi
cmpq %rsi, %rax
jne 0xf863
leaq 0x2ff7(%rip), %rsi      # 0x12884
movq %rbx, %rdi
callq 0xedb0
cmpb $0x1, 0x9c(%rbx)
jne 0xf8b7
leaq 0x7(%rsp), %rsi
movb %bpl, (%rsi)
movq 0x872b(%rip), %rdi      # 0x17fd8
movl $0x1, %edx
callq 0x3340
movq %rbx, %rdi
callq 0xed76
cmpb $0x1, 0xad(%rbx)
jne 0xf8e2
movq %rbx, %rdi
callq 0x102fa
jmp 0xf8e2
movb $0x1, %al
jmp 0xf8e4
movsbl %bpl, %esi
movq %rbx, %rdi
callq 0xfa24
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/JenTus[P]TCEM/src_TCEM/anyoption.cc
// Function: AnyOption::matchOpt(char*)
int 
AnyOption::matchOpt( char *opt )
{
	for( int i = 0 ; i < option_counter ; i++ ){
		if( strcmp( options[i], opt ) == 0 ){
			if( optiontype[i] ==  COMMON_OPT ||
			    optiontype[i] ==  COMMAND_OPT )	
			{ /* found option return index */
				return i;
			}else if( optiontype[i] == COMMON_FLAG ||
			       optiontype[i] == COMMAND_FLAG )
			{ /* found flag, set it */ 
				setFlagOn( opt );
				return -1;
			}
		}
	}
	printVerbose( "Unknown command argument option : " );
	printVerbose( opt  ) ;
	printVerbose( );
	printAutoUsage();
	return  -1;	
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movslq 0x50(%rdi), %r12
testq %r12, %r12
jle 0xf93f
movq 0x38(%rbx), %r13
movq 0x40(%rbx), %rbp
xorl %r15d, %r15d
movq (%r13,%r15,8), %rdi
movq %r14, %rsi
callq 0x3430
testl %eax, %eax
jne 0xf937
movl (%rbp,%r15,4), %eax
leal -0x1(%rax), %ecx
cmpl $0x2, %ecx
jb 0xf98b
addl $-0x4, %eax
cmpl $0x1, %eax
jbe 0xf97a
incq %r15
cmpq %r15, %r12
jne 0xf911
leaq 0x2f3e(%rip), %rsi      # 0x12884
movq %rbx, %rdi
callq 0xedb0
movq %rbx, %rdi
movq %r14, %rsi
callq 0xedfe
movq %rbx, %rdi
callq 0xed76
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
cmpb $0x1, 0xad(%rbx)
jne 0xf98b
movq %rbx, %rdi
callq 0x102fa
jmp 0xf98b
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf99e
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/JenTus[P]TCEM/src_TCEM/anyoption.cc
// Function: AnyOption::setFlagOn(char const*)
bool
AnyOption::setFlagOn( const char *option )
{
	if( !valueStoreOK() )
		return false;
        for( int i = 0 ; i < option_counter ; i++ ){
                if( strcmp( options[i], option ) == 0 ){
                        values[ optionindex[i] ] = (char*) malloc((strlen(TRUE_FLAG)+1)*sizeof(char));
                        strcpy( values[ optionindex[i] ]  ,  TRUE_FLAG );
			return true;
		}
        }
        return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0xf306
testb %al, %al
je 0xf9df
movslq 0x50(%rbx), %r12
testq %r12, %r12
jle 0xf9df
movq 0x38(%rbx), %r13
xorl %r15d, %r15d
movq (%r13,%r15,8), %rdi
movq %r14, %rsi
callq 0x3430
testl %eax, %eax
je 0xf9eb
incq %r15
cmpq %r15, %r12
jne 0xf9c6
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl $0x5, %edi
callq 0x3400
movq 0x48(%rbx), %rcx
movq 0x78(%rbx), %rdx
movslq (%rcx,%r15,4), %rcx
movq %rax, (%rdx,%rcx,8)
movq 0x48(%rbx), %rax
movq 0x78(%rbx), %rcx
movslq (%rax,%r15,4), %rax
movq (%rcx,%rax,8), %rax
movb $0x0, 0x4(%rax)
movl $0x65757274, (%rax)     # imm = 0x65757274
movb $0x1, %al
jmp 0xf9e1
nop
// File: /workspace/github_cpp_makefile_star2_O3/JenTus[P]TCEM/src_TCEM/anyoption.cc
// Function: AnyOption::setFlagOn(char)
bool
AnyOption::setFlagOn( char option )
{
	if( !valueStoreOK() )
		return false;
        for( int i = 0 ; i < optchar_counter ; i++ ){
                if( optionchars[i] == option ){
                        values[ optcharindex[i] ] = (char*) malloc((strlen(TRUE_FLAG)+1)*sizeof(char));
			strcpy( values[ optcharindex[i] ] , TRUE_FLAG );
			return true;
		}
        }
        return false;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
callq 0xf306
testb %al, %al
je 0xfa54
movslq 0x70(%rbx), %rax
testq %rax, %rax
jle 0xfa54
movq 0x58(%rbx), %rcx
xorl %r14d, %r14d
cmpb %bpl, (%rcx,%r14)
je 0xfa5b
incq %r14
cmpq %r14, %rax
jne 0xfa46
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movl $0x5, %edi
callq 0x3400
movq 0x68(%rbx), %rcx
movq 0x78(%rbx), %rdx
movslq (%rcx,%r14,4), %rcx
movq %rax, (%rdx,%rcx,8)
movq 0x68(%rbx), %rax
movq 0x78(%rbx), %rcx
movslq (%rax,%r14,4), %rax
movq (%rcx,%rax,8), %rax
movb $0x0, 0x4(%rax)
movl $0x65757274, (%rax)     # imm = 0x65757274
movb $0x1, %al
jmp 0xfa56
nop
// File: /workspace/github_cpp_makefile_star2_O3/JenTus[P]TCEM/src_TCEM/anyoption.cc
// Function: AnyOption::getValue(char const*)
char*
AnyOption::getValue( const char *option )
{
	if( !valueStoreOK() ) {
		cout << "Error while reading the parameter: " << option << endl;
		return NULL;
	}

	for( int i = 0 ; i < option_counter ; i++ ){
		if( strcmp( options[i], option ) == 0 )
			return values[ optionindex[i] ];
	}
		
	cout << "Error while reading the parameter: " << option << endl;
	return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0xf306
testb %al, %al
je 0xfad9
movslq 0x50(%r14), %r15
testq %r15, %r15
jle 0xfad9
movq 0x38(%r14), %r13
xorl %r12d, %r12d
movq (%r13,%r12,8), %rdi
movq %rbx, %rsi
callq 0x3430
testl %eax, %eax
je 0xfb60
incq %r12
cmpq %r12, %r15
jne 0xfabc
movq 0x84f8(%rip), %r14      # 0x17fd8
leaq 0x2dc0(%rip), %rsi      # 0x128a7
movl $0x23, %edx
movq %r14, %rdi
callq 0x3340
testq %rbx, %rbx
je 0xfb15
movq %rbx, %rdi
callq 0x3130
movq 0x84d0(%rip), %rdi      # 0x17fd8
movq %rbx, %rsi
movq %rax, %rdx
callq 0x3340
jmp 0xfb2d
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x3560
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
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x48(%r14), %rax
movq 0x78(%r14), %rcx
movslq (%rax,%r12,4), %rax
movq (%rcx,%rax,8), %rax
jmp 0xfb56
// File: /workspace/github_cpp_makefile_star2_O3/JenTus[P]TCEM/src_TCEM/anyoption.cc
// Function: AnyOption::getFlag(char const*)
bool
AnyOption::getFlag( const char *option )
{
	if( !valueStoreOK() )
		return false;
	for( int i = 0 ; i < option_counter ; i++ ){
		if( strcmp( options[i], option ) == 0 )
			return findFlag( values[ optionindex[i] ] );
	}
	return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0xf306
testb %al, %al
je 0xfbdd
movslq 0x50(%rbx), %r15
testq %r15, %r15
jle 0xfbdd
movq 0x38(%rbx), %r13
xorl %r12d, %r12d
movq (%r13,%r12,8), %rdi
movq %r14, %rsi
callq 0x3430
testl %eax, %eax
je 0xfbb5
incq %r12
cmpq %r12, %r15
jne 0xfb9a
jmp 0xfbdd
movq 0x48(%rbx), %rax
movq 0x78(%rbx), %rcx
movslq (%rax,%r12,4), %rax
movq (%rcx,%rax,8), %rsi
testq %rsi, %rsi
je 0xfbdd
leaq 0x2cfa(%rip), %rdi      # 0x128cb
callq 0x3430
testl %eax, %eax
sete %al
jmp 0xfbdf
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/JenTus[P]TCEM/src_TCEM/anyoption.cc
// Function: AnyOption::getValue(char)
char*
AnyOption::getValue( char option )
{
	if( !valueStoreOK() ) {

		cout << "Error while reading the parameter: " << option << endl;
		return NULL;
	}

	for( int i = 0 ; i < optchar_counter ; i++ ){
		if( optionchars[i] == option )
			return values[ optcharindex[i] ];
	}
		
	cout << "Error while reading the parameter: " << option << endl;
	return NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0xf306
testb %al, %al
je 0xfc5e
movslq 0x70(%r14), %rax
testq %rax, %rax
jle 0xfc3c
movq 0x58(%r14), %rdx
xorl %ecx, %ecx
cmpb %bl, (%rdx,%rcx)
je 0xfcc1
incq %rcx
cmpq %rcx, %rax
jne 0xfc2b
movq 0x8395(%rip), %r14      # 0x17fd8
leaq 0x2c5d(%rip), %rsi      # 0x128a7
movl $0x23, %edx
movq %r14, %rdi
callq 0x3340
leaq 0x7(%rsp), %rsi
jmp 0xfc7e
movq 0x8373(%rip), %r14      # 0x17fd8
leaq 0x2c3b(%rip), %rsi      # 0x128a7
movl $0x23, %edx
movq %r14, %rdi
callq 0x3340
leaq 0x6(%rsp), %rsi
movb %bl, (%rsi)
movl $0x1, %edx
movq %r14, %rdi
callq 0x3340
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x32d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31e0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x68(%r14), %rax
movq 0x78(%r14), %rdx
movslq (%rax,%rcx,4), %rax
movq (%rdx,%rax,8), %rax
jmp 0xfcb9
nop
// File: /workspace/github_cpp_makefile_star2_O3/JenTus[P]TCEM/src_TCEM/anyoption.cc
// Function: AnyOption::getFlag(char)
bool
AnyOption::getFlag( char option )
{
	if( !valueStoreOK() )
		return false;
	for( int i = 0 ; i < optchar_counter ; i++ ){
		if( optionchars[i] == option )
			return findFlag( values[ optcharindex[i] ] ) ;
	}
	return false;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0xf306
testb %al, %al
je 0xfd2c
movslq 0x70(%rbx), %rax
testq %rax, %rax
jle 0xfd2c
movq 0x58(%rbx), %rdx
xorl %ecx, %ecx
cmpb %bpl, (%rdx,%rcx)
je 0xfd04
incq %rcx
cmpq %rcx, %rax
jne 0xfcf4
jmp 0xfd2c
movq 0x68(%rbx), %rax
movq 0x78(%rbx), %rdx
movslq (%rax,%rcx,4), %rax
movq (%rdx,%rax,8), %rsi
testq %rsi, %rsi
je 0xfd2c
leaq 0x2bab(%rip), %rdi      # 0x128cb
callq 0x3430
testl %eax, %eax
sete %al
jmp 0xfd2e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/JenTus[P]TCEM/src_TCEM/anyoption.cc
// Function: AnyOption::consumeFile(char*)
bool
AnyOption::consumeFile( char *buffer )
{
	if (buffer != NULL) {
		char *cursor = buffer;/* preserve the ptr */
		char *pline = NULL ;
		int linelength = 0;
		bool newline = true;
		for( unsigned int i = 0 ; i < strlen( buffer ) ; i++ ){
			if( *cursor == endofline ) { /* end of line */
				if( pline != NULL ) /* valid line */
					processLine( pline, linelength );
				pline = NULL;
				newline = true;
			}else if( newline ){ /* start of line */
				newline = false;
				if( (*cursor != comment ) ){ /* not a comment */
					pline = cursor ;
					linelength = 0 ;
				}
			}
			cursor++; /* keep moving */
			linelength++;
		}
		free (buffer);
		return true;
	}
	return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, 0x10(%rsp)
testq %rsi, %rsi
je 0xfe34
movq %rbx, 0x8(%rsp)
cmpb $0x0, (%rbx)
je 0xfe27
movb $0x1, %r12b
movl $0x1, %r13d
xorl %ebp, %ebp
xorl %r15d, %r15d
movq 0x8(%rsp), %rbx
movl %r12d, %ecx
movb (%rbx), %al
movq 0x10(%rsp), %rdx
cmpb 0xa7(%rdx), %al
sete %r12b
jne 0xfdf1
testq %r15, %r15
je 0xfdec
movq 0x10(%rsp), %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0xff1e
xorl %r15d, %r15d
jmp 0xfe0d
testb $0x1, %cl
je 0xfe0d
movq 0x10(%rsp), %rcx
cmpb 0xa5(%rcx), %al
cmovneq %rbx, %r15
movl $0x0, %eax
cmovnel %eax, %ebp
incq %rbx
incl %ebp
movl %r13d, %r14d
movq 0x8(%rsp), %rdi
callq 0x3130
incl %r13d
cmpq %r14, %rax
ja 0xfdc2
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x3380
testq %rbx, %rbx
setne %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/JenTus[P]TCEM/src_TCEM/anyoption.cc
// Function: AnyOption::readFile(char const*)
char*
AnyOption::readFile( const char* fname )
{
        int length;
        char *buffer;
        ifstream is;
        is.open ( fname , ifstream::in );
        if( ! is.good() ){
                is.close();
                return NULL;
        }
        is.seekg (0, ios::end);
        length = is.tellg();
        is.seekg (0, ios::beg);
        buffer = (char*) malloc(length*sizeof(char)+1);
        is.read (buffer,length);
        is.close();
        return buffer;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rsi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x3330
movq %r14, %rdi
movq %rbx, %rsi
movl $0x8, %edx
callq 0x31a0
movq (%rsp), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x20(%rsp,%rax)
je 0xfea7
movq %rsp, %rdi
callq 0x3090
xorl %ebx, %ebx
jmp 0xfef2
movq %rsp, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x3420
movq %rsp, %rdi
callq 0x3590
movq %rax, %rbx
movq %rsp, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3420
movslq %ebx, %r14
leaq 0x1(%r14), %rdi
callq 0x3400
movq %rax, %rbx
movq %rsp, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x33d0
movq %rsp, %rdi
callq 0x3090
movq %rsp, %rdi
callq 0x30b0
movq %rbx, %rax
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
retq
jmp 0xff0a
movq %rax, %rbx
movq %rsp, %rdi
callq 0x30b0
movq %rbx, %rdi
callq 0x35c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/JenTus[P]TCEM/src_TCEM/anyoption.cc
// Function: AnyOption::processLine(char*, int)
void
AnyOption::processLine( char *theline, int length  )
{
        bool found = false;
        char *pline = (char*) malloc( (length+1)*sizeof(char) );
        for( int i = 0 ; i < length ; i ++ )
                pline[i]= *(theline++);
        pline[length] = nullterminate;
        char *cursor = pline ; /* preserve the ptr */
        if( *cursor == delimiter || *(cursor+length-1) == delimiter ){
                justValue( pline );/* line with start/end delimiter */
        }else{
                for( int i = 1 ; i < length-1 && !found ; i++){/* delimiter */
                        if( *cursor == delimiter ){
                                *(cursor-1) = nullterminate; /* two strings */
                                found = true;
                                valuePairs( pline , cursor+1 );
                        }
                        cursor++;
                }
                cursor++;
                if( !found ) /* not a pair */
                        justValue( pline );
        }
        free (pline);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %r14
leal 0x1(%r15), %eax
movslq %eax, %rdi
callq 0x3400
movq %rax, %rbx
testl %r15d, %r15d
jle 0xff51
movl %r15d, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3250
movb 0xa9(%r14), %cl
movslq %r15d, %rax
movb %cl, (%rbx,%rax)
movb 0xa6(%r14), %cl
cmpb %cl, (%rbx)
je 0xff75
cmpb %cl, -0x1(%rbx,%rax)
je 0xff75
cmpl $0x3, %r15d
jge 0xff93
movq %r14, %rdi
movq %rbx, %rsi
callq 0xffda
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3380
decl %r15d
movb 0xa6(%r14), %al
movq %rbx, %rdx
incq %rdx
movl $0x2, %ecx
movb -0x1(%rdx), %sil
cmpb %al, %sil
je 0xffc2
cmpl %r15d, %ecx
jge 0xff75
incl %ecx
incq %rdx
cmpb %al, %sil
jne 0xffa8
jmp 0xff75
movb 0xa9(%r14), %al
movb %al, -0x2(%rdx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x10102
jmp 0xff80
nop
// File: /workspace/github_cpp_makefile_star2_O3/JenTus[P]TCEM/src_TCEM/anyoption.cc
// Function: AnyOption::justValue(char*)
void
AnyOption::justValue( char *type )
{

	if ( strlen(chomp(type)) == 1  ){ /* this is a char option */
		for( int i = 0 ; i < optchar_counter ; i++ ){
			if(  optionchars[i] == type[0]  ){ /* match */
				if( optchartype[i] == COMMON_FLAG ||
				    optchartype[i] == FILE_FLAG )
				{
			 		setFlagOn( type[0] );
			 		return;
				}
			}
		}
	}	
	/* if no char options matched */
	for( int i = 0 ; i < option_counter ; i++ ){
		if( strcmp( options[i], type ) == 0 ){ /* match */
			if( optiontype[i] == COMMON_FLAG ||
			    optiontype[i] == FILE_FLAG )
			{
		 		setFlagOn( type );
		 		return;
			}
		}
	}
        printVerbose( "Unknown option in resourcefile : " );
	printVerbose( type  );
	printVerbose( );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movb 0xa8(%rdi), %bpl
movq %rsi, %r12
movq %r12, %rax
incq %r12
cmpb %bpl, (%rax)
je 0xfff5
leaq -0x1(%r12), %r15
movq %r15, %rdi
callq 0x3130
addq %r12, %rax
movq %rax, %rcx
decq %rax
cmpb %bpl, -0x2(%rcx)
je 0x10010
movb 0xa9(%rbx), %cl
movb %cl, (%rax)
movq %r15, %rdi
callq 0x3130
cmpq $0x1, %rax
jne 0x10067
movslq 0x70(%rbx), %rax
testq %rax, %rax
jle 0x10067
movq 0x58(%rbx), %rcx
movq 0x60(%rbx), %rsi
movb (%r14), %dl
xorl %edi, %edi
cmpb %dl, (%rcx,%rdi)
jne 0x1005f
movl (%rsi,%rdi,4), %r8d
orl $0x2, %r8d
cmpl $0x6, %r8d
je 0x100e8
incq %rdi
cmpq %rdi, %rax
jne 0x10048
movslq 0x50(%rbx), %r15
testq %r15, %r15
jle 0x1009f
movq 0x38(%rbx), %r12
movq 0x40(%rbx), %r13
xorl %ebp, %ebp
movq (%r12,%rbp,8), %rdi
movq %r14, %rsi
callq 0x3430
testl %eax, %eax
jne 0x10097
movl (%r13,%rbp,4), %eax
orl $0x2, %eax
cmpl $0x6, %eax
je 0x100cf
incq %rbp
cmpq %rbp, %r15
jne 0x1007a
leaq 0x282a(%rip), %rsi      # 0x128d0
movq %rbx, %rdi
callq 0xedb0
movq %rbx, %rdi
movq %r14, %rsi
callq 0xedfe
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xed76
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xf99e
movsbl %dl, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xfa24
nop