LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpca_lang_contents
mpc_err_t *mpca_lang_contents(int flags, const char *filename, ...) {

  mpca_grammar_st_t st;
  mpc_input_t *i;
  mpc_err_t *err;

  va_list va;

  FILE *f = fopen(filename, "rb");

  if (f == NULL) {
    err = mpc_err_file(filename, "Unable to open file!");
    return err;
  }

  va_start(va, filename);

  st.va = &va;
  st.parsers_num = 0;
  st.parsers = NULL;
  st.flags = flags;

  i = mpc_input_new_file(filename, f);
  err = mpca_lang_st(i, &st);
  mpc_input_delete(i);

  free(st.parsers);
  va_end(va);

  fclose(f);

  return err;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
testb %al, %al
je 0xdb24
movaps %xmm0, -0xf0(%rbp)
movaps %xmm1, -0xe0(%rbp)
movaps %xmm2, -0xd0(%rbp)
movaps %xmm3, -0xc0(%rbp)
movaps %xmm4, -0xb0(%rbp)
movaps %xmm5, -0xa0(%rbp)
movaps %xmm6, -0x90(%rbp)
movaps %xmm7, -0x80(%rbp)
movq %r9, -0xf8(%rbp)
movq %r8, -0x100(%rbp)
movq %rcx, -0x108(%rbp)
movq %rdx, -0x110(%rbp)
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x4981(%rip), %rsi      # 0x124d3
callq 0x46c0
movq %rax, -0x68(%rbp)
cmpq $0x0, -0x68(%rbp)
jne 0xdb83
movq -0x18(%rbp), %rdi
leaq 0x4969(%rip), %rsi      # 0x124d6
callq 0x6b00
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xdc0d
leaq -0x60(%rbp), %rax
leaq -0x120(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
leaq -0x60(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x30(%rbp)
movq $0x0, -0x28(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x6780
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xd400
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
callq 0x64e0
movq -0x28(%rbp), %rdi
callq 0x4850
leaq -0x60(%rbp), %rax
movq -0x68(%rbp), %rdi
callq 0x4190
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpc_malloc
static void *mpc_malloc(mpc_input_t *i, size_t n) {
  size_t j;
  char *p;

  if (n > sizeof(mpc_mem_t)) { return malloc(n); }

  j = i->mem_index;
  do {
    if (!i->mem_full[i->mem_index]) {
      p = (void*)(i->mem + i->mem_index);
      i->mem_full[i->mem_index] = 1;
      i->mem_index = (i->mem_index+1) % MPC_INPUT_MEM_NUM;
      return p;
    }
    i->mem_index = (i->mem_index+1) % MPC_INPUT_MEM_NUM;
  } while (j != i->mem_index);

  return malloc(n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x40, -0x18(%rbp)
jbe 0xec69
movq -0x18(%rbp), %rdi
callq 0x4570
movq %rax, -0x8(%rbp)
jmp 0xed15
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x70(%rcx), %rcx
cmpb $0x0, 0x78(%rax,%rcx)
jne 0xecdb
movq -0x10(%rbp), %rax
addq $0x278, %rax            # imm = 0x278
movq -0x10(%rbp), %rcx
movq 0x70(%rcx), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x70(%rcx), %rcx
movb $0x1, 0x78(%rax,%rcx)
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rcx
addq $0x1, %rcx
andq $0x1ff, %rcx            # imm = 0x1FF
movq -0x10(%rbp), %rax
movq %rcx, 0x70(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xed15
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rcx
addq $0x1, %rcx
andq $0x1ff, %rcx            # imm = 0x1FF
movq -0x10(%rbp), %rax
movq %rcx, 0x70(%rax)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x70(%rcx), %rax
jne 0xec75
movq -0x18(%rbp), %rdi
callq 0x4570
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpc_input_any
static int mpc_input_any(mpc_input_t *i, char **o) {
  char x;
  if (mpc_input_terminated(i)) { return 0; }
  x = mpc_input_getc(i);
  return mpc_input_success(i, x, o);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xfbf0
cmpl $0x0, %eax
je 0xed47
movl $0x0, -0x4(%rbp)
jmp 0xed69
movq -0x10(%rbp), %rdi
callq 0xfc20
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rdi
movb -0x19(%rbp), %al
movq -0x18(%rbp), %rdx
movsbl %al, %esi
callq 0xfd00
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpc_input_char
static int mpc_input_char(mpc_input_t *i, char c, char **o) {
  char x;
  if (mpc_input_terminated(i)) { return 0; }
  x = mpc_input_getc(i);
  return x == c ? mpc_input_success(i, x, o) : mpc_input_failure(i, x);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0xfbf0
cmpl $0x0, %eax
je 0xedad
movl $0x0, -0x4(%rbp)
jmp 0xedf3
movq -0x10(%rbp), %rdi
callq 0xfc20
movb %al, -0x21(%rbp)
movsbl -0x21(%rbp), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jne 0xeddd
movq -0x10(%rbp), %rdi
movb -0x21(%rbp), %al
movq -0x20(%rbp), %rdx
movsbl %al, %esi
callq 0xfd00
movl %eax, -0x28(%rbp)
jmp 0xeded
movq -0x10(%rbp), %rdi
movsbl -0x21(%rbp), %esi
callq 0x10050
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpc_input_range
static int mpc_input_range(mpc_input_t *i, char c, char d, char **o) {
  char x;
  if (mpc_input_terminated(i)) { return 0; }
  x = mpc_input_getc(i);
  return x >= c && x <= d ? mpc_input_success(i, x, o) : mpc_input_failure(i, x);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movb %sil, %dl
movq %rdi, -0x10(%rbp)
movb %dl, -0x11(%rbp)
movb %al, -0x12(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0xfbf0
cmpl $0x0, %eax
je 0xee32
movl $0x0, -0x4(%rbp)
jmp 0xee84
movq -0x10(%rbp), %rdi
callq 0xfc20
movb %al, -0x21(%rbp)
movsbl -0x21(%rbp), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jl 0xee6e
movsbl -0x21(%rbp), %eax
movsbl -0x12(%rbp), %ecx
cmpl %ecx, %eax
jg 0xee6e
movq -0x10(%rbp), %rdi
movb -0x21(%rbp), %al
movq -0x20(%rbp), %rdx
movsbl %al, %esi
callq 0xfd00
movl %eax, -0x28(%rbp)
jmp 0xee7e
movq -0x10(%rbp), %rdi
movsbl -0x21(%rbp), %esi
callq 0x10050
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpc_input_oneof
static int mpc_input_oneof(mpc_input_t *i, const char *c, char **o) {
  char x;
  if (mpc_input_terminated(i)) { return 0; }
  x = mpc_input_getc(i);
  return strchr(c, x) != 0 ? mpc_input_success(i, x, o) : mpc_input_failure(i, x);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0xfbf0
cmpl $0x0, %eax
je 0xeebb
movl $0x0, -0x4(%rbp)
jmp 0xef08
movq -0x10(%rbp), %rdi
callq 0xfc20
movb %al, -0x21(%rbp)
movq -0x18(%rbp), %rdi
movsbl -0x21(%rbp), %esi
callq 0x4210
cmpq $0x0, %rax
je 0xeef2
movq -0x10(%rbp), %rdi
movb -0x21(%rbp), %al
movq -0x20(%rbp), %rdx
movsbl %al, %esi
callq 0xfd00
movl %eax, -0x28(%rbp)
jmp 0xef02
movq -0x10(%rbp), %rdi
movsbl -0x21(%rbp), %esi
callq 0x10050
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpc_input_satisfy
static int mpc_input_satisfy(mpc_input_t *i, int(*cond)(char), char **o) {
  char x;
  if (mpc_input_terminated(i)) { return 0; }
  x = mpc_input_getc(i);
  return cond(x) ? mpc_input_success(i, x, o) : mpc_input_failure(i, x);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0xfbf0
cmpl $0x0, %eax
je 0xefdb
movl $0x0, -0x4(%rbp)
jmp 0xf024
movq -0x10(%rbp), %rdi
callq 0xfc20
movb %al, -0x21(%rbp)
movq -0x18(%rbp), %rax
movsbl -0x21(%rbp), %edi
callq *%rax
cmpl $0x0, %eax
je 0xf00e
movq -0x10(%rbp), %rdi
movb -0x21(%rbp), %al
movq -0x20(%rbp), %rdx
movsbl %al, %esi
callq 0xfd00
movl %eax, -0x28(%rbp)
jmp 0xf01e
movq -0x10(%rbp), %rdi
movsbl -0x21(%rbp), %esi
callq 0x10050
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpc_input_string
static int mpc_input_string(mpc_input_t *i, const char *c, char **o) {

  const char *x = c;

  mpc_input_mark(i);
  while (*x) {
    if (!mpc_input_char(i, *x, NULL)) {
      mpc_input_rewind(i);
      return 0;
    }
    x++;
  }
  mpc_input_unmark(i);

  *o = mpc_malloc(i, strlen(c) + 1);
  strcpy(*o, c);
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0xf510
movq -0x28(%rbp), %rax
cmpb $0x0, (%rax)
je 0xf097
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
movsbl (%rax), %esi
callq 0xed80
cmpl $0x0, %eax
jne 0xf089
movq -0x10(%rbp), %rdi
callq 0xf640
movl $0x0, -0x4(%rbp)
jmp 0xf0e2
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xf055
movq -0x10(%rbp), %rdi
callq 0xf6f0
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x41b0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
addq $0x1, %rsi
callq 0xec40
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x40e0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpc_input_eoi
static int mpc_input_eoi(mpc_input_t* i, char **o) {
  *o = NULL;
  if (i->state.term) {
    return 0;
  } else if (mpc_input_terminated(i)) {
    i->state.term = 1;
    return 1;
  } else {
    return 0;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x28(%rax)
je 0xf1ae
movl $0x0, -0x4(%rbp)
jmp 0xf1d7
movq -0x10(%rbp), %rdi
callq 0xfbf0
cmpl $0x0, %eax
je 0xf1d0
movq -0x10(%rbp), %rax
movl $0x1, 0x28(%rax)
movl $0x1, -0x4(%rbp)
jmp 0xf1d7
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpc_err_new
static mpc_err_t *mpc_err_new(mpc_input_t *i, const char *expected) {
  mpc_err_t *x;
  if (i->suppress) { return NULL; }
  x = mpc_malloc(i, sizeof(mpc_err_t));
  x->filename = mpc_malloc(i, strlen(i->filename) + 1);
  strcpy(x->filename, i->filename);
  x->state = i->state;
  x->expected_num = 1;
  x->expected = mpc_malloc(i, sizeof(char*));
  x->expected[0] = mpc_malloc(i, strlen(expected) + 1);
  strcpy(x->expected[0], expected);
  x->failure = NULL;
  x->received = mpc_input_peekc(i);
  return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x48(%rax)
je 0xf3b7
movq $0x0, -0x8(%rbp)
jmp 0xf4c2
movq -0x10(%rbp), %rdi
movl $0x48, %esi
callq 0xec40
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x41b0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
addq $0x1, %rsi
callq 0xec40
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x40e0
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rdx
movq %rdx, (%rax)
movq 0x18(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x20(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x28(%rcx), %rcx
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
movl $0x1, 0x20(%rax)
movq -0x10(%rbp), %rdi
movl $0x8, %esi
callq 0xec40
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x41b0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
addq $0x1, %rsi
callq 0xec40
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x40e0
movq -0x20(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x10(%rbp), %rdi
callq 0xfe60
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0x40(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpc_input_mark
static void mpc_input_mark(mpc_input_t *i) {

  if (i->backtrack < 1) { return; }

  i->marks_num++;

  if (i->marks_num > i->marks_slots) {
    i->marks_slots = i->marks_num + i->marks_num / 2;
    i->marks = realloc(i->marks, sizeof(mpc_state_t) * i->marks_slots);
    i->lasts = realloc(i->lasts, sizeof(char) * i->marks_slots);
  }

  i->marks[i->marks_num-1] = i->state;
  i->lasts[i->marks_num-1] = i->last;

  if (i->type == MPC_INPUT_PIPE && i->marks_num == 1) {
    i->buffer = calloc(1, 1);
  }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x4c(%rax)
jge 0xf52b
jmp 0xf638
movq -0x8(%rbp), %rax
movl 0x54(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x54(%rax)
movq -0x8(%rbp), %rax
movl 0x54(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x50(%rcx), %eax
jle 0xf5af
movq -0x8(%rbp), %rax
movl 0x54(%rax), %ecx
movq -0x8(%rbp), %rax
movl 0x54(%rax), %eax
movl $0x2, %esi
cltd
idivl %esi
addl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x50(%rax)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x50(%rax), %rsi
shlq $0x5, %rsi
callq 0x45e0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x50(%rax), %rsi
shlq $0x0, %rsi
callq 0x45e0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x60(%rax)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x54(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rdx
movq %rdx, (%rax)
movq 0x18(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x20(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x28(%rcx), %rcx
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movb 0x68(%rax), %dl
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x54(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
cmpl $0x2, (%rax)
jne 0xf638
movq -0x8(%rbp), %rax
cmpl $0x1, 0x54(%rax)
jne 0xf638
movl $0x1, %esi
movq %rsi, %rdi
callq 0x4390
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x38(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpc_input_rewind
static void mpc_input_rewind(mpc_input_t *i) {

  if (i->backtrack < 1) { return; }

  i->state = i->marks[i->marks_num-1];
  i->last  = i->lasts[i->marks_num-1];

  if (i->type == MPC_INPUT_FILE) {
    fseek(i->file, i->state.pos, SEEK_SET);
  }

  mpc_input_unmark(i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x4c(%rax)
jge 0xf65b
jmp 0xf6e2
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x58(%rcx), %rcx
movq -0x8(%rbp), %rdx
movl 0x54(%rdx), %edx
subl $0x1, %edx
movslq %edx, %rdx
shlq $0x5, %rdx
addq %rdx, %rcx
movq (%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x18(%rax)
movq 0x10(%rcx), %rdx
movq %rdx, 0x20(%rax)
movq 0x18(%rcx), %rcx
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x54(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x68(%rax)
movq -0x8(%rbp), %rax
cmpl $0x1, (%rax)
jne 0xf6d9
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
xorl %edx, %edx
callq 0x45d0
movq -0x8(%rbp), %rdi
callq 0xf6f0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpc_input_unmark
static void mpc_input_unmark(mpc_input_t *i) {
  int j;

  if (i->backtrack < 1) { return; }

  i->marks_num--;

  if (i->marks_slots > i->marks_num + i->marks_num / 2
  &&  i->marks_slots > MPC_INPUT_MARKS_MIN) {
    i->marks_slots =
      i->marks_num > MPC_INPUT_MARKS_MIN ?
      i->marks_num : MPC_INPUT_MARKS_MIN;
    i->marks = realloc(i->marks, sizeof(mpc_state_t) * i->marks_slots);
    i->lasts = realloc(i->lasts, sizeof(char) * i->marks_slots);
  }

  if (i->type == MPC_INPUT_PIPE && i->marks_num == 0) {
    for (j = strlen(i->buffer) - 1; j >= 0; j--)
      ungetc(i->buffer[j], i->file);

    free(i->buffer);
    i->buffer = NULL;
  }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x4c(%rax)
jge 0xf70b
jmp 0xf82d
movq -0x8(%rbp), %rax
movl 0x54(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x54(%rax)
movq -0x8(%rbp), %rax
movl 0x50(%rax), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x54(%rax), %ecx
movq -0x8(%rbp), %rax
movl 0x54(%rax), %eax
movl $0x2, %esi
cltd
idivl %esi
movl %eax, %edx
movl -0x10(%rbp), %eax
addl %edx, %ecx
cmpl %ecx, %eax
jle 0xf7bf
movq -0x8(%rbp), %rax
cmpl $0x20, 0x50(%rax)
jle 0xf7bf
movq -0x8(%rbp), %rax
cmpl $0x20, 0x54(%rax)
jle 0xf763
movq -0x8(%rbp), %rax
movl 0x54(%rax), %eax
movl %eax, -0x14(%rbp)
jmp 0xf76d
movl $0x20, %eax
movl %eax, -0x14(%rbp)
jmp 0xf76d
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x50(%rax)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x50(%rax), %rsi
shlq $0x5, %rsi
callq 0x45e0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x50(%rax), %rsi
shlq $0x0, %rsi
callq 0x45e0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x60(%rax)
movq -0x8(%rbp), %rax
cmpl $0x2, (%rax)
jne 0xf82d
movq -0x8(%rbp), %rax
cmpl $0x0, 0x54(%rax)
jne 0xf82d
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x41b0
subq $0x1, %rax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0xf814
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %edi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rsi
callq 0x45a0
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xf7e6
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x4850
movq -0x8(%rbp), %rax
movq $0x0, 0x38(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpc_grow_results
static mpc_result_t *mpc_grow_results(mpc_input_t *i, int j, mpc_result_t *results_stk, mpc_result_t *results){
  mpc_result_t *tmp_results = results;

  if (j == MPC_PARSE_STACK_MIN) {
    int results_slots = j + j / 2;
    tmp_results = mpc_malloc(i, sizeof(mpc_result_t) * results_slots);
    memcpy(tmp_results, results_stk, sizeof(mpc_result_t) * MPC_PARSE_STACK_MIN);
  } else if (j >= MPC_PARSE_STACK_MIN) {
    int results_slots = j + j / 2;
    tmp_results = mpc_realloc(i, tmp_results, sizeof(mpc_result_t) * results_slots);
  }

  return tmp_results;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x4, -0xc(%rbp)
jne 0xf8bd
movl -0xc(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0xc(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x34(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
shlq $0x3, %rsi
callq 0xec40
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rax)
jmp 0xf8f9
cmpl $0x4, -0xc(%rbp)
jl 0xf8f7
movl -0xc(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0xc(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x38(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movslq -0x30(%rbp), %rdx
shlq $0x3, %rdx
callq 0x10170
movq %rax, -0x28(%rbp)
jmp 0xf8f9
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpc_parse_fold
static mpc_val_t *mpc_parse_fold(mpc_input_t *i, mpc_fold_t f, int n, mpc_val_t **xs) {
  int j;
  if (f == mpcf_null)      { return mpcf_null(n, xs); }
  if (f == mpcf_fst)       { return mpcf_fst(n, xs); }
  if (f == mpcf_snd)       { return mpcf_snd(n, xs); }
  if (f == mpcf_trd)       { return mpcf_trd(n, xs); }
  if (f == mpcf_fst_free)  { return mpcf_input_fst_free(i, n, xs); }
  if (f == mpcf_snd_free)  { return mpcf_input_snd_free(i, n, xs); }
  if (f == mpcf_trd_free)  { return mpcf_input_trd_free(i, n, xs); }
  if (f == mpcf_strfold)   { return mpcf_input_strfold(i, n, xs); }
  if (f == mpcf_state_ast) { return mpcf_input_state_ast(i, n, xs); }
  for (j = 0; j < n; j++) { xs[j] = mpc_export(i, xs[j]); }
  return f(j, xs);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq 0x7612(%rip), %rax      # 0x16f40
cmpq %rax, -0x18(%rbp)
jne 0xf949
movl -0x1c(%rbp), %edi
movq -0x28(%rbp), %rsi
callq 0x4858
movq %rax, -0x8(%rbp)
jmp 0xfab6
movq 0x7608(%rip), %rax      # 0x16f58
cmpq %rax, -0x18(%rbp)
jne 0xf96b
movl -0x1c(%rbp), %edi
movq -0x28(%rbp), %rsi
callq 0x4860
movq %rax, -0x8(%rbp)
jmp 0xfab6
movq 0x7656(%rip), %rax      # 0x16fc8
cmpq %rax, -0x18(%rbp)
jne 0xf98d
movl -0x1c(%rbp), %edi
movq -0x28(%rbp), %rsi
callq 0x4878
movq %rax, -0x8(%rbp)
jmp 0xfab6
movq 0x75fc(%rip), %rax      # 0x16f90
cmpq %rax, -0x18(%rbp)
jne 0xf9af
movl -0x1c(%rbp), %edi
movq -0x28(%rbp), %rsi
callq 0x4870
movq %rax, -0x8(%rbp)
jmp 0xfab6
movq 0x7572(%rip), %rax      # 0x16f28
cmpq %rax, -0x18(%rbp)
jne 0xf9d5
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x28(%rbp), %rdx
callq 0x10250
movq %rax, -0x8(%rbp)
jmp 0xfab6
movq 0x7534(%rip), %rax      # 0x16f10
cmpq %rax, -0x18(%rbp)
jne 0xf9fb
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x28(%rbp), %rdx
callq 0x10280
movq %rax, -0x8(%rbp)
jmp 0xfab6
movq 0x7516(%rip), %rax      # 0x16f18
cmpq %rax, -0x18(%rbp)
jne 0xfa21
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x28(%rbp), %rdx
callq 0x102b0
movq %rax, -0x8(%rbp)
jmp 0xfab6
movq 0x7598(%rip), %rax      # 0x16fc0
cmpq %rax, -0x18(%rbp)
jne 0xfa44
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x28(%rbp), %rdx
callq 0x102e0
movq %rax, -0x8(%rbp)
jmp 0xfab6
movq 0x7515(%rip), %rax      # 0x16f60
cmpq %rax, -0x18(%rbp)
jne 0xfa67
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x28(%rbp), %rdx
callq 0x103d0
movq %rax, -0x8(%rbp)
jmp 0xfab6
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0xfaa5
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x6190
movq %rax, %rdx
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xfa6e
movq -0x18(%rbp), %rax
movl -0x2c(%rbp), %edi
movq -0x28(%rbp), %rsi
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpc_free
static void mpc_free(mpc_input_t *i, void *p) {
  size_t j;
  if (!mpc_mem_ptr(i, p)) { free(p); return; }
  j = ((size_t)(((char*)p) - ((char*)i->mem))) / sizeof(mpc_mem_t);
  i->mem_full[j] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x10200
cmpl $0x0, %eax
jne 0xfaed
movq -0x10(%rbp), %rdi
callq 0x4850
jmp 0xfb14
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
addq $0x278, %rcx            # imm = 0x278
subq %rcx, %rax
shrq $0x6, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movb $0x0, 0x78(%rax,%rcx)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpc_err_count
static mpc_err_t *mpc_err_count(mpc_input_t *i, mpc_err_t *x, int n) {
  mpc_err_t *y;
  int digits = n/10 + 1;
  char *prefix;
  prefix = mpc_malloc(i, digits + strlen(" of ") + 1);
  if (!prefix) {
    return NULL;
  }
  sprintf(prefix, "%i of ", n);
  y = mpc_err_repeat(i, x, prefix);
  mpc_free(i, prefix);
  return y;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
addq $0x4, %rsi
addq $0x1, %rsi
callq 0xec40
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0xfb9e
movq $0x0, -0x8(%rbp)
jmp 0xfbdd
movq -0x38(%rbp), %rdi
movl -0x1c(%rbp), %edx
leaq 0x2cdb(%rip), %rsi      # 0x12887
movb $0x0, %al
callq 0x4740
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x10510
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0xfac0
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpc_input_getc
static char mpc_input_getc(mpc_input_t *i) {

  char c = '\0';

  switch (i->type) {

    case MPC_INPUT_STRING: return i->string[i->state.pos];
    case MPC_INPUT_FILE: c = fgetc(i->file); return c;
    case MPC_INPUT_PIPE:

      if (!i->buffer) { c = getc(i->file); return c; }

      if (i->buffer && mpc_input_buffer_in_range(i)) {
        c = mpc_input_buffer_get(i);
        return c;
      } else {
        c = getc(i->file);
        return c;
      }

    default: return c;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x18(%rbp)
testl %eax, %eax
je 0xfc56
jmp 0xfc3f
movl -0x18(%rbp), %eax
subl $0x1, %eax
je 0xfc71
jmp 0xfc49
movl -0x18(%rbp), %eax
subl $0x2, %eax
je 0xfc89
jmp 0xfcf1
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movb (%rax,%rcx), %al
movb %al, -0x1(%rbp)
jmp 0xfcf7
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x4330
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
movb %al, -0x1(%rbp)
jmp 0xfcf7
movq -0x10(%rbp), %rax
cmpq $0x0, 0x38(%rax)
jne 0xfcac
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x47e0
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
movb %al, -0x1(%rbp)
jmp 0xfcf7
movq -0x10(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0xfcd9
movq -0x10(%rbp), %rdi
callq 0xffd0
cmpl $0x0, %eax
je 0xfcd9
movq -0x10(%rbp), %rdi
callq 0x10020
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
movb %al, -0x1(%rbp)
jmp 0xfcf7
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x47e0
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
movb %al, -0x1(%rbp)
jmp 0xfcf7
movb -0x11(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpc_input_success
static int mpc_input_success(mpc_input_t *i, char c, char **o) {

  if (i->type == MPC_INPUT_PIPE
  &&  i->buffer && !mpc_input_buffer_in_range(i)) {
    i->buffer = realloc(i->buffer, strlen(i->buffer) + 2);
    i->buffer[strlen(i->buffer) + 1] = '\0';
    i->buffer[strlen(i->buffer) + 0] = c;
  }

  i->last = c;
  i->state.pos++;
  i->state.col++;

  if (c == '\n') {
    i->state.col = 0;
    i->state.row++;
  }

  if (o) {
    (*o) = mpc_malloc(i, 2);
    (*o)[0] = c;
    (*o)[1] = '\0';
  }

  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x2, (%rax)
jne 0xfdc9
movq -0x8(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0xfdc9
movq -0x8(%rbp), %rdi
callq 0xffd0
cmpl $0x0, %eax
jne 0xfdc9
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x41b0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
addq $0x2, %rsi
callq 0x45e0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x41b0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movb $0x0, 0x1(%rax,%rcx)
movb -0x9(%rbp), %al
movb %al, -0x21(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x41b0
movb -0x21(%rbp), %dl
movq %rax, %rcx
movq -0x20(%rbp), %rax
movb %dl, (%rax,%rcx)
movb -0x9(%rbp), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x68(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rax)
movsbl -0x9(%rbp), %eax
cmpl $0xa, %eax
jne 0xfe18
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
cmpq $0x0, -0x18(%rbp)
je 0xfe4e
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0xec40
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movb -0x9(%rbp), %cl
movq -0x18(%rbp), %rax
movq (%rax), %rax
movb %cl, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movb $0x0, 0x1(%rax)
movl $0x1, %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpc_input_peekc
static char mpc_input_peekc(mpc_input_t *i) {

  char c = '\0';

  switch (i->type) {
    case MPC_INPUT_STRING: return i->string[i->state.pos];
    case MPC_INPUT_FILE:

      c = fgetc(i->file);
      if (feof(i->file)) { return '\0'; }

      fseek(i->file, -1, SEEK_CUR);
      return c;

    case MPC_INPUT_PIPE:

      if (!i->buffer) {
        c = getc(i->file);
        if (feof(i->file)) { return '\0'; }
        ungetc(c, i->file);
        return c;
      }

      if (i->buffer && mpc_input_buffer_in_range(i)) {
        return mpc_input_buffer_get(i);
      } else {
        c = getc(i->file);
        if (feof(i->file)) { return '\0'; }
        ungetc(c, i->file);
        return c;
      }

    default: return c;
  }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x18(%rbp)
testl %eax, %eax
je 0xfe96
jmp 0xfe7f
movl -0x18(%rbp), %eax
subl $0x1, %eax
je 0xfeb1
jmp 0xfe89
movl -0x18(%rbp), %eax
subl $0x2, %eax
je 0xff00
jmp 0xffb7
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movb (%rax,%rcx), %al
movb %al, -0x1(%rbp)
jmp 0xffbd
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x4330
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x4480
cmpl $0x0, %eax
je 0xfedc
movb $0x0, -0x1(%rbp)
jmp 0xffbd
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
movq $-0x1, %rsi
movl $0x1, %edx
callq 0x45d0
movb -0x11(%rbp), %al
movb %al, -0x1(%rbp)
jmp 0xffbd
movq -0x10(%rbp), %rax
cmpq $0x0, 0x38(%rax)
jne 0xff4f
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x47e0
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x4480
cmpl $0x0, %eax
je 0xff36
movb $0x0, -0x1(%rbp)
jmp 0xffbd
movsbl -0x11(%rbp), %edi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rsi
callq 0x45a0
movb -0x11(%rbp), %al
movb %al, -0x1(%rbp)
jmp 0xffbd
movq -0x10(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0xff76
movq -0x10(%rbp), %rdi
callq 0xffd0
cmpl $0x0, %eax
je 0xff76
movq -0x10(%rbp), %rdi
callq 0x10020
movb %al, -0x1(%rbp)
jmp 0xffbd
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x47e0
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x4480
cmpl $0x0, %eax
je 0xff9e
movb $0x0, -0x1(%rbp)
jmp 0xffbd
movsbl -0x11(%rbp), %edi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rsi
callq 0x45a0
movb -0x11(%rbp), %al
movb %al, -0x1(%rbp)
jmp 0xffbd
movb -0x11(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpc_input_failure
static int mpc_input_failure(mpc_input_t *i, char c) {

  switch (i->type) {
    case MPC_INPUT_STRING: { break; }
    case MPC_INPUT_FILE: fseek(i->file, -1, SEEK_CUR); { break; }
    case MPC_INPUT_PIPE: {

      if (!i->buffer) { ungetc(c, i->file); break; }

      if (i->buffer && mpc_input_buffer_in_range(i)) {
        break;
      } else {
        ungetc(c, i->file);
      }
    }
    default: { break; }
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x10(%rbp)
testl %eax, %eax
je 0x10085
jmp 0x10071
movl -0x10(%rbp), %eax
subl $0x1, %eax
je 0x10087
jmp 0x1007b
movl -0x10(%rbp), %eax
subl $0x2, %eax
je 0x100a2
jmp 0x100ee
jmp 0x100f0
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
movq $-0x1, %rsi
movl $0x1, %edx
callq 0x45d0
jmp 0x100f0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x38(%rax)
jne 0x100c0
movsbl -0x9(%rbp), %edi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rsi
callq 0x45a0
jmp 0x100f0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x100db
movq -0x8(%rbp), %rdi
callq 0xffd0
cmpl $0x0, %eax
je 0x100db
jmp 0x100f0
movsbl -0x9(%rbp), %edi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rsi
callq 0x45a0
jmp 0x100ee
jmp 0x100f0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpc_realloc
static void *mpc_realloc(mpc_input_t *i, void *p, size_t n) {

  char *q = NULL;

  if (!mpc_mem_ptr(i, p)) { return realloc(p, n); }

  if (n > sizeof(mpc_mem_t)) {
    q = malloc(n);
    memcpy(q, p, sizeof(mpc_mem_t));
    mpc_free(i, p);
    return q;
  }

  return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x10200
cmpl $0x0, %eax
jne 0x101b1
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x45e0
movq %rax, -0x8(%rbp)
jmp 0x101f6
cmpq $0x40, -0x20(%rbp)
jbe 0x101ee
movq -0x20(%rbp), %rdi
callq 0x4570
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x40, %edx
callq 0x44e0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xfac0
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x101f6
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpcf_input_strfold
static mpc_val_t *mpcf_input_strfold(mpc_input_t *i, int n, mpc_val_t **xs) {
  int j;
  size_t l = 0;
  if (n == 0) { return mpc_calloc(i, 1, 1); }
  for (j = 0; j < n; j++) { l += strlen(xs[j]); }
  xs[0] = mpc_realloc(i, xs[0], l + 1);
  for (j = 1; j < n; j++) { strcat(xs[0], xs[j]); mpc_free(i, xs[j]); }
  return xs[0];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x30(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x1031b
movq -0x10(%rbp), %rdi
movl $0x1, %edx
movq %rdx, %rsi
callq 0x104c0
movq %rax, -0x8(%rbp)
jmp 0x103c2
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x1034e
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x41b0
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x10322
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movq -0x30(%rbp), %rdx
addq $0x1, %rdx
callq 0x10170
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x103b7
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x4720
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0xfac0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x10377
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpcf_input_state_ast
static mpc_val_t *mpcf_input_state_ast(mpc_input_t *i, int n, mpc_val_t **xs) {
  mpc_state_t *s = ((mpc_state_t**)xs)[0];
  mpc_ast_t *a = ((mpc_ast_t**)xs)[1];
  a = mpc_ast_state(a, *s);
  mpc_free(i, s);
  (void) n;
  return a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0x4090
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xfac0
movq -0x28(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpc_err_contains_expected
static int mpc_err_contains_expected(mpc_input_t *i, mpc_err_t *x, char *expected) {
  int j;
  (void)i;
  for (j = 0; j < x->expected_num; j++) {
    if (strcmp(x->expected[j], expected) == 0) { return 1; }
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jge 0x10bfb
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x20(%rbp), %rsi
callq 0x43c0
cmpl $0x0, %eax
jne 0x10bee
movl $0x1, -0x4(%rbp)
jmp 0x10c02
jmp 0x10bf0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x10bbb
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpc_err_add_expected
static void mpc_err_add_expected(mpc_input_t *i, mpc_err_t *x, char *expected) {
  (void)i;
  x->expected_num++;
  x->expected = mpc_realloc(i, x->expected, sizeof(char*) * x->expected_num);
  x->expected[x->expected_num-1] = mpc_malloc(i, strlen(expected) + 1);
  strcpy(x->expected[x->expected_num-1], expected);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x20(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rsi
movq -0x10(%rbp), %rax
movslq 0x20(%rax), %rdx
shlq $0x3, %rdx
callq 0x10170
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x41b0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
addq $0x1, %rsi
callq 0xec40
movq %rax, %rdx
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x20(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x20(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rsi
callq 0x40e0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpc_undefine_or
static void mpc_undefine_or(mpc_parser_t *p) {

  int i;
  for (i = 0; i < p->data.or.n; i++) {
    mpc_undefine_unretained(p->data.or.xs[i], 0);
  }
  free(p->data.or.xs);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x10d01
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
xorl %esi, %esi
callq 0x6c40
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x10cd3
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x4850
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpc_undefine_and
static void mpc_undefine_and(mpc_parser_t *p) {

  int i;
  for (i = 0; i < p->data.and.n; i++) {
    mpc_undefine_unretained(p->data.and.xs[i], 0);
  }
  free(p->data.and.xs);
  free(p->data.and.dxs);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x10d61
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
xorl %esi, %esi
callq 0x6c40
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x10d33
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x4850
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x4850
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpc_re_range_escape_char
static const char *mpc_re_range_escape_char(char c) {
  switch (c) {
    case '-': return "-";
    case 'a': return "\a";
    case 'f': return "\f";
    case 'n': return "\n";
    case 'r': return "\r";
    case 't': return "\t";
    case 'v': return "\v";
    case 'b': return "\b";
    case 'd': return "0123456789";
    case 's': return " \f\n\r\t\v";
    case 'w': return "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_";
    default: return NULL;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x9(%rbp)
movsbl -0x9(%rbp), %eax
addl $-0x2d, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x4a, %eax
ja 0x11086
movq -0x18(%rbp), %rax
leaq 0x1349(%rip), %rcx      # 0x12334
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x16db(%rip), %rax      # 0x126d6
movq %rax, -0x8(%rbp)
jmp 0x1108e
leaq 0x1901(%rip), %rax      # 0x1290c
movq %rax, -0x8(%rbp)
jmp 0x1108e
leaq 0x18f6(%rip), %rax      # 0x1290e
movq %rax, -0x8(%rbp)
jmp 0x1108e
leaq 0x1981(%rip), %rax      # 0x129a6
movq %rax, -0x8(%rbp)
jmp 0x1108e
leaq 0x18de(%rip), %rax      # 0x12910
movq %rax, -0x8(%rbp)
jmp 0x1108e
leaq 0x18d3(%rip), %rax      # 0x12912
movq %rax, -0x8(%rbp)
jmp 0x1108e
leaq 0x156f(%rip), %rax      # 0x125bb
movq %rax, -0x8(%rbp)
jmp 0x1108e
leaq 0x18bb(%rip), %rax      # 0x12914
movq %rax, -0x8(%rbp)
jmp 0x1108e
leaq 0x1569(%rip), %rax      # 0x125cf
movq %rax, -0x8(%rbp)
jmp 0x1108e
leaq 0x1543(%rip), %rax      # 0x125b6
movq %rax, -0x8(%rbp)
jmp 0x1108e
leaq 0x180e(%rip), %rax      # 0x1288e
movq %rax, -0x8(%rbp)
jmp 0x1108e
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpca_stmt_fold
static mpc_val_t *mpca_stmt_fold(int n, mpc_val_t **xs) {

  int i;
  mpca_stmt_t **stmts = malloc(sizeof(mpca_stmt_t*) * (n+1));

  for (i = 0; i < n; i++) {
    stmts[i] = xs[i];
  }
  stmts[n] = NULL;

  return stmts;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0x4570
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x11447
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1141c
movq -0x20(%rbp), %rax
movslq -0x4(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpca_stmt_list_delete
static void mpca_stmt_list_delete(mpc_val_t *x) {

  mpca_stmt_t **stmts = x;

  while(*stmts) {
    mpca_stmt_t *stmt = *stmts;
    free(stmt->ident);
    free(stmt->name);
    mpc_soft_delete(stmt->grammar);
    free(stmt);
    stmts++;
  }
  free(x);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x114d6
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x4850
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4850
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xcd70
movq -0x18(%rbp), %rdi
callq 0x4850
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
jmp 0x11484
movq -0x8(%rbp), %rdi
callq 0x4850
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/orangeduck[P]mpc/mpc.c
// Function: mpca_stmt_list_apply_to
static mpc_val_t *mpca_stmt_list_apply_to(mpc_val_t *x, void *s) {

  mpca_grammar_st_t *st = s;
  mpca_stmt_t *stmt;
  mpca_stmt_t **stmts = x;
  mpc_parser_t *left;

  while(*stmts) {
    stmt = *stmts;
    left = mpca_grammar_find_parser(stmt->ident, st);
    if (st->flags & MPCA_LANG_PREDICTIVE) { stmt->grammar = mpc_predictive(stmt->grammar); }
    if (stmt->name) { stmt->grammar = mpc_expect(stmt->grammar, stmt->name); }
    mpc_optimise(stmt->grammar);
    mpc_define(left, stmt->grammar);
    free(stmt->ident);
    free(stmt->name);
    free(stmt);
    stmts++;
  }

  free(x);

  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
je 0x115e0
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x110a0
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movl 0x18(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x11564
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x40d0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1158f
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x47c0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x4500
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x40f0
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x4850
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4850
movq -0x20(%rbp), %rdi
callq 0x4850
movq -0x28(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
jmp 0x11510
movq -0x8(%rbp), %rdi
callq 0x4850
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)