LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/orangeduck[P]mpc/mpc.c
// Function: mpca_lang_file
mpc_err_t *mpca_lang_file(int flags, FILE *f, ...) {
  mpca_grammar_st_t st;
  mpc_input_t *i;
  mpc_err_t *err;

  va_list va;
  va_start(va, f);

  st.va = &va;
  st.parsers_num = 0;
  st.parsers = NULL;
  st.flags = flags;

  i = mpc_input_new_file("<mpca_lang_file>", f);
  err = mpca_lang_st(i, &st);
  mpc_input_delete(i);

  free(st.parsers);
  va_end(va);
  return err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xf0, %rsp
leaq 0x40(%rsp), %r10
movq %rdx, 0x10(%r10)
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0xa102
movaps %xmm0, 0x70(%rsp)
movaps %xmm1, 0x80(%rsp)
movaps %xmm2, 0x90(%rsp)
movaps %xmm3, 0xa0(%rsp)
movaps %xmm4, 0xb0(%rsp)
movaps %xmm5, 0xc0(%rsp)
movaps %xmm6, 0xd0(%rsp)
movaps %xmm7, 0xe0(%rsp)
movq %rsp, %rax
movq %r10, 0x10(%rax)
leaq 0x110(%rsp), %rcx
movq %rcx, 0x8(%rax)
movabsq $0x3000000010, %rcx     # imm = 0x3000000010
movq %rcx, (%rax)
leaq 0x20(%rsp), %rbx
movq %rax, (%rbx)
andl $0x0, 0x8(%rbx)
andq $0x0, 0x10(%rbx)
movl %edi, 0x18(%rbx)
leaq 0x24d1(%rip), %rdi      # 0xc60e
callq 0x5da4
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0xa174
movq %rax, %r15
movq %r14, %rdi
callq 0x5c40
movq 0x10(%rbx), %rdi
callq 0x4880
movq %r15, %rax
addq $0xf0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/orangeduck[P]mpc/mpc.c
// Function: mpca_lang_pipe
mpc_err_t *mpca_lang_pipe(int flags, FILE *p, ...) {
  mpca_grammar_st_t st;
  mpc_input_t *i;
  mpc_err_t *err;

  va_list va;
  va_start(va, p);

  st.va = &va;
  st.parsers_num = 0;
  st.parsers = NULL;
  st.flags = flags;

  i = mpc_input_new_pipe("<mpca_lang_pipe>", p);
  err = mpca_lang_st(i, &st);
  mpc_input_delete(i);

  free(st.parsers);
  va_end(va);
  return err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xf0, %rsp
leaq 0x40(%rsp), %r10
movq %rdx, 0x10(%r10)
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0xa616
movaps %xmm0, 0x70(%rsp)
movaps %xmm1, 0x80(%rsp)
movaps %xmm2, 0x90(%rsp)
movaps %xmm3, 0xa0(%rsp)
movaps %xmm4, 0xb0(%rsp)
movaps %xmm5, 0xc0(%rsp)
movaps %xmm6, 0xd0(%rsp)
movaps %xmm7, 0xe0(%rsp)
movq %rsp, %rax
movq %r10, 0x10(%rax)
leaq 0x110(%rsp), %rcx
movq %rcx, 0x8(%rax)
movabsq $0x3000000010, %rcx     # imm = 0x3000000010
movq %rcx, (%rax)
leaq 0x20(%rsp), %rbx
movq %rax, (%rbx)
andl $0x0, 0x8(%rbx)
andq $0x0, 0x10(%rbx)
movl %edi, 0x18(%rbx)
leaq 0x1fce(%rip), %rdi      # 0xc61f
callq 0x5e6a
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0xa174
movq %rax, %r15
movq %r14, %rdi
callq 0x5c40
movq 0x10(%rbx), %rdi
callq 0x4880
movq %r15, %rax
addq $0xf0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/orangeduck[P]mpc/mpc.c
// Function: mpca_lang
mpc_err_t *mpca_lang(int flags, const char *language, ...) {

  mpca_grammar_st_t st;
  mpc_input_t *i;
  mpc_err_t *err;

  va_list va;
  va_start(va, language);

  st.va = &va;
  st.parsers_num = 0;
  st.parsers = NULL;
  st.flags = flags;

  i = mpc_input_new_string("<mpca_lang>", language);
  err = mpca_lang_st(i, &st);
  mpc_input_delete(i);

  free(st.parsers);
  va_end(va);
  return err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xf0, %rsp
leaq 0x40(%rsp), %r10
movq %rdx, 0x10(%r10)
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0xa6ea
movaps %xmm0, 0x70(%rsp)
movaps %xmm1, 0x80(%rsp)
movaps %xmm2, 0x90(%rsp)
movaps %xmm3, 0xa0(%rsp)
movaps %xmm4, 0xb0(%rsp)
movaps %xmm5, 0xc0(%rsp)
movaps %xmm6, 0xd0(%rsp)
movaps %xmm7, 0xe0(%rsp)
movq %rsp, %rax
movq %r10, 0x10(%rax)
leaq 0x110(%rsp), %rcx
movq %rcx, 0x8(%rax)
movabsq $0x3000000010, %rcx     # imm = 0x3000000010
movq %rcx, (%rax)
leaq 0x20(%rsp), %rbx
movq %rax, (%rbx)
andl $0x0, 0x8(%rbx)
andq $0x0, 0x10(%rbx)
movl %edi, 0x18(%rbx)
leaq 0x1f0b(%rip), %rdi      # 0xc630
callq 0x5b86
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0xa174
movq %rax, %r15
movq %r14, %rdi
callq 0x5c40
movq 0x10(%rbx), %rdi
callq 0x4880
movq %r15, %rax
addq $0xf0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xf0, %rsp
movq %rsi, %r14
movl %edi, %ebp
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0xa7bf
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
leaq 0x1b7f(%rip), %rsi      # 0xc345
movq %r14, %rdi
callq 0x46e0
testq %rax, %rax
je 0xa860
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq %rsp, %rcx
movq %rax, 0x10(%rcx)
leaq 0x120(%rsp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rcx)
leaq 0xd0(%rsp), %r15
movq %rcx, (%r15)
andl $0x0, 0x8(%r15)
andq $0x0, 0x10(%r15)
movl %ebp, 0x18(%r15)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5da4
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0xa174
movq %rax, %r12
movq %r14, %rdi
callq 0x5c40
movq 0x10(%r15), %rdi
callq 0x4880
movq %rbx, %rdi
callq 0x41a0
movq %r12, %rax
addq $0xf0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
addq $0xf0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x5f5e
// File: /workspace/github_c_makefile_star2_O2/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:
cmpq $0x41, %rsi
jae 0xafb4
movq 0x70(%rdi), %rax
movq %rax, %rcx
cmpb $0x0, 0x78(%rdi,%rcx)
je 0xafbc
incl %ecx
andl $0x1ff, %ecx            # imm = 0x1FF
movq %rcx, 0x70(%rdi)
cmpq %rcx, %rax
jne 0xaf9c
movq %rsi, %rdi
jmp 0x45a0
movq %rcx, %rax
shlq $0x6, %rax
addq %rdi, %rax
addq $0x278, %rax            # imm = 0x278
movb $0x1, 0x78(%rdi,%rcx)
movl 0x70(%rdi), %ecx
incl %ecx
andl $0x1ff, %ecx            # imm = 0x1FF
movq %rcx, 0x70(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
callq 0xb4e0
xorl %ebx, %ebx
testl %eax, %eax
jne 0xb027
movq %r15, %rdi
callq 0xb4f1
cmpb %bpl, %al
jne 0xb01c
movsbl %bpl, %esi
movq %r15, %rdi
movq %r14, %rdx
callq 0xb55b
pushq $0x1
popq %rbx
jmp 0xb027
movsbl %al, %esi
movq %r15, %rdi
callq 0xb6cd
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
cmpl $0x0, 0x48(%rdi)
je 0xb06c
xorl %ebx, %ebx
jmp 0xb103
movq %rsi, %r15
movq %rdi, %r14
pushq $0x48
popq %rsi
callq 0xaf8f
movq %rax, %rbx
movq 0x8(%r14), %rdi
callq 0x41c0
leaq 0x1(%rax), %rsi
movq %r14, %rdi
callq 0xaf8f
movq %rax, 0x28(%rbx)
movq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0x40e0
movups 0x10(%r14), %xmm0
movups 0x20(%r14), %xmm1
movups %xmm0, (%rbx)
movups %xmm1, 0x10(%rbx)
movl $0x1, 0x20(%rbx)
pushq $0x8
popq %rsi
movq %r14, %rdi
callq 0xaf8f
movq %rax, 0x38(%rbx)
movq %r15, %rdi
callq 0x41c0
leaq 0x1(%rax), %rsi
movq %r14, %rdi
callq 0xaf8f
movq 0x38(%rbx), %rcx
movq %rax, (%rcx)
movq 0x38(%rbx), %rax
movq (%rax), %rdi
movq %r15, %rsi
callq 0x40e0
andq $0x0, 0x30(%rbx)
movq %r14, %rdi
callq 0xb5fc
movb %al, 0x40(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
cmpl $0x0, 0x4c(%rdi)
jle 0xb1a4
pushq %rbx
movq %rdi, %rbx
movl 0x54(%rdi), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x54(%rdi)
cmpl 0x50(%rdi), %eax
jl 0xb15d
pushq $0x2
popq %rsi
movl %ecx, %eax
cltd
idivl %esi
addl %ecx, %eax
movl %eax, 0x50(%rbx)
movq 0x58(%rbx), %rdi
movslq %eax, %rsi
shlq $0x5, %rsi
callq 0x4610
movq %rax, 0x58(%rbx)
movq 0x60(%rbx), %rdi
movslq 0x50(%rbx), %rsi
callq 0x4610
movq %rax, 0x60(%rbx)
movl 0x54(%rbx), %ecx
movq 0x58(%rbx), %rax
movslq %ecx, %rcx
shlq $0x5, %rcx
movups 0x10(%rbx), %xmm0
movups 0x20(%rbx), %xmm1
movups %xmm1, -0x10(%rax,%rcx)
movups %xmm0, -0x20(%rax,%rcx)
movb 0x68(%rbx), %al
movq 0x60(%rbx), %rcx
movslq 0x54(%rbx), %rdx
movb %al, -0x1(%rcx,%rdx)
cmpl $0x2, (%rbx)
jne 0xb1a3
cmpl $0x1, 0x54(%rbx)
jne 0xb1a3
pushq $0x1
popq %rdi
movq %rdi, %rsi
callq 0x43c0
movq %rax, 0x38(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
cmpl $0x0, 0x4c(%rdi)
jle 0xb1f5
pushq %rbx
movq %rdi, %rbx
movq 0x58(%rdi), %rax
movslq 0x54(%rdi), %rcx
movq %rcx, %rdx
shlq $0x5, %rdx
movups -0x20(%rax,%rdx), %xmm0
movups -0x10(%rax,%rdx), %xmm1
movups %xmm0, 0x10(%rdi)
movups %xmm1, 0x20(%rdi)
movq 0x60(%rdi), %rax
movb -0x1(%rax,%rcx), %al
movb %al, 0x68(%rdi)
cmpl $0x1, (%rdi)
jne 0xb1ef
movq 0x10(%rbx), %rsi
movq 0x40(%rbx), %rdi
xorl %edx, %edx
callq 0x4600
movq %rbx, %rdi
popq %rbx
jmp 0xb1f6
retq
// File: /workspace/github_c_makefile_star2_O2/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:
cmpl $0x0, 0x4c(%rdi)
jle 0xb2a3
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x50(%rdi), %edi
movl 0x54(%rbx), %esi
leal -0x1(%rsi), %ecx
movl %ecx, 0x54(%rbx)
pushq $0x2
popq %r8
movl %ecx, %eax
cltd
idivl %r8d
cmpl $0x21, %edi
jl 0xb258
addl %esi, %eax
decl %eax
cmpl %eax, %edi
jle 0xb258
cmpl $0x22, %esi
pushq $0x20
popq %rsi
cmovgel %ecx, %esi
movl %esi, 0x50(%rbx)
movq 0x58(%rbx), %rdi
shlq $0x5, %rsi
callq 0x4610
movq %rax, 0x58(%rbx)
movq 0x60(%rbx), %rdi
movslq 0x50(%rbx), %rsi
callq 0x4610
movq %rax, 0x60(%rbx)
cmpl $0x2, (%rbx)
jne 0xb29c
cmpl $0x0, 0x54(%rbx)
jne 0xb29c
movq 0x38(%rbx), %rdi
callq 0x41c0
movl %eax, %r14d
decq %r14
movq 0x38(%rbx), %rdi
testl %r14d, %r14d
js 0xb292
movl %r14d, %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movsbl (%rdi,%rax), %edi
movq 0x40(%rbx), %rsi
callq 0x45d0
jmp 0xb26f
callq 0x4880
andq $0x0, 0x38(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
cmpl $0x4, %esi
jne 0xb2c5
pushq %rbx
movq %rdx, %rbx
pushq $0x30
popq %rsi
callq 0xaf8f
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups %xmm0, (%rax)
movups %xmm1, 0x10(%rax)
popq %rbx
retq
jl 0xb2d9
movl %esi, %edx
shrl %edx
addl %esi, %edx
shlq $0x3, %rdx
movq %rcx, %rsi
jmp 0xb723
movq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq 0x5c51(%rip), %rsi      # 0x10f40
je 0xb375
movq %rcx, %rbx
cmpq 0x5c59(%rip), %rsi      # 0x10f58
je 0xb37a
cmpq 0x5cc0(%rip), %rsi      # 0x10fc8
je 0xb37f
cmpq 0x5c7f(%rip), %rsi      # 0x10f90
je 0xb385
movl %edx, %r15d
movq %rdi, %r14
cmpq 0x5c08(%rip), %rsi      # 0x10f28
je 0xb39b
cmpq 0x5be7(%rip), %rsi      # 0x10f10
je 0xb3a8
cmpq 0x5be6(%rip), %rsi      # 0x10f18
je 0xb3ac
cmpq 0x5c85(%rip), %rsi      # 0x10fc0
je 0xb3e4
cmpq 0x5c18(%rip), %rsi      # 0x10f60
je 0xb415
movq %rsi, %r13
xorl %r12d, %r12d
testl %r15d, %r15d
cmovlel %r12d, %r15d
cmpq %r12, %r15
je 0xb3cb
movq (%rbx,%r12,8), %rsi
movq %r14, %rdi
callq 0x58c7
movq %rax, (%rbx,%r12,8)
incq %r12
jmp 0xb35b
xorl %r12d, %r12d
jmp 0xb389
movq (%rbx), %r12
jmp 0xb389
movq 0x8(%rbx), %r12
jmp 0xb389
movq 0x10(%rbx), %r12
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
movl %r15d, %esi
movq %rbx, %rdx
xorl %ecx, %ecx
jmp 0xb3b8
pushq $0x1
jmp 0xb3ae
pushq $0x2
popq %rcx
movq %r14, %rdi
movl %r15d, %esi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xb7a5
movl %r15d, %edi
movq %rbx, %rsi
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
testl %r15d, %r15d
je 0xb488
xorl %r13d, %r13d
testl %r15d, %r15d
movl $0x0, %ebp
cmovgl %r15d, %ebp
xorl %r12d, %r12d
cmpq %r13, %rbp
je 0xb441
movq (%rbx,%r13,8), %rdi
callq 0x41c0
addq %rax, %r12
incq %r13
jmp 0xb3ff
movq (%rbx), %rsi
movq 0x8(%rbx), %r12
testq %r12, %r12
je 0xb434
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movups %xmm1, 0x20(%r12)
movups %xmm0, 0x10(%r12)
movq %r14, %rdi
callq 0xb49e
jmp 0xb389
movq (%rbx), %rsi
incq %r12
movq %r14, %rdi
movq %r12, %rdx
callq 0xb723
movq %rax, %r12
movq %rax, (%rbx)
movslq %r15d, %r15
pushq $0x1
popq %r13
cmpq %r15, %r13
jge 0xb389
movq (%rbx,%r13,8), %rsi
movq %r12, %rdi
callq 0x4740
movq (%rbx,%r13,8), %rsi
movq %r14, %rdi
callq 0xb49e
incq %r13
movq (%rbx), %r12
jmp 0xb45f
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0xaf8f
movq %rax, %r12
movb $0x0, (%rax)
jmp 0xb389
// File: /workspace/github_c_makefile_star2_O2/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:
leaq 0x278(%rdi), %rax
cmpq %rsi, %rax
seta %cl
leaq 0x8278(%rdi), %rdx
cmpq %rsi, %rdx
setbe %dl
orb %cl, %dl
cmpb $0x1, %dl
jne 0xb4c7
movq %rsi, %rdi
jmp 0x4880
subq %rax, %rsi
shrq $0x6, %rsi
movb $0x0, 0x78(%rdi,%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0x2, %eax
je 0xb520
cmpl $0x1, %eax
je 0xb515
testl %eax, %eax
jne 0xb546
movq 0x10(%rbx), %rax
movq 0x30(%rbx), %rcx
movb (%rcx,%rax), %al
jmp 0xb553
movq 0x40(%rbx), %rdi
callq 0x4350
jmp 0xb553
movq 0x38(%rbx), %r14
testq %r14, %r14
je 0xb54a
movq %rbx, %rdi
callq 0xb6a0
testl %eax, %eax
je 0xb54a
movq 0x10(%rbx), %rax
movq 0x58(%rbx), %rcx
subq (%rcx), %rax
movb (%r14,%rax), %al
jmp 0xb553
xorl %eax, %eax
jmp 0xb553
movq 0x40(%rbx), %rdi
callq 0x4810
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
cmpl $0x2, (%rdi)
jne 0xb5b9
movq 0x38(%r14), %r15
testq %r15, %r15
je 0xb5b9
movq %r14, %rdi
callq 0xb6a0
testl %eax, %eax
jne 0xb5b9
movq %r15, %rdi
callq 0x41c0
leaq 0x2(%rax), %rsi
movq %r15, %rdi
callq 0x4610
movq %rax, %r15
movq %rax, 0x38(%r14)
movq %rax, %rdi
callq 0x41c0
movb $0x0, 0x1(%r15,%rax)
movq %r15, %rdi
callq 0x41c0
movb %bpl, (%r15,%rax)
movb %bpl, 0x68(%r14)
incq 0x10(%r14)
incq 0x20(%r14)
cmpb $0xa, %bpl
jne 0xb5d4
andq $0x0, 0x20(%r14)
incq 0x18(%r14)
testq %rbx, %rbx
je 0xb5f1
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0xaf8f
movq %rax, (%rbx)
movb %bpl, (%rax)
movq (%rbx), %rax
movb $0x0, 0x1(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl (%rdi), %eax
cmpl $0x2, %eax
je 0xb649
cmpl $0x1, %eax
je 0xb620
testl %eax, %eax
jne 0xb686
movq 0x10(%r14), %rax
movq 0x30(%r14), %rcx
movb (%rcx,%rax), %bl
jmp 0xb688
movq 0x40(%r14), %rdi
callq 0x4350
movl %eax, %ebx
movq 0x40(%r14), %rdi
callq 0x44b0
testl %eax, %eax
jne 0xb686
movq 0x40(%r14), %rdi
pushq $-0x1
popq %rsi
pushq $0x1
popq %rdx
callq 0x4600
jmp 0xb688
movq 0x38(%r14), %rbx
testq %rbx, %rbx
je 0xb66e
movq %r14, %rdi
callq 0xb6a0
testl %eax, %eax
je 0xb66e
movq 0x10(%r14), %rax
movq 0x58(%r14), %rcx
subq (%rcx), %rax
movb (%rbx,%rax), %bl
jmp 0xb688
movq 0x40(%r14), %rdi
callq 0x4810
movl %eax, %ebx
movq 0x40(%r14), %rdi
callq 0x44b0
testl %eax, %eax
je 0xb692
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movsbl %bl, %edi
movq 0x40(%r14), %rsi
callq 0x45d0
jmp 0xb688
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0x2, %eax
je 0xb6f4
cmpl $0x1, %eax
jne 0xb709
movq 0x40(%rbx), %rdi
pushq $-0x1
popq %rsi
pushq $0x1
popq %rdx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4600
movl %esi, %ebp
cmpq $0x0, 0x38(%rbx)
je 0xb710
movq %rbx, %rdi
callq 0xb6a0
testl %eax, %eax
je 0xb710
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movsbl %bpl, %edi
movq 0x40(%rbx), %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x45d0
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
leaq 0x278(%rdi), %rax
cmpq %rsi, %rax
seta %al
leaq 0x8278(%rdi), %rcx
cmpq %rsi, %rcx
setbe %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0xb75c
movq %rbx, %rdi
movq %rdx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x4610
cmpq $0x41, %rdx
jb 0xb79c
movq %rdi, %r14
movq %rdx, %rdi
callq 0x45a0
movq %rax, %r15
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups 0x20(%rbx), %xmm2
movups 0x30(%rbx), %xmm3
movups %xmm0, (%rax)
movups %xmm1, 0x10(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm3, 0x30(%rax)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xb49e
movq %r15, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movslq %edi, %r14
leaq 0x8(,%r14,8), %rdi
callq 0x45a0
xorl %ecx, %ecx
testl %r14d, %r14d
movl $0x0, %edx
cmovgl %r14d, %edx
cmpq %rcx, %rdx
je 0xbbf3
movq (%rbx,%rcx,8), %rsi
movq %rsi, (%rax,%rcx,8)
incq %rcx
jmp 0xbbe1
andq $0x0, (%rax,%r14,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq %rdi, %r15
movq (%r15), %r14
testq %r14, %r14
je 0xbc3b
movq (%r14), %rdi
callq 0x4880
movq 0x8(%r14), %rdi
callq 0x4880
movq 0x10(%r14), %rdi
callq 0x9d3b
movq %r14, %rdi
callq 0x4880
addq $0x8, %r15
jmp 0xbc0b
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x4880
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rdi, %r13
movq (%r13), %r15
testq %r15, %r15
je 0xbcce
movq (%r15), %rdi
movq %r14, %rsi
callq 0xb9f6
movq %rax, %r12
testb $0x1, 0x18(%r14)
je 0xbc85
movq 0x10(%r15), %rdi
callq 0x40d0
movq %rax, 0x10(%r15)
movq 0x8(%r15), %rsi
movq 0x10(%r15), %rdi
testq %rsi, %rsi
je 0xbc9e
callq 0x47f0
movq %rax, %rdi
movq %rax, 0x10(%r15)
callq 0x4530
movq 0x10(%r15), %rsi
movq %r12, %rdi
callq 0x40f0
movq (%r15), %rdi
callq 0x4880
movq 0x8(%r15), %rdi
callq 0x4880
movq %r15, %rdi
callq 0x4880
addq $0x8, %r13
jmp 0xbc5a
movq %rbx, %rdi
callq 0x4880
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/orangeduck[P]mpc/mpc.c
// Function: mpca_stmt_afold
static mpc_val_t *mpca_stmt_afold(int n, mpc_val_t **xs) {
  mpca_stmt_t *stmt = malloc(sizeof(mpca_stmt_t));
  stmt->ident = ((char**)xs)[0];
  stmt->name = ((char**)xs)[1];
  stmt->grammar = ((mpc_parser_t**)xs)[3];
  (void) n;
  free(((char**)xs)[2]);
  free(((char**)xs)[4]);

  return stmt;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
pushq $0x18
popq %rdi
callq 0x45a0
movq %rax, %r14
movups (%rbx), %xmm0
movups %xmm0, (%rax)
movq 0x18(%rbx), %rax
movq %rax, 0x10(%r14)
movq 0x10(%rbx), %rdi
callq 0x4880
movq 0x20(%rbx), %rdi
callq 0x4880
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/aap[P]rx-0/common/fe.c
// Function: panic
void
panic(char *fmt, ...)
{
	va_list ap;
	va_start(ap, fmt);
	vfprintf(stderr, fmt, ap);
	fprintf(stderr, "\n");
	va_end(ap);
	quit();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %r10
leaq -0xd0(%rbp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x2560
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
leaq -0x20(%rbp), %rdx
movq %rdi, 0x10(%rdx)
leaq 0x10(%rbp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rdx)
movq 0x5a74(%rip), %rbx      # 0x7ff8
movq (%rbx), %rdi
movq %r10, %rsi
callq 0x2300
movq (%rbx), %rsi
pushq $0xa
popq %rdi
callq 0x2160
callq 0x259f
// File: /workspace/github_c_makefile_star2_O2/aap[P]rx-0/common/fe.c
// Function: quit
void
quit(void)
{
	reset(0);
	putchar('\n');

	deinitmach();
	exit(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x2672
pushq $0xa
popq %rdi
callq 0x2050
callq 0x4754
xorl %edi, %edi
callq 0x2330
// File: /workspace/github_c_makefile_star2_O2/aap[P]rx-0/common/fe.c
// Function: raw
int
raw(int fd)
{
	struct termios tio;
	if(tcgetattr(fd, &tio) < 0) return -1;
	tiosaved = tio;
	cfmakeraw(&tio);
//	tio.c_iflag |= ICRNL;
	tio.c_oflag |= OPOST | ONLCR;
	if(tcsetattr(fd, TCSAFLUSH, &tio) < 0) return -1;
	canreset = 1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %edi, %r14d
leaq -0x54(%rbp), %rsi
callq 0x22b0
pushq $-0x1
popq %rbx
testl %eax, %eax
js 0x2665
leaq -0x54(%rbp), %r15
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups 0x20(%r15), %xmm2
movups 0x2c(%r15), %xmm3
movups %xmm3, 0xac47(%rip)     # 0xd26c
movups %xmm2, 0xac34(%rip)     # 0xd260
movups %xmm1, 0xac1d(%rip)     # 0xd250
movups %xmm0, 0xac06(%rip)     # 0xd240
movq %r15, %rdi
callq 0x2240
orb $0x5, 0x4(%r15)
pushq $0x2
popq %rsi
movl %r14d, %edi
movq %r15, %rdx
callq 0x22c0
testl %eax, %eax
js 0x2665
movl $0x1, 0xac19(%rip)      # 0xd27c
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/aap[P]rx-0/common/fe.c
// Function: tyo
void
tyo(char c)
{
	static char *alt = "◊";
	static char *ctrl = "↑";

	if(c < 040){
		switch(c){
		case ALT:
			write(1, alt, strlen(alt));
			return;
		case CTL('J'):
		case CTL('M'):
		case CTL('H'):
		case CTL('I'):
			write(1, &c, 1);
			break;
		default:
			write(1, ctrl, strlen(ctrl));
			c += 0100;
			write(1, &c, 1);
		}
	}else
		write(1, &c, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebx
movb %bl, -0x11(%rbp)
cmpb $0x1f, %bl
jg 0x2720
movsbl %bl, %eax
leal -0x8(%rax), %ecx
cmpl $0x3, %ecx
jb 0x2720
cmpl $0xd, %eax
je 0x2720
cmpl $0x1b, %eax
jne 0x2738
leaq 0x2a48(%rip), %rsi      # 0x5155
pushq $0x1
popq %rdi
pushq $0x3
popq %rdx
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x20d0
pushq $0x1
popq %rdi
leaq -0x11(%rbp), %rsi
pushq $0x1
popq %rdx
callq 0x20d0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x2a1a(%rip), %rsi      # 0x5159
pushq $0x1
popq %r14
pushq $0x3
popq %rdx
movl %r14d, %edi
callq 0x20d0
addb $0x40, %bl
leaq -0x11(%rbp), %rsi
movb %bl, (%rsi)
pushq $0x1
popq %rdx
movl %r14d, %edi
jmp 0x272a
// File: /workspace/github_c_makefile_star2_O2/aap[P]rx-0/common/fe.c
// Function: typenum
void
typenum(Word n)
{
	Word d;
	d = n % base;
	n /= base;
	if(n)
		typenum(n);
	tyo(d + '0');
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
movl 0x5ab9(%rip), %r14d     # 0x8228
cmpl %edi, %r14d
ja 0x2782
movl %ebx, %eax
xorl %edx, %edx
divl %r14d
movl %eax, %edi
callq 0x275f
movl %ebx, %eax
xorl %edx, %edx
divl %r14d
addb $0x30, %dl
movsbl %dl, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x26dc
// File: /workspace/github_c_makefile_star2_O2/aap[P]rx-0/common/fe.c
// Function: parsenum
Word
parsenum(void)
{
	Word w;
	char *c;

	w = 0;
	for(c = bufstart; c < &buf[nbuf]; c++){
		if(*c >= '0' && *c <= '9')
			w = w*base + *c-'0';
		else
			return BUF_ERR;
		w &= WORDMASK;
	}
	return w;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x5999(%rip), %rcx      # 0x8220
movslq 0xab96(%rip), %rax      # 0xd424
leaq 0xa9eb(%rip), %rdx      # 0xd280
addq %rax, %rdx
xorl %eax, %eax
movl 0x5988(%rip), %edi      # 0x8228
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
cmpq %rdx, %rcx
jae 0x28cf
movzbl (%rcx), %r8d
leal -0x30(%r8), %r9d
cmpb $0x9, %r9b
ja 0x28cd
imull %edi, %eax
addl %r8d, %eax
addl $0x3ffd0, %eax          # imm = 0x3FFD0
andl $0x3ffff, %eax          # imm = 0x3FFFF
incq %rcx
jmp 0x28a5
movl %esi, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/aap[P]rx-0/common/fe.c
// Function: defsym
void
defsym(char *sym, Word val)
{
	int i;
	for(i = 0; i < SYMTABSIZE; i++)
		if(symtab[i].sym[0] == '\0')
			goto found;
	err("?SYMTAB? ");
found:
	strncpy(symtab[i].sym, sym, 12);
	symtab[i].sym[11] = '\0';
	symtab[i].value = val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %rsi
xorl %r14d, %r14d
leaq 0x5946(%rip), %r15      # 0x8230
cmpq $0x5000, %r14           # imm = 0x5000
je 0x2922
cmpb $0x0, (%r14,%r15)
je 0x2900
addq $0x14, %r14
jmp 0x28ea
leaq (%r15,%r14), %rdi
pushq $0xc
popq %rdx
callq 0x2080
movb $0x0, 0xb(%r14,%r15)
movl %ebx, 0x10(%r14,%r15)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2834(%rip), %rdi      # 0x515d
callq 0x2801
// File: /workspace/github_c_makefile_star2_O2/aap[P]rx-0/common/fe.c
// Function: findsym
char*
findsym(Word val)
{
	int i;
	for(i = 0; i < SYMTABSIZE; i++)
		if(symtab[i].sym[0] &&
		   !(symtab[i].flags & SYM_HALFKILL) &&
		   symtab[i].value == val)
			return symtab[i].sym;
	return nil;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
leaq 0x58f5(%rip), %rcx      # 0x8230
xorl %edx, %edx
cmpq $0x5000, %rdx           # imm = 0x5000
je 0x2965
cmpb $0x0, (%rdx,%rcx)
je 0x2959
testb $0x1, 0xc(%rdx,%rcx)
jne 0x2959
cmpl %edi, 0x10(%rdx,%rcx)
je 0x295f
addq $0x14, %rdx
jmp 0x293d
addq %rdx, %rcx
movq %rcx, %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/aap[P]rx-0/common/fe.c
// Function: parsesym
Word
parsesym(void)
{
	Word i;

	if(strcmp(bufstart, ".") == 0)
		return dot;

	for(i = 0; i < SYMTABSIZE; i++)
		if(symtab[i].sym[0] && strcasecmp(bufstart, symtab[i].sym) == 0)
			return symtab[i].value;
	return BUF_ERR;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x58a7(%rip), %rbx      # 0x8220
cmpb $0x2e, (%rbx)
jne 0x2984
cmpb $0x0, 0x1(%rbx)
je 0x29bf
xorl %r15d, %r15d
pushq $-0x1
popq %r14
leaq 0x589e(%rip), %r12      # 0x8230
cmpq $0x5000, %r15           # imm = 0x5000
je 0x29c7
cmpb $0x0, (%r15,%r12)
je 0x29b2
leaq (%r12,%r15), %rsi
movq %rbx, %rdi
callq 0x2060
testl %eax, %eax
je 0x29b8
addq $0x14, %r15
jmp 0x2992
movl 0x10(%r15,%r12), %r14d
jmp 0x29c7
movzwl 0xaa61(%rip), %r14d     # 0xd428
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/aap[P]rx-0/common/fe.c
// Function: parse
int
parse(Word *t)
{
	Word w;

	w = parsenum();
	if(bufstart >= &buf[nbuf])
		return 0;
	if((w = parsenum()) == BUF_ERR && (w = parsesym()) == BUF_ERR)
		err("?U? ");
	nbuf = 0;
	*t = w;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x287c
movslq 0xaa3c(%rip), %rcx      # 0xd424
leaq 0xa891(%rip), %rdx      # 0xd280
addq %rcx, %rdx
xorl %ecx, %ecx
cmpq %rdx, 0x5825(%rip)      # 0x8220
jae 0x2a18
cmpl $-0x1, %eax
jne 0x2a0c
callq 0x2967
cmpl $-0x1, %eax
je 0x2a21
andl $0x0, 0xaa11(%rip)      # 0xd424
movl %eax, (%rbx)
pushq $0x1
popq %rcx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x273f(%rip), %rdi      # 0x5167
callq 0x2801
// File: /workspace/github_c_makefile_star2_O2/aap[P]rx-0/common/fe.c
// Function: combine
void
combine(Word t)
{
	switch(as.op){
	case '+':
	default:
		as.exp += t;
		break;
	case '-':
		as.exp += ~t;
		break;
	case '*':
		as.exp *= t;
		break;
	case '|':
		as.exp /= t;
		break;
	}
	as.gotexp = 1;
	as.op = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0xa9e4(%rip), %eax      # 0xd430
cmpl $0x2a, %eax
je 0x2a73
cmpl $0x2d, %eax
je 0x2a69
cmpl $0x7c, %eax
jne 0x2a6b
movl 0xa9cb(%rip), %eax      # 0xd42c
xorl %edx, %edx
divl %edi
movl %eax, %edi
jmp 0x2a7a
notl %edi
addl 0xa9bb(%rip), %edi      # 0xd42c
jmp 0x2a7a
imull 0xa9b2(%rip), %edi      # 0xd42c
movl %edi, 0xa9ac(%rip)      # 0xd42c
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rax, 0xa99f(%rip)      # 0xd430
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/aap[P]rx-0/common/fe.c
// Function: endword
int
endword(Word *w)
{
	Word t;

	if(!parse(&t)){
		if(!as.gotexp)
			return 0;
		t = 0;
	}
	combine(t);
	t = as.exp;
	t &= WORDMASK;
	*w = t;
	resetexp();
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq -0xc(%rbp), %rdi
callq 0x29d3
testl %eax, %eax
je 0x2aae
movl -0xc(%rbp), %eax
jmp 0x2ab9
xorl %eax, %eax
cmpl $0x0, 0xa97d(%rip)      # 0xd434
je 0x2adf
movl %eax, %edi
callq 0x2a42
movl $0x3ffff, %eax          # imm = 0x3FFFF
andl 0xa961(%rip), %eax      # 0xd42c
movl %eax, (%rbx)
andq $0x0, 0xa957(%rip)      # 0xd42c
andl $0x0, 0xa958(%rip)      # 0xd434
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/aap[P]rx-0/common/fe.c
// Function: symaddr
char*
symaddr(Addr a)
{
	static char s[100];
	char *p, *sym;
	p = s;
	memset(s, 0, 100);
	sym = a == 0 ? nil : findsym(a);
	if(sym)
		p += sprintf(p, "%s", sym);
	else
		p += sprintf(p, "%o", a);
	return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
xorps %xmm0, %xmm0
movaps %xmm0, 0xa977(%rip)     # 0xd490
movaps %xmm0, 0xa960(%rip)     # 0xd480
movaps %xmm0, 0xa949(%rip)     # 0xd470
movaps %xmm0, 0xa932(%rip)     # 0xd460
movaps %xmm0, 0xa91b(%rip)     # 0xd450
movaps %xmm0, 0xa904(%rip)     # 0xd440
andl $0x0, 0xa95d(%rip)      # 0xd4a0
testl %edi, %edi
je 0x2b66
movl %ebx, %edi
callq 0x292e
testq %rax, %rax
je 0x2b66
leaq 0xa8e6(%rip), %rdi      # 0xd440
movq %rax, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x2090
leaq 0xa8d3(%rip), %r14      # 0xd440
leaq 0x272b(%rip), %rsi      # 0x529f
movq %r14, %rdi
movl %ebx, %edx
xorl %eax, %eax
callq 0x2320
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/aap[P]rx-0/common/fe.c
// Function: aclose
void
aclose(int ins)
{
	// this is a bit ugly...
	// we don't want ^M to set Q if no location is open
	Word t;
	t = q;
	if(endword(&q) && ins){
		if(opened)
			deposit(addr, q);
		else if(regopened)
			depositreg(addr, q);
	}
	addr = q & ADDRMASK;
	if(!opened && !regopened)
		q = t;
	opened = 0;
	regopened = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
movl 0xa899(%rip), %r14d     # 0xd4a4
leaq 0xa892(%rip), %rdi      # 0xd4a4
callq 0x2a93
testl %ebx, %ebx
je 0x2c57
testl %eax, %eax
je 0x2c57
cmpl $0x0, 0xa886(%rip)      # 0xd4ac
je 0x2c3c
movzwl 0xa881(%rip), %edi      # 0xd4b0
movl 0xa86f(%rip), %esi      # 0xd4a4
callq 0x3d64
jmp 0x2c57
cmpl $0x0, 0xa871(%rip)      # 0xd4b4
je 0x2c57
movzwl 0xa864(%rip), %edi      # 0xd4b0
movl 0xa852(%rip), %esi      # 0xd4a4
callq 0x3d8a
movzwl 0xa846(%rip), %eax      # 0xd4a4
movw %ax, 0xa84b(%rip)       # 0xd4b0
movl 0xa849(%rip), %eax      # 0xd4b4
orl 0xa83b(%rip), %eax      # 0xd4ac
jne 0x2c7a
movl %r14d, 0xa82a(%rip)     # 0xd4a4
andl $0x0, 0xa82b(%rip)      # 0xd4ac
andl $0x0, 0xa82c(%rip)      # 0xd4b4
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/aap[P]rx-0/common/fe.c
// Function: aopen
void
aopen(int mode)
{
	opened = 1;
	q = examine(addr);
	typestr("   ");
	if(mode != MODE_NONE)
		typeout(mode);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
movl $0x1, 0xa80d(%rip)      # 0xd4ac
movzwl 0xa80a(%rip), %edi      # 0xd4b0
callq 0x3d77
movl %eax, 0xa7f3(%rip)      # 0xd4a4
leaq 0x24c0(%rip), %rdi      # 0x5178
callq 0x2798
testl %ebx, %ebx
je 0x2cce
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2bae
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/aap[P]rx-0/common/fe.c
// Function: aropen
void
aropen(int mode)
{
	regopened = 1;
	q = examinereg(addr);
	typestr("   ");
	if(mode != MODE_NONE)
		typeout(mode);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
movl $0x1, 0xa7cd(%rip)      # 0xd4b4
movzwl 0xa7c2(%rip), %edi      # 0xd4b0
callq 0x3dc3
movl %eax, 0xa7ab(%rip)      # 0xd4a4
leaq 0x2478(%rip), %rdi      # 0x5178
callq 0x2798
testl %ebx, %ebx
je 0x2d16
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2bae
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/aap[P]rx-0/common/util.c
// Function: serve1
int
serve1(int port)
{
	int sockfd, confd;
	socklen_t len;
	struct sockaddr_in server, client;
	int x;

	sockfd = socket(AF_INET, SOCK_STREAM, 0);
	if(sockfd < 0){
		perror("error: socket");
		return -1;
	}

	x = 1;
	setsockopt (sockfd, SOL_SOCKET, SO_REUSEADDR, (void *)&x, sizeof x);
	
	memset(&server, 0, sizeof(server));
	server.sin_family = AF_INET;
	server.sin_addr.s_addr = INADDR_ANY;
	server.sin_port = htons(port);
	if(bind(sockfd, (struct sockaddr*)&server, sizeof(server)) < 0){
		perror("error: bind");
		return -1;
	}
	listen(sockfd, 5);
	len = sizeof(client);
	while(confd = accept(sockfd, (struct sockaddr*)&client, &len),
	      confd >= 0)
		return confd;
	perror("error: accept");
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl %edi, %r14d
pushq $0x2
popq %rdi
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x2400
testl %eax, %eax
js 0x364c
movl %eax, %ebx
leaq -0x14(%rbp), %rcx
movl $0x1, (%rcx)
pushq $0x1
popq %rsi
pushq $0x2
popq %rdx
pushq $0x4
popq %r8
movl %eax, %edi
callq 0x20c0
leaq -0x38(%rbp), %rsi
andq $0x0, 0x8(%rsi)
movw $0x2, (%rsi)
andl $0x0, 0x4(%rsi)
rolw $0x8, %r14w
movw %r14w, 0x2(%rsi)
pushq $0x10
popq %rdx
movl %ebx, %edi
callq 0x2260
testl %eax, %eax
js 0x3655
pushq $0x5
popq %rsi
movl %ebx, %edi
callq 0x2220
leaq -0x18(%rbp), %rdx
movl $0x10, (%rdx)
leaq -0x28(%rbp), %rsi
movl %ebx, %edi
callq 0x2310
testl %eax, %eax
js 0x365e
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1b54(%rip), %rdi      # 0x51a7
jmp 0x3665
leaq 0x1b59(%rip), %rdi      # 0x51b5
jmp 0x3665
leaq 0x1b5c(%rip), %rdi      # 0x51c1
callq 0x22f0
pushq $-0x1
popq %rax
jmp 0x3643
// File: /workspace/github_c_makefile_star2_O2/aap[P]rx-0/common/threading.c
// Function: lock
void
lock(Lock *lk)
{
	if(!lk->init)
		lockinit(lk);
	if(pthread_mutex_lock(&lk->mutex) != 0)
		abort();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, (%rdi)
jne 0x36ae
movq %rbx, %rdi
callq 0x36ca
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x23b0
testl %eax, %eax
jne 0x36c5
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x2070
// File: /workspace/github_c_makefile_star2_O2/aap[P]rx-0/common/threading.c
// Function: lockinit
static void
lockinit(Lock *lk)
{
	pthread_mutexattr_t attr;

	pthread_mutex_lock(&initmutex);
	if(lk->init == 0){
		pthread_mutexattr_init(&attr);
		pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_NORMAL);
		pthread_mutex_init(&lk->mutex, &attr);
		pthread_mutexattr_destroy(&attr);
		lk->init = 1;
	}
	pthread_mutex_unlock(&initmutex);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x9e99(%rip), %rdi      # 0xd578
callq 0x23b0
cmpl $0x0, (%rbx)
jne 0x3719
leaq -0x14(%rbp), %r14
movq %r14, %rdi
callq 0x2350
movq %r14, %rdi
xorl %esi, %esi
callq 0x2110
leaq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x2390
movq %r14, %rdi
callq 0x23a0
movl $0x1, (%rbx)
leaq 0x9e58(%rip), %rdi      # 0xd578
callq 0x21f0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/aap[P]rx-0/common/threading.c
// Function: canlock
int
canlock(Lock *lk)
{
	int r;

	if(!lk->init)
		lockinit(lk);
	r = pthread_mutex_trylock(&lk->mutex);
	if(r == 0)
		return 1;
	if(r == EBUSY)
		return 0;
	abort();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, (%rdi)
jne 0x3744
movq %rbx, %rdi
callq 0x36ca
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x2170
testl %eax, %eax
je 0x375d
cmpl $0x10, %eax
jne 0x3767
xorl %eax, %eax
jmp 0x3760
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x2070
// File: /workspace/github_c_makefile_star2_O2/aap[P]rx-0/common/threading.c
// Function: rsleep
void
rsleep(Rendez *r)
{
	if(!r->init)
		rendinit(r);
	if(pthread_cond_wait(&r->cond, &r->l->mutex) != 0)
		abort();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpl $0x0, (%rdi)
jne 0x37da
leaq 0x9dda(%rip), %rdi      # 0xd578
callq 0x23b0
cmpl $0x0, (%rbx)
jne 0x37ce
leaq -0x14(%rbp), %r14
movq %r14, %rdi
callq 0x2250
leaq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x21e0
movq %r14, %rdi
callq 0x2140
movl $0x1, (%rbx)
leaq 0x9da3(%rip), %rdi      # 0xd578
callq 0x21f0
movq 0x8(%rbx), %rsi
addq $0x10, %rbx
addq $0x8, %rsi
movq %rbx, %rdi
callq 0x20e0
testl %eax, %eax
jne 0x37fb
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x2070
// File: /workspace/github_c_makefile_star2_O2/aap[P]rx-0/common/threading.c
// Function: threadcreate
int
threadcreate(void *(*f)(void*), void *arg)
{
	struct ThreadArg *args;
	int id;

	lock(&idlock);
	id = addthreadid();
	args = malloc(sizeof(*args));
	args->id = id;
	args->f = f;
	args->arg = arg;
	pthread_create(&threads[id], nil, trampoline, args);
	unlock(&idlock);
	return id;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x9ce6(%rip), %rbx      # 0xd538
movq %rbx, %rdi
callq 0x3698
callq 0x38ac
movl %eax, %r12d
pushq $0x18
popq %rdi
callq 0x2210
movl %r12d, (%rax)
movq %r15, 0x8(%rax)
movq %r14, 0x10(%rax)
movslq %r12d, %r14
leaq (,%r14,8), %rdi
addq 0x9ce1(%rip), %rdi      # 0xd568
leaq 0x75(%rip), %rdx        # 0x3903
xorl %esi, %esi
movq %rax, %rcx
callq 0x2270
movq %rbx, %rdi
callq 0x376c
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/aap[P]rx-0/common/threading.c
// Function: addthreadid
static int
addthreadid(void)
{
	int id;

	if(numthreads >= maxthreads){
		maxthreads += 64;
		threads = realloc(threads, maxthreads*sizeof(*threads));
	}
	id = numthreads++;
	threads[id] = 0;
	return id;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movslq 0x9cb7(%rip), %rbx      # 0xd570
movslq 0x9ce0(%rip), %rcx      # 0xd5a0
movq 0x9ca1(%rip), %rax      # 0xd568
cmpl %ecx, %ebx
jl 0x38ec
leaq 0x40(%rcx), %rdx
movl %edx, 0x9ccb(%rip)      # 0xd5a0
leaq 0x200(,%rcx,8), %rsi
movq %rax, %rdi
callq 0x2230
movq %rax, 0x9c7c(%rip)      # 0xd568
leal 0x1(%rbx), %ecx
movl %ecx, 0x9c7b(%rip)      # 0xd570
andq $0x0, (%rax,%rbx,8)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/aap[P]rx-0/common/threading.c
// Function: gethandle
static pthread_t
gethandle(int id)
{
	pthread_t th;
	lock(&idlock);
	th = threads[id];
	unlock(&idlock);
	return th;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
leaq 0x9b91(%rip), %r14      # 0xd538
movq %r14, %rdi
callq 0x3698
movq 0x9bb2(%rip), %rax      # 0xd568
movslq %ebx, %rcx
movq (%rax,%rcx,8), %rbx
movq %r14, %rdi
callq 0x376c
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq