LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x30, %edi
callq 0x2190
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x11273
movq 0xfda0(%rip), %rax      # 0x20ff8
movq (%rax), %rdi
leaq 0x995c(%rip), %rsi      # 0x1abbe
movb $0x0, %al
callq 0x2140
movq $0x0, -0x8(%rbp)
jmp 0x112c1
callq 0x131d0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
callq 0x131d0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
callq 0x131f0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x20e0
movq -0x58(%rbp), %rax
movl $0x9, -0x50(%rbp)
movq 0x8(%rax), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, -0x48(%rbp)
movl -0x14(%rbp), %ecx
movl %ecx, -0x40(%rbp)
movl -0x18(%rbp), %ecx
movl %ecx, -0x3c(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, -0x38(%rbp)
movq -0x28(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x20(%rax)
movups -0x50(%rbp), %xmm0
movups -0x40(%rbp), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x11030
addq $0x80, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x20e0
movl $0x9, -0x50(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x40(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x20(%rax)
movups -0x50(%rbp), %xmm0
movups -0x40(%rbp), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x11030
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, -0x40(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x20e0
movl $0x5, -0x38(%rbp)
movl $0x10, %edi
callq 0x2190
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x11972
movq 0xf6ad(%rip), %rax      # 0x20ff8
movq (%rax), %rdi
leaq 0x9269(%rip), %rsi      # 0x1abbe
movb $0x0, %al
callq 0x2140
movq -0x48(%rbp), %rdi
movq -0x8(%rbp), %rax
movl $0x1, 0x20(%rax)
callq 0x10670
jmp 0x1199a
movq -0x48(%rbp), %rdi
movq -0x30(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
leaq -0x38(%rbp), %rsi
movl $0x28, %edx
callq 0x2170
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mattn[P]orelang/ore.c
// Function: parse_args
static int
parse_args(int argc, char **argv) {
  int i;
  for (i = 1; i < argc; i++) {
    if (argv[i][0] != '-') break;
    switch (argv[i][1]) {
    case 'v':
      verbose = 1;
      break;
    default:
      return -1;
    }
  }
  if (i == argc) return 0;
  return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x14467
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0x14430
jmp 0x14467
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movb 0x1(%rax), %al
subb $0x76, %al
jne 0x14451
jmp 0x14445
movl $0x1, 0xcda1(%rip)      # 0x211f0
jmp 0x1445a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1447e
jmp 0x1445c
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x14412
movl -0x14(%rbp), %eax
cmpl -0x8(%rbp), %eax
jne 0x14478
movl $0x0, -0x4(%rbp)
jmp 0x1447e
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x14501
movq 0xcb1a(%rip), %rax      # 0x20ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rcx
leaq 0x5ec2(%rip), %rsi      # 0x1a3ba
movb $0x0, %al
callq 0x2140
jmp 0x14539
movq 0xcaf0(%rip), %rax      # 0x20ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %r8
addq $0x1, %r8
leaq 0x7d33(%rip), %rsi      # 0x1c265
movb $0x0, %al
callq 0x2140
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0xa8(%rbp)
movq %rdi, -0xa0(%rbp)
movq %rsi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movl $0x0, -0x28(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x146bf
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0x145a2
leaq 0x62ee(%rip), %rdi      # 0x1a87e
movb $0x0, %al
callq 0x20d0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x14581
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rsi
leaq 0x7cbd(%rip), %rdi      # 0x1c27f
movb $0x0, %al
callq 0x20d0
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
je 0x14697
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x34(%rbp), %ecx
shrl $0x4, %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %eax
movl -0x34(%rbp), %ecx
andl $0xf, %ecx
shll %ecx
shrl %cl, %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0x14609
jmp 0x14689
cmpl $0x0, -0x38(%rbp)
jle 0x1461d
leaq 0x7c70(%rip), %rdi      # 0x1c286
movb $0x0, %al
callq 0x20d0
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movl -0x34(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rsi
leaq 0x7c4d(%rip), %rdi      # 0x1c288
movb $0x0, %al
callq 0x20d0
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rsi
movl -0x34(%rbp), %eax
imulq $0x28, %rax, %rax
addq %rax, %rsi
leaq -0x70(%rbp), %rdi
movl $0x28, %edx
callq 0x2170
movq -0x8(%rbp), %rsi
leaq -0x70(%rbp), %rcx
leaq -0x98(%rbp), %rdi
movl $0x1, %edx
xorl %eax, %eax
movl %eax, %r8d
callq 0x14750
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x145d0
leaq 0x7bef(%rip), %rdi      # 0x1c28d
movb $0x0, %al
callq 0x20d0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x1456f
movq -0xa8(%rbp), %rdi
callq 0x10670
movq -0xa0(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, -0x60(%rbp)
movq %rsi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x14806
cmpl $0x0, -0x24(%rbp)
je 0x14799
leaq 0x5c6c(%rip), %rdi      # 0x1a3fe
movb $0x0, %al
callq 0x20d0
movq -0x18(%rbp), %rsi
movslq -0x24(%rbp), %rax
imulq $0x28, %rax, %rax
addq %rax, %rsi
leaq -0x50(%rbp), %rdi
movl $0x28, %edx
callq 0x2170
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x20(%rax)
movups -0x50(%rbp), %xmm0
movups -0x40(%rbp), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x18d70
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rsi
leaq 0x5ee7(%rip), %rdi      # 0x1a6cf
movb $0x0, %al
callq 0x20d0
movq -0x58(%rbp), %rdi
callq 0x2280
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x14779
movq -0x68(%rbp), %rdi
callq 0x10670
movq -0x60(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, -0x70(%rbp)
movq %rsi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
movaps %xmm0, -0x50(%rbp)
movq $0x0, -0x30(%rbp)
movl $0x2, -0x50(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x68(%rbp)
subl $0x4, %eax
je 0x14879
jmp 0x1486c
movl -0x68(%rbp), %eax
subl $0x5, %eax
je 0x148a3
jmp 0x14903
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rdi
callq 0x20b0
movq -0x78(%rbp), %rdi
movl %eax, -0x48(%rbp)
leaq -0x50(%rbp), %rsi
movl $0x28, %edx
callq 0x2170
jmp 0x14931
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movl $0x0, -0x64(%rbp)
movq -0x58(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq -0x58(%rbp), %rcx
cmpq 0x8(%rcx), %rax
je 0x148e9
movl -0x64(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x64(%rbp)
movq -0x60(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x60(%rbp)
jmp 0x148c4
movq -0x78(%rbp), %rdi
movl -0x64(%rbp), %eax
movl %eax, -0x48(%rbp)
leaq -0x50(%rbp), %rsi
movl $0x28, %edx
callq 0x2170
jmp 0x14931
jmp 0x14905
movq 0xc6ec(%rip), %rax      # 0x20ff8
movq (%rax), %rdi
leaq 0x79a8(%rip), %rsi      # 0x1c2be
movb $0x0, %al
callq 0x2140
movq -0x78(%rbp), %rdi
movq -0x8(%rbp), %rax
movl $0x1, 0x20(%rax)
callq 0x10670
movq -0x70(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, -0x68(%rbp)
movq %rsi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x2, (%rax)
je 0x14999
movq 0xc689(%rip), %rax      # 0x20ff8
movq (%rax), %rdi
leaq 0x7969(%rip), %rsi      # 0x1c2e2
movb $0x0, %al
callq 0x2140
movq -0x70(%rbp), %rdi
movq -0x8(%rbp), %rax
movl $0x1, 0x20(%rax)
callq 0x10670
jmp 0x14a75
callq 0x11820
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
cmpl $0x2, -0xc(%rbp)
jne 0x14a07
movq -0x18(%rbp), %rax
cmpl $0x2, 0x28(%rax)
je 0x149f1
movq 0xc631(%rip), %rax      # 0x20ff8
movq (%rax), %rdi
leaq 0x7911(%rip), %rsi      # 0x1c2e2
movb $0x0, %al
callq 0x2140
movq -0x70(%rbp), %rdi
movq -0x8(%rbp), %rax
movl $0x1, 0x20(%rax)
callq 0x10670
jmp 0x14a75
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movl 0x30(%rax), %eax
movl %eax, -0x30(%rbp)
jmp 0x14a14
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
subl $0x1, %eax
movl %eax, -0x30(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x30(%rbp), %eax
jg 0x14a64
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x20e0
movl $0x2, -0x60(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x58(%rbp)
movq -0x28(%rbp), %rdi
callq 0x11890
movq %rax, %rdi
leaq -0x60(%rbp), %rsi
movl $0x28, %edx
callq 0x2170
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x14a1a
movq -0x70(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x11900
movq -0x68(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, -0x60(%rbp)
movq %rsi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x4, (%rax)
je 0x14b54
movq 0xc4ce(%rip), %rax      # 0x20ff8
movq (%rax), %rdi
leaq 0x77c6(%rip), %rsi      # 0x1c2fa
movb $0x0, %al
callq 0x2140
movq -0x68(%rbp), %rdi
movq -0x8(%rbp), %rax
movl $0x1, 0x20(%rax)
callq 0x10670
jmp 0x14bf3
movq -0x18(%rbp), %rcx
movq 0x20(%rcx), %rdx
movq %rsp, %rax
movq %rdx, 0x20(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x19410
movq %rax, %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rsi
leaq -0x30(%rbp), %rdx
callq 0x3f60
cmpl $0x0, %eax
jne 0x14bb7
movq -0x30(%rbp), %rdi
callq 0x144c0
movq -0x30(%rbp), %rdi
callq 0x2380
movq -0x68(%rbp), %rdi
movq -0x8(%rbp), %rax
movl $0x1, 0x20(%rax)
callq 0x10670
jmp 0x14bf3
cmpl $0x0, 0xc632(%rip)      # 0x211f0
je 0x14bc9
movq -0x30(%rbp), %rdi
callq 0x8840
movq -0x8(%rbp), %rsi
movq -0x30(%rbp), %rdx
leaq -0x58(%rbp), %rdi
callq 0x119b0
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x30(%rbp), %rsi
callq 0x84a0
movq -0x68(%rbp), %rdi
callq 0x10670
movq -0x60(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x90(%rbp)
movq %rdi, -0x88(%rbp)
movq %rsi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
cmpl $0x1, -0xc(%rbp)
jne 0x14c77
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, (%rax)
je 0x14c77
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rdi
callq 0x2030
movq -0x90(%rbp), %rdi
movq -0x98(%rbp), %rsi
movq %rax, %rdx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x14e10
jmp 0x14d8d
callq 0x131d0
movq %rax, -0x30(%rbp)
movl $0x0, -0x24(%rbp)
movq 0xc352(%rip), %rax      # 0x20fe0
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x14d79
movq 0xc339(%rip), %rax      # 0x20fe0
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x14cc2
jmp 0x14d79
movq -0x38(%rbp), %rdi
movl $0x3d, %esi
callq 0x20c0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x14d69
movl $0x0, -0x44(%rbp)
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rax
subq %rax, %rsi
addq $0x1, %rsi
movl $0x1, %edi
callq 0x2120
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %rax
subq %rax, %rdx
callq 0x2170
movq -0x8(%rbp), %rsi
movq -0x40(%rbp), %rdx
addq $0x1, %rdx
leaq -0x78(%rbp), %rdi
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x14e10
movq -0x30(%rbp), %rdi
movq -0x50(%rbp), %rsi
leaq -0x44(%rbp), %rdx
callq 0x10cd0
movl %eax, -0x7c(%rbp)
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rdi
movl -0x7c(%rbp), %eax
imulq $0x28, %rax, %rax
addq %rax, %rdi
leaq -0x78(%rbp), %rsi
movl $0x28, %edx
callq 0x2170
jmp 0x14d6b
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x14c87
movq -0x90(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x15e60
movq -0x88(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, -0x28(%rbp)
movq %rsi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x2, (%rax)
je 0x14dfe
movq 0xc229(%rip), %rax      # 0x20ff8
movq (%rax), %rdi
leaq 0x7509(%rip), %rsi      # 0x1c2e2
movb $0x0, %al
callq 0x2140
movq -0x30(%rbp), %rdi
movq -0x8(%rbp), %rax
movl $0x1, 0x20(%rax)
callq 0x10670
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rax
movl 0x8(%rax), %edi
callq 0x2230
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, -0x48(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x14e40
movq -0x50(%rbp), %rdi
callq 0x10670
jmp 0x14eec
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x20e0
movl $0x4, -0x40(%rbp)
movl $0x10, %edi
callq 0x2190
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x14e9a
movq 0xc185(%rip), %rax      # 0x20ff8
movq (%rax), %rdi
leaq 0x5d41(%rip), %rsi      # 0x1abbe
movb $0x0, %al
callq 0x2140
movq -0x50(%rbp), %rdi
movq -0x8(%rbp), %rax
movl $0x1, 0x20(%rax)
callq 0x10670
jmp 0x14eec
movq -0x38(%rbp), %rax
movl $0x0, 0xc(%rax)
cmpl $0x0, -0x14(%rbp)
jge 0x14eba
movq -0x10(%rbp), %rdi
callq 0x20b0
movq %rax, -0x58(%rbp)
jmp 0x14ec2
movslq -0x14(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rax
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
leaq -0x40(%rbp), %rsi
movl $0x28, %edx
callq 0x2170
movq -0x48(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mattn[P]orelang/ore.c
// Function: ore_parse_num
static ore_value
ore_parse_num(ore_context* ore, const char* s) {
  ore_value v = {0};
  if (*s == '0' && *(s+1) == 'x') {
    v.t = ORE_TYPE_INT;
    v.v.i = strtol(s, NULL, 16);
  } else if (!strchr(s, '.')) {
    v.t = ORE_TYPE_INT;
    v.v.i = atoi(s);
  } else {
    v.t = ORE_TYPE_FLOAT;
    v.v.d = atof(s);
  }
  return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, %rax
movq %rax, -0x18(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
xorl %esi, %esi
movl $0x28, %edx
callq 0x20e0
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jne 0x15858
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x78, %eax
jne 0x15858
movq -0x20(%rbp), %rax
movl $0x2, (%rax)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x10, %edx
callq 0x2160
movq %rax, %rcx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
jmp 0x158a8
movq -0x10(%rbp), %rdi
movl $0x2e, %esi
callq 0x20c0
cmpq $0x0, %rax
jne 0x1588a
movq -0x20(%rbp), %rax
movl $0x2, (%rax)
movq -0x10(%rbp), %rdi
callq 0x2200
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
jmp 0x158a6
movq -0x20(%rbp), %rax
movl $0x3, (%rax)
movq -0x10(%rbp), %rdi
callq 0x2090
movq -0x20(%rbp), %rax
movsd %xmm0, 0x8(%rax)
jmp 0x158a8
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, -0x40(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x20e0
movl $0x6, -0x38(%rbp)
movl $0x10, %edi
callq 0x2190
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x15ed2
movq 0xb14d(%rip), %rax      # 0x20ff8
movq (%rax), %rdi
leaq 0x4d09(%rip), %rsi      # 0x1abbe
movb $0x0, %al
callq 0x2140
movq -0x48(%rbp), %rdi
movq -0x8(%rbp), %rax
movl $0x1, 0x20(%rax)
callq 0x10670
jmp 0x15efa
movq -0x48(%rbp), %rdi
movq -0x30(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
leaq -0x38(%rbp), %rsi
movl $0x28, %edx
callq 0x2170
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mattn[P]orelang/ore.c
// Function: ore_kind
static const char*
ore_kind(ore_value v) {
  switch (v.t) {
    case ORE_TYPE_NIL:
      return "nil";
    case ORE_TYPE_BOOL:
      return "bool";
    case ORE_TYPE_INT:
      return "int";
    case ORE_TYPE_FLOAT:
      return "float";
    case ORE_TYPE_STRING:
      return "string";
    case ORE_TYPE_CFUNC:
      return "func";
    case ORE_TYPE_FUNC:
      return "func";
    case ORE_TYPE_ARRAY:
      return "array";
    case ORE_TYPE_HASH:
      return "hash";
    case ORE_TYPE_REGEXP:
      return "regexp";
    case ORE_TYPE_ENV:
      return "env";
    case ORE_TYPE_CLASS:
      return "class";
    case ORE_TYPE_CCLASS:
      return "class";
    case ORE_TYPE_OBJECT:
      return "object";
  }
  return "unknown";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x10(%rbp)
subq $0xd, %rax
ja 0x16491
movq -0x10(%rbp), %rax
leaq 0x4699(%rip), %rcx      # 0x1aa5c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x4865(%rip), %rax      # 0x1ac38
movq %rax, -0x8(%rbp)
jmp 0x1649c
leaq 0x5d4f(%rip), %rax      # 0x1c132
movq %rax, -0x8(%rbp)
jmp 0x1649c
leaq 0x5c04(%rip), %rax      # 0x1bff7
movq %rax, -0x8(%rbp)
jmp 0x1649c
leaq 0x4219(%rip), %rax      # 0x1a61c
movq %rax, -0x8(%rbp)
jmp 0x1649c
leaq 0x5bdb(%rip), %rax      # 0x1bfee
movq %rax, -0x8(%rbp)
jmp 0x1649c
leaq 0x489d(%rip), %rax      # 0x1acc0
movq %rax, -0x8(%rbp)
jmp 0x1649c
leaq 0x4890(%rip), %rax      # 0x1acc0
movq %rax, -0x8(%rbp)
jmp 0x1649c
leaq 0x47ff(%rip), %rax      # 0x1ac3c
movq %rax, -0x8(%rbp)
jmp 0x1649c
leaq 0x47fd(%rip), %rax      # 0x1ac47
movq %rax, -0x8(%rbp)
jmp 0x1649c
leaq 0x47f5(%rip), %rax      # 0x1ac4c
movq %rax, -0x8(%rbp)
jmp 0x1649c
leaq 0x5b83(%rip), %rax      # 0x1bfe7
movq %rax, -0x8(%rbp)
jmp 0x1649c
leaq 0x485d(%rip), %rax      # 0x1acce
movq %rax, -0x8(%rbp)
jmp 0x1649c
leaq 0x4850(%rip), %rax      # 0x1acce
movq %rax, -0x8(%rbp)
jmp 0x1649c
leaq 0x5cac(%rip), %rax      # 0x1c137
movq %rax, -0x8(%rbp)
jmp 0x1649c
leaq 0x5ca6(%rip), %rax      # 0x1c13e
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mattn[P]orelang/ore.c
// Function: ore_expr
static ore_value
ore_expr(ore_context* ore, mpc_ast_t* t) {
  int i;
  ore_value lhs = ore_eval(ore, t->children[0]);
  for (i = 1; i < t->children_num; i += 2) {
    char* op = t->children[i]->contents;
    ore_value rhs = ore_eval(ore, t->children[i+1]);
    lhs = ore_expr0(ore, lhs, op, rhs);
  }
  return lhs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq (%rax), %rdx
callq 0x119b0
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jge 0x16599
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdx
leaq -0x48(%rbp), %rdi
callq 0x119b0
movq -0x80(%rbp), %rcx
movq -0x8(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rdi
movq %rsp, %rax
movq %rdi, 0x48(%rax)
movups -0x48(%rbp), %xmm0
movups -0x38(%rbp), %xmm1
movups %xmm1, 0x38(%rax)
movups %xmm0, 0x28(%rax)
movq 0x20(%rcx), %rdi
movq %rdi, 0x20(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq -0x70(%rbp), %rdi
callq 0x165b0
movq -0x80(%rbp), %rdi
leaq -0x70(%rbp), %rsi
movl $0x28, %edx
callq 0x2170
movl -0x14(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x14(%rbp)
jmp 0x164e9
movq -0x78(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mattn[P]orelang/ore.c
// Function: ore_define_class
static ore_value
ore_define_class(ore_context* ore, mpc_ast_t* tn, mpc_ast_t* tb, const char* base) {
  ore_value v = { ORE_TYPE_CLASS };
  v.v.c = (ore_class*) malloc(sizeof(ore_class));
  if (!v.v.c) {
    fprintf(stderr, "failed to allocate memory\n");
    ore->err = ORE_ERROR_EXCEPTION;
    return ore_value_nil();
  }
  v.v.c->n = strdup(tn->contents);
  if (!v.v.c->n) {
    fprintf(stderr, "failed to allocate memory\n");
    ore->err = ORE_ERROR_EXCEPTION;
    return ore_value_nil();
  }
  v.v.c->t = tb;
  v.v.c->b = base;
  ore_context* g = ore;
  while (g->parent) g = g->parent;
  ore_define(g, v.v.c->n, v);
  return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, -0x58(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
leaq -0x48(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x20e0
movl $0xb, -0x48(%rbp)
movl $0x18, %edi
callq 0x2190
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x17010
movq 0xa012(%rip), %rax      # 0x20ff8
movq (%rax), %rdi
leaq 0x3bce(%rip), %rsi      # 0x1abbe
movb $0x0, %al
callq 0x2140
movq -0x60(%rbp), %rdi
movq -0x8(%rbp), %rax
movl $0x1, 0x20(%rax)
callq 0x10670
jmp 0x170d4
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2240
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, (%rax)
movq -0x40(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x1705f
movq 0x9fc0(%rip), %rax      # 0x20ff8
movq (%rax), %rdi
leaq 0x3b7c(%rip), %rsi      # 0x1abbe
movb $0x0, %al
callq 0x2140
movq -0x60(%rbp), %rdi
movq -0x8(%rbp), %rax
movl $0x1, 0x20(%rax)
callq 0x10670
jmp 0x170d4
movq -0x18(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x17098
movq -0x50(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x50(%rbp)
jmp 0x1707f
movq -0x50(%rbp), %rdi
movq -0x40(%rbp), %rax
movq (%rax), %rsi
movq -0x28(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x20(%rax)
movups -0x48(%rbp), %xmm0
movups -0x38(%rbp), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x11030
movq -0x60(%rbp), %rdi
leaq -0x48(%rbp), %rsi
movl $0x28, %edx
callq 0x2170
movq -0x58(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mattn[P]orelang/ore.c
// Function: ore_find_statements
static mpc_ast_t*
ore_find_statements(mpc_ast_t* t) {
  int i;
  if (is_a(t, "template")) return t;
  for (i = 0; i < t->children_num; i++) {
    if (is_a(t->children[i], "char") && t->children[i]->contents[0] == '{') {
      if (t->children[i+1]->contents[0] != '}') {
        return t->children[i+1];
      }
    }
  }
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x31fb(%rip), %rsi      # 0x1acc5
callq 0x2260
cmpq $0x0, %rax
je 0x17ae2
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x17b90
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jge 0x17b88
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rdi
leaq 0x2b0f(%rip), %rsi      # 0x1a622
callq 0x2260
cmpq $0x0, %rax
je 0x17b78
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movsbl (%rax), %eax
cmpl $0x7b, %eax
jne 0x17b78
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movsbl (%rax), %eax
cmpl $0x7d, %eax
je 0x17b76
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x17b90
jmp 0x17b78
jmp 0x17b7a
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x17ae9
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mattn[P]orelang/ore.c
// Function: ore_cmp_lessmore
static int
ore_cmp_lessmore(ore_context* ore, ore_value lhs, ore_value rhs) {
  if (lhs.t != rhs.t) return 0;
  switch (lhs.t) {
    case ORE_TYPE_INT:
      return lhs.v.i - rhs.v.i;
    case ORE_TYPE_FLOAT:
      return lhs.v.d - rhs.v.d;
    default:
      break;
  }
  fprintf(stderr, "invalid operator\n");
  ore->err = ORE_ERROR_EXCEPTION;
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0x38(%rbp), %rcx
movq %rcx, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq %rdi, -0x10(%rbp)
movl (%rax), %eax
cmpl (%rcx), %eax
je 0x1841b
movl $0x0, -0x4(%rbp)
jmp 0x1848f
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
subl $0x2, %eax
je 0x18435
jmp 0x1842b
movl -0x24(%rbp), %eax
subl $0x3, %eax
je 0x18448
jmp 0x18463
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
subl 0x8(%rcx), %eax
movl %eax, -0x4(%rbp)
jmp 0x1848f
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movsd 0x8(%rcx), %xmm0
subsd 0x8(%rax), %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x4(%rbp)
jmp 0x1848f
jmp 0x18465
movq 0x8b8c(%rip), %rax      # 0x20ff8
movq (%rax), %rdi
leaq 0x3d62(%rip), %rsi      # 0x1c1d8
movb $0x0, %al
callq 0x2140
movq -0x10(%rbp), %rax
movl $0x1, 0x20(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mattn[P]orelang/ore.c
// Function: ore_match_regexp
static ore_value
ore_match_regexp(ore_context* ore, ore_value lhs, ore_value rhs) {
  if (lhs.t == ORE_TYPE_STRING && rhs.t == ORE_TYPE_REGEXP) {
    struct slre_cap caps[10];
    memset(caps, 0, sizeof(caps));
    if (slre_match(rhs.v.r->p, lhs.v.s->p, lhs.v.s->l, caps, 10, 0) > 0) {
      int i;
      ore_array_t* a = kl_init(value);
      for (i = 0; i < 10; i++) {
        if (caps[i].ptr == NULL) break;
        char* p = calloc(1, caps[i].len + 1);
        memcpy(p, caps[i].ptr, caps[i].len);
        *kl_pushp(value, a) = ore_value_str_from_ptr(ore, p, caps[i].len);
      }
      return ore_value_array_from_klist(ore, a);
    }
  }
  return ore_value_nil();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x110(%rbp)
movq %rdi, -0x108(%rbp)
leaq 0x38(%rbp), %rax
movq %rax, -0x100(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0xf8(%rbp)
movq %rsi, -0x8(%rbp)
cmpl $0x4, (%rax)
jne 0x18678
movq -0x100(%rbp), %rax
cmpl $0x7, (%rax)
jne 0x18678
leaq -0xb0(%rbp), %rdi
xorl %esi, %esi
movl $0xa0, %edx
callq 0x20e0
movq -0x100(%rbp), %rcx
movq -0xf8(%rbp), %rax
movq 0x8(%rcx), %rcx
movq (%rcx), %rdi
movq 0x8(%rax), %rcx
movq (%rcx), %rsi
movq 0x8(%rax), %rax
movl 0x8(%rax), %edx
leaq -0xb0(%rbp), %rcx
movl $0xa, %r8d
xorl %r9d, %r9d
callq 0xe920
cmpl $0x0, %eax
jle 0x18676
callq 0x11820
movq %rax, -0xc0(%rbp)
movl $0x0, -0xb4(%rbp)
cmpl $0xa, -0xb4(%rbp)
jge 0x1865d
movslq -0xb4(%rbp), %rcx
leaq -0xb0(%rbp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
jne 0x18583
jmp 0x1865d
movslq -0xb4(%rbp), %rcx
leaq -0xb0(%rbp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
addl $0x1, %eax
movslq %eax, %rsi
movl $0x1, %edi
callq 0x2120
movq %rax, -0xc8(%rbp)
movq -0xc8(%rbp), %rdi
movslq -0xb4(%rbp), %rcx
leaq -0xb0(%rbp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
movslq -0xb4(%rbp), %rcx
leaq -0xb0(%rbp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
movslq 0x8(%rax), %rdx
callq 0x2170
movq -0xc0(%rbp), %rdi
callq 0x11890
movq %rax, -0x118(%rbp)
movq -0x8(%rbp), %rsi
movq -0xc8(%rbp), %rdx
movslq -0xb4(%rbp), %rcx
leaq -0xb0(%rbp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %ecx
leaq -0xf0(%rbp), %rdi
callq 0x14e10
movq -0x118(%rbp), %rdi
leaq -0xf0(%rbp), %rsi
movl $0x28, %edx
callq 0x2170
movl -0xb4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xb4(%rbp)
jmp 0x18556
movq -0x110(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0xc0(%rbp), %rdx
callq 0x11900
jmp 0x18684
jmp 0x18678
movq -0x110(%rbp), %rdi
callq 0x10670
movq -0x108(%rbp), %rax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mattn[P]orelang/ore.c
// Function: ore_class_new
static ore_value
ore_class_new(ore_context* ore, ore_value clazz) {
  ore_value v = { ORE_TYPE_OBJECT };
  ore_context* this = ore_new(ore);
  v.v.o = (ore_object*) malloc(sizeof(ore_object));
  if (!v.v.o) {
    fprintf(stderr, "failed to allocate memory\n");
    ore->err = ORE_ERROR_EXCEPTION;
    return ore_value_nil();
  }
  if (clazz.v.c->b != NULL) {
    ore_value bc = ore_find_global(ore, clazz.v.c->b);
    if (bc.t == ORE_TYPE_CLASS)
      ore_define(this, "super", ore_class_new(this, bc));
  }
  v.v.o->t = clazz.t;
  v.v.o->c = clazz.v.c;
  v.v.o->e = this;
  v.v.o->ref = -1;
  ore_eval(this, ore_find_statements(clazz.v.c->t));
  ore_define(this, "this", v);
  return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0xc8(%rbp)
movq %rdi, -0xc0(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq %rsi, -0x8(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x20e0
movl $0xd, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x11230
movq %rax, -0x38(%rbp)
movl $0x20, %edi
callq 0x2190
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x18795
movq 0x8890(%rip), %rax      # 0x20ff8
movq (%rax), %rdi
leaq 0x244c(%rip), %rsi      # 0x1abbe
movb $0x0, %al
callq 0x2140
movq -0xc8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl $0x1, 0x20(%rax)
callq 0x10670
jmp 0x188d3
movq -0xb8(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x10(%rax)
je 0x18834
movq -0xb8(%rbp), %rax
movq -0x8(%rbp), %rsi
movq 0x8(%rax), %rax
movq 0x10(%rax), %rdx
leaq -0x60(%rbp), %rdi
callq 0x186a0
cmpl $0xb, -0x60(%rbp)
jne 0x18832
movq -0x38(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x20(%rax)
movups -0x60(%rbp), %xmm0
movups -0x50(%rbp), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq -0x88(%rbp), %rdi
callq 0x18700
movq -0xd0(%rbp), %rdi
movq -0x68(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x20(%rax)
movups -0x88(%rbp), %xmm0
movups -0x78(%rbp), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq 0x39e0(%rip), %rsi      # 0x1c20d
callq 0x11030
jmp 0x18834
movq -0xb8(%rbp), %rax
movl (%rax), %edx
movq -0x28(%rbp), %rcx
movl %edx, (%rcx)
movq 0x8(%rax), %rdx
movq -0x28(%rbp), %rcx
movq %rdx, 0x8(%rcx)
movq -0x38(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq %rdx, 0x10(%rcx)
movq -0x28(%rbp), %rcx
movl $0xffffffff, 0x18(%rcx) # imm = 0xFFFFFFFF
movq -0x38(%rbp), %rcx
movq %rcx, -0xd8(%rbp)
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x17ab0
movq -0xd8(%rbp), %rsi
movq %rax, %rdx
leaq -0xb0(%rbp), %rdi
callq 0x119b0
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x20(%rax)
movups -0x30(%rbp), %xmm0
movups -0x20(%rbp), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq 0x395a(%rip), %rsi      # 0x1c213
callq 0x11030
movq -0xc8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl $0x28, %edx
callq 0x2170
movq -0xc0(%rbp), %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mattn[P]orelang/./kstring.h
// Function: kputc
static inline int kputc(int c, kstring_t *s)
{
	if (s->l + 1 >= s->m) {
		char *tmp;
		s->m = s->l + 2;
		kroundup32(s->m);
		if ((tmp = (char*)realloc(s->s, s->m)))
			s->s = tmp;
		else
			return EOF;
	}
	s->s[s->l++] = c;
	s->s[s->l] = 0;
	return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
addq $0x1, %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jb 0x1925a
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x2, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
shrq %rcx
movq -0x10(%rbp), %rax
orq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
shrq $0x2, %rcx
movq -0x10(%rbp), %rax
orq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
shrq $0x4, %rcx
movq -0x10(%rbp), %rax
orq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
shrq $0x8, %rcx
movq -0x10(%rbp), %rax
orq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
shrq $0x10, %rcx
movq -0x10(%rbp), %rax
orq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x21c0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x1924f
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x19258
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x19294
jmp 0x1925a
movl -0x8(%rbp), %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rsi
movq (%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, (%rsi)
movb %dl, (%rax,%rcx)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movb $0x0, (%rax,%rcx)
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mattn[P]orelang/./kstring.h
// Function: kputsn
static inline int kputsn(const char *p, int l, kstring_t *s)
{
	if (s->l + l + 1 >= s->m) {
		char *tmp;
		s->m = s->l + l + 2;
		kroundup32(s->m);
		if ((tmp = (char*)realloc(s->s, s->m)))
			s->s = tmp;
		else
			return EOF;
	}
	memcpy(s->s + s->l, p, l);
	s->l += l;
	s->s[s->l] = 0;
	return l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
addq %rcx, %rax
addq $0x1, %rax
movq -0x20(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jb 0x193bc
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movslq -0x14(%rbp), %rax
addq %rax, %rcx
addq $0x2, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
shrq %rcx
movq -0x20(%rbp), %rax
orq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
shrq $0x2, %rcx
movq -0x20(%rbp), %rax
orq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
shrq $0x4, %rcx
movq -0x20(%rbp), %rax
orq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
shrq $0x8, %rcx
movq -0x20(%rbp), %rax
orq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
shrq $0x10, %rcx
movq -0x20(%rbp), %rax
orq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x21c0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x193b1
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x193ba
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x193ff
jmp 0x193bc
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x20(%rbp), %rax
addq (%rax), %rdi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x2170
movslq -0x14(%rbp), %rcx
movq -0x20(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rcx
movb $0x0, (%rax,%rcx)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_5/exercise_5_05/strncmp.c
// Function: main
int main(void)
{
  char s[100] = "This is the first string";
  char *t = "This is the second string";
  size_t nr_chars = 13;

  int is_equal = strcmp_ptr(s, t, nr_chars);

  if (is_equal == 0)
  {
    puts("String s is equal with string t.");
  }
  else if (is_equal > 0)
  {
    puts("String s contains more chars than string t.");
  }
  else if (is_equal < 0)
  {
    puts("String s contains less chars than string t.");
  }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x70(%rbp), %rdi
leaq 0xea3(%rip), %rsi       # 0x2010
movl $0x64, %edx
callq 0x1040
leaq 0xef6(%rip), %rax       # 0x2074
movq %rax, -0x78(%rbp)
movq $0xd, -0x80(%rbp)
leaq -0x70(%rbp), %rdi
movq -0x78(%rbp), %rsi
movq -0x80(%rbp), %rdx
callq 0x1200
movl %eax, -0x84(%rbp)
cmpl $0x0, -0x84(%rbp)
jne 0x11b8
leaq 0xedd(%rip), %rdi       # 0x208e
callq 0x1030
jmp 0x11e8
cmpl $0x0, -0x84(%rbp)
jle 0x11cf
leaq 0xee7(%rip), %rdi       # 0x20af
callq 0x1030
jmp 0x11e6
cmpl $0x0, -0x84(%rbp)
jge 0x11e4
leaq 0xefc(%rip), %rdi       # 0x20db
callq 0x1030
jmp 0x11e6
jmp 0x11e8
xorl %eax, %eax
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)