LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/thegenemyers[P]DASCRUBBER/align.c
// Function: Check_Trace_Points
int Check_Trace_Points(Overlap *ovl, int tspace, int verbose, char *fname)
{ int i, p, q; 

  if (tspace != 0)
    { if (((ovl->path.aepos-1)/tspace - ovl->path.abpos/tspace)*2 != ovl->path.tlen-2)
        { if (verbose) 
            EPRINTF(EPLACE,"  %s: Wrong number of trace points\n",fname);
          return (1);
        }         
      p = ovl->path.bbpos;
      if (tspace <= TRACE_XOVR)
        { uint8 *trace8 = (uint8 *) ovl->path.trace;
          for (i = 1; i < ovl->path.tlen; i += 2)
            p += trace8[i];
        }
      else      
        { uint16 *trace16 = (uint16 *) ovl->path.trace;
          for (i = 1; i < ovl->path.tlen; i += 2)
            p += trace16[i];
        }
      if (p != ovl->path.bepos)
        { if (verbose)
            EPRINTF(EPLACE,"  %s: Trace point sum != aligned interval\n",fname);
          return (1); 
        }         
    }
  else
    { uint16 *trace16 = (uint16 *) ovl->path.trace;

      p = ovl->path.bbpos;
      q = ovl->path.abpos;
      for (i = 1; i < ovl->path.tlen; i += 2)
        { p += trace16[i];
          q += trace16[i-1];
        }
      if (p != ovl->path.bepos || q != ovl->path.aepos)
        { if (verbose)
            EPRINTF(EPLACE,"  %s: Trace point sum != aligned interval\n",fname);
          return (1); 
        }         
    }
  return (0);
}

// Assembly:
pushq %rbx
movl %edx, %r8d
pushq $0x1
popq %rbx
testl %esi, %esi
je 0x8750
movl 0x10(%rdi), %r9d
movl 0x18(%rdi), %eax
decl %eax
cltd
idivl %esi
movl %eax, %r10d
movl %r9d, %eax
cltd
idivl %esi
subl %eax, %r10d
addl %r10d, %r10d
movslq 0x8(%rdi), %rdx
leal -0x2(%rdx), %eax
cmpl %eax, %r10d
jne 0x8795
movl 0x14(%rdi), %eax
movq (%rdi), %r9
cmpl $0x7e, %esi
jge 0x87b7
pushq $0x1
popq %rsi
cmpq %rdx, %rsi
jge 0x87cd
movzbl (%r9,%rsi), %r10d
addl %r10d, %eax
addq $0x2, %rsi
jmp 0x8739
movq (%rdi), %rsi
movl 0x14(%rdi), %edx
movl 0x10(%rdi), %eax
movslq 0x8(%rdi), %r9
pushq $0x1
popq %r10
cmpq %r9, %r10
jge 0x877d
movzwl (%rsi,%r10,2), %r11d
addl %r11d, %edx
movzwl -0x2(%rsi,%r10,2), %r11d
addl %r11d, %eax
addq $0x2, %r10
jmp 0x8761
cmpl 0x1c(%rdi), %edx
jne 0x8787
cmpl 0x18(%rdi), %eax
je 0x87d2
testl %r8d, %r8d
je 0x87d4
leaq 0xfe1b(%rip), %rsi      # 0x185ae
jmp 0x87a1
testl %r8d, %r8d
je 0x87d4
leaq 0xfde9(%rip), %rsi      # 0x1858a
movq 0x15850(%rip), %rax     # 0x1dff8
movq (%rax), %rdi
movq %rcx, %rdx
xorl %eax, %eax
callq 0x11a0
jmp 0x87d4
pushq $0x1
popq %rsi
cmpq %rdx, %rsi
jge 0x87cd
movzwl (%r9,%rsi,2), %r10d
addl %r10d, %eax
addq $0x2, %rsi
jmp 0x87ba
cmpl 0x1c(%rdi), %eax
jne 0x8787
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/thegenemyers[P]DASCRUBBER/align.c
// Function: Flip_Alignment
void Flip_Alignment(Alignment *align, int full)
{ char *aseq  = align->aseq;
  char *bseq  = align->bseq;
  int   alen  = align->alen;
  int   blen  = align->blen;
  Path *path  = align->path;
  int   comp  = COMP(align->flags);

  int  *trace = (int *) path->trace;
  int   tlen  = path->tlen;

  int   i, j, p;

  if (comp)
    { p = path->abpos;
      path->abpos = blen - path->bepos;
      path->bepos = alen - p;
      p = path->aepos;
      path->aepos = blen - path->bbpos;
      path->bbpos = alen - p;

      if (full)
        { alen += 2;
          blen += 2;

          for (i = 0; i < tlen; i++)
            if ((p = trace[i]) < 0)
              trace[i] = alen + p;
            else
              trace[i] = p - blen;

          i = tlen-1;
          j = 0;
          while (j < i)
            { p = trace[i];
              trace[i] = trace[j];
              trace[j] = p;
              i -= 1;
              j += 1;
            }

          alen -= 2;
          blen -= 2;
        }
    }
  else
    { p = path->abpos;
      path->abpos = path->bbpos;
      path->bbpos = p;
      p = path->aepos;
      path->aepos = path->bepos;
      path->bepos = p;

      if (full)
        for (i = 0; i < tlen; i++)
          trace[i] = - (trace[i]);
    }

  align->aseq  = bseq;
  align->bseq  = aseq;
  align->alen  = blen;
  align->blen  = alen;
}

// Assembly:
pushq %rbp
pushq %rbx
movdqu 0x10(%rdi), %xmm0
movl 0x20(%rdi), %eax
movl 0x24(%rdi), %ecx
movq (%rdi), %r9
movq (%r9), %rdx
movslq 0x8(%r9), %r8
testb $0x1, 0x8(%rdi)
movl 0x10(%r9), %r10d
jne 0x8838
movl 0x14(%r9), %r11d
movl %r11d, 0x10(%r9)
movl %r10d, 0x14(%r9)
movq 0x18(%r9), %xmm1
pshufd $0xe1, %xmm1, %xmm1     # xmm1 = xmm1[1,0,2,3]
movq %xmm1, 0x18(%r9)
testl %esi, %esi
je 0x88c1
xorl %esi, %esi
testl %r8d, %r8d
cmovlel %esi, %r8d
cmpq %rsi, %r8
je 0x88c1
negl (%rdx,%rsi,4)
incq %rsi
jmp 0x8827
movl %ecx, %r11d
subl 0x1c(%r9), %r11d
movl %r11d, 0x10(%r9)
movl %eax, %r11d
subl %r10d, %r11d
movl %r11d, 0x1c(%r9)
movl %ecx, %r10d
subl 0x14(%r9), %r10d
movl %eax, %r11d
subl 0x18(%r9), %r11d
movl %r10d, 0x18(%r9)
movl %r11d, 0x14(%r9)
testl %esi, %esi
je 0x88c1
leal 0x2(%rax), %esi
movl $0xfffffffe, %r9d       # imm = 0xFFFFFFFE
subl %ecx, %r9d
xorl %r10d, %r10d
testl %r8d, %r8d
movl $0x0, %r11d
cmovgl %r8d, %r11d
cmpq %r10, %r11
je 0x889f
movl (%rdx,%r10,4), %ebx
testl %ebx, %ebx
movl %r9d, %ebp
cmovsl %esi, %ebp
addl %ebx, %ebp
movl %ebp, (%rdx,%r10,4)
incq %r10
jmp 0x8883
decq %r8
xorl %esi, %esi
cmpq %r8, %rsi
jge 0x88c1
movl (%rdx,%r8,4), %r9d
movl (%rdx,%rsi,4), %r10d
movl %r10d, (%rdx,%r8,4)
movl %r9d, (%rdx,%rsi,4)
incq %rsi
decq %r8
jmp 0x88a4
pshufd $0x4e, %xmm0, %xmm0     # xmm0 = xmm0[2,3,0,1]
movdqu %xmm0, 0x10(%rdi)
movl %ecx, 0x20(%rdi)
movl %eax, 0x24(%rdi)
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/thegenemyers[P]DASCRUBBER/align.c
// Function: Complement_Seq
void Complement_Seq(char *aseq, int len)
{ char *s, *t;
  int   c;

  s = aseq;
  t = aseq + (len-1);
  while (s < t)
    { c    = 3 - *s;
      *s++ = (char) (3 - *t);
      *t-- = (char) c;
    }
  if (s == t)
    *s = (char) (3 - *s);
}

