LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x826c(%rip), %ebp      # 0xa150
movl 0x825d(%rip), %r14d     # 0xa148
leaq 0x3172(%rip), %rdi      # 0x5064
callq 0x1e64
testl %eax, %eax
je 0x1fdf
movl 0x8253(%rip), %edi      # 0xa158
movl 0x8249(%rip), %esi      # 0xa154
callq 0x1a26
movl 0x8239(%rip), %r15d     # 0xa150
movl %r15d, 0x823a(%rip)     # 0xa158
movl 0x8223(%rip), %r12d     # 0xa148
leaq 0x313b(%rip), %rdi      # 0x5067
callq 0x1e64
testl %eax, %eax
jne 0x1f80
leaq 0x312b(%rip), %rbx      # 0x5067
movl %r15d, 0x820d(%rip)     # 0xa150
movl %r12d, 0x81fe(%rip)     # 0xa148
cmpl 0x81fb(%rip), %r15d     # 0xa14c
jl 0x1f6a
callq 0x1d60
testl %eax, %eax
je 0x1f80
movl 0x81ed(%rip), %r15d     # 0xa150
movl 0x81de(%rip), %r12d     # 0xa148
incl %r15d
movl %r15d, 0x81dc(%rip)     # 0xa150
movq %rbx, %rdi
callq 0x1e64
testl %eax, %eax
je 0x1f3c
movl %r15d, 0x81c9(%rip)     # 0xa150
movl %r12d, 0x81ba(%rip)     # 0xa148
movl 0x81c4(%rip), %edi      # 0xa158
movl 0x81ba(%rip), %esi      # 0xa154
callq 0x1a26
movl 0x81ab(%rip), %eax      # 0xa150
movl %eax, 0x81a9(%rip)      # 0xa154
leaq 0x30b5(%rip), %rdi      # 0x5067
callq 0x1e64
testl %eax, %eax
je 0x1fdf
callq 0x1c2e
movl 0x8192(%rip), %esi      # 0xa158
movl 0x8188(%rip), %edx      # 0xa154
leaq 0xa6(%rip), %rdi        # 0x2079
callq 0x1ff7
movl $0x1, %eax
jmp 0x1fee
movl %ebp, 0x816b(%rip)      # 0xa150
movl %r14d, 0x815c(%rip)     # 0xa148
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movslq 0x8138(%rip), %r15      # 0xa148
movl 0x8119(%rip), %r12d     # 0xa130
movq 0x811a(%rip), %rax      # 0xa138
cmpl %r12d, %r15d
jl 0x2050
addl %r12d, %r12d
movslq %r12d, %r13
leaq (,%r13,8), %rcx
leaq (%rcx,%rcx,2), %rsi
movq %rax, %rdi
callq 0x1110
cmpl %r13d, %r15d
jge 0x2023
movl %r12d, 0x80e7(%rip)     # 0xa130
movq %rax, 0x80e8(%rip)      # 0xa138
leaq (%r15,%r15,2), %rcx
movl %ebp, (%rax,%rcx,8)
movl %ebx, 0x4(%rax,%rcx,8)
movq %r14, 0x8(%rax,%rcx,8)
leal 0x1(%r15), %eax
movl %eax, 0x80de(%rip)      # 0xa148
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x8095(%rip), %ebx      # 0xa150
movl 0x8087(%rip), %ebp      # 0xa148
callq 0x21ad
testl %eax, %eax
je 0x212d
movl 0x8088(%rip), %esi      # 0xa158
movl 0x807e(%rip), %edx      # 0xa154
leaq 0x78(%rip), %rdi        # 0x2155
callq 0x1ff7
callq 0x22a9
testl %eax, %eax
je 0x212d
callq 0x22e7
testl %eax, %eax
je 0x212d
movl 0x805e(%rip), %esi      # 0xa158
movl 0x8054(%rip), %edx      # 0xa154
leaq 0x8c(%rip), %rdi        # 0x2193
callq 0x1ff7
movl 0x803e(%rip), %ebx      # 0xa150
movl 0x8030(%rip), %ebp      # 0xa148
movl $0x3b, %edi
callq 0x1d1b
testl %eax, %eax
je 0x213d
callq 0x1c2e
jmp 0x2149
movl %ebx, 0x801d(%rip)      # 0xa150
movl %ebp, 0x800f(%rip)      # 0xa148
xorl %eax, %eax
jmp 0x214e
movl %ebx, 0x800d(%rip)      # 0xa150
movl %ebp, 0x7fff(%rip)      # 0xa148
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x7f99(%rip), %ebx      # 0xa150
movl 0x7f8b(%rip), %ebp      # 0xa148
movl 0x7f95(%rip), %edi      # 0xa158
movl 0x7f8b(%rip), %esi      # 0xa154
callq 0x1a26
movl 0x7f7c(%rip), %eax      # 0xa150
movl %eax, 0x7f7e(%rip)      # 0xa158
leaq 0x3001(%rip), %rdi      # 0x51e2
callq 0x2253
testl %eax, %eax
je 0x2240
leaq 0x3012(%rip), %rbx      # 0x5203
movl 0x7f59(%rip), %ebp      # 0xa150
movl 0x7f4a(%rip), %r14d     # 0xa148
movq %rbx, %rdi
callq 0x2253
testl %eax, %eax
jne 0x21f1
movl %ebp, 0x7f40(%rip)      # 0xa150
movl %r14d, 0x7f31(%rip)     # 0xa148
movl 0x7f3b(%rip), %edi      # 0xa158
movl 0x7f31(%rip), %esi      # 0xa154
callq 0x1a26
movl 0x7f22(%rip), %eax      # 0xa150
movl %eax, 0x7f20(%rip)      # 0xa154
callq 0x1c2e
movl $0x1, %eax
jmp 0x224e
movl %ebx, 0x7f0a(%rip)      # 0xa150
movl %ebp, 0x7efc(%rip)      # 0xa148
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x7ef3(%rip), %eax      # 0xa150
cmpl 0x7ee9(%rip), %eax      # 0xa14c
jl 0x2274
callq 0x1d60
testl %eax, %eax
je 0x22a5
movl 0x7edc(%rip), %eax      # 0xa150
movq 0x7e9d(%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 0x22a5
incl %eax
movl %eax, 0x7eb2(%rip)      # 0xa150
movl $0x1, %eax
jmp 0x22a7
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x7e9e(%rip), %ebx      # 0xa150
movl 0x7e90(%rip), %ebp      # 0xa148
movl $0x3d, %edi
callq 0x1d1b
testl %eax, %eax
je 0x22d2
callq 0x1c2e
movl $0x1, %eax
jmp 0x22e0
movl %ebx, 0x7e78(%rip)      # 0xa150
movl %ebp, 0x7e6a(%rip)      # 0xa148
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
pushq %rax
movl 0x7e5c(%rip), %ebp      # 0xa150
movl 0x7e4d(%rip), %r15d     # 0xa148
callq 0x23b6
testl %eax, %eax
je 0x2378
movl 0x7e46(%rip), %ebp      # 0xa150
movl 0x7e37(%rip), %r15d     # 0xa148
movl $0x7c, %edi
callq 0x1d1b
movl $0x1, %ebx
testl %eax, %eax
je 0x237a
callq 0x1c2e
callq 0x23b6
testl %eax, %eax
je 0x237a
leaq 0x5b(%rip), %r14        # 0x2394
movl 0x7e19(%rip), %esi      # 0xa158
movl 0x7e0f(%rip), %edx      # 0xa154
movq %r14, %rdi
callq 0x1ff7
movl 0x7dfd(%rip), %ebp      # 0xa150
movl 0x7dee(%rip), %r15d     # 0xa148
movl $0x7c, %edi
callq 0x1d1b
testl %eax, %eax
je 0x237a
callq 0x1c2e
callq 0x23b6
testl %eax, %eax
jne 0x2339
jmp 0x237a
xorl %ebx, %ebx
movl %ebp, 0x7dd0(%rip)      # 0xa150
movl %r15d, 0x7dc1(%rip)     # 0xa148
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/macournoyer[P]peg/leg.c
// Function: yy_sequence
YY_RULE(int) yy_sequence()
{  int yypos0= yypos, yythunkpos0= yythunkpos;
  yyprintf((stderr, "%s\n", "sequence"));  if (!yy_prefix()) goto l82;
  l83:;	
  {  int yypos84= yypos, yythunkpos84= yythunkpos;  if (!yy_prefix()) goto l84;  yyDo(yy_1_sequence, yybegin, yyend);  goto l83;
  l84:;	  yypos= yypos84; yythunkpos= yythunkpos84;
  }
  yyprintf((stderr, "  ok   %s @ %s\n", "sequence", yybuf+yypos));
  return 1;
  l82:;	  yypos= yypos0; yythunkpos= yythunkpos0;
  yyprintf((stderr, "  fail %s @ %s\n", "sequence", yybuf+yypos));
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl 0x7d8d(%rip), %ebp      # 0xa150
movl 0x7d7e(%rip), %r15d     # 0xa148
callq 0x245f
testl %eax, %eax
je 0x2421
movl 0x7d77(%rip), %ebp      # 0xa150
movl 0x7d68(%rip), %r15d     # 0xa148
callq 0x245f
movl $0x1, %ebx
testl %eax, %eax
je 0x2423
leaq 0x48(%rip), %r14        # 0x243d
movl 0x7d5d(%rip), %esi      # 0xa158
movl 0x7d53(%rip), %edx      # 0xa154
movq %r14, %rdi
callq 0x1ff7
movl 0x7d41(%rip), %ebp      # 0xa150
movl 0x7d32(%rip), %r15d     # 0xa148
callq 0x245f
testl %eax, %eax
jne 0x23f5
jmp 0x2423
xorl %ebx, %ebx
movl %ebp, 0x7d27(%rip)      # 0xa150
movl %r15d, 0x7d18(%rip)     # 0xa148
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x7ce8(%rip), %ebx      # 0xa150
movl 0x7cda(%rip), %ebp      # 0xa148
callq 0x257d
testl %eax, %eax
je 0x2495
callq 0x25bb
testl %eax, %eax
je 0x2495
movl 0x7cd2(%rip), %esi      # 0xa158
movl 0x7cc8(%rip), %edx      # 0xa154
leaq 0xad(%rip), %rdi        # 0x2540
jmp 0x2503
movl %ebx, 0x7cb5(%rip)      # 0xa150
movl %ebp, 0x7ca7(%rip)      # 0xa148
callq 0x257d
testl %eax, %eax
je 0x24c8
callq 0x274c
testl %eax, %eax
je 0x24c8
movl 0x7c9f(%rip), %esi      # 0xa158
movl 0x7c95(%rip), %edx      # 0xa154
leaq 0x89(%rip), %rdi        # 0x254f
jmp 0x2503
movl %ebx, 0x7c82(%rip)      # 0xa150
movl %ebp, 0x7c74(%rip)      # 0xa148
movl $0x21, %edi
callq 0x1d1b
testl %eax, %eax
je 0x2514
callq 0x1c2e
callq 0x274c
testl %eax, %eax
je 0x2514
movl 0x7c62(%rip), %esi      # 0xa158
movl 0x7c58(%rip), %edx      # 0xa154
leaq 0x63(%rip), %rdi        # 0x2566
callq 0x1ff7
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl %ebx, 0x7c36(%rip)      # 0xa150
movl %ebp, 0x7c28(%rip)      # 0xa148
callq 0x274c
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
jne 0x250d
movl %ebx, 0x7c1a(%rip)      # 0xa150
movl %ebp, 0x7c0c(%rip)      # 0xa148
xorl %eax, %eax
jmp 0x250d
// File: /workspace/github_c_makefile_star2_O3/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 0x7bca(%rip), %ebx      # 0xa150
movl 0x7bbc(%rip), %ebp      # 0xa148
movl $0x26, %edi
callq 0x1d1b
testl %eax, %eax
je 0x25a6
callq 0x1c2e
movl $0x1, %eax
jmp 0x25b4
movl %ebx, 0x7ba4(%rip)      # 0xa150
movl %ebp, 0x7b96(%rip)      # 0xa148
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/macournoyer[P]peg/leg.c
// Function: yy_action
YY_RULE(int) yy_action()
{  int yypos0= yypos, yythunkpos0= yythunkpos;
  yyprintf((stderr, "%s\n", "action"));  if (!yymatchChar('{')) goto l72;  yyText(yybegin, yyend);  if (!(YY_BEGIN)) goto l72;
  l73:;	
  {  int yypos74= yypos, yythunkpos74= yythunkpos;  if (!yy_braces()) goto l74;  goto l73;
  l74:;	  yypos= yypos74; yythunkpos= yythunkpos74;
  }  yyText(yybegin, yyend);  if (!(YY_END)) goto l72;  if (!yymatchChar('}')) goto l72;  if (!yy__()) goto l72;
  yyprintf((stderr, "  ok   %s @ %s\n", "action", yybuf+yypos));
  return 1;
  l72:;	  yypos= yypos0; yythunkpos= yythunkpos0;
  yyprintf((stderr, "  fail %s @ %s\n", "action", yybuf+yypos));
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x7b84(%rip), %ebx      # 0xa150
movl 0x7b76(%rip), %ebp      # 0xa148
movl $0x7b, %edi
callq 0x1d1b
testl %eax, %eax
je 0x272f
movl 0x7b6e(%rip), %edi      # 0xa158
movl 0x7b64(%rip), %esi      # 0xa154
callq 0x1a26
movl 0x7b55(%rip), %ecx      # 0xa150
movl %ecx, 0x7b57(%rip)      # 0xa158
movl %ecx, %r14d
movl 0x7b3d(%rip), %r15d     # 0xa148
movl $0x7b, %edi
callq 0x1d1b
testl %eax, %eax
je 0x2695
movl 0x7b30(%rip), %r12d     # 0xa150
movl 0x7b21(%rip), %r13d     # 0xa148
movl $0x7d, %edi
callq 0x1d1b
testl %eax, %eax
jne 0x266f
movl %r12d, 0x7b14(%rip)     # 0xa150
movl %r13d, 0x7b05(%rip)     # 0xa148
cmpl 0x7b02(%rip), %r12d     # 0xa14c
jl 0x2663
callq 0x1d60
testl %eax, %eax
je 0x266f
movl 0x7af4(%rip), %r12d     # 0xa150
movl 0x7ae5(%rip), %r13d     # 0xa148
incl %r12d
movl %r12d, 0x7ae3(%rip)     # 0xa150
jmp 0x2627
movl %r12d, 0x7ada(%rip)     # 0xa150
movl %r13d, 0x7acb(%rip)     # 0xa148
movl $0x7d, %edi
callq 0x1d1b
movl 0x7ac3(%rip), %ecx      # 0xa150
testl %eax, %eax
jne 0x2601
movl %r14d, 0x7ab4(%rip)     # 0xa150
movl %r15d, 0x7aa5(%rip)     # 0xa148
movl $0x7d, %edi
callq 0x1d1b
testl %eax, %eax
jne 0x26ea
movl %r14d, 0x7a98(%rip)     # 0xa150
movl %r15d, 0x7a89(%rip)     # 0xa148
cmpl 0x7a86(%rip), %r14d     # 0xa14c
jl 0x26d8
callq 0x1d60
testl %eax, %eax
je 0x26ea
movl 0x7a78(%rip), %r14d     # 0xa150
incl %r14d
movl %r14d, 0x7a6e(%rip)     # 0xa150
movl %r14d, %ecx
jmp 0x2601
movl %r14d, 0x7a5f(%rip)     # 0xa150
movl %r15d, 0x7a50(%rip)     # 0xa148
movl 0x7a5a(%rip), %edi      # 0xa158
movl 0x7a50(%rip), %esi      # 0xa154
callq 0x1a26
movl 0x7a41(%rip), %eax      # 0xa150
movl %eax, 0x7a3f(%rip)      # 0xa154
movl $0x7d, %edi
callq 0x1d1b
testl %eax, %eax
je 0x272f
callq 0x1c2e
movl $0x1, %eax
jmp 0x273d
movl %ebx, 0x7a1b(%rip)      # 0xa150
movl %ebp, 0x7a0d(%rip)      # 0xa148
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/macournoyer[P]peg/leg.c
// Function: yy_BEGIN
YY_RULE(int) yy_BEGIN()
{  int yypos0= yypos, yythunkpos0= yythunkpos;
  yyprintf((stderr, "%s\n", "BEGIN"));  if (!yymatchChar('<')) goto l32;  if (!yy__()) goto l32;
  yyprintf((stderr, "  ok   %s @ %s\n", "BEGIN", yybuf+yypos));
  return 1;
  l32:;	  yypos= yypos0; yythunkpos= yythunkpos0;
  yyprintf((stderr, "  fail %s @ %s\n", "BEGIN", yybuf+yypos));
  return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl 0x7295(%rip), %ebx      # 0xa150
movl 0x7287(%rip), %ebp      # 0xa148
movl $0x3c, %edi
callq 0x1d1b
testl %eax, %eax
je 0x2edb
callq 0x1c2e
movl $0x1, %eax
jmp 0x2ee9
movl %ebx, 0x726f(%rip)      # 0xa150
movl %ebp, 0x7261(%rip)      # 0xa148
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/macournoyer[P]peg/leg.c
// Function: yy_END
YY_RULE(int) yy_END()
{  int yypos0= yypos, yythunkpos0= yythunkpos;
  yyprintf((stderr, "%s\n", "END"));  if (!yymatchChar('>')) goto l31;  if (!yy__()) goto l31;
  yyprintf((stderr, "  ok   %s @ %s\n", "END", yybuf+yypos));
  return 1;
  l31:;	  yypos= yypos0; yythunkpos= yythunkpos0;
  yyprintf((stderr, "  fail %s @ %s\n", "END", yybuf+yypos));
  return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl 0x7257(%rip), %ebx      # 0xa150
movl 0x7249(%rip), %ebp      # 0xa148
movl $0x3e, %edi
callq 0x1d1b
testl %eax, %eax
je 0x2f19
callq 0x1c2e
movl $0x1, %eax
jmp 0x2f27
movl %ebx, 0x7231(%rip)      # 0xa150
movl %ebp, 0x7223(%rip)      # 0xa148
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/macournoyer[P]peg/tree.c
// Function: makeRule
Node *makeRule(char *name)
{
  Node *node= newNode(Rule);
  node->rule.name= strdup(name);
  node->rule.id= ++ruleCount;
  node->rule.flags= 0;
  node->rule.next= rules;
  rules= node;
  return node;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %edi
movl $0x30, %esi
callq 0x10a0
movq %rax, %r14
movl $0x1, (%rax)
movq %rbx, %rdi
callq 0x1190
movq %rax, 0x10(%r14)
movl 0x724b(%rip), %eax      # 0xa1bc
incl %eax
movl %eax, 0x7243(%rip)      # 0xa1bc
movl %eax, 0x28(%r14)
movq 0x7214(%rip), %rax      # 0xa198
movq %rax, 0x8(%r14)
movq %r14, 0x7209(%rip)      # 0xa198
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/macournoyer[P]peg/tree.c
// Function: findRule
Node *findRule(char *name)
{
  Node *n;
  char *ptr;
  for (ptr= name;  *ptr;  ptr++) if ('-' == *ptr) *ptr= '_';
  for (n= rules;  n;  n= n->any.next)
    {
      assert(Rule == n->type);
      if (!strcmp(name, n->rule.name))
	return n;
    }
  return makeRule(name);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rdi, %rax
movzbl (%rax), %ecx
cmpl $0x2d, %ecx
je 0x2fb2
testl %ecx, %ecx
jne 0x2fb5
jmp 0x2fba
movb $0x5f, (%rax)
incq %rax
jmp 0x2fa4
movq 0x71d7(%rip), %r14      # 0xa198
testq %r14, %r14
je 0x2fe2
cmpl $0x1, (%r14)
jne 0x2ffc
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0x10b0
testl %eax, %eax
je 0x2ff1
movq 0x8(%r14), %r14
jmp 0x2fc1
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2f40
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x2309(%rip), %rdi      # 0x530c
leaq 0x2312(%rip), %rsi      # 0x531c
leaq 0x2312(%rip), %rcx      # 0x5323
movl $0x40, %edx
callq 0x1060
// File: /workspace/github_c_makefile_star2_O3/macournoyer[P]peg/tree.c
// Function: Rule_setExpression
void Rule_setExpression(Node *node, Node *expression)
{
  assert(node);
#ifdef DEBUG
  Node_print(node);  fprintf(stderr, " [%d]<- ", node->type);  Node_print(expression);  fprintf(stderr, "\n");
#endif
  assert(Rule == node->type);
  node->rule.expression= expression;
  if (!start || !strcmp(node->rule.name, "start"))
    start= node;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x3069
movq %rdi, %rbx
cmpl $0x1, (%rdi)
jne 0x3088
movq %rsi, 0x20(%rbx)
cmpq $0x0, 0x715e(%rip)      # 0xa1a8
je 0x3060
movq 0x10(%rbx), %rdi
leaq 0x2323(%rip), %rsi      # 0x537a
callq 0x10b0
testl %eax, %eax
jne 0x3067
movq %rbx, 0x7141(%rip)      # 0xa1a8
popq %rbx
retq
leaq 0x22ca(%rip), %rdi      # 0x533a
leaq 0x22a5(%rip), %rsi      # 0x531c
leaq 0x22c1(%rip), %rcx      # 0x533f
movl $0x4f, %edx
callq 0x1060
leaq 0x22d8(%rip), %rdi      # 0x5367
leaq 0x2286(%rip), %rsi      # 0x531c
leaq 0x22a2(%rip), %rcx      # 0x533f
movl $0x53, %edx
callq 0x1060
// File: /workspace/github_c_makefile_star2_O3/macournoyer[P]peg/tree.c
// Function: makeVariable
Node *makeVariable(char *name)
{
  Node *node;
  assert(thisRule);
  for (node= thisRule->rule.variables;  node;  node= node->variable.next)
    if (!strcmp(name, node->variable.name))
      return node;
  node= newNode(Variable);
  node->variable.name= strdup(name);
  node->variable.next= thisRule->rule.variables;
  thisRule->rule.variables= node;
  return node;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x70ea(%rip), %r15      # 0xa1a0
testq %r15, %r15
je 0x311e
movq %rdi, %rbx
movq 0x18(%r15), %r12
testq %r12, %r12
je 0x30e3
movq %r12, %r14
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0x10b0
testl %eax, %eax
je 0x310f
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0x30ca
movl $0x1, %edi
movl $0x28, %esi
callq 0x10a0
movq %rax, %r14
movl $0x2, (%rax)
movq %rbx, %rdi
callq 0x1190
movq %rax, 0x10(%r14)
movq %r12, 0x8(%r14)
movq %r14, 0x18(%r15)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x225b(%rip), %rdi      # 0x5380
leaq 0x21f0(%rip), %rsi      # 0x531c
leaq 0x2256(%rip), %rcx      # 0x5389
movl $0x5c, %edx
callq 0x1060
// File: /workspace/github_c_makefile_star2_O3/macournoyer[P]peg/tree.c
// Function: makeName
Node *makeName(Node *rule)
{
  Node *node= newNode(Name);
  node->name.rule= rule;
  node->name.variable= 0;
  rule->rule.flags |= RuleUsed;
  return node;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %edi
movl $0x20, %esi
callq 0x10a0
movl $0x3, (%rax)
movq %rbx, 0x10(%rax)
orb $0x1, 0x2c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/macournoyer[P]peg/tree.c
// Function: makeAction
Node *makeAction(char *text)
{
  Node *node= newNode(Action);
  char name[1024];
  assert(thisRule);
  sprintf(name, "_%d_%s", ++actionCount, thisRule->rule.name);
  node->action.name= strdup(name);
  node->action.text= strdup(text);
  node->action.list= actions;
  node->action.rule= thisRule;
  actions= node;
  {
    char *ptr;
    for (ptr= node->action.text;  *ptr;  ++ptr)
      if ('$' == ptr[0] && '$' == ptr[1])
	ptr[1]= ptr[0]= 'y';
  }
  return node;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
movq %rdi, %r14
movl $0x1, %edi
movl $0x30, %esi
callq 0x10a0
movq %rax, %rbx
movl $0x8, (%rax)
movq 0x6f58(%rip), %rax      # 0xa1a0
testq %rax, %rax
je 0x32db
movl 0x6f61(%rip), %edx      # 0xa1b8
incl %edx
movl %edx, 0x6f59(%rip)      # 0xa1b8
movq 0x10(%rax), %rcx
leaq 0x2153(%rip), %rsi      # 0x53bd
movq %rsp, %r15
movq %r15, %rdi
xorl %eax, %eax
callq 0x1160
movq %r15, %rdi
callq 0x1190
movq %rax, 0x20(%rbx)
movq %r14, %rdi
callq 0x1190
movq %rax, 0x10(%rbx)
movq 0x6efa(%rip), %rcx      # 0xa190
movq %rcx, 0x18(%rbx)
movq 0x6eff(%rip), %rcx      # 0xa1a0
movq %rcx, 0x28(%rbx)
movq %rbx, 0x6ee4(%rip)      # 0xa190
incq %rax
movzbl -0x1(%rax), %ecx
cmpl $0x24, %ecx
je 0x32be
testl %ecx, %ecx
jne 0x32ac
jmp 0x32cb
cmpb $0x24, (%rax)
jne 0x32ac
movw $0x7979, -0x1(%rax)     # imm = 0x7979
jmp 0x32ac
movq %rbx, %rax
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r14
popq %r15
retq
leaq 0x209e(%rip), %rdi      # 0x5380
leaq 0x2033(%rip), %rsi      # 0x531c
leaq 0x20b4(%rip), %rcx      # 0x53a4
movl $0x8e, %edx
callq 0x1060
// File: /workspace/github_c_makefile_star2_O3/macournoyer[P]peg/tree.c
// Function: makeAlternate
Node *makeAlternate(Node *e)
{
  if (Alternate != e->type)
    {
      Node *node= newNode(Alternate);
      assert(e);
      assert(!e->any.next);
      node->alternate.first=
	node->alternate.last= e;
      return node;
    }
  return e;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0xa, (%rdi)
je 0x3360
movl $0x1, %edi
movl $0x20, %esi
callq 0x10a0
movl $0xa, (%rax)
cmpq $0x0, 0x8(%rbx)
jne 0x3365
movq %rbx, 0x18(%rax)
movq %rbx, 0x10(%rax)
movq %rax, %rbx
movq %rbx, %rax
popq %rbx
retq
leaq 0x2074(%rip), %rdi      # 0x53e0
leaq 0x1fa9(%rip), %rsi      # 0x531c
leaq 0x204a(%rip), %rcx      # 0x53c4
movl $0xab, %edx
callq 0x1060
// File: /workspace/github_c_makefile_star2_O3/macournoyer[P]peg/tree.c
// Function: Alternate_append
Node *Alternate_append(Node *a, Node *e)
{
  assert(a);
  a= makeAlternate(a);
  assert(a->alternate.last);
  assert(e);
  a->alternate.last->any.next= e;
  a->alternate.last= e;
  return a;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x33aa
movq %rsi, %rbx
callq 0x3330
movq 0x18(%rax), %rcx
testq %rcx, %rcx
je 0x33c9
testq %rbx, %rbx
je 0x33e8
movq %rbx, 0x8(%rcx)
movq %rbx, 0x18(%rax)
popq %rbx
retq
leaq 0x203c(%rip), %rdi      # 0x53ed
leaq 0x1f64(%rip), %rsi      # 0x531c
leaq 0x2030(%rip), %rcx      # 0x53ef
movl $0xb5, %edx
callq 0x1060
leaq 0x2046(%rip), %rdi      # 0x5416
leaq 0x1f45(%rip), %rsi      # 0x531c
leaq 0x2011(%rip), %rcx      # 0x53ef
movl $0xb7, %edx
callq 0x1060
leaq 0x1f4e(%rip), %rdi      # 0x533d
leaq 0x1f26(%rip), %rsi      # 0x531c
leaq 0x1ff2(%rip), %rcx      # 0x53ef
movl $0xb8, %edx
callq 0x1060
// File: /workspace/github_c_makefile_star2_O3/macournoyer[P]peg/tree.c
// Function: makeSequence
Node *makeSequence(Node *e)
{
  if (Sequence != e->type)
    {
      Node *node= newNode(Sequence);
      assert(e);
      assert(!e->any.next);
      node->sequence.first=
	node->sequence.last= e;
      return node;
    }
  return e;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0xb, (%rdi)
je 0x3437
movl $0x1, %edi
movl $0x20, %esi
callq 0x10a0
movl $0xb, (%rax)
cmpq $0x0, 0x8(%rbx)
jne 0x343c
movq %rbx, 0x18(%rax)
movq %rbx, 0x10(%rax)
movq %rax, %rbx
movq %rbx, %rax
popq %rbx
retq
leaq 0x1f9d(%rip), %rdi      # 0x53e0
leaq 0x1ed2(%rip), %rsi      # 0x531c
leaq 0x1fd7(%rip), %rcx      # 0x5428
movl $0xc4, %edx
callq 0x1060
// File: /workspace/github_c_makefile_star2_O3/macournoyer[P]peg/tree.c
// Function: Sequence_append
Node *Sequence_append(Node *a, Node *e)
{
  assert(a);
  a= makeSequence(a);
  assert(a->sequence.last);
  assert(e);
  a->sequence.last->any.next= e;
  a->sequence.last= e;
  return a;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x3481
movq %rsi, %rbx
callq 0x3407
movq 0x18(%rax), %rcx
testq %rcx, %rcx
je 0x34a0
testq %rbx, %rbx
je 0x34bf
movq %rbx, 0x8(%rcx)
movq %rbx, 0x18(%rax)
popq %rbx
retq
leaq 0x1f65(%rip), %rdi      # 0x53ed
leaq 0x1e8d(%rip), %rsi      # 0x531c
leaq 0x1fad(%rip), %rcx      # 0x5443
movl $0xce, %edx
callq 0x1060
leaq 0x1fc2(%rip), %rdi      # 0x5469
leaq 0x1e6e(%rip), %rsi      # 0x531c
leaq 0x1f8e(%rip), %rcx      # 0x5443
movl $0xd0, %edx
callq 0x1060
leaq 0x1e77(%rip), %rdi      # 0x533d
leaq 0x1e4f(%rip), %rsi      # 0x531c
leaq 0x1f6f(%rip), %rcx      # 0x5443
movl $0xd1, %edx
callq 0x1060
// File: /workspace/github_c_makefile_star2_O3/macournoyer[P]peg/tree.c
// Function: push
Node *push(Node *node)
{
  assert(node);
  assert(stackPointer < stack + 1023);
#ifdef DEBUG
  dumpStack();  fprintf(stderr, " PUSH ");  Node_print(node);  fprintf(stderr, "\n");
#endif
  return *++stackPointer= node;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x35a6
movq 0x6b6a(%rip), %rax      # 0xa0f0
leaq 0x8c2b(%rip), %rcx      # 0xc1b8
cmpq %rcx, %rax
jae 0x35c5
leaq 0x8(%rax), %rcx
movq %rcx, 0x6b53(%rip)      # 0xa0f0
movq %rdi, 0x8(%rax)
movq %rdi, %rax
popq %rcx
retq
leaq 0x1d8d(%rip), %rdi      # 0x533a
leaq 0x1d68(%rip), %rsi      # 0x531c
leaq 0x1ebf(%rip), %rcx      # 0x547a
movl $0x10e, %edx            # imm = 0x10E
callq 0x1060
leaq 0x1ec1(%rip), %rdi      # 0x548d
leaq 0x1d49(%rip), %rsi      # 0x531c
leaq 0x1ea0(%rip), %rcx      # 0x547a
movl $0x10f, %edx            # imm = 0x10F
callq 0x1060
// File: /workspace/github_c_makefile_star2_O3/macournoyer[P]peg/compile.c
// Function: Rule_compile_c_header
void Rule_compile_c_header(void)
{
  fprintf(output, "/* A recursive-descent parser generated by peg %d.%d.%d */\n", PEG_MAJOR, PEG_MINOR, PEG_LEVEL);
  fprintf(output, "\n");
  fprintf(output, "%s", header);
  fprintf(output, "#define YYRULECOUNT %d\n", ruleCount);
}

// Assembly:
pushq %rbx
leaq 0x68f4(%rip), %rbx      # 0xa1b0
movq (%rbx), %rdi
leaq 0x1d6e(%rip), %rsi      # 0x5634
xorl %edx, %edx
movl $0x1, %ecx
movl $0x2, %r8d
xorl %eax, %eax
callq 0x10c0
movq (%rbx), %rsi
movl $0xa, %edi
callq 0x1090
movq (%rbx), %rsi
leaq 0x1e8b(%rip), %rdi      # 0x577c
callq 0x1070
movq (%rbx), %rdi
leaq 0x68bc(%rip), %rax      # 0xa1bc
movl (%rax), %edx
leaq 0x1d67(%rip), %rsi      # 0x5670
xorl %eax, %eax
popq %rbx
jmp 0x10c0
// File: /workspace/github_c_makefile_star2_O3/macournoyer[P]peg/compile.c
// Function: consumesInput
int consumesInput(Node *node)
{
  if (!node) return 0;

  switch (node->type)
    {
    case Rule:
      {
	int result= 0;
	if (RuleReached & node->rule.flags)
	  fprintf(stderr, "possible infinite left recursion in rule '%s'\n", node->rule.name);
	else
	  {
	    node->rule.flags |= RuleReached;
	    result= consumesInput(node->rule.expression);
	    node->rule.flags &= ~RuleReached;
	  }
	return result;
      }
      break;

    case Dot:		return 1;
    case Name:		return consumesInput(node->name.rule);
    case Character:
    case String:	return strlen(node->string.value) > 0;
    case Class:		return 1;
    case Action:	return 0;
    case Predicate:	return 0;

    case Alternate:
      {
	Node *n;
	for (n= node->alternate.first;  n;  n= n->alternate.next)
	  if (!consumesInput(n))
	    return 0;
      }
      return 1;

    case Sequence:
      {
	Node *n;
	for (n= node->alternate.first;  n;  n= n->alternate.next)
	  if (consumesInput(n))
	    return 1;
      }
      return 0;

    case PeekFor:	return 0;
    case PeekNot:	return 0;
    case Query:		return 0;
    case Star:		return 0;
    case Plus:		return consumesInput(node->plus.element);

    default:
      fprintf(stderr, "\nconsumesInput: illegal node type %d\n", node->type);
      exit(1);
    }
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x39b5
movq %rdi, %r14
leaq 0x1c4e(%rip), %rax      # 0x5578
movl (%r14), %edi
leal -0x1(%rdi), %ecx
cmpl $0xf, %ecx
ja 0x39c9
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq 0x10(%r14), %r14
testq %r14, %r14
jne 0x392a
jmp 0x39b5
movq 0x10(%r14), %rax
xorl %ebx, %ebx
cmpb $0x0, (%rax)
setne %bl
jmp 0x39b5
movq 0x10(%r14), %r14
testq %r14, %r14
je 0x39b0
movq %r14, %rdi
callq 0x3911
testl %eax, %eax
je 0x39b5
movq 0x8(%r14), %r14
jmp 0x395f
movl 0x2c(%r14), %eax
testb $0x2, %al
jne 0x39bf
orl $0x2, %eax
movl %eax, 0x2c(%r14)
movq 0x20(%r14), %rdi
callq 0x3911
andb $-0x3, 0x2c(%r14)
jmp 0x39b7
movq 0x10(%r14), %r14
testq %r14, %r14
je 0x39b5
movq %r14, %rdi
callq 0x3911
testl %eax, %eax
jne 0x39b0
movq 0x8(%r14), %r14
jmp 0x3999
movl $0x1, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
callq 0x1343
jmp 0x39b5
callq 0x1362
// File: /workspace/github_c_makefile_star2_O3/chatziko-k08[P]lecture-code/tests/ADTVector_test.c
// Function: test_create
void test_create(void) {
	Vector vec = vector_create(0, NULL);
	Vector vec2 = vector_create(10, NULL);	// 10 αρχικά στοιχεία

	vector_set_destroy_value(vec, NULL);
	vector_set_destroy_value(vec2, NULL);

	TEST_ASSERT(vector_size(vec) == 0);
	TEST_ASSERT(vector_size(vec2) == 10);

	vector_destroy(vec);
	vector_destroy(vec2);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
xorl %edi, %edi
xorl %esi, %esi
callq 0x4a9c
movq %rax, %rbx
movl $0xa, %edi
xorl %esi, %esi
callq 0x4a9c
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
callq 0x4c80
movq %r14, %rdi
xorl %esi, %esi
callq 0x4c80
movq %rbx, %rdi
callq 0x4adc
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0x162a(%rip), %rsi      # 0x5318
leaq 0x190e(%rip), %rcx      # 0x5603
leaq 0x162d(%rip), %r8       # 0x5329
movl $0x14, %edx
xorl %eax, %eax
callq 0x25cc
testl %eax, %eax
je 0x3d59
movq %r14, %rdi
callq 0x4adc
xorl %edi, %edi
cmpl $0xa, %eax
sete %dil
leaq 0x15f4(%rip), %rsi      # 0x5318
leaq 0x18d8(%rip), %rcx      # 0x5603
leaq 0x160d(%rip), %r8       # 0x533f
movl $0x15, %edx
xorl %eax, %eax
callq 0x25cc
testl %eax, %eax
je 0x3d59
movq %rbx, %rdi
callq 0x4c89
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4c89
callq 0x2e2b
// File: /workspace/github_c_makefile_star2_O3/chatziko-k08[P]lecture-code/tests/ADTVector_test.c
// Function: test_insert_last
void test_insert_last(void) {
	Vector vec = vector_create(0, NULL);
	int N = 1000;
	int* array = malloc(N * sizeof(*array));		// Στο vector θα προσθέσουμε pointers προς τα στοιχεία αυτού του πίνακα

	// insert 1000 στοιχεία ώστε να συμβούν πολλαπλά resizes
	for (int i = 0; i < 1000; i++) {
		vector_insert_last(vec, &array[i]);
		TEST_ASSERT(vector_size(vec) == i+1);		// Το size ενημερώθηκε;
		TEST_ASSERT(vector_get_at(vec, i) == &array[i]);	// Μπορούμε να κάνουμε at το στοιχείο που μόλις βάλαμε;
	}

	// Δοκιμή ότι μετά τα resizes τα στοιχεία είναι ακόμα προσπελάσιμα
	for (int i = 0; i < 1000; i++)
		TEST_ASSERT(vector_get_at(vec, i) == &array[i]);

	vector_destroy(vec);
	free(array);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
xorl %edi, %edi
xorl %esi, %esi
callq 0x4a9c
movq %rax, 0x8(%rsp)
movl $0xfa0, %edi            # imm = 0xFA0
callq 0x21a0
movq %rax, (%rsp)
leaq 0x1589(%rip), %r12      # 0x5318
leaq 0x186d(%rip), %rbx      # 0x5603
xorl %r14d, %r14d
xorl %r13d, %r13d
movq 0x8(%rsp), %r15
cmpq $0xfa0, %r14            # imm = 0xFA0
je 0x3e3d
movq (%rsp), %rax
leaq (%rax,%r14), %rbp
movq %r15, %rdi
movq %rbp, %rsi
callq 0x4b6d
movq %r15, %rdi
callq 0x4adc
leaq 0x1(%r13), %rcx
movl %eax, %eax
xorl %edi, %edi
movq %rcx, 0x10(%rsp)
cmpq %rax, %rcx
sete %dil
movq %r12, %rsi
movl $0x23, %edx
movq %rbx, %rcx
leaq 0x1568(%rip), %r8       # 0x5357
xorl %eax, %eax
callq 0x25cc
testl %eax, %eax
je 0x3e38
movq %r15, %rdi
movl %r13d, %esi
callq 0x4ae0
xorl %edi, %edi
cmpq %rax, %rbp
sete %dil
movq %r12, %rsi
movl $0x24, %edx
movq %rbx, %rcx
leaq 0x154f(%rip), %r8       # 0x536f
xorl %eax, %eax
callq 0x25cc
addq $0x4, %r14
movq 0x10(%rsp), %r13
testl %eax, %eax
jne 0x3da1
callq 0x2e2b
leaq 0x14d4(%rip), %r15      # 0x5318
leaq 0x17b8(%rip), %r12      # 0x5603
leaq 0x151d(%rip), %r13      # 0x536f
movq (%rsp), %r14
xorl %ebp, %ebp
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x4ae0
xorl %edi, %edi
cmpq %rax, %r14
sete %dil
movq %r15, %rsi
movl $0x29, %edx
movq %r12, %rcx
movq %r13, %r8
xorl %eax, %eax
callq 0x25cc
testl %eax, %eax
je 0x3e38
incq %rbp
addq $0x4, %r14
cmpq $0x3e8, %rbp            # imm = 0x3E8
jne 0x3e5d
movq %rbx, %rdi
callq 0x4c89
movq (%rsp), %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x22a0
// File: /workspace/github_c_makefile_star2_O3/chatziko-k08[P]lecture-code/tests/ADTVector_test.c
// Function: test_remove_last
void test_remove_last(void) {
	Vector vec = vector_create(1000, NULL);
	int N = 1000;
	int* array = malloc(N * sizeof(*array));

	// replace για προσθήκη δεδομένων, χωρίς ελέγχους (έχουμε ξεχωριστό test για το replace)
	for (int i = 0; i < 1000; i++)
		vector_set_at(vec, i, &array[i]);

	// Διαδοχικά remove ώστε να συμβούν και resizes
	for (int i = 999; i >= 0; i--) {
		TEST_ASSERT(vector_get_at(vec, i) == &array[i]);
		vector_remove_last(vec);
		TEST_ASSERT(vector_size(vec) == i);
	}

	vector_destroy(vec);
	free(array);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %r14d, %r14d
movl $0x3e8, %edi            # imm = 0x3E8
xorl %esi, %esi
callq 0x4a9c
movq %rax, %rbx
movl $0xfa0, %edi            # imm = 0xFA0
callq 0x21a0
movq %rax, %rbp
movq %rax, %r15
movq %rbx, %rdi
movl %r14d, %esi
movq %r15, %rdx
callq 0x4b13
incq %r14
addq $0x4, %r15
cmpq $0x3e8, %r14            # imm = 0x3E8
jne 0x3ee5
movq %rbp, (%rsp)
addq $0xf9c, %rbp            # imm = 0xF9C
movl $0x3e7, %r15d           # imm = 0x3E7
leaq 0x13fd(%rip), %r12      # 0x5318
leaq 0x16e1(%rip), %r13      # 0x5603
leaq 0x1469(%rip), %r14      # 0x5392
movq %rbx, %rdi
movl %r15d, %esi
callq 0x4ae0
xorl %edi, %edi
cmpq %rax, %rbp
sete %dil
movq %r12, %rsi
movl $0x3a, %edx
movq %r13, %rcx
leaq 0x1420(%rip), %r8       # 0x536f
xorl %eax, %eax
callq 0x25cc
testl %eax, %eax
je 0x3fb7
movq %rbx, %rdi
callq 0x4bb1
movq %rbx, %rdi
callq 0x4adc
movl %eax, %eax
xorl %edi, %edi
cmpq %rax, %r15
sete %dil
movq %r12, %rsi
movl $0x3c, %edx
movq %r13, %rcx
movq %r14, %r8
xorl %eax, %eax
callq 0x25cc
testl %eax, %eax
je 0x3fb7
addq $-0x4, %rbp
addq $-0x1, %r15
jb 0x3f29
movq %rbx, %rdi
callq 0x4c89
movq (%rsp), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x22a0
callq 0x2e2b
// File: /workspace/github_c_makefile_star2_O3/chatziko-k08[P]lecture-code/tests/ADTVector_test.c
// Function: test_get_set_at
void test_get_set_at(void) {
	int N = 1000;
	Vector vec = vector_create(N/2, NULL);		// αρχικοποίηση με N/2 NULLs
	TEST_ASSERT(vector_size(vec) == N/2);

	// insert επιπλέον N/2 NULLs, θα τα αλλάξουμε μετά με replace
	for (int i = 0; i < N/2; i++)
		vector_insert_last(vec, NULL);

	int* array = malloc(N * sizeof(*array));
	for (int i = 0; i < N; i++) {
		TEST_ASSERT(vector_get_at(vec, i) == NULL);
		vector_set_at(vec, i, &array[i]);
		TEST_ASSERT(vector_get_at(vec, i) == &array[i]);
	}

	vector_destroy(vec);
	free(array);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl $0x1f4, %ebp            # imm = 0x1F4
movl $0x1f4, %edi            # imm = 0x1F4
xorl %esi, %esi
callq 0x4a9c
movq %rax, %rbx
movq %rax, %rdi
callq 0x4adc
xorl %edi, %edi
cmpl $0x1f4, %eax            # imm = 0x1F4
sete %dil
leaq 0x1323(%rip), %rsi      # 0x5318
leaq 0x1607(%rip), %rcx      # 0x5603
leaq 0x13a5(%rip), %r8       # 0x53a8
movl $0x46, %edx
xorl %eax, %eax
callq 0x25cc
testl %eax, %eax
je 0x40e9
movq %rbx, %rdi
xorl %esi, %esi
callq 0x4b6d
decl %ebp
jne 0x4017
movl $0xfa0, %edi            # imm = 0xFA0
callq 0x21a0
movq %rax, %r14
leaq 0x12df(%rip), %r15      # 0x5318
leaq 0x15c3(%rip), %r12      # 0x5603
leaq 0x1328(%rip), %rbp      # 0x536f
movq %rax, (%rsp)
xorl %r13d, %r13d
movq %rbx, %rdi
movl %r13d, %esi
callq 0x4ae0
xorl %edi, %edi
testq %rax, %rax
sete %dil
movq %r15, %rsi
movl $0x4e, %edx
movq %r12, %rcx
leaq 0x134c(%rip), %r8       # 0x53c0
xorl %eax, %eax
callq 0x25cc
testl %eax, %eax
je 0x40e9
movq %rbx, %rdi
movl %r13d, %esi
movq %r14, %rdx
callq 0x4b13
movq %rbx, %rdi
movl %r13d, %esi
callq 0x4ae0
xorl %edi, %edi
cmpq %rax, %r14
sete %dil
movq %r15, %rsi
movl $0x50, %edx
movq %r12, %rcx
movq %rbp, %r8
xorl %eax, %eax
callq 0x25cc
testl %eax, %eax
je 0x40e9
incq %r13
addq $0x4, %r14
cmpq $0x3e8, %r13            # imm = 0x3E8
jne 0x404e
movq %rbx, %rdi
callq 0x4c89
movq (%rsp), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x22a0
callq 0x2e2b
// File: /workspace/github_c_makefile_star2_O3/chatziko-k08[P]lecture-code/tests/ADTVector_test.c
// Function: test_find
void test_find(void) {
	Vector vec = vector_create(1000, NULL);
	int N = 1000;
	int* array = malloc(N * sizeof(*array));

	// replace για προσθήκη δεδομένων
	for (int i = 0; i < 1000; i++) {
		array[i] = i;
		vector_set_at(vec, i, &array[i]);
	}

	for (int i = 0; i < 1000; i++) {
		int* p = vector_find(vec, &i, compare_ints);
		TEST_ASSERT(*p == i);

		VectorNode node = vector_find_node(vec, &i, compare_ints);
		TEST_ASSERT(*(int*)vector_node_value(vec, node) == i);
	}

	int not_exists = -12;
	TEST_ASSERT(vector_find(vec, &not_exists, compare_ints) == NULL);
	TEST_ASSERT(vector_find_node(vec, &not_exists, compare_ints) == VECTOR_EOF);

	vector_destroy(vec);
	free(array);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
xorl %r14d, %r14d
movl $0x3e8, %edi            # imm = 0x3E8
xorl %esi, %esi
callq 0x4a9c
movq %rax, %rbx
movl $0xfa0, %edi            # imm = 0xFA0
callq 0x21a0
movq %rax, %r15
movq %rax, 0x10(%rsp)
movl %r14d, (%r15)
movq %rbx, %rdi
movl %r14d, %esi
movq %r15, %rdx
callq 0x4b13
incq %r14
addq $0x4, %r15
cmpq $0x3e8, %r14            # imm = 0x3E8
jne 0x4352
leaq 0x8(%rsp), %r15
movl $0x0, (%r15)
leaq -0x6b(%rip), %r12       # 0x431b
leaq 0xf8b(%rip), %r13       # 0x5318
leaq 0x126f(%rip), %rbp      # 0x5603
leaq 0x10f0(%rip), %r14      # 0x548b
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x4c2c
movl (%rax), %eax
xorl %edi, %edi
cmpl 0x8(%rsp), %eax
sete %dil
movq %r13, %rsi
movl $0x82, %edx
movq %rbp, %rcx
leaq 0x10bc(%rip), %r8       # 0x5483
xorl %eax, %eax
callq 0x25cc
testl %eax, %eax
je 0x44d9
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x4d21
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4d1d
movl (%rax), %eax
xorl %edi, %edi
cmpl 0x8(%rsp), %eax
sete %dil
movq %r13, %rsi
movl $0x85, %edx
movq %rbp, %rcx
movq %r14, %r8
xorl %eax, %eax
callq 0x25cc
testl %eax, %eax
je 0x44d9
movl 0x8(%rsp), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x8(%rsp)
cmpl $0x3e7, %eax            # imm = 0x3E7
jl 0x439b
leaq 0xc(%rsp), %rsi
movl $0xfffffff4, (%rsi)     # imm = 0xFFFFFFF4
leaq -0x125(%rip), %rdx      # 0x431b
movq %rbx, %rdi
callq 0x4c2c
xorl %edi, %edi
testq %rax, %rax
sete %dil
leaq 0xec0(%rip), %rsi       # 0x5318
leaq 0x11a4(%rip), %rcx      # 0x5603
leaq 0x104e(%rip), %r8       # 0x54b4
movl $0x89, %edx
xorl %eax, %eax
callq 0x25cc
testl %eax, %eax
je 0x44d9
leaq -0x162(%rip), %rdx      # 0x431b
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x4d21
xorl %edi, %edi
testq %rax, %rax
sete %dil
leaq 0xe7e(%rip), %rsi       # 0x5318
leaq 0x1162(%rip), %rcx      # 0x5603
leaq 0x1040(%rip), %r8       # 0x54e8
movl $0x8a, %edx
xorl %eax, %eax
callq 0x25cc
testl %eax, %eax
je 0x44d9
movq %rbx, %rdi
callq 0x4c89
movq 0x10(%rsp), %rdi
callq 0x22a0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2e2b
// File: /workspace/github_c_makefile_star2_O3/chatziko-k08[P]lecture-code/tests/ADTVector_test.c
// Function: test_destroy
void test_destroy(void) {
	// Απλά εκτελούμε την destroy, για να ελέγξουμε αν όντως δουλεύει
	// σωστά τρέχουμε το test με valgrind.

	Vector vec = vector_create(1, free);

	vector_set_at(vec, 0, malloc(1));
	vector_insert_last(vec, malloc(1));
	vector_remove_last(vec);

	vector_destroy(vec);
}

// Assembly:
pushq %rbx
movq 0x3ada(%rip), %rsi      # 0x7fc0
movl $0x1, %edi
callq 0x4a9c
movq %rax, %rbx
movl $0x1, %edi
callq 0x21a0
movq %rbx, %rdi
xorl %esi, %esi
movq %rax, %rdx
callq 0x4b13
movl $0x1, %edi
callq 0x21a0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4b6d
movq %rbx, %rdi
callq 0x4bb1
movq %rbx, %rdi
popq %rbx
jmp 0x4c89
// File: /workspace/github_c_makefile_star2_O3/felipelouza[P]egap/util.c
// Function: open_unsortedLCP_files
void open_unsortedLCP_files(g_data *g)
{
  char filename[Filename_size];
  snprintf(filename,Filename_size,"%s.pair.lcp",g->outPath);
  g->unsortedLcp = fopen(filename,"wb");
  if(g->unsortedLcp==NULL) {perror(filename); die(__func__);}
  snprintf(filename,Filename_size,"%s.size.lcp",g->outPath);
  g->unsortedLcp_size = fopen(filename,"wb");
  if(g->unsortedLcp_size==NULL) {perror(filename); die(__func__);}
  // write total size of the LCP array to first position of .size.lcp file 
  size_t e = fwrite(&(g->mergeLen),sizeof(customInt),1,g->unsortedLcp_size);  
  if(e!=1) die(__func__);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1008, %rsp           # imm = 0x1008
movq %rdi, %rbx
movq 0x80(%rdi), %rcx
leaq 0xb1ba(%rip), %rdx      # 0xec2e
movq %rsp, %r14
movl $0x1000, %esi           # imm = 0x1000
movq %r14, %rdi
xorl %eax, %eax
callq 0x2140
leaq 0xaea1(%rip), %rsi      # 0xe92e
movq %r14, %rdi
callq 0x21e0
movq %rax, 0x58(%rbx)
testq %rax, %rax
je 0x3b00
movq 0x80(%rbx), %rcx
leaq 0xb1a5(%rip), %rdx      # 0xec51
movq %rsp, %r14
movl $0x1000, %esi           # imm = 0x1000
movq %r14, %rdi
xorl %eax, %eax
callq 0x2140
leaq 0xae69(%rip), %rsi      # 0xe92e
movq %r14, %rdi
callq 0x21e0
movq %rax, 0x60(%rbx)
testq %rax, %rax
je 0x3b08
addq $0x28, %rbx
movl $0x8, %esi
movl $0x1, %edx
movq %rbx, %rdi
movq %rax, %rcx
callq 0x2390
cmpq $0x1, %rax
jne 0x3b10
addq $0x1008, %rsp           # imm = 0x1008
popq %rbx
popq %r14
retq
movq %rsp, %rdi
callq 0x247f
movq %rsp, %rdi
callq 0x246d
leaq 0xb123(%rip), %rdi      # 0xec3a
callq 0x39fc
// File: /workspace/github_c_makefile_star2_O3/felipelouza[P]egap/util.c
// Function: writeLcp
void writeLcp(customInt k, uint32_t lcp, g_data *g)
{
  assert(g->unsortedLcp!=NULL);
  assert(lcp <= MAX_LCP_SIZE);
  if(k>=(1ULL<<(8*POS_SIZE))) { // at most pos_size bytes for the position
    fprintf(stderr,"%d bytes per position are not enough. Increase POS_SIZE and recompile\n",POS_SIZE); 
    exit(EXIT_FAILURE);
  } 
  size_t e = fwrite(&lcp,BSIZE,1,g->unsortedLcp);
  if(e!=1) die(__func__);
  e = fwrite(&k,POS_SIZE,1,g->unsortedLcp);
  if(e!=1) die(__func__);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, 0x8(%rsp)
movl %esi, 0x4(%rsp)
shrq $0x28, %rdi
jne 0x3b81
movq %rdx, %rbx
movq 0x58(%rdx), %rcx
leaq 0x4(%rsp), %rdi
movl $0x1, %esi
movl $0x1, %edx
callq 0x2390
cmpq $0x1, %rax
jne 0x3b75
movq 0x58(%rbx), %rcx
leaq 0x8(%rsp), %rdi
movl $0x5, %esi
movl $0x1, %edx
callq 0x2390
cmpq $0x1, %rax
jne 0x3b75
addq $0x10, %rsp
popq %rbx
retq
leaq 0xb128(%rip), %rdi      # 0xeca4
callq 0x39fc
callq 0x2491
// File: /workspace/github_c_makefile_star2_O3/felipelouza[P]egap/util.c
// Function: writeLcp_EOF
void writeLcp_EOF(uint64_t size, g_data *g)
{
  assert(g->unsortedLcp!=NULL && g->unsortedLcp_size!=NULL);

  // write eof to .pair.lcp file
  uint64_t b = ~0ULL; // all 1's 
  size_t e = fwrite(&b,BSIZE,1,g->unsortedLcp);  
  if(e!=1) die(__func__);
  e = fwrite(&b,POS_SIZE,1,g->unsortedLcp);  
  if(e!=1) die(__func__);
  // write size of complete LCP segment to .size.lcp file 
  e = fwrite(&size,8,1,g->unsortedLcp_size);  
  if(e!=1) die(__func__);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, 0x8(%rsp)
movq %rsp, %rdi
movq $-0x1, (%rdi)
movq 0x58(%rsi), %rcx
movl $0x1, %esi
movl $0x1, %edx
callq 0x2390
cmpq $0x1, %rax
jne 0x3bf6
movq 0x58(%rbx), %rcx
movq %rsp, %rdi
movl $0x5, %esi
movl $0x1, %edx
callq 0x2390
cmpq $0x1, %rax
jne 0x3bf6
movq 0x60(%rbx), %rcx
leaq 0x8(%rsp), %rdi
movl $0x8, %esi
movl $0x1, %edx
callq 0x2390
cmpq $0x1, %rax
jne 0x3bf6
addq $0x10, %rsp
popq %rbx
retq
leaq 0xb0b0(%rip), %rdi      # 0xecad
callq 0x39fc