LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2df2
testl %ecx, %ecx
jne 0x2e15
cmpl %edi, %esi
setge %cl
cmpl %edx, %esi
setge %r8b
movl $0x1, %eax
testb %r8b, %cl
jne 0x2e39
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 0x2e39
cmpl %edi, %esi
setge %al
cmpl %edx, %esi
setge %cl
andb %al, %cl
jmp 0x2e36
cmpl %edi, %edx
setge %cl
cmpl %esi, %edx
setge %r8b
movl $0x2, %eax
testb %r8b, %cl
jne 0x2e39
cmpl %esi, %edi
setl %al
cmpl %edx, %edi
setl %cl
orb %al, %cl
movzbl %cl, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x451b(%rip), %r14      # 0x7ac7
movq %r13, %rdi
movq %r14, %rsi
callq 0x21e0
movq %rax, %r15
movq %rax, %rdi
movq %r13, %rsi
movq %r14, %rdx
movl $0x1, %ecx
callq 0x2cfc
movq %r15, %rdi
movq %rbx, %rsi
movl $0x190, %edx            # imm = 0x190
callq 0x2c55
cmpl $-0x1, %eax
je 0x36a4
movq %r13, 0x18(%rsp)
leaq 0xa(%rsp), %r14
xorl %r13d, %r13d
subq $0x8, %rsp
movq %rbx, %rdi
leaq 0x4286(%rip), %rsi      # 0x7887
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 0x36ce
movl 0x14(%rsp), %edi
movl 0x10(%rsp), %esi
movl 0xc(%rsp), %edx
testl %ebp, %ebp
je 0x3657
callq 0x2d43
cvtss2sd %xmm0, %xmm0
jmp 0x3680
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 0x3993(%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 0x2c55
cmpl $-0x1, %eax
jne 0x35f3
jmp 0x36a7
xorl %r13d, %r13d
testq %r15, %r15
je 0x36b4
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_O3/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 0x4002
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 0x3ff2
movl %edx, %r10d
xorl %r11d, %r11d
leaq 0x7155(%rip), %rbx      # 0xb164
testl %edx, %edx
jle 0x403a
movb (%r11,%rbx), %bpl
xorl %r14d, %r14d
cmpb %bpl, (%rdi,%r14)
jne 0x4032
incl (%r8,%r11,4)
movb (%rdi,%r14), %r15b
cmpb (%rsi,%r14), %r15b
jne 0x4032
incl (%rcx,%r11,4)
incq %r14
cmpq %r14, %r10
jne 0x401a
incq %r11
cmpq $0x3, %r11
jne 0x400f
testl %eax, %eax
jle 0x4087
movl %eax, %edx
xorl %esi, %esi
movsd 0x2fb5(%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 0x4053
movslq %eax, %rdx
xorps %xmm0, %xmm0
cvtsi2sdl (%rcx,%rdx,4), %xmm0
movl (%r8,%rdx,4), %eax
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
addsd 0x2f63(%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_O3/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 0x63d8
movl %r8d, %ebp
movq %rcx, %r15
cltq
movq (%r14,%rax,8), %r12
movq %r12, %rdi
callq 0x2a3f
testb %al, %al
je 0x63d8
movq %r12, %rdi
callq 0x21f0
testb %bpl, %bpl
je 0x63c1
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
ja 0x63fe
ucomisd (%rsp), %xmm0
ja 0x63fe
movsd %xmm0, (%r15)
addl $0x2, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x4bf9(%rip), %rax      # 0xafd8
movq (%rax), %rdi
movslq %ebx, %rax
movq (%r14,%rax,8), %rdx
leaq 0x13a7(%rip), %rsi      # 0x7797
xorl %eax, %eax
callq 0x2240
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x63c9
movq 0x4bd3(%rip), %rax      # 0xafd8
movq (%rax), %rdi
movslq %ebx, %rax
movq (%r14,%rax,8), %rdx
leaq 0x1339(%rip), %rsi      # 0x774f
movsd 0x8(%rsp), %xmm0
movsd (%rsp), %xmm1
movb $0x2, %al
callq 0x2240
jmp 0x63f7
// File: /workspace/github_cpp_makefile_star2_O3/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
movl 0x8(%rdi), %eax
testl %eax, %eax
je 0x655d
xorl %r14d, %r14d
movq (%rbx), %rcx
movq (%rcx,%r14,8), %rdi
testq %rdi, %rdi
je 0x6553
callq 0x2220
movl 0x8(%rbx), %eax
incq %r14
movl %eax, %ecx
cmpq %rcx, %r14
jb 0x653f
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x656a
callq 0x2220
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1b72
xorl %edx, %edx
divl 0x18(%rbx)
movl %edx, %r14d
movq 0x20(%rbx), %rdi
addq $0x8, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x1b72
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 0x1b42
movl %ebp, %ecx
shrl $0x5, %ecx
movl (%rax,%rcx,4), %eax
movl %r14d, %esi
shrl $0x8, %esi
btl %ebp, %eax
jae 0x1b4d
movl $0xff, %r15d
andl %r15d, %r14d
movq 0x10(%rdi), %rax
movl (%rax,%rsi,4), %r12d
shll $0x3, %esi
movl %r14d, %edx
callq 0x1bc8
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 0x1bc8
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 0x1b64
movl %ebp, %esi
shrl $0x8, %esi
movzbl %bpl, %edx
jmp 0x1b51
movzbl %r14b, %edx
movq 0x10(%rdi), %rax
movl (%rax,%rsi,4), %ebx
shll $0x3, %esi
callq 0x1bc8
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_O3/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:
movl %edx, %ecx
xorl %edx, %edx
movq 0x8(%rdi), %rax
cmpl $0x20, %ecx
jb 0x1c4b
leal -0x20(%rcx), %edi
shrl $0x5, %edi
addl %esi, %edi
xorl %edx, %edx
movl $0x55555555, %r8d       # imm = 0x55555555
movl $0x33333333, %r9d       # imm = 0x33333333
movl %esi, %r10d
movl (%rax,%r10,4), %r10d
movl %r10d, %r11d
shrl %r11d
andl %r8d, %r11d
andl %r8d, %r10d
addl %r11d, %r10d
movl %r10d, %r11d
shrl $0x2, %r11d
andl %r9d, %r11d
andl %r9d, %r10d
addl %r11d, %r10d
movl %r10d, %r11d
shrl $0x4, %r11d
addl %r10d, %r11d
andl $0xf0f0f0f, %r11d       # imm = 0xF0F0F0F
movl %r11d, %r10d
shrl $0x8, %r10d
addl %r11d, %r10d
movl %r10d, %r11d
shrl $0x10, %r11d
addl %r10d, %r11d
movzbl %r11b, %r10d
addl %r10d, %edx
incl %esi
addl $-0x20, %ecx
cmpl $0x1f, %ecx
ja 0x1beb
incl %edi
movl %edi, %esi
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
retq
// File: /workspace/github_cpp_makefile_star2_O3/joncampbell123[P]haxcc/haxpp.cpp
// Function: token::operator==(token const&) const
bool token::operator==(const token &t) const {
    if (tval != t.tval) return false;
    if (bsize != t.bsize) return false;
    if (i != t.i) return false;
    if (f != t.f) return false;
    if (s != t.s) return false;
    if (sval != t.sval) return false;
    return true;
}

// Assembly:
pushq %rbx
movl (%rdi), %eax
cmpl (%rsi), %eax
jne 0x2aad
movb 0x4(%rdi), %al
cmpb 0x4(%rsi), %al
jne 0x2aad
movq 0x8(%rdi), %rax
xorl %ebx, %ebx
cmpq 0x8(%rsi), %rax
jne 0x2aaf
movb 0x10(%rsi), %al
cmpb %al, 0x10(%rdi)
jne 0x2aaf
fldt 0x20(%rdi)
fldt 0x20(%rsi)
xorl %ebx, %ebx
fxch %st(1)
fucompi %st(1), %st
fstp %st(0)
jne 0x2aaf
jp 0x2aaf
movl 0x30(%rsi), %eax
cmpl %eax, 0x30(%rdi)
jne 0x2aaf
movq 0x40(%rdi), %rax
cmpq 0x40(%rsi), %rax
jne 0x2aad
movq 0x50(%rdi), %rdx
cmpq 0x50(%rsi), %rdx
jne 0x2aad
movb $0x1, %bl
testq %rdx, %rdx
je 0x2aaf
movq 0x48(%rsi), %rsi
movq 0x48(%rdi), %rdi
callq 0x21e0
testl %eax, %eax
je 0x2aaf
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2cb5
cmpb $0x1, 0x8(%rbx)
jne 0x2cb5
callq 0x21b0
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
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2cfa
cmpb $0x1, 0x8(%rbx)
jne 0x2cf3
callq 0x21b0
movq $0x0, (%rbx)
movb $0x0, 0x8(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2d4b
retq
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
leaq 0x10a06(%rip), %rsi     # 0x13760
callq 0x2230
movq %rax, (%rbx)
testq %rax, %rax
je 0x2d6b
movb $0x1, 0x8(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2dc7
movq %rdi, %r14
movq (%r14), %rdi
callq 0x22e0
cmpl $0xd, %eax
je 0x2da5
movl %eax, %ebx
cmpl $0xa, %eax
jne 0x2dce
incl 0x30(%r14)
movl $0x1, 0x34(%r14)
jmp 0x2dd2
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x2dde
incl 0x34(%r14)
movq (%r14), %rdi
callq 0x2390
testl %eax, %eax
jne 0x2de8
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x20e0
movq %rax, %rbx
leaq 0x10967(%rip), %rsi     # 0x13763
movq %rax, %rdi
callq 0x20b0
movq 0x171ed(%rip), %rsi     # 0x19ff8
movq 0x1719e(%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_O3/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 0x2e88
cmpb $0x1, 0x8(%rbx)
jne 0x2e81
callq 0x21b0
movq $0x0, (%rbx)
movb $0x0, 0x8(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2ed5
retq
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
leaq 0x10897(%rip), %rsi     # 0x1377b
callq 0x2230
movq %rax, (%rbx)
testq %rax, %rax
je 0x2ef5
movb $0x1, 0x8(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2f30
movq %rdi, %rbx
movsbl %al, %edi
callq 0x2260
cmpl $-0x1, %eax
jne 0x2f30
movq (%rbx), %rdi
callq 0x2390
testl %eax, %eax
jne 0x2f38
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x20e0
movq %rax, %rbx
leaq 0x10832(%rip), %rsi     # 0x1377e
movq %rax, %rdi
callq 0x20b0
movq 0x1709d(%rip), %rsi     # 0x19ff8
movq 0x1704e(%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_O3/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 0x2fa9
movq %rdi, %rbx
movq %rsi, %rdi
movq %rax, %rsi
callq 0x2200
cmpl $-0x1, %eax
jne 0x2fa9
movq (%rbx), %rdi
callq 0x2390
testl %eax, %eax
jne 0x2fb1
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x20e0
movq %rax, %rbx
leaq 0x107b9(%rip), %rsi     # 0x1377e
movq %rax, %rdi
callq 0x20b0
movq 0x17024(%rip), %rsi     # 0x19ff8
movq 0x16fd5(%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_O3/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 0x302e
cmpb $0x1, (%rdi)
jne 0x301f
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 0x10754(%rip), %rsi     # 0x13796
movq %rax, %rdi
callq 0x23a0
movq 0x16f87(%rip), %rsi     # 0x19fd8
movq 0x16f68(%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_O3/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 0x30a8
movb (%rdi), %al
cmpb $0x1, %al
jne 0x3096
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 0x106f1(%rip), %rsi     # 0x137ad
movq %rax, %rdi
callq 0x23a0
movq 0x16f0d(%rip), %rsi     # 0x19fd8
movq 0x16eee(%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_O3/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 0x2d98
cmpl $0x2a, %eax
je 0x33be
cmpl $0x2f, %eax
je 0x33a7
cmpl $-0x1, %eax
jne 0x338e
jmp 0x33cb
movq %rbx, %rdi
callq 0x2d98
cmpl $0x2a, %eax
jne 0x338e
movq %rbx, %rdi
callq 0x336f
jmp 0x338e
movq %rbx, %rdi
callq 0x2d98
cmpl $0x2f, %eax
jne 0x338e
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x33e2
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 0x3404
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21d0
movq %rbx, %rdi
callq 0x2360
// File: /workspace/github_cpp_makefile_star2_O3/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 0x11210(%rip), %rsi     # 0x14645
callq 0x2080
testl %eax, %eax
je 0x3554
leaq 0x1037d(%rip), %rsi     # 0x137c6
movq %rbx, %rdi
callq 0x2080
testl %eax, %eax
je 0x355b
leaq 0x1036b(%rip), %rsi     # 0x137cb
movq %rbx, %rdi
callq 0x2080
testl %eax, %eax
je 0x3562
leaq 0x111cb(%rip), %rsi     # 0x14642
movq %rbx, %rdi
callq 0x2080
testl %eax, %eax
je 0x3569
leaq 0x10342(%rip), %rsi     # 0x137d0
movq %rbx, %rdi
callq 0x2080
testl %eax, %eax
je 0x3570
leaq 0x10333(%rip), %rsi     # 0x137d8
movq %rbx, %rdi
callq 0x2080
testl %eax, %eax
je 0x3577
leaq 0x10322(%rip), %rsi     # 0x137de
movq %rbx, %rdi
callq 0x2080
testl %eax, %eax
je 0x357e
leaq 0x10312(%rip), %rsi     # 0x137e5
movq %rbx, %rdi
callq 0x2080
testl %eax, %eax
je 0x3585
leaq 0x10302(%rip), %rsi     # 0x137ec
movq %rbx, %rdi
callq 0x2080
testl %eax, %eax
je 0x358c
leaq 0x102f1(%rip), %rsi     # 0x137f2
movq %rbx, %rdi
callq 0x2080
testl %eax, %eax
je 0x3593
leaq 0x1068c(%rip), %rsi     # 0x13ba4
movq %rbx, %rdi
callq 0x2080
testl %eax, %eax
je 0x359a
leaq 0x102cf(%rip), %rsi     # 0x137fa
movq %rbx, %rdi
callq 0x2080
testl %eax, %eax
je 0x35a1
leaq 0x102c2(%rip), %rsi     # 0x13800
movq %rbx, %rdi
callq 0x2080
xorl %ecx, %ecx
testl %eax, %eax
movl $0x31, %eax
cmovnel %ecx, %eax
jmp 0x35a6
movl $0x60, %eax
jmp 0x35a6
movl $0x5a, %eax
jmp 0x35a6
movl $0x61, %eax
jmp 0x35a6
movl $0x62, %eax
jmp 0x35a6
movl $0x63, %eax
jmp 0x35a6
movl $0x64, %eax
jmp 0x35a6
movl $0x65, %eax
jmp 0x35a6
movl $0x66, %eax
jmp 0x35a6
movl $0x67, %eax
jmp 0x35a6
movl $0x68, %eax
jmp 0x35a6
movl $0x69, %eax
jmp 0x35a6
movl $0x6a, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3ca8
xorl %r8d, %r8d
xorl %eax, %eax
movb (%r9,%r8), %r10b
andb $-0x8, %r10b
cmpb $0x30, %r10b
jne 0x3cad
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 0x3cad
cmpl %ecx, %r8d
jb 0x3c71
jmp 0x3cad
xorl %r8d, %r8d
xorl %eax, %eax
cmpl %edx, %r8d
jb 0x3cba
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x20e0
movq %rax, %rbx
leaq 0xfc7b(%rip), %rsi      # 0x13949
movq %rax, %rdi
callq 0x23a0
movq 0x162fb(%rip), %rsi     # 0x19fd8
movq 0x162dc(%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_O3/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 0x3d99
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 0x3d4d
movzbl %bl, %ebx
addl $-0x41, %ebx
cmpl $0x25, %ebx
ja 0x3d9e
btq %rbx, %r11
jae 0x3d9e
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 0x3d6f
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 0x3d9e
cmpl %ecx, %r8d
jb 0x3d2f
jmp 0x3d9e
xorl %r8d, %r8d
xorl %eax, %eax
cmpl %edx, %r8d
jb 0x3dae
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x20e0
movq %rax, %rbx
leaq 0xfba6(%rip), %rsi      # 0x13968
movq %rax, %rdi
callq 0x23a0
movq 0x16207(%rip), %rsi     # 0x19fd8
movq 0x161e8(%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_O3/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 0x41c6
movl $0xc9, %ecx
movabsq $0x3f0000003f, %rdx     # imm = 0x3F0000003F
movb (%r8), %r9b
leal -0x30(%r9), %r10d
cmpb $0xa, %r10b
jb 0x4184
movzbl %r9b, %r9d
addl $-0x41, %r9d
cmpl $0x25, %r9d
ja 0x41c6
btq %r9, %rdx
jae 0x41c6
leaq 0x1(%r8), %r9
movq %r9, (%rdi)
movb (%r8), %r8b
leal -0x61(%r8), %r11d
movl $0xa9, %r10d
cmpb $0x6, %r11b
jb 0x41a4
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 0x4163
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4244
movsbl (%rcx), %edx
addl $-0x30, %edx
cmpl $0x9, %edx
ja 0x4244
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 0x421a
retq
// File: /workspace/github_cpp_makefile_star2_O3/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), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq (%rsi), %r13
cmpq %rdx, %r13
je 0x5022
movq %rdx, %r14
movq %rsi, %r15
movsbl (%r13), %ebp
movl %ebp, %edi
callq 0x2300
cmpl $0x5f, %ebp
je 0x4fd3
testl %eax, %eax
je 0x5040
leaq 0x1(%r13), %rax
movq %rax, (%r15)
movsbl (%r13), %esi
movq %rbx, %rdi
callq 0x2190
movq (%r15), %r13
cmpq %r14, %r13
je 0x5010
movsbl (%r13), %r12d
leal -0x30(%r12), %eax
cmpl $0xa, %eax
jb 0x4fd3
movl %r12d, %edi
callq 0x2300
cmpb $0x5f, %r12b
je 0x4fd3
testl %eax, %eax
jne 0x4fd3
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 0xeb89(%rip), %rsi      # 0x13bbf
movq %rax, %rdi
callq 0x23a0
jmp 0x505c
movl $0x10, %edi
callq 0x20e0
movq %rax, %r14
leaq 0xeb90(%rip), %rsi      # 0x13be4
movq %rax, %rdi
callq 0x23a0
movq 0x14f75(%rip), %rsi     # 0x19fd8
movq 0x14f56(%rip), %rdx     # 0x19fc0
movq %r14, %rdi
callq 0x2330
jmp 0x5074
movq %rax, %r15
movq %r14, %rdi
callq 0x2160
jmp 0x5086
jmp 0x5083
movq %rax, %r15
movq (%rbx), %rdi
cmpq (%rsp), %rdi
je 0x509e
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x21d0
movq %r15, %rdi
callq 0x2360
// File: /workspace/github_cpp_makefile_star2_O3/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 0x67e2
movq 0x137d9(%rip), %rax     # 0x19fb8
movq (%rax), %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x50ff
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x2200
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x6814
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21d0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/joncampbell123[P]haxcc/haxpp.cpp
// Function: do_macro_expand_read_invoke_param(__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)
string do_macro_expand_read_invoke_param(string::iterator &li,const string::iterator lie,bool final_variadic=false) {
    int paren = 0;
    string r;

    do {
        if (li == lie)
            throw invalid_argument("string terminated unexpectedly");
        if (*li == '(') {
            paren++;
        }
        else if (*li == ')') {
            if (paren > 0)
                paren--;
            else
                break;
        }
        else if (*li == ',' && !final_variadic) {
            break;
        }

        r += *(li++);
    } while (1);

    return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
xorl %r13d, %r13d
xorb $0x1, %bpl
movq (%r15), %rax
cmpq %r14, %rax
je 0x68a1
movzbl (%rax), %ecx
cmpl $0x29, %ecx
je 0x6866
cmpl $0x28, %ecx
jne 0x6870
incl %r13d
jmp 0x687b
testl %r13d, %r13d
jle 0x688f
decl %r13d
jmp 0x687b
cmpb $0x2c, %cl
sete %cl
testb %bpl, %cl
jne 0x688f
leaq 0x1(%rax), %rcx
movq %rcx, (%r15)
movsbl (%rax), %esi
movq %rbx, %rdi
callq 0x2190
jmp 0x684c
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, %r15
leaq 0xd665(%rip), %rsi      # 0x13f1a
movq %rax, %rdi
callq 0x23a0
movq 0x13714(%rip), %rsi     # 0x19fd8
movq 0x136f5(%rip), %rdx     # 0x19fc0
movq %r15, %rdi
callq 0x2330
jmp 0x68e2
movq %rax, %r14
movq %r15, %rdi
callq 0x2160
jmp 0x68e5
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x68f9
movq (%r12), %rsi
incq %rsi
callq 0x21d0
movq %r14, %rdi
callq 0x2360
// File: /workspace/github_cpp_makefile_star2_O3/joncampbell123[P]haxcc/haxpp.cpp
// Function: pp_stringify(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string pp_stringify(const string &s) {
    string r;

    r += '\"';
    for (auto si=s.begin();si!=s.end();si++) {
        if (*si == '\'' || *si == '\"' || *si == '\\') r += '\\';
        r += *si;
    }
    r += '\"';

    return r;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movl $0x22, %esi
callq 0x2190
cmpq $0x0, 0x8(%r14)
je 0x6981
movq (%r14), %r12
movabsq $0x400000000000021, %r13 # imm = 0x400000000000021
movzbl (%r12), %eax
movl %eax, %ecx
addl $-0x22, %ecx
cmpl $0x3a, %ecx
ja 0x6967
btq %rcx, %r13
jae 0x6967
movq %rbx, %rdi
movl $0x5c, %esi
callq 0x2190
movb (%r12), %al
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2190
incq %r12
movq (%r14), %rax
addq 0x8(%r14), %rax
cmpq %rax, %r12
jne 0x6941
movq %rbx, %rdi
movl $0x22, %esi
callq 0x2190
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x699d
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x69b3
movq (%r15), %rsi
incq %rsi
callq 0x21d0
movq %r14, %rdi
callq 0x2360
// File: /workspace/github_cpp_makefile_star2_O3/joncampbell123[P]haxcc/haxpp.cpp
// Function: expression::newnode(token const&)
expression::node::node_t expression::newnode(const token &nt) {
    const node::node_t r = nodelist.size();
    nodelist.resize(r+size_t(1));
    nodelist[r].tval = nt;
    return r;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r12
subq (%rdi), %r12
movq %r12, %rax
sarq $0x4, %rax
movabsq $-0x71c71c71c71c71c7, %r15 # imm = 0x8E38E38E38E38E39
imulq %rax, %r15
leaq 0x1(%r15), %rsi
callq 0xf106
movq (%r14), %rax
leaq (%rax,%r12), %rdi
movl $0x9, %ecx
movq %rbx, %rsi
rep  movsq (%rsi), %es:(%rdi)
leaq (%rax,%r12), %rdi
addq $0x48, %rdi
addq $0x48, %rbx
movq %rbx, %rsi
callq 0x2100
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/joncampbell123[P]haxcc/haxpp.cpp
// Function: match_token_list(token::token_t&, token const&, tokenlist_entry const*)
bool match_token_list(token::token_t &repl,const token &t,const tokenlist_entry *tokens) {
    while (tokens->match != token::NONE) {
        if (t.tval == tokens->match) {
            repl = tokens->replace;
            return true;
        }

        tokens++;
    }

    return false;
}

// Assembly:
movl (%rdx), %ecx
testl %ecx, %ecx
je 0xaeb9
movl (%rsi), %eax
addq $0x8, %rdx
cmpl %ecx, %eax
je 0xaebc
movl (%rdx), %ecx
addq $0x8, %rdx
testl %ecx, %ecx
jne 0xaeab
xorl %eax, %eax
retq
movl -0x4(%rdx), %eax
movl %eax, (%rdi)
movb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O3/joncampbell123[P]haxcc/haxpp.cpp
// Function: parse_expr_ltr_unary(expression&, __gnu_cxx::__normal_iterator<token*, std::vector<token, std::allocator<token>>>&, __gnu_cxx::__normal_iterator<token*, std::vector<token, std::allocator<token>>> const&, unsigned int, tokenlist_entry const*, unsigned long)
expression::node::node_t parse_expr_ltr_unary(expression &expr,token_string::iterator &ti,const token_string::iterator &tie,unsigned int min_prec,const tokenlist_entry *match_token,expression::node::node_t headnode) {
    token::token_t repl;
    unsigned int prec;

    while (ti != tie && match_token_list(/*&*/repl,*ti,match_token) && (prec=token::precedence(*ti,false)) <= min_prec) {
        const expression::node::node_t opnode = expr.newnode(*(ti++),repl);

        expr.getnode(opnode).children.resize(1);
        expr.getnode(opnode).children[0] = headnode;
        headnode = opnode;
    }

    return headnode;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %r15
movl %ecx, 0xc(%rsp)
movq %rsi, 0x10(%rsp)
movq (%rsi), %rbp
cmpq (%rdx), %rbp
je 0xb800
movq %rdx, %r14
movq %rdi, %r13
leaq 0x8(%r8), %rsi
movabsq $-0x71c71c71c71c71c7, %r12 # imm = 0x8E38E38E38E38E39
movl (%r8), %ecx
testl %ecx, %ecx
je 0xb800
movl (%rbp), %eax
movq %rsi, %rbx
cmpl %ecx, %eax
je 0xb753
movl (%rbx), %ecx
addq $0x8, %rbx
testl %ecx, %ecx
jne 0xb740
jmp 0xb800
movq %rsi, 0x20(%rsp)
movq %r8, 0x18(%rsp)
movq %rbp, %rdi
xorl %esi, %esi
callq 0x291e
cmpl 0xc(%rsp), %eax
ja 0xb800
movl -0x4(%rbx), %edx
leaq 0x70(%rbp), %rax
movq 0x10(%rsp), %rcx
movq %rax, (%rcx)
movq %r13, %rdi
movq %rbp, %rsi
callq 0xae2e
movq %rax, %rbx
movq (%r13), %rax
movq 0x8(%r13), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
imulq %r12, %rcx
cmpq %rcx, %rbx
jae 0xb815
leaq (%rbx,%rbx,8), %rbp
shlq $0x4, %rbp
leaq (%rax,%rbp), %rdi
addq $0x70, %rdi
movl $0x1, %esi
callq 0xf148
movq (%r13), %rax
movq 0x8(%r13), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
imulq %r12, %rcx
cmpq %rcx, %rbx
jae 0xb833
movq 0x70(%rax,%rbp), %rax
movq %r15, (%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rbp
movq %rbx, %r15
cmpq (%r14), %rbp
movq 0x18(%rsp), %r8
movq 0x20(%rsp), %rsi
jne 0xb72f
jmp 0xb803
movq %r15, %rbx
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x20e0
movq %rax, %rbx
leaq 0x8f1e(%rip), %rsi      # 0x14747
movq %rax, %rdi
callq 0x20b0
jmp 0xb84f
movl $0x10, %edi
callq 0x20e0
movq %rax, %rbx
leaq 0x8f00(%rip), %rsi      # 0x14747
movq %rax, %rdi
callq 0x20b0
movq 0xe7a2(%rip), %rsi      # 0x19ff8
movq 0xe753(%rip), %rdx      # 0x19fb0
movq %rbx, %rdi
callq 0x2330
jmp 0xb867
movq %rax, %r14
movq %rbx, %rdi
callq 0x2160
movq %r14, %rdi
callq 0x2360
// File: /workspace/github_cpp_makefile_star2_O3/joncampbell123[P]haxcc/haxpp.cpp
// Function: dump_expr_node(_IO_FILE*, expression const&, unsigned long, unsigned int)
void dump_expr_node(FILE *fp,const expression &expr,const expression::node::node_t node,unsigned int depth) {
    if (fp == NULL)
        fp = stderr;

    for (unsigned int c=0;c < depth;c++)
        fprintf(fp,"| ");

    fprintf(fp,"node[%zu]: %s\n",node,to_string(expr.getnode(node).tval).c_str());
    for (size_t i=0;i < expr.getnode(node).children.size();i++)
        dump_expr_node(fp,expr,expr.getnode(node).children[i],depth+1u);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
testq %rdi, %rdi
jne 0xc32b
movq 0xdc90(%rip), %rax      # 0x19fb8
movq (%rax), %r12
testl %ebx, %ebx
je 0xc351
leaq 0x7a79(%rip), %r13      # 0x13daf
movl %ebx, %ebp
movl $0x2, %esi
movl $0x1, %edx
movq %r13, %rdi
movq %r12, %rcx
callq 0x23c0
decl %ebp
jne 0xc338
movq (%r15), %rsi
movq 0x8(%r15), %rax
subq %rsi, %rax
sarq $0x4, %rax
movabsq $-0x71c71c71c71c71c7, %rcx # imm = 0x8E38E38E38E38E39
imulq %rcx, %rax
cmpq %r14, %rax
jbe 0xc472
leaq (%r14,%r14,8), %r13
shlq $0x4, %r13
addq %r13, %rsi
leaq 0x8(%rsp), %rbp
movq %rbp, %rdi
callq 0x50ff
movq (%rbp), %rcx
leaq 0x7eec(%rip), %rsi      # 0x14285
movq %r12, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x2280
movq (%rbp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xc3c1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21d0
movq (%r15), %rax
movq 0x8(%r15), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
movabsq $-0x71c71c71c71c71c7, %rdx # imm = 0x8E38E38E38E38E39
imulq %rdx, %rcx
cmpq %r14, %rcx
jbe 0xc431
incl %ebx
xorl %ebp, %ebp
movq 0x70(%rax,%r13), %rcx
movq 0x78(%rax,%r13), %rax
subq %rcx, %rax
sarq $0x3, %rax
cmpq %rax, %rbp
jae 0xc463
movq (%rcx,%rbp,8), %rdx
movq %r12, %rdi
movq %r15, %rsi
movl %ebx, %ecx
callq 0xc303
incq %rbp
movq (%r15), %rax
movq 0x8(%r15), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
movabsq $-0x71c71c71c71c71c7, %rdx # imm = 0x8E38E38E38E38E39
imulq %rdx, %rcx
cmpq %r14, %rcx
ja 0xc3e6
movl $0x10, %edi
callq 0x20e0
movq %rax, %rbx
leaq 0x8302(%rip), %rsi      # 0x14747
movq %rax, %rdi
callq 0x20b0
movq 0xdba4(%rip), %rsi      # 0x19ff8
movq 0xdb55(%rip), %rdx      # 0x19fb0
movq %rbx, %rdi
callq 0x2330
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x20e0
movq %rax, %rbx
leaq 0x82c1(%rip), %rsi      # 0x14747
movq %rax, %rdi
callq 0x20b0
jmp 0xc44d
jmp 0xc492
movq %rax, %r14
movq %rbx, %rdi
callq 0x2160
movq %r14, %rdi
callq 0x2360
// File: /workspace/github_cpp_makefile_star2_O3/joncampbell123[P]haxcc/haxpp.cpp
// Function: dump_expr(_IO_FILE*, expression const&)
void dump_expr(FILE *fp,const expression &expr) {
    if (fp == NULL)
        fp = stderr;

    fprintf(fp,"expression:\n");
    if (expr.root != expression::node::none)
        dump_expr_node(fp,expr,expr.root,1);
    fprintf(fp,"END\n");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testq %rdi, %rdi
jne 0xc4be
movq 0xdafd(%rip), %rax      # 0x19fb8
movq (%rax), %rbx
leaq 0x7dcf(%rip), %rdi      # 0x14294
movl $0xc, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x23c0
movq 0x18(%r14), %rdx
cmpq $-0x1, %rdx
je 0xc4f1
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %ecx
callq 0xc303
leaq 0x7da9(%rip), %rdi      # 0x142a1
movl $0x4, %esi
movl $0x1, %edx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x23c0
// File: /workspace/github_cpp_makefile_star2_O3/joncampbell123[P]haxcc/haxpp.cpp
// Function: FileSourceStack::pop()
void pop() {
        if (stkpos >= 0) {
            src[stkpos].close();
            stkpos--;
        }
        else {
            throw underflow_error("FileSourceStack stack underflow");
        }
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x18(%rdi), %rax
testq %rax, %rax
js 0xf3c7
movq %rdi, %rbx
movq (%rdi), %rcx
imulq $0x38, %rax, %rdx
leaq (%rcx,%rdx), %r14
movq (%rcx,%rdx), %rdi
testq %rdi, %rdi
je 0xf3b3
cmpb $0x1, 0x8(%r14)
jne 0xf3ac
callq 0x21b0
movq 0x18(%rbx), %rax
movq $0x0, (%r14)
movb $0x0, 0x8(%r14)
decq %rax
movq %rax, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x20e0
movq %rax, %rbx
leaq 0x5458(%rip), %rsi      # 0x14833
movq %rax, %rdi
callq 0x23d0
movq 0xabbe(%rip), %rsi      # 0x19fa8
movq 0xabff(%rip), %rdx      # 0x19ff0
movq %rbx, %rdi
callq 0x2330
movq %rax, %r14
movq %rbx, %rdi
callq 0x2160
movq %r14, %rdi
callq 0x2360
// File: /workspace/github_cpp_makefile_star2_O3/ashlall[P]StreamStats/Test/./../SourceCode/BasicStats/BasicStats.cpp
// Function: BasicStats::insert(double)
void BasicStats::insert(double num)
{
  stream_size++; 
  sum = sum + num;
  squaredsum += num * num;
  min = if_MIN(num);
  max = if_MAX(num);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x20(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x20(%rdi)
movsd (%rdi), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rdi)
movapd %xmm0, %xmm1
mulsd %xmm0, %xmm1
addsd 0x8(%rdi), %xmm1
movsd %xmm1, 0x8(%rdi)
movapd %xmm0, %xmm2
testq %rax, %rax
je 0x12b7
minsd 0x10(%rdi), %xmm2
movsd 0x18(%rdi), %xmm1
jmp 0x12bb
movapd %xmm0, %xmm1
movsd %xmm2, 0x10(%rdi)
movapd %xmm1, %xmm2
cmplesd %xmm0, %xmm2
andpd %xmm2, %xmm0
andnpd %xmm1, %xmm2
orpd %xmm0, %xmm2
movlpd %xmm2, 0x18(%rdi)
popq %rbp
retq