LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl 0x993a(%rip), %eax      # 0xc168
movl %eax, -0x8(%rbp)
movl 0x9929(%rip), %eax      # 0xc160
movl %eax, -0xc(%rbp)
movl $0x3d, %edi
callq 0x1ed0
cmpl $0x0, %eax
jne 0x284b
jmp 0x2860
callq 0x1da0
cmpl $0x0, %eax
jne 0x2857
jmp 0x2860
movl $0x1, -0x4(%rbp)
jmp 0x2879
movl -0x8(%rbp), %eax
movl %eax, 0x98ff(%rip)      # 0xc168
movl -0xc(%rbp), %eax
movl %eax, 0x98ee(%rip)      # 0xc160
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl 0x98ca(%rip), %eax      # 0xc168
movl %eax, -0x8(%rbp)
movl 0x98b9(%rip), %eax      # 0xc160
movl %eax, -0xc(%rbp)
callq 0x2980
cmpl $0x0, %eax
jne 0x28b6
jmp 0x2917
jmp 0x28b8
movl 0x98aa(%rip), %eax      # 0xc168
movl %eax, -0x10(%rbp)
movl 0x9899(%rip), %eax      # 0xc160
movl %eax, -0x14(%rbp)
callq 0x3f90
cmpl $0x0, %eax
jne 0x28d6
jmp 0x28fc
callq 0x2980
cmpl $0x0, %eax
jne 0x28e2
jmp 0x28fc
movl 0x9888(%rip), %esi      # 0xc170
movl 0x987e(%rip), %edx      # 0xc16c
leaq 0x4b(%rip), %rdi        # 0x2940
callq 0x23e0
jmp 0x28b8
movl -0x10(%rbp), %eax
movl %eax, 0x9863(%rip)      # 0xc168
movl -0x14(%rbp), %eax
movl %eax, 0x9852(%rip)      # 0xc160
movl $0x1, -0x4(%rbp)
jmp 0x2930
movl -0x8(%rbp), %eax
movl %eax, 0x9848(%rip)      # 0xc168
movl -0xc(%rbp), %eax
movl %eax, 0x9837(%rip)      # 0xc160
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl 0x97da(%rip), %eax      # 0xc168
movl %eax, -0x8(%rbp)
movl 0x97c9(%rip), %eax      # 0xc160
movl %eax, -0xc(%rbp)
callq 0x2a60
cmpl $0x0, %eax
jne 0x29a6
jmp 0x29fb
jmp 0x29a8
movl 0x97ba(%rip), %eax      # 0xc168
movl %eax, -0x10(%rbp)
movl 0x97a9(%rip), %eax      # 0xc160
movl %eax, -0x14(%rbp)
callq 0x2a60
cmpl $0x0, %eax
jne 0x29c6
jmp 0x29e0
movl 0x97a4(%rip), %esi      # 0xc170
movl 0x979a(%rip), %edx      # 0xc16c
leaq 0x47(%rip), %rdi        # 0x2a20
callq 0x23e0
jmp 0x29a8
movl -0x10(%rbp), %eax
movl %eax, 0x977f(%rip)      # 0xc168
movl -0x14(%rbp), %eax
movl %eax, 0x976e(%rip)      # 0xc160
movl $0x1, -0x4(%rbp)
jmp 0x2a14
movl -0x8(%rbp), %eax
movl %eax, 0x9764(%rip)      # 0xc168
movl -0xc(%rbp), %eax
movl %eax, 0x9753(%rip)      # 0xc160
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl 0x96fa(%rip), %eax      # 0xc168
movl %eax, -0x8(%rbp)
movl 0x96e9(%rip), %eax      # 0xc160
movl %eax, -0xc(%rbp)
movl 0x96e8(%rip), %eax      # 0xc168
movl %eax, -0x10(%rbp)
movl 0x96d7(%rip), %eax      # 0xc160
movl %eax, -0x14(%rbp)
callq 0x2c30
cmpl $0x0, %eax
jne 0x2a98
jmp 0x2ac1
callq 0x2ca0
cmpl $0x0, %eax
jne 0x2aa4
jmp 0x2ac1
movl 0x96c6(%rip), %esi      # 0xc170
movl 0x96bc(%rip), %edx      # 0xc16c
leaq 0xe9(%rip), %rdi        # 0x2ba0
callq 0x23e0
jmp 0x2b69
movl -0x10(%rbp), %eax
movl %eax, 0x969e(%rip)      # 0xc168
movl -0x14(%rbp), %eax
movl %eax, 0x968d(%rip)      # 0xc160
callq 0x2c30
cmpl $0x0, %eax
jne 0x2adf
jmp 0x2b05
callq 0x2ee0
cmpl $0x0, %eax
jne 0x2aeb
jmp 0x2b05
movl 0x967f(%rip), %esi      # 0xc170
movl 0x9675(%rip), %edx      # 0xc16c
leaq 0xd2(%rip), %rdi        # 0x2bd0
callq 0x23e0
jmp 0x2b69
movl -0x10(%rbp), %eax
movl %eax, 0x965a(%rip)      # 0xc168
movl -0x14(%rbp), %eax
movl %eax, 0x9649(%rip)      # 0xc160
callq 0x3f20
cmpl $0x0, %eax
jne 0x2b23
jmp 0x2b49
callq 0x2ee0
cmpl $0x0, %eax
jne 0x2b2f
jmp 0x2b49
movl 0x963b(%rip), %esi      # 0xc170
movl 0x9631(%rip), %edx      # 0xc16c
leaq 0xbe(%rip), %rdi        # 0x2c00
callq 0x23e0
jmp 0x2b69
movl -0x10(%rbp), %eax
movl %eax, 0x9616(%rip)      # 0xc168
movl -0x14(%rbp), %eax
movl %eax, 0x9605(%rip)      # 0xc160
callq 0x2ee0
cmpl $0x0, %eax
jne 0x2b67
jmp 0x2b72
jmp 0x2b69
movl $0x1, -0x4(%rbp)
jmp 0x2b8b
movl -0x8(%rbp), %eax
movl %eax, 0x95ed(%rip)      # 0xc168
movl -0xc(%rbp), %eax
movl %eax, 0x95dc(%rip)      # 0xc160
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl 0x952a(%rip), %eax      # 0xc168
movl %eax, -0x8(%rbp)
movl 0x9519(%rip), %eax      # 0xc160
movl %eax, -0xc(%rbp)
movl $0x26, %edi
callq 0x1ed0
cmpl $0x0, %eax
jne 0x2c5b
jmp 0x2c70
callq 0x1da0
cmpl $0x0, %eax
jne 0x2c67
jmp 0x2c70
movl $0x1, -0x4(%rbp)
jmp 0x2c89
movl -0x8(%rbp), %eax
movl %eax, 0x94ef(%rip)      # 0xc168
movl -0xc(%rbp), %eax
movl %eax, 0x94de(%rip)      # 0xc160
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl 0x94ba(%rip), %eax      # 0xc168
movl %eax, -0x8(%rbp)
movl 0x94a9(%rip), %eax      # 0xc160
movl %eax, -0xc(%rbp)
movl $0x7b, %edi
callq 0x1ed0
cmpl $0x0, %eax
jne 0x2cce
jmp 0x2d72
movl 0x949c(%rip), %edi      # 0xc170
movl 0x9492(%rip), %esi      # 0xc16c
callq 0x1b40
movl 0x9483(%rip), %eax      # 0xc168
movl %eax, 0x9485(%rip)      # 0xc170
movb $0x1, %al
testb $0x1, %al
jne 0x2cf3
jmp 0x2d72
jmp 0x2cf5
movl 0x946d(%rip), %eax      # 0xc168
movl %eax, -0x10(%rbp)
movl 0x945c(%rip), %eax      # 0xc160
movl %eax, -0x14(%rbp)
callq 0x2da0
cmpl $0x0, %eax
jne 0x2d13
jmp 0x2d15
jmp 0x2cf5
movl -0x10(%rbp), %eax
movl %eax, 0x944a(%rip)      # 0xc168
movl -0x14(%rbp), %eax
movl %eax, 0x9439(%rip)      # 0xc160
movl 0x9443(%rip), %edi      # 0xc170
movl 0x9439(%rip), %esi      # 0xc16c
callq 0x1b40
movl 0x942a(%rip), %eax      # 0xc168
movl %eax, 0x9428(%rip)      # 0xc16c
movb $0x1, %al
testb $0x1, %al
jne 0x2d4c
jmp 0x2d72
movl $0x7d, %edi
callq 0x1ed0
cmpl $0x0, %eax
jne 0x2d5d
jmp 0x2d72
callq 0x1da0
cmpl $0x0, %eax
jne 0x2d69
jmp 0x2d72
movl $0x1, -0x4(%rbp)
jmp 0x2d8b
movl -0x8(%rbp), %eax
movl %eax, 0x93ed(%rip)      # 0xc168
movl -0xc(%rbp), %eax
movl %eax, 0x93dc(%rip)      # 0xc160
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/macournoyer[P]peg/leg.c
// Function: yy_braces
YY_RULE(int) yy_braces()
{  int yypos0= yypos, yythunkpos0= yythunkpos;
  yyprintf((stderr, "%s\n", "braces"));
  {  int yypos14= yypos, yythunkpos14= yythunkpos;  if (!yymatchChar('{')) goto l15;
  l16:;	
  {  int yypos17= yypos, yythunkpos17= yythunkpos;
  {  int yypos18= yypos, yythunkpos18= yythunkpos;  if (!yymatchChar('}')) goto l18;  goto l17;
  l18:;	  yypos= yypos18; yythunkpos= yythunkpos18;
  }  if (!yymatchDot()) goto l17;  goto l16;
  l17:;	  yypos= yypos17; yythunkpos= yythunkpos17;
  }  if (!yymatchChar('}')) goto l15;  goto l14;
  l15:;	  yypos= yypos14; yythunkpos= yythunkpos14;
  {  int yypos19= yypos, yythunkpos19= yythunkpos;  if (!yymatchChar('}')) goto l19;  goto l13;
  l19:;	  yypos= yypos19; yythunkpos= yythunkpos19;
  }  if (!yymatchDot()) goto l13;
  }
  l14:;	
  yyprintf((stderr, "  ok   %s @ %s\n", "braces", yybuf+yypos));
  return 1;
  l13:;	  yypos= yypos0; yythunkpos= yythunkpos0;
  yyprintf((stderr, "  fail %s @ %s\n", "braces", yybuf+yypos));
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl 0x93ba(%rip), %eax      # 0xc168
movl %eax, -0x8(%rbp)
movl 0x93a9(%rip), %eax      # 0xc160
movl %eax, -0xc(%rbp)
movl 0x93a8(%rip), %eax      # 0xc168
movl %eax, -0x10(%rbp)
movl 0x9397(%rip), %eax      # 0xc160
movl %eax, -0x14(%rbp)
movl $0x7b, %edi
callq 0x1ed0
cmpl $0x0, %eax
jne 0x2ddd
jmp 0x2e5b
jmp 0x2ddf
movl 0x9383(%rip), %eax      # 0xc168
movl %eax, -0x18(%rbp)
movl 0x9372(%rip), %eax      # 0xc160
movl %eax, -0x1c(%rbp)
movl 0x9371(%rip), %eax      # 0xc168
movl %eax, -0x20(%rbp)
movl 0x9360(%rip), %eax      # 0xc160
movl %eax, -0x24(%rbp)
movl $0x7d, %edi
callq 0x1ed0
cmpl $0x0, %eax
jne 0x2e14
jmp 0x2e16
jmp 0x2e36
movl -0x20(%rbp), %eax
movl %eax, 0x9349(%rip)      # 0xc168
movl -0x24(%rbp), %eax
movl %eax, 0x9338(%rip)      # 0xc160
callq 0x2250
cmpl $0x0, %eax
jne 0x2e34
jmp 0x2e36
jmp 0x2ddf
movl -0x18(%rbp), %eax
movl %eax, 0x9329(%rip)      # 0xc168
movl -0x1c(%rbp), %eax
movl %eax, 0x9318(%rip)      # 0xc160
movl $0x7d, %edi
callq 0x1ed0
cmpl $0x0, %eax
jne 0x2e59
jmp 0x2e5b
jmp 0x2eb2
movl -0x10(%rbp), %eax
movl %eax, 0x9304(%rip)      # 0xc168
movl -0x14(%rbp), %eax
movl %eax, 0x92f3(%rip)      # 0xc160
movl 0x92f5(%rip), %eax      # 0xc168
movl %eax, -0x28(%rbp)
movl 0x92e4(%rip), %eax      # 0xc160
movl %eax, -0x2c(%rbp)
movl $0x7d, %edi
callq 0x1ed0
cmpl $0x0, %eax
jne 0x2e90
jmp 0x2e92
jmp 0x2ebb
movl -0x28(%rbp), %eax
movl %eax, 0x92cd(%rip)      # 0xc168
movl -0x2c(%rbp), %eax
movl %eax, 0x92bc(%rip)      # 0xc160
callq 0x2250
cmpl $0x0, %eax
jne 0x2eb0
jmp 0x2ebb
jmp 0x2eb2
movl $0x1, -0x4(%rbp)
jmp 0x2ed4
movl -0x8(%rbp), %eax
movl %eax, 0x92a4(%rip)      # 0xc168
movl -0xc(%rbp), %eax
movl %eax, 0x9293(%rip)      # 0xc160
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/macournoyer[P]peg/leg.c
// Function: yy_suffix
YY_RULE(int) yy_suffix()
{  int yypos0= yypos, yythunkpos0= yythunkpos;
  yyprintf((stderr, "%s\n", "suffix"));  if (!yy_primary()) goto l66;
  {  int yypos67= yypos, yythunkpos67= yythunkpos;
  {  int yypos69= yypos, yythunkpos69= yythunkpos;  if (!yy_QUESTION()) goto l70;  yyDo(yy_1_suffix, yybegin, yyend);  goto l69;
  l70:;	  yypos= yypos69; yythunkpos= yythunkpos69;  if (!yy_STAR()) goto l71;  yyDo(yy_2_suffix, yybegin, yyend);  goto l69;
  l71:;	  yypos= yypos69; yythunkpos= yythunkpos69;  if (!yy_PLUS()) goto l67;  yyDo(yy_3_suffix, yybegin, yyend);
  }
  l69:;	  goto l68;
  l67:;	  yypos= yypos67; yythunkpos= yythunkpos67;
  }
  l68:;	
  yyprintf((stderr, "  ok   %s @ %s\n", "suffix", yybuf+yypos));
  return 1;
  l66:;	  yypos= yypos0; yythunkpos= yythunkpos0;
  yyprintf((stderr, "  fail %s @ %s\n", "suffix", yybuf+yypos));
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl 0x927a(%rip), %eax      # 0xc168
movl %eax, -0x8(%rbp)
movl 0x9269(%rip), %eax      # 0xc160
movl %eax, -0xc(%rbp)
callq 0x3090
cmpl $0x0, %eax
jne 0x2f09
jmp 0x2fde
movl 0x9259(%rip), %eax      # 0xc168
movl %eax, -0x10(%rbp)
movl 0x9248(%rip), %eax      # 0xc160
movl %eax, -0x14(%rbp)
movl 0x9247(%rip), %eax      # 0xc168
movl %eax, -0x18(%rbp)
movl 0x9236(%rip), %eax      # 0xc160
movl %eax, -0x1c(%rbp)
callq 0x3dd0
cmpl $0x0, %eax
jne 0x2f39
jmp 0x2f53
movl 0x9231(%rip), %esi      # 0xc170
movl 0x9227(%rip), %edx      # 0xc16c
leaq 0xb4(%rip), %rdi        # 0x3000
callq 0x23e0
jmp 0x2fc1
movl -0x18(%rbp), %eax
movl %eax, 0x920c(%rip)      # 0xc168
movl -0x1c(%rbp), %eax
movl %eax, 0x91fb(%rip)      # 0xc160
callq 0x3e40
cmpl $0x0, %eax
jne 0x2f71
jmp 0x2f8b
movl 0x91f9(%rip), %esi      # 0xc170
movl 0x91ef(%rip), %edx      # 0xc16c
leaq 0xac(%rip), %rdi        # 0x3030
callq 0x23e0
jmp 0x2fc1
movl -0x18(%rbp), %eax
movl %eax, 0x91d4(%rip)      # 0xc168
movl -0x1c(%rbp), %eax
movl %eax, 0x91c3(%rip)      # 0xc160
callq 0x3eb0
cmpl $0x0, %eax
jne 0x2fa9
jmp 0x2fc3
movl 0x91c1(%rip), %esi      # 0xc170
movl 0x91b7(%rip), %edx      # 0xc16c
leaq 0xa4(%rip), %rdi        # 0x3060
callq 0x23e0
jmp 0x2fd5
movl -0x10(%rbp), %eax
movl %eax, 0x919c(%rip)      # 0xc168
movl -0x14(%rbp), %eax
movl %eax, 0x918b(%rip)      # 0xc160
movl $0x1, -0x4(%rbp)
jmp 0x2ff7
movl -0x8(%rbp), %eax
movl %eax, 0x9181(%rip)      # 0xc168
movl -0xc(%rbp), %eax
movl %eax, 0x9170(%rip)      # 0xc160
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/macournoyer[P]peg/leg.c
// Function: yy_COLON
YY_RULE(int) yy_COLON()
{  int yypos0= yypos, yythunkpos0= yythunkpos;
  yyprintf((stderr, "%s\n", "COLON"));  if (!yymatchChar(':')) goto l49;  if (!yy__()) goto l49;
  yyprintf((stderr, "  ok   %s @ %s\n", "COLON", yybuf+yypos));
  return 1;
  l49:;	  yypos= yypos0; yythunkpos= yythunkpos0;
  yyprintf((stderr, "  fail %s @ %s\n", "COLON", yybuf+yypos));
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl 0x8c0a(%rip), %eax      # 0xc168
movl %eax, -0x8(%rbp)
movl 0x8bf9(%rip), %eax      # 0xc160
movl %eax, -0xc(%rbp)
movl $0x3a, %edi
callq 0x1ed0
cmpl $0x0, %eax
jne 0x357b
jmp 0x3590
callq 0x1da0
cmpl $0x0, %eax
jne 0x3587
jmp 0x3590
movl $0x1, -0x4(%rbp)
jmp 0x35a9
movl -0x8(%rbp), %eax
movl %eax, 0x8bcf(%rip)      # 0xc168
movl -0xc(%rbp), %eax
movl %eax, 0x8bbe(%rip)      # 0xc160
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/macournoyer[P]peg/leg.c
// Function: yy_OPEN
YY_RULE(int) yy_OPEN()
{  int yypos0= yypos, yythunkpos0= yythunkpos;
  yyprintf((stderr, "%s\n", "OPEN"));  if (!yymatchChar('(')) goto l48;  if (!yy__()) goto l48;
  yyprintf((stderr, "  ok   %s @ %s\n", "OPEN", yybuf+yypos));
  return 1;
  l48:;	  yypos= yypos0; yythunkpos= yythunkpos0;
  yyprintf((stderr, "  fail %s @ %s\n", "OPEN", yybuf+yypos));
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl 0x8b9a(%rip), %eax      # 0xc168
movl %eax, -0x8(%rbp)
movl 0x8b89(%rip), %eax      # 0xc160
movl %eax, -0xc(%rbp)
movl $0x28, %edi
callq 0x1ed0
cmpl $0x0, %eax
jne 0x35eb
jmp 0x3600
callq 0x1da0
cmpl $0x0, %eax
jne 0x35f7
jmp 0x3600
movl $0x1, -0x4(%rbp)
jmp 0x3619
movl -0x8(%rbp), %eax
movl %eax, 0x8b5f(%rip)      # 0xc168
movl -0xc(%rbp), %eax
movl %eax, 0x8b4e(%rip)      # 0xc160
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/macournoyer[P]peg/leg.c
// Function: yy_CLOSE
YY_RULE(int) yy_CLOSE()
{  int yypos0= yypos, yythunkpos0= yythunkpos;
  yyprintf((stderr, "%s\n", "CLOSE"));  if (!yymatchChar(')')) goto l47;  if (!yy__()) goto l47;
  yyprintf((stderr, "  ok   %s @ %s\n", "CLOSE", yybuf+yypos));
  return 1;
  l47:;	  yypos= yypos0; yythunkpos= yythunkpos0;
  yyprintf((stderr, "  fail %s @ %s\n", "CLOSE", yybuf+yypos));
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl 0x8b2a(%rip), %eax      # 0xc168
movl %eax, -0x8(%rbp)
movl 0x8b19(%rip), %eax      # 0xc160
movl %eax, -0xc(%rbp)
movl $0x29, %edi
callq 0x1ed0
cmpl $0x0, %eax
jne 0x365b
jmp 0x3670
callq 0x1da0
cmpl $0x0, %eax
jne 0x3667
jmp 0x3670
movl $0x1, -0x4(%rbp)
jmp 0x3689
movl -0x8(%rbp), %eax
movl %eax, 0x8aef(%rip)      # 0xc168
movl -0xc(%rbp), %eax
movl %eax, 0x8ade(%rip)      # 0xc160
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/macournoyer[P]peg/leg.c
// Function: yy_class
YY_RULE(int) yy_class()
{  int yypos0= yypos, yythunkpos0= yythunkpos;
  yyprintf((stderr, "%s\n", "class"));  if (!yymatchChar('[')) goto l34;  yyText(yybegin, yyend);  if (!(YY_BEGIN)) goto l34;
  l35:;	
  {  int yypos36= yypos, yythunkpos36= yythunkpos;
  {  int yypos37= yypos, yythunkpos37= yythunkpos;  if (!yymatchChar(']')) goto l37;  goto l36;
  l37:;	  yypos= yypos37; yythunkpos= yythunkpos37;
  }  if (!yy_range()) goto l36;  goto l35;
  l36:;	  yypos= yypos36; yythunkpos= yythunkpos36;
  }  yyText(yybegin, yyend);  if (!(YY_END)) goto l34;  if (!yymatchChar(']')) goto l34;  if (!yy__()) goto l34;
  yyprintf((stderr, "  ok   %s @ %s\n", "class", yybuf+yypos));
  return 1;
  l34:;	  yypos= yypos0; yythunkpos= yythunkpos0;
  yyprintf((stderr, "  fail %s @ %s\n", "class", yybuf+yypos));
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl 0x86ba(%rip), %eax      # 0xc168
movl %eax, -0x8(%rbp)
movl 0x86a9(%rip), %eax      # 0xc160
movl %eax, -0xc(%rbp)
movl $0x5b, %edi
callq 0x1ed0
cmpl $0x0, %eax
jne 0x3ace
jmp 0x3bac
movl 0x869c(%rip), %edi      # 0xc170
movl 0x8692(%rip), %esi      # 0xc16c
callq 0x1b40
movl 0x8683(%rip), %eax      # 0xc168
movl %eax, 0x8685(%rip)      # 0xc170
movb $0x1, %al
testb $0x1, %al
jne 0x3af6
jmp 0x3bac
jmp 0x3af8
movl 0x866a(%rip), %eax      # 0xc168
movl %eax, -0x10(%rbp)
movl 0x8659(%rip), %eax      # 0xc160
movl %eax, -0x14(%rbp)
movl 0x8658(%rip), %eax      # 0xc168
movl %eax, -0x18(%rbp)
movl 0x8647(%rip), %eax      # 0xc160
movl %eax, -0x1c(%rbp)
movl $0x5d, %edi
callq 0x1ed0
cmpl $0x0, %eax
jne 0x3b2d
jmp 0x3b2f
jmp 0x3b4f
movl -0x18(%rbp), %eax
movl %eax, 0x8630(%rip)      # 0xc168
movl -0x1c(%rbp), %eax
movl %eax, 0x861f(%rip)      # 0xc160
callq 0x3bd0
cmpl $0x0, %eax
jne 0x3b4d
jmp 0x3b4f
jmp 0x3af8
movl -0x10(%rbp), %eax
movl %eax, 0x8610(%rip)      # 0xc168
movl -0x14(%rbp), %eax
movl %eax, 0x85ff(%rip)      # 0xc160
movl 0x8609(%rip), %edi      # 0xc170
movl 0x85ff(%rip), %esi      # 0xc16c
callq 0x1b40
movl 0x85f0(%rip), %eax      # 0xc168
movl %eax, 0x85ee(%rip)      # 0xc16c
movb $0x1, %al
testb $0x1, %al
jne 0x3b86
jmp 0x3bac
movl $0x5d, %edi
callq 0x1ed0
cmpl $0x0, %eax
jne 0x3b97
jmp 0x3bac
callq 0x1da0
cmpl $0x0, %eax
jne 0x3ba3
jmp 0x3bac
movl $0x1, -0x4(%rbp)
jmp 0x3bc5
movl -0x8(%rbp), %eax
movl %eax, 0x85b3(%rip)      # 0xc168
movl -0xc(%rbp), %eax
movl %eax, 0x85a2(%rip)      # 0xc160
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/macournoyer[P]peg/leg.c
// Function: yy_range
YY_RULE(int) yy_range()
{  int yypos0= yypos, yythunkpos0= yythunkpos;
  yyprintf((stderr, "%s\n", "range"));
  {  int yypos21= yypos, yythunkpos21= yythunkpos;  if (!yy_char()) goto l22;  if (!yymatchChar('-')) goto l22;  if (!yy_char()) goto l22;  goto l21;
  l22:;	  yypos= yypos21; yythunkpos= yythunkpos21;  if (!yy_char()) goto l20;
  }
  l21:;	
  yyprintf((stderr, "  ok   %s @ %s\n", "range", yybuf+yypos));
  return 1;
  l20:;	  yypos= yypos0; yythunkpos= yythunkpos0;
  yyprintf((stderr, "  fail %s @ %s\n", "range", yybuf+yypos));
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl 0x858a(%rip), %eax      # 0xc168
movl %eax, -0x8(%rbp)
movl 0x8579(%rip), %eax      # 0xc160
movl %eax, -0xc(%rbp)
movl 0x8578(%rip), %eax      # 0xc168
movl %eax, -0x10(%rbp)
movl 0x8567(%rip), %eax      # 0xc160
movl %eax, -0x14(%rbp)
callq 0x38f0
cmpl $0x0, %eax
jne 0x3c08
jmp 0x3c27
movl $0x2d, %edi
callq 0x1ed0
cmpl $0x0, %eax
jne 0x3c19
jmp 0x3c27
callq 0x38f0
cmpl $0x0, %eax
jne 0x3c25
jmp 0x3c27
jmp 0x3c47
movl -0x10(%rbp), %eax
movl %eax, 0x8538(%rip)      # 0xc168
movl -0x14(%rbp), %eax
movl %eax, 0x8527(%rip)      # 0xc160
callq 0x38f0
cmpl $0x0, %eax
jne 0x3c45
jmp 0x3c50
jmp 0x3c47
movl $0x1, -0x4(%rbp)
jmp 0x3c69
movl -0x8(%rbp), %eax
movl %eax, 0x850f(%rip)      # 0xc168
movl -0xc(%rbp), %eax
movl %eax, 0x84fe(%rip)      # 0xc160
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/macournoyer[P]peg/leg.c
// Function: yy_DOT
YY_RULE(int) yy_DOT()
{  int yypos0= yypos, yythunkpos0= yythunkpos;
  yyprintf((stderr, "%s\n", "DOT"));  if (!yymatchChar('.')) goto l33;  if (!yy__()) goto l33;
  yyprintf((stderr, "  ok   %s @ %s\n", "DOT", yybuf+yypos));
  return 1;
  l33:;	  yypos= yypos0; yythunkpos= yythunkpos0;
  yyprintf((stderr, "  fail %s @ %s\n", "DOT", yybuf+yypos));
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl 0x84da(%rip), %eax      # 0xc168
movl %eax, -0x8(%rbp)
movl 0x84c9(%rip), %eax      # 0xc160
movl %eax, -0xc(%rbp)
movl $0x2e, %edi
callq 0x1ed0
cmpl $0x0, %eax
jne 0x3cab
jmp 0x3cc0
callq 0x1da0
cmpl $0x0, %eax
jne 0x3cb7
jmp 0x3cc0
movl $0x1, -0x4(%rbp)
jmp 0x3cd9
movl -0x8(%rbp), %eax
movl %eax, 0x849f(%rip)      # 0xc168
movl -0xc(%rbp), %eax
movl %eax, 0x848e(%rip)      # 0xc160
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl 0x846a(%rip), %eax      # 0xc168
movl %eax, -0x8(%rbp)
movl 0x8459(%rip), %eax      # 0xc160
movl %eax, -0xc(%rbp)
movl $0x3c, %edi
callq 0x1ed0
cmpl $0x0, %eax
jne 0x3d1b
jmp 0x3d30
callq 0x1da0
cmpl $0x0, %eax
jne 0x3d27
jmp 0x3d30
movl $0x1, -0x4(%rbp)
jmp 0x3d49
movl -0x8(%rbp), %eax
movl %eax, 0x842f(%rip)      # 0xc168
movl -0xc(%rbp), %eax
movl %eax, 0x841e(%rip)      # 0xc160
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl 0x83fa(%rip), %eax      # 0xc168
movl %eax, -0x8(%rbp)
movl 0x83e9(%rip), %eax      # 0xc160
movl %eax, -0xc(%rbp)
movl $0x3e, %edi
callq 0x1ed0
cmpl $0x0, %eax
jne 0x3d8b
jmp 0x3da0
callq 0x1da0
cmpl $0x0, %eax
jne 0x3d97
jmp 0x3da0
movl $0x1, -0x4(%rbp)
jmp 0x3db9
movl -0x8(%rbp), %eax
movl %eax, 0x83bf(%rip)      # 0xc168
movl -0xc(%rbp), %eax
movl %eax, 0x83ae(%rip)      # 0xc160
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/macournoyer[P]peg/leg.c
// Function: yy_QUESTION
YY_RULE(int) yy_QUESTION()
{  int yypos0= yypos, yythunkpos0= yythunkpos;
  yyprintf((stderr, "%s\n", "QUESTION"));  if (!yymatchChar('?')) goto l52;  if (!yy__()) goto l52;
  yyprintf((stderr, "  ok   %s @ %s\n", "QUESTION", yybuf+yypos));
  return 1;
  l52:;	  yypos= yypos0; yythunkpos= yythunkpos0;
  yyprintf((stderr, "  fail %s @ %s\n", "QUESTION", yybuf+yypos));
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl 0x838a(%rip), %eax      # 0xc168
movl %eax, -0x8(%rbp)
movl 0x8379(%rip), %eax      # 0xc160
movl %eax, -0xc(%rbp)
movl $0x3f, %edi
callq 0x1ed0
cmpl $0x0, %eax
jne 0x3dfb
jmp 0x3e10
callq 0x1da0
cmpl $0x0, %eax
jne 0x3e07
jmp 0x3e10
movl $0x1, -0x4(%rbp)
jmp 0x3e29
movl -0x8(%rbp), %eax
movl %eax, 0x834f(%rip)      # 0xc168
movl -0xc(%rbp), %eax
movl %eax, 0x833e(%rip)      # 0xc160
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/macournoyer[P]peg/leg.c
// Function: yy_STAR
YY_RULE(int) yy_STAR()
{  int yypos0= yypos, yythunkpos0= yythunkpos;
  yyprintf((stderr, "%s\n", "STAR"));  if (!yymatchChar('*')) goto l51;  if (!yy__()) goto l51;
  yyprintf((stderr, "  ok   %s @ %s\n", "STAR", yybuf+yypos));
  return 1;
  l51:;	  yypos= yypos0; yythunkpos= yythunkpos0;
  yyprintf((stderr, "  fail %s @ %s\n", "STAR", yybuf+yypos));
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl 0x831a(%rip), %eax      # 0xc168
movl %eax, -0x8(%rbp)
movl 0x8309(%rip), %eax      # 0xc160
movl %eax, -0xc(%rbp)
movl $0x2a, %edi
callq 0x1ed0
cmpl $0x0, %eax
jne 0x3e6b
jmp 0x3e80
callq 0x1da0
cmpl $0x0, %eax
jne 0x3e77
jmp 0x3e80
movl $0x1, -0x4(%rbp)
jmp 0x3e99
movl -0x8(%rbp), %eax
movl %eax, 0x82df(%rip)      # 0xc168
movl -0xc(%rbp), %eax
movl %eax, 0x82ce(%rip)      # 0xc160
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/macournoyer[P]peg/leg.c
// Function: yy_PLUS
YY_RULE(int) yy_PLUS()
{  int yypos0= yypos, yythunkpos0= yythunkpos;
  yyprintf((stderr, "%s\n", "PLUS"));  if (!yymatchChar('+')) goto l50;  if (!yy__()) goto l50;
  yyprintf((stderr, "  ok   %s @ %s\n", "PLUS", yybuf+yypos));
  return 1;
  l50:;	  yypos= yypos0; yythunkpos= yythunkpos0;
  yyprintf((stderr, "  fail %s @ %s\n", "PLUS", yybuf+yypos));
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl 0x82aa(%rip), %eax      # 0xc168
movl %eax, -0x8(%rbp)
movl 0x8299(%rip), %eax      # 0xc160
movl %eax, -0xc(%rbp)
movl $0x2b, %edi
callq 0x1ed0
cmpl $0x0, %eax
jne 0x3edb
jmp 0x3ef0
callq 0x1da0
cmpl $0x0, %eax
jne 0x3ee7
jmp 0x3ef0
movl $0x1, -0x4(%rbp)
jmp 0x3f09
movl -0x8(%rbp), %eax
movl %eax, 0x826f(%rip)      # 0xc168
movl -0xc(%rbp), %eax
movl %eax, 0x825e(%rip)      # 0xc160
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/macournoyer[P]peg/leg.c
// Function: yy_NOT
YY_RULE(int) yy_NOT()
{  int yypos0= yypos, yythunkpos0= yythunkpos;
  yyprintf((stderr, "%s\n", "NOT"));  if (!yymatchChar('!')) goto l65;  if (!yy__()) goto l65;
  yyprintf((stderr, "  ok   %s @ %s\n", "NOT", yybuf+yypos));
  return 1;
  l65:;	  yypos= yypos0; yythunkpos= yythunkpos0;
  yyprintf((stderr, "  fail %s @ %s\n", "NOT", yybuf+yypos));
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl 0x823a(%rip), %eax      # 0xc168
movl %eax, -0x8(%rbp)
movl 0x8229(%rip), %eax      # 0xc160
movl %eax, -0xc(%rbp)
movl $0x21, %edi
callq 0x1ed0
cmpl $0x0, %eax
jne 0x3f4b
jmp 0x3f60
callq 0x1da0
cmpl $0x0, %eax
jne 0x3f57
jmp 0x3f60
movl $0x1, -0x4(%rbp)
jmp 0x3f79
movl -0x8(%rbp), %eax
movl %eax, 0x81ff(%rip)      # 0xc168
movl -0xc(%rbp), %eax
movl %eax, 0x81ee(%rip)      # 0xc160
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/macournoyer[P]peg/leg.c
// Function: yy_BAR
YY_RULE(int) yy_BAR()
{  int yypos0= yypos, yythunkpos0= yythunkpos;
  yyprintf((stderr, "%s\n", "BAR"));  if (!yymatchChar('|')) goto l81;  if (!yy__()) goto l81;
  yyprintf((stderr, "  ok   %s @ %s\n", "BAR", yybuf+yypos));
  return 1;
  l81:;	  yypos= yypos0; yythunkpos= yythunkpos0;
  yyprintf((stderr, "  fail %s @ %s\n", "BAR", yybuf+yypos));
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl 0x81ca(%rip), %eax      # 0xc168
movl %eax, -0x8(%rbp)
movl 0x81b9(%rip), %eax      # 0xc160
movl %eax, -0xc(%rbp)
movl $0x7c, %edi
callq 0x1ed0
cmpl $0x0, %eax
jne 0x3fbb
jmp 0x3fd0
callq 0x1da0
cmpl $0x0, %eax
jne 0x3fc7
jmp 0x3fd0
movl $0x1, -0x4(%rbp)
jmp 0x3fe9
movl -0x8(%rbp), %eax
movl %eax, 0x818f(%rip)      # 0xc168
movl -0xc(%rbp), %eax
movl %eax, 0x817e(%rip)      # 0xc160
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/macournoyer[P]peg/leg.c
// Function: yy_SEMICOLON
YY_RULE(int) yy_SEMICOLON()
{  int yypos0= yypos, yythunkpos0= yythunkpos;
  yyprintf((stderr, "%s\n", "SEMICOLON"));  if (!yymatchChar(';')) goto l85;  if (!yy__()) goto l85;
  yyprintf((stderr, "  ok   %s @ %s\n", "SEMICOLON", yybuf+yypos));
  return 1;
  l85:;	  yypos= yypos0; yythunkpos= yythunkpos0;
  yyprintf((stderr, "  fail %s @ %s\n", "SEMICOLON", yybuf+yypos));
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl 0x815a(%rip), %eax      # 0xc168
movl %eax, -0x8(%rbp)
movl 0x8149(%rip), %eax      # 0xc160
movl %eax, -0xc(%rbp)
movl $0x3b, %edi
callq 0x1ed0
cmpl $0x0, %eax
jne 0x402b
jmp 0x4040
callq 0x1da0
cmpl $0x0, %eax
jne 0x4037
jmp 0x4040
movl $0x1, -0x4(%rbp)
jmp 0x4059
movl -0x8(%rbp), %eax
movl %eax, 0x811f(%rip)      # 0xc168
movl -0xc(%rbp), %eax
movl %eax, 0x810e(%rip)      # 0xc160
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/macournoyer[P]peg/leg.c
// Function: yy_trailer
YY_RULE(int) yy_trailer()
{  int yypos0= yypos, yythunkpos0= yythunkpos;
  yyprintf((stderr, "%s\n", "trailer"));  if (!yymatchString("%%")) goto l96;  yyText(yybegin, yyend);  if (!(YY_BEGIN)) goto l96;
  l97:;	
  {  int yypos98= yypos, yythunkpos98= yythunkpos;  if (!yymatchDot()) goto l98;  goto l97;
  l98:;	  yypos= yypos98; yythunkpos= yythunkpos98;
  }  yyText(yybegin, yyend);  if (!(YY_END)) goto l96;  yyDo(yy_1_trailer, yybegin, yyend);
  yyprintf((stderr, "  ok   %s @ %s\n", "trailer", yybuf+yypos));
  return 1;
  l96:;	  yypos= yypos0; yythunkpos= yythunkpos0;
  yyprintf((stderr, "  fail %s @ %s\n", "trailer", yybuf+yypos));
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl 0x80ea(%rip), %eax      # 0xc168
movl %eax, -0x8(%rbp)
movl 0x80d9(%rip), %eax      # 0xc160
movl %eax, -0xc(%rbp)
leaq 0x316b(%rip), %rdi      # 0x71fc
callq 0x20e0
cmpl $0x0, %eax
jne 0x40a0
jmp 0x413f
movl 0x80ca(%rip), %edi      # 0xc170
movl 0x80c0(%rip), %esi      # 0xc16c
callq 0x1b40
movl 0x80b1(%rip), %eax      # 0xc168
movl %eax, 0x80b3(%rip)      # 0xc170
movb $0x1, %al
testb $0x1, %al
jne 0x40c5
jmp 0x413f
jmp 0x40c7
movl 0x809b(%rip), %eax      # 0xc168
movl %eax, -0x10(%rbp)
movl 0x808a(%rip), %eax      # 0xc160
movl %eax, -0x14(%rbp)
callq 0x2250
cmpl $0x0, %eax
jne 0x40e5
jmp 0x40e7
jmp 0x40c7
movl -0x10(%rbp), %eax
movl %eax, 0x8078(%rip)      # 0xc168
movl -0x14(%rbp), %eax
movl %eax, 0x8067(%rip)      # 0xc160
movl 0x8071(%rip), %edi      # 0xc170
movl 0x8067(%rip), %esi      # 0xc16c
callq 0x1b40
movl 0x8058(%rip), %eax      # 0xc168
movl %eax, 0x8056(%rip)      # 0xc16c
movb $0x1, %al
testb $0x1, %al
jne 0x411e
jmp 0x413f
movl 0x804c(%rip), %esi      # 0xc170
movl 0x8042(%rip), %edx      # 0xc16c
leaq 0x3f(%rip), %rdi        # 0x4170
callq 0x23e0
movl $0x1, -0x4(%rbp)
jmp 0x4158
movl -0x8(%rbp), %eax
movl %eax, 0x8020(%rip)      # 0xc168
movl -0xc(%rbp), %eax
movl %eax, 0x800f(%rip)      # 0xc160
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/macournoyer[P]peg/leg.c
// Function: yy_end_of_file
YY_RULE(int) yy_end_of_file()
{  int yypos0= yypos, yythunkpos0= yythunkpos;
  yyprintf((stderr, "%s\n", "end_of_file"));
  {  int yypos95= yypos, yythunkpos95= yythunkpos;  if (!yymatchDot()) goto l95;  goto l94;
  l95:;	  yypos= yypos95; yythunkpos= yythunkpos95;
  }
  yyprintf((stderr, "  ok   %s @ %s\n", "end_of_file", yybuf+yypos));
  return 1;
  l94:;	  yypos= yypos0; yythunkpos= yythunkpos0;
  yyprintf((stderr, "  fail %s @ %s\n", "end_of_file", yybuf+yypos));
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl 0x7fca(%rip), %eax      # 0xc168
movl %eax, -0x8(%rbp)
movl 0x7fb9(%rip), %eax      # 0xc160
movl %eax, -0xc(%rbp)
movl 0x7fb8(%rip), %eax      # 0xc168
movl %eax, -0x10(%rbp)
movl 0x7fa7(%rip), %eax      # 0xc160
movl %eax, -0x14(%rbp)
callq 0x2250
cmpl $0x0, %eax
jne 0x41c8
jmp 0x41ca
jmp 0x41e5
movl -0x10(%rbp), %eax
movl %eax, 0x7f95(%rip)      # 0xc168
movl -0x14(%rbp), %eax
movl %eax, 0x7f84(%rip)      # 0xc160
movl $0x1, -0x4(%rbp)
jmp 0x41fe
movl -0x8(%rbp), %eax
movl %eax, 0x7f7a(%rip)      # 0xc168
movl -0xc(%rbp), %eax
movl %eax, 0x7f69(%rip)      # 0xc160
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, %edi
movl $0x30, %esi
callq 0x4290
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1180
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movl 0x7f83(%rip), %ecx      # 0xc1cc
addl $0x1, %ecx
movl %ecx, 0x7f7a(%rip)      # 0xc1cc
movq -0x10(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x2c(%rax)
movq 0x7f3d(%rip), %rcx      # 0xc1a8
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq %rax, 0x7f2a(%rip)      # 0xc1a8
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpb $0x0, (%rax)
je 0x4314
movq -0x20(%rbp), %rax
movsbl (%rax), %ecx
movl $0x2d, %eax
cmpl %ecx, %eax
jne 0x4304
movq -0x20(%rbp), %rax
movb $0x5f, (%rax)
jmp 0x4306
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x42e4
movq 0x7e8d(%rip), %rax      # 0xc1a8
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x4384
movq -0x18(%rbp), %rcx
movl $0x1, %eax
cmpl (%rcx), %eax
jne 0x4335
jmp 0x4354
leaq 0x3054(%rip), %rdi      # 0x7390
leaq 0x305d(%rip), %rsi      # 0x73a0
movl $0x40, %edx
leaq 0x3058(%rip), %rcx      # 0x73a7
callq 0x1060
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x10b0
cmpl $0x0, %eax
jne 0x4374
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4391
jmp 0x4376
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x431f
movq -0x10(%rbp), %rdi
callq 0x4210
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x43d9
jmp 0x43f8
leaq 0x2fde(%rip), %rdi      # 0x73be
leaq 0x2fb9(%rip), %rsi      # 0x73a0
movl $0x4f, %edx
leaq 0x2fd0(%rip), %rcx      # 0x73c3
callq 0x1060
movq -0x8(%rbp), %rcx
movl $0x1, %eax
cmpl (%rcx), %eax
jne 0x4407
jmp 0x4426
leaq 0x2fdd(%rip), %rdi      # 0x73eb
leaq 0x2f8b(%rip), %rsi      # 0x73a0
movl $0x53, %edx
leaq 0x2fa2(%rip), %rcx      # 0x73c3
callq 0x1060
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
cmpq $0x0, 0x7d7e(%rip)      # 0xc1b8
je 0x4455
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0x2fb3(%rip), %rsi      # 0x73fe
callq 0x10b0
cmpl $0x0, %eax
jne 0x4460
movq -0x8(%rbp), %rax
movq %rax, 0x7d58(%rip)      # 0xc1b8
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, 0x7d2c(%rip)      # 0xc1b0
je 0x4488
jmp 0x44a7
leaq 0x2f75(%rip), %rdi      # 0x7404
leaq 0x2f0a(%rip), %rsi      # 0x73a0
movl $0x5c, %edx
leaq 0x2f6b(%rip), %rcx      # 0x740d
callq 0x1060
movq 0x7d02(%rip), %rax      # 0xc1b0
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x44ed
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x10b0
cmpl $0x0, %eax
jne 0x44dd
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x453e
jmp 0x44df
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x44b6
movl $0x2, %edi
movl $0x28, %esi
callq 0x4290
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1180
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq 0x7c95(%rip), %rax      # 0xc1b0
movq 0x18(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq 0x7c7e(%rip), %rax      # 0xc1b0
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x3, %edi
movl $0x20, %esi
callq 0x4290
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movl 0x2c(%rax), %ecx
orl $0x1, %ecx
movl %ecx, 0x2c(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x420, %rsp            # imm = 0x420
movq %rdi, -0x8(%rbp)
movl $0x8, %edi
movl $0x30, %esi
callq 0x4290
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x7b06(%rip)      # 0xc1b0
je 0x46ae
jmp 0x46cd
leaq 0x2d4f(%rip), %rdi      # 0x7404
leaq 0x2ce4(%rip), %rsi      # 0x73a0
movl $0x8e, %edx
leaq 0x2d60(%rip), %rcx      # 0x7428
callq 0x1060
leaq -0x410(%rbp), %rdi
movl 0x7aee(%rip), %edx      # 0xc1c8
addl $0x1, %edx
movl %edx, 0x7ae5(%rip)      # 0xc1c8
movq 0x7ac6(%rip), %rax      # 0xc1b0
movq 0x10(%rax), %rcx
leaq 0x2d4c(%rip), %rsi      # 0x7441
movb $0x0, %al
callq 0x1160
leaq -0x410(%rbp), %rdi
callq 0x1180
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rdi
callq 0x1180
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq 0x7a72(%rip), %rcx      # 0xc1a0
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq 0x7a73(%rip), %rcx      # 0xc1b0
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movq %rax, 0x7a50(%rip)      # 0xc1a0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x418(%rbp)
movq -0x418(%rbp), %rax
cmpb $0x0, (%rax)
je 0x47bd
movq -0x418(%rbp), %rax
movsbl (%rax), %ecx
movl $0x24, %eax
cmpl %ecx, %eax
jne 0x47a7
movq -0x418(%rbp), %rax
movsbl 0x1(%rax), %ecx
movl $0x24, %eax
cmpl %ecx, %eax
jne 0x47a7
movq -0x418(%rbp), %rax
movb $0x79, (%rax)
movq -0x418(%rbp), %rax
movb $0x79, 0x1(%rax)
jmp 0x47a9
movq -0x418(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x418(%rbp)
jmp 0x475f
movq -0x10(%rbp), %rax
addq $0x420, %rsp            # imm = 0x420
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movl $0xa, %eax
cmpl (%rcx), %eax
je 0x48b2
movl $0xa, %edi
movl $0x20, %esi
callq 0x4290
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4849
jmp 0x4868
leaq 0x2b71(%rip), %rdi      # 0x73c1
leaq 0x2b49(%rip), %rsi      # 0x73a0
movl $0xaa, %edx
leaq 0x2be5(%rip), %rcx      # 0x7448
callq 0x1060
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x4875
jmp 0x4894
leaq 0x2be8(%rip), %rdi      # 0x7464
leaq 0x2b1d(%rip), %rsi      # 0x73a0
movl $0xab, %edx
leaq 0x2bb9(%rip), %rcx      # 0x7448
callq 0x1060
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x48ba
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x48e9
jmp 0x4908
leaq 0x2b81(%rip), %rdi      # 0x7471
leaq 0x2aa9(%rip), %rsi      # 0x73a0
movl $0xb5, %edx
leaq 0x2b70(%rip), %rcx      # 0x7473
callq 0x1060
movq -0x8(%rbp), %rdi
callq 0x4810
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x4922
jmp 0x4941
leaq 0x2b71(%rip), %rdi      # 0x749a
leaq 0x2a70(%rip), %rsi      # 0x73a0
movl $0xb7, %edx
leaq 0x2b37(%rip), %rcx      # 0x7473
callq 0x1060
cmpq $0x0, -0x10(%rbp)
je 0x494a
jmp 0x4969
leaq 0x2a70(%rip), %rdi      # 0x73c1
leaq 0x2a48(%rip), %rsi      # 0x73a0
movl $0xb8, %edx
leaq 0x2b0f(%rip), %rcx      # 0x7473
callq 0x1060
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movl $0xb, %eax
cmpl (%rcx), %eax
je 0x4a32
movl $0xb, %edi
movl $0x20, %esi
callq 0x4290
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x49c9
jmp 0x49e8
leaq 0x29f1(%rip), %rdi      # 0x73c1
leaq 0x29c9(%rip), %rsi      # 0x73a0
movl $0xc3, %edx
leaq 0x2ac9(%rip), %rcx      # 0x74ac
callq 0x1060
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x49f5
jmp 0x4a14
leaq 0x2a68(%rip), %rdi      # 0x7464
leaq 0x299d(%rip), %rsi      # 0x73a0
movl $0xc4, %edx
leaq 0x2a9d(%rip), %rcx      # 0x74ac
callq 0x1060
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4a3a
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4a69
jmp 0x4a88
leaq 0x2a01(%rip), %rdi      # 0x7471
leaq 0x2929(%rip), %rsi      # 0x73a0
movl $0xce, %edx
leaq 0x2a44(%rip), %rcx      # 0x74c7
callq 0x1060
movq -0x8(%rbp), %rdi
callq 0x4990
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x4aa2
jmp 0x4ac1
leaq 0x2a44(%rip), %rdi      # 0x74ed
leaq 0x28f0(%rip), %rsi      # 0x73a0
movl $0xd0, %edx
leaq 0x2a0b(%rip), %rcx      # 0x74c7
callq 0x1060
cmpq $0x0, -0x10(%rbp)
je 0x4aca
jmp 0x4ae9
leaq 0x28f0(%rip), %rdi      # 0x73c1
leaq 0x28c8(%rip), %rsi      # 0x73a0
movl $0xd1, %edx
leaq 0x29e3(%rip), %rcx      # 0x74c7
callq 0x1060
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop