LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/mattn[P]orelang/mpc.c
// Function: mpcf_re_escape
static mpc_val_t *mpcf_re_escape(mpc_val_t *x) {
  
  char *s = x;
  mpc_parser_t *p;
  
  /* Regex Special Characters */
  if (s[0] == '.') { free(s); return mpc_any(); }
  if (s[0] == '^') { free(s); return mpc_and(2, mpcf_snd, mpc_soi(), mpc_lift(mpcf_ctor_str), free); }
  if (s[0] == '$') { free(s); return mpc_and(2, mpcf_snd, mpc_eoi(), mpc_lift(mpcf_ctor_str), free); }
  
  /* Regex Escape */
  if (s[0] == '\\') {
    p = mpc_re_escape_char(s[1]);
    p = (p == NULL) ? mpc_char(s[1]) : p;
    free(s);
    return p;
  }
  
  /* Regex Standard */
  p = mpc_char(s[0]);
  free(s);
  return p;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movzbl (%rdi), %eax
cmpl $0x24, %eax
je 0x544e
cmpl $0x5e, %eax
je 0x5413
cmpl $0x5c, %eax
je 0x5429
cmpl $0x2e, %eax
jne 0x5492
movq %rbx, %rdi
callq 0x22c0
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3f95
movq %rbx, %rdi
callq 0x22c0
movq 0x12b8e(%rip), %rbx     # 0x17fb0
callq 0x44a2
jmp 0x5462
movb 0x1(%rbx), %al
movzbl %al, %ecx
leal -0x61(%rcx), %edx
cmpl $0x16, %edx
ja 0x549a
leaq 0xad1a(%rip), %rcx      # 0x10158
movslq (%rcx,%rdx,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
pushq $0x7
jmp 0x54fb
movq %rbx, %rdi
callq 0x22c0
movq 0x12b53(%rip), %rbx     # 0x17fb0
callq 0x44c8
movq %rax, %r14
leaq -0x9a2(%rip), %rdi      # 0x4aca
callq 0x3e31
leaq -0x75e(%rip), %rsi      # 0x4d1a
pushq $0x2
popq %rdi
movq %r14, %rdx
movq %rax, %rcx
movq %rbx, %r8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x434a
movsbl %al, %edi
jmp 0x5575
cmpl $0x41, %ecx
je 0x5518
cmpl $0x42, %ecx
je 0x554c
cmpl $0x44, %ecx
je 0x5511
cmpl $0x53, %ecx
je 0x5503
cmpl $0x57, %ecx
je 0x550a
cmpl $0x5a, %ecx
jne 0x5572
callq 0x44c8
jmp 0x551d
callq 0x458a
jmp 0x5567
pushq $0xc
jmp 0x54fb
pushq $0x9
jmp 0x54fb
callq 0x46e4
jmp 0x5567
callq 0x481a
jmp 0x5567
pushq $0xd
jmp 0x54fb
pushq $0xa
jmp 0x54fb
callq 0x44ee
jmp 0x551d
pushq $0xb
popq %rdi
callq 0x3faf
jmp 0x5567
callq 0x458a
jmp 0x5551
callq 0x481a
jmp 0x5551
callq 0x46e4
jmp 0x5551
callq 0x44a2
movq %rax, %r14
leaq -0xa5d(%rip), %rdi      # 0x4aca
callq 0x3e31
leaq -0x819(%rip), %rsi      # 0x4d1a
movq 0x12a76(%rip), %r8      # 0x17fb0
pushq $0x2
popq %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x434a
jmp 0x5567
callq 0x44ee
movq 0x12a58(%rip), %rsi     # 0x17fb0
leaq -0xa95(%rip), %rdx      # 0x4aca
movq %rax, %rdi
callq 0x4173
movq %rax, %r14
testq %rax, %rax
jne 0x557d
movb 0x1(%rbx), %al
movsbl %al, %edi
callq 0x3faf
movq %rax, %r14
movq %rbx, %rdi
callq 0x22c0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/mattn[P]orelang/mpc.c
// Function: mpcf_strtriml
mpc_val_t *mpcf_strtriml(mpc_val_t *x) {
  char *s = x;
  while (isspace(*s)) {
    memmove(s, s+1, strlen(s));
  }
  return s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x22b0
movq %rax, %r14
leaq 0x1(%rbx), %r15
movq (%r14), %rax
movsbq (%rbx), %rcx
testb $0x20, 0x1(%rax,%rcx,2)
je 0x581c
movq %rbx, %rdi
callq 0x20c0
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x21f0
jmp 0x57f6
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/mattn[P]orelang/mpc.c
// Function: mpcf_strtrimr
mpc_val_t *mpcf_strtrimr(mpc_val_t *x) {
  char *s = x;
  size_t l = strlen(s);
  while (isspace(s[l-1])) {
    s[l-1] = '\0'; l--;
  }
  return s;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x20c0
movq %rax, %r14
callq 0x22b0
leaq (%r14,%rbx), %rcx
decq %rcx
movq (%rax), %rdx
movsbq (%rcx), %rsi
testb $0x20, 0x1(%rdx,%rsi,2)
je 0x5856
movb $0x0, (%rcx)
decq %rcx
jmp 0x5840
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/mattn[P]orelang/mpc.c
// Function: mpcf_maths
mpc_val_t *mpcf_maths(int n, mpc_val_t **xs) {
  int **vs = (int**)xs;
  (void) n;
  
  if (strcmp(xs[1], "*") == 0) { *vs[0] *= *vs[2]; }
  if (strcmp(xs[1], "/") == 0) { *vs[0] /= *vs[2]; }
  if (strcmp(xs[1], "%") == 0) { *vs[0] %= *vs[2]; }
  if (strcmp(xs[1], "+") == 0) { *vs[0] += *vs[2]; }
  if (strcmp(xs[1], "-") == 0) { *vs[0] -= *vs[2]; }
  
  free(xs[1]); free(xs[2]);
  
  return xs[0];
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movq 0x8(%rsi), %rdi
movb (%rdi), %al
cmpb $0x2a, %al
jne 0x5bfd
cmpb $0x0, 0x1(%rdi)
jne 0x5c5d
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
movl (%rax), %edx
imull (%rcx), %edx
movl %edx, (%rax)
movb (%rdi), %al
cmpb $0x2f, %al
jne 0x5c17
cmpb $0x0, 0x1(%rdi)
jne 0x5c5d
movq (%rbx), %rcx
movq 0x10(%rbx), %rsi
movl (%rcx), %eax
cltd
idivl (%rsi)
movl %eax, (%rcx)
movb (%rdi), %al
cmpb $0x25, %al
jne 0x5c31
cmpb $0x0, 0x1(%rdi)
jne 0x5c5d
movq (%rbx), %rcx
movq 0x10(%rbx), %rsi
movl (%rcx), %eax
cltd
idivl (%rsi)
movl %edx, (%rcx)
movb (%rdi), %al
cmpb $0x2b, %al
jne 0x5c48
cmpb $0x0, 0x1(%rdi)
jne 0x5c5d
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
movl (%rcx), %ecx
addl %ecx, (%rax)
movb (%rdi), %al
cmpb $0x2d, %al
jne 0x5c5d
cmpb $0x0, 0x1(%rdi)
jne 0x5c5d
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
movl (%rcx), %ecx
subl %ecx, (%rax)
callq 0x22c0
movq 0x10(%rbx), %rdi
callq 0x22c0
movq (%rbx), %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/mattn[P]orelang/mpc.c
// Function: mpcf_fold_ast
mpc_val_t *mpcf_fold_ast(int n, mpc_val_t **xs) {
  
  int i, j;
  mpc_ast_t** as = (mpc_ast_t**)xs;
  mpc_ast_t *r;
  
  if (n == 0) { return NULL; }
  if (n == 1) { return xs[0]; }
  if (n == 2 && xs[1] == NULL) { return xs[0]; }
  if (n == 2 && xs[0] == NULL) { return xs[1]; }
  
  r = mpc_ast_new(">", "");
  
  for (i = 0; i < n; i++) {
    
    if (as[i] == NULL) { continue; }
    
    if (as[i] && as[i]->children_num > 0) {
      
      for (j = 0; j < as[i]->children_num; j++) {
        mpc_ast_add_child(r, as[i]->children[j]);
      }
      
      mpc_ast_delete_no_children(as[i]);
      
    } else if (as[i] && as[i]->children_num == 0) {
      mpc_ast_add_child(r, as[i]);
    }
  
  }
  
  if (r->children_num) {
    r->state = r->children[0]->state;
  }
  
  return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testl %edi, %edi
je 0x67ae
movq %rsi, %r14
movl %edi, %r15d
cmpl $0x2, %edi
je 0x66e3
cmpl $0x1, %r15d
jne 0x66fc
movq (%r14), %rbx
jmp 0x67b5
movq (%r14), %rax
movq 0x8(%r14), %rbx
testq %rbx, %rbx
je 0x67b2
testq %rax, %rax
je 0x67b5
leaq 0xa008(%rip), %rdi      # 0x1070b
leaq 0x9fbe(%rip), %rsi      # 0x106c8
callq 0x61f1
movq %rax, %rbx
xorl %r13d, %r13d
testl %r15d, %r15d
cmovlel %r13d, %r15d
cmpq %r15, %r13
je 0x678f
movq (%r14,%r13,8), %r12
testq %r12, %r12
je 0x678a
movl 0x28(%r12), %eax
testl %eax, %eax
jle 0x677d
xorl %ebp, %ebp
cltq
movq 0x30(%r12), %rdi
cmpq %rax, %rbp
jge 0x675b
movq (%rdi,%rbp,8), %rsi
movq %rbx, %rdi
callq 0x6348
incq %rbp
movq (%r14,%r13,8), %r12
movl 0x28(%r12), %eax
jmp 0x6735
callq 0x22c0
movq (%r12), %rdi
callq 0x22c0
movq 0x8(%r12), %rdi
callq 0x22c0
movq %r12, %rdi
callq 0x22c0
jmp 0x678a
jne 0x678a
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6348
incq %r13
jmp 0x671c
cmpl $0x0, 0x28(%rbx)
je 0x67b5
movq 0x30(%rbx), %rax
movq (%rax), %rax
movups 0x10(%rax), %xmm0
movups %xmm0, 0x10(%rbx)
movq 0x20(%rax), %rax
movq %rax, 0x20(%rbx)
jmp 0x67b5
xorl %ebx, %ebx
jmp 0x67b5
movq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mattn[P]orelang/mpc.c
// Function: mpcaf_grammar_repeat
static mpc_val_t *mpcaf_grammar_repeat(int n, mpc_val_t **xs) { 
  int num;
  (void) n;
  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
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x8(%rsi), %rdi
testq %rdi, %rdi
je 0x6f20
movzbl (%rdi), %eax
cmpl $0x21, %eax
je 0x6f5c
cmpl $0x3f, %eax
je 0x6f2a
cmpl $0x2b, %eax
je 0x6f43
cmpl $0x2a, %eax
jne 0x6f62
cmpb $0x0, 0x1(%rdi)
jne 0x6f62
callq 0x22c0
movq (%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x687c
movq (%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
cmpb $0x0, 0x1(%rdi)
jne 0x6f62
callq 0x22c0
movq (%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x41ce
cmpb $0x0, 0x1(%rdi)
jne 0x6f62
callq 0x22c0
movq (%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x688b
cmpb $0x0, 0x1(%rdi)
je 0x6f79
movl (%rdi), %ebp
callq 0x22c0
movq (%rbx), %rsi
movl %ebp, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x689a
callq 0x22c0
movq (%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x686b
// File: /workspace/github_c_makefile_star2_O2/mattn[P]orelang/mpc.c
// Function: mpcaf_grammar_regex
static mpc_val_t *mpcaf_grammar_regex(mpc_val_t *x, void *s) {
  mpca_grammar_st_t *st = s;
  char *y = mpcf_unescape_regex(x);
  mpc_parser_t *p = (st->flags & MPCA_LANG_WHITESPACE_SENSITIVE) ? mpc_re(y) : mpc_tok(mpc_re(y));
  free(y);
  return mpca_state(mpca_tag(mpc_apply(p, mpcf_str_ast), "regex"));
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
callq 0x5a96
movq %rax, %rbx
movb 0x18(%r14), %bpl
movq %rax, %rdi
callq 0x4f7c
movq %rax, %r14
testb $0x2, %bpl
jne 0x707d
movq %r14, %rdi
callq 0x4e30
movq %rax, %r14
movq %rbx, %rdi
callq 0x22c0
leaq -0x8c5(%rip), %rsi      # 0x67c7
movq %r14, %rdi
callq 0x4114
leaq 0x9462(%rip), %rsi      # 0x104fd
movq %rax, %rdi
callq 0x6841
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x6819
// File: /workspace/github_c_makefile_star2_O2/mattn[P]orelang/mpc.c
// Function: mpc_nodecount_unretained
static int mpc_nodecount_unretained(mpc_parser_t* p, int force) {

  int i, total;

  if (p->retained && !force) { return 0; }

  if (p->type == MPC_TYPE_EXPECT) { return 1 + mpc_nodecount_unretained(p->data.expect.x, 0); }

  if (p->type == MPC_TYPE_APPLY)    { return 1 + mpc_nodecount_unretained(p->data.apply.x, 0); }
  if (p->type == MPC_TYPE_APPLY_TO) { return 1 + mpc_nodecount_unretained(p->data.apply_to.x, 0); }
  if (p->type == MPC_TYPE_PREDICT)  { return 1 + mpc_nodecount_unretained(p->data.predict.x, 0); }

  if (p->type == MPC_TYPE_NOT)   { return 1 + mpc_nodecount_unretained(p->data.not.x, 0); }
  if (p->type == MPC_TYPE_MAYBE) { return 1 + mpc_nodecount_unretained(p->data.not.x, 0); }

  if (p->type == MPC_TYPE_MANY)  { return 1 + mpc_nodecount_unretained(p->data.repeat.x, 0); }
  if (p->type == MPC_TYPE_MANY1) { return 1 + mpc_nodecount_unretained(p->data.repeat.x, 0); }
  if (p->type == MPC_TYPE_COUNT) { return 1 + mpc_nodecount_unretained(p->data.repeat.x, 0); }

  if (p->type == MPC_TYPE_OR) { 
    total = 0;
    for(i = 0; i < p->data.or.n; i++) {
      total += mpc_nodecount_unretained(p->data.or.xs[i], 0);
    }
    return total;
  }
  
  if (p->type == MPC_TYPE_AND) {
    total = 0;
    for(i = 0; i < p->data.and.n; i++) {
      total += mpc_nodecount_unretained(p->data.and.xs[i], 0);
    }
    return total;
  }

  return 1;
  
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r14
xorl %r15d, %r15d
pushq $0x1
popq %rbx
leaq 0x888a(%rip), %rax      # 0x10210
testl %esi, %esi
setne %cl
testb $0x1, %cl
jne 0x7996
cmpb $0x0, (%r14)
jne 0x79db
movzbl 0x10(%r14), %ecx
addl $-0x5, %ecx
cmpl $0x13, %ecx
ja 0x79dd
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq 0x18(%r14), %r14
incl %r15d
xorl %ecx, %ecx
jmp 0x798b
movq 0x18(%r14), %r14
incl %r15d
xorl %esi, %esi
jmp 0x7986
movq 0x18(%r14), %rdi
jmp 0x79cc
movq 0x28(%r14), %rdi
xorl %esi, %esi
callq 0x796d
leal (%rax,%r15), %ebx
incl %ebx
jmp 0x79e0
xorl %ebx, %ebx
addl %r15d, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl 0x18(%r14), %r12d
xorl %r13d, %r13d
testl %r12d, %r12d
cmovlel %r13d, %r12d
xorl %ebx, %ebx
cmpq %r13, %r12
je 0x79dd
movq 0x20(%r14), %rax
movq (%rax,%r13,8), %rdi
xorl %esi, %esi
callq 0x796d
addl %eax, %ebx
incq %r13
jmp 0x79fc
movl 0x18(%r14), %r12d
xorl %r13d, %r13d
testl %r12d, %r12d
cmovlel %r13d, %r12d
xorl %ebx, %ebx
cmpq %r13, %r12
je 0x79dd
movq 0x28(%r14), %rax
movq (%rax,%r13,8), %rdi
xorl %esi, %esi
callq 0x796d
addl %eax, %ebx
incq %r13
jmp 0x7a27
// File: /workspace/github_c_makefile_star2_O2/mattn[P]orelang/mpc.c
// Function: mpc_input_unmark
static void mpc_input_unmark(mpc_input_t *i) {
  
  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) {
    free(i->buffer);
    i->buffer = NULL;
  }
  
}

// Assembly:
cmpl $0x0, 0x44(%rdi)
jle 0x82db
pushq %rbx
movq %rdi, %rbx
movl 0x48(%rdi), %edi
movl 0x4c(%rbx), %esi
leal -0x1(%rsi), %ecx
movl %ecx, 0x4c(%rbx)
pushq $0x2
popq %r8
movl %ecx, %eax
cltd
idivl %r8d
cmpl $0x21, %edi
jl 0x82c1
addl %esi, %eax
decl %eax
cmpl %eax, %edi
jle 0x82c1
cmpl $0x22, %esi
pushq $0x20
popq %rax
cmovgel %ecx, %eax
movl %eax, 0x48(%rbx)
movq 0x50(%rbx), %rdi
imulq $0x18, %rax, %rsi
callq 0x21e0
movq %rax, 0x50(%rbx)
movq 0x58(%rbx), %rdi
movslq 0x48(%rbx), %rsi
callq 0x21e0
movq %rax, 0x58(%rbx)
cmpl $0x2, (%rbx)
jne 0x82da
cmpl $0x0, 0x4c(%rbx)
jne 0x82da
movq 0x30(%rbx), %rdi
callq 0x22c0
andq $0x0, 0x30(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/mattn[P]orelang/mpc.c
// Function: mpc_input_terminated
static int mpc_input_terminated(mpc_input_t *i) {
  if (i->type == MPC_INPUT_STRING && i->state.pos == (long)strlen(i->string)) { return 1; }
  if (i->type == MPC_INPUT_FILE && feof(i->file)) { return 1; }
  if (i->type == MPC_INPUT_PIPE && feof(i->file)) { return 1; }
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0x1, %eax
je 0x8613
testl %eax, %eax
jne 0x8622
movq 0x10(%rbx), %r14
movq 0x28(%rbx), %rdi
callq 0x20c0
cmpq %rax, %r14
je 0x8634
jmp 0x8639
movq 0x38(%rbx), %rdi
callq 0x2170
testl %eax, %eax
jne 0x8634
movl (%rbx), %eax
cmpl $0x2, %eax
jne 0x8639
movq 0x38(%rbx), %rdi
callq 0x2170
testl %eax, %eax
je 0x8639
pushq $0x1
popq %rax
jmp 0x863b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/mattn[P]orelang/slre.c
// Function: doh
static int doh(const char *s, int s_len, struct regex_info *info, int bi) {
  const struct bracket_pair *b = &info->brackets[bi];
  int i = 0, len, result;
  const char *p;

  do {
    p = i == 0 ? b->ptr : info->branches[b->branches + i - 1].schlong + 1;
    len = b->num_branches == 0 ? b->len :
      i == b->num_branches ? (int) (b->ptr + b->len - p) :
      (int) (info->branches[b->branches + i].schlong - p);
    DBG(("%s %d %d [%.*s] [%.*s]\n", __func__, bi, i, len, p, s_len, s));
    result = bar(p, len, s, s_len, info, bi);
    DBG(("%s <- %d\n", __func__, result));
  } while (result <= 0 && i++ < b->num_branches);  /* At least 1 iteration */

  return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movslq %ecx, %rax
imulq $0x18, %rax, %r12
addq %rdx, %r12
leaq 0x968(%rdx), %rax
movq %rax, (%rsp)
xorl %r13d, %r13d
testl %r13d, %r13d
je 0x98db
movl 0xc(%r12), %eax
addl %r13d, %eax
decl %eax
cltq
shlq $0x4, %rax
movq (%rsp), %rcx
movq 0x8(%rcx,%rax), %rdi
incq %rdi
jmp 0x98df
movq (%r12), %rdi
movl 0x10(%r12), %eax
testl %eax, %eax
je 0x98f8
cmpl %eax, %r13d
jne 0x98ff
movl (%r12), %esi
addl 0x8(%r12), %esi
jmp 0x9913
movl 0x8(%r12), %esi
jmp 0x9915
movslq 0xc(%r12), %rax
addq %r13, %rax
shlq $0x4, %rax
movq (%rsp), %rcx
movl 0x8(%rcx,%rax), %esi
subl %edi, %esi
movq %r15, %rdx
movl %ebp, %ecx
movq %r14, %r8
movl %ebx, %r9d
callq 0x9946
testl %eax, %eax
jg 0x9937
incq %r13
leal -0x1(%r13), %ecx
cmpl 0x10(%r12), %ecx
jl 0x98b8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mattn[P]orelang/ore.c
// Function: ore_value_ref
void
ore_value_ref(ore_value v) {
  switch (v.t) {
    case ORE_TYPE_STRING:
      v.v.s->ref++;
      if (verbose)
        printf("ref str %d %p\n", v.v.s->ref, v.v.s->p);
      break;
    case ORE_TYPE_ARRAY:
      v.v.a->ref++;
      if (verbose)
        printf("ref array %d %p\n", v.v.a->ref, v.v.a->p);
      break;
    case ORE_TYPE_HASH:
      v.v.h->ref++;
      if (verbose)
        printf("ref hash %d %p\n", v.v.h->ref, v.v.h->p);
      break;
    case ORE_TYPE_REGEXP:
      v.v.r->ref++;
      if (verbose)
        printf("ref regexp %d %p\n", v.v.r->ref, v.v.r->p);
      break;
    case ORE_TYPE_ENV:
      v.v.e->ref++;
      if (verbose)
        printf("ref env %d %p\n", v.v.e->ref, v.v.e->p);
      break;
    case ORE_TYPE_OBJECT:
      v.v.o->ref++;
      if (verbose)
        printf("ref object %d %p\n", v.v.o->ref, v.v.o);
      break;
    default: 
      break;
  }
}

// Assembly:
movl 0x8(%rsp), %ecx
addl $-0x4, %ecx
cmpl $0x9, %ecx
ja 0xa51c
leaq 0x8(%rsp), %rax
leaq 0x63e8(%rip), %rdx      # 0x10828
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq 0x8(%rax), %rax
movl 0xc(%rax), %esi
incl %esi
movl %esi, 0xc(%rax)
cmpl $0x0, 0xddac(%rip)      # 0x18208
je 0xa51c
movq (%rax), %rdx
leaq 0x655c(%rip), %rdi      # 0x109c8
jmp 0xa515
movq 0x8(%rax), %rax
movl 0x8(%rax), %esi
incl %esi
movl %esi, 0x8(%rax)
cmpl $0x0, 0xdd84(%rip)      # 0x18208
je 0xa51c
movq (%rax), %rdx
leaq 0x6569(%rip), %rdi      # 0x109fd
jmp 0xa515
movq 0x8(%rax), %rdx
movl 0x18(%rdx), %esi
incl %esi
movl %esi, 0x18(%rdx)
cmpl $0x0, 0xdd5f(%rip)      # 0x18208
je 0xa51c
leaq 0x6582(%rip), %rdi      # 0x10a34
jmp 0xa515
movq 0x8(%rax), %rax
movl 0x8(%rax), %esi
incl %esi
movl %esi, 0x8(%rax)
cmpl $0x0, 0xdd41(%rip)      # 0x18208
je 0xa51c
movq (%rax), %rdx
leaq 0x6517(%rip), %rdi      # 0x109ea
jmp 0xa515
movq 0x8(%rax), %rax
movl 0xc(%rax), %esi
incl %esi
movl %esi, 0xc(%rax)
cmpl $0x0, 0xdd20(%rip)      # 0x18208
je 0xa51c
movq (%rax), %rdx
leaq 0x651b(%rip), %rdi      # 0x10a0f
jmp 0xa515
movq 0x8(%rax), %rax
movl 0x8(%rax), %esi
incl %esi
movl %esi, 0x8(%rax)
cmpl $0x0, 0xdcff(%rip)      # 0x18208
je 0xa51c
movq (%rax), %rdx
leaq 0x650e(%rip), %rdi      # 0x10a23
xorl %eax, %eax
jmp 0x20e0
retq
// File: /workspace/github_c_makefile_star2_O2/mattn[P]orelang/ore.c
// Function: ore_value_env_from_context
ore_value
ore_value_env_from_context(ore_context* p) {
  ore_value v = { ORE_TYPE_ENV };
  v.v.e = (ore_env*) malloc(sizeof(ore_env));
  if (!v.v.e) {
    fprintf(stderr, "failed to allocate memory\n");
    p->err = ORE_ERROR_EXCEPTION;
    return ore_value_nil();
  }
  v.v.e->ref = 0;
  v.v.e->p = p;
  return v;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x10
popq %rdi
callq 0x21a0
testq %rax, %rax
je 0xa5a4
andl $0x0, 0x8(%rax)
movq %r14, (%rax)
movq $0xa, (%rbx)
movq %rax, 0x8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
andq $0x0, 0x20(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xda4d(%rip), %rax      # 0x17ff8
movq (%rax), %rcx
leaq 0x6491(%rip), %rdi      # 0x10a46
pushq $0x1a
popq %rsi
pushq $0x1
popq %rdx
callq 0x2260
movl $0x1, 0x20(%r14)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
jmp 0xa590
// File: /workspace/github_c_makefile_star2_O2/mattn[P]orelang/ore.c
// Function: ore_prop
ore_value
ore_prop(ore_context* ore, const char* name) {
  ore_context* p = ore;
  if (!p)
    return ore_value_nil();
  khint_t k;
  k = kh_get(value, p->env, name);
  if (k != kh_end(p->env)) {
    return kh_value(p->env, k);
  }
  return ore_value_nil();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
je 0xa63c
movq (%rsi), %r14
movq %r14, %rdi
movq %rdx, %rsi
callq 0xa67b
cmpl (%r14), %eax
jne 0xa64d
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
andq $0x0, 0x20(%rbx)
jmp 0xa670
movq 0x20(%r14), %rcx
movl %eax, %eax
imulq $0x28, %rax, %rax
movq 0x20(%rcx,%rax), %rdx
movq %rdx, 0x20(%rbx)
movups (%rcx,%rax), %xmm0
movups 0x10(%rcx,%rax), %xmm1
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/mattn[P]orelang/ore.c
// Function: ore_get
ore_value
ore_get(ore_context* ore, const char* name) {
  ore_context* p = ore;
  if (!p)
    return ore_value_nil();
  khint_t k;
  while (p) {
    k = kh_get(value, p->env, name);
    if (k != kh_end(p->env)) {
      return kh_value(p->env, k);
    }
    p = p->parent;
  }
  fprintf(stderr, "unknown identifier '%s'\n", name);
  ore->err = ORE_ERROR_EXCEPTION;
  return ore_value_nil();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
testq %rsi, %rsi
je 0xa79c
movq %rdx, %r15
movq %rsi, %r14
movq %rsi, %r13
testq %r13, %r13
je 0xa7b8
movq (%r13), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0xa67b
cmpl (%r12), %eax
jne 0xa776
movq 0x8(%r13), %r13
jmp 0xa756
movq 0x20(%r12), %rcx
movl %eax, %eax
imulq $0x28, %rax, %rax
movq 0x20(%rcx,%rax), %rdx
movq %rdx, 0x20(%rbx)
movups (%rcx,%rax), %xmm0
movups 0x10(%rcx,%rax), %xmm1
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
jmp 0xa7ab
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
andq $0x0, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0xd839(%rip), %rax      # 0x17ff8
movq (%rax), %rdi
leaq 0x6298(%rip), %rsi      # 0x10a61
movq %r15, %rdx
xorl %eax, %eax
callq 0x2160
movl $0x1, 0x20(%r14)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups %xmm0, 0x10(%rbx)
jmp 0xa7a6
// File: /workspace/github_c_makefile_star2_O2/mattn[P]orelang/ore.c
// Function: ore_set
void
ore_set(ore_context* ore, const char* name, ore_value v) {
  khint_t k;
  int r = 0;
  ore_value old = ore_value_nil();
  while (ore) {
    k = kh_get(value, ore->env, name);
    if (k != kh_end(ore->env)) {
      old = kh_value(ore->env, k);
      ore_value_ref(v);
      ore_value_unref(old);
      k = kh_put(value, ore->env, name, &r);
      kh_value(ore->env, k) = v;
      return;
    }
    if (ore->parent == NULL) {
      if (k != kh_end(ore->env)) 
        old = kh_value(ore->env, k);
      ore_value_ref(v);
      ore_value_unref(old);
      k = kh_put(value, ore->env, name, &r);
      kh_value(ore->env, k) = v;
      return;
    }
    ore = ore->parent;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
leaq 0x80(%rsp), %r15
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
andq $0x0, 0x50(%rsp)
testq %rdi, %rdi
je 0xa8de
movq %rdi, %r12
movq (%rdi), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa67b
cmpl (%r14), %eax
jne 0xa83b
movq 0x8(%r12), %rdi
testq %rdi, %rdi
jne 0xa810
jmp 0xa862
movq 0x20(%r14), %rcx
movl %eax, %eax
imulq $0x28, %rax, %rax
movq 0x20(%rcx,%rax), %rdx
movq %rdx, 0x50(%rsp)
movups (%rcx,%rax), %xmm0
movups 0x10(%rcx,%rax), %xmm1
movaps %xmm1, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movq 0x20(%r15), %rax
movq %rax, 0x20(%rsp)
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0xa424
movq 0x50(%rsp), %rax
movq %rax, 0x20(%rsp)
movaps 0x30(%rsp), %xmm0
movaps 0x40(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0xa113
movq (%r12), %rdi
leaq 0x2c(%rsp), %rdx
movq %rbx, %rsi
callq 0xa8ea
movq (%r12), %rcx
movq 0x20(%rcx), %rcx
movl %eax, %eax
imulq $0x28, %rax, %rax
movq 0x20(%r15), %rdx
movq %rdx, 0x20(%rcx,%rax)
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups %xmm1, 0x10(%rcx,%rax)
movups %xmm0, (%rcx,%rax)
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/mattn[P]orelang/ore.c
// Function: ore_define
void
ore_define(ore_context* ore, const char* name, ore_value v) {
  int r = 0;
  ore_value old = ore_value_nil();
  khint_t k = kh_get(value, ore->env, name);
  if (k != kh_end(ore->env))
    old = kh_value(ore->env, k);
  k = kh_put(value, ore->env, name, &r);
  ore_value_ref(v);
  kh_value(ore->env, k) = v;
  ore_value_unref(old);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x90(%rsp), %r12
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
andq $0x0, 0x50(%rsp)
movq (%rdi), %r15
movq %r15, %rdi
callq 0xa67b
cmpl (%r15), %eax
je 0xab34
movq 0x20(%r15), %rcx
movl %eax, %eax
imulq $0x28, %rax, %rax
movq 0x20(%rcx,%rax), %rdx
movq %rdx, 0x50(%rsp)
movups (%rcx,%rax), %xmm0
movups 0x10(%rcx,%rax), %xmm1
movaps %xmm1, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
leaq 0x2c(%rsp), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0xa8ea
movl %eax, %ebp
movq 0x20(%r12), %rax
movq %rax, 0x20(%rsp)
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0xa424
movq (%rbx), %rax
movq 0x20(%rax), %rax
movl %ebp, %ecx
imulq $0x28, %rcx, %rcx
movq 0x20(%r12), %rdx
movq %rdx, 0x20(%rax,%rcx)
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups %xmm1, 0x10(%rax,%rcx)
movups %xmm0, (%rax,%rcx)
movq 0x50(%rsp), %rax
movq %rax, 0x20(%rsp)
movaps 0x30(%rsp), %xmm0
movaps 0x40(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0xa113
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mattn[P]orelang/ore.c
// Function: orex_define_class
ore_value
orex_define_class(ore_context* ore, const char* name) {
  ore_value v = { ORE_TYPE_CCLASS };
  v.v.x = (ore_cclass*) malloc(sizeof(ore_cclass));
  if (!v.v.x) {
    fprintf(stderr, "failed to allocate memory\n");
    ore->err = ORE_ERROR_EXCEPTION;
    return ore_value_nil();
  }
  v.v.x->n = name;
  v.v.x->e = ore_new(ore);
  ore_context* g = ore;
  while (g->parent) g = g->parent;
  ore_define(g, v.v.x->n, v);
  return v;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x40(%rsp)
andq $0x0, 0x50(%rsp)
movl $0xc, 0x30(%rsp)
pushq $0x10
popq %rdi
callq 0x21a0
movq %rax, 0x38(%rsp)
testq %rax, %rax
je 0xac70
movq %rax, %r15
movq %r12, (%rax)
movq %r14, %rdi
callq 0xaca5
movq %rax, 0x8(%r15)
movq %r14, %rdi
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0xac16
movq (%r15), %rsi
movq 0x50(%rsp), %rax
movq %rax, 0x20(%rsp)
movaps 0x30(%rsp), %xmm0
movaps 0x40(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0xaad0
movq 0x50(%rsp), %rax
movq %rax, 0x20(%rbx)
movaps 0x30(%rsp), %xmm0
movaps 0x40(%rsp), %xmm1
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0xd381(%rip), %rax      # 0x17ff8
movq (%rax), %rcx
leaq 0x5dc5(%rip), %rdi      # 0x10a46
pushq $0x1a
popq %rsi
pushq $0x1
popq %rdx
callq 0x2260
movl $0x1, 0x20(%r14)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups %xmm0, 0x10(%rbx)
andq $0x0, 0x20(%rbx)
jmp 0xac61
// File: /workspace/github_c_makefile_star2_O2/mattn[P]orelang/ore.c
// Function: ore_new
ore_context*
ore_new(ore_context* parent) {
  ore_context* ore = (ore_context*) malloc(sizeof(ore_context));
  if (!ore) {
    fprintf(stderr, "failed to allocate memory\n");
    return NULL;
  }
  ore->env = kh_init(value);
  ore->ct = kh_init(value);
  ore->err = ORE_ERROR_NONE;
  ore->parent = parent;
  ore->ast = kh_init(ast);
  return ore;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
pushq $0x30
popq %rdi
callq 0x21a0
movq %rax, %rbx
testq %rax, %rax
je 0xacef
callq 0xcefc
movq %rax, (%rbx)
callq 0xcefc
movq %rax, 0x10(%rbx)
andl $0x0, 0x20(%rbx)
movq %r14, 0x8(%rbx)
pushq $0x1
popq %rdi
pushq $0x28
popq %rsi
callq 0x2140
movq %rax, 0x28(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xd302(%rip), %rax      # 0x17ff8
movq (%rax), %rcx
leaq 0x5d46(%rip), %rdi      # 0x10a46
pushq $0x1a
popq %rsi
pushq $0x1
popq %rdx
callq 0x2260
jmp 0xace4
// File: /workspace/github_c_makefile_star2_O2/mattn[P]orelang/ore.c
// Function: orex_define_method
void
orex_define_method(ore_context* ore, ore_value clazz, const char* name, int num_in, int max_in, ore_cfunc_t c, void* u) {
  ore_value v = { ORE_TYPE_CFUNC };
  v.v.f.ore = clazz.v.x->e;
  v.v.f.num_in = num_in;
  v.v.f.max_in = max_in;
  v.v.f.x.c = c;
  v.v.f.u = u;
  ore_define(clazz.v.x->e, name, v);
}

// Assembly:
subq $0x58, %rsp
andq $0x0, 0x30(%rsp)
movl $0x9, 0x30(%rsp)
movq 0x68(%rsp), %rax
movq 0x8(%rax), %rdi
movq %rdi, 0x38(%rsp)
movl %edx, 0x40(%rsp)
movl %ecx, 0x44(%rsp)
movq %r8, 0x48(%rsp)
movq %r9, 0x50(%rsp)
movq %r9, 0x20(%rsp)
movups 0x30(%rsp), %xmm0
movups 0x40(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0xaad0
addq $0x58, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/mattn[P]orelang/ore.c
// Function: ore_define_cfunc
void
ore_define_cfunc(ore_context* ore, const char* name, int num_in, int max_in, ore_cfunc_t c, void* u) {
  ore_value v = { ORE_TYPE_CFUNC };
  v.v.f.ore = ore;
  v.v.f.num_in = num_in;
  v.v.f.max_in = max_in;
  v.v.f.x.c = c;
  v.v.f.u = u;
  ore_define(ore, name, v);
}

// Assembly:
subq $0x58, %rsp
andq $0x0, 0x30(%rsp)
movl $0x9, 0x30(%rsp)
movq %rdi, 0x38(%rsp)
movl %edx, 0x40(%rsp)
movl %ecx, 0x44(%rsp)
movq %r8, 0x48(%rsp)
movq %r9, 0x50(%rsp)
movq %r9, 0x20(%rsp)
movups 0x30(%rsp), %xmm0
movups 0x40(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0xaad0
addq $0x58, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/mattn[P]orelang/ore.c
// Function: ore_value_array_from_klist
static ore_value
ore_value_array_from_klist(ore_context* ore, ore_array_t* p) {
  ore_value v = { ORE_TYPE_ARRAY };
  v.v.a = (ore_array*) malloc(sizeof(ore_array));
  if (!v.v.a) {
    fprintf(stderr, "failed to allocate memory\n");
    ore->err = ORE_ERROR_EXCEPTION;
    return ore_value_nil();
  }
  v.v.a->ref = 0;
  v.v.a->p = p;
  return v;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x10
popq %rdi
callq 0x21a0
testq %rax, %rax
je 0xb18c
andl $0x0, 0x8(%rax)
movq %r15, (%rax)
movq $0x5, (%rbx)
movq %rax, 0x8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
andq $0x0, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0xce65(%rip), %rax      # 0x17ff8
movq (%rax), %rcx
leaq 0x58a9(%rip), %rdi      # 0x10a46
pushq $0x1a
popq %rsi
pushq $0x1
popq %rdx
callq 0x2260
movl $0x1, 0x20(%r14)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
jmp 0xb17a
// File: /workspace/github_c_makefile_star2_O2/mattn[P]orelang/ore.c
// Function: ore_err_print
static void
ore_err_print(mpc_err_t* err) {
  if (err->failure)
    fprintf(stderr, "%s: error: %s\n", err->filename, err->failure);
  else
    fprintf(stderr, "%s:%ld:%ld: syntax error\n", err->filename, err->state.row+1, err->state.col+1);
}

// Assembly:
movq %rdi, %rax
movq 0x20(%rdi), %rdx
movq 0x28(%rdi), %rcx
movq 0xa56c(%rip), %rsi      # 0x17ff8
movq (%rsi), %rdi
testq %rcx, %rcx
jne 0xdab0
movq 0x8(%rax), %rcx
movq 0x10(%rax), %r8
incq %rcx
incq %r8
leaq 0x4621(%rip), %rsi      # 0x120ca
xorl %eax, %eax
jmp 0x2160
leaq 0x27d9(%rip), %rsi      # 0x10290
xorl %eax, %eax
jmp 0x2160
// File: /workspace/github_c_makefile_star2_O2/mattn[P]orelang/ore.c
// Function: ore_cfunc_dump_env
static ore_value
ore_cfunc_dump_env(ore_context* ore, int num_in, ore_value* args, void* u) {
  int i, level = 0;
  while (ore) {
    for (i = 0; i < level; i++) printf(" ");
    ore_hash_t* h = (ore_hash_t*) ore->env;
    ore_hash_iter_t k;
    int n = 0;
    printf("%p : {", ore->env);
    for (k = kh_begin(h); k != kh_end(h); k++) {
      if (!kh_exist(h, k)) continue;
      if (n > 0) {
        printf(",");
      }
      const char* key = kh_key(h, k);
      printf("%s: ", key);
      ore_value pa[] = { kh_val(h, k) };
      ore_cfunc_print(ore, 1, pa, NULL);
      n++;
    }
    printf("}\n");
    ore = ore->parent;
    level++;
  }
  return ore_value_nil();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r14
movq %rdi, 0x10(%rsp)
pushq $0x20
popq %rbp
xorl %ebx, %ebx
testq %r14, %r14
je 0xdbc1
movl %ebx, 0xc(%rsp)
subl $0x1, %ebx
jb 0xdaf4
movl %ebp, %edi
callq 0x2040
jmp 0xdae6
movq %r14, 0x18(%rsp)
movq (%r14), %r14
xorl %r13d, %r13d
leaq 0x45de(%rip), %rdi      # 0x120e4
movq %r14, %rsi
xorl %eax, %eax
callq 0x20e0
xorl %ebx, %ebx
xorl %r15d, %r15d
cmpl (%r14), %ebx
je 0xdba1
movq 0x10(%r14), %rax
movl %ebx, %ecx
shrl $0x4, %ecx
movl (%rax,%rcx,4), %eax
movl %r13d, %ecx
andb $0x1e, %cl
shrl %cl, %eax
testb $0x3, %al
jne 0xdb96
testl %r15d, %r15d
jle 0xdb43
pushq $0x2c
popq %rdi
callq 0x2040
movq 0x18(%r14), %rax
movl %ebx, %r12d
movq (%rax,%r12,8), %rsi
leaq 0x4596(%rip), %rdi      # 0x120eb
xorl %eax, %eax
callq 0x20e0
movq 0x20(%r14), %rax
imulq $0x28, %r12, %rcx
movq 0x20(%rax,%rcx), %rdx
movq %rdx, 0x40(%rsp)
movups (%rax,%rcx), %xmm0
movups 0x10(%rax,%rcx), %xmm1
movaps %xmm1, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
leaq 0x50(%rsp), %rdi
pushq $0x1
popq %rdx
leaq 0x20(%rsp), %rcx
callq 0xdc2b
incl %r15d
incl %ebx
addl $0x2, %r13d
jmp 0xdb15
leaq 0x2b8f(%rip), %rdi      # 0x10737
callq 0x2070
movq 0x18(%rsp), %r14
movq 0x8(%r14), %r14
movl 0xc(%rsp), %ebx
incl %ebx
jmp 0xdad9
xorps %xmm0, %xmm0
movq 0x10(%rsp), %rax
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
andq $0x0, 0x20(%rax)
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mattn[P]orelang/ore.c
// Function: ore_cfunc_print
static ore_value
ore_cfunc_print(ore_context* ore, int num_in, ore_value* args, void* u) {
  int i;
  for (i = 0; i < num_in; i++) {
    if (i != 0) printf(", ");
    ore_value v = args[i];
    char* s = ore_value_to_str(ore, v);
    printf("%s", s);
    free(s);
  }
  return ore_value_nil();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r14
movq %rdi, 0x30(%rsp)
xorl %eax, %eax
testl %edx, %edx
cmovlel %eax, %edx
imulq $0x28, %rdx, %rbp
leaq 0x2950(%rip), %r15      # 0x105a3
leaq 0x267a(%rip), %r12      # 0x102d4
xorl %ebx, %ebx
cmpq %rbx, %rbp
je 0xdcb1
testq %rbx, %rbx
je 0xdc70
movq %r12, %rdi
xorl %eax, %eax
callq 0x20e0
movq 0x20(%r14,%rbx), %rax
movq %rax, 0x20(%rsp)
movups (%r14,%rbx), %xmm0
movups 0x10(%r14,%rbx), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0xf902
movq %rax, %r13
movq %r15, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x20e0
movq %r13, %rdi
callq 0x22c0
addq $0x28, %rbx
jmp 0xdc5c
xorps %xmm0, %xmm0
movq 0x30(%rsp), %rax
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
andq $0x0, 0x20(%rax)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mattn[P]orelang/ore.c
// Function: ore_cfunc_len
static ore_value
ore_cfunc_len(ore_context* ore, int num_in, ore_value* args, void* u) {
  ore_value v = { ORE_TYPE_INT };
  switch (args[0].t) {
    case ORE_TYPE_STRING:
      v.v.i = strlen(args[0].v.s->p);
      return v;
    case ORE_TYPE_ARRAY:
      {
        ore_array_t* a = (ore_array_t*) args[0].v.a->p;
        ore_array_iter_t *k;
        int n = 0;
        for (k = kl_begin(a); k != kl_end(a); k = kl_next(k)) n++;
        v.v.i = n;
      }
      return v;
    default:
      break;
  }
  fprintf(stderr, "argument should be string or array\n");
  ore->err = ORE_ERROR_EXCEPTION;
  return ore_value_nil();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rcx), %eax
cmpl $0x5, %eax
je 0xdcff
cmpl $0x4, %eax
jne 0xdd3c
movq 0x8(%rcx), %rax
movq (%rax), %rdi
callq 0x20c0
movq $0x2, (%rbx)
movl %eax, 0x8(%rbx)
jmp 0xdd26
movq 0x8(%rcx), %rax
movq (%rax), %rcx
movq 0x8(%rcx), %rdx
xorl %eax, %eax
movq (%rcx), %rcx
cmpq %rdx, %rcx
je 0xdd1c
incl %eax
addq $0x28, %rcx
jmp 0xdd0c
movq $0x2, (%rbx)
movl %eax, 0x8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0xc(%rbx)
movups %xmm0, 0x18(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rsi, %r14
movq 0xa2b2(%rip), %rax      # 0x17ff8
movq (%rax), %rcx
leaq 0x43ce(%rip), %rdi      # 0x1211e
pushq $0x23
popq %rsi
pushq $0x1
popq %rdx
callq 0x2260
movl $0x1, 0x20(%r14)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups %xmm0, 0x10(%rbx)
andq $0x0, 0x20(%rbx)
jmp 0xdd31
// File: /workspace/github_c_makefile_star2_O2/mattn[P]orelang/ore.c
// Function: ore_cfunc_range
static ore_value
ore_cfunc_range(ore_context* ore, int num_in, ore_value* args, void* u) {
  if (args[0].t != ORE_TYPE_INT) {
    fprintf(stderr, "argument should be int\n");
    ore->err = ORE_ERROR_EXCEPTION;
    return ore_value_nil();
  }
  ore_array_t* a = kl_init(value);
  int from = 0;
  int to = 0;
  if (num_in == 2) {
    if (args[1].t != ORE_TYPE_INT) {
      fprintf(stderr, "argument should be int\n");
      ore->err = ORE_ERROR_EXCEPTION;
      return ore_value_nil();
    }
    from = args[0].v.i;
    to = args[1].v.i;
  } else {
    to = args[0].v.i - 1;
  }
  int j;
  for (j = from; j <= to; j++) {
    ore_value v = { ORE_TYPE_INT };
    v.v.i = j;
    *kl_pushp(value, a) = v;
  }
  return ore_value_array_from_klist(ore, a);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x2, (%rcx)
jne 0xde02
movq %rcx, %r12
movl %edx, %ebp
callq 0xb0dd
movq %rax, %r15
cmpl $0x2, %ebp
jne 0xddb0
cmpl $0x2, 0x28(%r12)
jne 0xde02
movl 0x8(%r12), %r13d
movl 0x30(%r12), %ebp
jmp 0xdddd
movl 0x8(%r12), %ebp
decl %ebp
xorl %r13d, %r13d
jmp 0xdddd
movq %r15, %rdi
callq 0xb123
movq $0x2, (%rax)
movl %r13d, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0xc(%rax)
movups %xmm0, 0x18(%rax)
incl %r13d
cmpl %ebp, %r13d
jle 0xddbc
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xb14a
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xa1ef(%rip), %rax      # 0x17ff8
movq (%rax), %rcx
leaq 0x432f(%rip), %rdi      # 0x12142
pushq $0x17
popq %rsi
pushq $0x1
popq %rdx
callq 0x2260
movl $0x1, 0x20(%r14)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups %xmm0, 0x10(%rbx)
andq $0x0, 0x20(%rbx)
jmp 0xddf0
// File: /workspace/github_c_makefile_star2_O2/mattn[P]orelang/ore.c
// Function: ore_cfunc_load
static ore_value
ore_cfunc_load(ore_context* ore, int num_in, ore_value* args, void* u) {
  ore_parse_context* pctx = (ore_parse_context*) u;

  mpc_result_t result;
  if (args[0].t != ORE_TYPE_STRING) {
    fprintf(stderr, "argument should be string\n");
    ore->err = ORE_ERROR_EXCEPTION;
    return ore_value_nil();
  }
  if (!mpc_parse_contents(ore_value_str_ptr(args[0]), pctx->program, &result)) {
    ore_err_print(result.error);
    mpc_err_delete(result.error);
    ore->err = ORE_ERROR_EXCEPTION;
    return ore_value_nil();
  }
  if (verbose)
    mpc_ast_print(result.output);
  ore_eval(ore, result.output);
  mpc_ast_add_child(pctx->root, result.output);
  return ore_value_nil();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x4, (%rcx)
jne 0xdf21
movq %r8, %r15
movq 0x8(%rcx), %rax
movq (%rax), %rdi
movq 0x8(%r8), %rsi
movq %rsp, %rdx
callq 0x378a
testl %eax, %eax
je 0xdeeb
cmpl $0x0, 0xa351(%rip)      # 0x18208
je 0xdec2
movq (%rsp), %rdi
callq 0x651f
movq (%rsp), %rdx
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0xb1b8
movq (%r15), %rdi
movq (%rsp), %rsi
callq 0x6348
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups %xmm0, 0x10(%rbx)
jmp 0xdf0f
movq (%rsp), %rdi
callq 0xda7a
movq (%rsp), %rdi
callq 0x23bc
movl $0x1, 0x20(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
andq $0x0, 0x20(%rbx)
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0xa0d0(%rip), %rax      # 0x17ff8
movq (%rax), %rcx
leaq 0x4228(%rip), %rdi      # 0x1215a
pushq $0x1a
popq %rsi
pushq $0x1
popq %rdx
callq 0x2260
movl $0x1, 0x20(%r14)
jmp 0xdedf
// File: /workspace/github_c_makefile_star2_O2/mattn[P]orelang/ore.c
// Function: ore_cfunc_environ
static ore_value
ore_cfunc_environ(ore_context* ore, int num_in, ore_value* args, void* u) {
  if (num_in == 1 && args[0].v.s->p) {
    return ore_value_str_from_ptr(ore, (char*) getenv(args[0].v.s->p), -1);
  } else {
    int i;
    ore_hash_t* h = kh_init(value);
    for (i = 0; environ[i]; i++) {
      const char* p = environ[i];
      if (p == NULL) break;
      const char* t = strchr(p, '=');
      if (t) {
        int r = 0;
        char* n = calloc(1, t-p+1);
        memcpy(n, p, t-p);
        ore_value val = ore_value_str_from_ptr(ore, (char*) t+1, -1);
        khint_t k = kh_put(value, h, n, &r);
        kh_value(h, k) = val;
      }
    }
    return ore_value_hash_from_khash(ore, h);
  }
  fprintf(stderr, "invalid argument\n");
  ore->err = ORE_ERROR_EXCEPTION;
  return ore_value_nil();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, 0x8(%rsp)
movq %rdi, %rbx
cmpl $0x1, %edx
jne 0xdf8b
movq 0x8(%rcx), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0xdf8b
callq 0x2030
pushq $-0x1
popq %rcx
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
callq 0xe0cb
jmp 0xe064
movq %rbx, 0x10(%rsp)
callq 0xcefc
movq %rax, %r15
movq 0xa041(%rip), %rax      # 0x17fe0
movq (%rax), %r12
xorl %r14d, %r14d
movq (%r12,%r14), %r13
testq %r13, %r13
je 0xe04f
movq %r13, %rdi
pushq $0x3d
popq %rsi
callq 0x20d0
testq %rax, %rax
je 0xe046
movq %rax, %rbx
movq %rax, %r12
subq %r13, %r12
leaq 0x1(%r12), %rsi
pushq $0x1
popq %rdi
callq 0x2140
movq %rax, %rbp
movq %rax, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x2190
incq %rbx
leaq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rbx, %rdx
pushq $-0x1
popq %rcx
callq 0xe0cb
movq %r15, %rdi
movq %rbp, %rsi
leaq 0x1c(%rsp), %rdx
callq 0xa8ea
movq 0x20(%r15), %rcx
movl %eax, %eax
imulq $0x28, %rax, %rax
movq 0x40(%rsp), %rdx
movq %rdx, 0x20(%rcx,%rax)
movups 0x20(%rsp), %xmm0
movups 0x30(%rsp), %xmm1
movups %xmm1, 0x10(%rcx,%rax)
movups %xmm0, (%rcx,%rax)
movq 0x9f9d(%rip), %rax      # 0x17fe0
movq (%rax), %r12
addq $0x8, %r14
jmp 0xdfa5
movq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
movq %r15, %rdx
callq 0xe7ab
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mattn[P]orelang/ore.c
// Function: ore_cfunc_exit
static ore_value
ore_cfunc_exit(ore_context* ore, int num_in, ore_value* args, void* u) {
  if (args[0].t != ORE_TYPE_INT) {
    fprintf(stderr, "argument should be int\n");
    ore->err = ORE_ERROR_EXCEPTION;
    return ore_value_nil();
  }
  exit(args[0].v.i);
  return ore_value_nil();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x2, (%rcx)
je 0xe0c3
movq %rsi, %r14
movq %rdi, %rbx
movq 0x9f6c(%rip), %rax      # 0x17ff8
movq (%rax), %rcx
leaq 0x40ac(%rip), %rdi      # 0x12142
pushq $0x17
popq %rsi
pushq $0x1
popq %rdx
callq 0x2260
movl $0x1, 0x20(%r14)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups %xmm0, 0x10(%rbx)
andq $0x0, 0x20(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl 0x8(%rcx), %edi
callq 0x2250
// File: /workspace/github_c_makefile_star2_O2/mattn[P]orelang/ore.c
// Function: ore_value_str_from_ptr
static ore_value
ore_value_str_from_ptr(ore_context* ore, char* p, int l) {
  if (p == NULL) return ore_value_nil();
  ore_value v = { ORE_TYPE_STRING };
  v.v.s = (ore_string*) malloc(sizeof(ore_string));
  if (!v.v.s) {
    fprintf(stderr, "failed to allocate memory\n");
    ore->err = ORE_ERROR_EXCEPTION;
    return ore_value_nil();
  }
  v.v.s->ref = 0;
  v.v.s->l = l < 0 ? strlen(p) : l;
  v.v.s->p = p;
  return v;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
testq %rdx, %rdx
je 0xe125
movl %ecx, %r15d
movq %rdx, %r14
movq %rsi, %r12
pushq $0x10
popq %rdi
callq 0x21a0
testq %rax, %rax
je 0xe141
movq %rax, %r13
andl $0x0, 0xc(%rax)
testl %r15d, %r15d
jns 0xe109
movq %r14, %rdi
callq 0x20c0
movq %rax, %r15
movl %r15d, 0x8(%r13)
movq %r14, (%r13)
movq $0x4, (%rbx)
movq %r13, 0x8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
jmp 0xe12f
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
andq $0x0, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x9eb0(%rip), %rax      # 0x17ff8
movq (%rax), %rcx
leaq 0x28f4(%rip), %rdi      # 0x10a46
pushq $0x1a
popq %rsi
pushq $0x1
popq %rdx
callq 0x2260
movl $0x1, 0x20(%r12)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
jmp 0xe11f
// File: /workspace/github_c_makefile_star2_O2/mattn[P]orelang/ore.c
// Function: ore_parse_str
static ore_value
ore_parse_str(ore_context* ore, const char* s) {
  ore_value v = { ORE_TYPE_STRING };
  char* t = strdup(s);
  if (!t) {
    fprintf(stderr, "failed to allocate memory\n");
    ore->err = ORE_ERROR_EXCEPTION;
    return ore_value_nil();
  }
  char* p = t + 1;
  char* ps = p;
  int n = 0;
  while (*p) {
    if (*p == '\\' && *(p+1)) {
      p++;
      switch (*p) {
        case 'b': *ps = '\b'; break;
        case 'f': *ps = '\f'; break;
        case 'r': *ps = '\r'; break;
        case 'n': *ps = '\n'; break;
        case 't': *ps = '\t'; break;
        default:
         *ps = *p;
      }
    } else
      *ps = *p;
    p++; ps++; n++;
  }
  *p = 0x00;
  size_t l = n - 1;
  v.v.s = (ore_string*) malloc(sizeof(ore_string));
  if (!v.v.s) {
    fprintf(stderr, "failed to allocate memory\n");
    ore->err = ORE_ERROR_EXCEPTION;
    return ore_value_nil();
  }
  v.v.s->ref = 0;
  v.v.s->l = l;
  v.v.s->p = calloc(1, l + 1);
  strncpy(v.v.s->p, t + 1, l);
  free(t);
  return v;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
movq %rdx, %rdi
callq 0x2270
testq %rax, %rax
je 0xe776
movq %rax, %r15
movq %rax, %r12
incq %r12
pushq $-0x1
popq %r13
leaq 0x219b(%rip), %rax      # 0x10850
movq %r12, %rcx
movzbl (%rcx), %edx
cmpl $0x5c, %edx
je 0xe6c6
testl %edx, %edx
jne 0xe6fa
jmp 0xe707
movsbl 0x1(%rcx), %esi
testl %esi, %esi
je 0xe6fa
incq %rcx
leal -0x62(%rsi), %edx
rorl %edx
cmpl $0x9, %edx
ja 0xe6e8
movslq (%rax,%rdx,4), %rdx
addq %rax, %rdx
jmpq *%rdx
movb $0x8, %dl
jmp 0xe6fa
movl %esi, %edx
jmp 0xe6fa
movb $0xa, %dl
jmp 0xe6fa
movb $0xc, %dl
jmp 0xe6fa
movb $0xd, %dl
jmp 0xe6fa
movb $0x9, %dl
movb %dl, 0x2(%r15,%r13)
incq %rcx
incq %r13
jmp 0xe6b8
movb $0x0, (%rcx)
pushq $0x10
popq %rdi
callq 0x21a0
testq %rax, %rax
je 0xe776
movq %rax, %rbp
andl $0x0, 0xc(%rax)
movl %r13d, 0x8(%rax)
leaq 0x1(%r13), %rsi
pushq $0x1
popq %rdi
callq 0x2140
movq %rax, (%rbp)
movq %rax, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x2050
movq %r15, %rdi
callq 0x22c0
movq $0x4, (%rbx)
movq %rbp, 0x8(%rbx)
movaps (%rsp), %xmm0
movups %xmm0, 0x10(%rbx)
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rbx)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x987b(%rip), %rax      # 0x17ff8
movq (%rax), %rcx
leaq 0x22bf(%rip), %rdi      # 0x10a46
pushq $0x1a
popq %rsi
pushq $0x1
popq %rdx
callq 0x2260
movl $0x1, 0x20(%r14)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups %xmm0, 0x10(%rbx)
andq $0x0, 0x20(%rbx)
jmp 0xe764
// File: /workspace/github_c_makefile_star2_O2/mattn[P]orelang/ore.c
// Function: ore_value_hash_from_khash
static ore_value
ore_value_hash_from_khash(ore_context* ore, ore_hash_t* p) {
  ore_value v = { ORE_TYPE_HASH };
  v.v.h = (ore_hash*) malloc(sizeof(ore_hash));
  if (!v.v.h) {
    fprintf(stderr, "failed to allocate memory\n");
    ore->err = ORE_ERROR_EXCEPTION;
    return ore_value_nil();
  }
  v.v.h->ref = 0;
  v.v.h->p = p;
  return v;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x10
popq %rdi
callq 0x21a0
testq %rax, %rax
je 0xe7ed
andl $0x0, 0x8(%rax)
movq %r15, (%rax)
movq $0x6, (%rbx)
movq %rax, 0x8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
andq $0x0, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x9804(%rip), %rax      # 0x17ff8
movq (%rax), %rcx
leaq 0x2248(%rip), %rdi      # 0x10a46
pushq $0x1a
popq %rsi
pushq $0x1
popq %rdx
callq 0x2260
movl $0x1, 0x20(%r14)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
jmp 0xe7db