LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x1
popq %r12
leal -0x1(%r12), %r13d
movq %r14, %rdi
callq 0x3120
cmpq %r13, %rax
jbe 0xcb58
movb (%r14,%r13), %r15b
movsbl %r15b, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0xcc78
testb %al, %al
jne 0xcb84
incl %r12d
jmp 0xcb2b
leaq 0x1cc5(%rip), %rsi      # 0xe824
movq %rbx, %rdi
callq 0xc2ea
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc300
movq %rbx, %rdi
callq 0xc2d4
movq %rbx, %rdi
callq 0xcc6a
jmp 0xcbc4
movq %r14, %rdi
callq 0x3120
decq %rax
cmpq %r13, %rax
je 0xcbc7
movb 0xa4(%rbx), %al
movb 0xa8(%rbx), %cl
movl %r12d, %edx
movb (%r14,%rdx), %sil
incl %r12d
cmpb %cl, %sil
je 0xcba0
cmpb %al, %sil
je 0xcba0
addq %rdx, %r14
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0xcbda
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_O2/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 0xc762
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
je 0xcc5f
movslq 0x70(%r14), %rcx
movq 0x58(%r14), %rdx
testl %ecx, %ecx
movl $0x0, %esi
cmovgl %ecx, %esi
cmpq %rax, %rsi
je 0xcc59
leaq 0x1(%rax), %r15
cmpb %bpl, (%rdx,%rax)
movq %r15, %rax
jne 0xcc08
movq %rbx, %rdi
callq 0x3120
leaq 0x1(%rax), %rdi
callq 0x33e0
movq 0x68(%r14), %rcx
movq 0x78(%r14), %rdx
movslq -0x4(%rcx,%r15,4), %rcx
movq %rax, (%rdx,%rcx,8)
movq 0x68(%r14), %rax
movq 0x78(%r14), %rcx
movslq -0x4(%rax,%r15,4), %rax
movq (%rcx,%rax,8), %rdi
movq %rbx, %rsi
callq 0x32a0
movb $0x1, %al
jmp 0xcc5f
cmpq %rcx, %rax
setl %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movl 0x70(%rdi), %eax
movq 0x58(%rdi), %rcx
movq 0x60(%rdi), %rdx
xorl %esi, %esi
testl %eax, %eax
cmovlel %esi, %eax
cmpq %rsi, %rax
je 0xccb7
cmpb %bpl, (%rcx,%rsi)
jne 0xccb2
movl (%rdx,%rsi,4), %edi
leal -0x1(%rdi), %r8d
cmpl $0x2, %r8d
jb 0xcce4
addl $-0x4, %edi
cmpl $0x1, %edi
jbe 0xcce8
incq %rsi
jmp 0xcc92
leaq 0x1b66(%rip), %rsi      # 0xe824
movq %rbx, %rdi
callq 0xc2ea
movsbl %bpl, %esi
movq %rbx, %rdi
callq 0xc316
movq %rbx, %rdi
callq 0xc2d4
movq %rbx, %rdi
callq 0xcc6a
jmp 0xccf4
movb $0x1, %al
jmp 0xccf6
movsbl %bpl, %esi
movq %rbx, %rdi
callq 0xce3a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movl 0x50(%rdi), %r12d
movq 0x38(%rdi), %r13
movq 0x40(%rdi), %rbp
xorl %r15d, %r15d
testl %r12d, %r12d
cmovlel %r15d, %r12d
cmpq %r15, %r12
je 0xcd55
movq (%r13,%r15,8), %rdi
movq %r14, %rsi
callq 0x3420
testl %eax, %eax
jne 0xcd50
movl (%rbp,%r15,4), %eax
leal -0x1(%rax), %ecx
cmpl $0x2, %ecx
jb 0xcd90
addl $-0x4, %eax
cmpl $0x1, %eax
jbe 0xcd81
incq %r15
jmp 0xcd25
leaq 0x1ac8(%rip), %rsi      # 0xe824
movq %rbx, %rdi
callq 0xc2ea
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc300
movq %rbx, %rdi
callq 0xc2d4
movq %rbx, %rdi
callq 0xcc6a
jmp 0xcd8c
movq %rbx, %rdi
movq %r14, %rsi
callq 0xcda2
pushq $-0x1
popq %r15
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
callq 0xc762
xorl %ebx, %ebx
testb %al, %al
je 0xce29
movslq 0x50(%r14), %r12
movq 0x38(%r14), %r13
testl %r12d, %r12d
movl $0x0, %ebp
cmovgl %r12d, %ebp
cmpq %rbx, %rbp
je 0xce23
movq (%r13,%rbx,8), %rdi
movq %r15, %rsi
callq 0x3420
incq %rbx
testl %eax, %eax
jne 0xcdd2
pushq $0x5
popq %rdi
callq 0x33e0
movq 0x48(%r14), %rcx
movq 0x78(%r14), %rdx
movslq -0x4(%rcx,%rbx,4), %rcx
movq %rax, (%rdx,%rcx,8)
movq 0x48(%r14), %rax
movq 0x78(%r14), %rcx
movslq -0x4(%rax,%rbx,4), %rax
movq (%rcx,%rax,8), %rax
movb $0x0, 0x4(%rax)
movl $0x65757274, (%rax)     # imm = 0x65757274
movb $0x1, %bl
jmp 0xce29
cmpq %r12, %rbx
setl %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xc762
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
je 0xceb2
movslq 0x70(%rbx), %rcx
movq 0x58(%rbx), %rdx
testl %ecx, %ecx
movl $0x0, %esi
cmovgl %ecx, %esi
cmpq %rax, %rsi
je 0xceac
leaq 0x1(%rax), %r14
cmpb %bpl, (%rdx,%rax)
movq %r14, %rax
jne 0xce62
pushq $0x5
popq %rdi
callq 0x33e0
movq 0x68(%rbx), %rcx
movq 0x78(%rbx), %rdx
movslq -0x4(%rcx,%r14,4), %rcx
movq %rax, (%rdx,%rcx,8)
movq 0x68(%rbx), %rax
movq 0x78(%rbx), %rcx
movslq -0x4(%rax,%r14,4), %rax
movq (%rcx,%rax,8), %rax
movb $0x0, 0x4(%rax)
movl $0x65757274, (%rax)     # imm = 0x65757274
movb $0x1, %al
jmp 0xceb2
cmpq %rcx, %rax
setl %al
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xc762
testb %al, %al
je 0xcf0e
movl 0x50(%r14), %r12d
movq 0x38(%r14), %r13
xorl %r15d, %r15d
testl %r12d, %r12d
cmovlel %r15d, %r12d
cmpq %r15, %r12
je 0xcf0e
movq (%r13,%r15,8), %rdi
movq %rbx, %rsi
callq 0x3420
incq %r15
testl %eax, %eax
jne 0xcee2
movq 0x48(%r14), %rax
movq 0x78(%r14), %rcx
movslq -0x4(%rax,%r15,4), %rax
movq (%rcx,%rax,8), %rax
jmp 0xcf36
movq 0x80c3(%rip), %rdi      # 0x14fd8
leaq 0x192b(%rip), %rsi      # 0xe847
callq 0x32c0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x32c0
movq %rax, %rdi
callq 0x3150
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/JenTus[P]TCEM/src_TCEM/anyoption.cc
// Function: AnyOption::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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0xc762
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
je 0xcfb2
movslq 0x50(%rbx), %r15
movq 0x38(%rbx), %r13
testl %r15d, %r15d
movl $0x0, %ebp
cmovgl %r15d, %ebp
movq %rax, %r12
cmpq %rax, %rbp
je 0xcfaa
movq (%r13,%r12,8), %rdi
movq %r14, %rsi
callq 0x3420
movl %eax, %ecx
leaq 0x1(%r12), %rax
testl %ecx, %ecx
jne 0xcf72
movq 0x48(%rbx), %rcx
movq 0x78(%rbx), %rdx
movslq -0x4(%rcx,%rax,4), %rax
movq (%rdx,%rax,8), %rsi
callq 0xcfc2
movl %eax, %ecx
cmpq %r15, %r12
setl %al
andb %cl, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xc762
testb %al, %al
je 0xd027
movl 0x70(%r14), %eax
movq 0x58(%r14), %rcx
xorl %edx, %edx
testl %eax, %eax
cmovlel %edx, %eax
cmpq %rdx, %rax
je 0xd027
leaq 0x1(%rdx), %rsi
cmpb %bl, (%rcx,%rdx)
movq %rsi, %rdx
jne 0xd003
movq 0x68(%r14), %rax
movq 0x78(%r14), %rcx
movslq -0x4(%rax,%rsi,4), %rax
movq (%rcx,%rax,8), %rax
jmp 0xd04f
movq 0x7faa(%rip), %rdi      # 0x14fd8
leaq 0x1812(%rip), %rsi      # 0xe847
callq 0x32c0
movsbl %bl, %esi
movq %rax, %rdi
callq 0x3340
movq %rax, %rdi
callq 0x3150
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/JenTus[P]TCEM/src_TCEM/anyoption.cc
// Function: AnyOption::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 %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0xc762
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
je 0xd0b7
movslq 0x70(%rbx), %r14
movq 0x58(%rbx), %rdx
testl %r14d, %r14d
movl $0x0, %esi
cmovgl %r14d, %esi
movq %rax, %r15
cmpq %rax, %rsi
je 0xd0af
leaq 0x1(%r15), %rax
cmpb %bpl, (%rdx,%r15)
jne 0xd085
movq 0x68(%rbx), %rcx
movq 0x78(%rbx), %rdx
movslq -0x4(%rcx,%rax,4), %rax
movq (%rdx,%rax,8), %rsi
callq 0xcfc2
movl %eax, %ecx
cmpq %r14, %r15
setl %al
andb %cl, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rax
movq %rsi, %rbx
movq %rdi, (%rsp)
testq %rsi, %rsi
je 0xd19e
movb $0x1, %r14b
xorl %r13d, %r13d
xorl %r15d, %r15d
xorl %ebp, %ebp
movl %r14d, %r12d
movl %r13d, %r14d
movq %rbx, %rdi
callq 0x3120
cmpq %r14, %rax
jbe 0xd196
leaq (%rbx,%r13), %rax
movb (%rax), %cl
movq (%rsp), %rdx
cmpb 0xa7(%rdx), %cl
sete %r14b
jne 0xd173
testq %r15, %r15
je 0xd16e
movq (%rsp), %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0xd284
xorl %r15d, %r15d
jmp 0xd18f
testb $0x1, %r12b
je 0xd18f
movq (%rsp), %rdx
cmpb 0xa5(%rdx), %cl
cmovneq %rax, %r15
movl $0x0, %eax
cmovnel %eax, %ebp
incl %ebp
incq %r13
jmp 0xd132
movq %rbx, %rdi
callq 0x3350
testq %rbx, %rbx
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3310
pushq $0x8
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3190
movq (%rsp), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x20(%rsp,%rax)
je 0xd20f
movq %rsp, %rdi
callq 0x3090
xorl %ebx, %ebx
jmp 0xd258
movq %rsp, %rdi
pushq $0x2
popq %rdx
xorl %esi, %esi
callq 0x3400
movq %rsp, %rdi
callq 0x3540
movq %rax, %rbx
movq %rsp, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3400
movslq %ebx, %r14
leaq 0x1(%r14), %rdi
callq 0x33e0
movq %rax, %rbx
movq %rsp, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x33a0
movq %rsp, %rdi
callq 0x3090
movq %rsp, %rdi
callq 0x30c0
movq %rbx, %rax
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
retq
jmp 0xd270
movq %rax, %rbx
movq %rsp, %rdi
callq 0x30c0
movq %rbx, %rdi
callq 0x3560
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %rbx
leal 0x1(%r15), %eax
movslq %eax, %rdi
callq 0x33e0
movq %rax, %r14
xorl %eax, %eax
testl %r15d, %r15d
movl $0x0, %ecx
cmovgl %r15d, %ecx
cmpq %rax, %rcx
je 0xd2c7
movb (%r12,%rax), %dl
movb %dl, (%r14,%rax)
incq %rax
jmp 0xd2b5
movb 0xa9(%rbx), %cl
movslq %r15d, %rax
movb %cl, (%r14,%rax)
movb 0xa6(%rbx), %cl
cmpb %cl, (%r14)
je 0xd337
cmpb %cl, -0x1(%r14,%rax)
je 0xd337
decl %r15d
movq %r14, %r12
incq %r12
pushq $0x1
popq %rbp
xorl %r13d, %r13d
cmpl %r15d, %ebp
jge 0xd331
testb $0x1, %r13b
jne 0xd331
movb -0x1(%r12), %al
cmpb 0xa6(%rbx), %al
sete %r13b
jne 0xd32a
movb 0xa9(%rbx), %al
movb %al, -0x2(%r12)
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0xd452
incl %ebp
incq %r12
jmp 0xd2f5
testb $0x1, %r13b
jne 0xd342
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd358
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3350
// File: /workspace/github_cpp_makefile_star2_O2/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
callq 0xd570
movq %rax, %rdi
callq 0x3120
cmpq $0x1, %rax
jne 0xd3b3
movl 0x70(%rbx), %eax
movq 0x58(%rbx), %rcx
movq 0x60(%rbx), %rdx
xorl %esi, %esi
testl %eax, %eax
cmovlel %esi, %eax
cmpq %rsi, %rax
je 0xd3b3
movb (%rcx,%rsi), %dil
cmpb (%r14), %dil
jne 0xd3ae
movl (%rdx,%rsi,4), %r8d
orl $0x2, %r8d
cmpl $0x6, %r8d
je 0xd438
incq %rsi
jmp 0xd38e
movl 0x50(%rbx), %r15d
movq 0x38(%rbx), %r12
movq 0x40(%rbx), %r13
xorl %ebp, %ebp
testl %r15d, %r15d
cmovlel %ebp, %r15d
cmpq %rbp, %r15
je 0xd3ef
movq (%r12,%rbp,8), %rdi
movq %r14, %rsi
callq 0x3420
testl %eax, %eax
jne 0xd3ea
movl (%r13,%rbp,4), %eax
orl $0x2, %eax
cmpl $0x6, %eax
je 0xd41f
incq %rbp
jmp 0xd3c8
leaq 0x147a(%rip), %rsi      # 0xe870
movq %rbx, %rdi
callq 0xc2ea
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc300
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xc2d4
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xcda2
movsbl %dil, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xce3a
// File: /workspace/github_cpp_makefile_star2_O2/JenTus[P]TCEM/src_TCEM/anyoption.cc
// Function: AnyOption::valuePairs(char*, char*)
void
AnyOption::valuePairs( char *type, char *value )
{
	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_OPT ||
				    optchartype[i] == FILE_OPT )
				{
			 		setValue( type[0] , chomp(value) );
			 		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_OPT ||
			    optiontype[i] == FILE_OPT )
			{
		 		setValue( type , chomp(value) );
		 		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 %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
callq 0xd570
movq %rax, %rdi
callq 0x3120
cmpq $0x1, %rax
jne 0xd4ad
movl 0x70(%rbx), %eax
movq 0x58(%rbx), %rcx
movq 0x60(%rbx), %rdx
xorl %esi, %esi
testl %eax, %eax
cmovlel %esi, %eax
cmpq %rsi, %rax
je 0xd4ad
movb (%rcx,%rsi), %bpl
cmpb (%r14), %bpl
jne 0xd4a8
movl (%rdx,%rsi,4), %edi
orl $0x2, %edi
cmpl $0x3, %edi
je 0xd547
incq %rsi
jmp 0xd48b
movq %r15, (%rsp)
movl 0x50(%rbx), %r12d
movq 0x38(%rbx), %r13
movq 0x40(%rbx), %rbp
xorl %r15d, %r15d
testl %r12d, %r12d
cmovlel %r15d, %r12d
cmpq %r15, %r12
je 0xd4ef
movq (%r13,%r15,8), %rdi
movq %r14, %rsi
callq 0x3420
testl %eax, %eax
jne 0xd4ea
movl (%rbp,%r15,4), %eax
orl $0x2, %eax
cmpl $0x3, %eax
je 0xd51f
incq %r15
jmp 0xd4c7
leaq 0x137a(%rip), %rsi      # 0xe870
movq %rbx, %rdi
callq 0xc2ea
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc300
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xc2d4
movq %rbx, %rdi
movq (%rsp), %rsi
callq 0xd570
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xca68
movq %rbx, %rdi
movq %r15, %rsi
callq 0xd570
movsbl %bpl, %esi
movq %rbx, %rdi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xcbda
nop
// File: /workspace/github_cpp_makefile_star2_O2/JenTus[P]TCEM/src_TCEM/anyoption.cc
// Function: AnyOption::chomp(char*)
char*
AnyOption::chomp( char *str )
{
        while( *str == whitespace )
                str++;
        char *end = str+strlen(str)-1;
        while( *end == whitespace )
                end--;
        *(end+1) = nullterminate;
        return str;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movb 0xa8(%rdi), %bpl
movq %r15, %rax
incq %r15
cmpb %bpl, (%rax)
je 0xd584
leaq -0x1(%r15), %r14
movq %r14, %rdi
callq 0x3120
addq %r15, %rax
movq %rax, %rcx
decq %rax
cmpb %bpl, -0x2(%rcx)
je 0xd59e
movb 0xa9(%rbx), %cl
movb %cl, (%rax)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/JenTus[P]TCEM/src_TCEM/anyoption.cc
// Function: AnyOption::printUsage()
void
AnyOption::printUsage()
{
	
	if( once ) {
		once = false ;
		cout << endl ;
		for( int i = 0 ; i < usage_lines ; i++ )
			cout << usage[i] << endl ;	
		cout << endl ;
	}
}

// Assembly:
cmpb $0x1, 0xab(%rdi)
jne 0xd627
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movb $0x0, 0xab(%rdi)
movq 0x79f9(%rip), %r14      # 0x14fd8
movq %r14, %rdi
callq 0x3150
xorl %r15d, %r15d
movslq 0x94(%rbx), %rax
cmpq %rax, %r15
jge 0xd616
movq 0x88(%rbx), %rax
movq (%rax,%r15,8), %rsi
movq %r14, %rdi
callq 0x32c0
movq %rax, %rdi
callq 0x3150
incq %r15
jmp 0xd5ea
movq 0x79bb(%rip), %rdi      # 0x14fd8
popq %rbx
popq %r14
popq %r15
jmp 0x3150
retq
// File: /workspace/github_cpp_makefile_star2_O2/JenTus[P]TCEM/src_TCEM/anyoption.cc
// Function: AnyOption::addUsage(char const*)
void
AnyOption::addUsage( const char *line )
{
	if( usage_lines >= max_usage_lines ){
		if( doubleUsageStorage() == false ){
			addUsageError( line );
			exit(1);
		}
	}
	usage[ usage_lines ] = line ;	
	usage_lines++;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x94(%rdi), %eax
cmpl 0x90(%rdi), %eax
jl 0xd652
movq %rbx, %rdi
callq 0xc204
testb %al, %al
je 0xd66f
movl 0x94(%rbx), %eax
movq 0x88(%rbx), %rcx
cltq
movq %r14, (%rcx,%rax,8)
incl %eax
movl %eax, 0x94(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rsi
callq 0xd678
nop
// File: /workspace/github_cpp_makefile_star2_O2/JenTus[P]TCEM/src_TCEM/anyoption.cc
// Function: AnyOption::addUsageError(char const*)
void
AnyOption::addUsageError( const char *line )
{
	cout << endl ;
	cout << "OPTIONS ERROR : Failed allocating extra memory " << endl ;
	cout << "While adding the usage/help  : \""<< line << "\"" << endl;
	cout << "Exiting." << endl ;
	cout << endl ;
	exit(0);

}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq 0x7952(%rip), %rbx      # 0x14fd8
movq %rbx, %rdi
callq 0x3150
leaq 0x110e(%rip), %rsi      # 0xe7a3
movq %rbx, %rdi
callq 0x32c0
movq %rax, %rdi
callq 0x3150
leaq 0x11e6(%rip), %rsi      # 0xe892
movq %rbx, %rdi
callq 0x32c0
movq %rax, %rdi
movq %r14, %rsi
callq 0x32c0
leaq 0x11eb(%rip), %rsi      # 0xe8b1
movq %rax, %rdi
callq 0x32c0
movq %rax, %rdi
callq 0x3150
leaq 0x107a(%rip), %rsi      # 0xe757
movq %rbx, %rdi
callq 0x32c0
movq %rax, %rdi
callq 0x3150
movq %rbx, %rdi
callq 0x3150
xorl %edi, %edi
callq 0x3360
// File: /workspace/github_cpp_makefile_star2_O2/JenTus[P]TCEM/src_TCEM/sfmt/SFMT.c
// Function: sfmt_gen_rand_all
void sfmt_gen_rand_all(sfmt_t * sfmt) {
    int i;
    w128_t *r1, *r2;

    r1 = &sfmt->state[SFMT_N - 2];
    r2 = &sfmt->state[SFMT_N - 1];
    for (i = 0; i < SFMT_N - SFMT_POS1; i++) {
	do_recursion(&sfmt->state[i], &sfmt->state[i],
		     &sfmt->state[i + SFMT_POS1], r1, r2);
	r1 = r2;
	r2 = &sfmt->state[i];
    }
    for (; i < SFMT_N; i++) {
	do_recursion(&sfmt->state[i], &sfmt->state[i],
		     &sfmt->state[i + SFMT_POS1 - SFMT_N], r1, r2);
	r1 = r2;
	r2 = &sfmt->state[i];
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x9a0(%rdi), %rcx
leaq 0x9b0(%rdi), %r14
pushq $0x22
popq %r12
movq %rdi, %rax
subq $0x1, %r12
jb 0xd75a
movq %rax, %r15
leaq 0x7a0(%rax), %rdx
movq %rax, %rdi
movq %rax, %rsi
movq %r14, %r8
callq 0xd794
leaq 0x10(%r15), %rax
movq %r14, %rcx
movq %r15, %r14
jmp 0xd730
pushq $0x7a
popq %r12
subq $0x1, %r12
jb 0xd788
leaq 0x220(%rbx), %r15
movq %r15, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movq %r14, %r8
callq 0xd794
addq $0x10, %rbx
movq %r14, %rcx
movq %r15, %r14
jmp 0xd75e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/JenTus[P]TCEM/src_TCEM/sfmt/SFMT-common.h
// Function: do_recursion(W128_T*, W128_T*, W128_T*, W128_T*, W128_T*)
inline static void lshift128(w128_t *out, w128_t const *in, int shift)
{
    uint64_t th, tl, oh, ol;

    th = ((uint64_t)in->u[3] << 32) | ((uint64_t)in->u[2]);
    tl = ((uint64_t)in->u[1] << 32) | ((uint64_t)in->u[0]);

    oh = th << (shift * 8);
    ol = tl << (shift * 8);
    oh |= tl >> (64 - shift * 8);
    out->u[1] = (uint32_t)(ol >> 32);
    out->u[0] = (uint32_t)ol;
    out->u[3] = (uint32_t)(oh >> 32);
    out->u[2] = (uint32_t)oh;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl 0xc(%rsi), %eax
movl 0x8(%rsi), %r9d
movl (%rsi), %r14d
movl 0x4(%rsi), %r10d
shlq $0x28, %rax
shlq $0x8, %r9
orq %r9, %rax
movq %r10, %rbx
shlq $0x28, %rbx
movq %r14, %r15
shlq $0x8, %r15
orq %r15, %rbx
shrl $0x18, %r10d
orl %r10d, %r9d
shrq $0x20, %rax
movl 0xc(%rcx), %r10d
movq %r10, %r11
shlq $0x20, %r11
movl 0x8(%rcx), %r12d
orq %r12, %r11
movq (%rcx), %rcx
shrq $0x8, %r11
shrdq $0x8, %r12, %rcx
shrl $0x8, %r10d
movl (%rdx), %ebp
shrl $0xb, %ebp
andl $-0x11, %ebp
movl (%r8), %r12d
shll $0x12, %r12d
xorl %ebp, %r12d
xorl %ecx, %r15d
xorl %r12d, %r15d
xorl %r14d, %r15d
movl %r15d, (%rdi)
movl 0x4(%rdx), %ebp
shrl $0xb, %ebp
andl $0x1ecb7f, %ebp         # imm = 0x1ECB7F
movl 0x4(%r8), %r14d
shll $0x12, %r14d
xorl %ebp, %r14d
xorq %rbx, %rcx
shrq $0x20, %rcx
xorl 0x4(%rsi), %ecx
xorl %r14d, %ecx
movl %ecx, 0x4(%rdi)
movl 0x8(%rdx), %ecx
shrl $0xb, %ecx
andl $0x1affff, %ecx         # imm = 0x1AFFFF
movl 0x8(%r8), %ebx
shll $0x12, %ebx
xorl %ecx, %ebx
xorl %r9d, %r11d
xorl 0x8(%rsi), %r11d
xorl %ebx, %r11d
movl %r11d, 0x8(%rdi)
movl 0xc(%rdx), %ecx
shrl $0xb, %ecx
andl $-0xa, %ecx
movl 0xc(%r8), %edx
shll $0x12, %edx
xorl %ecx, %edx
xorl %eax, %r10d
xorl 0xc(%rsi), %r10d
xorl %edx, %r10d
movl %r10d, 0xc(%rdi)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/JenTus[P]TCEM/src_TCEM/sfmt/SFMT.c
// Function: sfmt_fill_array32
void sfmt_fill_array32(sfmt_t * sfmt, uint32_t *array, int size) {
    assert(sfmt->idx == SFMT_N32);
    assert(size % 4 == 0);
    assert(size >= SFMT_N32);

    gen_rand_array(sfmt, (w128_t *)array, size / 4);
    sfmt->idx = SFMT_N32;
}

// Assembly:
pushq %rbx
cmpl $0x270, 0x9c0(%rdi)     # imm = 0x270
jne 0xd8b5
testb $0x3, %dl
jne 0xd8d4
cmpl $0x26f, %edx            # imm = 0x26F
jle 0xd8f3
movq %rdi, %rbx
shrl $0x2, %edx
callq 0xd912
movl $0x270, 0x9c0(%rbx)     # imm = 0x270
popq %rbx
retq
leaq 0x1034(%rip), %rdi      # 0xe8f0
leaq 0x1043(%rip), %rsi      # 0xe906
leaq 0x1051(%rip), %rcx      # 0xe91b
movl $0x11c, %edx            # imm = 0x11C
callq 0x31a0
leaq 0x1072(%rip), %rdi      # 0xe94d
leaq 0x1024(%rip), %rsi      # 0xe906
leaq 0x1032(%rip), %rcx      # 0xe91b
movl $0x11d, %edx            # imm = 0x11D
callq 0x31a0
leaq 0x1061(%rip), %rdi      # 0xe95b
leaq 0x1005(%rip), %rsi      # 0xe906
leaq 0x1013(%rip), %rcx      # 0xe91b
movl $0x11e, %edx            # imm = 0x11E
callq 0x31a0
// File: /workspace/github_cpp_makefile_star2_O2/JenTus[P]TCEM/src_TCEM/sfmt/SFMT.c
// Function: gen_rand_array(SFMT_T*, W128_T*, int)
inline static void gen_rand_array(sfmt_t * sfmt, w128_t *array, int size) {
    int i, j;
    w128_t *r1, *r2;

    r1 = &sfmt->state[SFMT_N - 2];
    r2 = &sfmt->state[SFMT_N - 1];
    for (i = 0; i < SFMT_N - SFMT_POS1; i++) {
	do_recursion(&array[i], &sfmt->state[i], &sfmt->state[i + SFMT_POS1], r1, r2);
	r1 = r2;
	r2 = &array[i];
    }
    for (; i < SFMT_N; i++) {
	do_recursion(&array[i], &sfmt->state[i],
		     &array[i + SFMT_POS1 - SFMT_N], r1, r2);
	r1 = r2;
	r2 = &array[i];
    }
    for (; i < size - SFMT_N; i++) {
	do_recursion(&array[i], &array[i - SFMT_N],
		     &array[i + SFMT_POS1 - SFMT_N], r1, r2);
	r1 = r2;
	r2 = &array[i];
    }
    for (j = 0; j < 2 * SFMT_N - size; j++) {
	sfmt->state[j] = array[j + size - SFMT_N];
    }
    for (; i < size; i++, j++) {
	do_recursion(&array[i], &array[i - SFMT_N],
		     &array[i + SFMT_POS1 - SFMT_N], r1, r2);
	r1 = r2;
	r2 = &array[i];
	sfmt->state[j] = array[i];
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x10(%rsp)
movq %rdi, %rbx
leaq 0x9a0(%rdi), %rcx
leaq 0x9b0(%rdi), %r12
pushq $0x22
popq %r14
movq %rsi, 0x8(%rsp)
movq %rsi, %rax
movq %rdi, %r13
subq $0x1, %r14
jb 0xd973
movq %rax, %rbp
leaq 0x7a0(%r13), %rdx
movq %rax, %rdi
movq %r13, %rsi
movq %r12, %r8
callq 0xd794
addq $0x10, %r13
leaq 0x10(%rbp), %rax
movq %r12, %rcx
movq %rbp, %r12
jmp 0xd945
leaq 0x220(%rbx), %r13
pushq $0x7a
popq %r15
movq 0x8(%rsp), %rbp
subq $0x1, %r15
jb 0xd9b1
leaq 0x220(%rbp), %r14
movq %r14, %rdi
movq %r13, %rsi
movq %rbp, %rdx
movq %r12, %r8
callq 0xd794
addq $0x10, %r13
addq $0x10, %rbp
movq %r12, %rcx
movq %r14, %r12
jmp 0xd983
movq 0x10(%rsp), %rax
addl $0xffffff64, %eax       # imm = 0xFFFFFF64
movslq %eax, %r15
movl $0x9c, %ebp
movq 0x8(%rsp), %r13
cmpq %r15, %rbp
jge 0xd9f8
leaq 0x9c0(%r13), %r14
leaq 0x7a0(%r13), %rdx
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %r8
callq 0xd794
incq %rbp
addq $0x10, %r13
movq %r12, %rcx
movq %r14, %r12
jmp 0xd9c8
movl $0x138, %eax            # imm = 0x138
movq 0x10(%rsp), %rdx
subl %edx, %eax
movslq %edx, %r14
xorl %edx, %edx
testl %eax, %eax
cmovlel %edx, %eax
movq %r14, %rsi
shlq $0x4, %rsi
movq 0x8(%rsp), %rdi
addq %rdi, %rsi
addq $-0x9c0, %rsi           # imm = 0xF640
shlq $0x4, %rax
addq $0x9c0, %r13            # imm = 0x9C0
cmpq %rdx, %rax
je 0xda42
movups (%rsi,%rdx), %xmm0
movups %xmm0, (%rbx,%rdx)
addq $0x10, %rdx
jmp 0xda2f
addq %rax, %rbx
cmpq %r14, %rbp
jge 0xda81
movq %r13, %r15
leaq -0x9c0(%r13), %rsi
leaq -0x220(%r13), %rdx
movq %r13, %rdi
movq %r12, %r8
callq 0xd794
movups (%r13), %xmm0
movups %xmm0, (%rbx)
incq %rbp
addq $0x10, %rbx
addq $0x10, %r13
movq %r12, %rcx
movq %r15, %r12
jmp 0xda45
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/JenTus[P]TCEM/src_TCEM/sfmt/SFMT.c
// Function: sfmt_fill_array64
void sfmt_fill_array64(sfmt_t * sfmt, uint64_t *array, int size) {
    assert(sfmt->idx == SFMT_N32);
    assert(size % 2 == 0);
    assert(size >= SFMT_N64);

    gen_rand_array(sfmt, (w128_t *)array, size / 2);
    sfmt->idx = SFMT_N32;

#if defined(BIG_ENDIAN64) && !defined(ONLY64)
    swap((w128_t *)array, size /2);
#endif
}

// Assembly:
pushq %rbx
cmpl $0x270, 0x9c0(%rdi)     # imm = 0x270
jne 0xdac0
testb $0x1, %dl
jne 0xdadf
cmpl $0x137, %edx            # imm = 0x137
jle 0xdafe
movq %rdi, %rbx
shrl %edx
callq 0xd912
movl $0x270, 0x9c0(%rbx)     # imm = 0x270
popq %rbx
retq
leaq 0xe29(%rip), %rdi       # 0xe8f0
leaq 0xe38(%rip), %rsi       # 0xe906
leaq 0xe97(%rip), %rcx       # 0xe96c
movl $0x140, %edx            # imm = 0x140
callq 0x31a0
leaq 0xeb8(%rip), %rdi       # 0xe99e
leaq 0xe19(%rip), %rsi       # 0xe906
leaq 0xe78(%rip), %rcx       # 0xe96c
movl $0x141, %edx            # imm = 0x141
callq 0x31a0
leaq 0xea7(%rip), %rdi       # 0xe9ac
leaq 0xdfa(%rip), %rsi       # 0xe906
leaq 0xe59(%rip), %rcx       # 0xe96c
movl $0x142, %edx            # imm = 0x142
callq 0x31a0
// File: /workspace/github_cpp_makefile_star2_O2/JenTus[P]TCEM/src_TCEM/sfmt/SFMT.c
// Function: sfmt_init_gen_rand
void sfmt_init_gen_rand(sfmt_t * sfmt, uint32_t seed) {
    int i;

    uint32_t *psfmt32 = &sfmt->state[0].u[0];

    psfmt32[idxof(0)] = seed;
    for (i = 1; i < SFMT_N32; i++) {
	psfmt32[idxof(i)] = 1812433253UL * (psfmt32[idxof(i - 1)]
					    ^ (psfmt32[idxof(i - 1)] >> 30))
	    + i;
    }
    sfmt->idx = SFMT_N32;
    period_certification(sfmt);
}

// Assembly:
movl %esi, (%rdi)
pushq $0x1
popq %rax
cmpq $0x270, %rax            # imm = 0x270
je 0xdb45
movl -0x4(%rdi,%rax,4), %ecx
movl %ecx, %edx
shrl $0x1e, %edx
xorl %ecx, %edx
imull $0x6c078965, %edx, %ecx # imm = 0x6C078965
addl %eax, %ecx
movl %ecx, (%rdi,%rax,4)
incq %rax
jmp 0xdb22
movl $0x270, 0x9c0(%rdi)     # imm = 0x270
jmp 0xdb51
// File: /workspace/github_cpp_makefile_star2_O2/ef-gy[P]libefgy/include/ef.gy/series.h
// Function: efgy::math::series::power<efgy::math::numeric::fractional<long long>, efgy::math::algorithm::powerSeriesE, unsigned long long>::sumTo(unsigned long long const&, efgy::math::numeric::fractional<long long> const&, efgy::math::numeric::fractional<long long> const&, efgy::math::numeric::fractional<long long> const&, efgy::math::numeric::fractional<long long> const&)
constexpr static Q sumTo(const N &n, const Q &f, const Q &x, const Q &c,
                           const Q &acc) {
    return n == 0 ? acc + (sequence::at(0) * f)
                  : sumTo(n - 1, f, x, c,
                          acc + (sequence::at(n) * f *
                                 exponentiate::integral<Q>::raise(x - c, n)));
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %r8, %rbx
movq %rsi, %r14
movq (%rdi), %rax
testq %rax, %rax
je 0xf31d
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %rbp
decq %rax
leaq 0x8(%rsp), %rcx
movq %rax, (%rcx)
callq 0xf564
leaq 0x68(%rsp), %rdi
movq %rax, (%rdi)
movq %rdx, 0x8(%rdi)
movq %r14, %rsi
callq 0xf3a4
leaq 0x18(%rsp), %r13
movq %rax, (%r13)
movq %rdx, 0x8(%r13)
movq %r12, %rdi
movq %r15, %rsi
callq 0xf498
leaq 0x48(%rsp), %rdi
movq %rax, (%rdi)
movq %rdx, 0x8(%rdi)
movq (%rbp), %rax
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
callq 0xf3d8
leaq 0x58(%rsp), %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
movq %r13, %rdi
callq 0xf3a4
leaq 0x28(%rsp), %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
movq %rbx, %rdi
callq 0xf362
leaq 0x38(%rsp), %r8
movq %rax, (%r8)
movq %rdx, 0x8(%r8)
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0xf252
jmp 0xf353
leaq 0x18(%rsp), %rdi
andq $0x0, (%rdi)
callq 0xf564
leaq 0x28(%rsp), %rdi
movq %rax, (%rdi)
movq %rdx, 0x8(%rdi)
movq %r14, %rsi
callq 0xf3a4
leaq 0x38(%rsp), %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
movq %rbx, %rdi
callq 0xf362
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tobias93[P]piano/rtaudio/tests/testall.cpp
// Function: sawi(void*, void*, unsigned int, double, unsigned int, void*)
int sawi( void *outputBuffer, void * /*inputBuffer*/, unsigned int nBufferFrames,
          double /*streamTime*/, RtAudioStreamStatus status, void *data )
{
  unsigned int i, j;
  extern unsigned int channels;
  double *buffer = (double *) outputBuffer;
  double *lastValues = (double *) data;

  if ( status )
    std::cout << "Stream underflow detected!" << std::endl;

  for ( i=0; i<nBufferFrames; i++ ) {
    for ( j=0; j<channels; j++ ) {
      *buffer++ = (double) lastValues[j];
      lastValues[j] += BASE_RATE * (j+1+(j*0.1));
      if ( lastValues[j] >= 1.0 ) lastValues[j] -= 2.0;
    }
  }

  return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %r8, %rbx
movl %edx, %ebp
movq %rdi, %r14
testl %ecx, %ecx
je 0x45cf
movq 0x7a0d(%rip), %rdi      # 0xbfc8
leaq 0x3bf7(%rip), %rsi      # 0x81b9
callq 0x41d0
movq %rax, %rdi
callq 0x40d0
movl 0x7c43(%rip), %eax      # 0xc218
shlq $0x3, %rax
xorl %ecx, %ecx
movsd 0x3a25(%rip), %xmm0     # 0x8008
movsd 0x3a25(%rip), %xmm1     # 0x8010
movsd 0x3a25(%rip), %xmm2     # 0x8018
movsd 0x3a25(%rip), %xmm3     # 0x8020
cmpl %ebp, %ecx
je 0x4664
xorl %edx, %edx
xorl %esi, %esi
cmpq %rdx, %rax
je 0x465d
movsd (%rbx,%rdx), %xmm4
movsd %xmm4, (%r14,%rdx)
movl %esi, %edi
incq %rsi
movl %esi, %r8d
cvtsi2sd %r8, %xmm5
cvtsi2sd %rdi, %xmm6
mulsd %xmm0, %xmm6
addsd %xmm5, %xmm6
mulsd %xmm1, %xmm6
addsd %xmm4, %xmm6
movapd %xmm6, %xmm4
addsd %xmm2, %xmm4
movapd %xmm3, %xmm5
cmpnlesd %xmm6, %xmm5
andpd %xmm5, %xmm6
andnpd %xmm4, %xmm5
orpd %xmm6, %xmm5
movlpd %xmm5, (%rbx,%rdx)
addq $0x8, %rdx
jmp 0x4603
incl %ecx
addq %rdx, %r14
jmp 0x45fb
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tobias93[P]piano/rtaudio/tests/testall.cpp
// Function: inout(void*, void*, unsigned int, double, unsigned int, void*)
int inout( void *outputBuffer, void *inputBuffer, unsigned int /*nBufferFrames*/,
           double /*streamTime*/, RtAudioStreamStatus status, void *data )
{
  // Since the number of input and output channels is equal, we can do
  // a simple buffer copy operation here.
  if ( status ) std::cout << "Stream over/underflow detected." << std::endl;

  unsigned int *bytes = (unsigned int *) data;
  memcpy( outputBuffer, inputBuffer, *bytes );
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %r8, %r15
movq %rsi, %rbx
movq %rdi, %r14
testl %ecx, %ecx
je 0x4757
movq 0x7885(%rip), %rdi      # 0xbfc8
leaq 0x3a8a(%rip), %rsi      # 0x81d4
callq 0x41d0
movq %rax, %rdi
callq 0x40d0
movl (%r15), %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4170
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/tmtxt[P]microcontroller-emulation/main.cpp
// Function: main
int main(int argc, char *argv[])
{
	// VARIABLES USED FOR THIS PROGRAM
	
	// userOption: stores the user option. The program must handle both
	// upperand lowercase so that this variable will save only lowercase value.
	// The program have to change it to lowercase before saving
	char userOption;

	// The Microcontroller of the program
	Microcontroller* microcontroller = 0;

	
	// EXECUTION OF PROGRAM

	// print welcome
	cout << "MICROCONTROLLER SIMULATOR" << endl;
	
	// Start the program
	// Loop for user enter option until user enter 'q' or 'Q'
	do
	{
		// Display the application prompt
		cout << "Message: Enter the option you want. Type h for help" << endl;
		cout << "> ";
		
		// Read user input
		userOption = inputOption();

		cout << endl;

		// Check the userOption variable and the switch the user to the right function
		switchOption(userOption, &microcontroller);

		if(userOption != 'q'){
			// Display a newline character, just for decoration
			cout << endl;
		}
		
	} while (userOption != 'q');

	// print the goodbye message
	cout << "Quitting..." << endl;
	cout << "Thank you for using my software." << endl;
	
	// End the program
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
leaq 0x8(%rsp), %rbx
andq $0x0, (%rbx)
movq 0x6af0(%rip), %r14      # 0x8fc8
leaq 0x2b69(%rip), %rsi      # 0x5048
movq %r14, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20b0
leaq 0x2b6c(%rip), %r15      # 0x5062
leaq 0x2b99(%rip), %r12      # 0x5096
movq %r14, %rdi
movq %r15, %rsi
callq 0x2170
movq %rax, %rdi
callq 0x20b0
movq %r14, %rdi
movq %r12, %rsi
callq 0x2170
callq 0x258c
movl %eax, %ebp
movq %r14, %rdi
callq 0x20b0
movsbl %bpl, %ebp
movl %ebp, %edi
movq %rbx, %rsi
callq 0x25f2
cmpb $0x71, %bpl
je 0x2548
movq %r14, %rdi
callq 0x20b0
jmp 0x24fd
movq 0x6a79(%rip), %rbx      # 0x8fc8
leaq 0x2b43(%rip), %rsi      # 0x5099
movq %rbx, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20b0
leaq 0x2b38(%rip), %rsi      # 0x50a5
movq %rbx, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20b0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tmtxt[P]microcontroller-emulation/main.cpp
// Function: optionConnectHandler(mcontroller::Microcontroller**)
void optionConnectHandler(Microcontroller** microcontroller){

	// a factory for creating microcontroller
	MicrocontrollerFactory factory;

	// first free memory for the existing microcontroller
	delete *microcontroller;
	
	// display the prompt to ask user to enter microcontroller type
	cout << "Message: Connect to Microcontroller" << endl;
	cout << "Message: Auto disconnect other Microcontroller (if aleady connected)" << endl;
	cout << "Message: Enter the type of microcontroller to connect" << endl;
	cout << "type? ";

	// read the microcontroller type from user
	string inputMicrocontrollerType;
	cin >> inputMicrocontrollerType;

	// create microcontroller
	(*microcontroller) = factory.createMicrocontroller(inputMicrocontrollerType);
	
}

// Assembly:
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
leaq 0x40(%rsp), %rdi
callq 0x4424
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2689
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x6938(%rip), %rdi      # 0x8fc8
leaq 0x2b78(%rip), %rsi      # 0x520f
callq 0x2170
movq %rax, %rdi
callq 0x20b0
movq 0x691d(%rip), %rdi      # 0x8fc8
leaq 0x2b81(%rip), %rsi      # 0x5233
callq 0x2170
movq %rax, %rdi
callq 0x20b0
movq 0x6902(%rip), %rdi      # 0x8fc8
leaq 0x2bab(%rip), %rsi      # 0x5278
callq 0x2170
movq %rax, %rdi
callq 0x20b0
movq 0x68e7(%rip), %rdi      # 0x8fc8
leaq 0x2bc6(%rip), %rsi      # 0x52ae
callq 0x2170
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x68d3(%rip), %rdi      # 0x8fd8
movq %rsp, %rsi
callq 0x21b0
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x21e0
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x457a
movq %rax, (%rbx)
leaq 0x20(%rsp), %rdi
callq 0x20a0
movq %rsp, %rdi
callq 0x20a0
leaq 0x40(%rsp), %rdi
callq 0x2e62
addq $0x70, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x20a0
jmp 0x2760
movq %rax, %rbx
movq %rsp, %rdi
callq 0x20a0
jmp 0x276d
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x2e62
movq %rbx, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O2/tmtxt[P]microcontroller-emulation/main.cpp
// Function: executeOptionIfConnected(mcontroller::Microcontroller**, void (*)(mcontroller::Microcontroller**))
void executeOptionIfConnected(Microcontroller** microcontroller, optionHandler* handlerFunction){
	
	// check whether the microcontroller is connected
	if((*microcontroller) == 0){
		// Not connected
		// print the message to cerr
		cerr << "Error: Not connected to any controller!" << endl;
		cerr << "Message: Type c to connect to a controller." << endl;
		cerr << "Message: Type h for help." << endl;
	} else {
		// Connected
		// execute the handler function
		handlerFunction(microcontroller);
	}
}

// Assembly:
cmpq $0x0, (%rdi)
je 0x2787
jmpq *%rsi
pushq %rbx
movq 0x6861(%rip), %rbx      # 0x8ff0
leaq 0x2d61(%rip), %rsi      # 0x54f7
movq %rbx, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20b0
leaq 0x2d72(%rip), %rsi      # 0x551f
movq %rbx, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20b0
leaq 0x2d87(%rip), %rsi      # 0x554b
movq %rbx, %rdi
callq 0x2170
movq %rax, %rdi
popq %rbx
jmp 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/tmtxt[P]microcontroller-emulation/main.cpp
// Function: optionDisplayAllMemoryHandler(mcontroller::Microcontroller**)
void optionDisplayAllMemoryHandler(mcontroller::Microcontroller** microcontroller){

	// print the message for user
	cout << "Message: Display all memory." << endl;
	
	// the memory array
	unsigned char* memory = (*microcontroller)->getMemory();

	// the memory size
	int memorySize = (*microcontroller)->getMemorySize();

	// loop through the memory array and display
	for (int i = 0; i < memorySize; ++i)
	{
		// special case: add new line and print the left-most value
		if((i % 16) == 0){
			cout << endl;
			cout << std::setfill('0') << std::setw(4);
			cout << hex << i;
			cin.clear();
		}

		// special case: current column is column 8, print one more extra space
		if((i % 8) == 0){
			cout << " ";
		}

		// normal case: print the value in that memory address
		cout << " ";
		cout << std::setfill('0') << std::setw(2);
		int value = memory[i];
		cout << hex << value;
		cin.clear();
	}

	cout << endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movq 0x67de(%rip), %rbx      # 0x8fc8
leaq 0x2c28(%rip), %rsi      # 0x5419
movq %rbx, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20b0
movq (%r15), %rdi
callq 0x2fc4
movq %rax, %r14
movq (%r15), %rdi
callq 0x2fca
movl %eax, %r15d
xorl %r12d, %r12d
testl %eax, %eax
cmovlel %r12d, %r15d
movq 0x67b1(%rip), %rbp      # 0x8fd8
leaq 0x2b78(%rip), %r13      # 0x53a6
cmpq %r12, %r15
je 0x2905
testb $0xf, %r12b
jne 0x2892
movq %rbx, %rdi
callq 0x20b0
movq %rbx, %rdi
pushq $0x30
popq %rsi
callq 0x2220
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq $0x4, 0x10(%rax,%rcx)
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl 0x18(%rbx,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%rbx,%rax)
movq %rbx, %rdi
movl %r12d, %esi
callq 0x2260
movq (%rbp), %rax
movq -0x18(%rax), %rdi
addq %rbp, %rdi
xorl %esi, %esi
callq 0x2250
testb $0x7, %r12b
jne 0x28a3
movq %rbx, %rdi
movq %r13, %rsi
callq 0x2170
movq %rbx, %rdi
movq %r13, %rsi
callq 0x2170
movq %rbx, %rdi
pushq $0x30
popq %rsi
callq 0x2220
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq $0x2, 0x10(%rax,%rcx)
movzbl (%r14,%r12), %esi
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl 0x18(%rbx,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%rbx,%rax)
movq %rbx, %rdi
callq 0x2260
movq (%rbp), %rax
movq -0x18(%rax), %rdi
addq %rbp, %rdi
xorl %esi, %esi
callq 0x2250
incq %r12
jmp 0x282e
movq 0x66bc(%rip), %rdi      # 0x8fc8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/tmtxt[P]microcontroller-emulation/main.cpp
// Function: optionExecuteHandler(mcontroller::Microcontroller**)
void optionExecuteHandler(mcontroller::Microcontroller** microcontroller){

	// print the message for user
	cout << "Message: Execute from current PC" << endl;
	
	// execute the opcode
	(*microcontroller)->execute();
	
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x669e(%rip), %rdi      # 0x8fc8
leaq 0x2b05(%rip), %rsi      # 0x5436
callq 0x2170
movq %rax, %rdi
callq 0x20b0
movq (%rbx), %rdi
movq (%rdi), %rax
popq %rbx
jmpq *0x18(%rax)