LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x7d9d(%rip), %eax      # 0xa150
cmpl 0x7d93(%rip), %eax      # 0xa14c
jl 0x23c4
callq 0x1e77
testl %eax, %eax
je 0x23f9
movq 0x7d4d(%rip), %rcx      # 0xa118
movslq 0x7d7e(%rip), %rax      # 0xa150
movsbl (%rcx,%rax), %ecx
movl %ecx, %edx
sarl $0x3, %edx
movslq %edx, %rdx
movzbl (%rbx,%rdx), %edx
andl $0x7, %ecx
btl %ecx, %edx
jae 0x23f9
incl %eax
movl %eax, 0x7d5e(%rip)      # 0xa150
movl $0x1, %eax
jmp 0x23fb
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x7d4a(%rip), %ebx      # 0xa150
movl 0x7d3c(%rip), %ebp      # 0xa148
movl $0x3d, %edi
callq 0x1e34
testl %eax, %eax
je 0x2426
callq 0x1cea
movl $0x1, %eax
jmp 0x2434
movl %ebx, 0x7d24(%rip)      # 0xa150
movl %ebp, 0x7d16(%rip)      # 0xa148
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/macournoyer[P]peg/leg.c
// Function: yy_expression
YY_RULE(int) yy_expression()
{  int yypos0= yypos, yythunkpos0= yythunkpos;
  yyprintf((stderr, "%s\n", "expression"));  if (!yy_sequence()) goto l86;
  l87:;	
  {  int yypos88= yypos, yythunkpos88= yythunkpos;  if (!yy_BAR()) goto l88;  if (!yy_sequence()) goto l88;  yyDo(yy_1_expression, yybegin, yyend);  goto l87;
  l88:;	  yypos= yypos88; yythunkpos= yythunkpos88;
  }
  yyprintf((stderr, "  ok   %s @ %s\n", "expression", yybuf+yypos));
  return 1;
  l86:;	  yypos= yypos0; yythunkpos= yythunkpos0;
  yyprintf((stderr, "  fail %s @ %s\n", "expression", yybuf+yypos));
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl 0x7d06(%rip), %r15d     # 0xa150
movl 0x7cf7(%rip), %r12d     # 0xa148
callq 0x24fb
testl %eax, %eax
je 0x24be
leaq 0x78(%rip), %rbx        # 0x24d9
movl $0x1, %ebp
movl 0x7ce3(%rip), %r15d     # 0xa150
movl 0x7cd4(%rip), %r12d     # 0xa148
movl $0x7c, %edi
callq 0x1e34
movl %eax, %r14d
testl %eax, %eax
je 0x248c
callq 0x1cea
jmp 0x249a
movl %r15d, 0x7cbd(%rip)     # 0xa150
movl %r12d, 0x7cae(%rip)     # 0xa148
testl %r14d, %r14d
je 0x24c0
callq 0x24fb
testl %eax, %eax
je 0x24c0
movl 0x7caa(%rip), %esi      # 0xa158
movl 0x7ca0(%rip), %edx      # 0xa154
movq %rbx, %rdi
callq 0x2130
jmp 0x2466
xorl %ebp, %ebp
movl %r15d, 0x7c89(%rip)     # 0xa150
movl %r12d, 0x7c7a(%rip)     # 0xa148
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x7c48(%rip), %ebx      # 0xa150
movl 0x7c3a(%rip), %ebp      # 0xa148
callq 0x25a1
testl %eax, %eax
je 0x2566
leaq 0x61(%rip), %rbx        # 0x257f
movl 0x7c2b(%rip), %r14d     # 0xa150
movl 0x7c1c(%rip), %r15d     # 0xa148
callq 0x25a1
movl %eax, %ebp
testl %eax, %eax
je 0x254d
movl 0x7c1b(%rip), %esi      # 0xa158
movl 0x7c11(%rip), %edx      # 0xa154
movq %rbx, %rdi
callq 0x2130
jmp 0x255b
movl %r14d, 0x7bfc(%rip)     # 0xa150
movl %r15d, 0x7bed(%rip)     # 0xa148
testl %ebp, %ebp
jne 0x251e
movl $0x1, %eax
jmp 0x2574
movl %ebx, 0x7be4(%rip)      # 0xa150
movl %ebp, 0x7bd6(%rip)      # 0xa148
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
movl 0x7ba5(%rip), %ebp      # 0xa150
movl 0x7b96(%rip), %r14d     # 0xa148
callq 0x26db
testl %eax, %eax
je 0x25dc
callq 0x2719
testl %eax, %eax
je 0x25dc
movl 0x7b8e(%rip), %esi      # 0xa158
movl 0x7b84(%rip), %edx      # 0xa154
leaq 0xc7(%rip), %rdi        # 0x269e
jmp 0x2661
movl %ebp, 0x7b6e(%rip)      # 0xa150
movl %r14d, 0x7b5f(%rip)     # 0xa148
callq 0x26db
testl %eax, %eax
je 0x2610
callq 0x28cc
testl %eax, %eax
je 0x2610
movl 0x7b57(%rip), %esi      # 0xa158
movl 0x7b4d(%rip), %edx      # 0xa154
leaq 0x9f(%rip), %rdi        # 0x26ad
jmp 0x2661
movl %ebp, 0x7b3a(%rip)      # 0xa150
movl %r14d, 0x7b2b(%rip)     # 0xa148
movl $0x21, %edi
callq 0x1e34
movl %eax, %ebx
testl %eax, %eax
je 0x2634
callq 0x1cea
jmp 0x2641
movl %ebp, 0x7b16(%rip)      # 0xa150
movl %r14d, 0x7b07(%rip)     # 0xa148
testl %ebx, %ebx
je 0x2670
callq 0x28cc
testl %eax, %eax
je 0x2670
movl 0x7b04(%rip), %esi      # 0xa158
movl 0x7afa(%rip), %edx      # 0xa154
leaq 0x63(%rip), %rdi        # 0x26c4
callq 0x2130
movl $0x1, %eax
popq %rbx
popq %r14
popq %rbp
retq
movl %ebp, 0x7ada(%rip)      # 0xa150
movl %r14d, 0x7acb(%rip)     # 0xa148
callq 0x28cc
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
jne 0x266b
movl %ebp, 0x7abd(%rip)      # 0xa150
movl %r14d, 0x7aae(%rip)     # 0xa148
xorl %eax, %eax
jmp 0x266b
// File: /workspace/github_c_makefile_star2_O1/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 0x7a6c(%rip), %ebx      # 0xa150
movl 0x7a5e(%rip), %ebp      # 0xa148
movl $0x26, %edi
callq 0x1e34
testl %eax, %eax
je 0x2704
callq 0x1cea
movl $0x1, %eax
jmp 0x2712
movl %ebx, 0x7a46(%rip)      # 0xa150
movl %ebp, 0x7a38(%rip)      # 0xa148
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x7a26(%rip), %ebx      # 0xa150
movl 0x7a18(%rip), %ebp      # 0xa148
movl $0x7b, %edi
callq 0x1e34
testl %eax, %eax
je 0x28af
movl 0x7a10(%rip), %edi      # 0xa158
movl 0x7a06(%rip), %esi      # 0xa154
callq 0x1a82
movl 0x79f7(%rip), %eax      # 0xa150
movl %eax, 0x79f9(%rip)      # 0xa158
movl 0x79ea(%rip), %r14d     # 0xa150
movl 0x79db(%rip), %r15d     # 0xa148
movl $0x7b, %edi
callq 0x1e34
testl %eax, %eax
je 0x2804
movl 0x79ca(%rip), %r12d     # 0xa150
movl 0x79bb(%rip), %r13d     # 0xa148
movl $0x7d, %edi
callq 0x1e34
movl $0x5, %ecx
testl %eax, %eax
jne 0x27b0
movl %r12d, 0x79a9(%rip)     # 0xa150
movl %r13d, 0x799a(%rip)     # 0xa148
xorl %ecx, %ecx
cmpl $0x5, %ecx
je 0x27dd
testl %ecx, %ecx
jne 0x27ed
movl 0x7991(%rip), %eax      # 0xa150
cmpl 0x7987(%rip), %eax      # 0xa14c
jl 0x27d0
callq 0x1e77
testl %eax, %eax
je 0x27dd
incl 0x797a(%rip)            # 0xa150
movl $0x3, %ecx
jmp 0x27ed
movl %r12d, 0x796c(%rip)     # 0xa150
movl %r13d, 0x795d(%rip)     # 0xa148
xorl %ecx, %ecx
testl %ecx, %ecx
jne 0x277f
movl $0x7d, %edi
callq 0x1e34
movl $0x6, %ecx
testl %eax, %eax
jne 0x2858
movl %r14d, 0x7945(%rip)     # 0xa150
movl %r15d, 0x7936(%rip)     # 0xa148
movl $0x7d, %edi
callq 0x1e34
movl $0x8, %ecx
testl %eax, %eax
jne 0x2835
movl %r14d, 0x7924(%rip)     # 0xa150
movl %r15d, 0x7915(%rip)     # 0xa148
xorl %ecx, %ecx
testl %eax, %eax
jne 0x2858
movl 0x7911(%rip), %eax      # 0xa150
cmpl 0x7907(%rip), %eax      # 0xa14c
jl 0x2850
callq 0x1e77
testl %eax, %eax
je 0x2863
incl 0x78fa(%rip)            # 0xa150
xorl %ecx, %ecx
cmpl $0x8, %ecx
jne 0x275f
jmp 0x286a
movl $0x8, %ecx
jmp 0x2858
movl %r14d, 0x78df(%rip)     # 0xa150
movl %r15d, 0x78d0(%rip)     # 0xa148
movl 0x78da(%rip), %edi      # 0xa158
movl 0x78d0(%rip), %esi      # 0xa154
callq 0x1a82
movl 0x78c1(%rip), %eax      # 0xa150
movl %eax, 0x78bf(%rip)      # 0xa154
movl $0x7d, %edi
callq 0x1e34
testl %eax, %eax
je 0x28af
callq 0x1cea
movl $0x1, %eax
jmp 0x28bd
movl %ebx, 0x789b(%rip)      # 0xa150
movl %ebp, 0x788d(%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_O1/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 0x6fe9(%rip), %ebx      # 0xa150
movl 0x6fdb(%rip), %ebp      # 0xa148
movl $0x3c, %edi
callq 0x1e34
testl %eax, %eax
je 0x3187
callq 0x1cea
movl $0x1, %eax
jmp 0x3195
movl %ebx, 0x6fc3(%rip)      # 0xa150
movl %ebp, 0x6fb5(%rip)      # 0xa148
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6fab(%rip), %ebx      # 0xa150
movl 0x6f9d(%rip), %ebp      # 0xa148
movl $0x3e, %edi
callq 0x1e34
testl %eax, %eax
je 0x31c5
callq 0x1cea
movl $0x1, %eax
jmp 0x31d3
movl %ebx, 0x6f85(%rip)      # 0xa150
movl %ebp, 0x6f77(%rip)      # 0xa148
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6f9f(%rip), %eax      # 0xa1bc
incl %eax
movl %eax, 0x6f97(%rip)      # 0xa1bc
movl %eax, 0x28(%r14)
movl $0x0, 0x2c(%r14)
movq 0x6f60(%rip), %rax      # 0xa198
movq %rax, 0x8(%r14)
movq %r14, 0x6f55(%rip)      # 0xa198
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3266
testl %ecx, %ecx
jne 0x3269
jmp 0x326e
movb $0x5f, (%rax)
incq %rax
jmp 0x3258
movq 0x6f23(%rip), %r14      # 0xa198
testq %r14, %r14
je 0x3296
cmpl $0x1, (%r14)
jne 0x32b0
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0x10b0
testl %eax, %eax
je 0x32a5
movq 0x8(%r14), %r14
jmp 0x3275
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x31ec
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x206d(%rip), %rdi      # 0x5324
leaq 0x2076(%rip), %rsi      # 0x5334
leaq 0x2076(%rip), %rcx      # 0x533b
movl $0x40, %edx
callq 0x1060
// File: /workspace/github_c_makefile_star2_O1/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 0x331d
movq %rdi, %rbx
cmpl $0x1, (%rdi)
jne 0x333c
movq %rsi, 0x20(%rbx)
cmpq $0x0, 0x6eaa(%rip)      # 0xa1a8
je 0x3314
movq 0x10(%rbx), %rdi
leaq 0x2087(%rip), %rsi      # 0x5392
callq 0x10b0
testl %eax, %eax
jne 0x331b
movq %rbx, 0x6e8d(%rip)      # 0xa1a8
popq %rbx
retq
leaq 0x202e(%rip), %rdi      # 0x5352
leaq 0x2009(%rip), %rsi      # 0x5334
leaq 0x2025(%rip), %rcx      # 0x5357
movl $0x4f, %edx
callq 0x1060
leaq 0x203c(%rip), %rdi      # 0x537f
leaq 0x1fea(%rip), %rsi      # 0x5334
leaq 0x2006(%rip), %rcx      # 0x5357
movl $0x53, %edx
callq 0x1060
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq 0x6e39(%rip), %r15      # 0xa1a0
testq %r15, %r15
je 0x33c7
movq %rdi, %r14
movq 0x18(%r15), %rbx
testq %rbx, %rbx
je 0x338e
movq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x10b0
testl %eax, %eax
je 0x33be
movq 0x8(%rbx), %rbx
jmp 0x3373
movl $0x1, %edi
movl $0x28, %esi
callq 0x10a0
movq %rax, %rbx
movl $0x2, (%rax)
movq %r14, %rdi
callq 0x1190
movq %rax, 0x10(%rbx)
movq 0x18(%r15), %rax
movq %rax, 0x8(%rbx)
movq %rbx, 0x18(%r15)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1fca(%rip), %rdi      # 0x5398
leaq 0x1f5f(%rip), %rsi      # 0x5334
leaq 0x1fc5(%rip), %rcx      # 0x53a1
movl $0x5c, %edx
callq 0x1060
// File: /workspace/github_c_makefile_star2_O1/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)
movq $0x0, 0x18(%rax)
orb $0x1, 0x2c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6ca7(%rip), %rax      # 0xa1a0
testq %rax, %rax
je 0x358c
movl 0x6cb0(%rip), %edx      # 0xa1b8
incl %edx
movl %edx, 0x6ca8(%rip)      # 0xa1b8
movq 0x10(%rax), %rcx
leaq 0x1eba(%rip), %rsi      # 0x53d5
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 0x6c49(%rip), %rcx      # 0xa190
movq %rcx, 0x18(%rbx)
movq 0x6c4e(%rip), %rcx      # 0xa1a0
movq %rcx, 0x28(%rbx)
movq %rbx, 0x6c33(%rip)      # 0xa190
incq %rax
movzbl -0x1(%rax), %ecx
cmpl $0x24, %ecx
je 0x356f
testl %ecx, %ecx
jne 0x355d
jmp 0x357c
cmpb $0x24, (%rax)
jne 0x355d
movw $0x7979, -0x1(%rax)     # imm = 0x7979
jmp 0x355d
movq %rbx, %rax
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1e05(%rip), %rdi      # 0x5398
leaq 0x1d9a(%rip), %rsi      # 0x5334
leaq 0x1e1b(%rip), %rcx      # 0x53bc
movl $0x8e, %edx
callq 0x1060
// File: /workspace/github_c_makefile_star2_O1/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 0x3611
movl $0x1, %edi
movl $0x20, %esi
callq 0x10a0
movl $0xa, (%rax)
cmpq $0x0, 0x8(%rbx)
jne 0x3616
movq %rbx, 0x18(%rax)
movq %rbx, 0x10(%rax)
movq %rax, %rbx
movq %rbx, %rax
popq %rbx
retq
leaq 0x1ddb(%rip), %rdi      # 0x53f8
leaq 0x1d10(%rip), %rsi      # 0x5334
leaq 0x1db1(%rip), %rcx      # 0x53dc
movl $0xab, %edx
callq 0x1060
// File: /workspace/github_c_makefile_star2_O1/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 0x365b
movq %rsi, %rbx
callq 0x35e1
movq 0x18(%rax), %rcx
testq %rcx, %rcx
je 0x367a
testq %rbx, %rbx
je 0x3699
movq %rbx, 0x8(%rcx)
movq %rbx, 0x18(%rax)
popq %rbx
retq
leaq 0x1da3(%rip), %rdi      # 0x5405
leaq 0x1ccb(%rip), %rsi      # 0x5334
leaq 0x1d97(%rip), %rcx      # 0x5407
movl $0xb5, %edx
callq 0x1060
leaq 0x1dad(%rip), %rdi      # 0x542e
leaq 0x1cac(%rip), %rsi      # 0x5334
leaq 0x1d78(%rip), %rcx      # 0x5407
movl $0xb7, %edx
callq 0x1060
leaq 0x1cb5(%rip), %rdi      # 0x5355
leaq 0x1c8d(%rip), %rsi      # 0x5334
leaq 0x1d59(%rip), %rcx      # 0x5407
movl $0xb8, %edx
callq 0x1060
// File: /workspace/github_c_makefile_star2_O1/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 0x36e8
movl $0x1, %edi
movl $0x20, %esi
callq 0x10a0
movl $0xb, (%rax)
cmpq $0x0, 0x8(%rbx)
jne 0x36ed
movq %rbx, 0x18(%rax)
movq %rbx, 0x10(%rax)
movq %rax, %rbx
movq %rbx, %rax
popq %rbx
retq
leaq 0x1d04(%rip), %rdi      # 0x53f8
leaq 0x1c39(%rip), %rsi      # 0x5334
leaq 0x1d3e(%rip), %rcx      # 0x5440
movl $0xc4, %edx
callq 0x1060
// File: /workspace/github_c_makefile_star2_O1/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 0x3732
movq %rsi, %rbx
callq 0x36b8
movq 0x18(%rax), %rcx
testq %rcx, %rcx
je 0x3751
testq %rbx, %rbx
je 0x3770
movq %rbx, 0x8(%rcx)
movq %rbx, 0x18(%rax)
popq %rbx
retq
leaq 0x1ccc(%rip), %rdi      # 0x5405
leaq 0x1bf4(%rip), %rsi      # 0x5334
leaq 0x1d14(%rip), %rcx      # 0x545b
movl $0xce, %edx
callq 0x1060
leaq 0x1d29(%rip), %rdi      # 0x5481
leaq 0x1bd5(%rip), %rsi      # 0x5334
leaq 0x1cf5(%rip), %rcx      # 0x545b
movl $0xd0, %edx
callq 0x1060
leaq 0x1bde(%rip), %rdi      # 0x5355
leaq 0x1bb6(%rip), %rsi      # 0x5334
leaq 0x1cd6(%rip), %rcx      # 0x545b
movl $0xd1, %edx
callq 0x1060
// File: /workspace/github_c_makefile_star2_O1/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 0x3857
movq 0x68b9(%rip), %rax      # 0xa0f0
leaq 0x897a(%rip), %rcx      # 0xc1b8
cmpq %rcx, %rax
jae 0x3876
leaq 0x8(%rax), %rcx
movq %rcx, 0x68a2(%rip)      # 0xa0f0
movq %rdi, 0x8(%rax)
movq %rdi, %rax
popq %rcx
retq
leaq 0x1af4(%rip), %rdi      # 0x5352
leaq 0x1acf(%rip), %rsi      # 0x5334
leaq 0x1c26(%rip), %rcx      # 0x5492
movl $0x10e, %edx            # imm = 0x10E
callq 0x1060
leaq 0x1c28(%rip), %rdi      # 0x54a5
leaq 0x1ab0(%rip), %rsi      # 0x5334
leaq 0x1c07(%rip), %rcx      # 0x5492
movl $0x10f, %edx            # imm = 0x10F
callq 0x1060
// File: /workspace/github_c_makefile_star2_O1/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 0x6634(%rip), %rbx      # 0xa1b0
movq (%rbx), %rdi
leaq 0x1ac6(%rip), %rsi      # 0x564c
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 0x1be3(%rip), %rdi      # 0x5794
callq 0x1070
movq (%rbx), %rdi
leaq 0x65fc(%rip), %rax      # 0xa1bc
movl (%rax), %edx
leaq 0x1abf(%rip), %rsi      # 0x5688
xorl %eax, %eax
popq %rbx
jmp 0x10c0
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x19b1(%rip), %rax      # 0x5590
xorl %ebx, %ebx
testq %r14, %r14
je 0x3c7e
movl (%r14), %edi
leal -0x1(%rdi), %ecx
cmpl $0xf, %ecx
ja 0x3c8f
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq 0x10(%r14), %r14
jmp 0x3be1
movl $0x1, %ebx
jmp 0x3c7e
movq 0x10(%r14), %rax
xorl %ebx, %ebx
cmpb $0x0, (%rax)
setne %bl
jmp 0x3c7e
movq 0x10(%r14), %rbx
testq %rbx, %rbx
sete %bpl
je 0x3c7a
movq %rbx, %rdi
callq 0x3bd1
testl %eax, %eax
je 0x3c7a
movq 0x8(%rbx), %rbx
jmp 0x3c21
movl 0x2c(%r14), %eax
testb $0x2, %al
jne 0x3c85
orl $0x2, %eax
movl %eax, 0x2c(%r14)
movq 0x20(%r14), %rdi
callq 0x3bd1
andb $-0x3, 0x2c(%r14)
jmp 0x3c80
movq 0x10(%r14), %rbx
testq %rbx, %rbx
setne %bpl
je 0x3c7a
movq %rbx, %rdi
callq 0x3bd1
testl %eax, %eax
jne 0x3c7a
movq 0x8(%rbx), %rbx
jmp 0x3c5f
movzbl %bpl, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %r14, %rdi
callq 0x1343
jmp 0x3c7e
callq 0x1362
// File: /workspace/github_c_makefile_star2_O1/macournoyer[P]peg/compile.c
// Function: Rule_compile_c
void Rule_compile_c(Node *node)
{
  Node *n;

  for (n= rules;  n;  n= n->rule.next)
    consumesInput(n);

  fprintf(output, "%s", preamble);
  for (n= node;  n;  n= n->rule.next)
    fprintf(output, "YY_RULE(int) yy_%s(); /* %d */\n", n->rule.name, n->rule.id);
  fprintf(output, "\n");
  for (n= actions;  n;  n= n->action.list)
    {
      fprintf(output, "YY_ACTION(void) yy%s(char *yytext, int yyleng)\n{\n", n->action.name);
      fprintf(output, "  (void)yytext; (void)yyleng;\n");
      defineVariables(n->action.rule->rule.variables);
      fprintf(output, "  yyprintf((stderr, \"do yy%s\\n\"));\n", n->action.name);
      fprintf(output, "  %s;\n", n->action.text);
      undefineVariables(n->action.rule->rule.variables);
      fprintf(output, "}\n");
    }
  Rule_compile_c2(node);
  fprintf(output, footer, start->rule.name);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
leaq 0x64ef(%rip), %rax      # 0xa198
movq (%rax), %rbx
testq %rbx, %rbx
je 0x3cbf
movq %rbx, %rdi
callq 0x3bd1
movq 0x8(%rbx), %rbx
jmp 0x3cac
leaq 0x64ea(%rip), %r12      # 0xa1b0
movq (%r12), %rsi
leaq 0x1aff(%rip), %rdi      # 0x57d0
callq 0x1070
testq %r15, %r15
je 0x3d04
leaq 0x1a13(%rip), %rbx      # 0x56f5
movq %r15, %r14
movq (%r12), %rdi
movq 0x10(%r14), %rdx
movl 0x28(%r14), %ecx
movq %rbx, %rsi
xorl %eax, %eax
callq 0x10c0
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0x3ce5
movq %r15, (%rsp)
movq (%r12), %rsi
movl $0xa, %edi
callq 0x1090
leaq 0x6473(%rip), %rax      # 0xa190
movq (%rax), %r13
testq %r13, %r13
je 0x3e17
leaq 0x2cbf(%rip), %rbx      # 0x69ef
leaq 0x2ca2(%rip), %r14      # 0x69d9
movq (%r12), %rdi
movq 0x20(%r13), %rdx
leaq 0x19cf(%rip), %rsi      # 0x5715
xorl %eax, %eax
callq 0x10c0
movq (%r12), %rcx
movl $0x1e, %esi
movl $0x1, %edx
leaq 0x19e5(%rip), %rdi      # 0x5747
callq 0x1180
movq 0x28(%r13), %rax
movq 0x18(%rax), %rbp
testq %rbp, %rbp
je 0x3d9f
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
movq (%r12), %rdi
movq 0x10(%rbp), %rdx
movq %r14, %rsi
movl %r15d, %ecx
xorl %eax, %eax
callq 0x10c0
movl %r15d, 0x20(%rbp)
movq 0x8(%rbp), %rbp
decl %r15d
testq %rbp, %rbp
jne 0x3d7a
movq (%r12), %rdi
movq 0x20(%r13), %rdx
leaq 0x19b8(%rip), %rsi      # 0x5766
xorl %eax, %eax
callq 0x10c0
movq (%r12), %rdi
movq 0x10(%r13), %rdx
leaq 0x19c6(%rip), %rsi      # 0x578a
xorl %eax, %eax
callq 0x10c0
movq 0x28(%r13), %rax
movq 0x18(%rax), %r15
testq %r15, %r15
je 0x3df0
movq (%r12), %rdi
movq 0x10(%r15), %rdx
movq %rbx, %rsi
xorl %eax, %eax
callq 0x10c0
movq 0x8(%r15), %r15
jmp 0x3dd3
movq (%r12), %rcx
movl $0x2, %esi
movl $0x1, %edx
leaq 0x198c(%rip), %rdi      # 0x5791
callq 0x1180
movq 0x18(%r13), %r13
testq %r13, %r13
jne 0x3d37
movq (%rsp), %rdi
callq 0x3e4e
movq (%r12), %rdi
leaq 0x637d(%rip), %rax      # 0xa1a8
movq (%rax), %rax
movq 0x10(%rax), %rdx
leaq 0x2f36(%rip), %rsi      # 0x6d6f
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x10c0
// File: /workspace/github_c_makefile_star2_O1/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 0x4bb8
movq %rax, %rbx
movl $0xa, %edi
xorl %esi, %esi
callq 0x4bb8
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
callq 0x4d99
movq %r14, %rdi
xorl %esi, %esi
callq 0x4d99
movq %rbx, %rdi
callq 0x4bf8
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0x1515(%rip), %rsi      # 0x5318
leaq 0x17fc(%rip), %rcx      # 0x5606
leaq 0x1518(%rip), %r8       # 0x5329
movl $0x14, %edx
xorl %eax, %eax
callq 0x25cc
testl %eax, %eax
je 0x3e6e
movq %r14, %rdi
callq 0x4bf8
xorl %edi, %edi
cmpl $0xa, %eax
sete %dil
leaq 0x14df(%rip), %rsi      # 0x5318
leaq 0x17c6(%rip), %rcx      # 0x5606
leaq 0x14f8(%rip), %r8       # 0x533f
movl $0x15, %edx
xorl %eax, %eax
callq 0x25cc
testl %eax, %eax
je 0x3e6e
movq %rbx, %rdi
callq 0x4da2
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4da2
callq 0x2e13
// File: /workspace/github_c_makefile_star2_O1/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 0x4bb8
movq %rax, 0x8(%rsp)
movl $0xfa0, %edi            # imm = 0xFA0
callq 0x21a0
movq %rax, (%rsp)
leaq 0x1474(%rip), %r12      # 0x5318
leaq 0x175b(%rip), %rbx      # 0x5606
xorl %r14d, %r14d
xorl %r13d, %r13d
movq 0x8(%rsp), %r15
cmpq $0xfa0, %r14            # imm = 0xFA0
je 0x3f52
movq (%rsp), %rax
leaq (%rax,%r14), %rbp
movq %r15, %rdi
movq %rbp, %rsi
callq 0x4c89
movq %r15, %rdi
callq 0x4bf8
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 0x1453(%rip), %r8       # 0x5357
xorl %eax, %eax
callq 0x25cc
testl %eax, %eax
je 0x3f4d
movq %r15, %rdi
movl %r13d, %esi
callq 0x4bfc
xorl %edi, %edi
cmpq %rax, %rbp
sete %dil
movq %r12, %rsi
movl $0x24, %edx
movq %rbx, %rcx
leaq 0x143a(%rip), %r8       # 0x536f
xorl %eax, %eax
callq 0x25cc
addq $0x4, %r14
movq 0x10(%rsp), %r13
testl %eax, %eax
jne 0x3eb6
callq 0x2e13
leaq 0x13bf(%rip), %r15      # 0x5318
leaq 0x16a6(%rip), %r12      # 0x5606
leaq 0x1408(%rip), %r13      # 0x536f
movq (%rsp), %r14
xorl %ebp, %ebp
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x4bfc
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 0x3f4d
incq %rbp
addq $0x4, %r14
cmpq $0x3e8, %rbp            # imm = 0x3E8
jne 0x3f72
movq %rbx, %rdi
callq 0x4da2
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_O1/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 0x4bb8
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 0x4c2f
incq %r14
addq $0x4, %r15
cmpq $0x3e8, %r14            # imm = 0x3E8
jne 0x3ffa
movq %rbp, (%rsp)
addq $0xf9c, %rbp            # imm = 0xF9C
movl $0x3e7, %r15d           # imm = 0x3E7
leaq 0x12e8(%rip), %r12      # 0x5318
leaq 0x15cf(%rip), %r13      # 0x5606
leaq 0x1354(%rip), %r14      # 0x5392
movq %rbx, %rdi
movl %r15d, %esi
callq 0x4bfc
xorl %edi, %edi
cmpq %rax, %rbp
sete %dil
movq %r12, %rsi
movl $0x3a, %edx
movq %r13, %rcx
leaq 0x130b(%rip), %r8       # 0x536f
xorl %eax, %eax
callq 0x25cc
testl %eax, %eax
je 0x40cc
movq %rbx, %rdi
callq 0x4cca
movq %rbx, %rdi
callq 0x4bf8
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 0x40cc
addq $-0x4, %rbp
addq $-0x1, %r15
jb 0x403e
movq %rbx, %rdi
callq 0x4da2
movq (%rsp), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x22a0
callq 0x2e13
// File: /workspace/github_c_makefile_star2_O1/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 0x4bb8
movq %rax, %rbx
movq %rax, %rdi
callq 0x4bf8
xorl %edi, %edi
cmpl $0x1f4, %eax            # imm = 0x1F4
sete %dil
leaq 0x120e(%rip), %rsi      # 0x5318
leaq 0x14f5(%rip), %rcx      # 0x5606
leaq 0x1290(%rip), %r8       # 0x53a8
movl $0x46, %edx
xorl %eax, %eax
callq 0x25cc
testl %eax, %eax
je 0x41fe
movq %rbx, %rdi
xorl %esi, %esi
callq 0x4c89
decl %ebp
jne 0x412c
movl $0xfa0, %edi            # imm = 0xFA0
callq 0x21a0
movq %rax, %r14
leaq 0x11ca(%rip), %r15      # 0x5318
leaq 0x14b1(%rip), %r12      # 0x5606
leaq 0x1213(%rip), %rbp      # 0x536f
movq %rax, (%rsp)
xorl %r13d, %r13d
movq %rbx, %rdi
movl %r13d, %esi
callq 0x4bfc
xorl %edi, %edi
testq %rax, %rax
sete %dil
movq %r15, %rsi
movl $0x4e, %edx
movq %r12, %rcx
leaq 0x1237(%rip), %r8       # 0x53c0
xorl %eax, %eax
callq 0x25cc
testl %eax, %eax
je 0x41fe
movq %rbx, %rdi
movl %r13d, %esi
movq %r14, %rdx
callq 0x4c2f
movq %rbx, %rdi
movl %r13d, %esi
callq 0x4bfc
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 0x41fe
incq %r13
addq $0x4, %r14
cmpq $0x3e8, %r13            # imm = 0x3E8
jne 0x4163
movq %rbx, %rdi
callq 0x4da2
movq (%rsp), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x22a0
callq 0x2e13
// File: /workspace/github_c_makefile_star2_O1/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 0x4bb8
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 0x4c2f
incq %r14
addq $0x4, %r15
cmpq $0x3e8, %r14            # imm = 0x3E8
jne 0x4467
leaq 0x8(%rsp), %r15
movl $0x0, (%r15)
leaq -0x6b(%rip), %r12       # 0x4430
leaq 0xe76(%rip), %r13       # 0x5318
leaq 0x115d(%rip), %rbp      # 0x5606
leaq 0xfdb(%rip), %r14       # 0x548b
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x4d45
movl (%rax), %eax
xorl %edi, %edi
cmpl 0x8(%rsp), %eax
sete %dil
movq %r13, %rsi
movl $0x82, %edx
movq %rbp, %rcx
leaq 0xfa7(%rip), %r8        # 0x5483
xorl %eax, %eax
callq 0x25cc
testl %eax, %eax
je 0x45ee
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x4e3a
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4e36
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 0x45ee
movl 0x8(%rsp), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x8(%rsp)
cmpl $0x3e7, %eax            # imm = 0x3E7
jl 0x44b0
leaq 0xc(%rsp), %rsi
movl $0xfffffff4, (%rsi)     # imm = 0xFFFFFFF4
leaq -0x125(%rip), %rdx      # 0x4430
movq %rbx, %rdi
callq 0x4d45
xorl %edi, %edi
testq %rax, %rax
sete %dil
leaq 0xdab(%rip), %rsi       # 0x5318
leaq 0x1092(%rip), %rcx      # 0x5606
leaq 0xf39(%rip), %r8        # 0x54b4
movl $0x89, %edx
xorl %eax, %eax
callq 0x25cc
testl %eax, %eax
je 0x45ee
leaq -0x162(%rip), %rdx      # 0x4430
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x4e3a
xorl %edi, %edi
testq %rax, %rax
sete %dil
leaq 0xd69(%rip), %rsi       # 0x5318
leaq 0x1050(%rip), %rcx      # 0x5606
leaq 0xf2b(%rip), %r8        # 0x54e8
movl $0x8a, %edx
xorl %eax, %eax
callq 0x25cc
testl %eax, %eax
je 0x45ee
movq %rbx, %rdi
callq 0x4da2
movq 0x10(%rsp), %rdi
callq 0x22a0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2e13
// File: /workspace/github_c_makefile_star2_O1/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 0x39c5(%rip), %rsi      # 0x7fc0
movl $0x1, %edi
callq 0x4bb8
movq %rax, %rbx
movl $0x1, %edi
callq 0x21a0
movq %rbx, %rdi
xorl %esi, %esi
movq %rax, %rdx
callq 0x4c2f
movl $0x1, %edi
callq 0x21a0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4c89
movq %rbx, %rdi
callq 0x4cca
movq %rbx, %rdi
popq %rbx
jmp 0x4da2
// File: /workspace/github_c_makefile_star2_O1/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 0xb243(%rip), %rdx      # 0xec2e
movq %rsp, %r14
movl $0x1000, %esi           # imm = 0x1000
movq %r14, %rdi
xorl %eax, %eax
callq 0x2140
leaq 0xaf2a(%rip), %rsi      # 0xe92e
movq %r14, %rdi
callq 0x21e0
movq %rax, 0x58(%rbx)
testq %rax, %rax
je 0x3a78
movq 0x80(%rbx), %rcx
leaq 0xb22e(%rip), %rdx      # 0xec51
movq %rsp, %r14
movl $0x1000, %esi           # imm = 0x1000
movq %r14, %rdi
xorl %eax, %eax
callq 0x2140
leaq 0xaef2(%rip), %rsi      # 0xe92e
movq %r14, %rdi
callq 0x21e0
movq %rax, 0x60(%rbx)
testq %rax, %rax
je 0x3a80
movq 0x60(%rbx), %rcx
addq $0x28, %rbx
movl $0x8, %esi
movl $0x1, %edx
movq %rbx, %rdi
callq 0x2390
cmpq $0x1, %rax
jne 0x3a88
addq $0x1008, %rsp           # imm = 0x1008
popq %rbx
popq %r14
retq
movq %rsp, %rdi
callq 0x247f
movq %rsp, %rdi
callq 0x246d
leaq 0xb1ab(%rip), %rdi      # 0xec3a
callq 0x3973
// File: /workspace/github_c_makefile_star2_O1/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 0x3af9
movq %rdx, %rbx
movq 0x58(%rdx), %rcx
leaq 0x4(%rsp), %rdi
movl $0x1, %esi
movl $0x1, %edx
callq 0x2390
cmpq $0x1, %rax
jne 0x3aed
movq 0x58(%rbx), %rcx
leaq 0x8(%rsp), %rdi
movl $0x5, %esi
movl $0x1, %edx
callq 0x2390
cmpq $0x1, %rax
jne 0x3aed
addq $0x10, %rsp
popq %rbx
retq
leaq 0xb1b0(%rip), %rdi      # 0xeca4
callq 0x3973
callq 0x2491
// File: /workspace/github_c_makefile_star2_O1/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 0x3b6e
movq 0x58(%rbx), %rcx
movq %rsp, %rdi
movl $0x5, %esi
movl $0x1, %edx
callq 0x2390
cmpq $0x1, %rax
jne 0x3b6e
movq 0x60(%rbx), %rcx
leaq 0x8(%rsp), %rdi
movl $0x8, %esi
movl $0x1, %edx
callq 0x2390
cmpq $0x1, %rax
jne 0x3b6e
addq $0x10, %rsp
popq %rbx
retq
leaq 0xb138(%rip), %rdi      # 0xecad
callq 0x3973
// File: /workspace/github_c_makefile_star2_O1/felipelouza[P]egap/util.c
// Function: initLCPmem
void initLCPmem(g_data *g)
{
  char filename[Filename_size];
  
  assert(g->lcpMerge);
  // allocate g->lcps and g->lcp[0..]
  g->lcps = (lcpInt **) malloc(g->numBwt*sizeof(lcpInt *));
  if(!g->lcps) die(__func__);
  
  snprintf(filename,Filename_size,"%s.%s",g->lcpinPath,LCP_EXT);
  int fd = open(filename,O_RDWR);
  if(fd == -1) die(__func__);
  // mmap lcp values, init lcps[] with a copy of the LCP values  
  g->lcps[0] = mmap(NULL,g->mergeLen*sizeof(lcpInt),PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);
  if(g->lcps[0] == MAP_FAILED) die(__func__);
  #ifdef USE_MMAP_ADVISE
  madvise(g->lcps[0], g->mergeLen*sizeof(lcpInt), MADV_DONTNEED);// lcp values are not need untill the end of the bwt-merge phase 
  #endif
  if(close(fd)!=0) die(__func__);

  // init lcps[1..]
  for(int i=0;i<g->numBwt-1;i++)
    g->lcps[i+1] = g->lcps[i] + g->bwtLen[i];
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1000, %rsp           # imm = 0x1000
movq %rdi, %rbx
movslq 0x20(%rdi), %rdi
shlq $0x3, %rdi
callq 0xc63a
movq %rax, 0x88(%rbx)
testq %rax, %rax
je 0x3c87
movq 0x78(%rbx), %rcx
leaq 0xad57(%rip), %rdx      # 0xe91e
leaq 0xb0f7(%rip), %r8       # 0xecc5
movq %rsp, %r14
movl $0x1000, %esi           # imm = 0x1000
movq %r14, %rdi
xorl %eax, %eax
callq 0x2140
movq %r14, %rdi
movl $0x2, %esi
xorl %eax, %eax
callq 0x22f0
cmpl $-0x1, %eax
je 0x3c87
movl %eax, %ebp
movq 0x28(%rbx), %rsi
xorl %edi, %edi
movl $0x3, %edx
movl $0x1, %ecx
movl %eax, %r8d
xorl %r9d, %r9d
callq 0x2230
movq 0x88(%rbx), %rcx
movq %rax, (%rcx)
movq 0x88(%rbx), %rax
cmpq $-0x1, (%rax)
je 0x3c87
movq 0x28(%rbx), %rsi
movq 0x88(%rbx), %rax
movq (%rax), %rdi
movl $0x4, %edx
callq 0x22e0
movl %ebp, %edi
callq 0x2160
testl %eax, %eax
jne 0x3c87
movl 0x20(%rbx), %eax
cmpl $0x2, %eax
jl 0x3c7b
decl %eax
xorl %ecx, %ecx
movq 0x8(%rbx), %rdx
movq 0x88(%rbx), %rsi
movq (%rsi,%rcx,8), %rdi
addq (%rdx,%rcx,8), %rdi
movq %rdi, 0x8(%rsi,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x3c5b
addq $0x1000, %rsp           # imm = 0x1000
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xb02c(%rip), %rdi      # 0xecba
callq 0x3973
// File: /workspace/github_c_makefile_star2_O1/felipelouza[P]egap/util.c
// Function: openDAFile
static FILE *openDAFile(g_data *g)
{
  char filename[Filename_size];

  if(g->verbose>1) puts("Writing Document Array");
  assert(g->outputDA);
  snprintf(filename,Filename_size,"%s.%d.%s",g->outPath,g->outputDA,DA_EXT);
  FILE *f = fopen(filename,"wb");
  if(f==NULL) die("Error opening Document array file");
  return f;
}

// Assembly:
pushq %rbx
subq $0x1000, %rsp           # imm = 0x1000
movq %rdi, %rbx
cmpl $0x2, 0x94(%rdi)
jl 0x3f8f
leaq 0xb459(%rip), %rdi      # 0xf3e3
callq 0x2090
movq 0x80(%rbx), %rcx
movl 0x44(%rbx), %r8d
leaq 0xabd3(%rip), %rdx      # 0xeb74
leaq 0xa355(%rip), %r9       # 0xe2fd
movq %rsp, %rbx
movl $0x1000, %esi           # imm = 0x1000
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2140
leaq 0xa96d(%rip), %rsi      # 0xe92e
movq %rbx, %rdi
callq 0x21e0
testq %rax, %rax
je 0x3fd7
addq $0x1000, %rsp           # imm = 0x1000
popq %rbx
retq
leaq 0xb41c(%rip), %rdi      # 0xf3fa
callq 0x3973
// File: /workspace/github_c_makefile_star2_O1/felipelouza[P]egap/util.c
// Function: openSAFile
static FILE *openSAFile(g_data *g)
{
  char filename[Filename_size];

  if(g->verbose>1) puts("Writing Suffix Array");
  assert(g->outputSA);
  snprintf(filename,Filename_size,"%s.%d.%s",g->outPath,g->outputSA,SA_EXT);
  FILE *f = fopen(filename,"wb");
  if(f==NULL) die("Error opening Suffix array file");
  return f;
}

// Assembly:
pushq %rbx
subq $0x1000, %rsp           # imm = 0x1000
movq %rdi, %rbx
cmpl $0x2, 0x94(%rdi)
jl 0x472f
leaq 0xacf2(%rip), %rdi      # 0xf41c
callq 0x2090
movq 0x80(%rbx), %rcx
movl 0x4c(%rbx), %r8d
leaq 0xa433(%rip), %rdx      # 0xeb74
leaq 0x9bf2(%rip), %r9       # 0xe33a
movq %rsp, %rbx
movl $0x1000, %esi           # imm = 0x1000
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2140
leaq 0xa1cd(%rip), %rsi      # 0xe92e
movq %rbx, %rdi
callq 0x21e0
testq %rax, %rax
je 0x4777
addq $0x1000, %rsp           # imm = 0x1000
popq %rbx
retq
leaq 0xacb3(%rip), %rdi      # 0xf431
callq 0x3973