LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: nanjiangshu[P]calSOV/calSOV.cpp
// Function: option_parser_filename(int, char**, int, char*)
int option_parser_filename(int argc, char **argv, int beg, char *filename)/*{{{*/
/*****************************************************************************
 * beg is the current index of argument list, e.g., argv[i] = "--out"
 ****************************************************************************/
{
    int i ; 
    bool isNonOptionArg = false;
    bool isFileNameSet = false;

    for(i = beg +1 ; i < argc ; i++)
    {
        if(argv[i][0] == '-' && strcmp(argv[i], "--") != 0 && !isNonOptionArg)
        {
            fprintf(stderr,"option '%s' must be followed by a filename, not option\n", argv[beg]);
            return -1;
        }
        else if(strcmp(argv[i], "--") == 0 && !isNonOptionArg)
        {
            isNonOptionArg = true;
        }
        else
        {
            my_strcpy(filename, argv[i], MAX_PATH-1);
            isFileNameSet = true;
            break;
        }
    }

    if(!isFileNameSet)
    {
        fprintf(stderr,"option '%s' must be followed by a filename\n", argv[beg]);
        return -1;
    }
    else 
    {
        return i+1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movb $0x0, -0x25(%rbp)
movb $0x0, -0x26(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x2a35
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x29da
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0xacf9(%rip), %rsi      # 0xd693
callq 0x2320
cmpl $0x0, %eax
je 0x29da
testb $0x1, -0x25(%rbp)
jne 0x29da
movq 0x10627(%rip), %rax     # 0x12fd8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
leaq 0xaccf(%rip), %rsi      # 0xd696
movb $0x0, %al
callq 0x2330
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2a71
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0xaca6(%rip), %rsi      # 0xd693
callq 0x2320
cmpl $0x0, %eax
jne 0x2a03
testb $0x1, -0x25(%rbp)
jne 0x2a03
movb $0x1, -0x25(%rbp)
jmp 0x2a23
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movl $0x1f3, %edx            # imm = 0x1F3
callq 0x2830
movb $0x1, -0x26(%rbp)
jmp 0x2a35
jmp 0x2a25
jmp 0x2a27
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2967
testb $0x1, -0x26(%rbp)
jne 0x2a68
movq 0x10596(%rip), %rax     # 0x12fd8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
leaq 0xac76(%rip), %rsi      # 0xd6ce
movb $0x0, %al
callq 0x2330
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2a71
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: nanjiangshu[P]calSOV/calSOV.cpp
// Function: IsNumeric(char const*)
bool IsNumeric(const char* str)/*{{{*/
//**********************************************************************
//IsNumeric(char*)
//check if a string is a numeric number
{
	int i = 0;
    int cntdot = 0;
	while(str[i] != '\0')
	{
        if( i == 0)
        {
            if(!isdigit(str[i]) && str[i] != '+' && str[i] != '-' && str[i] != '.' )
                return false;
            if(str[i] == '.')
                cntdot ++;
        }
        else
        {
            if(! isdigit(str[i]) && str[i] != '.')
                return false;
            if(str[i] == '.')
                cntdot ++;
        }
        i ++;
	}
    if(cntdot >= 2)
        return false;
    else 
        return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x2b7a
cmpl $0x0, -0x14(%rbp)
jne 0x2b23
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x21f0
cmpl $0x0, %eax
jne 0x2b07
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2b, %eax
je 0x2b07
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2d, %eax
je 0x2b07
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2e, %eax
je 0x2b07
movb $0x0, -0x1(%rbp)
jmp 0x2b8a
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2e, %eax
jne 0x2b21
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x2b6c
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x21f0
cmpl $0x0, %eax
jne 0x2b50
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2e, %eax
je 0x2b50
movb $0x0, -0x1(%rbp)
jmp 0x2b8a
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2e, %eax
jne 0x2b6a
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x2b6c
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2a9a
cmpl $0x2, -0x18(%rbp)
jl 0x2b86
movb $0x0, -0x1(%rbp)
jmp 0x2b8a
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: nanjiangshu[P]calSOV/calSOV.cpp
// Function: fgetline(_IO_FILE*, char*, int)
int fgetline(FILE* fp, char* line, int max/* = 0x7FFFFFFF*/)/*{{{*/
/*****************************************************************************
 * Read one line from fp, copying it to line array (but no more than max
 * chars). Does not place terminating \n in line array.  
 * it can be called without "max" flag, but should make sure the allocated
 * memory for "line" is larger than the longest line.
 *
 * Returns: line length, or 0 for empty line, or "EOF" for end-of-file.
 * 
 * since fgetc(), getc(), getchar(), returns int value,always use an int
 * variable to store the result of the fgetc(), getc() and getchar().  
 * getc() is faster than fgetc()
 *   LOG: 2006-04-26 16:31:29 Wednesday  Week 17 <nanjiang@shu>
 *   bug fixed for '\n' return keys, 
 *   now it is valid for both dos and unix
 ****************************************************************************/
{
    int nch = 0; /* record number of characters actually read */
    int c;
    max = max - 1;			/* leave room for '\0' */
    while((c = getc(fp)) != EOF)
    {
        if(c == 0x0d ) continue; /* in unix, '\n'= 0x0a, thus 0x0d will be cheated as another character*/ 
        if(c == '\n') break; /* in dos, '\n' is also equal to 0x0a, but the preceding 0x0d will not be read*/ 

        if(nch < max)
        {
            line[nch] = c;
            nch = nch + 1;
        }
    }
    line[nch] = '\0';

    if(c == EOF && nch == 0) return EOF;
    else return nch;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x1c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20d0
movl %eax, -0x24(%rbp)
cmpl $-0x1, %eax
je 0x2e27
cmpl $0xd, -0x24(%rbp)
jne 0x2dfc
jmp 0x2de3
cmpl $0xa, -0x24(%rbp)
jne 0x2e04
jmp 0x2e27
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x2e25
movl -0x24(%rbp), %eax
movb %al, %dl
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x2de3
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
cmpl $-0x1, -0x24(%rbp)
jne 0x2e48
cmpl $0x0, -0x20(%rbp)
jne 0x2e48
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2e4e
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: nanjiangshu[P]calSOV/calSOV.cpp
// Function: IsInCharSet(char, char const*, int)
bool IsInCharSet(const char ch, const char *charSet, int n /*= 0 */)/*{{{*/
/*****************************************************************************
 * check if the character "ch" is in charSet,
 ****************************************************************************/
{
	if(n == 0)
        n = strlen(charSet);
    int i;
	for(i = 0 ;i < n ; i ++)
	{
		if(ch == charSet[i])
			return true;
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
movb %al, -0x2(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x2e87
movq -0x10(%rbp), %rdi
callq 0x2110
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x2ebd
movsbl -0x2(%rbp), %eax
movq -0x10(%rbp), %rcx
movslq -0x18(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0x2eb0
movb $0x1, -0x1(%rbp)
jmp 0x2ec1
jmp 0x2eb2
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x2e8e
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: nanjiangshu[P]calSOV/calSOV.cpp
// Function: checkfilestream(_IO_FILE*, char const*, char const*, bool)
int checkfilestream(FILE *fp, const char* filename, const char *mode, bool isAssert /*= false*/)/*{{{*/
{
    if( fp == NULL)
    {
        fprintf(stderr,"Can not open file '%s' with mode '%s'\n", filename,mode);
        if(isAssert)
        {
            assert(fp != NULL);
        }
        return -1;
    }
    else
        return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2f4b
movq 0x100df(%rip), %rax     # 0x12fd8
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq 0xa8ac(%rip), %rsi      # 0xd7b7
movb $0x0, %al
callq 0x2330
testb $0x1, -0x21(%rbp)
je 0x2f42
cmpq $0x0, -0x10(%rbp)
je 0x2f21
jmp 0x2f40
leaq 0xa8b6(%rip), %rdi      # 0xd7de
leaq 0xa8ba(%rip), %rsi      # 0xd7e9
movl $0x189, %edx            # imm = 0x189
leaq 0xa8b9(%rip), %rcx      # 0xd7f4
callq 0x2170
jmp 0x2f42
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2f52
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: nanjiangshu[P]calSOV/calSOV.cpp
// Function: GetRawHSRConfidence(int, int, int)
double GetRawHSRConfidence(int probH, int probS, int probR)/*{{{*/
/*Determine raw confidence of the prediction based on the probability on H, S
 * and R
 * 2009-07-21, Nanjiang*/
{
    double sumHSR =  double(probH+probS+probR) + 1e-6; /*plus 1e-6 to avoid division by zero*/
    double maxHSR =  double (max (max(probH, probS), probR ));
    double rawConf = maxHSR/sumHSR;
    return rawConf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl -0x4(%rbp), %eax
addl -0x8(%rbp), %eax
addl -0xc(%rbp), %eax
cvtsi2sd %eax, %xmm0
movsd 0xa082(%rip), %xmm1     # 0xd008
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
leaq -0x4(%rbp), %rdi
leaq -0x8(%rbp), %rsi
callq 0x7de0
movq %rax, %rdi
leaq -0xc(%rbp), %rsi
callq 0x7de0
cvtsi2sdl (%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
divsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: nanjiangshu[P]calSOV/calSOV.cpp
// Function: GetNormHSRConfidence(int, int, int)
float GetNormHSRConfidence(int probH, int probS, int probR)/*{{{*/
/*Determine normalized confidence of the prediction based on the probability on H, S
 * and R, parameters were obtained by polynormial regression (order 2) of the
 * raw confidence and two Q3 at different raw confidence bins
 * 2009-08-02 
 * */
{
    double sumHSR =  double(probH+probS+probR) + 1e-6; /*plus 0.00001 to avoid division by zero*/
    double maxHSR =  double (max (max(probH, probS), probR ));
    double rawConf =(maxHSR/sumHSR)*100.0;

    double normConf = poly_a1 * rawConf*rawConf + poly_a2 * rawConf + poly_a3;

    /*method 2, three order regression, 2009-08-02 */
   //y = -0.0001x3 + 0.0225x2 - 0.1356x + 28.889 
    //double a1 =-0.0001;
    //double a2 = 0.0225;
    //double a3 = -0.1356;
    //double a4 =28.889; 
    //double normConf =  a1 * rawConf*rawConf*rawConf + a2 * rawConf*rawConf + a3*rawConf + a4;

    normConf /= 100.0;
    if (normConf < 0.0)
    {
        normConf = 0.0;
    }
    else if (normConf> 1.0)
    {
        normConf = 1.0;
    }
    return normConf;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl -0x4(%rbp), %eax
addl -0x8(%rbp), %eax
addl -0xc(%rbp), %eax
cvtsi2sd %eax, %xmm0
movsd 0xa012(%rip), %xmm1     # 0xd008
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
leaq -0x4(%rbp), %rdi
leaq -0x8(%rbp), %rsi
callq 0x7de0
movq %rax, %rdi
leaq -0xc(%rbp), %rsi
callq 0x7de0
cvtsi2sdl (%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
divsd -0x18(%rbp), %xmm0
movsd 0x9fdd(%rip), %xmm1     # 0xd010
mulsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd 0x101cc(%rip), %xmm0    # 0x13210
mulsd -0x28(%rbp), %xmm0
movsd -0x28(%rbp), %xmm2
movsd 0x101c2(%rip), %xmm1    # 0x13218
mulsd -0x28(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
addsd 0x101b5(%rip), %xmm0    # 0x13220
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
movsd 0x9f93(%rip), %xmm1     # 0xd010
divsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x30(%rbp), %xmm0
jbe 0x309a
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
jmp 0x30bc
movsd -0x30(%rbp), %xmm0
movsd 0x9f71(%rip), %xmm1     # 0xd018
ucomisd %xmm1, %xmm0
jbe 0x30ba
movsd 0x9f63(%rip), %xmm0     # 0xd018
movsd %xmm0, -0x30(%rbp)
jmp 0x30bc
movsd -0x30(%rbp), %xmm0
cvtsd2ss %xmm0, %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: nanjiangshu[P]calSOV/calSOV.cpp
// Function: GetHSRState(int, int, int, int)
int GetHSRState(int probH, int probS, int probR, int method_HSR /*= 1*/)/*{{{*/
/*Determine the state of secondary structure based on the probability on H, S
 * and R
 * the return value is 0 or 1 or 2, representing H, S and R respectively
 * 2009-07-13, Nanjiang*/
{
    int hsrState = 2;
    if (method_HSR == 0)
    {
        if  (    (probS>=probH) && (probS>=probR) ) { hsrState = 1; }
        else if ((probH>=probS) && (probH>=probR) ) { hsrState = 0; }
        else                                        { hsrState = 2; }
    }
    else if (method_HSR == 1)
    {
        if  (    (probR>=probH) && (probR>=probS) ) { hsrState = 2; }
        else if ((probS>=probH) && (probS>=probR) ) { hsrState = 1; }
        else { hsrState = 0; }
    }
    else 
    {
        if  (    (probR>=probH) && (probR>=probS) ) { hsrState = 2; }
        else if ((probH>=probS) && (probH>=probR) ) { hsrState = 0; }
        else { hsrState = 1; }
    }

    return hsrState;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movl $0x2, -0x14(%rbp)
cmpl $0x0, -0x10(%rbp)
jne 0x312d
movl -0x8(%rbp), %eax
cmpl -0x4(%rbp), %eax
jl 0x3106
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
jl 0x3106
movl $0x1, -0x14(%rbp)
jmp 0x3128
movl -0x4(%rbp), %eax
cmpl -0x8(%rbp), %eax
jl 0x311f
movl -0x4(%rbp), %eax
cmpl -0xc(%rbp), %eax
jl 0x311f
movl $0x0, -0x14(%rbp)
jmp 0x3126
movl $0x2, -0x14(%rbp)
jmp 0x3128
jmp 0x31af
cmpl $0x1, -0x10(%rbp)
jne 0x3170
movl -0xc(%rbp), %eax
cmpl -0x4(%rbp), %eax
jl 0x314c
movl -0xc(%rbp), %eax
cmpl -0x8(%rbp), %eax
jl 0x314c
movl $0x2, -0x14(%rbp)
jmp 0x316e
movl -0x8(%rbp), %eax
cmpl -0x4(%rbp), %eax
jl 0x3165
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
jl 0x3165
movl $0x1, -0x14(%rbp)
jmp 0x316c
movl $0x0, -0x14(%rbp)
jmp 0x316e
jmp 0x31ad
movl -0xc(%rbp), %eax
cmpl -0x4(%rbp), %eax
jl 0x3189
movl -0xc(%rbp), %eax
cmpl -0x8(%rbp), %eax
jl 0x3189
movl $0x2, -0x14(%rbp)
jmp 0x31ab
movl -0x4(%rbp), %eax
cmpl -0x8(%rbp), %eax
jl 0x31a2
movl -0x4(%rbp), %eax
cmpl -0xc(%rbp), %eax
jl 0x31a2
movl $0x0, -0x14(%rbp)
jmp 0x31a9
movl $0x1, -0x14(%rbp)
jmp 0x31ab
jmp 0x31ad
jmp 0x31af
movl -0x14(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: nanjiangshu[P]calSOV/calSOV.cpp
// Function: GetSecSeg[abi:cxx11](char*, char, int)
list < pair <int, int > > GetSecSeg(char *seq, char state, int seqLength)/*{{{*/
    /*Get segment list for a certain secondary structure state*/
{
    list < pair <int,int> > segList;
    pair <int, int> seg;
    int i,j;
    i = 0;
    while (i < seqLength) 
    {
        int b, e;
        if (seq[i] == state)
        {
            b = i;
            j = i;
            while (j < seqLength && seq[j] == state)
            {
                j ++;
            }
            e = j;
            i = j;
            seg = make_pair(b,e);
            segList.push_back(seg);
        }
        else
        {
            i ++;
        }
    }
    return segList;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x60(%rbp)
movb %dl, %al
movq %rdi, %rdx
movq %rdx, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl %ecx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x83b0
leaq -0x24(%rbp), %rdi
callq 0x83d0
jmp 0x3faa
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x4088
movq -0x10(%rbp), %rax
movslq -0x38(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jne 0x407a
movl -0x38(%rbp), %eax
movl %eax, -0x40(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %ecx
xorl %eax, %eax
cmpl -0x18(%rbp), %ecx
movb %al, -0x61(%rbp)
jge 0x4006
movq -0x10(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0x61(%rbp)
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0x400f
jmp 0x4031
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x3fe1
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x8490
jmp 0x40a8
movl -0x3c(%rbp), %eax
movl %eax, -0x44(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, -0x38(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x44(%rbp), %rsi
callq 0x83f0
movq %rax, -0x70(%rbp)
jmp 0x4050
movq -0x70(%rbp), %rax
movq %rax, -0x4c(%rbp)
leaq -0x24(%rbp), %rdi
movq %rdi, -0x78(%rbp)
leaq -0x4c(%rbp), %rsi
callq 0x8420
movq -0x60(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0x8450
jmp 0x4078
jmp 0x4083
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x3fb1
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x409b
movq -0x60(%rbp), %rdi
callq 0x8490
movq -0x58(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x2380
nopw %cs:(%rax,%rax)
// File: nanjiangshu[P]calSOV/calSOV.cpp
// Function: int option_parser_numeric<int>(int, char**, int, int&, bool, int, int)
int option_parser_numeric(int argc, char **argv, int beg, T &x, bool isRangeSet /*= false*/, T min /*= MIN_INT*/, T max /*= MAX_INT*/)/*{{{*/
/*****************************************************************************
 * beg is the current index of argument list, e.g., argv[i] = "--value"
 ****************************************************************************/
{
    int i ; 
    bool isValueSet = false;
    double tmp;
    i = beg +1;

    if (i < argc)
    {
        if(IsNumeric(argv[i]))
        {
            tmp = atof(argv[i]);
            if(isRangeSet)
            {
                if(tmp < min || tmp > max)
                {
                    fprintf(stderr,"Invalid value! Value after option '%s' must be in the range of [%g %g]\n", argv[beg], double(min), double(max));
                    return -1;
                }
            }
            x = T(tmp);
            isValueSet = true;
        }
    }

    if(!isValueSet)
    {
        fprintf(stderr,"option '%s' must be followed by a numerical value\n", argv[beg]);
        return -1;
    }
    else 
    {
        return i+1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %r8b, %al
movl 0x10(%rbp), %r8d
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movl %r9d, -0x28(%rbp)
movb $0x0, -0x2d(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x7eff
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2a80
testb $0x1, %al
jne 0x7e79
jmp 0x7efd
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x22f0
movsd %xmm0, -0x38(%rbp)
testb $0x1, -0x21(%rbp)
je 0x7eee
movsd -0x38(%rbp), %xmm1
cvtsi2sdl -0x28(%rbp), %xmm0
ucomisd %xmm1, %xmm0
ja 0x7eb5
movsd -0x38(%rbp), %xmm0
cvtsi2sdl 0x10(%rbp), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x7eec
movq 0xb11c(%rip), %rax      # 0x12fd8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
cvtsi2sdl -0x28(%rbp), %xmm0
cvtsi2sdl 0x10(%rbp), %xmm1
leaq 0x581e(%rip), %rsi      # 0xd6fa
movb $0x2, %al
callq 0x2330
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7f3b
jmp 0x7eee
cvttsd2si -0x38(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x2d(%rbp)
jmp 0x7eff
testb $0x1, -0x2d(%rbp)
jne 0x7f32
movq 0xb0cc(%rip), %rax      # 0x12fd8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
leaq 0x5820(%rip), %rsi      # 0xd742
movb $0x0, %al
callq 0x2330
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7f3b
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: nanjiangshu[P]calSOV/./array.h
// Function: Array1D<char>::~Array1D()
Array1D<T>::~Array1D(void) /*{{{*/
{
    delete [] array1D ;
    array1D = NULL;
    this->size = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x838b
movq -0x10(%rbp), %rdi
callq 0x2310
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movl $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: nanjiangshu[P]calSOV/./array.h
// Function: Array1D<char>::Init(char)
void Array1D<T>::Init(T initValue) /*{{{*/
{
    unsigned int i;
    for(i = 0; i < size; i ++)
    {
        array1D[i] = initValue;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl (%rcx), %eax
jae 0x8b74
movq -0x18(%rbp), %rax
movb -0x9(%rbp), %dl
movq 0x8(%rax), %rax
movl -0x10(%rbp), %ecx
movb %dl, (%rax,%rcx)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x8b4d
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: nanjiangshu[P]calSOV/./array.h
// Function: Array2D<int>::Array2D(unsigned int, unsigned int)
Array2D<T>::Array2D(unsigned int rowSize, unsigned int colSize)
{
	this->rowSize = rowSize;
	this->colSize = colSize;
	unsigned int i ;
	array2D = new T*[rowSize] ;
	for ( i = 0 ; i < rowSize ; i ++ )
		array2D[i] = new T[colSize] ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, 0x8(%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0xc(%rax)
movl -0xc(%rbp), %eax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x8d83
movl -0x10(%rbp), %eax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, %rdx
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl -0x14(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x8d3b
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: nanjiangshu[P]calSOV/./array.h
// Function: Array2D<int>::Init(int)
void Array2D<T>::Init(T initValue) /*{{{*/
{ 
    unsigned int i,j;
    for (i = 0 ; i < rowSize; i ++)
    {
        for(j = 0; j < colSize; j ++)
        {
            array2D[i][j] = initValue;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x20(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0x8(%rcx), %eax
jae 0x8ea8
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0xc(%rcx), %eax
jae 0x8e9b
movq -0x20(%rbp), %rax
movl -0xc(%rbp), %edx
movq (%rax), %rax
movl -0x10(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movl -0x14(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x8e6d
jmp 0x8e9d
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x8e5a
popq %rbp
retq
nopw (%rax,%rax)
// File: nanjiangshu[P]calSOV/./array.h
// Function: Array2D<double>::~Array2D()
Array2D<T>::~Array2D(void)/*{{{*/
{
	unsigned int i ; 
	for ( i = 0 ; i < rowSize ; i ++ )
		delete [] array2D[i] ;
	delete [] array2D ;
    array2D = NULL;
    this->rowSize = 0;
    this->colSize = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x8(%rcx), %eax
jae 0x9065
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl -0xc(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x9058
movq -0x20(%rbp), %rdi
callq 0x2310
jmp 0x905a
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x902b
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x907f
movq -0x28(%rbp), %rdi
callq 0x2310
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movl $0x0, 0x8(%rax)
movl $0x0, 0xc(%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: sile[P]mphf/./mmap_t.hh
// Function: MPHF::mmap_t::mmap_t(char const*, bool, int)
mmap_t(const char* path, bool write_mode=false, int flags=MAP_SHARED){
      int OPEN_MODE=O_RDONLY;
      int PROT = PROT_READ;
      if(write_mode) {
	OPEN_MODE=O_RDWR;
	PROT |= PROT_WRITE;
      }
      
      int f = open(path, OPEN_MODE);
      struct stat statbuf;
      fstat(f, &statbuf);
      ptr = mmap(0, statbuf.st_size, PROT, flags, f, 0);
      size=statbuf.st_size;
      close(f);  
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc0(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x1, -0x20(%rbp)
testb $0x1, -0x11(%rbp)
je 0x1ecc
movl $0x2, -0x1c(%rbp)
movl -0x20(%rbp), %eax
orl $0x2, %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
movb $0x0, %al
callq 0x10d0
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %edi
leaq -0xb8(%rbp), %rsi
callq 0x1190
movq -0x88(%rbp), %rsi
movl -0x20(%rbp), %edx
movl -0x18(%rbp), %ecx
movl -0x24(%rbp), %r8d
xorl %eax, %eax
movl %eax, %r9d
movq %r9, %rdi
callq 0x11b0
movq %rax, %rcx
movq -0xc0(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x88(%rbp), %rcx
movq %rcx, (%rax)
movl -0x24(%rbp), %edi
callq 0x11c0
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: sile[P]mphf/./hash.hh
// Function: MPHF::Hash::mphf(char const*, unsigned int) const
unsigned mphf(const char* key, unsigned size) const {
      unsigned h1 = d.h1(key,size);
      unsigned h2 = d.h2(key,size);
      
      if(d.rank_bv->is_1bit(h1)==false)
	return d.rank_bv->rank(h2);
      if(d.rank_bv->is_1bit(h2)==false)
	return d.rank_bv->rank(h1);

      unsigned v[2] = {d.rank_bv->rank(h1), d.rank_bv->rank(h2)};
      unsigned i = d.hash_assign_bv->get(v[0])+d.hash_assign_bv->get(v[1]);
      return v[i%2];
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x21f0
movq -0x38(%rbp), %rdi
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x2230
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, -0x24(%rbp)
movq 0x28(%rax), %rdi
movl -0x20(%rbp), %esi
callq 0x2280
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x2141
movq -0x38(%rbp), %rax
movq 0x28(%rax), %rdi
movl -0x24(%rbp), %esi
callq 0x22c0
movl %eax, -0x4(%rbp)
jmp 0x21d8
movq -0x38(%rbp), %rax
movq 0x28(%rax), %rdi
movl -0x24(%rbp), %esi
callq 0x2280
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x2170
movq -0x38(%rbp), %rax
movq 0x28(%rax), %rdi
movl -0x20(%rbp), %esi
callq 0x22c0
movl %eax, -0x4(%rbp)
jmp 0x21d8
movq -0x38(%rbp), %rax
movq 0x28(%rax), %rdi
movl -0x20(%rbp), %esi
callq 0x22c0
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, -0x2c(%rbp)
movq 0x28(%rax), %rdi
movl -0x24(%rbp), %esi
callq 0x22c0
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, -0x28(%rbp)
movq 0x30(%rax), %rdi
movl -0x2c(%rbp), %esi
callq 0x2320
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, -0x3c(%rbp)
movq 0x30(%rax), %rdi
movl -0x28(%rbp), %esi
callq 0x2320
movl %eax, %ecx
movl -0x3c(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
andl $0x1, %eax
movl %eax, %eax
movl -0x2c(%rbp,%rax,4), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: sile[P]mphf/./bit_vector.hh
// Function: MPHF::BitVector::block_rank(unsigned int, unsigned int) const
unsigned block_rank(unsigned block_num, unsigned offset) const {
      unsigned r=0;
      for(; offset >= 32; block_num++, offset-=32)
	r += log_count(blocks[block_num]);
      return r + log_count(blocks[block_num] & ((2 << offset)-1));
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x20, -0x10(%rbp)
jb 0x2464
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movl -0xc(%rbp), %ecx
movl (%rax,%rcx,4), %edi
callq 0x24a0
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
subl $0x20, %eax
movl %eax, -0x10(%rbp)
jmp 0x2431
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, -0x24(%rbp)
movq 0x8(%rax), %rax
movl -0xc(%rbp), %ecx
movl (%rax,%rcx,4), %edi
movl -0x10(%rbp), %ecx
movl $0x2, %eax
shll %cl, %eax
subl $0x1, %eax
andl %eax, %edi
callq 0x24a0
movl %eax, %ecx
movl -0x24(%rbp), %eax
addl %ecx, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: joncampbell123[P]haxcc/haxpp.cpp
// Function: token::operator==(token const&) const
bool token::operator==(const token &t) const {
    if (tval != t.tval) return false;
    if (bsize != t.bsize) return false;
    if (i != t.i) return false;
    if (f != t.f) return false;
    if (s != t.s) return false;
    if (sval != t.sval) return false;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
je 0x3d8b
movb $0x0, -0x1(%rbp)
jmp 0x3e30
movq -0x20(%rbp), %rax
movzbl 0x4(%rax), %eax
movq -0x18(%rbp), %rcx
movzbl 0x4(%rcx), %ecx
cmpl %ecx, %eax
je 0x3da8
movb $0x0, -0x1(%rbp)
jmp 0x3e30
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
callq 0x3bc0
testb $0x1, %al
jne 0x3dc3
jmp 0x3dc9
movb $0x0, -0x1(%rbp)
jmp 0x3e30
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
movq -0x18(%rbp), %rsi
addq $0x20, %rsi
callq 0x3c50
testb $0x1, %al
jne 0x3de4
jmp 0x3dea
movb $0x0, -0x1(%rbp)
jmp 0x3e30
movq -0x20(%rbp), %rdi
addq $0x40, %rdi
movq -0x18(%rbp), %rsi
addq $0x40, %rsi
callq 0x3cd0
testb $0x1, %al
jne 0x3e05
jmp 0x3e0b
movb $0x0, -0x1(%rbp)
jmp 0x3e30
movq -0x20(%rbp), %rdi
addq $0x48, %rdi
movq -0x18(%rbp), %rsi
addq $0x48, %rsi
callq 0x15680
testb $0x1, %al
jne 0x3e26
jmp 0x3e2c
movb $0x0, -0x1(%rbp)
jmp 0x3e30
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: joncampbell123[P]haxcc/haxpp.cpp
// Function: FileSource::set(_IO_FILE*)
void FileSource::set(FILE *_fp) {
    close();
    fp = _fp;
    path.clear();
    reset_counters();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x4230
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, (%rdi)
addq $0x10, %rdi
callq 0x33b0
movq -0x18(%rbp), %rdi
callq 0x41d0
addq $0x20, %rsp
popq %rbp
retq
// File: joncampbell123[P]haxcc/haxpp.cpp
// Function: FileSource::close()
void FileSource::close() {
    if (fp != NULL) {
        if (ownership) fclose(fp);
        fp = NULL;
    }
    ownership = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, (%rax)
je 0x426b
movq -0x10(%rbp), %rax
testb $0x1, 0x8(%rax)
je 0x4260
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x3290
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: joncampbell123[P]haxcc/haxpp.cpp
// Function: FileSource::open()
void FileSource::open() {
    if (fp == NULL) {
        fp = fopen(path.c_str(),"rb");
        if (fp != NULL)
            ownership = true;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, (%rax)
jne 0x4310
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x30f0
movq %rax, %rdi
leaq 0x2073f(%rip), %rsi     # 0x24a30
callq 0x3340
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, (%rax)
je 0x430e
movq -0x10(%rbp), %rax
movb $0x1, 0x8(%rax)
jmp 0x4310
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: joncampbell123[P]haxcc/haxpp.cpp
// Function: FileSource::getc()
int FileSource::getc() {
    int c = EOF;

    if (fp != NULL) {
        do {
            c = fgetc(fp);
        } while (c == '\r'/*chars to ignore*/);

        if (c == '\n') {
            line++;
            column = 1;
        }
        else {
            column++;
        }

        if (ferror(fp))
            throw runtime_error("File I/O error, reading");
    }

    return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
cmpq $0x0, (%rax)
je 0x4478
jmp 0x43d7
movq -0x28(%rbp), %rax
movq (%rax), %rdi
callq 0x3440
movl %eax, -0xc(%rbp)
cmpl $0xd, -0xc(%rbp)
je 0x43d7
cmpl $0xa, -0xc(%rbp)
jne 0x4408
movq -0x28(%rbp), %rax
movl 0x30(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x30(%rax)
movl $0x1, 0x34(%rax)
jmp 0x4415
movq -0x28(%rbp), %rax
movl 0x34(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x34(%rax)
movq -0x28(%rbp), %rax
movq (%rax), %rdi
callq 0x3510
cmpl $0x0, %eax
je 0x4476
movl $0x10, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq 0x205f2(%rip), %rsi     # 0x24a33
callq 0x30d0
jmp 0x4448
movq -0x30(%rbp), %rdi
movq 0x2eba5(%rip), %rsi     # 0x32ff8
movq 0x2eb56(%rip), %rdx     # 0x32fb0
callq 0x34b0
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x31f0
jmp 0x4481
jmp 0x4478
movl -0xc(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x34e0
nopw (%rax,%rax)
// File: joncampbell123[P]haxcc/haxpp.cpp
// Function: FileDest::close()
void FileDest::close() {
    if (fp != NULL) {
        if (ownership) fclose(fp);
        fp = NULL;
    }
    ownership = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, (%rax)
je 0x450b
movq -0x10(%rbp), %rax
testb $0x1, 0x8(%rax)
je 0x4500
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x3290
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: joncampbell123[P]haxcc/haxpp.cpp
// Function: FileDest::open()
void FileDest::open() {
    if (fp == NULL) {
        fp = fopen(path.c_str(),"wb");
        if (fp != NULL)
            ownership = true;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, (%rax)
jne 0x45b0
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x30f0
movq %rax, %rdi
leaq 0x204ba(%rip), %rsi     # 0x24a4b
callq 0x3340
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, (%rax)
je 0x45ae
movq -0x10(%rbp), %rax
movb $0x1, 0x8(%rax)
jmp 0x45b0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: joncampbell123[P]haxcc/haxpp.cpp
// Function: FileDest::putc(char)
void FileDest::putc(char c) {
    if (fp != NULL) {
        if (fputc((int)c,fp) == EOF) {
            if (ferror(fp))
                throw runtime_error("File I/O error, writing");
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, (%rax)
je 0x469a
movq -0x28(%rbp), %rax
movsbl -0x9(%rbp), %edi
movq (%rax), %rsi
callq 0x3380
cmpl $-0x1, %eax
jne 0x4698
movq -0x28(%rbp), %rax
movq (%rax), %rdi
callq 0x3510
cmpl $0x0, %eax
je 0x4696
movl $0x10, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq 0x203ed(%rip), %rsi     # 0x24a4e
callq 0x30d0
jmp 0x4668
movq -0x30(%rbp), %rdi
movq 0x2e985(%rip), %rsi     # 0x32ff8
movq 0x2e936(%rip), %rdx     # 0x32fb0
callq 0x34b0
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x31f0
jmp 0x46a0
jmp 0x4698
jmp 0x469a
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x34e0
nopl (%rax)
// File: joncampbell123[P]haxcc/haxpp.cpp
// Function: FileDest::puts(char const*)
void FileDest::puts(const char *s) {
    if (fp != NULL) {
        if (fputs(s,fp) == EOF) {
            if (ferror(fp))
                throw runtime_error("File I/O error, writing");
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, (%rax)
je 0x4748
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rdi
movq (%rax), %rsi
callq 0x3320
cmpl $-0x1, %eax
jne 0x4746
movq -0x28(%rbp), %rax
movq (%rax), %rdi
callq 0x3510
cmpl $0x0, %eax
je 0x4744
movl $0x10, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq 0x2033f(%rip), %rsi     # 0x24a4e
callq 0x30d0
jmp 0x4716
movq -0x30(%rbp), %rdi
movq 0x2e8d7(%rip), %rsi     # 0x32ff8
movq 0x2e888(%rip), %rdx     # 0x32fb0
callq 0x34b0
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x31f0
jmp 0x474e
jmp 0x4746
jmp 0x4748
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x34e0
nopw (%rax,%rax)
// File: joncampbell123[P]haxcc/haxpp.cpp
// Function: pp_cond_t::on_if(bool, bool)
void pp_cond_t::on_if(const bool r,const bool pr) {
    allow_elif = true;
    allow_else = true;
    pcond = pr;
    cond = r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dl, %al
movb %sil, %cl
movq %rdi, -0x8(%rbp)
andb $0x1, %cl
movb %cl, -0x9(%rbp)
andb $0x1, %al
movb %al, -0xa(%rbp)
movq -0x8(%rbp), %rax
movb $0x1, 0x3(%rax)
movb $0x1, 0x2(%rax)
movb -0xa(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x1(%rax)
movb -0x9(%rbp), %cl
andb $0x1, %cl
movb %cl, (%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: joncampbell123[P]haxcc/haxpp.cpp
// Function: pp_cond_t::on_elif(bool)
void pp_cond_t::on_elif(const bool r) {
    if (allow_elif) {
        if (cond) pcond = false;
        allow_elif = false;
        cond = r;
    }
    else {
        throw invalid_argument("#elif not allowed here");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
testb $0x1, 0x3(%rax)
je 0x4825
movq -0x28(%rbp), %rax
testb $0x1, (%rax)
je 0x4813
movq -0x28(%rbp), %rax
movb $0x0, 0x1(%rax)
movq -0x28(%rbp), %rax
movb $0x0, 0x3(%rax)
movb -0x9(%rbp), %cl
andb $0x1, %cl
movb %cl, (%rax)
jmp 0x4875
movl $0x10, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq 0x20226(%rip), %rsi     # 0x24a66
callq 0x3530
jmp 0x4847
movq -0x30(%rbp), %rdi
movq 0x2e786(%rip), %rsi     # 0x32fd8
movq 0x2e767(%rip), %rdx     # 0x32fc0
callq 0x34b0
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x31f0
jmp 0x487b
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x34e0
nopw %cs:(%rax,%rax)
// File: joncampbell123[P]haxcc/haxpp.cpp
// Function: pp_cond_t::on_else()
void pp_cond_t::on_else() {
    if (allow_else) {
        if (cond) pcond = false;
        /* cannot have #elif after #else */
        allow_else = false;
        allow_elif = false;
        cond = !cond;
    }
    else {
        throw invalid_argument("#else not allowed here");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
testb $0x1, 0x2(%rax)
je 0x4913
movq -0x20(%rbp), %rax
testb $0x1, (%rax)
je 0x48fb
movq -0x20(%rbp), %rax
movb $0x0, 0x1(%rax)
movq -0x20(%rbp), %rax
movb $0x0, 0x2(%rax)
movb $0x0, 0x3(%rax)
movb (%rax), %cl
xorb $-0x1, %cl
andb $0x1, %cl
movb %cl, (%rax)
jmp 0x4963
movl $0x10, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
leaq 0x2014f(%rip), %rsi     # 0x24a7d
callq 0x3530
jmp 0x4935
movq -0x28(%rbp), %rdi
movq 0x2e698(%rip), %rsi     # 0x32fd8
movq 0x2e679(%rip), %rdx     # 0x32fc0
callq 0x34b0
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x31f0
jmp 0x4969
addq $0x30, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0x34e0
nopw %cs:(%rax,%rax)
// File: joncampbell123[P]haxcc/haxpp.cpp
// Function: macro_t::operator==(macro_t const&) const
bool macro_t::operator==(const macro_t &m) const {
    if (subst != m.subst) return false;
    if (param != m.param) return false;
    if (parens != m.parens) return false;
    if (last_param_variadic != m.last_param_variadic) return false;
    if (last_param_optional != m.last_param_optional) return false;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x18(%rbp), %rsi
callq 0x15760
testb $0x1, %al
jne 0x49d7
jmp 0x49e0
movb $0x0, -0x1(%rbp)
jmp 0x4a6e
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
movq -0x18(%rbp), %rsi
addq $0x18, %rsi
callq 0x15790
testb $0x1, %al
jne 0x49fb
jmp 0x4a01
movb $0x0, -0x1(%rbp)
jmp 0x4a6e
movq -0x20(%rbp), %rax
movb 0x32(%rax), %al
andb $0x1, %al
movzbl %al, %eax
movq -0x18(%rbp), %rcx
movb 0x32(%rcx), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
je 0x4a24
movb $0x0, -0x1(%rbp)
jmp 0x4a6e
movq -0x20(%rbp), %rax
movb 0x30(%rax), %al
andb $0x1, %al
movzbl %al, %eax
movq -0x18(%rbp), %rcx
movb 0x30(%rcx), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
je 0x4a47
movb $0x0, -0x1(%rbp)
jmp 0x4a6e
movq -0x20(%rbp), %rax
movb 0x31(%rax), %al
andb $0x1, %al
movzbl %al, %eax
movq -0x18(%rbp), %rcx
movb 0x31(%rcx), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
je 0x4a6a
movb $0x0, -0x1(%rbp)
jmp 0x4a6e
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: joncampbell123[P]haxcc/haxpp.cpp
// Function: read_line(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, FileSource&)
bool read_line(string &line,FileSource &src) {
    int c;

    line.clear();
    while (!src.eof()) {
        c = src.getc();

        if (c == EOF)
            break;
        else if (c == '\n')
            break;
        else if (c == '\\')
            read_line_esc(line,src);
        else if (c == '\'')
            read_line_quote(line,src,c);
        else if (c == '/') {
            int c2 = src.getc();
            if (c2 == EOF) {
                line += c;
            }
            else if (c2 == '/') { /* C++ // comment */
                if (!read_line_skip_cpp_comment(src))
                    break;
            }
            else if (c2 == '*') { /* C comment like this */
                read_line_skip_c_comment(src);
            }
            else {
                line += c;
                line += c2;
            }
        }
        else
            line += c;
    }

    if (line.empty() && src.eof())
        return false;

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x33b0
movq -0x18(%rbp), %rdi
callq 0x4340
xorb $-0x1, %al
testb $0x1, %al
jne 0x4aad
jmp 0x4b96
movq -0x18(%rbp), %rdi
callq 0x43b0
movl %eax, -0x1c(%rbp)
cmpl $-0x1, -0x1c(%rbp)
jne 0x4ac4
jmp 0x4b96
cmpl $0xa, -0x1c(%rbp)
jne 0x4acf
jmp 0x4b96
cmpl $0x5c, -0x1c(%rbp)
jne 0x4ae7
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4bd0
jmp 0x4b8d
cmpl $0x27, -0x1c(%rbp)
jne 0x4b05
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %eax
movsbl %al, %edx
callq 0x4c30
jmp 0x4b8b
cmpl $0x2f, -0x1c(%rbp)
jne 0x4b7a
movq -0x18(%rbp), %rdi
callq 0x43b0
movl %eax, -0x20(%rbp)
cmpl $-0x1, -0x20(%rbp)
jne 0x4b2e
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rdi
movsbl %al, %esi
callq 0x3190
jmp 0x4b78
cmpl $0x2f, -0x20(%rbp)
jne 0x4b45
movq -0x18(%rbp), %rdi
callq 0x4cc0
testb $0x1, %al
jne 0x4b43
jmp 0x4b96
jmp 0x4b76
cmpl $0x2a, -0x20(%rbp)
jne 0x4b56
movq -0x18(%rbp), %rdi
callq 0x4d80
jmp 0x4b74
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rdi
movsbl %al, %esi
callq 0x3190
movl -0x20(%rbp), %eax
movq -0x10(%rbp), %rdi
movsbl %al, %esi
callq 0x3190
jmp 0x4b76
jmp 0x4b78
jmp 0x4b89
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rdi
movsbl %al, %esi
callq 0x3190
jmp 0x4b8b
jmp 0x4b8d
jmp 0x4b8f
jmp 0x4b91
jmp 0x4a99
movq -0x10(%rbp), %rdi
callq 0x34a0
testb $0x1, %al
jne 0x4ba5
jmp 0x4bba
movq -0x18(%rbp), %rdi
callq 0x4340
testb $0x1, %al
jne 0x4bb4
jmp 0x4bba
movb $0x0, -0x1(%rbp)
jmp 0x4bbe
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: joncampbell123[P]haxcc/haxpp.cpp
// Function: read_line_esc(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, FileSource&)
static void read_line_esc(string &line,FileSource &src) {
    int c2 = src.getc();
    if (c2 != EOF) { /* trailing \<EOF> should just do nothing */
        if (c2 == '\n') { /* \<newline>, so it continues on the next line */
            line += ' ';
        }
        else {
            line += '\\';
            line += c2;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x43b0
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
je 0x4c27
cmpl $0xa, -0x14(%rbp)
jne 0x4c08
movq -0x8(%rbp), %rdi
movl $0x20, %esi
callq 0x3190
jmp 0x4c25
movq -0x8(%rbp), %rdi
movl $0x5c, %esi
callq 0x3190
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rdi
movsbl %al, %esi
callq 0x3190
jmp 0x4c27
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)