LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
decl %ebp
xorl %r15d, %r15d
movq %r14, %rdi
callq 0x20c0
cmpl $0xd, %eax
je 0x2c64
cmpl $-0x1, %eax
je 0x2c8b
cmpl $0xa, %eax
je 0x2c8b
cmpl %ebp, %r15d
jge 0x2c64
movl %r15d, %ecx
movb %al, (%rbx,%rcx)
incl %r15d
jmp 0x2c64
movl %r15d, %ecx
movb $0x0, (%rbx,%rcx)
notl %eax
orl %r15d, %eax
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovnel %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
testl %edx, %edx
jne 0x2cc2
movq %rbx, %rdi
callq 0x20e0
movq %rax, %rdx
testl %edx, %edx
setg %al
jle 0x2ced
cmpb %bpl, (%rbx)
je 0x2ced
movl %edx, %eax
movl $0x1, %edx
movq %rdx, %rcx
cmpq %rdx, %rax
je 0x2ce7
leaq 0x1(%rcx), %rdx
cmpb %bpl, (%rbx,%rcx)
jne 0x2cd5
cmpq %rax, %rcx
setb %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
leal (%rsi,%rdi), %eax
addl %edx, %eax
cvtsi2sd %eax, %xmm1
addsd 0x42e0(%rip), %xmm1     # 0x7008
cmpl %esi, %edi
cmovgl %edi, %esi
cmpl %edx, %esi
cmovlel %edx, %esi
cvtsi2sd %esi, %xmm0
divsd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
cmpl $0x1, %ecx
je 0x2dea
testl %ecx, %ecx
jne 0x2e0d
cmpl %edi, %esi
setge %cl
cmpl %edx, %esi
setge %r8b
movl $0x1, %eax
testb %r8b, %cl
jne 0x2e31
cmpl %esi, %edi
setl %al
cmpl %edx, %edi
setl %cl
orb %al, %cl
movzbl %cl, %eax
addl %eax, %eax
retq
cmpl %edi, %edx
setge %cl
cmpl %esi, %edx
setge %r8b
movl $0x2, %eax
testb %r8b, %cl
jne 0x2e31
cmpl %edi, %esi
setge %al
cmpl %edx, %esi
setge %cl
andb %al, %cl
jmp 0x2e2e
cmpl %edi, %edx
setge %cl
cmpl %esi, %edx
setge %r8b
movl $0x2, %eax
testb %r8b, %cl
jne 0x2e31
cmpl %esi, %edi
setl %al
cmpl %edx, %edi
setl %cl
orb %al, %cl
movzbl %cl, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/nanjiangshu[P]calSOV/calSOV.cpp
// Function: ReadConf(char const*, double*, int)
int ReadConf(const char *infile, double *predConf, int typeConfidence)/*{{{*/
{
    int linesize;
    int maxline = 400;
    Array1D <char> line_1darray(maxline+1);
    char *line = line_1darray.array1D;
    char aa;
    char obs_sec;
    int status_sscanf = 0;

    int seqLength = 0;
    FILE *fp = fopen(infile, "r");
    checkfilestream(fp, infile, "r", true);
    int num ; 
    char shape;
    int probH;
    int probS;
    int probR;
    int cntRes = 0;
    while((linesize=fgetline(fp, line, maxline)) != EOF)
    { 
        status_sscanf = sscanf(line,"%d %c %c %c %d %d %d" , &num,&aa,&shape, &obs_sec,&probH,&probS,&probR);
        if (status_sscanf != 7)
        {
            fprintf(stderr,"sscanf error!");
            fprintf(stderr,"File: %s\n", infile);
            fprintf(stderr,"line: %s\n", line);
            assert (status_sscanf == 7);
        }

        if (typeConfidence == 0) /*Raw confidence*/
        {
            predConf[cntRes] = GetRawHSRConfidence(probH, probS, probR);
        }
        else 
        {
            predConf[cntRes] = GetNormHSRConfidence(probH, probS, probR);
        }

        cntRes ++;
    } 
    seqLength = cntRes;
    if (fp != NULL) { fclose(fp); }
    return seqLength;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %r13
movl $0x191, %edi            # imm = 0x191
callq 0x2030
movq %rax, %rbx
leaq 0x44bf(%rip), %r14      # 0x7a7e
movq %r13, %rdi
movq %r14, %rsi
callq 0x21e0
movq %rax, %r15
movq %rax, %rdi
movq %r13, %rsi
movq %r14, %rdx
movl $0x1, %ecx
callq 0x2cf4
movq %r15, %rdi
movq %rbx, %rsi
movl $0x190, %edx            # imm = 0x190
callq 0x2c50
cmpl $-0x1, %eax
je 0x36b7
movq %r13, 0x18(%rsp)
leaq 0xa(%rsp), %r14
xorl %r13d, %r13d
subq $0x8, %rsp
movq %rbx, %rdi
leaq 0x421e(%rip), %rsi      # 0x7832
leaq 0x2c(%rsp), %rdx
leaq 0x13(%rsp), %rcx
leaq 0x11(%rsp), %r8
movq %r14, %r9
xorl %eax, %eax
leaq 0x14(%rsp), %r10
pushq %r10
leaq 0x20(%rsp), %r10
pushq %r10
leaq 0x2c(%rsp), %r10
pushq %r10
callq 0x2150
addq $0x20, %rsp
cmpl $0x7, %eax
jne 0x36e1
movl 0x14(%rsp), %edi
movl 0x10(%rsp), %esi
movl 0xc(%rsp), %edx
testl %ebp, %ebp
je 0x366a
callq 0x2d3b
cvtss2sd %xmm0, %xmm0
jmp 0x3693
leal (%rsi,%rdi), %eax
addl %edx, %eax
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
cmpl %esi, %edi
cmovgl %edi, %esi
cmpl %edx, %esi
cmovlel %edx, %esi
addsd 0x3980(%rip), %xmm1     # 0x7008
xorps %xmm0, %xmm0
cvtsi2sd %esi, %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%r12,%r13,8)
incq %r13
movq %r15, %rdi
movq %rbx, %rsi
movl $0x190, %edx            # imm = 0x190
callq 0x2c50
cmpl $-0x1, %eax
jne 0x3606
jmp 0x36ba
xorl %r13d, %r13d
testq %r15, %r15
je 0x36c7
movq %r15, %rdi
callq 0x2160
movq %rbx, %rdi
callq 0x2220
movl %r13d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x18(%rsp), %rdi
movq %rbx, %rsi
callq 0x240f
// File: /workspace/github_cpp_makefile_star2_O1/nanjiangshu[P]calSOV/calSOV.cpp
// Function: CalQ3(char*, char*, int, int*, int*, double*, int)
int CalQ3(char *obsSec, char *predSec, int seqLength, int *numCorrectHSR, int *numHSR, double *q3HSR, int numState = 3)/*{{{*/
    /*=======================================================================
     * numCorrectHSR[4]
     * numHSR[4] Helix, Sheet, Coil, All
     * q3HSR[4]
     * numState = 3 by default
     *====================================================================*/
{

    int iterHSRState = 0; /*iterator for the HSR state, H, S and R*/
    char thisHSRstate = ' '; /*current HSR state*/
    int i = 0;

    for (i=0;i<=numState; i++)
    {
        numCorrectHSR[i] = 0;
        numHSR[i] = 0;
    }

    for (iterHSRState=0; iterHSRState<3; iterHSRState++)//corrsponding to H, S, R
    {
        thisHSRstate = HSRalphabet[iterHSRState];
        for(i=0; i<seqLength; i++)
        { 
            if (  obsSec[i] == thisHSRstate  )
            {
                numHSR[iterHSRState] ++;
                if (obsSec[i] == predSec[i])
                {
                    numCorrectHSR[iterHSRState] ++;
                }
            }
        } 
    }

    for (i=0; i<numState; i++)
    {   
        q3HSR[i] = numCorrectHSR[i] / double (numHSR[i]+1e-6);
        numCorrectHSR[numState]  += numCorrectHSR[i];
        numHSR[numState]  += numHSR[i];
    }
    q3HSR[numState] = numCorrectHSR[numState] / double (numHSR[numState]+1e-6); 

    return numHSR[numState];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
movl 0x28(%rsp), %eax
testl %eax, %eax
js 0x3f63
leal 0x1(%rax), %r10d
xorl %r11d, %r11d
xorl %ebx, %ebx
movl %r11d, (%rcx,%rbx,4)
movl %r11d, (%r8,%rbx,4)
incq %rbx
cmpq %rbx, %r10
jne 0x3f53
movl %edx, %r10d
xorl %r11d, %r11d
leaq 0x71f4(%rip), %rbx      # 0xb164
testl %edx, %edx
jle 0x3f9b
movb (%r11,%rbx), %bpl
xorl %r14d, %r14d
cmpb %bpl, (%rdi,%r14)
jne 0x3f93
incl (%r8,%r11,4)
movb (%rdi,%r14), %r15b
cmpb (%rsi,%r14), %r15b
jne 0x3f93
incl (%rcx,%r11,4)
incq %r14
cmpq %r14, %r10
jne 0x3f7b
incq %r11
cmpq $0x3, %r11
jne 0x3f70
testl %eax, %eax
jle 0x3fe8
movl %eax, %edx
xorl %esi, %esi
movsd 0x3054(%rip), %xmm0     # 0x7008
movl (%rcx,%rsi,4), %edi
xorps %xmm1, %xmm1
cvtsi2sd %edi, %xmm1
xorps %xmm2, %xmm2
cvtsi2sdl (%r8,%rsi,4), %xmm2
addsd %xmm0, %xmm2
divsd %xmm2, %xmm1
movsd %xmm1, (%r9,%rsi,8)
addl %edi, (%rcx,%rdx,4)
movl (%r8,%rsi,4), %edi
addl %edi, (%r8,%rdx,4)
incq %rsi
cmpq %rsi, %rdx
jne 0x3fb4
movslq %eax, %rdx
xorps %xmm0, %xmm0
cvtsi2sdl (%rcx,%rdx,4), %xmm0
movl (%r8,%rdx,4), %eax
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
addsd 0x3002(%rip), %xmm1     # 0x7008
divsd %xmm1, %xmm0
movsd %xmm0, (%r9,%rdx,8)
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/nanjiangshu[P]calSOV/calSOV.cpp
// Function: int option_parser_numeric<double>(int, char**, int, double&, bool, double, double)
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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movsd %xmm1, (%rsp)
movsd %xmm0, 0x8(%rsp)
movl %edx, %ebx
movq %rsi, %r14
leal 0x1(%rbx), %eax
cmpl %edi, %eax
jge 0x62b2
movl %r8d, %ebp
movq %rcx, %r15
cltq
movq (%r14,%rax,8), %r12
movq %r12, %rdi
callq 0x2a40
testb %al, %al
je 0x62b2
movq %r12, %rdi
callq 0x21f0
testb %bpl, %bpl
je 0x629b
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
ja 0x62d8
ucomisd (%rsp), %xmm0
ja 0x62d8
movsd %xmm0, (%r15)
addl $0x2, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x4d1f(%rip), %rax      # 0xafd8
movq (%rax), %rdi
movslq %ebx, %rax
movq (%r14,%rax,8), %rdx
leaq 0x1478(%rip), %rsi      # 0x7742
xorl %eax, %eax
callq 0x2240
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x62a3
movq 0x4cf9(%rip), %rax      # 0xafd8
movq (%rax), %rdi
movslq %ebx, %rax
movq (%r14,%rax,8), %rdx
leaq 0x140a(%rip), %rsi      # 0x76fa
movsd 0x8(%rsp), %xmm0
movsd (%rsp), %xmm1
movb $0x2, %al
callq 0x2240
jmp 0x62d1
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x8(%rdi)
je 0x6434
xorl %r14d, %r14d
movq (%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x6429
callq 0x2220
incq %r14
movl 0x8(%rbx), %eax
cmpq %rax, %r14
jb 0x6418
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x6441
callq 0x2220
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/sile[P]mphf/./hash.hh
// Function: MPHF::Hash::Data::Data(char const*)
Data(const char* filepath) 
	: mm(filepath), key_count(0), hash_value_limit(0), middle(0),
	  h(NULL), rank_bv(NULL), hash_assign_bv(NULL) {
	if(!mm)
	  return;
	
	const char* p=static_cast<const char*>(mm.ptr);
	
	key_count        = reinterpret_cast<const unsigned*>(p)[0];
	hash_value_limit = reinterpret_cast<const unsigned*>(p)[1];
	middle = hash_value_limit/2;
	p += sizeof(unsigned)*2;
	
	h = reinterpret_cast<const HashImpl*>(p);
        p += sizeof(HashImpl)*2;
      
        unsigned bit_length = reinterpret_cast<const unsigned*>(p)[0];
        p += sizeof(unsigned);
	rank_bv = new BitVector(bit_length, 
				reinterpret_cast<const unsigned*>(p), 
				reinterpret_cast<const unsigned*>(p)+BitVector::block_size(bit_length));
        p += sizeof(unsigned)*(BitVector::block_size(bit_length)+BitVector::rank_index_size(bit_length));

	bit_length = reinterpret_cast<const unsigned*>(p)[0];
	p += sizeof(unsigned);
	hash_assign_bv = new BitVector(bit_length, reinterpret_cast<const unsigned*>(p), NULL);
      }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
xorl %edx, %edx
movl $0x1, %ecx
callq 0x19aa
movq %r14, 0x10(%rbx)
movl $0x0, 0x18(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
movq %r14, 0x30(%rbx)
movq 0x8(%rbx), %r14
cmpq $-0x1, %r14
je 0x1988
movl (%r14), %eax
movl %eax, 0x10(%rbx)
movl 0x4(%r14), %eax
movl %eax, 0x14(%rbx)
shrl %eax
movl %eax, 0x18(%rbx)
leaq 0x8(%r14), %rax
movq %rax, 0x20(%rbx)
movl 0x18(%r14), %r15d
movl $0x18, %edi
callq 0x10e0
leaq 0x1c(%r14), %rcx
leal 0x1f(%r15), %edx
shrl $0x5, %edx
leaq (%r14,%rdx,4), %rsi
addq $0x1c, %rsi
movl %r15d, (%rax)
movq %rcx, 0x8(%rax)
movq %rsi, 0x10(%rax)
movq %rax, 0x28(%rbx)
addl $0xff, %r15d
shrl $0x8, %r15d
addl %edx, %r15d
movl 0x1c(%r14,%r15,4), %ebp
movl $0x18, %edi
callq 0x10e0
leaq (%r14,%r15,4), %rcx
addq $0x1c, %rcx
addq $0x4, %rcx
movl %ebp, (%rax)
movq %rcx, 0x8(%rax)
movq $0x0, 0x10(%rax)
movq %rax, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x1070
movq %r15, %rdi
callq 0x1150
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
movl %ecx, %ebp
movq %rsi, %rax
movq %rdi, %rbx
leal 0x1(,%rdx,2), %r14d
leal (%rdx,%rdx), %esi
movq %rax, %rdi
xorl %eax, %eax
callq 0x10a0
movl %eax, %r15d
movq %rsp, %r12
movl %eax, %edi
movq %r12, %rsi
callq 0x1130
movq 0x30(%r12), %r12
xorl %edi, %edi
movq %r12, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %r15d, %r8d
xorl %r9d, %r9d
callq 0x1160
movq %rax, 0x8(%rbx)
movq %r12, (%rbx)
movl %r15d, %edi
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1180
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0x1b3e
xorl %edx, %edx
divl 0x18(%rbx)
movl %edx, %r14d
movq 0x20(%rbx), %rdi
addq $0x8, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x1b3e
movl 0x18(%rbx), %ecx
xorl %edx, %edx
divl %ecx
movl %edx, %ebp
addl %ecx, %ebp
movq 0x28(%rbx), %rdi
movq 0x8(%rdi), %rax
movl %r14d, %ecx
shrl $0x5, %ecx
movl (%rax,%rcx,4), %ecx
btl %r14d, %ecx
jae 0x1b0e
movl %ebp, %ecx
shrl $0x5, %ecx
movl (%rax,%rcx,4), %eax
movl %r14d, %esi
shrl $0x8, %esi
btl %ebp, %eax
jae 0x1b19
movl $0xff, %r15d
andl %r15d, %r14d
movq 0x10(%rdi), %rax
movl (%rax,%rsi,4), %r12d
shll $0x3, %esi
movl %r14d, %edx
callq 0x1b94
leal (%r12,%rax), %r14d
decl %r14d
movl %r14d, 0x8(%rsp)
movq 0x28(%rbx), %rdi
movl %ebp, %esi
shrl $0x8, %esi
andl %r15d, %ebp
movq 0x10(%rdi), %rax
movl (%rax,%rsi,4), %r15d
shll $0x3, %esi
movl %ebp, %edx
callq 0x1b94
addl %r15d, %eax
decl %eax
movl %eax, 0xc(%rsp)
movq 0x30(%rbx), %rcx
movq 0x8(%rcx), %rdx
movl %r14d, %ecx
shrl $0x5, %ecx
movl (%rdx,%rcx,4), %esi
movl %r14d, %ecx
shrl %cl, %esi
movl %eax, %ecx
shrl $0x5, %ecx
movl (%rdx,%rcx,4), %edx
movl %eax, %ecx
shrl %cl, %edx
addl %esi, %edx
andl $0x1, %edx
movl 0x8(%rsp,%rdx,4), %eax
jmp 0x1b30
movl %ebp, %esi
shrl $0x8, %esi
movzbl %bpl, %edx
jmp 0x1b1d
movzbl %r14b, %edx
movq 0x10(%rdi), %rax
movl (%rax,%rsi,4), %ebx
shll $0x3, %esi
callq 0x1b94
addl %ebx, %eax
decl %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movl %edx, %ecx
xorl %edx, %edx
cmpl $0x20, %ecx
jb 0x1c13
movq 0x8(%rdi), %r8
leal -0x20(%rcx), %eax
shrl $0x5, %eax
addl %esi, %eax
xorl %edx, %edx
movl $0x55555555, %r9d       # imm = 0x55555555
movl $0x33333333, %r10d      # imm = 0x33333333
movl %esi, %r11d
movl (%r8,%r11,4), %r11d
movl %r11d, %ebx
shrl %ebx
andl %r9d, %ebx
andl %r9d, %r11d
addl %ebx, %r11d
movl %r11d, %ebx
shrl $0x2, %ebx
andl %r10d, %ebx
andl %r10d, %r11d
addl %ebx, %r11d
movl %r11d, %ebx
shrl $0x4, %ebx
addl %r11d, %ebx
andl $0xf0f0f0f, %ebx        # imm = 0xF0F0F0F
movl %ebx, %r11d
shrl $0x8, %r11d
addl %ebx, %r11d
movl %r11d, %ebx
shrl $0x10, %ebx
addl %r11d, %ebx
movzbl %bl, %r11d
addl %r11d, %edx
incl %esi
addl $-0x20, %ecx
cmpl $0x1f, %ecx
ja 0x1bb8
incl %eax
movl %eax, %esi
movq 0x8(%rdi), %rax
movl %esi, %esi
movl $0x2, %edi
shll %cl, %edi
decl %edi
andl (%rax,%rsi,4), %edi
movl %edi, %eax
shrl %eax
movl $0x55555555, %ecx       # imm = 0x55555555
andl %ecx, %eax
andl %ecx, %edi
addl %eax, %edi
movl %edi, %eax
shrl $0x2, %eax
movl $0x33333333, %ecx       # imm = 0x33333333
andl %ecx, %eax
andl %ecx, %edi
addl %eax, %edi
movl %edi, %eax
shrl $0x4, %eax
addl %edi, %eax
andl $0xf0f0f0f, %eax        # imm = 0xF0F0F0F
movl %eax, %ecx
shrl $0x8, %ecx
addl %eax, %ecx
movl %ecx, %eax
shrl $0x10, %eax
addl %ecx, %eax
movzbl %al, %eax
addl %edx, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
movl (%rdi), %eax
cmpl (%rsi), %eax
jne 0x2ab1
movb 0x4(%rdi), %al
cmpb 0x4(%rsi), %al
jne 0x2ab1
movq 0x8(%rdi), %rcx
xorl %eax, %eax
cmpq 0x8(%rsi), %rcx
jne 0x2ab3
movb 0x10(%rsi), %cl
cmpb %cl, 0x10(%rdi)
jne 0x2ab3
fldt 0x20(%rdi)
fldt 0x20(%rsi)
xorl %eax, %eax
fxch %st(1)
fucompi %st(1), %st
fstp %st(0)
jne 0x2ab3
jp 0x2ab3
movl 0x30(%rsi), %ecx
cmpl %ecx, 0x30(%rdi)
jne 0x2ab3
movq 0x40(%rdi), %rax
cmpq 0x40(%rsi), %rax
jne 0x2ab1
movq 0x50(%rdi), %rdx
cmpq 0x50(%rsi), %rdx
jne 0x2ab1
testq %rdx, %rdx
je 0x2ab4
pushq %rax
movq 0x48(%rsi), %rsi
movq 0x48(%rdi), %rdi
callq 0x21e0
testl %eax, %eax
sete %al
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
movb $0x1, %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/joncampbell123[P]haxcc/haxpp.cpp
// Function: FileSource::set(_IO_FILE*)
void FileSource::set(FILE *_fp) {
    close();
    fp = _fp;
    path.clear();
    reset_counters();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x2cc6
cmpb $0x1, 0x8(%rbx)
jne 0x2cbf
callq 0x21b0
movq $0x0, (%rbx)
xorl %eax, %eax
movb %al, 0x8(%rbx)
movq %r14, (%rbx)
movq $0x0, 0x18(%rbx)
movq 0x10(%rbx), %rcx
movb %al, (%rcx)
movq $0x1, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/joncampbell123[P]haxcc/haxpp.cpp
// Function: FileSource::close()
void FileSource::close() {
    if (fp != NULL) {
        if (ownership) fclose(fp);
        fp = NULL;
    }
    ownership = false;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x2d0a
cmpb $0x1, 0x8(%rbx)
jne 0x2d03
callq 0x21b0
movq $0x0, (%rbx)
movb $0x0, 0x8(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
cmpq $0x0, (%rdi)
je 0x2d5b
retq
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
leaq 0x10966(%rip), %rsi     # 0x136d0
callq 0x2230
movq %rax, (%rbx)
testq %rax, %rax
je 0x2d7b
movb $0x1, 0x8(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
cmpq $0x0, (%rdi)
je 0x2dd7
movq %rdi, %r14
movq (%r14), %rdi
callq 0x22e0
cmpl $0xd, %eax
je 0x2db5
movl %eax, %ebx
cmpl $0xa, %eax
jne 0x2dde
incl 0x30(%r14)
movl $0x1, 0x34(%r14)
jmp 0x2de2
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x2dee
incl 0x34(%r14)
movq (%r14), %rdi
callq 0x2390
testl %eax, %eax
jne 0x2df8
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x20e0
movq %rax, %rbx
leaq 0x108c7(%rip), %rsi     # 0x136d3
movq %rax, %rdi
callq 0x20b0
movq 0x171dd(%rip), %rsi     # 0x19ff8
movq 0x1718e(%rip), %rdx     # 0x19fb0
movq %rbx, %rdi
callq 0x2330
movq %rax, %r14
movq %rbx, %rdi
callq 0x2160
movq %r14, %rdi
callq 0x2360
nop
// File: /workspace/github_cpp_makefile_star2_O1/joncampbell123[P]haxcc/haxpp.cpp
// Function: FileDest::close()
void FileDest::close() {
    if (fp != NULL) {
        if (ownership) fclose(fp);
        fp = NULL;
    }
    ownership = false;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x2e9e
cmpb $0x1, 0x8(%rbx)
jne 0x2e97
callq 0x21b0
movq $0x0, (%rbx)
movb $0x0, 0x8(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
cmpq $0x0, (%rdi)
je 0x2eeb
retq
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
leaq 0x107f1(%rip), %rsi     # 0x136eb
callq 0x2230
movq %rax, (%rbx)
testq %rax, %rax
je 0x2f0b
movb $0x1, 0x8(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movl %esi, %eax
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x2f46
movq %rdi, %rbx
movsbl %al, %edi
callq 0x2260
cmpl $-0x1, %eax
jne 0x2f46
movq (%rbx), %rdi
callq 0x2390
testl %eax, %eax
jne 0x2f4e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x20e0
movq %rax, %rbx
leaq 0x1078c(%rip), %rsi     # 0x136ee
movq %rax, %rdi
callq 0x20b0
movq 0x17087(%rip), %rsi     # 0x19ff8
movq 0x17038(%rip), %rdx     # 0x19fb0
movq %rbx, %rdi
callq 0x2330
movq %rax, %r14
movq %rbx, %rdi
callq 0x2160
movq %r14, %rdi
callq 0x2360
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq (%rdi), %rax
testq %rax, %rax
je 0x2fbf
movq %rdi, %rbx
movq %rsi, %rdi
movq %rax, %rsi
callq 0x2200
cmpl $-0x1, %eax
jne 0x2fbf
movq (%rbx), %rdi
callq 0x2390
testl %eax, %eax
jne 0x2fc7
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x20e0
movq %rax, %rbx
leaq 0x10713(%rip), %rsi     # 0x136ee
movq %rax, %rdi
callq 0x20b0
movq 0x1700e(%rip), %rsi     # 0x19ff8
movq 0x16fbf(%rip), %rdx     # 0x19fb0
movq %rbx, %rdi
callq 0x2330
movq %rax, %r14
movq %rbx, %rdi
callq 0x2160
movq %r14, %rdi
callq 0x2360
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
cmpb $0x1, 0x3(%rdi)
jne 0x3044
cmpb $0x1, (%rdi)
jne 0x3035
movb $0x0, 0x1(%rdi)
movb $0x0, 0x3(%rdi)
movb %sil, (%rdi)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x20e0
movq %rax, %rbx
leaq 0x106ae(%rip), %rsi     # 0x13706
movq %rax, %rdi
callq 0x23a0
movq 0x16f71(%rip), %rsi     # 0x19fd8
movq 0x16f52(%rip), %rdx     # 0x19fc0
movq %rbx, %rdi
callq 0x2330
movq %rax, %r14
movq %rbx, %rdi
callq 0x2160
movq %r14, %rdi
callq 0x2360
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
cmpb $0x1, 0x2(%rdi)
jne 0x30be
movb (%rdi), %al
cmpb $0x1, %al
jne 0x30ac
movb $0x0, 0x1(%rdi)
movw $0x0, 0x2(%rdi)
xorb $0x1, %al
movb %al, (%rdi)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x20e0
movq %rax, %rbx
leaq 0x1064b(%rip), %rsi     # 0x1371d
movq %rax, %rdi
callq 0x23a0
movq 0x16ef7(%rip), %rsi     # 0x19fd8
movq 0x16ed8(%rip), %rdx     # 0x19fc0
movq %rbx, %rdi
callq 0x2330
movq %rax, %r14
movq %rbx, %rdi
callq 0x2160
movq %r14, %rdi
callq 0x2360
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq $0x0, 0x8(%rdi)
movq (%rdi), %rax
movb $0x0, (%rax)
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x3201
callq 0x22c0
testl %eax, %eax
je 0x322a
cmpq $0x0, 0x8(%r14)
je 0x320c
movb $0x1, %al
jmp 0x321f
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x321d
callq 0x22c0
testl %eax, %eax
je 0x3208
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x18(%rsp), %r15
movq %rbx, %rdi
callq 0x2da8
cmpl $0x2e, %eax
jle 0x326c
cmpl $0x2f, %eax
je 0x329b
cmpl $0x5c, %eax
jne 0x32d0
movq %rbx, %rdi
callq 0x2da8
cmpl $-0x1, %eax
je 0x32eb
movl %eax, %ebp
movq %r14, %rdi
cmpl $0xa, %eax
jne 0x32d5
movl $0x20, %esi
jmp 0x32e6
cmpl $0x27, %eax
jne 0x32be
movq %r14, %rdi
movl $0x27, %esi
callq 0x2190
movq %rbx, %rdi
callq 0x2da8
movl %eax, %ebp
movsbl %bpl, %esi
movq %r14, %rdi
callq 0x2190
cmpl $0x27, %ebp
jne 0x327e
jmp 0x32eb
movq %rbx, %rdi
callq 0x2da8
cmpl $0x2f, %eax
je 0x3313
movl %eax, %ebp
cmpl $0x2a, %eax
je 0x3309
movq %r14, %rdi
movl $0x2f, %esi
cmpl $-0x1, %ebp
jne 0x32da
jmp 0x32e6
cmpl $-0x1, %eax
je 0x3201
cmpl $0xa, %eax
je 0x3201
movsbl %al, %esi
jmp 0x32e3
movl $0x5c, %esi
callq 0x2190
movsbl %bpl, %esi
movq %r14, %rdi
callq 0x2190
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x3201
callq 0x22c0
testl %eax, %eax
je 0x322f
jmp 0x3201
movq %rbx, %rdi
callq 0x33a3
jmp 0x32eb
movq %r15, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
movq %rbx, %rdi
callq 0x2da8
cmpl $0x5c, %eax
je 0x333f
cmpl $-0x1, %eax
je 0x334c
cmpl $0xa, %eax
jne 0x3326
jmp 0x3350
movq %rbx, %rdi
callq 0x2da8
cmpl $0xa, %eax
jne 0x3326
xorl %ebp, %ebp
jmp 0x3353
movb $0x1, %bpl
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x336a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21d0
movq (%rbx), %rdi
testq %rdi, %rdi
sete %al
orb %al, %bpl
je 0x32f7
jmp 0x3201
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x339b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21d0
movq %rbx, %rdi
callq 0x2360
// File: /workspace/github_cpp_makefile_star2_O1/joncampbell123[P]haxcc/haxpp.cpp
// Function: read_line_skip_c_comment(FileSource&)
static void read_line_skip_c_comment(FileSource &src) {
    string tmp;
    int c;

    do {
        c = src.getc();
        if (c == EOF)
            break;
        else if (c == '*') { /* C comment closing */
            c = src.getc();
            if (c == '/') break;
        }
        else if (c == '/') {
            c = src.getc();
            if (c == '*') /* another C comment opening. we allow nesting */
                read_line_skip_c_comment(src);
        }
    } while(1);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
movq %rbx, %rdi
callq 0x2da8
cmpl $0x2a, %eax
je 0x33f2
cmpl $0x2f, %eax
je 0x33db
cmpl $-0x1, %eax
jne 0x33c2
jmp 0x33ff
movq %rbx, %rdi
callq 0x2da8
cmpl $0x2a, %eax
jne 0x33c2
movq %rbx, %rdi
callq 0x33a3
jmp 0x33c2
movq %rbx, %rdi
callq 0x2da8
cmpl $0x2f, %eax
jne 0x33c2
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x3416
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21d0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x3438
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21d0
movq %rbx, %rdi
callq 0x2360
// File: /workspace/github_cpp_makefile_star2_O1/joncampbell123[P]haxcc/haxpp.cpp
// Function: is_pp_keyword(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
enum token::token_t is_pp_keyword(const string &s) {
    if (s == "if")
        return token::IF;
    if (s == "else")
        return token::ELSE;
    if (s == "elif")
        return token::ELIF;
    if (s == "endif")
        return token::ENDIF;
    if (s == "defined")
        return token::DEFINED;
    if (s == "ifdef")
        return token::IFDEF;
    if (s == "ifndef")
        return token::IFNDEF;
    if (s == "define")
        return token::DEFINE;
    if (s == "undef")
        return token::UNDEF;
    if (s == "include")
        return token::INCLUDE;
    if (s == "line")
        return token::LINE;
    if (s == "error")
        return token::ERROR;
    if (s == "pragma")
        return token::PRAGMA;

    return token::NONE;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x1114c(%rip), %rsi     # 0x145b5
callq 0x2080
testl %eax, %eax
je 0x3588
leaq 0x102b9(%rip), %rsi     # 0x13736
movq %rbx, %rdi
callq 0x2080
testl %eax, %eax
je 0x358f
leaq 0x102a7(%rip), %rsi     # 0x1373b
movq %rbx, %rdi
callq 0x2080
testl %eax, %eax
je 0x3596
leaq 0x11107(%rip), %rsi     # 0x145b2
movq %rbx, %rdi
callq 0x2080
testl %eax, %eax
je 0x359d
leaq 0x1027e(%rip), %rsi     # 0x13740
movq %rbx, %rdi
callq 0x2080
testl %eax, %eax
je 0x35a4
leaq 0x1026f(%rip), %rsi     # 0x13748
movq %rbx, %rdi
callq 0x2080
testl %eax, %eax
je 0x35ab
leaq 0x1025e(%rip), %rsi     # 0x1374e
movq %rbx, %rdi
callq 0x2080
testl %eax, %eax
je 0x35b2
leaq 0x1024e(%rip), %rsi     # 0x13755
movq %rbx, %rdi
callq 0x2080
testl %eax, %eax
je 0x35b9
leaq 0x1023e(%rip), %rsi     # 0x1375c
movq %rbx, %rdi
callq 0x2080
testl %eax, %eax
je 0x35c0
leaq 0x1022d(%rip), %rsi     # 0x13762
movq %rbx, %rdi
callq 0x2080
testl %eax, %eax
je 0x35c7
leaq 0x105c8(%rip), %rsi     # 0x13b14
movq %rbx, %rdi
callq 0x2080
testl %eax, %eax
je 0x35ce
leaq 0x1020b(%rip), %rsi     # 0x1376a
movq %rbx, %rdi
callq 0x2080
testl %eax, %eax
je 0x35d5
leaq 0x101fe(%rip), %rsi     # 0x13770
movq %rbx, %rdi
callq 0x2080
xorl %ecx, %ecx
testl %eax, %eax
movl $0x31, %eax
cmovnel %ecx, %eax
jmp 0x35da
movl $0x60, %eax
jmp 0x35da
movl $0x5a, %eax
jmp 0x35da
movl $0x61, %eax
jmp 0x35da
movl $0x62, %eax
jmp 0x35da
movl $0x63, %eax
jmp 0x35da
movl $0x64, %eax
jmp 0x35da
movl $0x65, %eax
jmp 0x35da
movl $0x66, %eax
jmp 0x35da
movl $0x67, %eax
jmp 0x35da
movl $0x68, %eax
jmp 0x35da
movl $0x69, %eax
jmp 0x35da
movl $0x6a, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/joncampbell123[P]haxcc/haxpp.cpp
// Function: parse_escape_oct(__gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&, __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, unsigned int, unsigned int)
unsigned long long parse_escape_oct(string::iterator &li,const string::iterator lie,const unsigned int min_digits,const unsigned int max_digits) {
    unsigned long long r = 0;
    unsigned int digits = 0;

    while (li != lie && digits < max_digits) {
        if (isoctdigit(*li)) {
            r = (r << 3ull) + char2oct_assume(*(li++));
            digits++;
        }
        else {
            break;
        }
    }

    if (digits < min_digits)
        throw invalid_argument("octal parse: not enough digits");

    return r;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %r9
cmpq %rsi, %r9
sete %al
testl %ecx, %ecx
sete %r8b
orb %al, %r8b
jne 0x3cdc
xorl %r8d, %r8d
xorl %eax, %eax
movb (%r9,%r8), %r10b
andb $-0x8, %r10b
cmpb $0x30, %r10b
jne 0x3ce1
leaq (%r9,%r8), %r10
leaq 0x1(%r10), %r11
movq %r11, (%rdi)
movb (%r10), %r10b
addb $-0x30, %r10b
movzbl %r10b, %r10d
leaq (%r10,%rax,8), %rax
incq %r8
cmpq %rsi, %r11
je 0x3ce1
cmpl %ecx, %r8d
jb 0x3ca5
jmp 0x3ce1
xorl %r8d, %r8d
xorl %eax, %eax
cmpl %edx, %r8d
jb 0x3cee
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x20e0
movq %rax, %rbx
leaq 0xfbb7(%rip), %rsi      # 0x138b9
movq %rax, %rdi
callq 0x23a0
movq 0x162c7(%rip), %rsi     # 0x19fd8
movq 0x162a8(%rip), %rdx     # 0x19fc0
movq %rbx, %rdi
callq 0x2330
movq %rax, %r14
movq %rbx, %rdi
callq 0x2160
movq %r14, %rdi
callq 0x2360
// File: /workspace/github_cpp_makefile_star2_O1/joncampbell123[P]haxcc/haxpp.cpp
// Function: parse_escape_hex(__gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&, __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, unsigned int, unsigned int)
unsigned long long parse_escape_hex(string::iterator &li,const string::iterator lie,const unsigned int min_digits,const unsigned int max_digits) {
    unsigned long long r = 0;
    unsigned int digits = 0;

    while (li != lie && digits < max_digits) {
        if (ishexdigit(*li)) {
            r = (r << 4ull) + char2hex_assume(*(li++));
            digits++;
        }
        else {
            break;
        }
    }

    if (digits < min_digits)
        throw invalid_argument("hex parse: not enough digits");

    return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %r9
cmpq %rsi, %r9
sete %al
testl %ecx, %ecx
sete %r8b
orb %al, %r8b
jne 0x3dcd
xorl %r8d, %r8d
movl $0xc9, %r10d
movabsq $0x3f0000003f, %r11     # imm = 0x3F0000003F
xorl %eax, %eax
movb (%r9,%r8), %bl
leal -0x30(%rbx), %ebp
cmpb $0xa, %bpl
jb 0x3d81
movzbl %bl, %ebx
addl $-0x41, %ebx
cmpl $0x25, %ebx
ja 0x3dd2
btq %rbx, %r11
jae 0x3dd2
leaq (%r9,%r8), %r14
leaq 0x1(%r14), %rbx
movq %rbx, (%rdi)
movb (%r14), %r14b
leal -0x61(%r14), %r15d
movl $0xa9, %ebp
cmpb $0x6, %r15b
jb 0x3da3
movl $0xd0, %ebp
movq %rax, %r15
shlq $0x4, %r15
leal -0x41(%r14), %eax
cmpb $0x6, %al
cmovbl %r10d, %ebp
addb %r14b, %bpl
movzbl %bpl, %eax
addq %r15, %rax
incq %r8
cmpq %rsi, %rbx
je 0x3dd2
cmpl %ecx, %r8d
jb 0x3d63
jmp 0x3dd2
xorl %r8d, %r8d
xorl %eax, %eax
cmpl %edx, %r8d
jb 0x3de2
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x20e0
movq %rax, %rbx
leaq 0xfae2(%rip), %rsi      # 0x138d8
movq %rax, %rdi
callq 0x23a0
movq 0x161d3(%rip), %rsi     # 0x19fd8
movq 0x161b4(%rip), %rdx     # 0x19fc0
movq %rbx, %rdi
callq 0x2330
movq %rax, %r14
movq %rbx, %rdi
callq 0x2160
movq %r14, %rdi
callq 0x2360
// File: /workspace/github_cpp_makefile_star2_O1/joncampbell123[P]haxcc/haxpp.cpp
// Function: parse_hex_number(__gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&, __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>)
unsigned long long parse_hex_number(string::iterator &li,const string::iterator lie) {
    unsigned long long r = 0;

    while (li != lie && ishexdigit(*li))
        r = (r << 4ull) + char2hex_assume(*(li++));

    return r;
}

// Assembly:
movq (%rdi), %r8
xorl %eax, %eax
cmpq %rsi, %r8
je 0x41fa
movl $0xc9, %ecx
movabsq $0x3f0000003f, %rdx     # imm = 0x3F0000003F
movb (%r8), %r9b
leal -0x30(%r9), %r10d
cmpb $0xa, %r10b
jb 0x41b8
movzbl %r9b, %r9d
addl $-0x41, %r9d
cmpl $0x25, %r9d
ja 0x41fa
btq %r9, %rdx
jae 0x41fa
leaq 0x1(%r8), %r9
movq %r9, (%rdi)
movb (%r8), %r8b
leal -0x61(%r8), %r11d
movl $0xa9, %r10d
cmpb $0x6, %r11b
jb 0x41d8
movl $0xd0, %r10d
shlq $0x4, %rax
leal -0x41(%r8), %r11d
cmpb $0x6, %r11b
cmovbl %ecx, %r10d
addb %r8b, %r10b
movzbl %r10b, %r8d
addq %r8, %rax
movq %r9, %r8
cmpq %rsi, %r9
jne 0x4197
retq
// File: /workspace/github_cpp_makefile_star2_O1/joncampbell123[P]haxcc/haxpp.cpp
// Function: parse_dec_number(__gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&, __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>)
unsigned long long parse_dec_number(string::iterator &li,const string::iterator lie) {
    unsigned long long r = 0;

    while (li != lie && isdigit(*li))
        r = (r * 10ull) + char2dec_assume(*(li++));

    return r;
}

// Assembly:
movq (%rdi), %rcx
xorl %eax, %eax
cmpq %rsi, %rcx
je 0x4278
movsbl (%rcx), %edx
addl $-0x30, %edx
cmpl $0x9, %edx
ja 0x4278
leaq (%rax,%rax,4), %rax
leaq 0x1(%rcx), %rdx
movq %rdx, (%rdi)
movb (%rcx), %cl
addb $-0x30, %cl
movzbl %cl, %ecx
leaq (%rcx,%rax,2), %rax
movq %rdx, %rcx
cmpq %rsi, %rdx
jne 0x424e
retq
// File: /workspace/github_cpp_makefile_star2_O1/joncampbell123[P]haxcc/haxpp.cpp
// Function: parse_number_looks_like_float(__gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>)
bool parse_number_looks_like_float(string::iterator /*does not modify caller copy*/li,const string::iterator lie) {
    if (strit_next_match_inc(li,lie,'0','x')) {
        while (li != lie && isxdigit(*li)) li++;
        if (li != lie) return (*li == '.' || *li == 'p' || *li == 'p');
    }
    else {
        while (li != lie && isdigit(*li)) li++;
        if (li != lie) return (*li == '.' || *li == 'e' || *li == 'E');
    }

    return false;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x4a61
cmpb $0x30, (%rbx)
jne 0x4a61
leaq 0x1(%rbx), %rax
cmpq %r14, %rax
je 0x4a61
xorl %eax, %eax
cmpb $0x78, 0x1(%rbx)
sete %al
leaq (%rbx,%rax,2), %rbx
jmp 0x4a63
xorl %eax, %eax
cmpq %r14, %rbx
sete %bpl
testb %al, %al
je 0x4ab6
cmpq %r14, %rbx
je 0x4b01
movsbl (%rbx), %edi
callq 0x2060
testl %eax, %eax
je 0x4aa1
incq %rbx
cmpq %r14, %rbx
sete %bpl
je 0x4b01
movsbl (%rbx), %edi
callq 0x2060
incq %rbx
testl %eax, %eax
jne 0x4a86
decq %rbx
testb %bpl, %bpl
jne 0x4b01
movb (%rbx), %al
cmpb $0x2e, %al
sete %cl
cmpb $0x70, %al
sete %al
orb %cl, %al
jmp 0x4b03
cmpq %r14, %rbx
je 0x4b01
movsbl (%rbx), %eax
addl $-0x30, %eax
cmpl $0x9, %eax
ja 0x4ae3
incq %rbx
cmpq %r14, %rbx
sete %bpl
je 0x4b01
movsbl (%rbx), %eax
addl $-0x30, %eax
incq %rbx
cmpl $0x9, %eax
jbe 0x4ac9
decq %rbx
testb %bpl, %bpl
jne 0x4b01
movb (%rbx), %cl
addb $-0x2e, %cl
cmpb $0x37, %cl
ja 0x4b01
movabsq $0x80000000800001, %rax # imm = 0x80000000800001
shrq %cl, %rax
jmp 0x4b03
xorl %eax, %eax
andb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/joncampbell123[P]haxcc/haxpp.cpp
// Function: parse_identifier(__gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&, __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>)
string parse_identifier(string::iterator &li,const string::iterator lie) {
    string r;

    if (li == lie) throw invalid_argument("expected identifier, got end of line");
    if (!isidentifier_fc(*li)) throw invalid_argument("expected identifier");

    do {
        r += *(li++);
        if (li == lie) break;
        if (!isidentifier_mc(*li)) break;
    } while (1);

    return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %r13
movq %r13, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq (%rsi), %rax
cmpq %rdx, %rax
je 0x5148
movq %rdx, %r14
movq %rsi, %r15
movsbl (%rax), %ebp
movl %ebp, %edi
callq 0x2300
cmpl $0x5f, %ebp
je 0x50f9
testl %eax, %eax
je 0x5166
movq (%r15), %rax
leaq 0x1(%rax), %rcx
movq %rcx, (%r15)
movsbl (%rax), %esi
movq %rbx, %rdi
callq 0x2190
movq (%r15), %rax
cmpq %r14, %rax
je 0x5136
movsbl (%rax), %r12d
leal -0x30(%r12), %eax
cmpl $0xa, %eax
jb 0x50f9
movl %r12d, %edi
callq 0x2300
cmpb $0x5f, %r12b
je 0x50f9
testl %eax, %eax
jne 0x50f9
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x20e0
movq %rax, %r14
leaq 0xe9d3(%rip), %rsi      # 0x13b2f
movq %rax, %rdi
callq 0x23a0
jmp 0x5182
movl $0x10, %edi
callq 0x20e0
movq %rax, %r14
leaq 0xe9da(%rip), %rsi      # 0x13b54
movq %rax, %rdi
callq 0x23a0
movq 0x14e4f(%rip), %rsi     # 0x19fd8
movq 0x14e30(%rip), %rdx     # 0x19fc0
movq %r14, %rdi
callq 0x2330
jmp 0x519a
movq %rax, %r15
movq %r14, %rdi
callq 0x2160
jmp 0x51ac
jmp 0x51a9
movq %rax, %r15
movq (%rbx), %rdi
cmpq %r13, %rdi
je 0x51c0
movq (%r13), %rsi
incq %rsi
callq 0x21d0
movq %r15, %rdi
callq 0x2360
// File: /workspace/github_cpp_makefile_star2_O1/joncampbell123[P]haxcc/haxpp.cpp
// Function: print_token(_IO_FILE*, token const&)
void print_token(FILE *fp,const token &t) {
    if (fp == NULL)
        fp = stderr;

    const string s = to_string(t);
    fputs(s.c_str(),fp);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x6906
movq 0x136b5(%rip), %rax     # 0x19fb8
movq (%rax), %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x5221
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x2200
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x6938
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21d0
addq $0x28, %rsp
popq %rbx
popq %r14
retq