LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/mpc.c
// Function: mpc_err_new
static mpc_err_t *mpc_err_new(const char *filename, mpc_state_t s, const char *expected, char recieved) {
  mpc_err_t *x = malloc(sizeof(mpc_err_t));
  x->filename = malloc(strlen(filename) + 1);
  strcpy(x->filename, filename);
  x->state = s;
  x->expected_num = 1;
  x->expected = malloc(sizeof(char*));
  x->expected[0] = malloc(strlen(expected) + 1);
  strcpy(x->expected[0], expected);
  x->failure = NULL;
  x->recieved = recieved;
  return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %r8b, %al
movq %rsi, -0x1c(%rbp)
movl %edx, -0x14(%rbp)
movq -0x1c(%rbp), %rdx
movq %rdx, -0xc(%rbp)
movl -0x14(%rbp), %edx
movl %edx, -0x4(%rbp)
movq %rdi, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movb %al, -0x31(%rbp)
movl $0x30, %edi
callq 0x2250
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rdi
callq 0x20f0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x2250
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x2070
movq -0x40(%rbp), %rax
movq -0xc(%rbp), %rcx
movq %rcx, (%rax)
movl -0x4(%rbp), %ecx
movl %ecx, 0x8(%rax)
movq -0x40(%rbp), %rax
movl $0x1, 0xc(%rax)
movl $0x8, %edi
callq 0x2250
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x30(%rbp), %rdi
callq 0x20f0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x2250
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq 0x20(%rax), %rax
movq %rcx, (%rax)
movq -0x40(%rbp), %rax
movq 0x20(%rax), %rax
movq (%rax), %rdi
movq -0x30(%rbp), %rsi
callq 0x2070
movq -0x40(%rbp), %rax
movq $0x0, 0x18(%rax)
movb -0x31(%rbp), %cl
movq -0x40(%rbp), %rax
movb %cl, 0x28(%rax)
movq -0x40(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/mpc.c
// Function: mpc_input_peekc
static char mpc_input_peekc(mpc_input_t *i) {
  
  char c;
  
  switch (i->type) {
    case MPC_INPUT_STRING: return i->string[i->state.pos];
    case MPC_INPUT_FILE: 
      
      if (feof(i->file)) { return '\0'; }
      
      c = fgetc(i->file);
      fseek(i->file, -1, SEEK_CUR);
      break;
    
    case MPC_INPUT_PIPE:
      
      if (feof(i->file)) { return '\0'; }
      
      if (!i->buffer) { c = getc(i->file); ungetc(c, i->file); break; }
      
      if (i->buffer && mpc_input_buffer_in_range(i)) {
        return mpc_input_buffer_get(i);
      } else {
        c = getc(i->file); ungetc(c, i->file);
        break;
      }
      
  }
  
  return c;
  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x18(%rbp)
testl %eax, %eax
je 0xcc42
jmp 0xcc2b
movl -0x18(%rbp), %eax
subl $0x1, %eax
je 0xcc5d
jmp 0xcc35
movl -0x18(%rbp), %eax
subl $0x2, %eax
je 0xcca6
jmp 0xcd34
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x10(%rcx), %rcx
movb (%rax,%rcx), %al
movb %al, -0x1(%rbp)
jmp 0xcd3a
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x2200
cmpl $0x0, %eax
je 0xcc78
movb $0x0, -0x1(%rbp)
jmp 0xcd3a
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x2170
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
movq $-0x1, %rsi
movl $0x1, %edx
callq 0x2290
jmp 0xcd34
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x2200
cmpl $0x0, %eax
je 0xccbe
movb $0x0, -0x1(%rbp)
jmp 0xcd3a
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0xccec
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x2360
movb %al, -0x11(%rbp)
movsbl -0x11(%rbp), %edi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0x2280
jmp 0xcd34
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0xcd13
movq -0x10(%rbp), %rdi
callq 0x13910
cmpl $0x0, %eax
je 0xcd13
movq -0x10(%rbp), %rdi
callq 0x13960
movb %al, -0x1(%rbp)
jmp 0xcd3a
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x2360
movb %al, -0x11(%rbp)
movsbl -0x11(%rbp), %edi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0x2280
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/voithos[P]awl/src/mpc.c
// Function: mpc_stack_popr
static int mpc_stack_popr(mpc_stack_t *s, mpc_result_t *x) {
  int r;
  *x = s->results[s->results_num-1];
  r = s->returns[s->results_num-1];
  s->results_num--;
  mpc_stack_results_reserve_less(s);
  return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x20(%rcx), %rcx
movq -0x8(%rbp), %rdx
movl 0x18(%rdx), %edx
subl $0x1, %edx
movslq %edx, %rdx
movq (%rcx,%rdx,8), %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x18(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x18(%rax)
movq -0x8(%rbp), %rdi
callq 0x13ae0
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/mpc.c
// Function: mpc_input_mark
static void mpc_input_mark(mpc_input_t *i) {
  
  if (i->backtrack < 1) { return; }
  
  i->marks_num++;
  i->marks = realloc(i->marks, sizeof(mpc_state_t) * i->marks_num);
  i->lasts = realloc(i->lasts, sizeof(int) * i->marks_num);
  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, 0x38(%rax)
jge 0xce4b
jmp 0xcf18
movq -0x8(%rbp), %rax
movl 0x3c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x3c(%rax)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x3c(%rax), %rax
imulq $0xc, %rax, %rsi
callq 0x22a0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x3c(%rax), %rsi
shlq $0x2, %rsi
callq 0x22a0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x3c(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rdx
movq %rdx, (%rax)
movl 0x18(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
movsbl 0x50(%rax), %edx
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x3c(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
cmpl $0x2, (%rax)
jne 0xcf18
movq -0x8(%rbp), %rax
cmpl $0x1, 0x3c(%rax)
jne 0xcf18
movl $0x1, %esi
movq %rsi, %rdi
callq 0x21c0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/mpc.c
// Function: mpc_input_unmark
static void mpc_input_unmark(mpc_input_t *i) {
  
  if (i->backtrack < 1) { return; }
  
  i->marks_num--;
  i->marks = realloc(i->marks, sizeof(mpc_state_t) * i->marks_num);
  i->lasts = realloc(i->lasts, sizeof(int) * i->marks_num);
  
  if (i->type == MPC_INPUT_PIPE && i->marks_num == 0) {
    free(i->buffer);
    i->buffer = NULL;
  }
  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x38(%rax)
jge 0xcfdb
jmp 0xd05c
movq -0x8(%rbp), %rax
movl 0x3c(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x3c(%rax)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x3c(%rax), %rax
imulq $0xc, %rax, %rsi
callq 0x22a0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x3c(%rax), %rsi
shlq $0x2, %rsi
callq 0x22a0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x8(%rbp), %rax
cmpl $0x2, (%rax)
jne 0xd05c
movq -0x8(%rbp), %rax
cmpl $0x0, 0x3c(%rax)
jne 0xd05c
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x23a0
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/mpc.c
// Function: mpc_stack_err
static void mpc_stack_err(mpc_stack_t *s, mpc_err_t* e) {
  mpc_err_t *errs[2];
  errs[0] = s->err;
  errs[1] = e;
  s->err = mpc_err_or(errs, 2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x20(%rbp), %rdi
movl $0x2, %esi
callq 0x13ba0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/mpc.c
// Function: mpc_stack_popr_out_single
static void mpc_stack_popr_out_single(mpc_stack_t *s, int n, mpc_dtor_t dx) {
  mpc_result_t x;
  while (n) {
    mpc_stack_popr(s, &x);
    dx(x.output);
    n--;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0xd1db
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xcd80
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rdi
callq *%rax
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xd1b3
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/mpc.c
// Function: mpc_err_count
static mpc_err_t *mpc_err_count(mpc_err_t *x, int n) {
  mpc_err_t *y;
  int digits = n/10 + 1;
  char *prefix = malloc(digits + strlen(" of ") + 1);
  sprintf(prefix, "%i of ", n);
  y = mpc_err_repeat(x, prefix);
  free(prefix);
  return y;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movslq -0x1c(%rbp), %rdi
addq $0x4, %rdi
addq $0x1, %rdi
callq 0x2250
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movl -0xc(%rbp), %edx
leaq 0xdf7b(%rip), %rsi      # 0x1b1ae
movb $0x0, %al
callq 0x2330
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x13f50
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rdi
callq 0x23a0
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/mpc.c
// Function: mpc_stack_popr_err
static void mpc_stack_popr_err(mpc_stack_t *s, int n) {
  mpc_result_t x;
  while (n) {
    mpc_stack_popr(s, &x);
    mpc_stack_err(s, x.error);
    n--;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0xd29a
movq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xcd80
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xd070
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xd26f
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/mpc.c
// Function: mpc_stack_popr_out
static void mpc_stack_popr_out(mpc_stack_t *s, int n, mpc_dtor_t *ds) {
  mpc_result_t x;
  while (n) {
    mpc_stack_popr(s, &x);
    ds[n-1](x.output);
    n--;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0xd338
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xcd80
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq -0x20(%rbp), %rdi
callq *%rax
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xd303
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/mpc.c
// Function: mpc_stack_terminate
static int mpc_stack_terminate(mpc_stack_t *s, mpc_result_t *r) {
  int success = s->returns[0];
  
  if (success) {
    r->output = s->results[0].output;
    mpc_err_delete(s->err);
  } else {
    mpc_stack_err(s, s->results[0].error);
    r->error = s->err;
  }
  
  free(s->parsers);
  free(s->states);
  free(s->results);
  free(s->returns);
  free(s);
  
  return success;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0xd384
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0xa380
jmp 0xd3a7
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq (%rax), %rsi
callq 0xd070
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x23a0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x23a0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x23a0
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x23a0
movq -0x8(%rbp), %rdi
callq 0x23a0
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/mpc.c
// Function: mpc_input_new_string
static mpc_input_t *mpc_input_new_string(const char *filename, const char *string) {

  mpc_input_t *i = malloc(sizeof(mpc_input_t));
  
  i->filename = malloc(strlen(filename) + 1);
  strcpy(i->filename, filename);
  i->type = MPC_INPUT_STRING;
  
  i->state = mpc_state_new();
  
  i->string = malloc(strlen(string) + 1);
  strcpy(i->string, string);
  i->buffer = NULL;
  i->file = NULL;
  
  i->backtrack = 1;
  i->marks_num = 0;
  i->marks = NULL;
  i->lasts = NULL;

  i->last = -1;
  
  return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x58, %edi
callq 0x2250
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x20f0
movq %rax, %rdi
incq %rdi
callq 0x2250
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x2070
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0xd940
movq %rax, %rcx
movq -0x40(%rbp), %rax
movl %edx, -0x30(%rbp)
movq %rcx, -0x38(%rbp)
movq -0x38(%rbp), %rcx
movq %rcx, -0x24(%rbp)
movl -0x30(%rbp), %ecx
movl %ecx, -0x1c(%rbp)
movq -0x24(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl -0x1c(%rbp), %ecx
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rdi
callq 0x20f0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x2250
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x2070
movq -0x18(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x18(%rbp), %rax
movl $0x1, 0x38(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x3c(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x48(%rax)
movq -0x18(%rbp), %rax
movb $-0x1, 0x50(%rax)
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/mpc.c
// Function: mpc_input_new_file
static mpc_input_t *mpc_input_new_file(const char *filename, FILE *file) {
  
  mpc_input_t *i = malloc(sizeof(mpc_input_t));
  
  i->filename = malloc(strlen(filename) + 1);
  strcpy(i->filename, filename);
  i->type = MPC_INPUT_FILE;
  i->state = mpc_state_new();
  
  i->string = NULL;
  i->buffer = NULL;
  i->file = file;
  
  i->backtrack = 1;
  i->marks_num = 0;
  i->marks = NULL;
  i->lasts = NULL;
  
  i->last = -1;
  
  return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x58, %edi
callq 0x2250
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x20f0
movq %rax, %rdi
incq %rdi
callq 0x2250
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x2070
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0xd940
movq %rax, %rcx
movq -0x40(%rbp), %rax
movl %edx, -0x30(%rbp)
movq %rcx, -0x38(%rbp)
movq -0x38(%rbp), %rcx
movq %rcx, -0x24(%rbp)
movl -0x30(%rbp), %ecx
movl %ecx, -0x1c(%rbp)
movq -0x24(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl -0x1c(%rbp), %ecx
movl %ecx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x18(%rbp), %rax
movl $0x1, 0x38(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x3c(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x48(%rax)
movq -0x18(%rbp), %rax
movb $-0x1, 0x50(%rax)
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/mpc.c
// Function: mpc_parse_contents
int mpc_parse_contents(const char *filename, mpc_parser_t *p, mpc_result_t *r) {
  
  FILE *f = fopen(filename, "rb");
  int res;
  
  if (f == NULL) {
    r->output = NULL;
    r->error = mpc_err_fail(filename, mpc_state_new(), "Unable to open file!");
    return 0;
  }
  
  res = mpc_parse_file(filename, f, p, r);
  fclose(f);
  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xd5b6(%rip), %rsi      # 0x1ae45
callq 0x22f0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xd904
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
callq 0xd940
movq -0x60(%rbp), %rdi
movl %edx, -0x40(%rbp)
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x40(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x58(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x50(%rbp)
movq -0x58(%rbp), %rsi
movl -0x50(%rbp), %edx
leaq 0xd55c(%rip), %rcx      # 0x1ae48
callq 0xc4f0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0xd92b
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0xd5d0
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
callq 0x20e0
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/mpc.c
// Function: mpc_state_new
static mpc_state_t mpc_state_new(void) {
  mpc_state_t s;
  s.pos = 0;
  s.row = 0;
  s.col = 0;
  return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, -0xc(%rbp)
movl $0x0, -0x8(%rbp)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0xc(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl -0x18(%rbp), %edx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/mpc.c
// Function: mpc_undefined
static mpc_parser_t *mpc_undefined(void) {
  mpc_parser_t *p = calloc(1, sizeof(mpc_parser_t));
  p->retained = 0;
  p->type = MPC_TYPE_UNDEFINED;
  p->name = NULL;
  return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x1, %edi
movl $0x38, %esi
callq 0x21c0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/mpc.c
// Function: mpc_lift_val
mpc_parser_t *mpc_lift_val(mpc_val_t *x) {
  mpc_parser_t *p = mpc_undefined();
  p->type = MPC_TYPE_LIFT_VAL;
  p->data.lift.x = x;
  return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0xdb70
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movb $0x4, 0x10(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/mpc.c
// Function: mpc_lift
mpc_parser_t *mpc_lift(mpc_ctor_t lf) {
  mpc_parser_t *p = mpc_undefined();
  p->type = MPC_TYPE_LIFT;
  p->data.lift.lf = lf;
  return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0xdb70
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movb $0x3, 0x10(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/mpc.c
// Function: mpc_char
mpc_parser_t *mpc_char(char c) {
  mpc_parser_t *p = mpc_undefined();
  p->type = MPC_TYPE_SINGLE;
  p->data.single.x = c;
  return mpc_expectf(p, "'%c'", c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
callq 0xdb70
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movb $0xb, 0x10(%rax)
movb -0x1(%rbp), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x18(%rax)
movq -0x10(%rbp), %rdi
movsbl -0x1(%rbp), %edx
leaq 0xcc46(%rip), %rsi      # 0x1aeae
movb $0x0, %al
callq 0xe100
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/mpc.c
// Function: mpc_range
mpc_parser_t *mpc_range(char s, char e) {
  mpc_parser_t *p = mpc_undefined();
  p->type = MPC_TYPE_RANGE;
  p->data.range.x = s;
  p->data.range.y = e;
  return mpc_expectf(p, "character between '%c' and '%c'", s, e);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movb %dil, %cl
movb %cl, -0x1(%rbp)
movb %al, -0x2(%rbp)
callq 0xdb70
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movb $0xe, 0x10(%rax)
movb -0x1(%rbp), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x18(%rax)
movb -0x2(%rbp), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x19(%rax)
movq -0x10(%rbp), %rdi
movsbl -0x1(%rbp), %edx
movsbl -0x2(%rbp), %ecx
leaq 0xcbc7(%rip), %rsi      # 0x1ae93
movb $0x0, %al
callq 0xe100
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/mpc.c
// Function: mpc_noneof
mpc_parser_t *mpc_noneof(const char *s) {
  mpc_parser_t *p = mpc_undefined();
  p->type = MPC_TYPE_NONEOF;
  p->data.string.x = malloc(strlen(s) + 1);
  strcpy(p->data.string.x, s);
  return mpc_expectf(p, "one of '%s'", s);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0xdb70
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movb $0xd, 0x10(%rax)
movq -0x8(%rbp), %rdi
callq 0x20f0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x2250
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x2070
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rdx
leaq 0xcb06(%rip), %rsi      # 0x1aeb3
movb $0x0, %al
callq 0xe100
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/mpc.c
// Function: mpc_satisfy
mpc_parser_t *mpc_satisfy(int(*f)(char)) {
  mpc_parser_t *p = mpc_undefined();
  p->type = MPC_TYPE_SATISFY;
  p->data.satisfy.f = f;
  return mpc_expectf(p, "character satisfying function %p", f);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0xdb70
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movb $0xf, 0x10(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rdx
leaq 0xcac7(%rip), %rsi      # 0x1aebf
movb $0x0, %al
callq 0xe100
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/mpc.c
// Function: mpc_apply_to
mpc_parser_t *mpc_apply_to(mpc_parser_t *a, mpc_apply_to_t f, void *x) {
  mpc_parser_t *p = mpc_undefined();
  p->type = MPC_TYPE_APPLY_TO;
  p->data.apply_to.x = a;
  p->data.apply_to.f = f;
  p->data.apply_to.d = x;
  return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
callq 0xdb70
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movb $0x12, 0x10(%rax)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/mpc.c
// Function: mpc_predictive
mpc_parser_t *mpc_predictive(mpc_parser_t *a) {
  mpc_parser_t *p = mpc_undefined();
  p->type = MPC_TYPE_PREDICT;
  p->data.predict.x = a;
  return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0xdb70
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movb $0x13, 0x10(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/mpc.c
// Function: mpc_maybe_lift
mpc_parser_t *mpc_maybe_lift(mpc_parser_t *a, mpc_ctor_t lf) {
  mpc_parser_t *p = mpc_undefined();
  p->type = MPC_TYPE_MAYBE;
  p->data.not.x = a;
  p->data.not.lf = lf;
  return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0xdb70
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movb $0x15, 0x10(%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/mpc.c
// Function: mpc_many
mpc_parser_t *mpc_many(mpc_fold_t f, mpc_parser_t *a) {
  mpc_parser_t *p = mpc_undefined();
  p->type = MPC_TYPE_MANY;
  p->data.repeat.x = a;
  p->data.repeat.f = f;
  return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0xdb70
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movb $0x16, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/mpc.c
// Function: mpc_many1
mpc_parser_t *mpc_many1(mpc_fold_t f, mpc_parser_t *a) {
  mpc_parser_t *p = mpc_undefined();
  p->type = MPC_TYPE_MANY1;
  p->data.repeat.x = a;
  p->data.repeat.f = f;
  return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0xdb70
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movb $0x17, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/mpc.c
// Function: mpc_count
mpc_parser_t *mpc_count(int n, mpc_fold_t f, mpc_parser_t *a, mpc_dtor_t da) {
  mpc_parser_t *p = mpc_undefined();
  p->type = MPC_TYPE_COUNT;
  p->data.repeat.n = n;
  p->data.repeat.f = f;
  p->data.repeat.x = a;
  p->data.repeat.dx = da;
  return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
callq 0xdb70
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movb $0x18, 0x10(%rax)
movl -0x4(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/mpc.c
// Function: mpcf_strfold
mpc_val_t *mpcf_strfold(int n, mpc_val_t **xs) {
  char *x = calloc(1, 1);
  int i;
  for (i = 0; i < n; i++) {
    x = realloc(x, strlen(x) + strlen(xs[i]) + 1);
    strcat(x, xs[i]);
    free(xs[i]);
  }
  return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, %esi
movq %rsi, %rdi
callq 0x21c0
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0xec6e
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x20f0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x20f0
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdi
addq %rax, %rsi
addq $0x1, %rsi
callq 0x22a0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x2320
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x23a0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xebf7
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/mpc.c
// Function: mpcf_re_repeat
static mpc_val_t *mpcf_re_repeat(int n, mpc_val_t **xs) {
  
  int num;
  if (xs[1] == NULL) { return xs[0]; }
  if (strcmp(xs[1], "*") == 0) { free(xs[1]); return mpc_many(mpcf_strfold, xs[0]); }
  if (strcmp(xs[1], "+") == 0) { free(xs[1]); return mpc_many1(mpcf_strfold, xs[0]); }
  if (strcmp(xs[1], "?") == 0) { free(xs[1]); return mpc_maybe_lift(xs[0], mpcf_ctor_str); }
  num = *(int*)xs[1];
  free(xs[1]);
  
  return mpc_count(num, mpcf_strfold, xs[0], free);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xff2a
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x10025
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xa13f(%rip), %rsi      # 0x1a078
callq 0x21d0
cmpl $0x0, %eax
jne 0xff6c
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x23a0
movq -0x18(%rbp), %rax
movq (%rax), %rsi
leaq -0x138e(%rip), %rdi     # 0xebd0
callq 0xe690
movq %rax, -0x8(%rbp)
jmp 0x10025
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xa0fb(%rip), %rsi      # 0x1a076
callq 0x21d0
cmpl $0x0, %eax
jne 0xffab
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x23a0
movq -0x18(%rbp), %rax
movq (%rax), %rsi
leaq -0x13d0(%rip), %rdi     # 0xebd0
callq 0xe6e0
movq %rax, -0x8(%rbp)
jmp 0x10025
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xa223(%rip), %rsi      # 0x1a1dd
callq 0x21d0
cmpl $0x0, %eax
jne 0xffea
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x23a0
movq -0x18(%rbp), %rax
movq (%rax), %rdi
leaq -0xd4f(%rip), %rsi      # 0xf290
callq 0xe610
movq %rax, -0x8(%rbp)
jmp 0x10025
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x23a0
movl -0x1c(%rbp), %edi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
leaq -0x1445(%rip), %rsi     # 0xebd0
movq 0x11f9c(%rip), %rcx     # 0x21fb8
callq 0xe730
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/mpc.c
// Function: mpcf_escape_new
static mpc_val_t *mpcf_escape_new(mpc_val_t *x, char *input, char **output) {
  
  int i;
  int found;
  char *s = x;
  char *y = calloc(1, 1);
  char buff[2];
  
  while (*s) {
    
    i = 0;
    found = 0;

    while (output[i]) {
      if (*s == input[i]) {
        y = realloc(y, strlen(y) + strlen(output[i]) + 1);
        strcat(y, output[i]);
        found = 1;
        break;
      }
      i++;
    }
    
    if (!found) {
      y = realloc(y, strlen(y) + 2);
      buff[0] = *s; buff[1] = '\0';
      strcat(y, buff);
    }
    
    s++;
  }
  
  
  return y;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x1, %esi
movq %rsi, %rdi
callq 0x21c0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpb $0x0, (%rax)
je 0x10732
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x106dc
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
movq -0x10(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0x106ce
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
callq 0x20f0
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x20f0
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdi
addq %rax, %rsi
addq $0x1, %rsi
callq 0x22a0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x2320
movl $0x1, -0x20(%rbp)
jmp 0x106dc
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x10648
cmpl $0x0, -0x20(%rbp)
jne 0x10721
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x30(%rbp), %rdi
callq 0x20f0
movq -0x50(%rbp), %rdi
movq %rax, %rsi
addq $0x2, %rsi
callq 0x22a0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movb (%rax), %al
movb %al, -0x32(%rbp)
movb $0x0, -0x31(%rbp)
movq -0x30(%rbp), %rdi
leaq -0x32(%rbp), %rsi
callq 0x2320
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x1062d
movq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/mpc.c
// Function: mpcf_unescape_new
static mpc_val_t *mpcf_unescape_new(mpc_val_t *x, char *input, char **output) {
  
  int i;
  int found = 0;
  char *s = x;
  char *y = calloc(1, 1);
  char buff[2];

  while (*s) {
    
    i = 0;
    found = 0;
    
    while (output[i]) {
      if ((*(s+0)) == output[i][0] &&
          (*(s+1)) == output[i][1]) {
        y = realloc(y, strlen(y) + 2);
        buff[0] = input[i]; buff[1] = '\0';
        strcat(y, buff);
        found = 1;
        s++;
        break;
      }
      i++;
    }
      
    if (!found) {
      y = realloc(y, strlen(y) + 2);
      buff[0] = *s; buff[1] = '\0';
      strcat(y, buff);
    }
    
    if (*s == '\0') { break; }
    else { s++; }
  }
  
  return y;
  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x1, %esi
movq %rsi, %rdi
callq 0x21c0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpb $0x0, (%rax)
je 0x108e3
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x1087f
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
movq -0x18(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x10871
movq -0x28(%rbp), %rax
movsbl 0x1(%rax), %eax
movq -0x18(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movsbl 0x1(%rcx), %ecx
cmpl %ecx, %eax
jne 0x10871
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
callq 0x20f0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
addq $0x2, %rsi
callq 0x22a0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x32(%rbp)
movb $0x0, -0x31(%rbp)
movq -0x30(%rbp), %rdi
leaq -0x32(%rbp), %rsi
callq 0x2320
movl $0x1, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x1087f
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x107cf
cmpl $0x0, -0x20(%rbp)
jne 0x108c4
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rdi
callq 0x20f0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
addq $0x2, %rsi
callq 0x22a0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movb (%rax), %al
movb %al, -0x32(%rbp)
movb $0x0, -0x31(%rbp)
movq -0x30(%rbp), %rdi
leaq -0x32(%rbp), %rsi
callq 0x2320
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x108d2
jmp 0x108e3
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x107b4
movq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/mpc.c
// Function: mpc_test_fail
int mpc_test_fail(mpc_parser_t *p, const char *s, void *d,
  int(*tester)(void*, void*),
  mpc_dtor_t destructor,
  void(*printer)(void*)) {

  mpc_result_t r;  
  if (mpc_parse("<test>", s, p, &r)) {

    if (tester(r.output, d)) {
      destructor(r.output);
      return 0;
    } else {
      destructor(r.output);
      return 1;
    }
  
  } else {
    mpc_err_delete(r.error);
    return 1;
  }
  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq 0x9e32(%rip), %rdi      # 0x1b091
leaq -0x40(%rbp), %rcx
callq 0xd3f0
cmpl $0x0, %eax
je 0x112a6
movq -0x28(%rbp), %rax
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq *%rax
cmpl $0x0, %eax
je 0x11293
movq -0x30(%rbp), %rax
movq -0x40(%rbp), %rdi
callq *%rax
movl $0x0, -0x4(%rbp)
jmp 0x112b6
movq -0x30(%rbp), %rax
movq -0x40(%rbp), %rdi
callq *%rax
movl $0x1, -0x4(%rbp)
jmp 0x112b6
movq -0x40(%rbp), %rdi
callq 0xa380
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/mpc.c
// Function: mpc_test_pass
int mpc_test_pass(mpc_parser_t *p, const char *s, void *d,
  int(*tester)(void*, void*), 
  mpc_dtor_t destructor, 
  void(*printer)(void*)) {

  mpc_result_t r;  
  if (mpc_parse("<test>", s, p, &r)) {
    
    if (tester(r.output, d)) {
      destructor(r.output);
      return 1;
    } else {
      printf("Got "); printer(r.output); printf("\n");
      printf("Expected "); printer(d); printf("\n");
      destructor(r.output);
      return 0;
    }
    
  } else {    
    mpc_err_print(r.error);
    mpc_err_delete(r.error);
    return 0;
    
  }
  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq 0x9da2(%rip), %rdi      # 0x1b091
leaq -0x40(%rbp), %rcx
callq 0xd3f0
cmpl $0x0, %eax
je 0x11386
movq -0x28(%rbp), %rax
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq *%rax
cmpl $0x0, %eax
je 0x11327
movq -0x30(%rbp), %rax
movq -0x40(%rbp), %rdi
callq *%rax
movl $0x1, -0x4(%rbp)
jmp 0x1139f
leaq 0x9d6a(%rip), %rdi      # 0x1b098
movb $0x0, %al
callq 0x2110
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rdi
callq *%rax
leaq 0xa5ef(%rip), %rdi      # 0x1b935
movb $0x0, %al
callq 0x2110
leaq 0x9d49(%rip), %rdi      # 0x1b09d
movb $0x0, %al
callq 0x2110
movq -0x38(%rbp), %rax
movq -0x20(%rbp), %rdi
callq *%rax
leaq 0xa5c9(%rip), %rdi      # 0x1b935
movb $0x0, %al
callq 0x2110
movq -0x30(%rbp), %rax
movq -0x40(%rbp), %rdi
callq *%rax
movl $0x0, -0x4(%rbp)
jmp 0x1139f
movq -0x40(%rbp), %rdi
callq 0xa400
movq -0x40(%rbp), %rdi
callq 0xa380
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/mpc.c
// Function: mpc_ast_print_depth
static void mpc_ast_print_depth(mpc_ast_t *a, int d) {
  
  int i;
  for (i = 0; i < d; i++) { printf("  "); }
  
  if (strlen(a->contents)) {
    printf("%s:%i:%i '%s'\n", a->tag, a->state.row+1, a->state.col+1, a->contents);
  } else {
    printf("%s \n", a->tag);
  }
  
  for (i = 0; i < a->children_num; i++) {
    mpc_ast_print_depth(a->children[i], d+1);
  }
  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x11a47
leaq 0x9e02(%rip), %rdi      # 0x1b837
movb $0x0, %al
callq 0x2110
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x11a26
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x20f0
cmpq $0x0, %rax
je 0x11a8d
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq -0x8(%rbp), %rax
movl 0x14(%rax), %edx
addl $0x1, %edx
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %r8
leaq 0x97ce(%rip), %rdi      # 0x1b252
movb $0x0, %al
callq 0x2110
jmp 0x11aa2
movq -0x8(%rbp), %rax
movq (%rax), %rsi
leaq 0x97c6(%rip), %rdi      # 0x1b261
movb $0x0, %al
callq 0x2110
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
jge 0x11adb
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movl -0xc(%rbp), %esi
addl $0x1, %esi
callq 0x11a10
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x11aa9
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/mpc.c
// Function: mpcf_state_ast
mpc_val_t *mpcf_state_ast(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);
  free(s);
  return a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x30(%rbp)
movl 0x8(%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x30(%rbp), %rsi
movl -0x28(%rbp), %edx
callq 0x119a0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x23a0
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/mpc.c
// Function: mpcaf_grammar_repeat
static mpc_val_t *mpcaf_grammar_repeat(int n, mpc_val_t **xs) {
  
  int num;
  if (xs[1] == NULL) { return xs[0]; }  
  if (strcmp(xs[1], "*") == 0) { free(xs[1]); return mpca_many(xs[0]); }
  if (strcmp(xs[1], "+") == 0) { free(xs[1]); return mpca_many1(xs[0]); }
  if (strcmp(xs[1], "?") == 0) { free(xs[1]); return mpca_maybe(xs[0]); }
  if (strcmp(xs[1], "!") == 0) { free(xs[1]); return mpca_not(xs[0]); }
  num = *((int*)xs[1]);
  free(xs[1]);
  return mpca_count(num, xs[0]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x1278a
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x1289d
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x78df(%rip), %rsi      # 0x1a078
callq 0x21d0
cmpl $0x0, %eax
jne 0x127c5
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x23a0
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x11ec0
movq %rax, -0x8(%rbp)
jmp 0x1289d
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x78a2(%rip), %rsi      # 0x1a076
callq 0x21d0
cmpl $0x0, %eax
jne 0x12800
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x23a0
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x11ef0
movq %rax, -0x8(%rbp)
jmp 0x1289d
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x79ce(%rip), %rsi      # 0x1a1dd
callq 0x21d0
cmpl $0x0, %eax
jne 0x12838
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x23a0
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x11ea0
movq %rax, -0x8(%rbp)
jmp 0x1289d
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x8a66(%rip), %rsi      # 0x1b2ad
callq 0x21d0
cmpl $0x0, %eax
jne 0x12870
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x23a0
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x11e70
movq %rax, -0x8(%rbp)
jmp 0x1289d
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x23a0
movl -0x1c(%rbp), %edi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x11f20
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/mpc.c
// Function: mpca_grammar
mpc_parser_t *mpca_grammar(int flags, const char *grammar, ...) {
  mpca_grammar_st_t st;
  mpc_parser_t *res;
  va_list va;
  va_start(va, grammar);
  
  st.va = &va;
  st.parsers_num = 0;
  st.parsers = NULL;
  st.flags = flags;
  
  res = mpca_grammar_st(grammar, &st);  
  free(st.parsers);
  va_end(va);
  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
testb %al, %al
je 0x12b5e
movaps %xmm0, -0xd0(%rbp)
movaps %xmm1, -0xc0(%rbp)
movaps %xmm2, -0xb0(%rbp)
movaps %xmm3, -0xa0(%rbp)
movaps %xmm4, -0x90(%rbp)
movaps %xmm5, -0x80(%rbp)
movaps %xmm6, -0x70(%rbp)
movaps %xmm7, -0x60(%rbp)
movq %r9, -0xd8(%rbp)
movq %r8, -0xe0(%rbp)
movq %rcx, -0xe8(%rbp)
movq %rdx, -0xf0(%rbp)
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x100(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x30, -0x4c(%rbp)
movl $0x10, -0x50(%rbp)
leaq -0x50(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x122a0
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0x23a0
movq -0x38(%rbp), %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/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) {
    return mpc_err_fail(filename, mpc_state_new(), "Unable to open file!");
  }
  
  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 $0x160, %rsp            # imm = 0x160
testb %al, %al
je 0x13387
movaps %xmm0, -0x120(%rbp)
movaps %xmm1, -0x110(%rbp)
movaps %xmm2, -0x100(%rbp)
movaps %xmm3, -0xf0(%rbp)
movaps %xmm4, -0xe0(%rbp)
movaps %xmm5, -0xd0(%rbp)
movaps %xmm6, -0xc0(%rbp)
movaps %xmm7, -0xb0(%rbp)
movq %r9, -0x128(%rbp)
movq %r8, -0x130(%rbp)
movq %rcx, -0x138(%rbp)
movq %rdx, -0x140(%rbp)
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x7a90(%rip), %rsi      # 0x1ae45
callq 0x22f0
movq %rax, -0x68(%rbp)
cmpq $0x0, -0x68(%rbp)
jne 0x1342d
movq -0x18(%rbp), %rax
movq %rax, -0x158(%rbp)
callq 0xd940
movq -0x158(%rbp), %rdi
movl %edx, -0x80(%rbp)
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rax
movq %rax, -0x74(%rbp)
movl -0x80(%rbp), %eax
movl %eax, -0x6c(%rbp)
movq -0x74(%rbp), %rax
movq %rax, -0x98(%rbp)
movl -0x6c(%rbp), %eax
movl %eax, -0x90(%rbp)
movq -0x98(%rbp), %rsi
movl -0x90(%rbp), %edx
leaq 0x7a29(%rip), %rcx      # 0x1ae48
callq 0xc4f0
movq %rax, -0x8(%rbp)
jmp 0x134b7
leaq -0x60(%rbp), %rax
leaq -0x150(%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 0xd620
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x12ce0
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
callq 0xd560
movq -0x28(%rbp), %rdi
callq 0x23a0
leaq -0x60(%rbp), %rax
movq -0x68(%rbp), %rdi
callq 0x20e0
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x160, %rsp            # imm = 0x160
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/voithos[P]awl/src/mpc.c
// Function: mpc_state_invalid
static mpc_state_t mpc_state_invalid(void) {
  mpc_state_t s;
  s.pos = -1;
  s.row = -1;
  s.col = -1;
  return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x8(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0xc(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl -0x18(%rbp), %edx
popq %rbp
retq