LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2a11
movl %r15d, %ecx
cmpl $-0x1, %eax
je 0x2a38
cmpl $0xa, %eax
je 0x2a38
cmpl %ebp, %r15d
jge 0x2a11
movb %al, (%rbx,%rcx)
incl %r15d
jmp 0x2a11
movb $0x0, (%rbx,%rcx)
notl %eax
orl %r15d, %eax
pushq $-0x1
popq %rax
cmovnel %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2a6a
movq %rbx, %rdi
callq 0x20f0
movq %rax, %rdx
xorl %ecx, %ecx
testl %edx, %edx
movl $0x0, %eax
cmovgl %edx, %eax
movq %rcx, %rsi
cmpq %rcx, %rax
je 0x2a88
leaq 0x1(%rsi), %rcx
cmpb %bpl, (%rbx,%rsi)
jne 0x2a76
movslq %edx, %rax
cmpq %rax, %rsi
setl %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
xorl %eax, %eax
testq %rdi, %rdi
je 0x2aa2
popq %rbx
retq
movl %ecx, %ebx
movq %rdx, %rcx
movq %rsi, %rdx
movq 0x8527(%rip), %rax      # 0xafd8
movq (%rax), %rdi
leaq 0x4cf9(%rip), %rsi      # 0x77b4
xorl %eax, %eax
callq 0x2290
testb %bl, %bl
jne 0x2acb
pushq $-0x1
popq %rax
jmp 0x2aa0
leaq 0x4d09(%rip), %rdi      # 0x77db
leaq 0x4d0d(%rip), %rsi      # 0x77e6
leaq 0x4d11(%rip), %rcx      # 0x77f1
movl $0x189, %edx            # imm = 0x189
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O2/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 0x450d(%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_O2/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 0x2bb3
testl %ecx, %ecx
jne 0x2bcf
cmpl %edi, %esi
setge %al
cmpl %edx, %esi
setge %cl
testb %cl, %al
jne 0x2bf1
cmpl %esi, %edi
setl %al
cmpl %edx, %edi
setl %cl
orb %al, %cl
movzbl %cl, %eax
addl %eax, %eax
retq
cmpl %edi, %edx
setge %al
cmpl %esi, %edx
setge %cl
testb %cl, %al
jne 0x2bed
cmpl %edi, %esi
setge %al
cmpl %edx, %esi
setge %cl
andb %al, %cl
jmp 0x2be9
cmpl %edi, %edx
setge %al
cmpl %esi, %edx
setge %cl
testb %cl, %al
jne 0x2bed
cmpl %esi, %edi
setl %al
cmpl %edx, %edi
setl %cl
orb %al, %cl
movzbl %cl, %eax
retq
pushq $0x2
jmp 0x2bf3
pushq $0x1
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r14d
movq %rdi, %rbx
movq %rdi, 0x8(%rdi)
movq %rdi, (%rdi)
andq $0x0, 0x10(%rdi)
movq %rsi, %r15
movslq %ecx, %r13
xorl %r12d, %r12d
cmpl %ebp, %r12d
jge 0x34f3
movl %r12d, %eax
movslq %eax, %rcx
cmpb %r14b, (%r15,%rcx)
jne 0x34cf
movq %r13, %rdx
subq %rcx, %rdx
addq %r15, %rcx
xorl %r12d, %r12d
cmpq %r12, %rdx
je 0x34d6
cmpb %r14b, (%rcx,%r12)
jne 0x34db
incq %r12
jmp 0x34bf
incl %eax
movl %eax, %r12d
jmp 0x34a2
movl %ebp, %r12d
jmp 0x34de
addl %eax, %r12d
movl %eax, (%rsp)
movl %r12d, 0x4(%rsp)
movq %rbx, %rdi
movq %rsp, %rsi
callq 0x5c14
jmp 0x34a2
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x5f18
movq %r14, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O2/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
movslq %eax, %r10
xorl %r11d, %r11d
cmpq %r10, %r11
jg 0x3bbc
andl $0x0, (%rcx,%r11,4)
andl $0x0, (%r8,%r11,4)
incq %r11
jmp 0x3ba8
xorl %r11d, %r11d
testl %edx, %edx
cmovlel %r11d, %edx
leaq 0x75c0(%rip), %rbx      # 0xb18c
cmpq $0x3, %r11
je 0x3c00
movb (%r11,%rbx), %bpl
xorl %r14d, %r14d
cmpq %r14, %rdx
je 0x3bfb
cmpb %bpl, (%rdi,%r14)
jne 0x3bf6
incl (%r8,%r11,4)
movb (%rdi,%r14), %r15b
cmpb (%rsi,%r14), %r15b
jne 0x3bf6
incl (%rcx,%r11,4)
incq %r14
jmp 0x3bd9
incq %r11
jmp 0x3bcc
xorl %edx, %edx
testl %eax, %eax
cmovlel %edx, %eax
movsd 0x33f9(%rip), %xmm0     # 0x7008
cmpq %rdx, %rax
je 0x3c40
movl (%rcx,%rdx,4), %esi
cvtsi2sd %esi, %xmm1
cvtsi2sdl (%r8,%rdx,4), %xmm2
addsd %xmm0, %xmm2
divsd %xmm2, %xmm1
movsd %xmm1, (%r9,%rdx,8)
addl %esi, (%rcx,%r10,4)
movl (%r8,%rdx,4), %esi
addl %esi, (%r8,%r10,4)
incq %rdx
jmp 0x3c0f
cvtsi2sdl (%rcx,%r10,4), %xmm0
movl (%r8,%r10,4), %eax
cvtsi2sd %eax, %xmm1
addsd 0x33b2(%rip), %xmm1     # 0x7008
divsd %xmm1, %xmm0
movsd %xmm0, (%r9,%r10,8)
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5ae7
movl %r8d, %ebp
movq %rcx, %r15
cltq
movq (%r14,%rax,8), %r12
movq %r12, %rdi
callq 0x2810
testb %al, %al
je 0x5ae7
movq %r12, %rdi
callq 0x2230
testb %bpl, %bpl
je 0x5ad0
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
ja 0x5b0b
ucomisd (%rsp), %xmm0
ja 0x5b0b
movsd %xmm0, (%r15)
addl $0x2, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x54ea(%rip), %rax      # 0xafd8
movq (%rax), %rdi
movslq %ebx, %rax
movq (%r14,%rax,8), %rdx
leaq 0x1c40(%rip), %rsi      # 0x773f
xorl %eax, %eax
callq 0x2290
pushq $-0x1
popq %rbx
jmp 0x5ad8
movq 0x54c6(%rip), %rax      # 0xafd8
movq (%rax), %rdi
movslq %ebx, %rax
movq (%r14,%rax,8), %rdx
leaq 0x1bd4(%rip), %rsi      # 0x76f7
movsd 0x8(%rsp), %xmm0
movsd (%rsp), %xmm1
movb $0x2, %al
callq 0x2290
jmp 0x5b06
// File: /workspace/github_cpp_makefile_star2_O2/nanjiangshu[P]calSOV/./array.h
// Function: Array1D<char>::~Array1D()
Array1D<T>::~Array1D(void) /*{{{*/
{
    delete [] array1D ;
    array1D = NULL;
    this->size = 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x5c0a
callq 0x2260
andq $0x0, 0x8(%rbx)
andl $0x0, (%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
xorl %eax, %eax
movl (%rdi), %ecx
cmpq %rcx, %rax
jae 0x5d32
movq 0x8(%rdi), %rcx
movb %sil, (%rcx,%rax)
incq %rax
jmp 0x5d1e
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rdi, %rbx
movl %esi, 0x8(%rdi)
movl %edx, 0xc(%rdi)
movl %esi, %r15d
leaq (,%r15,8), %rdi
callq 0x2030
movq %rax, (%rbx)
movl %ebp, %r14d
shlq $0x2, %r14
xorl %r12d, %r12d
cmpq %r12, %r15
je 0x5dab
movq %r14, %rdi
callq 0x2030
movq (%rbx), %rcx
movq %rax, (%rcx,%r12,8)
incq %r12
jmp 0x5d92
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
xorl %eax, %eax
movl 0x8(%rdi), %ecx
cmpq %rcx, %rax
jae 0x5e30
movq (%rdi), %rcx
xorl %edx, %edx
movl 0xc(%rdi), %r8d
cmpq %r8, %rdx
jae 0x5e2b
movq (%rcx,%rax,8), %r8
movl %esi, (%r8,%rdx,4)
incq %rdx
jmp 0x5e15
incq %rax
jmp 0x5e08
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
xorl %r14d, %r14d
movl 0x8(%rbx), %eax
movq (%rbx), %rdi
cmpq %rax, %r14
jae 0x5e88
movq (%rdi,%r14,8), %rdi
testq %rdi, %rdi
je 0x5e83
callq 0x2260
incq %r14
jmp 0x5e6a
testq %rdi, %rdi
je 0x5e92
callq 0x2260
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x1
popq %rcx
xorl %edx, %edx
callq 0x16ba
andq $0x0, 0x10(%rbx)
andl $0x0, 0x18(%rbx)
andq $0x0, 0x30(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
movq 0x8(%rbx), %r14
cmpq $-0x1, %r14
je 0x169b
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
pushq $0x18
popq %rdi
callq 0x1110
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
pushq $0x18
popq %rdi
callq 0x1110
leaq (%r14,%r15,4), %rcx
addq $0x1c, %rcx
addq $0x4, %rcx
movl %ebp, (%rax)
movq %rcx, 0x8(%rax)
andq $0x0, 0x10(%rax)
movq %rax, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x172e
movq %r14, %rdi
callq 0x1160
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x10d0
movl %eax, %r15d
movq %rsp, %r12
movl %eax, %edi
movq %r12, %rsi
callq 0x1150
movq 0x30(%r12), %r12
xorl %edi, %edi
movq %r12, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movl %r15d, %r8d
xorl %r9d, %r9d
callq 0x1170
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_O2/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 %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
callq 0x17e8
movl %eax, %r14d
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x17fe
movl %eax, %ebp
movq 0x28(%rbx), %rdi
movq 0x8(%rdi), %rax
movl %r14d, %ecx
shrl $0x5, %ecx
movl (%rax,%rcx,4), %ecx
btl %r14d, %ecx
jae 0x17d6
movl %ebp, %ecx
shrl $0x5, %ecx
movl (%rax,%rcx,4), %eax
movl %r14d, %esi
btl %ebp, %eax
jae 0x17d8
callq 0x181c
movl %eax, %r14d
movl %eax, (%rsp)
movq 0x28(%rbx), %rdi
movl %ebp, %esi
callq 0x181c
movl %eax, 0x4(%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 (%rsp,%rdx,4), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %ebp, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x181c
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
xorl %r15d, %r15d
movq 0x8(%r14), %rax
movl %ebp, %ecx
movl (%rax,%rcx,4), %edi
cmpl $0x20, %ebx
jb 0x18b4
callq 0x18d2
addl %eax, %r15d
incl %ebp
addl $-0x20, %ebx
jmp 0x1897
pushq $0x2
popq %rax
movl %ebx, %ecx
shll %cl, %eax
decl %eax
andl %eax, %edi
callq 0x18d2
addl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x286d
movb 0x4(%rdi), %al
cmpb 0x4(%rsi), %al
jne 0x286d
movq 0x8(%rdi), %rcx
xorl %eax, %eax
cmpq 0x8(%rsi), %rcx
jne 0x286c
movb 0x10(%rsi), %cl
cmpb %cl, 0x10(%rdi)
jne 0x286c
fldt 0x20(%rdi)
fldt 0x20(%rsi)
xorl %eax, %eax
fxch %st(1)
fucompi %st(1), %st
fstp %st(0)
jne 0x286c
jp 0x286c
movl 0x30(%rsi), %ecx
cmpl %ecx, 0x30(%rdi)
jne 0x286c
movq 0x40(%rdi), %rax
cmpq 0x40(%rsi), %rax
jne 0x286d
pushq %rax
addq $0x48, %rdi
addq $0x48, %rsi
callq 0xb128
xorb $0x1, %al
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
movq %rdi, %r14
callq 0x2a34
movq %rbx, (%r14)
andq $0x0, 0x18(%r14)
movq 0x10(%r14), %rax
movb $0x0, (%rax)
movq $0x1, 0x30(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2a4f
cmpb $0x1, 0x8(%rbx)
jne 0x2a4b
callq 0x21b0
andq $0x0, (%rbx)
movb $0x0, 0x8(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2a89
retq
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
leaq 0xccc8(%rip), %rsi      # 0xf760
callq 0x2220
movq %rax, (%rbx)
testq %rax, %rax
je 0x2aa9
movb $0x1, 0x8(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2b05
movq %rdi, %r14
movq (%r14), %rdi
callq 0x22e0
cmpl $0xd, %eax
je 0x2ae3
movl %eax, %ebx
cmpl $0xa, %eax
jne 0x2b0a
incl 0x30(%r14)
movl $0x1, 0x34(%r14)
jmp 0x2b0e
pushq $-0x1
popq %rbx
jmp 0x2b1a
incl 0x34(%r14)
movq (%r14), %rdi
callq 0x2390
testl %eax, %eax
jne 0x2b24
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x20e0
movq %rax, %rbx
leaq 0xcc2d(%rip), %rsi      # 0xf763
movq %rax, %rdi
callq 0x20a0
movq 0x154b3(%rip), %rsi     # 0x17ff8
movq 0x15464(%rip), %rdx     # 0x17fb0
movq %rbx, %rdi
callq 0x2340
movq %rax, %r14
movq %rbx, %rdi
callq 0x2160
movq %r14, %rdi
callq 0x2370
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2ba9
cmpb $0x1, 0x8(%rbx)
jne 0x2ba5
callq 0x21b0
andq $0x0, (%rbx)
movb $0x0, 0x8(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2bdd
retq
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
leaq 0xcb8f(%rip), %rsi      # 0xf77b
callq 0x2220
movq %rax, (%rbx)
testq %rax, %rax
je 0x2bfd
movb $0x1, 0x8(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2c38
movq %rdi, %rbx
movsbl %al, %edi
callq 0x2250
cmpl $-0x1, %eax
jne 0x2c38
movq (%rbx), %rdi
callq 0x2390
testl %eax, %eax
jne 0x2c40
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x20e0
movq %rax, %rbx
leaq 0xcb2c(%rip), %rsi      # 0xf77e
movq %rax, %rdi
callq 0x20a0
movq 0x15397(%rip), %rsi     # 0x17ff8
movq 0x15348(%rip), %rdx     # 0x17fb0
movq %rbx, %rdi
callq 0x2340
movq %rax, %r14
movq %rbx, %rdi
callq 0x2160
movq %r14, %rdi
callq 0x2370
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2caf
movq %rdi, %rbx
movq %rsi, %rdi
movq %rax, %rsi
callq 0x2200
cmpl $-0x1, %eax
jne 0x2caf
movq (%rbx), %rdi
callq 0x2390
testl %eax, %eax
jne 0x2cb7
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x20e0
movq %rax, %rbx
leaq 0xcab5(%rip), %rsi      # 0xf77e
movq %rax, %rdi
callq 0x20a0
movq 0x15320(%rip), %rsi     # 0x17ff8
movq 0x152d1(%rip), %rdx     # 0x17fb0
movq %rbx, %rdi
callq 0x2340
movq %rax, %r14
movq %rbx, %rdi
callq 0x2160
movq %r14, %rdi
callq 0x2370
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2d32
cmpb $0x1, (%rdi)
jne 0x2d23
movb $0x0, 0x1(%rdi)
movb $0x0, 0x3(%rdi)
movb %sil, (%rdi)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x20e0
movq %rax, %rbx
leaq 0xca52(%rip), %rsi      # 0xf796
movq %rax, %rdi
callq 0x23a0
movq 0x15285(%rip), %rsi     # 0x17fd8
movq 0x15266(%rip), %rdx     # 0x17fc0
movq %rbx, %rdi
callq 0x2340
movq %rax, %r14
movq %rbx, %rdi
callq 0x2160
movq %r14, %rdi
callq 0x2370
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2da9
movb (%rdi), %al
cmpb $0x1, %al
jne 0x2d98
movb $0x0, 0x1(%rdi)
andw $0x0, 0x2(%rdi)
xorb $0x1, %al
movb %al, (%rdi)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x20e0
movq %rax, %rbx
leaq 0xc9f2(%rip), %rsi      # 0xf7ad
movq %rax, %rdi
callq 0x23a0
movq 0x1520e(%rip), %rsi     # 0x17fd8
movq 0x151ef(%rip), %rdx     # 0x17fc0
movq %rbx, %rdi
callq 0x2340
movq %rax, %r14
movq %rbx, %rdi
callq 0x2160
movq %r14, %rdi
callq 0x2370
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xb159
testb %al, %al
jne 0x2e38
leaq 0x18(%r14), %rdi
leaq 0x18(%rbx), %rsi
callq 0xb163
testb %al, %al
jne 0x2e38
movb 0x32(%r14), %al
cmpb 0x32(%rbx), %al
jne 0x2e38
movb 0x30(%r14), %al
cmpb 0x30(%rbx), %al
jne 0x2e38
movb 0x31(%r14), %al
cmpb 0x31(%rbx), %al
sete %al
jmp 0x2e3a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
andq $0x0, 0x8(%rdi)
movq %rsi, %rbx
movq (%rdi), %rax
movb $0x0, (%rax)
pushq $0x27
popq %rbp
pushq $0x2f
popq %r12
pushq $0x5c
popq %r13
movq %rbx, %rdi
callq 0x2ab4
testb %al, %al
jne 0x2fa1
movq %rbx, %rdi
callq 0x2ad6
cmpl $0x27, %eax
je 0x2f14
cmpl $0x2f, %eax
je 0x2eae
cmpl $0x5c, %eax
je 0x2ede
cmpl $-0x1, %eax
je 0x2fa1
cmpl $0xa, %eax
je 0x2fa1
movsbl %al, %esi
jmp 0x2f07
movq %rbx, %rdi
callq 0x2ad6
cmpl $0x2f, %eax
je 0x2f4d
movl %eax, %r15d
cmpl $0x2a, %eax
je 0x2f40
movq %r14, %rdi
movl %r12d, %esi
cmpl $-0x1, %r15d
je 0x2f0a
callq 0x2190
movsbl %r15b, %esi
jmp 0x2f07
movq %rbx, %rdi
callq 0x2ad6
cmpl $-0x1, %eax
je 0x2e6c
movl %eax, %r15d
movb $0x20, %al
cmpl $0xa, %r15d
je 0x2f04
movq %r14, %rdi
movl %r13d, %esi
callq 0x2190
movl %r15d, %eax
movsbl %al, %esi
movq %r14, %rdi
callq 0x2190
jmp 0x2e6c
movq %r14, %rdi
movl %ebp, %esi
callq 0x2190
movq %rbx, %rdi
callq 0x2ad6
movl %eax, %r15d
movsbl %r15b, %esi
movq %r14, %rdi
callq 0x2190
cmpl $0x27, %r15d
jne 0x2f1e
jmp 0x2e6c
movq %rbx, %rdi
callq 0x2fde
jmp 0x2e6c
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
andq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
movq %rbx, %rdi
callq 0x2ad6
cmpl $0x5c, %eax
je 0x2f7b
cmpl $-0x1, %eax
je 0x2f88
cmpl $0xa, %eax
jne 0x2f62
jmp 0x2f97
movq %rbx, %rdi
callq 0x2ad6
cmpl $0xa, %eax
jne 0x2f62
leaq 0x8(%rsp), %rdi
callq 0x2408
jmp 0x2e6c
leaq 0x8(%rsp), %rdi
callq 0x2408
cmpq $0x0, 0x8(%r14)
jne 0x2fb8
movq %rbx, %rdi
callq 0x2ab4
testb %al, %al
je 0x2fb8
xorl %eax, %eax
jmp 0x2fba
movb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2408
movq %rbx, %rdi
callq 0x2370
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq %rbx, %rdi
callq 0x2ad6
cmpl $0x2a, %eax
je 0x3027
cmpl $0x2f, %eax
je 0x3010
cmpl $-0x1, %eax
jne 0x2ff7
jmp 0x3034
movq %rbx, %rdi
callq 0x2ad6
cmpl $0x2a, %eax
jne 0x2ff7
movq %rbx, %rdi
callq 0x2fde
jmp 0x2ff7
movq %rbx, %rdi
callq 0x2ad6
cmpl $0x2f, %eax
jne 0x2ff7
movq %rsp, %rdi
callq 0x2408
addq $0x20, %rsp
popq %rbx
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2408
movq %rbx, %rdi
callq 0x2370
// File: /workspace/github_cpp_makefile_star2_O2/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 0xd5c7(%rip), %rsi      # 0x10645
callq 0xb1f3
testb %al, %al
je 0x308e
pushq $0x60
jmp 0x3198
leaq 0xc731(%rip), %rsi      # 0xf7c6
movq %rbx, %rdi
callq 0xb1f3
testb %al, %al
je 0x30a8
pushq $0x5a
jmp 0x3198
leaq 0xc71c(%rip), %rsi      # 0xf7cb
movq %rbx, %rdi
callq 0xb1f3
testb %al, %al
je 0x30c2
pushq $0x61
jmp 0x3198
leaq 0xd579(%rip), %rsi      # 0x10642
movq %rbx, %rdi
callq 0xb1f3
testb %al, %al
je 0x30dc
pushq $0x62
jmp 0x3198
leaq 0xc6ed(%rip), %rsi      # 0xf7d0
movq %rbx, %rdi
callq 0xb1f3
testb %al, %al
je 0x30f6
pushq $0x63
jmp 0x3198
leaq 0xc6db(%rip), %rsi      # 0xf7d8
movq %rbx, %rdi
callq 0xb1f3
testb %al, %al
je 0x3110
pushq $0x64
jmp 0x3198
leaq 0xc6c7(%rip), %rsi      # 0xf7de
movq %rbx, %rdi
callq 0xb1f3
testb %al, %al
je 0x3127
pushq $0x65
jmp 0x3198
leaq 0xc6b7(%rip), %rsi      # 0xf7e5
movq %rbx, %rdi
callq 0xb1f3
testb %al, %al
je 0x313e
pushq $0x66
jmp 0x3198
leaq 0xc6a7(%rip), %rsi      # 0xf7ec
movq %rbx, %rdi
callq 0xb1f3
testb %al, %al
je 0x3155
pushq $0x67
jmp 0x3198
leaq 0xc696(%rip), %rsi      # 0xf7f2
movq %rbx, %rdi
callq 0xb1f3
testb %al, %al
je 0x316c
pushq $0x68
jmp 0x3198
leaq 0xca31(%rip), %rsi      # 0xfba4
movq %rbx, %rdi
callq 0xb1f3
testb %al, %al
je 0x3183
pushq $0x69
jmp 0x3198
leaq 0xc670(%rip), %rsi      # 0xf7fa
movq %rbx, %rdi
callq 0xb1f3
testb %al, %al
je 0x319b
pushq $0x6a
popq %rax
popq %rbx
retq
leaq 0xc65e(%rip), %rsi      # 0xf800
movq %rbx, %rdi
callq 0xb1f3
xorl %ecx, %ecx
testb %al, %al
pushq $0x31
popq %rax
cmovel %ecx, %eax
jmp 0x3199
// File: /workspace/github_cpp_makefile_star2_O2/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
xorl %r8d, %r8d
xorl %eax, %eax
leaq (%r9,%r8), %r10
cmpq %rsi, %r10
je 0x3782
cmpl %ecx, %r8d
jae 0x3782
movb (%r10), %r11b
andb $-0x8, %r11b
cmpb $0x30, %r11b
jne 0x3782
leaq 0x1(%r10), %r11
movq %r11, (%rdi)
movb (%r10), %r10b
addb $-0x30, %r10b
movzbl %r10b, %r10d
leaq (%r10,%rax,8), %rax
incq %r8
jmp 0x374c
cmpl %edx, %r8d
jb 0x378f
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x20e0
movq %rax, %rbx
leaq 0xc1a8(%rip), %rsi      # 0xf949
movq %rax, %rdi
callq 0x23a0
movq 0x14828(%rip), %rsi     # 0x17fd8
movq 0x14809(%rip), %rdx     # 0x17fc0
movq %rbx, %rdi
callq 0x2340
movq %rax, %r14
movq %rbx, %rdi
callq 0x2160
movq %r14, %rdi
callq 0x2370
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, 0x4(%rsp)
movl %edx, (%rsp)
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rbx
xorl %r13d, %r13d
xorl %r12d, %r12d
leaq (%rbx,%r13), %rbp
cmpq %r14, %rbp
je 0x384c
cmpl 0x4(%rsp), %r13d
jae 0x384c
movsbl (%rbp), %edi
callq 0x36f9
testb %al, %al
je 0x384c
shlq $0x4, %r12
leaq 0x1(%rbp), %rax
movq %rax, (%r15)
movb (%rbp), %al
leal -0x61(%rax), %ecx
cmpb $0x6, %cl
movl $0xd0, %ecx
movl $0xa9, %edx
cmovbl %edx, %ecx
leal -0x41(%rax), %edx
cmpb $0x6, %dl
movl $0xc9, %edx
cmovbl %edx, %ecx
addb %al, %cl
movzbl %cl, %eax
addq %rax, %r12
incq %r13
jmp 0x37f3
cmpl (%rsp), %r13d
jb 0x3864
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x20e0
movq %rax, %rbx
leaq 0xc0f2(%rip), %rsi      # 0xf968
movq %rax, %rdi
callq 0x23a0
movq 0x14753(%rip), %rsi     # 0x17fd8
movq 0x14734(%rip), %rdx     # 0x17fc0
movq %rbx, %rdi
callq 0x2340
movq %rax, %r14
movq %rbx, %rdi
callq 0x2160
movq %r14, %rdi
callq 0x2370
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %r13
xorl %r15d, %r15d
movl $0xa9, %ebp
movl $0xc9, %r12d
cmpq %rbx, %r13
je 0x3c30
movsbl (%r13), %edi
callq 0x36f9
testb %al, %al
je 0x3c30
shlq $0x4, %r15
leaq 0x1(%r13), %rax
movq %rax, (%r14)
movb (%r13), %cl
leal -0x61(%rcx), %edx
cmpb $0x6, %dl
movl $0xd0, %edx
cmovbl %ebp, %edx
leal -0x41(%rcx), %esi
cmpb $0x6, %sil
cmovbl %r12d, %edx
addb %cl, %dl
movzbl %dl, %ecx
addq %rcx, %r15
movq %rax, %r13
jmp 0x3be8
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/joncampbell123[P]haxcc/haxpp.cpp
// Function: parse_oct_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_oct_number(string::iterator &li,const string::iterator lie) {
    unsigned long long r = 0;

    while (li != lie && isoctdigit_throw(*li))
        r = (r << 3ull) + char2oct_assume(*(li++));

    return r;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
xorl %r15d, %r15d
cmpq %rbx, %rax
je 0x3c7c
movsbl (%rax), %edi
callq 0x368f
testb %al, %al
je 0x3c7c
movq (%r14), %rcx
leaq 0x1(%rcx), %rax
movq %rax, (%r14)
movb (%rcx), %cl
addb $-0x30, %cl
movzbl %cl, %ecx
leaq (%rcx,%r15,8), %r15
jmp 0x3c53
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3cb4
movsbl (%rcx), %edx
addl $-0x30, %edx
cmpl $0x9, %edx
ja 0x3cb4
imulq $0xa, %rax, %rdx
leaq 0x1(%rcx), %r8
movq %r8, (%rdi)
movb (%rcx), %al
addb $-0x30, %al
movzbl %al, %eax
addq %rdx, %rax
movq %r8, %rcx
jmp 0x3c8a
retq
// File: /workspace/github_cpp_makefile_star2_O2/joncampbell123[P]haxcc/haxpp.cpp
// Function: parse_float_hexponent(long long&, __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>>>)
void parse_float_hexponent(signed long long &exponent,string::iterator &li,const string::iterator lie) {
    /* e.g. "p-3". caller has already eaten the 'p' */
    signed long long exp_adjust;

    if (strit_next_match_inc(li,lie,'-'))
        exp_adjust = -((signed long long)parse_dec_number(li,lie));
    else if (strit_next_match_inc(li,lie,'+'))
        exp_adjust =   (signed long long)parse_dec_number(li,lie);
    else
        exp_adjust =   (signed long long)parse_dec_number(li,lie);

    exponent += exp_adjust;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rax
cmpq %rdx, %rax
je 0x3ce7
cmpb $0x2d, (%rax)
jne 0x3cdc
incq %rax
movq %rax, (%rsi)
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x3c85
negq %rax
jmp 0x3cf2
cmpb $0x2b, (%rax)
jne 0x3ce7
incq %rax
movq %rax, (%rsi)
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x3c85
addq %rax, (%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/joncampbell123[P]haxcc/haxpp.cpp
// Function: parse_float_exponent(long double&, __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>>>)
void parse_float_exponent(long double &r,string::iterator &li,const string::iterator lie) {
    /* e.g. "e-3". caller has already eaten the 'e' */
    signed long long exp_adjust;

    if (strit_next_match_inc(li,lie,'-'))
        exp_adjust = -((signed long long)parse_dec_number(li,lie));
    else if (strit_next_match_inc(li,lie,'+'))
        exp_adjust =   (signed long long)parse_dec_number(li,lie);
    else
        exp_adjust =   (signed long long)parse_dec_number(li,lie);

    if (exp_adjust != 0) {
        long double m = 1;
        while (exp_adjust <= -9) {
            exp_adjust += 9;
            m /= 1000000000;
        }
        while (exp_adjust < 0) {
            exp_adjust++;
            m /= 10;
        }

        while (exp_adjust >= 9) {
            exp_adjust -= 9;
            m *= 1000000000;
        }
        while (exp_adjust > 0) {
            exp_adjust--;
            m *= 10;
        }

        r *= m;
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rax
cmpq %rdx, %rax
je 0x3d29
cmpb $0x2d, (%rax)
jne 0x3d1e
incq %rax
movq %rax, (%rsi)
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x3c85
negq %rax
jmp 0x3d34
cmpb $0x2b, (%rax)
jne 0x3d29
incq %rax
movq %rax, (%rsi)
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x3c85
testq %rax, %rax
je 0x3d83
fld1
cmpq $-0x8, %rax
jge 0x3d56
addq $0x9, %rax
fdivs 0xb9f9(%rip)            # 0xf744
jmp 0x3d3b
incq %rax
fdivs 0xb9ea(%rip)            # 0xf740
testq %rax, %rax
js 0x3d4d
jmp 0x3d67
addq $-0x9, %rax
fmuls 0xb9dd(%rip)            # 0xf744
cmpq $0x8, %rax
ja 0x3d5d
jmp 0x3d78
decq %rax
fmuls 0xb9c8(%rip)            # 0xf740
testq %rax, %rax
jg 0x3d6f
fldt (%rbx)
fmulp %st, %st(1)
fstpt (%rbx)
popq %rbx
retq