// Assembly:
movslq %esi, %rax
addq %rdi, %rax
decq %rax
cmpq %rax, %rdi
jae 0x88f6
movb $0x3, %cl
subb (%rdi), %cl
movb $0x3, %dl
subb (%rax), %dl
movb %dl, (%rdi)
incq %rdi
movb %cl, (%rax)
decq %rax
jmp 0x88dd
je 0x88f9
retq
movb $0x3, %al
subb (%rdi), %al
movb %al, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/thegenemyers[P]DASCRUBBER/align.c
// Function: enlarge_trace
static int enlarge_trace(_Work_Data *work, int newmax)
{ void *vec;
  int   max;

  max = ((int) (newmax*1.2)) + 10000;
  vec = Realloc(work->trace,max,"Enlarging trace vector");
  if (vec == NULL)
    EXIT(1);
  work->tramax = max;
  work->trace  = vec;
  return (0);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
cvtsi2sd %esi, %xmm0
mulsd 0x9245(%rip), %xmm0     # 0x18010
cvttsd2si %xmm0, %ebp
movq %rdi, %rbx
addl $0x2710, %ebp           # imm = 0x2710
movq 0x38(%rdi), %rdi
movslq %ebp, %rsi
leaq 0x98c2(%rip), %rdx      # 0x186a8
callq 0x10de9
testq %rax, %rax
je 0xedfe
movl %ebp, 0x30(%rbx)
movq %rax, 0x38(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
pushq $0x1
popq %rdi
callq 0x1280
// File: /workspace/github_c_makefile_star2_O2/thegenemyers[P]DASCRUBBER/align.c
// Function: hamming
static inline int hamming(char *a, char *b, int n)
{ int h, i, x, y;

  h = 0;
  for (i = 0; i < n; i++)
    { x = *a++;
      if (x == 4)
        break;
      y = *b++;
      if (x != y)
        { if (y == 4)
            break;
          else
            h += 1;
        }
    }
  return (h);
}

// Assembly:
xorl %ecx, %ecx
testl %edx, %edx
cmovlel %ecx, %edx
xorl %eax, %eax
cmpl %ecx, %edx
je 0x10d31
movb (%rdi,%rcx), %r8b
cmpb $0x4, %r8b
je 0x10d31
movb (%rsi,%rcx), %r9b
cmpb %r9b, %r8b
je 0x10d2c
cmpb $0x4, %r9b
je 0x10d31
incl %eax
incq %rcx
jmp 0x10d0d
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/aegis128l/aesnia/encrypt.c
// Function: aegis128L_initialization
void aegis128L_initialization(const unsigned char *key, const unsigned char *iv, __m128i *state)
{
       int i;

        __m128i  tmp;
        __m128i  keytmp = _mm_load_si128((__m128i*)key);
        __m128i  ivtmp  = _mm_load_si128((__m128i*)iv);

        state[0] = _mm_xor_si128(keytmp, ivtmp);
        state[1] = _mm_set_epi8(0xdd,0x28,0xb5,0x73,0x42,0x31,0x11,0x20,0xf1,0x2f,0xc2,0x6d,0x55,0x18,0x3d,0xdb);
        state[2] = _mm_set_epi8(0x62,0x79,0xe9,0x90,0x59,0x37,0x22,0x15,0x0d,0x08,0x05,0x03,0x02,0x01,0x1, 0x0);
        state[3] = _mm_set_epi8(0xdd,0x28,0xb5,0x73,0x42,0x31,0x11,0x20,0xf1,0x2f,0xc2,0x6d,0x55,0x18,0x3d,0xdb);
        state[4] = _mm_xor_si128(keytmp, ivtmp);
        state[5] = _mm_xor_si128(keytmp, _mm_set_epi8(0x62,0x79,0xe9,0x90,0x59,0x37,0x22,0x15,0x0d,0x08,0x05,0x03,0x02,0x01,0x1,0x0));
        state[6] = _mm_xor_si128(keytmp, _mm_set_epi8(0xdd,0x28,0xb5,0x73,0x42,0x31,0x11,0x20,0xf1,0x2f,0xc2,0x6d,0x55,0x18,0x3d,0xdb));
        state[7] = _mm_xor_si128(keytmp, _mm_set_epi8(0x62,0x79,0xe9,0x90,0x59,0x37,0x22,0x15,0x0d,0x08,0x05,0x03,0x02,0x01,0x1,0x0));

        for (i = 0; i < 10; i++)  {
             //state update function;
             tmp = state[7];
             state[7] = _mm_aesenc_si128(state[6],state[7]);
             state[6] = _mm_aesenc_si128(state[5],state[6]);
             state[5] = _mm_aesenc_si128(state[4],state[5]);
             state[4] = _mm_aesenc_si128(state[3],state[4]);
             state[3] = _mm_aesenc_si128(state[2],state[3]);
             state[2] = _mm_aesenc_si128(state[1],state[2]);
             state[1] = _mm_aesenc_si128(state[0],state[1]);
             state[0] = _mm_aesenc_si128(tmp,state[0]);

             //message is used to update the state.
             state[0] = _mm_xor_si128(state[0],ivtmp);
             state[4] = _mm_xor_si128(state[4],keytmp);
       }
}

// Assembly:
vmovdqa (%rdi), %xmm3
vmovdqa (%rsi), %xmm4
vmovdqa 0xe54(%rip), %xmm1      # 0x2000
vpxor %xmm3, %xmm4, %xmm0
vpxor %xmm1, %xmm3, %xmm5
vmovdqa 0xe54(%rip), %xmm2      # 0x2010
vpxor %xmm2, %xmm3, %xmm6
pushq $0xa
popq %rax
vmovdqa %xmm2, %xmm7
vmovdqa %xmm0, %xmm8
vmovdqa %xmm5, %xmm9
subl $0x1, %eax
jb 0x1206
vaesenc %xmm0, %xmm9, %xmm10
vaesenc %xmm9, %xmm6, %xmm9
vaesenc %xmm6, %xmm5, %xmm6
vaesenc %xmm5, %xmm8, %xmm5
vaesenc %xmm8, %xmm7, %xmm8
vaesenc %xmm7, %xmm1, %xmm7
vaesenc %xmm1, %xmm2, %xmm1
vaesenc %xmm2, %xmm0, %xmm2
vpxor %xmm4, %xmm10, %xmm0
vpxor %xmm3, %xmm8, %xmm8
jmp 0x11cf
vmovdqa %xmm9, 0x70(%rdx)
vmovdqa %xmm6, 0x60(%rdx)
vmovdqa %xmm5, 0x50(%rdx)
vmovdqa %xmm8, 0x40(%rdx)
vmovdqa %xmm7, 0x30(%rdx)
vmovdqa %xmm1, 0x20(%rdx)
vmovdqa %xmm2, 0x10(%rdx)
vmovdqa %xmm0, (%rdx)
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/aegis128l/aesnia/encrypt.c
// Function: aegis128L_tag_generation
void aegis128L_tag_generation(unsigned long long msglen, unsigned long long adlen, unsigned char maclen, unsigned char *mac, __m128i *state)
{
       int i;

        __m128i  tmp;
        __m128i  msgtmp;
        unsigned char t[16],tt[16];


        for (i = 0; i < 16; i++) tt[i] = 0;


        ((unsigned long long*)tt)[0] = adlen << 3;
        ((unsigned long long*)tt)[1] = msglen << 3;
        msgtmp = _mm_load_si128((__m128i*)tt);

        msgtmp = _mm_xor_si128(msgtmp, state[2]);   //note the change

        for (i = 0; i < 7; i++) {
             //state update function
             tmp = state[7];
             state[7] = _mm_aesenc_si128(state[6],state[7]);
             state[6] = _mm_aesenc_si128(state[5],state[6]);
             state[5] = _mm_aesenc_si128(state[4],state[5]);
             state[4] = _mm_aesenc_si128(state[3],state[4]);
             state[3] = _mm_aesenc_si128(state[2],state[3]);
             state[2] = _mm_aesenc_si128(state[1],state[2]);
             state[1] = _mm_aesenc_si128(state[0],state[1]);
             state[0] = _mm_aesenc_si128(tmp,state[0]);

             //message is used to update the state.
             state[0] = _mm_xor_si128(state[0],msgtmp);
             state[4] = _mm_xor_si128(state[4],msgtmp);
        }

        state[6] = _mm_xor_si128(state[6], state[5]);
        state[6] = _mm_xor_si128(state[6], state[4]);
        state[6] = _mm_xor_si128(state[6], state[3]);
        state[6] = _mm_xor_si128(state[6], state[2]);
        state[6] = _mm_xor_si128(state[6], state[1]);
        state[6] = _mm_xor_si128(state[6], state[0]);

        _mm_store_si128((__m128i*)t, state[6]);
        //in this program, the mac length is assumed to be multiple of bytes
        memcpy(mac,t,maclen);
}

// Assembly:
subq $0x28, %rsp
xorl %eax, %eax
cmpq $0x10, %rax
je 0x1243
movb $0x0, (%rsp,%rax)
incq %rax
jmp 0x1234
shlq $0x3, %rsi
movq %rsi, (%rsp)
shlq $0x3, %rdi
movq %rdi, 0x8(%rsp)
vmovdqa (%r8), %xmm0
vmovdqa 0x10(%r8), %xmm1
vmovdqa 0x20(%r8), %xmm3
vmovdqa 0x30(%r8), %xmm4
vpxor (%rsp), %xmm3, %xmm7
vmovdqa 0x70(%r8), %xmm8
vmovdqa 0x60(%r8), %xmm2
vmovdqa 0x50(%r8), %xmm5
vmovdqa 0x40(%r8), %xmm6
pushq $0x7
popq %rax
subl $0x1, %eax
jb 0x12c2
vaesenc %xmm0, %xmm8, %xmm9
vaesenc %xmm8, %xmm2, %xmm8
vaesenc %xmm2, %xmm5, %xmm2
vaesenc %xmm5, %xmm6, %xmm5
vaesenc %xmm6, %xmm4, %xmm6
vaesenc %xmm4, %xmm3, %xmm4
vaesenc %xmm3, %xmm1, %xmm3
vaesenc %xmm1, %xmm0, %xmm1
vpxor %xmm7, %xmm9, %xmm0
vpxor %xmm7, %xmm6, %xmm6
jmp 0x128b
vmovdqa %xmm8, 0x70(%r8)
vmovdqa %xmm5, 0x50(%r8)
vmovdqa %xmm6, 0x40(%r8)
vmovdqa %xmm4, 0x30(%r8)
vmovdqa %xmm3, 0x20(%r8)
vmovdqa %xmm1, 0x10(%r8)
vmovdqa %xmm0, (%r8)
vpternlogq $0x96, %xmm6, %xmm5, %xmm2
vpternlogq $0x96, %xmm3, %xmm4, %xmm2
vpternlogq $0x96, %xmm0, %xmm1, %xmm2
vmovdqa %xmm2, 0x60(%r8)
leaq 0x10(%rsp), %rsi
vmovdqa %xmm2, (%rsi)
movzbl %dl, %edx
movq %rcx, %rdi
callq 0x10b0
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/ramirezsebas[P]TP-LISTINGS/./src/capitulo_2/2.6/readfile.c
// Function: main
int main(){
	char txt[50];
	//para leer cualquier tipo de archivo que se encuentre en la misma ruta que readfile.c
	printf("Introduzca nombre de archivo (default: file.txt)\n");
	scanf(" %s",txt);
	//char dir[50] = "../../src/capitulo_2/2.6/";
	char dir[50] = "./";
		strcat(dir, txt);
	char* file_txt = read_from_file( dir, filebytes(dir));
	printf("%s", file_txt);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x80, %rsp
leaq 0xdb8(%rip), %rdi       # 0x2069
callq 0x1040
leaq 0xd47(%rip), %rdi       # 0x2004
leaq -0x90(%rbp), %rbx
movq %rbx, %rsi
xorl %eax, %eax
callq 0x10e0
xorps %xmm0, %xmm0
leaq -0x50(%rbp), %r14
movaps %xmm0, (%r14)
movaps %xmm0, 0x20(%r14)
movaps %xmm0, 0x10(%r14)
andw $0x0, 0x30(%r14)
movw $0x2f2e, (%r14)         # imm = 0x2F2E
movq %r14, %rdi
movq %rbx, %rsi
callq 0x10f0
movq %r14, %rdi
callq 0x132c
movq %r14, %rdi
movq %rax, %rsi
callq 0x11fc
leaq 0xcf1(%rip), %rdi       # 0x2005
movq %rax, %rsi
xorl %eax, %eax
callq 0x1060
xorl %eax, %eax
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ramirezsebas[P]TP-LISTINGS/./src/capitulo_2/2.6/readfile.c
// Function: filebytes
size_t filebytes(char* filename){

	size_t fbytes = 0;
	FILE *fich;
	fich = fopen(filename,"r");

	if(fich==NULL){
		return 0;
	}else{
		fseek(fich, 0L, SEEK_END);
		fbytes = ftell(fich);
		printf("file bytes : %zu\n", fbytes);
		fclose(fich);
	}
	return fbytes;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leaq 0xd01(%rip), %rsi       # 0x203b
callq 0x10d0
testq %rax, %rax
je 0x137a
movq %rax, %rbx
pushq $0x2
popq %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x10b0
movq %rbx, %rdi
callq 0x1090
movq %rax, %r14
leaq 0xca2(%rip), %rdi       # 0x2008
movq %rax, %rsi
xorl %eax, %eax
callq 0x1060
movq %rbx, %rdi
callq 0x1050
jmp 0x137d
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ikbenlike[P]nngutils/src/cat.c
// Function: cat
int cat(struct cat_args *args, char *name){
    int fd;
    int c;
    for(int i = 0; i < args->fcount; i++){
        if(!strcmp(args->files[i], "-")){
            fd = STDIN_FILENO;
        }
        else {
            fd = open(args->files[i], O_RDONLY);
            if(fd == -1){
                fprintf(stderr, "%s: %s\n", name, strerror(errno));
                exit(1);
            }
        }
        print_file(fd, args, name);
        close(fd);
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %r12d, %r12d
movslq 0x10(%r14), %rax
cmpq %rax, %r12
jge 0x1766
movq 0x8(%r14), %rax
movq (%rax,%r12,8), %rdi
cmpb $0x2d, (%rdi)
jne 0x1735
cmpb $0x0, 0x1(%rdi)
je 0x1761
xorl %esi, %esi
xorl %eax, %eax
callq 0x10e0
movl %eax, %r15d
cmpl $-0x1, %eax
je 0x1771
movl %r15d, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1462
movl %r15d, %edi
callq 0x1080
incq %r12
jmp 0x1719
xorl %r15d, %r15d
jmp 0x1746
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x2880(%rip), %rax      # 0x3ff8
movq (%rax), %r14
callq 0x1040
movl (%rax), %edi
callq 0x1100
leaq 0x8f2(%rip), %rsi       # 0x2080
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x10d0
pushq $0x1
popq %rdi
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O2/ikbenlike[P]nngutils/src/cat.c
// Function: main
int main(int argc, char **argv){
    struct cat_args *args = calloc(1, sizeof(struct cat_args));
    if(args == NULL){
        fprintf(stderr, "%s: %s\n", argv[0], strerror(errno));
        return 1;
    }
    args = parse_arg(args, argc, argv);
    if(argc == 1 || args->fcount == 0){
        args->files[0] = calloc(1, 2 * sizeof(char));
        strcpy(args->files[0], "-");
        args->fcount = 1;
    }
    cat(args, argv[0]);
    free(args->files);
    free(args);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %r15d
pushq $0x1
popq %rdi
pushq $0x18
popq %rsi
callq 0x10b0
testq %rax, %rax
je 0x1833
movq %rax, %r14
movq %rax, %rdi
movl %r15d, %esi
movq %rbx, %rdx
callq 0x120c
cmpl $0x1, %r15d
je 0x17e4
cmpl $0x0, 0x10(%r14)
jne 0x180a
pushq $0x1
popq %rdi
pushq $0x2
popq %rsi
callq 0x10b0
movq 0x8(%r14), %rcx
movq %rax, (%rcx)
movq 0x8(%r14), %rax
movq (%rax), %rax
movw $0x2d, (%rax)
movl $0x1, 0x10(%r14)
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x1705
movq 0x8(%r14), %rdi
callq 0x1030
movq %r14, %rdi
callq 0x1030
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x27be(%rip), %rax      # 0x3ff8
movq (%rax), %r14
movq (%rbx), %rbx
callq 0x1040
movl (%rax), %edi
callq 0x1100
leaq 0x82d(%rip), %rsi       # 0x2080
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x10d0
pushq $0x1
popq %rax
jmp 0x1828
// File: /workspace/github_c_makefile_star2_O2/macournoyer[P]peg/leg.c
// Function: yyparsefrom
YY_PARSE(int) YYPARSEFROM(yyrule yystart)
{
  int yyok;
  if (!yybuflen)
    {
      yybuflen= 1024;
      yybuf= malloc(yybuflen);
      yytextlen= 1024;
      yytext= malloc(yytextlen);
      yythunkslen= 32;
      yythunks= malloc(sizeof(yythunk) * yythunkslen);
      yyvalslen= 32;
      yyvals= malloc(sizeof(YYSTYPE) * yyvalslen);
      yybegin= yyend= yypos= yylimit= yythunkpos= 0;
    }
  yybegin= yyend= yypos;
  yythunkpos= 0;
  yyval= yyvals;
  yyok= yystart();
  if (yyok) yyDone();
  yyCommit();
  return yyok;
  (void)yyrefill;
  (void)yymatchDot;
  (void)yymatchChar;
  (void)yymatchString;
  (void)yymatchClass;
  (void)yyDo;
  (void)yyText;
  (void)yyDone;
  (void)yyCommit;
  (void)yyAccept;
  (void)yyPush;
  (void)yyPop;
  (void)yySet;
  (void)yytextmax;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x8e56(%rip)      # 0xa114
je 0x12cf
movl 0x8e8a(%rip), %ecx      # 0xa150
movq 0x8e73(%rip), %rax      # 0xa140
jmp 0x133e
movl $0x400, %ebp            # imm = 0x400
movl %ebp, 0x8e3a(%rip)      # 0xa114
movl $0x400, %edi            # imm = 0x400
callq 0x1100
movq %rax, 0x8e2d(%rip)      # 0xa118
movl %ebp, 0x8e2f(%rip)      # 0xa120
movl $0x400, %edi            # imm = 0x400
callq 0x1100
movq %rax, 0x8e26(%rip)      # 0xa128
movl $0x20, 0x8e24(%rip)     # 0xa130
movl $0x300, %edi            # imm = 0x300
callq 0x1100
movq %rax, 0x8e1b(%rip)      # 0xa138
movl $0x80, %edi
callq 0x1100
movq %rax, 0x8e12(%rip)      # 0xa140
andl $0x0, 0x8e17(%rip)      # 0xa14c
andl $0x0, 0x8e14(%rip)      # 0xa150
xorl %ecx, %ecx
movl %ecx, 0x8e10(%rip)      # 0xa154
movl %ecx, 0x8e0e(%rip)      # 0xa158
andl $0x0, 0x8df7(%rip)      # 0xa148
movq %rax, 0x8e08(%rip)      # 0xa160
xorl %eax, %eax
callq *%rbx
movl %eax, %ebx
testl %eax, %eax
je 0x13a9
pushq $0x8
popq %r14
xorl %r15d, %r15d
movslq 0x8dd8(%rip), %rax      # 0xa148
cmpq %rax, %r15
jge 0x13a9
movq 0x8dbc(%rip), %r12      # 0xa138
movl -0x8(%r12,%r14), %esi
movl -0x4(%r12,%r14), %eax
testl %eax, %eax
je 0x1395
movl %esi, %edi
movl %eax, %esi
callq 0x189d
movl %eax, %esi
movq 0x8d8c(%rip), %rdi      # 0xa128
callq *(%r12,%r14)
incq %r15
addq $0x18, %r14
jmp 0x1369
movslq 0x8da0(%rip), %r14      # 0xa150
movl 0x8d96(%rip), %eax      # 0xa14c
subl %r14d, %eax
movl %eax, 0x8d8d(%rip)      # 0xa14c
je 0x13d4
movq 0x8d50(%rip), %rdi      # 0xa118
leaq (%rdi,%r14), %rsi
movslq %eax, %rdx
callq 0x1120
subl %r14d, 0x8d7d(%rip)     # 0xa158
subl %r14d, 0x8d72(%rip)     # 0xa154
andl $0x0, 0x8d5f(%rip)      # 0xa148
andl $0x0, 0x8d60(%rip)      # 0xa150
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/macournoyer[P]peg/leg.c
// Function: yyerror
void yyerror(char *message)
{
  fprintf(stderr, "%s:%d: %s", fileName, lineNumber, message);
  if (yytext[0]) fprintf(stderr, " near token '%s'", yytext);
  if (yypos < yylimit || !feof(input))
    {
      yybuf[yylimit]= '\0';
      fprintf(stderr, " before text \"");
      while (yypos < yylimit)
	{
	  if ('\n' == yybuf[yypos] || '\r' == yybuf[yypos]) break;
	  fputc(yybuf[yypos++], stderr);
	}
      if (yypos == yylimit)
	{
	  int c;
	  while (EOF != (c= fgetc(input)) && '\n' != c && '\r' != c)
	    fputc(c, stderr);
	}
      fputc('\"', stderr);
    }
  fprintf(stderr, "\n");
  exit(1);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %r8
movq 0x8be4(%rip), %rbx      # 0x9ff8
movq (%rbx), %rdi
movq 0x8d4a(%rip), %rdx      # 0xa168
movl 0x8d4c(%rip), %ecx      # 0xa170
leaq 0x3bd9(%rip), %rsi      # 0x5004
xorl %eax, %eax
callq 0x10c0
movq 0x8cef(%rip), %rdx      # 0xa128
cmpb $0x0, (%rdx)
je 0x144f
movq (%rbx), %rdi
leaq 0x3bc6(%rip), %rsi      # 0x500e
xorl %eax, %eax
callq 0x10c0
movl 0x8cf7(%rip), %eax      # 0xa14c
cmpl %eax, 0x8cf5(%rip)      # 0xa150
jl 0x1477
movq 0x8ca4(%rip), %rdi      # 0xa108
callq 0x10d0
testl %eax, %eax
jne 0x150d
movl 0x8cd5(%rip), %eax      # 0xa14c
movq 0x8c9a(%rip), %rcx      # 0xa118
cltq
movb $0x0, (%rcx,%rax)
movq (%rbx), %rcx
leaq 0x3b91(%rip), %rdi      # 0x501f
pushq $0xe
popq %rsi
pushq $0x1
popq %rdx
callq 0x1180
movslq 0x8cb0(%rip), %rax      # 0xa150
movl 0x8ca6(%rip), %ecx      # 0xa14c
cmpl %ecx, %eax
jge 0x14d4
movq 0x8c67(%rip), %rdx      # 0xa118
movzbl (%rdx,%rax), %edx
cmpl $0xa, %edx
je 0x14d4
cmpl $0xd, %edx
je 0x14d4
movsbl %dl, %edi
incl %eax
movl %eax, 0x8c86(%rip)      # 0xa150
movq (%rbx), %rsi
callq 0x1090
jmp 0x1499
cmpl %ecx, %eax
jne 0x1502
movl $0x4801, %ebp           # imm = 0x4801
movq 0x8c24(%rip), %rdi      # 0xa108
callq 0x1080
leal 0x1(%rax), %ecx
cmpl $0xe, %ecx
ja 0x14f6
btl %ecx, %ebp
jb 0x1502
movq (%rbx), %rsi
movl %eax, %edi
callq 0x1090
jmp 0x14dd
movq (%rbx), %rsi
pushq $0x22
popq %rdi
callq 0x1090
movq (%rbx), %rsi
pushq $0xa
popq %rdi
callq 0x1090
pushq $0x1
popq %rdi
callq 0x1170
// File: /workspace/github_c_makefile_star2_O2/macournoyer[P]peg/leg.c
// Function: makeHeader
void makeHeader(char *text)
{
  Header *header= (Header *)malloc(sizeof(Header));
  header->text= strdup(text);
  header->next= headers;
  headers= header;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x10
popq %rdi
callq 0x1100
movq %rax, %r14
movq %rbx, %rdi
callq 0x1190
movq %rax, (%r14)
movq 0x8c34(%rip), %rax      # 0xa178
movq %rax, 0x8(%r14)
movq %r14, 0x8c29(%rip)      # 0xa178
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/macournoyer[P]peg/leg.c
// Function: yyText
YY_LOCAL(int) yyText(int begin, int end)
{
  int yyleng= end - begin;
  if (yyleng <= 0)
    yyleng= 0;
  else
    {
      while (yytextlen < (yyleng - 1))
	{
	  yytextlen *= 2;
	  yytext= realloc(yytext, yytextlen);
	}
      memcpy(yytext, yybuf + begin, yyleng);
    }
  yytext[yyleng]= '\0';
  return yyleng;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
subl %edi, %ebx
jle 0x18fb
movl %edi, %ebp
leal -0x1(%rbx), %r15d
movl 0x8868(%rip), %r12d     # 0xa120
movq 0x8869(%rip), %r14      # 0xa128
cmpl %r15d, %r12d
jge 0x18e5
addl %r12d, %r12d
movl %r12d, 0x8852(%rip)     # 0xa120
movslq %r12d, %rsi
movq %r14, %rdi
callq 0x1110
movq %rax, %r14
movq %rax, 0x8845(%rip)      # 0xa128
jmp 0x18bf
movslq %ebp, %rsi
addq 0x8829(%rip), %rsi      # 0xa118
movl %ebx, %edx
movq %r14, %rdi
callq 0x10e0
jmp 0x1904
xorl %ebx, %ebx
movq 0x8824(%rip), %r14      # 0xa128
movl %ebx, %eax
movb $0x0, (%r14,%rax)
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/macournoyer[P]peg/leg.c
// Function: yy_grammar
YY_RULE(int) yy_grammar()
{  int yypos0= yypos, yythunkpos0= yythunkpos;
  yyprintf((stderr, "%s\n", "grammar"));  if (!yy__()) goto l111;
  {  int yypos114= yypos, yythunkpos114= yythunkpos;  if (!yy_declaration()) goto l115;  goto l114;
  l115:;	  yypos= yypos114; yythunkpos= yythunkpos114;  if (!yy_definition()) goto l111;
  }
  l114:;	
  l112:;	
  {  int yypos113= yypos, yythunkpos113= yythunkpos;
  {  int yypos116= yypos, yythunkpos116= yythunkpos;  if (!yy_declaration()) goto l117;  goto l116;
  l117:;	  yypos= yypos116; yythunkpos= yythunkpos116;  if (!yy_definition()) goto l113;
  }
  l116:;	  goto l112;
  l113:;	  yypos= yypos113; yythunkpos= yythunkpos113;
  }
  {  int yypos118= yypos, yythunkpos118= yythunkpos;  if (!yy_trailer()) goto l118;  goto l119;
  l118:;	  yypos= yypos118; yythunkpos= yythunkpos118;
  }
  l119:;	  if (!yy_end_of_file()) goto l111;
  yyprintf((stderr, "  ok   %s @ %s\n", "grammar", yybuf+yypos));
  return 1;
  l111:;	  yypos= yypos0; yythunkpos= yythunkpos0;
  yyprintf((stderr, "  fail %s @ %s\n", "grammar", yybuf+yypos));
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl 0x882d(%rip), %ebx      # 0xa150
movl 0x881f(%rip), %ebp      # 0xa148
callq 0x1a74
movl 0x881b(%rip), %r14d     # 0xa150
movl 0x880c(%rip), %r15d     # 0xa148
callq 0x1d11
testl %eax, %eax
jne 0x1960
movl %r14d, 0x8804(%rip)     # 0xa150
movl %r15d, 0x87f5(%rip)     # 0xa148
callq 0x1e77
testl %eax, %eax
je 0x1a56
movl 0x87e9(%rip), %r14d     # 0xa150
movl 0x87da(%rip), %r15d     # 0xa148
callq 0x1d11
testl %eax, %eax
jne 0x1960
movl %r14d, 0x87d2(%rip)     # 0xa150
movl %r15d, 0x87c3(%rip)     # 0xa148
callq 0x1e77
testl %eax, %eax
jne 0x1960
movl %r14d, 0x87bb(%rip)     # 0xa150
movl %r15d, 0x87ac(%rip)     # 0xa148
leaq 0x36ec(%rip), %rdi      # 0x508f
callq 0x1c81
testl %eax, %eax
je 0x1a31
movl 0x87a2(%rip), %edi      # 0xa158
movl 0x8798(%rip), %esi      # 0xa154
callq 0x189d
movl 0x8789(%rip), %eax      # 0xa150
movl %eax, 0x878b(%rip)      # 0xa158
movl 0x877c(%rip), %r14d     # 0xa150
movl 0x876d(%rip), %r15d     # 0xa148
callq 0x1cdf
testl %eax, %eax
jne 0x19cd
movl %r14d, 0x8765(%rip)     # 0xa150
movl %r15d, 0x8756(%rip)     # 0xa148
movl 0x8760(%rip), %edi      # 0xa158
movl 0x8756(%rip), %esi      # 0xa154
callq 0x189d
movl 0x8747(%rip), %edx      # 0xa150
movl %edx, 0x8745(%rip)      # 0xa154
movl 0x8743(%rip), %esi      # 0xa158
leaq 0x119e(%rip), %rdi      # 0x2bba
callq 0x1e04
movl 0x8728(%rip), %r14d     # 0xa150
movl 0x8719(%rip), %r15d     # 0xa148
jmp 0x1a3f
movl %r14d, 0x8718(%rip)     # 0xa150
movl %r15d, 0x8709(%rip)     # 0xa148
callq 0x1cdf
movl %r14d, 0x8705(%rip)     # 0xa150
movl %r15d, 0x86f6(%rip)     # 0xa148
testl %eax, %eax
je 0x1a66
movl %ebx, 0x86f4(%rip)      # 0xa150
movl %ebp, 0x86e6(%rip)      # 0xa148
xorl %eax, %eax
jmp 0x1a69
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/macournoyer[P]peg/leg.c
// Function: yy__
YY_RULE(int) yy__()
{
  yyprintf((stderr, "%s\n", "_"));
  l107:;	
  {  int yypos108= yypos, yythunkpos108= yythunkpos;
  {  int yypos109= yypos, yythunkpos109= yythunkpos;  if (!yy_space()) goto l110;  goto l109;
  l110:;	  yypos= yypos109; yythunkpos= yythunkpos109;  if (!yy_comment()) goto l108;
  }
  l109:;	  goto l107;
  l108:;	  yypos= yypos108; yythunkpos= yythunkpos108;
  }
  yyprintf((stderr, "  ok   %s @ %s\n", "_", yybuf+yypos));
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
pushq $0x20
popq %rbx
pushq $0x9
popq %rbp
movl 0x86c4(%rip), %r15d     # 0xa150
movl 0x86b5(%rip), %r12d     # 0xa148
movl %ebx, %edi
callq 0x1b4e
testl %eax, %eax
jne 0x1a85
movl %r15d, 0x86ab(%rip)     # 0xa150
movl %r12d, 0x869c(%rip)     # 0xa148
movl %ebp, %edi
callq 0x1b4e
testl %eax, %eax
jne 0x1a85
movl %r15d, 0x8692(%rip)     # 0xa150
movl %r12d, 0x8683(%rip)     # 0xa148
callq 0x1c15
testl %eax, %eax
jne 0x1a85
movl %r15d, 0x867b(%rip)     # 0xa150
movl %r12d, 0x866c(%rip)     # 0xa148
pushq $0x23
popq %rdi
callq 0x1b4e
testl %eax, %eax
je 0x1b31
movl 0x8661(%rip), %r13d     # 0xa150
movl 0x8652(%rip), %r14d     # 0xa148
callq 0x1c15
testl %eax, %eax
jne 0x1b16
movl %r13d, 0x864a(%rip)     # 0xa150
movl %r14d, 0x863b(%rip)     # 0xa148
callq 0x1cdf
testl %eax, %eax
jne 0x1ae8
movl %r13d, 0x8633(%rip)     # 0xa150
movl %r14d, 0x8624(%rip)     # 0xa148
callq 0x1c15
testl %eax, %eax
jne 0x1a85
movl %r15d, 0x8618(%rip)     # 0xa150
movl %r12d, 0x8609(%rip)     # 0xa148
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/macournoyer[P]peg/leg.c
// Function: yyrefill
YY_LOCAL(int) yyrefill(void)
{
  int yyn;
  while (yybuflen - yypos < 512)
    {
      yybuflen *= 2;
      yybuf= realloc(yybuf, yybuflen);
    }
  YY_INPUT((yybuf + yypos), yyn, (yybuflen - yypos));
  if (!yyn) return 0;
  yylimit += yyn;
  return 1;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl 0x85b6(%rip), %ebx      # 0xa150
movl 0x8574(%rip), %ebp      # 0xa114
movq 0x8571(%rip), %rax      # 0xa118
movl %ebp, %ecx
subl %ebx, %ecx
cmpl $0x1ff, %ecx            # imm = 0x1FF
jg 0x1bcf
addl %ebp, %ebp
movl %ebp, 0x8559(%rip)      # 0xa114
movslq %ebp, %rsi
movq %rax, %rdi
callq 0x1110
movq %rax, 0x854b(%rip)      # 0xa118
jmp 0x1ba7
movq 0x8532(%rip), %rdi      # 0xa108
callq 0x11a0
cmpl $-0x1, %eax
je 0x1c0c
cmpl $0xd, %eax
je 0x1bea
cmpl $0xa, %eax
jne 0x1bf0
incl 0x8580(%rip)            # 0xa170
movq 0x8521(%rip), %rcx      # 0xa118
movslq 0x8552(%rip), %rdx      # 0xa150
movb %al, (%rcx,%rdx)
incl 0x8545(%rip)            # 0xa14c
pushq $0x1
popq %rax
jmp 0x1c0e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/macournoyer[P]peg/leg.c
// Function: yy_end_of_line
YY_RULE(int) yy_end_of_line()
{  int yypos0= yypos, yythunkpos0= yythunkpos;
  yyprintf((stderr, "%s\n", "end_of_line"));
  {  int yypos2= yypos, yythunkpos2= yythunkpos;  if (!yymatchString("\r\n")) goto l3;  goto l2;
  l3:;	  yypos= yypos2; yythunkpos= yythunkpos2;  if (!yymatchChar('\n')) goto l4;  goto l2;
  l4:;	  yypos= yypos2; yythunkpos= yythunkpos2;  if (!yymatchChar('\r')) goto l1;
  }
  l2:;	
  yyprintf((stderr, "  ok   %s @ %s\n", "end_of_line", yybuf+yypos));
  return 1;
  l1:;	  yypos= yypos0; yythunkpos= yythunkpos0;
  yyprintf((stderr, "  fail %s @ %s\n", "end_of_line", yybuf+yypos));
  return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl 0x8531(%rip), %ebp      # 0xa150
movl 0x8522(%rip), %r14d     # 0xa148
leaq 0x3434(%rip), %rdi      # 0x5061
callq 0x1c81
pushq $0x1
popq %rbx
testl %eax, %eax
jne 0x1c7a
movl %ebp, 0x8511(%rip)      # 0xa150
movl %r14d, 0x8502(%rip)     # 0xa148
pushq $0xa
popq %rdi
callq 0x1b4e
testl %eax, %eax
jne 0x1c7a
movl %ebp, 0x84f8(%rip)      # 0xa150
movl %r14d, 0x84e9(%rip)     # 0xa148
pushq $0xd
popq %rdi
callq 0x1b4e
testl %eax, %eax
jne 0x1c7a
movl %ebp, 0x84df(%rip)      # 0xa150
movl %r14d, 0x84d0(%rip)     # 0xa148
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/macournoyer[P]peg/leg.c
// Function: yymatchString
YY_LOCAL(int) yymatchString(char *s)
{
  int yysav= yypos;
  while (*s)
    {
      if (yypos >= yylimit && !yyrefill()) return 0;
      if (yybuf[yypos] != *s)
        {
          yypos= yysav;
          return 0;
        }
      ++s;
      ++yypos;
    }
  return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movl 0x84c2(%rip), %ebp      # 0xa150
pushq $0x1
popq %rbx
movl %ebp, %eax
movb (%r14), %cl
testb %cl, %cl
je 0x1cd8
cmpl 0x84ac(%rip), %eax      # 0xa14c
jl 0x1cb4
callq 0x1b91
testl %eax, %eax
je 0x1cd6
movl 0x849f(%rip), %eax      # 0xa150
movb (%r14), %cl
movq 0x845d(%rip), %rdx      # 0xa118
movslq %eax, %rsi
cmpb %cl, (%rdx,%rsi)
jne 0x1cd0
incq %r14
incl %eax
movl %eax, 0x8482(%rip)      # 0xa150
jmp 0x1c93
movl %ebp, 0x847a(%rip)      # 0xa150
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/macournoyer[P]peg/leg.c
// Function: yy_declaration
YY_RULE(int) yy_declaration()
{  int yypos0= yypos, yythunkpos0= yythunkpos;
  yyprintf((stderr, "%s\n", "declaration"));  if (!yymatchString("%{")) goto l102;  yyText(yybegin, yyend);  if (!(YY_BEGIN)) goto l102;
  l103:;	
  {  int yypos104= yypos, yythunkpos104= yythunkpos;
  {  int yypos105= yypos, yythunkpos105= yythunkpos;  if (!yymatchString("%}")) goto l105;  goto l104;
  l105:;	  yypos= yypos105; yythunkpos= yythunkpos105;
  }  if (!yymatchDot()) goto l104;  goto l103;
  l104:;	  yypos= yypos104; yythunkpos= yythunkpos104;
  }  yyText(yybegin, yyend);  if (!(YY_END)) goto l102;  if (!yy_RPERCENT()) goto l102;  yyDo(yy_1_declaration, yybegin, yyend);
  yyprintf((stderr, "  ok   %s @ %s\n", "declaration", yybuf+yypos));
  return 1;
  l102:;	  yypos= yypos0; yythunkpos= yythunkpos0;
  yyprintf((stderr, "  fail %s @ %s\n", "declaration", yybuf+yypos));
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl 0x8431(%rip), %ebp      # 0xa150
movl 0x8422(%rip), %r14d     # 0xa148
leaq 0x3337(%rip), %rdi      # 0x5064
callq 0x1c81
testl %eax, %eax
je 0x1dec
movl 0x8418(%rip), %edi      # 0xa158
movl 0x840e(%rip), %esi      # 0xa154
callq 0x189d
movl 0x83ff(%rip), %eax      # 0xa150
movl %eax, 0x8401(%rip)      # 0xa158
leaq 0x3309(%rip), %rbx      # 0x5067
movl 0x83eb(%rip), %r15d     # 0xa150
movl 0x83dc(%rip), %r12d     # 0xa148
movq %rbx, %rdi
callq 0x1c81
testl %eax, %eax
jne 0x1d8f
movl %r15d, 0x83d1(%rip)     # 0xa150
movl %r12d, 0x83c2(%rip)     # 0xa148
callq 0x1cdf
testl %eax, %eax
jne 0x1d5e
movl %r15d, 0x83ba(%rip)     # 0xa150
movl %r12d, 0x83ab(%rip)     # 0xa148
movl 0x83b5(%rip), %edi      # 0xa158
movl 0x83ab(%rip), %esi      # 0xa154
callq 0x189d
movl 0x839c(%rip), %eax      # 0xa150
movl %eax, 0x839a(%rip)      # 0xa154
leaq 0x32a6(%rip), %rdi      # 0x5067
callq 0x1c81
testl %eax, %eax
je 0x1dec
callq 0x1a74
movl 0x8383(%rip), %esi      # 0xa158
movl 0x8379(%rip), %edx      # 0xa154
leaq 0x90(%rip), %rdi        # 0x1e72
callq 0x1e04
pushq $0x1
popq %rax
jmp 0x1dfb
movl %ebp, 0x835e(%rip)      # 0xa150
movl %r14d, 0x834f(%rip)     # 0xa148
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/macournoyer[P]peg/leg.c
// Function: yyDo
YY_LOCAL(void) yyDo(yyaction action, int begin, int end)
{
  while (yythunkpos >= yythunkslen)
    {
      yythunkslen *= 2;
      yythunks= realloc(yythunks, sizeof(yythunk) * yythunkslen);
    }
  yythunks[yythunkpos].begin=  begin;
  yythunks[yythunkpos].end=    end;
  yythunks[yythunkpos].action= action;
  ++yythunkpos;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movslq 0x832e(%rip), %r15      # 0xa148
movl 0x830f(%rip), %r12d     # 0xa130
movq 0x8310(%rip), %rax      # 0xa138
cmpl %r12d, %r15d
jl 0x1e4f
addl %r12d, %r12d
movl %r12d, 0x82f9(%rip)     # 0xa130
movslq %r12d, %rcx
imulq $0x18, %rcx, %rsi
movq %rax, %rdi
callq 0x1110
movq %rax, 0x82eb(%rip)      # 0xa138
jmp 0x1e28
imulq $0x18, %r15, %rcx
movl %ebp, (%rax,%rcx)
movl %ebx, 0x4(%rax,%rcx)
movq %r14, 0x8(%rax,%rcx)
leal 0x1(%r15), %eax
movl %eax, 0x82df(%rip)      # 0xa148
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/macournoyer[P]peg/leg.c
// Function: yy_definition
YY_RULE(int) yy_definition()
{  int yypos0= yypos, yythunkpos0= yythunkpos;
  yyprintf((stderr, "%s\n", "definition"));  if (!yy_identifier()) goto l99;  yyDo(yy_1_definition, yybegin, yyend);  if (!yy_EQUAL()) goto l99;  if (!yy_expression()) goto l99;  yyDo(yy_2_definition, yybegin, yyend);
  {  int yypos100= yypos, yythunkpos100= yythunkpos;  if (!yy_SEMICOLON()) goto l100;  goto l101;
  l100:;	  yypos= yypos100; yythunkpos= yythunkpos100;
  }
  l101:;	
  yyprintf((stderr, "  ok   %s @ %s\n", "definition", yybuf+yypos));
  return 1;
  l99:;	  yypos= yypos0; yythunkpos= yythunkpos0;
  yyprintf((stderr, "  fail %s @ %s\n", "definition", yybuf+yypos));
  return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl 0x82d0(%rip), %ebx      # 0xa150
movl 0x82c2(%rip), %ebp      # 0xa148
callq 0x1f6e
testl %eax, %eax
je 0x1ef0
movl 0x82c3(%rip), %esi      # 0xa158
movl 0x82b9(%rip), %edx      # 0xa154
leaq 0x74(%rip), %rdi        # 0x1f16
callq 0x1e04
callq 0x2066
testl %eax, %eax
je 0x1ef0
callq 0x20a0
testl %eax, %eax
je 0x1ef0
movl 0x8299(%rip), %esi      # 0xa158
movl 0x828f(%rip), %edx      # 0xa154
leaq 0x88(%rip), %rdi        # 0x1f54
callq 0x1e04
movl 0x8279(%rip), %ebx      # 0xa150
movl 0x826b(%rip), %ebp      # 0xa148
pushq $0x3b
popq %rdi
callq 0x1b4e
testl %eax, %eax
je 0x1f00
callq 0x1a74
jmp 0x1f0c
movl %ebx, 0x825a(%rip)      # 0xa150
movl %ebp, 0x824c(%rip)      # 0xa148
xorl %eax, %eax
jmp 0x1f0f
movl %ebx, 0x824a(%rip)      # 0xa150
movl %ebp, 0x823c(%rip)      # 0xa148
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/macournoyer[P]peg/leg.c
// Function: yy_identifier
YY_RULE(int) yy_identifier()
{  int yypos0= yypos, yythunkpos0= yythunkpos;
  yyprintf((stderr, "%s\n", "identifier"));  yyText(yybegin, yyend);  if (!(YY_BEGIN)) goto l90;  if (!yymatchClass((unsigned char *)"\000\000\000\000\000\040\000\000\376\377\377\207\376\377\377\007\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000")) goto l90;
  l91:;	
  {  int yypos92= yypos, yythunkpos92= yythunkpos;  if (!yymatchClass((unsigned char *)"\000\000\000\000\000\040\377\003\376\377\377\207\376\377\377\007\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000")) goto l92;  goto l91;
  l92:;	  yypos= yypos92; yythunkpos= yythunkpos92;
  }  yyText(yybegin, yyend);  if (!(YY_END)) goto l90;  if (!yy__()) goto l90;
  yyprintf((stderr, "  ok   %s @ %s\n", "identifier", yybuf+yypos));
  return 1;
  l90:;	  yypos= yypos0; yythunkpos= yythunkpos0;
  yyprintf((stderr, "  fail %s @ %s\n", "identifier", yybuf+yypos));
  return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl 0x81d8(%rip), %ebx      # 0xa150
movl 0x81ca(%rip), %ebp      # 0xa148
movl 0x81d4(%rip), %edi      # 0xa158
movl 0x81ca(%rip), %esi      # 0xa154
callq 0x189d
movl 0x81bb(%rip), %eax      # 0xa150
movl %eax, 0x81bd(%rip)      # 0xa158
leaq 0x3240(%rip), %rdi      # 0x51e2
callq 0x2012
testl %eax, %eax
je 0x1fff
leaq 0x3251(%rip), %rbx      # 0x5203
movl 0x8198(%rip), %ebp      # 0xa150
movl 0x8189(%rip), %r14d     # 0xa148
movq %rbx, %rdi
callq 0x2012
testl %eax, %eax
jne 0x1fb2
movl %ebp, 0x817f(%rip)      # 0xa150
movl %r14d, 0x8170(%rip)     # 0xa148
movl 0x817a(%rip), %edi      # 0xa158
movl 0x8170(%rip), %esi      # 0xa154
callq 0x189d
movl 0x8161(%rip), %eax      # 0xa150
movl %eax, 0x815f(%rip)      # 0xa154
callq 0x1a74
pushq $0x1
popq %rax
jmp 0x200d
movl %ebx, 0x814b(%rip)      # 0xa150
movl %ebp, 0x813d(%rip)      # 0xa148
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/macournoyer[P]peg/leg.c
// Function: yymatchClass
YY_LOCAL(int) yymatchClass(unsigned char *bits)
{
  int c;
  if (yypos >= yylimit && !yyrefill()) return 0;
  c= yybuf[yypos];
  if (bits[c >> 3] & (1 << (c & 7)))
    {
      ++yypos;
      yyprintf((stderr, "  ok   yymatchClass @ %s\n", yybuf+yypos));
      return 1;
    }
  yyprintf((stderr, "  fail yymatchClass @ %s\n", yybuf+yypos));
  return 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x8134(%rip), %eax      # 0xa150
cmpl 0x812a(%rip), %eax      # 0xa14c
jl 0x2033
callq 0x1b91
testl %eax, %eax
je 0x2062
movl 0x811d(%rip), %eax      # 0xa150
movq 0x80de(%rip), %rcx      # 0xa118
movslq %eax, %rdx
movsbl (%rcx,%rdx), %ecx
movl %ecx, %edx
sarl $0x3, %edx
movslq %edx, %rdx
movzbl (%rbx,%rdx), %edx
andl $0x7, %ecx
btl %ecx, %edx
jae 0x2062
incl %eax
movl %eax, 0x80f3(%rip)      # 0xa150
pushq $0x1
popq %rax
jmp 0x2064
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/macournoyer[P]peg/leg.c
// Function: yy_EQUAL
YY_RULE(int) yy_EQUAL()
{  int yypos0= yypos, yythunkpos0= yythunkpos;
  yyprintf((stderr, "%s\n", "EQUAL"));  if (!yymatchChar('=')) goto l89;  if (!yy__()) goto l89;
  yyprintf((stderr, "  ok   %s @ %s\n", "EQUAL", yybuf+yypos));
  return 1;
  l89:;	  yypos= yypos0; yythunkpos= yythunkpos0;
  yyprintf((stderr, "  fail %s @ %s\n", "EQUAL", yybuf+yypos));
  return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl 0x80e1(%rip), %ebx      # 0xa150
movl 0x80d3(%rip), %ebp      # 0xa148
pushq $0x3d
popq %rdi
callq 0x1b4e
testl %eax, %eax
je 0x208b
callq 0x1a74
pushq $0x1
popq %rax
jmp 0x2099
movl %ebx, 0x80bf(%rip)      # 0xa150
movl %ebp, 0x80b1(%rip)      # 0xa148
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/macournoyer[P]peg/leg.c
// Function: yy_expression
YY_RULE(int) yy_expression()
{  int yypos0= yypos, yythunkpos0= yythunkpos;
  yyprintf((stderr, "%s\n", "expression"));  if (!yy_sequence()) goto l86;
  l87:;	
  {  int yypos88= yypos, yythunkpos88= yythunkpos;  if (!yy_BAR()) goto l88;  if (!yy_sequence()) goto l88;  yyDo(yy_1_expression, yybegin, yyend);  goto l87;
  l88:;	  yypos= yypos88; yythunkpos= yythunkpos88;
  }
  yyprintf((stderr, "  ok   %s @ %s\n", "expression", yybuf+yypos));
  return 1;
  l86:;	  yypos= yypos0; yythunkpos= yythunkpos0;
  yyprintf((stderr, "  fail %s @ %s\n", "expression", yybuf+yypos));
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl 0x80a1(%rip), %r15d     # 0xa150
movl 0x8092(%rip), %r12d     # 0xa148
callq 0x2146
testl %eax, %eax
je 0x2109
pushq $0x7c
popq %rbp
pushq $0x1
popq %rbx
leaq 0x58(%rip), %r14        # 0x2124
movl 0x807d(%rip), %r15d     # 0xa150
movl 0x806e(%rip), %r12d     # 0xa148
movl %ebp, %edi
callq 0x1b4e
testl %eax, %eax
je 0x210b
callq 0x1a74
callq 0x2146
testl %eax, %eax
je 0x210b
movl 0x805f(%rip), %esi      # 0xa158
movl 0x8055(%rip), %edx      # 0xa154
movq %r14, %rdi
callq 0x1e04
jmp 0x20cc
xorl %ebx, %ebx
movl %r15d, 0x803e(%rip)     # 0xa150
movl %r12d, 0x802f(%rip)     # 0xa148
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/macournoyer[P]peg/leg.c
// Function: yy_prefix
YY_RULE(int) yy_prefix()
{  int yypos0= yypos, yythunkpos0= yythunkpos;
  yyprintf((stderr, "%s\n", "prefix"));
  {  int yypos77= yypos, yythunkpos77= yythunkpos;  if (!yy_AND()) goto l78;  if (!yy_action()) goto l78;  yyDo(yy_1_prefix, yybegin, yyend);  goto l77;
  l78:;	  yypos= yypos77; yythunkpos= yythunkpos77;  if (!yy_AND()) goto l79;  if (!yy_suffix()) goto l79;  yyDo(yy_2_prefix, yybegin, yyend);  goto l77;
  l79:;	  yypos= yypos77; yythunkpos= yythunkpos77;  if (!yy_NOT()) goto l80;  if (!yy_suffix()) goto l80;  yyDo(yy_3_prefix, yybegin, yyend);  goto l77;
  l80:;	  yypos= yypos77; yythunkpos= yythunkpos77;  if (!yy_suffix()) goto l76;
  }
  l77:;	
  yyprintf((stderr, "  ok   %s @ %s\n", "prefix", yybuf+yypos));
  return 1;
  l76:;	  yypos= yypos0; yythunkpos= yythunkpos0;
  yyprintf((stderr, "  fail %s @ %s\n", "prefix", yybuf+yypos));
  return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl 0x7f70(%rip), %ebx      # 0xa150
movl 0x7f62(%rip), %ebp      # 0xa148
callq 0x22ea
testl %eax, %eax
je 0x220d
callq 0x2324
testl %eax, %eax
je 0x220d
movl 0x7f5a(%rip), %esi      # 0xa158
movl 0x7f50(%rip), %edx      # 0xa154
leaq 0xa2(%rip), %rdi        # 0x22ad
jmp 0x2279
movl %ebx, 0x7f3d(%rip)      # 0xa150
movl %ebp, 0x7f2f(%rip)      # 0xa148
callq 0x22ea
testl %eax, %eax
je 0x2240
callq 0x2473
testl %eax, %eax
je 0x2240
movl 0x7f27(%rip), %esi      # 0xa158
movl 0x7f1d(%rip), %edx      # 0xa154
leaq 0x7e(%rip), %rdi        # 0x22bc
jmp 0x2279
movl %ebx, 0x7f0a(%rip)      # 0xa150
movl %ebp, 0x7efc(%rip)      # 0xa148
pushq $0x21
popq %rdi
callq 0x1b4e
testl %eax, %eax
je 0x2288
callq 0x1a74
callq 0x2473
testl %eax, %eax
je 0x2288
movl 0x7eec(%rip), %esi      # 0xa158
movl 0x7ee2(%rip), %edx      # 0xa154
leaq 0x5a(%rip), %rdi        # 0x22d3
callq 0x1e04
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl %ebx, 0x7ec2(%rip)      # 0xa150
movl %ebp, 0x7eb4(%rip)      # 0xa148
callq 0x2473
testl %eax, %eax
jne 0x227e
movl %ebx, 0x7ead(%rip)      # 0xa150
movl %ebp, 0x7e9f(%rip)      # 0xa148
xorl %eax, %eax
jmp 0x2281
// File: /workspace/github_c_makefile_star2_O2/macournoyer[P]peg/leg.c
// Function: yy_AND
YY_RULE(int) yy_AND()
{  int yypos0= yypos, yythunkpos0= yythunkpos;
  yyprintf((stderr, "%s\n", "AND"));  if (!yymatchChar('&')) goto l75;  if (!yy__()) goto l75;
  yyprintf((stderr, "  ok   %s @ %s\n", "AND", yybuf+yypos));
  return 1;
  l75:;	  yypos= yypos0; yythunkpos= yythunkpos0;
  yyprintf((stderr, "  fail %s @ %s\n", "AND", yybuf+yypos));
  return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl 0x7e5d(%rip), %ebx      # 0xa150
movl 0x7e4f(%rip), %ebp      # 0xa148
pushq $0x26
popq %rdi
callq 0x1b4e
testl %eax, %eax
je 0x230f
callq 0x1a74
pushq $0x1
popq %rax
jmp 0x231d
movl %ebx, 0x7e3b(%rip)      # 0xa150
movl %ebp, 0x7e2d(%rip)      # 0xa148
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq