LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x20090
testb $0x1, %al
jne 0x206f0
movb $0x0, 0x37(%rsp)
jmp 0x2079f
movl $0x0, 0x14(%rsp)
movq 0x8(%rsp), %rcx
movl 0x14(%rsp), %eax
cmpl 0x50(%rcx), %eax
jge 0x2079a
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rax
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x20(%rsp), %rsi
callq 0x4510
cmpl $0x0, %eax
jne 0x20788
movq 0x18(%rsp), %rdi
callq 0x4150
movq %rax, %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
callq 0x44b0
movq 0x8(%rsp), %rcx
movq %rax, %rsi
movq 0x78(%rcx), %rax
movq 0x48(%rcx), %rdx
movslq 0x14(%rsp), %rdi
movslq (%rdx,%rdi,4), %rdx
movq %rsi, (%rax,%rdx,8)
movq 0x78(%rcx), %rax
movq 0x48(%rcx), %rcx
movslq 0x14(%rsp), %rdx
movslq (%rcx,%rdx,4), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x18(%rsp), %rsi
callq 0x4340
movb $0x1, 0x37(%rsp)
jmp 0x2079f
jmp 0x2078a
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x206f8
movb $0x0, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x20(%rsp)
movl $0x0, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
callq 0x4150
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x208ea
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rax
movl 0x2c(%rsp), %ecx
movb (%rax,%rcx), %al
movb %al, 0x2b(%rsp)
movsbl 0x2b(%rsp), %esi
callq 0x20a50
testb $0x1, %al
jne 0x2081c
jmp 0x208d8
movl 0x2c(%rsp), %eax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
callq 0x4150
movq %rax, %rcx
movq 0x10(%rsp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jne 0x2084d
movb 0x2b(%rsp), %al
movb %al, 0x47(%rsp)
jmp 0x20923
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
movq 0x20(%rsp), %rax
movq 0x30(%rsp), %rcx
movl 0x2c(%rsp), %edx
movsbl (%rcx,%rdx), %ecx
movsbl 0xa8(%rax), %edx
movb $0x1, %al
cmpl %edx, %ecx
movb %al, 0xf(%rsp)
je 0x2089d
movq 0x20(%rsp), %rcx
movq 0x30(%rsp), %rax
movl 0x2c(%rsp), %edx
movsbl (%rax,%rdx), %eax
movsbl 0xa4(%rcx), %ecx
cmpl %ecx, %eax
sete %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x208a7
jmp 0x208b4
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x20858
movq 0x20(%rsp), %rdi
movb 0x2b(%rsp), %al
movq 0x30(%rsp), %rdx
movl 0x2c(%rsp), %ecx
addq %rcx, %rdx
movsbl %al, %esi
callq 0x20930
movb $0x30, 0x47(%rsp)
jmp 0x20923
jmp 0x208da
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x207d0
movq 0x20(%rsp), %rdi
leaq 0x3f11(%rip), %rsi      # 0x24807
callq 0x1f6c0
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x1f700
movq 0x20(%rsp), %rdi
callq 0x1f690
movq 0x20(%rsp), %rdi
callq 0x20a20
movb $0x30, 0x47(%rsp)
movb 0x47(%rsp), %al
addq $0x48, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movb %sil, %al
movq %rdi, 0x28(%rsp)
movb %al, 0x27(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x20090
testb $0x1, %al
jne 0x20962
movb $0x0, 0x37(%rsp)
jmp 0x20a0b
movl $0x0, 0x14(%rsp)
movq 0x8(%rsp), %rcx
movl 0x14(%rsp), %eax
cmpl 0x70(%rcx), %eax
jge 0x20a06
movq 0x8(%rsp), %rax
movq 0x58(%rax), %rax
movslq 0x14(%rsp), %rcx
movsbl (%rax,%rcx), %eax
movsbl 0x27(%rsp), %ecx
cmpl %ecx, %eax
jne 0x209f4
movq 0x18(%rsp), %rdi
callq 0x4150
movq %rax, %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
callq 0x44b0
movq 0x8(%rsp), %rcx
movq %rax, %rsi
movq 0x78(%rcx), %rax
movq 0x68(%rcx), %rdx
movslq 0x14(%rsp), %rdi
movslq (%rdx,%rdi,4), %rdx
movq %rsi, (%rax,%rdx,8)
movq 0x78(%rcx), %rax
movq 0x68(%rcx), %rcx
movslq 0x14(%rsp), %rdx
movslq (%rcx,%rdx,4), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x18(%rsp), %rsi
callq 0x4340
movb $0x1, 0x37(%rsp)
jmp 0x20a0b
jmp 0x209f6
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x2096a
movb $0x0, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x18(%rsp)
movb %al, 0x17(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
movq 0x8(%rsp), %rcx
movl 0x10(%rsp), %eax
cmpl 0x70(%rcx), %eax
jge 0x20b25
movq 0x8(%rsp), %rax
movq 0x58(%rax), %rax
movslq 0x10(%rsp), %rcx
movsbl (%rax,%rcx), %eax
movsbl 0x17(%rsp), %ecx
cmpl %ecx, %eax
jne 0x20b13
movq 0x8(%rsp), %rax
movq 0x60(%rax), %rax
movslq 0x10(%rsp), %rcx
cmpl $0x1, (%rax,%rcx,4)
je 0x20ac7
movq 0x8(%rsp), %rax
movq 0x60(%rax), %rax
movslq 0x10(%rsp), %rcx
cmpl $0x2, (%rax,%rcx,4)
jne 0x20ad1
movb $0x1, 0x27(%rsp)
jmp 0x20b5e
movq 0x8(%rsp), %rax
movq 0x60(%rax), %rax
movslq 0x10(%rsp), %rcx
cmpl $0x4, (%rax,%rcx,4)
je 0x20af9
movq 0x8(%rsp), %rax
movq 0x60(%rax), %rax
movslq 0x10(%rsp), %rcx
cmpl $0x5, (%rax,%rcx,4)
jne 0x20b0f
movq 0x8(%rsp), %rdi
movsbl 0x17(%rsp), %esi
callq 0x20d70
movb $0x0, 0x27(%rsp)
jmp 0x20b5e
jmp 0x20b11
jmp 0x20b13
jmp 0x20b15
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x20a72
movq 0x8(%rsp), %rdi
leaq 0x3cd6(%rip), %rsi      # 0x24807
callq 0x1f6c0
movq 0x8(%rsp), %rdi
movsbl 0x17(%rsp), %esi
callq 0x1f740
movq 0x8(%rsp), %rdi
callq 0x1f690
movq 0x8(%rsp), %rdi
callq 0x20a20
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movl $0x0, 0xc(%rsp)
movq (%rsp), %rcx
movl 0xc(%rsp), %eax
cmpl 0x50(%rcx), %eax
jge 0x20c47
movq (%rsp), %rax
movq 0x38(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x10(%rsp), %rsi
callq 0x4510
cmpl $0x0, %eax
jne 0x20c35
movq (%rsp), %rax
movq 0x40(%rax), %rax
movslq 0xc(%rsp), %rcx
cmpl $0x1, (%rax,%rcx,4)
je 0x20be6
movq (%rsp), %rax
movq 0x40(%rax), %rax
movslq 0xc(%rsp), %rcx
cmpl $0x2, (%rax,%rcx,4)
jne 0x20bf3
movl 0xc(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x20c7f
movq (%rsp), %rax
movq 0x40(%rax), %rax
movslq 0xc(%rsp), %rcx
cmpl $0x4, (%rax,%rcx,4)
je 0x20c19
movq (%rsp), %rax
movq 0x40(%rax), %rax
movslq 0xc(%rsp), %rcx
cmpl $0x5, (%rax,%rcx,4)
jne 0x20c31
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x20c90
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x20c7f
jmp 0x20c33
jmp 0x20c35
jmp 0x20c37
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x20b8f
movq (%rsp), %rdi
leaq 0x3bb5(%rip), %rsi      # 0x24807
callq 0x1f6c0
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x1f700
movq (%rsp), %rdi
callq 0x1f690
movq (%rsp), %rdi
callq 0x20a20
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x20090
testb $0x1, %al
jne 0x20cba
movb $0x0, 0x27(%rsp)
jmp 0x20d58
movl $0x0, 0xc(%rsp)
movq (%rsp), %rcx
movl 0xc(%rsp), %eax
cmpl 0x50(%rcx), %eax
jge 0x20d53
movq (%rsp), %rax
movq 0x38(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x10(%rsp), %rsi
callq 0x4510
cmpl $0x0, %eax
jne 0x20d41
movl $0x5, %edi
callq 0x44b0
movq (%rsp), %rcx
movq %rax, %rsi
movq 0x78(%rcx), %rax
movq 0x48(%rcx), %rdx
movslq 0xc(%rsp), %rdi
movslq (%rdx,%rdi,4), %rdx
movq %rsi, (%rax,%rdx,8)
movq 0x78(%rcx), %rax
movq 0x48(%rcx), %rcx
movslq 0xc(%rsp), %rdx
movslq (%rcx,%rdx,4), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x3b19(%rip), %rsi      # 0x2484e
callq 0x4340
movb $0x1, 0x27(%rsp)
jmp 0x20d58
jmp 0x20d43
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x20cc2
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: JenTus[P]TCEM/src_TCEM/anyoption.cc
// Function: AnyOption::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:
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x18(%rsp)
movb %al, 0x17(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x20090
testb $0x1, %al
jne 0x20d9d
movb $0x0, 0x27(%rsp)
jmp 0x20e34
movl $0x0, 0x10(%rsp)
movq 0x8(%rsp), %rcx
movl 0x10(%rsp), %eax
cmpl 0x70(%rcx), %eax
jge 0x20e2f
movq 0x8(%rsp), %rax
movq 0x58(%rax), %rax
movslq 0x10(%rsp), %rcx
movsbl (%rax,%rcx), %eax
movsbl 0x17(%rsp), %ecx
cmpl %ecx, %eax
jne 0x20e1d
movl $0x5, %edi
callq 0x44b0
movq 0x8(%rsp), %rcx
movq %rax, %rsi
movq 0x78(%rcx), %rax
movq 0x68(%rcx), %rdx
movslq 0x10(%rsp), %rdi
movslq (%rdx,%rdi,4), %rdx
movq %rsi, (%rax,%rdx,8)
movq 0x78(%rcx), %rax
movq 0x68(%rcx), %rcx
movslq 0x10(%rsp), %rdx
movslq (%rcx,%rdx,4), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x3a3d(%rip), %rsi      # 0x2484e
callq 0x4340
movb $0x1, 0x27(%rsp)
jmp 0x20e34
jmp 0x20e1f
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x20da5
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nop
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x20090
testb $0x1, %al
jne 0x20e9d
movq 0xe171(%rip), %rdi      # 0x2efd8
leaq 0x39bc(%rip), %rsi      # 0x2482a
callq 0x4370
movq %rax, %rdi
movq 0x10(%rsp), %rsi
callq 0x4370
movq %rax, %rdi
movq 0xe13e(%rip), %rsi      # 0x2efc8
callq 0x43c0
movq $0x0, 0x20(%rsp)
jmp 0x20f39
movl $0x0, 0xc(%rsp)
movq (%rsp), %rcx
movl 0xc(%rsp), %eax
cmpl 0x50(%rcx), %eax
jge 0x20f01
movq (%rsp), %rax
movq 0x38(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x10(%rsp), %rsi
callq 0x4510
cmpl $0x0, %eax
jne 0x20ef2
movq (%rsp), %rcx
movq 0x78(%rcx), %rax
movq 0x48(%rcx), %rcx
movslq 0xc(%rsp), %rdx
movslq (%rcx,%rdx,4), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x20(%rsp)
jmp 0x20f39
jmp 0x20ef4
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x20ea5
movq 0xe0d0(%rip), %rdi      # 0x2efd8
leaq 0x391b(%rip), %rsi      # 0x2482a
callq 0x4370
movq %rax, %rdi
movq 0x10(%rsp), %rsi
callq 0x4370
movq %rax, %rdi
movq 0xe09d(%rip), %rsi      # 0x2efc8
callq 0x43c0
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x20090
testb $0x1, %al
jne 0x20f77
movb $0x0, 0x27(%rsp)
jmp 0x20fe6
movl $0x0, 0xc(%rsp)
movq (%rsp), %rcx
movl 0xc(%rsp), %eax
cmpl 0x50(%rcx), %eax
jge 0x20fe1
movq (%rsp), %rax
movq 0x38(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x10(%rsp), %rsi
callq 0x4510
cmpl $0x0, %eax
jne 0x20fd2
movq (%rsp), %rdi
movq 0x78(%rdi), %rax
movq 0x48(%rdi), %rcx
movslq 0xc(%rsp), %rdx
movslq (%rcx,%rdx,4), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x21000
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0x20fe6
jmp 0x20fd4
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x20f7f
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: JenTus[P]TCEM/src_TCEM/anyoption.cc
// Function: AnyOption::findFlag(char*)
bool
AnyOption::findFlag( char* val )
{
	if( val == NULL )
		return false;

	if( strcmp( TRUE_FLAG , val ) == 0 )
		return true;

	return false;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x2101b
movb $0x0, 0x17(%rsp)
jmp 0x2103c
movq (%rsp), %rsi
leaq 0x3828(%rip), %rdi      # 0x2484e
callq 0x4510
cmpl $0x0, %eax
jne 0x21037
movb $0x1, 0x17(%rsp)
jmp 0x2103c
movb $0x0, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x18(%rsp)
movb %al, 0x17(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x20090
testb $0x1, %al
jne 0x210b0
movq 0xdf5e(%rip), %rdi      # 0x2efd8
leaq 0x37a9(%rip), %rsi      # 0x2482a
callq 0x4370
movq %rax, %rdi
movsbl 0x17(%rsp), %esi
callq 0x4410
movq %rax, %rdi
movq 0xdf2b(%rip), %rsi      # 0x2efc8
callq 0x43c0
movq $0x0, 0x20(%rsp)
jmp 0x21149
movl $0x0, 0x10(%rsp)
movq 0x8(%rsp), %rcx
movl 0x10(%rsp), %eax
cmpl 0x70(%rcx), %eax
jge 0x21111
movq 0x8(%rsp), %rax
movq 0x58(%rax), %rax
movslq 0x10(%rsp), %rcx
movsbl (%rax,%rcx), %eax
movsbl 0x17(%rsp), %ecx
cmpl %ecx, %eax
jne 0x21102
movq 0x8(%rsp), %rcx
movq 0x78(%rcx), %rax
movq 0x68(%rcx), %rcx
movslq 0x10(%rsp), %rdx
movslq (%rcx,%rdx,4), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x20(%rsp)
jmp 0x21149
jmp 0x21104
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x210b8
movq 0xdec0(%rip), %rdi      # 0x2efd8
leaq 0x370b(%rip), %rsi      # 0x2482a
callq 0x4370
movq %rax, %rdi
movsbl 0x17(%rsp), %esi
callq 0x4410
movq %rax, %rdi
movq 0xde8d(%rip), %rsi      # 0x2efc8
callq 0x43c0
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x18(%rsp)
movb %al, 0x17(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x20090
testb $0x1, %al
jne 0x2118a
movb $0x0, 0x27(%rsp)
jmp 0x211f6
movl $0x0, 0x10(%rsp)
movq 0x8(%rsp), %rcx
movl 0x10(%rsp), %eax
cmpl 0x70(%rcx), %eax
jge 0x211f1
movq 0x8(%rsp), %rax
movq 0x58(%rax), %rax
movslq 0x10(%rsp), %rcx
movsbl (%rax,%rcx), %eax
movsbl 0x17(%rsp), %ecx
cmpl %ecx, %eax
jne 0x211e2
movq 0x8(%rsp), %rdi
movq 0x78(%rdi), %rax
movq 0x68(%rdi), %rcx
movslq 0x10(%rsp), %rdx
movslq (%rcx,%rdx,4), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x21000
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0x211f6
jmp 0x211e4
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x21192
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: JenTus[P]TCEM/src_TCEM/anyoption.cc
// Function: AnyOption::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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x213f5
movq 0x30(%rsp), %rax
movq %rax, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movb $0x1, 0x1b(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq %rax, (%rsp)
movq 0x30(%rsp), %rdi
callq 0x4150
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x213e4
movq 0x8(%rsp), %rcx
movq 0x28(%rsp), %rax
movsbl (%rax), %eax
movsbl 0xa7(%rcx), %ecx
cmpl %ecx, %eax
jne 0x21381
cmpq $0x0, 0x20(%rsp)
je 0x21371
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl 0x1c(%rsp), %edx
callq 0x21600
movq $0x0, 0x20(%rsp)
movb $0x1, 0x1b(%rsp)
jmp 0x213bb
testb $0x1, 0x1b(%rsp)
je 0x213b9
movq 0x8(%rsp), %rcx
movb $0x0, 0x1b(%rsp)
movq 0x28(%rsp), %rax
movsbl (%rax), %eax
movsbl 0xa5(%rcx), %ecx
cmpl %ecx, %eax
je 0x213b7
movq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
jmp 0x213b9
jmp 0x213bb
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x2131c
movq 0x30(%rsp), %rdi
callq 0x4420
movb $0x1, 0x47(%rsp)
jmp 0x213fa
movb $0x0, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x278, %rsp            # imm = 0x278
movq %rdi, 0x268(%rsp)
movq %rsi, 0x260(%rsp)
leaq 0x48(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x43f0
movq 0x20(%rsp), %rdi
movq 0x260(%rsp), %rsi
movl $0x8, %edx
callq 0x4200
jmp 0x214af
movq 0x48(%rsp), %rax
movq -0x18(%rax), %rax
leaq 0x48(%rsp,%rax), %rdi
callq 0x4620
movb %al, 0x1f(%rsp)
jmp 0x214c8
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0x21514
jmp 0x214d2
leaq 0x48(%rsp), %rdi
callq 0x40b0
jmp 0x214de
movq $0x0, 0x270(%rsp)
movl $0x1, 0x38(%rsp)
jmp 0x215d6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x40d0
jmp 0x215f0
xorl %eax, %eax
movl %eax, %esi
leaq 0x48(%rsp), %rdi
movl $0x2, %edx
callq 0x44d0
jmp 0x21529
leaq 0x48(%rsp), %rdi
callq 0x4660
movq %rdx, 0x8(%rsp)
movq %rax, 0x10(%rsp)
jmp 0x2153f
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0x28(%rsp)
movq %rax, 0x30(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x21d90
movq %rax, (%rsp)
jmp 0x21563
movq (%rsp), %rax
movl %eax, 0x25c(%rsp)
xorl %edx, %edx
movl %edx, %esi
leaq 0x48(%rsp), %rdi
callq 0x44d0
jmp 0x2157e
movslq 0x25c(%rsp), %rdi
incq %rdi
callq 0x44b0
movq %rax, 0x250(%rsp)
movq 0x250(%rsp), %rsi
movslq 0x25c(%rsp), %rdx
leaq 0x48(%rsp), %rdi
callq 0x4480
jmp 0x215b2
leaq 0x48(%rsp), %rdi
callq 0x40b0
jmp 0x215be
movq 0x250(%rsp), %rax
movq %rax, 0x270(%rsp)
movl $0x1, 0x38(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x40d0
movq 0x270(%rsp), %rax
addq $0x278, %rsp            # imm = 0x278
retq
movq 0x40(%rsp), %rdi
callq 0x4680
nopw (%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movb $0x0, 0x33(%rsp)
movl 0x34(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x0, %rdi
callq 0x44b0
movq %rax, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x34(%rsp), %eax
jge 0x21678
movq 0x38(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x38(%rsp)
movb (%rax), %dl
movq 0x28(%rsp), %rax
movslq 0x24(%rsp), %rcx
movb %dl, (%rax,%rcx)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x21641
movq 0x8(%rsp), %rcx
movb 0xa9(%rcx), %sil
movq 0x28(%rsp), %rax
movslq 0x34(%rsp), %rdx
movb %sil, (%rax,%rdx)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
movsbl 0xa6(%rcx), %ecx
cmpl %ecx, %eax
je 0x216ce
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rax
movslq 0x34(%rsp), %rdx
movsbl -0x1(%rax,%rdx), %eax
movsbl 0xa6(%rcx), %ecx
cmpl %ecx, %eax
jne 0x216e2
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x217b0
jmp 0x2179a
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %ecx
movl 0x34(%rsp), %edx
subl $0x1, %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, 0x7(%rsp)
jge 0x21709
movb 0x33(%rsp), %al
xorb $-0x1, %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x21713
jmp 0x21774
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
movsbl 0xa6(%rcx), %ecx
cmpl %ecx, %eax
jne 0x21756
movq 0x8(%rsp), %rdi
movb 0xa9(%rdi), %cl
movq 0x18(%rsp), %rax
movb %cl, -0x1(%rax)
movb $0x1, 0x33(%rsp)
movq 0x28(%rsp), %rsi
movq 0x18(%rsp), %rdx
addq $0x1, %rdx
callq 0x21920
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x216ea
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
testb $0x1, 0x33(%rsp)
jne 0x21798
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x217b0
jmp 0x2179a
movq 0x28(%rsp), %rdi
callq 0x4420
addq $0x48, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x18(%rsp), %rsi
callq 0x21ae0
movq %rax, %rdi
callq 0x4150
cmpq $0x1, %rax
jne 0x2186a
movl $0x0, 0x14(%rsp)
movq 0x8(%rsp), %rcx
movl 0x14(%rsp), %eax
cmpl 0x70(%rcx), %eax
jge 0x21868
movq 0x8(%rsp), %rax
movq 0x58(%rax), %rax
movslq 0x14(%rsp), %rcx
movsbl (%rax,%rcx), %eax
movq 0x18(%rsp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x21859
movq 0x8(%rsp), %rax
movq 0x60(%rax), %rax
movslq 0x14(%rsp), %rcx
cmpl $0x4, (%rax,%rcx,4)
je 0x21840
movq 0x8(%rsp), %rax
movq 0x60(%rax), %rax
movslq 0x14(%rsp), %rcx
cmpl $0x6, (%rax,%rcx,4)
jne 0x21857
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rax
movsbl (%rax), %esi
callq 0x20d70
jmp 0x21915
jmp 0x21859
jmp 0x2185b
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x217ec
jmp 0x2186a
movl $0x0, 0x10(%rsp)
movq 0x8(%rsp), %rcx
movl 0x10(%rsp), %eax
cmpl 0x50(%rcx), %eax
jge 0x218eb
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rax
movslq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x18(%rsp), %rsi
callq 0x4510
cmpl $0x0, %eax
jne 0x218dc
movq 0x8(%rsp), %rax
movq 0x40(%rax), %rax
movslq 0x10(%rsp), %rcx
cmpl $0x4, (%rax,%rcx,4)
je 0x218c9
movq 0x8(%rsp), %rax
movq 0x40(%rax), %rax
movslq 0x10(%rsp), %rcx
cmpl $0x6, (%rax,%rcx,4)
jne 0x218da
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x20c90
jmp 0x21915
jmp 0x218dc
jmp 0x218de
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x21872
movq 0x8(%rsp), %rdi
leaq 0x2f5c(%rip), %rsi      # 0x24853
callq 0x1f6c0
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x1f700
movq 0x8(%rsp), %rdi
callq 0x1f690
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq 0x28(%rsp), %rsi
callq 0x21ae0
movq %rax, %rdi
callq 0x4150
cmpq $0x1, %rax
jne 0x21a02
movl $0x0, 0x1c(%rsp)
movq 0x10(%rsp), %rcx
movl 0x1c(%rsp), %eax
cmpl 0x70(%rcx), %eax
jge 0x21a00
movq 0x10(%rsp), %rax
movq 0x58(%rax), %rax
movslq 0x1c(%rsp), %rcx
movsbl (%rax,%rcx), %eax
movq 0x28(%rsp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x219ee
movq 0x10(%rsp), %rax
movq 0x60(%rax), %rax
movslq 0x1c(%rsp), %rcx
cmpl $0x1, (%rax,%rcx,4)
je 0x219b9
movq 0x10(%rsp), %rax
movq 0x60(%rax), %rax
movslq 0x1c(%rsp), %rcx
cmpl $0x3, (%rax,%rcx,4)
jne 0x219ec
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rax
movb (%rax), %al
movb %al, 0xf(%rsp)
movq 0x20(%rsp), %rsi
callq 0x21ae0
movq 0x10(%rsp), %rdi
movq %rax, %rdx
movb 0xf(%rsp), %al
movsbl %al, %esi
callq 0x20930
jmp 0x21ace
jmp 0x219ee
jmp 0x219f0
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x21961
jmp 0x21a02
movl $0x0, 0x18(%rsp)
movq 0x10(%rsp), %rcx
movl 0x18(%rsp), %eax
cmpl 0x50(%rcx), %eax
jge 0x21aa4
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rax
movslq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x28(%rsp), %rsi
callq 0x4510
cmpl $0x0, %eax
jne 0x21a92
movq 0x10(%rsp), %rax
movq 0x40(%rax), %rax
movslq 0x18(%rsp), %rcx
cmpl $0x1, (%rax,%rcx,4)
je 0x21a65
movq 0x10(%rsp), %rax
movq 0x40(%rax), %rax
movslq 0x18(%rsp), %rcx
cmpl $0x3, (%rax,%rcx,4)
jne 0x21a90
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rsi
callq 0x21ae0
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
movq %rax, %rdx
callq 0x206c0
jmp 0x21ace
jmp 0x21a92
jmp 0x21a94
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x21a0a
movq 0x10(%rsp), %rdi
leaq 0x2da3(%rip), %rsi      # 0x24853
callq 0x1f6c0
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x1f700
movq 0x10(%rsp), %rdi
callq 0x1f690
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
movsbl 0xa8(%rcx), %ecx
cmpl %ecx, %eax
jne 0x21b20
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x21af8
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
callq 0x4150
movq %rax, %rcx
movq (%rsp), %rax
addq %rcx, %rax
addq $-0x1, %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
movsbl 0xa8(%rcx), %ecx
cmpl %ecx, %eax
jne 0x21b6e
movq 0x10(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x21b46
movq 0x8(%rsp), %rax
movb 0xa9(%rax), %cl
movq 0x10(%rsp), %rax
movb %cl, 0x1(%rax)
movq 0x18(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
testb $0x1, 0xab(%rax)
je 0x21c34
movq (%rsp), %rax
movb $0x0, 0xab(%rax)
movq 0xd417(%rip), %rdi      # 0x2efd8
movq 0xd400(%rip), %rsi      # 0x2efc8
callq 0x43c0
movl $0x0, 0xc(%rsp)
movq (%rsp), %rcx
movl 0xc(%rsp), %eax
cmpl 0x94(%rcx), %eax
jge 0x21c21
movq (%rsp), %rax
movq 0x88(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
movq 0xd3d8(%rip), %rdi      # 0x2efd8
callq 0x4370
movq %rax, %rdi
movq 0xd3b9(%rip), %rsi      # 0x2efc8
callq 0x43c0
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x21bd5
movq 0xd3b0(%rip), %rdi      # 0x2efd8
movq 0xd399(%rip), %rsi      # 0x2efc8
callq 0x43c0
addq $0x18, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rcx
movq %rcx, (%rsp)
movl 0x94(%rcx), %eax
cmpl 0x90(%rcx), %eax
jl 0x21c92
movq (%rsp), %rdi
callq 0x1f480
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x21c90
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x21cd0
movl $0x1, %edi
callq 0x4430
jmp 0x21c92
movq (%rsp), %rax
movq 0x8(%rsp), %rsi
movq 0x88(%rax), %rcx
movslq 0x94(%rax), %rdx
movq %rsi, (%rcx,%rdx,8)
movl 0x94(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x94(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0xd2f3(%rip), %rdi      # 0x2efd8
movq 0xd2dc(%rip), %rsi      # 0x2efc8
callq 0x43c0
movq 0xd2e0(%rip), %rdi      # 0x2efd8
leaq 0x2a87(%rip), %rsi      # 0x24786
callq 0x4370
movq %rax, %rdi
movq 0xd2ba(%rip), %rsi      # 0x2efc8
callq 0x43c0
movq 0xd2be(%rip), %rdi      # 0x2efd8
leaq 0x2b54(%rip), %rsi      # 0x24875
callq 0x4370
movq %rax, %rdi
movq 0x8(%rsp), %rsi
callq 0x4370
movq %rax, %rdi
leaq 0x2b57(%rip), %rsi      # 0x24894
callq 0x4370
movq %rax, %rdi
movq 0xd27c(%rip), %rsi      # 0x2efc8
callq 0x43c0
movq 0xd280(%rip), %rdi      # 0x2efd8
leaq 0x29db(%rip), %rsi      # 0x2473a
callq 0x4370
movq %rax, %rdi
movq 0xd25a(%rip), %rsi      # 0x2efc8
callq 0x43c0
movq 0xd25e(%rip), %rdi      # 0x2efd8
movq 0xd247(%rip), %rsi      # 0x2efc8
callq 0x43c0
xorl %edi, %edi
callq 0x4430
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x9a0, %rax            # imm = 0x9A0
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
addq $0x9b0, %rax            # imm = 0x9B0
movq %rax, 0x8(%rsp)
movl $0x0, 0x1c(%rsp)
cmpl $0x22, 0x1c(%rsp)
jge 0x21e7b
movq 0x20(%rsp), %rdi
movslq 0x1c(%rsp), %rax
shlq $0x4, %rax
addq %rax, %rdi
movq 0x20(%rsp), %rsi
movslq 0x1c(%rsp), %rax
shlq $0x4, %rax
addq %rax, %rsi
movq 0x20(%rsp), %rdx
movl 0x1c(%rsp), %eax
addl $0x7a, %eax
cltq
shlq $0x4, %rax
addq %rax, %rdx
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %r8
callq 0x21f10
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movslq 0x1c(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x21e01
jmp 0x21e7d
cmpl $0x9c, 0x1c(%rsp)
jge 0x21f02
movq 0x20(%rsp), %rdi
movslq 0x1c(%rsp), %rax
shlq $0x4, %rax
addq %rax, %rdi
movq 0x20(%rsp), %rsi
movslq 0x1c(%rsp), %rax
shlq $0x4, %rax
addq %rax, %rsi
movq 0x20(%rsp), %rdx
movl 0x1c(%rsp), %eax
addl $0x7a, %eax
subl $0x9c, %eax
cltq
shlq $0x4, %rax
addq %rax, %rdx
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %r8
callq 0x21f10
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movslq 0x1c(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x21e7d
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: 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 do_recursion(w128_t *r, w128_t *a, w128_t *b,
				w128_t *c, w128_t *d)
{
    w128_t x;
    w128_t y;

    lshift128(&x, a, SFMT_SL2);
    rshift128(&y, c, SFMT_SR2);
    r->u[0] = a->u[0] ^ x.u[0] ^ ((b->u[0] >> SFMT_SR1) & SFMT_MSK1)
	^ y.u[0] ^ (d->u[0] << SFMT_SL1);
    r->u[1] = a->u[1] ^ x.u[1] ^ ((b->u[1] >> SFMT_SR1) & SFMT_MSK2)
	^ y.u[1] ^ (d->u[1] << SFMT_SL1);
    r->u[2] = a->u[2] ^ x.u[2] ^ ((b->u[2] >> SFMT_SR1) & SFMT_MSK3)
	^ y.u[2] ^ (d->u[2] << SFMT_SL1);
    r->u[3] = a->u[3] ^ x.u[3] ^ ((b->u[3] >> SFMT_SR1) & SFMT_MSK4)
	^ y.u[3] ^ (d->u[3] << SFMT_SL1);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq 0x38(%rsp), %rsi
leaq 0x10(%rsp), %rdi
movl $0x1, %edx
callq 0x230c0
movq 0x28(%rsp), %rsi
movq %rsp, %rdi
movl $0x1, %edx
callq 0x231a0
movq 0x38(%rsp), %rax
movl (%rax), %ecx
xorl 0x10(%rsp), %ecx
movq 0x30(%rsp), %rax
movl (%rax), %eax
shrl $0xb, %eax
andl $0xdfffffef, %eax       # imm = 0xDFFFFFEF
xorl %eax, %ecx
xorl (%rsp), %ecx
movq 0x20(%rsp), %rax
movl (%rax), %eax
shll $0x12, %eax
xorl %eax, %ecx
movq 0x40(%rsp), %rax
movl %ecx, (%rax)
movq 0x38(%rsp), %rax
movl 0x4(%rax), %ecx
xorl 0x14(%rsp), %ecx
movq 0x30(%rsp), %rax
movl 0x4(%rax), %eax
shrl $0xb, %eax
andl $0xddfecb7f, %eax       # imm = 0xDDFECB7F
xorl %eax, %ecx
xorl 0x4(%rsp), %ecx
movq 0x20(%rsp), %rax
movl 0x4(%rax), %eax
shll $0x12, %eax
xorl %eax, %ecx
movq 0x40(%rsp), %rax
movl %ecx, 0x4(%rax)
movq 0x38(%rsp), %rax
movl 0x8(%rax), %ecx
xorl 0x18(%rsp), %ecx
movq 0x30(%rsp), %rax
movl 0x8(%rax), %eax
shrl $0xb, %eax
andl $0xbffaffff, %eax       # imm = 0xBFFAFFFF
xorl %eax, %ecx
xorl 0x8(%rsp), %ecx
movq 0x20(%rsp), %rax
movl 0x8(%rax), %eax
shll $0x12, %eax
xorl %eax, %ecx
movq 0x40(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x38(%rsp), %rax
movl 0xc(%rax), %ecx
xorl 0x1c(%rsp), %ecx
movq 0x30(%rsp), %rax
movl 0xc(%rax), %eax
shrl $0xb, %eax
andl $0xbffffff6, %eax       # imm = 0xBFFFFFF6
xorl %eax, %ecx
xorl 0xc(%rsp), %ecx
movq 0x20(%rsp), %rax
movl 0xc(%rax), %eax
shll $0x12, %eax
xorl %eax, %ecx
movq 0x40(%rsp), %rax
movl %ecx, 0xc(%rax)
addq $0x48, %rsp
retq
nop
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl %edx, 0x4(%rsp)
movq 0x10(%rsp), %rax
cmpl $0x270, 0x9c0(%rax)     # imm = 0x270
jne 0x22055
jmp 0x22074
leaq 0x2877(%rip), %rdi      # 0x248d3
leaq 0x2886(%rip), %rsi      # 0x248e9
movl $0x11c, %edx            # imm = 0x11C
leaq 0x288f(%rip), %rcx      # 0x248fe
callq 0x4210
movl 0x4(%rsp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x22087
jmp 0x220a6
leaq 0x28a2(%rip), %rdi      # 0x24930
leaq 0x2854(%rip), %rsi      # 0x248e9
movl $0x11d, %edx            # imm = 0x11D
leaq 0x285d(%rip), %rcx      # 0x248fe
callq 0x4210
cmpl $0x270, 0x4(%rsp)       # imm = 0x270
jl 0x220b2
jmp 0x220d1
leaq 0x2885(%rip), %rdi      # 0x2493e
leaq 0x2829(%rip), %rsi      # 0x248e9
movl $0x11e, %edx            # imm = 0x11E
leaq 0x2832(%rip), %rcx      # 0x248fe
callq 0x4210
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl 0x4(%rsp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %eax, %edx
callq 0x22110
movq 0x10(%rsp), %rax
movl $0x270, 0x9c0(%rax)     # imm = 0x270
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl %edx, 0x4(%rsp)
movq 0x10(%rsp), %rax
cmpl $0x270, 0x9c0(%rax)     # imm = 0x270
jne 0x22445
jmp 0x22464
leaq 0x2487(%rip), %rdi      # 0x248d3
leaq 0x2496(%rip), %rsi      # 0x248e9
movl $0x140, %edx            # imm = 0x140
leaq 0x24f0(%rip), %rcx      # 0x2494f
callq 0x4210
movl 0x4(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x22477
jmp 0x22496
leaq 0x2503(%rip), %rdi      # 0x24981
leaq 0x2464(%rip), %rsi      # 0x248e9
movl $0x141, %edx            # imm = 0x141
leaq 0x24be(%rip), %rcx      # 0x2494f
callq 0x4210
cmpl $0x138, 0x4(%rsp)       # imm = 0x138
jl 0x224a2
jmp 0x224c1
leaq 0x24e6(%rip), %rdi      # 0x2498f
leaq 0x2439(%rip), %rsi      # 0x248e9
movl $0x142, %edx            # imm = 0x142
leaq 0x2493(%rip), %rcx      # 0x2494f
callq 0x4210
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl 0x4(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %edx
callq 0x22110
movq 0x10(%rsp), %rax
movl $0x270, 0x9c0(%rax)     # imm = 0x270
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
movl 0x3c(%rsp), %eax
movl %eax, 0x24(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x28(%rsp)
xorl %edi, %edi
callq 0x22610
movl 0x24(%rsp), %edx
movl %eax, %ecx
movq 0x28(%rsp), %rax
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl $0x1, 0x38(%rsp)
cmpl $0x270, 0x38(%rsp)      # imm = 0x270
jge 0x225f1
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movl 0x38(%rsp), %edi
subl $0x1, %edi
callq 0x22610
movl %eax, %ecx
movq (%rsp), %rax
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x38(%rsp), %edi
subl $0x1, %edi
callq 0x22610
movq 0x8(%rsp), %rcx
movl %eax, %edx
movl 0x10(%rsp), %eax
movslq %edx, %rdx
movl (%rcx,%rdx,4), %ecx
shrl $0x1e, %ecx
xorl %ecx, %eax
movl %eax, %eax
imulq $0x6c078965, %rax, %rax # imm = 0x6C078965
movslq 0x38(%rsp), %rcx
addq %rcx, %rax
movl %eax, 0x14(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movl 0x38(%rsp), %edi
callq 0x22610
movl 0x14(%rsp), %edx
movl %eax, %ecx
movq 0x18(%rsp), %rax
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl 0x38(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x38(%rsp)
jmp 0x22549
movq 0x40(%rsp), %rax
movl $0x270, 0x9c0(%rax)     # imm = 0x270
movq 0x40(%rsp), %rdi
callq 0x22620
addq $0x48, %rsp
retq
nop
// File: JenTus[P]TCEM/src_TCEM/sfmt/SFMT.c
// Function: period_certification(SFMT_T*)
static void period_certification(sfmt_t * sfmt) {
    int inner = 0;
    int i, j;
    uint32_t work;
    uint32_t *psfmt32 = &sfmt->state[0].u[0];
    const uint32_t parity[4] = {SFMT_PARITY1, SFMT_PARITY2,
				SFMT_PARITY3, SFMT_PARITY4};

    for (i = 0; i < 4; i++)
	inner ^= psfmt32[idxof(i)] & parity[i];
    for (i = 16; i > 0; i >>= 1)
	inner ^= inner >> i;
    inner &= 1;
    /* check OK */
    if (inner == 1) {
	return;
    }
    /* check NG, and modification */
    for (i = 0; i < 4; i++) {
	work = 1;
	for (j = 0; j < 32; j++) {
	    if ((work & parity[i]) != 0) {
		psfmt32[idxof(i)] ^= work;
		return;
	    }
	    work = work << 1;
	}
    }
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl $0x0, 0x4c(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x235e(%rip), %rax      # 0x249a0
movq %rax, 0x20(%rsp)
movq 0x235a(%rip), %rax      # 0x249a8
movq %rax, 0x28(%rsp)
movl $0x0, 0x48(%rsp)
cmpl $0x4, 0x48(%rsp)
jge 0x226a0
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movl 0x48(%rsp), %edi
callq 0x22610
movl %eax, %ecx
movq 0x18(%rsp), %rax
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movslq 0x48(%rsp), %rcx
andl 0x20(%rsp,%rcx,4), %eax
xorl 0x4c(%rsp), %eax
movl %eax, 0x4c(%rsp)
movl 0x48(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x48(%rsp)
jmp 0x2265b
movl $0x10, 0x48(%rsp)
cmpl $0x0, 0x48(%rsp)
jle 0x226cd
movl 0x4c(%rsp), %eax
movl 0x48(%rsp), %ecx
sarl %cl, %eax
xorl 0x4c(%rsp), %eax
movl %eax, 0x4c(%rsp)
movl 0x48(%rsp), %eax
sarl %eax
movl %eax, 0x48(%rsp)
jmp 0x226a8
movl 0x4c(%rsp), %eax
andl $0x1, %eax
movl %eax, 0x4c(%rsp)
cmpl $0x1, 0x4c(%rsp)
jne 0x226e4
jmp 0x2277a
movl $0x0, 0x48(%rsp)
cmpl $0x4, 0x48(%rsp)
jge 0x2277a
movl $0x1, 0x40(%rsp)
movl $0x0, 0x44(%rsp)
cmpl $0x20, 0x44(%rsp)
jge 0x22768
movl 0x40(%rsp), %eax
movslq 0x48(%rsp), %rcx
andl 0x20(%rsp,%rcx,4), %eax
cmpl $0x0, %eax
je 0x22751
movl 0x40(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x48(%rsp), %edi
callq 0x22610
movl 0xc(%rsp), %edx
movl %eax, %ecx
movq 0x10(%rsp), %rax
movslq %ecx, %rcx
xorl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
jmp 0x2277a
movl 0x40(%rsp), %eax
shll %eax
movl %eax, 0x40(%rsp)
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
jmp 0x22707
jmp 0x2276a
movl 0x48(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x48(%rsp)
jmp 0x226ec
addq $0x58, %rsp
retq
nop
// File: JenTus[P]TCEM/src_TCEM/sfmt/SFMT-common.h
// Function: lshift128(W128_T*, W128_T const*, int)
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:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movq -0x10(%rsp), %rax
movl 0xc(%rax), %eax
shlq $0x20, %rax
movq -0x10(%rsp), %rcx
movl 0x8(%rcx), %ecx
orq %rcx, %rax
movq %rax, -0x20(%rsp)
movq -0x10(%rsp), %rax
movl 0x4(%rax), %eax
shlq $0x20, %rax
movq -0x10(%rsp), %rcx
movl (%rcx), %ecx
orq %rcx, %rax
movq %rax, -0x28(%rsp)
movq -0x20(%rsp), %rax
movl -0x14(%rsp), %ecx
shll $0x3, %ecx
movl %ecx, %ecx
shlq %cl, %rax
movq %rax, -0x30(%rsp)
movq -0x28(%rsp), %rax
movl -0x14(%rsp), %ecx
shll $0x3, %ecx
movl %ecx, %ecx
shlq %cl, %rax
movq %rax, -0x38(%rsp)
movq -0x28(%rsp), %rax
movl -0x14(%rsp), %edx
shll $0x3, %edx
movl $0x40, %ecx
subl %edx, %ecx
movl %ecx, %ecx
shrq %cl, %rax
orq -0x30(%rsp), %rax
movq %rax, -0x30(%rsp)
movq -0x38(%rsp), %rax
shrq $0x20, %rax
movl %eax, %ecx
movq -0x8(%rsp), %rax
movl %ecx, 0x4(%rax)
movq -0x38(%rsp), %rax
movl %eax, %ecx
movq -0x8(%rsp), %rax
movl %ecx, (%rax)
movq -0x30(%rsp), %rax
shrq $0x20, %rax
movl %eax, %ecx
movq -0x8(%rsp), %rax
movl %ecx, 0xc(%rax)
movq -0x30(%rsp), %rax
movl %eax, %ecx
movq -0x8(%rsp), %rax
movl %ecx, 0x8(%rax)
retq
nopw (%rax,%rax)