LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/pedro-onate[P]eva/eva.c
// Function: es_eval
es_val_t es_eval(es_ctx_t* ctx, es_val_t exp)
{
  struct timeval t0, t1, dt;

  es_val_t env, res;

  env = es_ctx_env(ctx);

  exp = es_macro_expand(ctx, exp, env);

  //es_printf(ctx, "expanded: %@\n", exp);

  es_val_t proc = es_compile(ctx, exp);

  gettimeofday(&t0, NULL);

  res = (es_val_t)es_vm_run(ctx, ES_VM_DISPATCH, proc);

  assert(ctx->fp == 0);

  gettimeofday(&t1, NULL);
  timeval_subtract(&dt, &t1, &t0);
  //printf("time: %f\n", dt.tv_sec * 1000.0 + dt.tv_usec / 1000.0);

  return res;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movq 0x42080(%rdi), %rdx
callq 0x44a7
movq %r14, %rdi
movq %rax, %rsi
callq 0x3b1f
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x1090
movq %r14, %rdi
movl $0x1, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x46e8
cmpl $0x0, 0x42078(%r14)
jne 0x43ad
movq %rax, %rbx
leaq 0x18(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x1090
movq 0x8(%r14), %rcx
movq 0x10(%rsp), %rdi
movq %rdi, %rax
movabsq $0x431bde82d7b634db, %rsi # imm = 0x431BDE82D7B634DB
subq %rcx, %rax
jle 0x4365
imulq %rsi
movq %rdx, %rax
shrq $0x12, %rax
shrq $0x3f, %rdx
addl %edx, %eax
incl %eax
imull $0xf4240, %eax, %edx    # imm = 0xF4240
movslq %edx, %rdx
subq %rdx, %rdi
movq %rdi, 0x10(%rsp)
cltq
addq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
subq %rdi, %rcx
cmpq $0xf4241, %rcx          # imm = 0xF4241
jl 0x43a2
movq %rcx, %rax
mulq %rsi
shrq $0x12, %rdx
movabsq $0xf424000000000, %rax  # imm = 0xF424000000000
imulq %rdx, %rax
sarq $0x20, %rax
addq %rdi, %rax
movq %rax, 0x10(%rsp)
movslq %edx, %rax
subq %rax, 0x8(%rsp)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x3472(%rip), %rdi      # 0x7826
leaq 0x33d3(%rip), %rsi      # 0x778e
leaq 0x3471(%rip), %rcx      # 0x7833
movl $0xa47, %edx            # imm = 0xA47
callq 0x10a0
// File: /workspace/github_c_makefile_star2_O1/pedro-onate[P]eva/eva.c
// Function: es_macro_expand_list
es_val_t es_macro_expand_list(es_ctx_t* ctx, es_val_t lst, es_val_t env)
{
  //es_printf(ctx, "macro-expand-list: %@\n", lst);
  if (es_is_nil(lst)) {
    return lst;
  } else if (es_is_pair(es_cdr(lst))) {
    return es_cons(ctx,
      es_macro_expand(ctx, es_car(lst), env),
      es_macro_expand_list(ctx, es_cdr(lst), env));
  } else {
    return es_cons(ctx, es_macro_expand(ctx, es_car(lst), env),
      es_macro_expand(ctx, es_cdr(lst), env));
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl %r15d, %ecx
andl $0x7, %ecx
cmpq $0x3, %rcx
je 0x43f9
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testq %rcx, %rcx
jne 0x43ff
movl (%r15), %eax
jmp 0x43ff
movl %r15d, %eax
sarl $0x3, %eax
testl %eax, %eax
je 0x4429
movq 0x18(%r15), %r13
movl %r13d, %eax
andl $0x7, %eax
cmpq $0x5, %rax
ja 0x445c
leaq 0x3052(%rip), %rcx      # 0x746c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl (%r13), %r13d
jmp 0x4462
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl $0x1, %r13d
jmp 0x4462
movl $0x3, %r13d
jmp 0x4462
sarl $0x3, %r13d
jmp 0x4462
movl $0x2, %r13d
jmp 0x4462
movl $0x4, %r13d
jmp 0x4462
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
movq 0x10(%r15), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x44a7
movq %rax, %r12
movq 0x18(%r15), %rsi
movq %rbx, %rdi
movq %r14, %rdx
cmpl $0x6, %r13d
jne 0x448b
callq 0x43cc
jmp 0x4490
callq 0x44a7
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x22f7
// File: /workspace/github_c_makefile_star2_O1/pedro-onate[P]eva/eva.c
// Function: es_macro_expand
es_val_t es_macro_expand(es_ctx_t* ctx, es_val_t exp, es_val_t env)
{
  //es_printf(ctx, "macro-expand: %@\n", exp);
  if (!es_is_pair(exp)) {
    return exp;
  }
  es_val_t op = es_car(exp);
  if (es_is_symbol(op)) {
    es_val_t val = es_lookup_symbol(ctx, env, op);
    if (es_is_macro(val)) {
      es_val_t trans = es_macro_transformer(val);
      return es_macro_expand(ctx, es_apply(ctx, trans, es_cdr(exp)), env);
    } else {
      return es_macro_expand_list(ctx, exp, env);
    }
  } else {
    return es_macro_expand_list(ctx, exp, env);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x2ff2(%rip), %r12      # 0x74b4
leaq 0x2fd3(%rip), %r13      # 0x749c
leaq 0x2fb4(%rip), %rbp      # 0x7484
movl %r15d, %eax
andl $0x7, %eax
cmpq $0x5, %rax
ja 0x450f
movslq (%rbp,%rax,4), %rax
addq %rbp, %rax
jmpq *%rax
movl (%r15), %eax
jmp 0x4514
movl $0x1, %eax
jmp 0x4514
movl $0x3, %eax
jmp 0x4514
movl %r15d, %eax
sarl $0x3, %eax
jmp 0x4514
movl $0x2, %eax
jmp 0x4514
movl $0x4, %eax
jmp 0x4514
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x6, %eax
jne 0x45eb
movq 0x10(%r15), %rdx
movl %edx, %eax
andl $0x7, %eax
cmpq $0x5, %rax
ja 0x455d
movslq (%r13,%rax,4), %rax
addq %r13, %rax
jmpq *%rax
movl (%rdx), %eax
jmp 0x4562
movl $0x1, %eax
jmp 0x4562
movl $0x3, %eax
jmp 0x4562
movl %edx, %eax
sarl $0x3, %eax
jmp 0x4562
movl $0x2, %eax
jmp 0x4562
movl $0x4, %eax
jmp 0x4562
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x3, %eax
jne 0x45cf
movq %r14, %rdi
movq %rbx, %rsi
callq 0x32de
movl %eax, %ecx
andl $0x7, %ecx
cmpq $0x5, %rcx
ja 0x45ad
movslq (%r12,%rcx,4), %rcx
addq %r12, %rcx
jmpq *%rcx
movl (%rax), %ecx
jmp 0x45b2
movl $0x1, %ecx
jmp 0x45b2
movl $0x3, %ecx
jmp 0x45b2
movl %eax, %ecx
sarl $0x3, %ecx
jmp 0x45b2
movl $0x2, %ecx
jmp 0x45b2
movl $0x4, %ecx
jmp 0x45b2
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpl $0x14, %ecx
jne 0x45cf
movq 0x10(%rax), %rsi
movq 0x18(%r15), %rdx
movq %r14, %rdi
callq 0x45fd
movq %rax, %r15
jmp 0x44d0
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x43cc
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/pedro-onate[P]eva/eva.c
// Function: es_apply
es_val_t es_apply(es_ctx_t* ctx, es_val_t proc, es_val_t args)
{
  es_val_t bc = ctx->bytecode;
  int argc = 0;
  while(!es_is_nil(args)) {
    push(ctx, es_car(args));
    args = es_cdr(args);
    argc++;
  }

  push(ctx, proc);

  int start = bytecode_label(bc);
  emit_call(bc, argc);
  emit_halt(bc);

  es_val_t thunk = es_make_proc(ctx, 0, 0, start, bytecode_label(bc));

  es_val_t res = (es_val_t)es_vm_run(ctx, ES_VM_DISPATCH, thunk);

  return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x42060(%rdi), %r14
xorl %ebp, %ebp
movl %edx, %ecx
andl $0x7, %ecx
cmpq $0x3, %rcx
je 0x4629
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testq %rcx, %rcx
jne 0x462e
movl (%rdx), %eax
jmp 0x462e
movl %edx, %eax
sarl $0x3, %eax
testl %eax, %eax
je 0x4653
movq 0x10(%rdx), %rax
movq 0x42070(%rbx), %rcx
leaq 0x8(%rcx), %rdi
movq %rdi, 0x42070(%rbx)
movq %rax, (%rcx)
movq 0x18(%rdx), %rdx
incl %ebp
jmp 0x4610
movq 0x42070(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x42070(%rbx)
movq %rsi, (%rax)
movl 0x8024(%r14), %r15d
xorl %edi, %edi
xorl %esi, %esi
movl $0xb, %edx
xorl %eax, %eax
callq 0x46e8
movq (%rax), %rsi
movzwl %bp, %edx
movq %r14, %rdi
callq 0x5a22
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x46e8
movq (%rax), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x5a22
movl 0x8024(%r14), %ebp
movl $0x20, %edx
movq %rbx, %rdi
movl $0x11, %esi
callq 0x2177
movq $0x0, 0x10(%rax)
movl %r15d, 0x18(%rax)
movl %ebp, 0x1c(%rax)
movq %rbx, %rdi
movl $0x1, %esi
movq %rax, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x46e8
// File: /workspace/github_c_makefile_star2_O1/pedro-onate[P]eva/eva.c
// Function: main
int main()
{
  es_ctx_t* ctx = es_ctx_new(64 * MB);

  es_ctx_set_iport(ctx, es_make_port(ctx, stdin));
  es_ctx_set_oport(ctx, es_make_port(ctx, stdout));

  es_printf(ctx, ".--------------.\n");
  es_printf(ctx, "|  Eva v%s  |\n", ES_VERSION_STR);
  es_printf(ctx, "'--------------'\n\n");

  es_val_t val = es_undefined;

  es_gc(ctx);

  do {
    es_printf(ctx, "eva> ");
    val = es_read(ctx);
    val = es_eval(ctx, val);
    es_printf(ctx, "%@\n", val);
    es_gc(ctx);
  } while (!es_is_eof_obj(val));

  es_ctx_free(ctx);

  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl $0x3d09000, %edi        # imm = 0x3D09000
callq 0x129c
movq %rax, %rbx
movq 0x601d(%rip), %rax      # 0xafe0
movq (%rax), %r15
movl $0x1848, %edx           # imm = 0x1848
movq %rbx, %rdi
movl $0xc, %esi
callq 0x2177
movq %rax, %r14
movq %r15, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x24(%rax)
movups %xmm0, 0x34(%rax)
movl $0x10000, %ebp          # imm = 0x10000
movl %ebp, 0x20(%rax)
movl $0x10000, %edi          # imm = 0x10000
callq 0x1100
movq %rax, 0x18(%r14)
movq %r14, 0x42050(%rbx)
movq 0x5fca(%rip), %rax      # 0xafd8
movq (%rax), %r15
movl $0x1848, %edx           # imm = 0x1848
movq %rbx, %rdi
movl $0xc, %esi
callq 0x2177
movq %rax, %r14
movq %r15, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x24(%rax)
movups %xmm0, 0x34(%rax)
movl %ebp, 0x20(%rax)
movl $0x10000, %edi          # imm = 0x10000
callq 0x1100
movq %rax, 0x18(%r14)
movq %r14, 0x42058(%rbx)
leaq 0x2806(%rip), %rsi      # 0x785a
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1917
leaq 0x2807(%rip), %rsi      # 0x786c
leaq 0x280f(%rip), %rdx      # 0x787b
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1917
leaq 0x2804(%rip), %rsi      # 0x7881
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1917
movq %rbx, %rdi
callq 0x362f
leaq 0x27fe(%rip), %r14      # 0x7894
leaq 0x27fd(%rip), %r15      # 0x789a
leaq 0x24d0(%rip), %r13      # 0x7574
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x1917
movq 0x42050(%rbx), %rsi
movq %rbx, %rdi
callq 0x2466
movq %rbx, %rdi
movq %rax, %rsi
callq 0x42be
movq %rax, %r12
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1917
movq %rbx, %rdi
callq 0x362f
movl %r12d, %eax
andl $0x7, %eax
cmpq $0x5, %rax
ja 0x5128
movslq (%r13,%rax,4), %rax
addq %r13, %rax
jmpq *%rax
movl (%r12), %r12d
jmp 0x512e
movl $0x1, %r12d
jmp 0x512e
movl $0x3, %r12d
jmp 0x512e
sarl $0x3, %r12d
jmp 0x512e
movl $0x2, %r12d
jmp 0x512e
movl $0x4, %r12d
jmp 0x512e
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
cmpl $0x7, %r12d
jne 0x50a4
movq %rbx, %rdi
callq 0x1030
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/pedro-onate[P]eva/eva.c
// Function: fn_mem_stats
static es_val_t fn_mem_stats(es_ctx_t* ctx, int argc, es_val_t argv[])
{
  size_t used = ctx->heap.next - ctx->heap.from_space;
  printf("heap size: %ld\n", ctx->heap.size);
  printf("allocated: %ld\n", used);

  return es_void;
}

// Assembly:
pushq %rbx
movq 0x8(%rdi), %rsi
movq 0x10(%rdi), %rbx
subq 0x18(%rdi), %rbx
leaq 0x28bb(%rip), %rdi      # 0x7a20
xorl %eax, %eax
callq 0x1080
leaq 0x28bd(%rip), %rdi      # 0x7a30
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1080
movl $0x5b, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/pedro-onate[P]eva/eva.c
// Function: fn_compile
static es_val_t fn_compile(es_ctx_t* ctx, int argc, es_val_t argv[])
{
  es_val_t b = es_make_bytecode(ctx);
  compile(ctx, b, argv[0], 0, 0, es_nil);
  emit_halt(b);
  return b;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %r15
movl $0x8028, %edx           # imm = 0x8028
movl $0x12, %esi
callq 0x2177
movq %rax, %rbx
movl $0x4000, %edi           # imm = 0x4000
callq 0x1100
movq %rax, 0x8018(%rbx)
movq $0x400, 0x8020(%rbx) # imm = 0x400
movq $0x1000, 0x8010(%rbx) # imm = 0x1000
movq (%r14), %rdx
movl $0x3, %r9d
movq %r15, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x3b91
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x46e8
movq (%rax), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x5a22
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/pedro-onate[P]eva/eva.c
// Function: fn_close
static es_val_t fn_close(es_ctx_t* ctx, int argc, es_val_t argv[])
{
  es_port_t* port = es_port_val(argv[0]);
  fclose(port->stream);
  port->stream = NULL;
  return es_void;
}

// Assembly:
pushq %rbx
movq (%rdx), %rbx
movq 0x10(%rbx), %rdi
callq 0x1060
movq $0x0, 0x10(%rbx)
movl $0x5b, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/pedro-onate[P]eva/eva.c
// Function: fn_apply
static es_val_t fn_apply(es_ctx_t* ctx, int argc, es_val_t argv[])
{
  es_val_t proc = argv[0];
  es_val_t args = argv[1];

  es_val_t b = ctx->bytecode;
  int start = bytecode_label(b);
  emit_pop(b);

  int nargs = 0;
  while (!es_is_nil(args)) {
    emit_const(b, alloc_const(b, es_car(args)));
    args = es_cdr(args);
    nargs++;
  }

  emit_const(b, alloc_const(b, proc));
  emit_tail_call(b, nargs);
  save(ctx);
  ctx->ip = es_bytecode_val(b)->inst + start;

  return es_void;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdx), %rax
movq %rax, (%rsp)
movq 0x8(%rdx), %r12
movq 0x42060(%rdi), %r14
movslq 0x8024(%r14), %r13
xorl %edi, %edi
xorl %esi, %esi
movl $0x2, %edx
xorl %eax, %eax
callq 0x46e8
movq (%rax), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x5a22
xorl %r15d, %r15d
movl %r12d, %ecx
andl $0x7, %ecx
cmpq $0x3, %rcx
je 0x578e
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testq %rcx, %rcx
jne 0x5794
movl (%r12), %eax
jmp 0x5794
movl %r12d, %eax
sarl $0x3, %eax
testl %eax, %eax
je 0x57cf
movq 0x10(%r12), %rsi
movq %r14, %rdi
callq 0x59c8
movl %eax, %ebp
xorl %edi, %edi
xorl %esi, %esi
movl $0x1, %edx
xorl %eax, %eax
callq 0x46e8
movq (%rax), %rsi
movzwl %bp, %edx
movq %r14, %rdi
callq 0x5a22
movq 0x18(%r12), %r12
incl %r15d
jmp 0x5772
movq %r14, %rdi
movq (%rsp), %rsi
callq 0x59c8
movl %eax, %r12d
xorl %edi, %edi
xorl %esi, %esi
movl $0x1, %edx
xorl %eax, %eax
callq 0x46e8
movq (%rax), %rsi
movl $0xffff, %ebp           # imm = 0xFFFF
andl %ebp, %r12d
movq %r14, %rdi
movq %r12, %rdx
callq 0x5a22
xorl %edi, %edi
xorl %esi, %esi
movl $0xc, %edx
xorl %eax, %eax
callq 0x46e8
movq (%rax), %rsi
andl %ebp, %r15d
movq %r14, %rdi
movq %r15, %rdx
callq 0x5a22
movq 0x42088(%rbx), %rax
movslq 0x42078(%rbx), %rcx
leal 0x1(%rcx), %edx
shlq $0x4, %rcx
movq %rax, 0x4a090(%rbx,%rcx)
movq 0x42068(%rbx), %rax
movq %rax, 0x4a098(%rbx,%rcx)
movl %edx, 0x42078(%rbx)
shlq $0x4, %r13
addq 0x8018(%r14), %r13
movq %r13, 0x42068(%rbx)
movl $0x5b, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/pedro-onate[P]eva/eva.c
// Function: fn_string_ref
static es_val_t fn_string_ref(es_ctx_t* ctx, int argc, es_val_t argv[])
{
  es_val_t str = argv[0];
  int k = es_fixnum_val(argv[1]);
  int c = es_string_ref(str, k);
  return es_make_char(c);
}

// Assembly:
movq (%rdx), %rax
movl 0x8(%rdx), %ecx
sarl $0x3, %ecx
movslq %ecx, %rcx
movsbq 0x18(%rax,%rcx), %rax
leaq 0x5(,%rax,8), %rax
retq
// File: /workspace/github_c_makefile_star2_O1/pedro-onate[P]eva/eva.c
// Function: alloc_const
static int alloc_const(es_val_t code, es_val_t v)
{
  es_bytecode_t* b = es_bytecode_val(code);
  assert(b->next_const < b->cpool_size);
  for(int i = 0; i < b->next_const; i++) {
    if (es_is_eq(v, b->consts[i]))
      return i;
  }
  b->consts[b->next_const] = v;
  return b->next_const++;
}

// Assembly:
pushq %rax
movl 0x8014(%rdi), %eax
cmpl 0x8010(%rdi), %eax
jge 0x5a03
testl %eax, %eax
jle 0x59ec
xorl %ecx, %ecx
cmpq %rsi, 0x10(%rdi,%rcx,8)
je 0x59ff
incq %rcx
cmpq %rcx, %rax
jne 0x59dd
movslq %eax, %rcx
movq %rsi, 0x10(%rdi,%rcx,8)
leal 0x1(%rax), %ecx
movl %ecx, 0x8014(%rdi)
jmp 0x5a01
movl %ecx, %eax
popq %rcx
retq
leaq 0x2036(%rip), %rdi      # 0x7a40
leaq 0x1d7d(%rip), %rsi      # 0x778e
leaq 0x2046(%rip), %rcx      # 0x7a5e
movl $0x62c, %edx            # imm = 0x62C
callq 0x10a0
// File: /workspace/github_c_makefile_star2_O1/pedro-onate[P]eva/eva.c
// Function: emit
static void emit(es_val_t code, es_inst_t inst)
{
  es_bytecode_t* b = es_bytecode_val(code);
  if (b->next_inst >= b->inst_size) {
    b->inst_size += b->inst_size / 2;
    b->inst = realloc(b->inst, b->inst_size);
  }

  b->inst[b->next_inst++] = inst;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl 0x8020(%rdi), %eax
cmpl %eax, 0x8024(%rdi)
jl 0x5a66
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
movl %ecx, 0x8020(%r15)
movq 0x8018(%r15), %rdi
movslq %ecx, %rsi
callq 0x1110
movq %rax, 0x8018(%r15)
movq 0x8018(%r15), %rax
movslq 0x8024(%r15), %rcx
leal 0x1(%rcx), %edx
movl %edx, 0x8024(%r15)
shlq $0x4, %rcx
movq %r14, (%rax,%rcx)
movq %rbx, 0x8(%rax,%rcx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/pedro-onate[P]eva/eva.c
// Function: print_inst
static void print_inst(es_ctx_t* ctx, es_val_t port, es_inst_t* inst)
{
  es_inst_info_t* i = es_vm_run(NULL, ES_VM_FETCH_OPCODE, inst->opcode);
  switch(i->arity) {
  case 0:
    es_port_printf(ctx, port, "%s", i->name);
    break;
  case 1:
    es_port_printf(ctx, port, "%s %d", i->name, inst->operand1);
    break;
  case 2:
    es_port_printf(ctx, port, "%s %d %d", i->name, inst->operand1, inst->operand2);
    break;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdx), %rdx
xorl %edi, %edi
xorl %esi, %esi
xorl %eax, %eax
callq 0x46e8
movl 0x10(%rax), %ecx
cmpl $0x2, %ecx
je 0x5afd
cmpl $0x1, %ecx
je 0x5adb
testl %ecx, %ecx
jne 0x5b24
movq 0x8(%rax), %rcx
leaq 0x201f(%rip), %rdx      # 0x7ae8
movq %r14, %rdi
movq %rbx, %rsi
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x2016
movq 0x8(%rax), %rcx
movswl 0x8(%r15), %r8d
leaq 0x2063(%rip), %rdx      # 0x7b4e
movq %r14, %rdi
movq %rbx, %rsi
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x2016
movq 0x8(%rax), %rcx
movswl 0x8(%r15), %r8d
movswl 0xa(%r15), %r9d
leaq 0x2042(%rip), %rdx      # 0x7b54
movq %r14, %rdi
movq %rbx, %rsi
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x2016
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/pedro-onate[P]eva/eva.c
// Function: peek
static es_token_t peek(es_val_t port, char* pbuf)
{
  es_port_mark(port);
  es_token_t t = next(port, pbuf);
  es_port_reset(port);
  return t;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x24(%rdi), %eax
movslq 0x40(%rdi), %rcx
leaq (%rcx,%rcx,2), %rdx
movl %eax, 0x48(%rdi,%rdx,8)
movq 0x30(%rdi), %rax
movq %rax, 0x50(%rdi,%rdx,8)
movl 0x38(%rdi), %eax
movl %eax, 0x58(%rdi,%rdx,8)
movl 0x3c(%rdi), %eax
movl %eax, 0x5c(%rdi,%rdx,8)
leal 0x1(%rcx), %eax
movl %eax, 0x40(%rdi)
callq 0x5b2a
movl %eax, %ebp
movq %rbx, %rdi
callq 0x290d
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/pedro-onate[P]eva/eva.c
// Function: step
static lstate_t step(lstate_t s, int c)
{
  if (s == lstate_start) {
    if (strchr("+-", c)) s = lstate_sign;
    else if (isdigit(c)) s = lstate_int;
    else if ('.' == c)   s = lstate_dot;
    else                 s = lstate_sym;
  } else if (s == lstate_sign) {
    s = isdigit(c) ? lstate_int : lstate_sym;
  } else if (s == lstate_int) {
    if (!isdigit(c) && !eot(c)) s = lstate_sym;
  } else if (s == lstate_dot && !eot(c)) {
    s = lstate_sym;
  }
  return s;
}

// Assembly:
cmpl $0x3, %edi
ja 0x5fce
pushq %rbx
movl %esi, %ebx
movl %edi, %eax
leaq 0x17fc(%rip), %rcx      # 0x76e4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1cf8(%rip), %rdi      # 0x7bf0
movl $0x3, %edx
movl %ebx, %esi
callq 0x10d0
movq %rax, %rcx
movl $0x1, %eax
testq %rcx, %rcx
jne 0x5fcc
callq 0x1190
movq (%rax), %rcx
movslq %ebx, %rdx
movl $0x2, %eax
testb $0x8, 0x1(%rcx,%rdx,2)
jne 0x5fcc
xorl %eax, %eax
cmpl $0x2e, %ebx
setne %al
addl $0x3, %eax
jmp 0x5fcc
callq 0x1190
movq (%rax), %rcx
movslq %ebx, %rdx
movl $0x2, %eax
testb $0x8, 0x1(%rcx,%rdx,2)
jne 0x5fcc
leaq 0x1c84(%rip), %rdi      # 0x7be2
movl $0xb, %edx
movl %ebx, %esi
callq 0x10d0
xorl %ecx, %ecx
testq %rax, %rax
sete %cl
cmpl $-0x1, %ebx
leal 0x2(%rcx,%rcx), %ecx
movl $0x2, %eax
cmovnel %ecx, %eax
jmp 0x5fcc
leaq 0x1c58(%rip), %rdi      # 0x7be2
movl $0xb, %edx
movl %ebx, %esi
callq 0x10d0
testq %rax, %rax
setne %al
cmpl $-0x1, %ebx
sete %cl
orb %al, %cl
movzbl %cl, %ecx
movl $0x4, %eax
subl %ecx, %eax
jmp 0x5fcc
callq 0x1190
movq (%rax), %rax
movslq %ebx, %rcx
xorl %edx, %edx
testb $0x8, 0x1(%rax,%rcx,2)
sete %dl
leal 0x2(,%rdx,2), %eax
popq %rbx
retq
movl $0x4, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/pedro-onate[P]eva/eva.c
// Function: compile_seq
static es_val_t compile_seq(es_ctx_t* ctx, es_val_t bc, es_val_t seq, int tail_pos, int next, es_val_t scope)
{
  while(!es_is_nil(es_cdr(seq))) {
    compile(ctx, bc, es_car(seq), 0, 0, scope);
    emit_pop(bc);
    seq = es_cdr(seq);
  }
  compile(ctx, bc, es_car(seq), tail_pos, next, scope);
  return es_void;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r13
movq 0x18(%r12), %rax
movl %eax, %edx
andl $0x7, %edx
cmpq $0x3, %rdx
je 0x6223
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testq %rdx, %rdx
jne 0x6228
movl (%rax), %ecx
jmp 0x6228
sarl $0x3, %eax
movl %eax, %ecx
movq 0x10(%r12), %rdx
testl %ecx, %ecx
je 0x6268
movq %r13, %rdi
movq %r15, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %rbx, %r9
callq 0x3b91
xorl %edi, %edi
xorl %esi, %esi
movl $0x2, %edx
xorl %eax, %eax
callq 0x46e8
movq (%rax), %rsi
movq %r15, %rdi
xorl %edx, %edx
callq 0x5a22
movq 0x18(%r12), %r12
jmp 0x6205
movq %r13, %rdi
movq %r15, %rsi
movl %r14d, %ecx
movl %ebp, %r8d
movq %rbx, %r9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3b91
// File: /workspace/github_c_makefile_star2_O1/pedro-onate[P]eva/eva.c
// Function: compile_call
static es_val_t compile_call(es_ctx_t* ctx, es_val_t bc, es_val_t exp, int tail_pos, int next, es_val_t scope)
{
  es_val_t op   = es_car(exp);
  es_val_t args = es_cdr(exp);
  int argc      = es_list_length(args);
  compile_args(ctx, bc, args, scope);
  compile(ctx, bc, op, 0, 0, scope);
  if (tail_pos) {
    emit_tail_call(bc, argc);
  } else {
    emit_call(bc, argc);
  }
  return es_void;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movl %ecx, %ebp
movq %rsi, %rbx
movq %rdi, %r12
movq 0x10(%rdx), %r15
movq 0x18(%rdx), %rdx
xorl %r13d, %r13d
movq %rdx, %rax
movl %eax, %esi
andl $0x7, %esi
cmpq $0x3, %rsi
je 0x62c7
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testq %rsi, %rsi
jne 0x62cc
movl (%rax), %ecx
jmp 0x62cc
movl %eax, %ecx
sarl $0x3, %ecx
testl %ecx, %ecx
je 0x62d9
movq 0x18(%rax), %rax
incl %r13d
jmp 0x62ae
movq %r12, %rdi
movq %rbx, %rsi
movq %r14, %rcx
callq 0x64aa
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %r14, %r9
callq 0x3b91
movzwl %r13w, %r14d
cmpl $0x1, %ebp
movl $0xc, %edx
sbbl $0x0, %edx
xorl %edi, %edi
xorl %esi, %esi
xorl %eax, %eax
callq 0x46e8
movq (%rax), %rsi
movq %rbx, %rdi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5a22
// File: /workspace/github_c_makefile_star2_O1/pedro-onate[P]eva/eva.c
// Function: flatten_args
static es_val_t flatten_args(es_ctx_t* ctx, es_val_t args)
{
  if (es_is_nil(args)) {
    return es_nil;
  } else if (es_is_symbol(args)) {
    return es_cons(ctx, args, es_nil);
  } else {
    return es_cons(ctx, es_car(args), flatten_args(ctx, es_cdr(args)));
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, %eax
andl $0x7, %eax
cmpq $0x3, %rax
je 0x6353
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testq %rax, %rax
jne 0x6358
movl (%rsi), %ecx
jmp 0x6358
movl %esi, %ecx
sarl $0x3, %ecx
testl %ecx, %ecx
je 0x6376
cmpq $0x5, %rax
ja 0x63a6
leaq 0x13bb(%rip), %rcx      # 0x7724
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl (%rsi), %eax
jmp 0x63ab
movl $0x3, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x1, %eax
jmp 0x63ab
movl $0x3, %eax
jmp 0x63ab
movl %esi, %eax
sarl $0x3, %eax
jmp 0x63ab
movl $0x2, %eax
jmp 0x63ab
movl $0x4, %eax
jmp 0x63ab
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x3, %eax
jne 0x63ba
movl $0x3, %edx
movq %rbx, %rdi
jmp 0x63d3
movq 0x10(%rsi), %r14
movq 0x18(%rsi), %rsi
movq %rbx, %rdi
callq 0x6333
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x22f7
// File: /workspace/github_c_makefile_star2_O1/pedro-onate[P]eva/eva.c
// Function: arg_idx
static int arg_idx(es_val_t scope, es_val_t symbol, int* pidx, int* pdepth)
{
  int idx   = -1;
  int depth = 0;

  while(!es_is_nil(scope)
    && (idx = index_of(scope_args(scope), symbol)) == -1
    && !es_is_nil((scope = scope_parent(scope)))
  ) {
    depth++;
  }
  if (idx == -1) return 0;
  *pidx   = idx;
  *pdepth = depth;
  return 1;
}

// Assembly:
xorl %eax, %eax
movl %edi, %r9d
andl $0x7, %r9d
cmpq $0x3, %r9
je 0x63fe
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
testq %r9, %r9
jne 0x6405
movl (%rdi), %r8d
jmp 0x6405
movl %edi, %r8d
sarl $0x3, %r8d
testl %r8d, %r8d
je 0x6490
leaq 0x10(%rdi), %r9
xorl %r8d, %r8d
movq (%r9), %r9
movl %r9d, %r11d
andl $0x7, %r11d
cmpq $0x3, %r11
je 0x6435
movl $0xffffffff, %r10d      # imm = 0xFFFFFFFF
testq %r11, %r11
jne 0x643c
movl (%r9), %r10d
jmp 0x643c
movl %r9d, %r10d
sarl $0x3, %r10d
testl %r10d, %r10d
je 0x6450
cmpq %rsi, 0x10(%r9)
je 0x6456
incl %r8d
addq $0x18, %r9
jmp 0x6415
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
cmpl $-0x1, %r8d
jne 0x6496
movq 0x18(%rdi), %rdi
movl %edi, %r9d
andl $0x7, %r9d
cmpq $0x3, %r9
je 0x647d
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
testq %r9, %r9
jne 0x6484
movl (%rdi), %r8d
jmp 0x6484
movl %edi, %r8d
sarl $0x3, %r8d
testl %r8d, %r8d
je 0x6490
incl %eax
jmp 0x63e1
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
cmpl $-0x1, %r8d
je 0x64a7
movl %r8d, (%rdx)
movl %eax, (%rcx)
movl $0x1, %eax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/pedro-onate[P]eva/eva.c
// Function: compile_args
static es_val_t compile_args(es_ctx_t* ctx, es_val_t bc, es_val_t args, es_val_t scope)
{
  if (!es_is_nil(args)) {
    compile(ctx, bc, es_car(args), 0, 0, scope);
    compile_args(ctx, bc, es_cdr(args), scope);
  }
  return es_void;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl %r14d, %ecx
andl $0x7, %ecx
cmpq $0x3, %rcx
je 0x64d9
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testq %rcx, %rcx
jne 0x64df
movl (%r14), %eax
jmp 0x64df
movl %r14d, %eax
sarl $0x3, %eax
testl %eax, %eax
je 0x6500
movq 0x10(%r14), %rdx
movq %r12, %rdi
movq %r15, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %rbx, %r9
callq 0x3b91
movq 0x18(%r14), %r14
jmp 0x64be
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/pedro-onate[P]eva/eva.c
// Function: es_make_args
static es_val_t es_make_args(es_ctx_t* ctx, es_args_t* parent, int arity, int rest, int argc, es_val_t* argv)
{
  gc_root(ctx, parent);
  es_args_t* env = es_alloc(ctx, ES_ARGS_TYPE, sizeof(es_args_t) + argc * sizeof(es_val_t));
  int i = 0;
  env->parent = parent;
  env->size   = argc;
  for(; i < arity; i++)
    env->args[i] = argv[i];
  if (rest && argc > arity) {
    es_val_t iter = env->args[i] = es_cons(ctx, argv[i], es_nil);
    for(int j = i + 1; j < argc; j++) {
      es_set_cdr(iter, es_cons(ctx, argv[j], es_nil));
      iter = es_cdr(iter);
    }
  } else {
    env->args[i] = es_nil;
  }
  gc_unroot(ctx, 1);
  return es_obj_to_val(env);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r15
movl %r8d, %ebp
movl %ecx, 0x8(%rsp)
movl %edx, %r14d
movq %rdi, %rbx
leaq 0x10(%rsp), %r13
movq %rsi, (%r13)
movslq 0x2040(%rdi), %rax
leal 0x1(%rax), %ecx
movl %ecx, 0x2040(%rdi)
movq %r13, 0x40(%rdi,%rax,8)
movslq %r8d, %r12
leaq 0x20(,%r12,8), %rdx
movl $0x10, %esi
callq 0x2177
movl %r14d, %edx
movq %rax, %r14
movq (%r13), %rax
movq %rax, 0x10(%r14)
movl %r12d, 0x18(%r14)
testl %edx, %edx
jle 0x658b
movl %edx, %eax
xorl %r13d, %r13d
movq (%r15,%r13,8), %rcx
movq %rcx, 0x20(%r14,%r13,8)
incq %r13
cmpq %r13, %rax
jne 0x6578
jmp 0x658e
xorl %r13d, %r13d
cmpl $0x0, 0x8(%rsp)
sete %al
cmpl %edx, %ebp
setle %cl
orb %al, %cl
jne 0x65fb
movl %r13d, %eax
movq %rax, 0x8(%rsp)
movq (%r15,%rax,8), %rsi
movl $0x3, %edx
movq %rbx, %rdi
callq 0x22f7
movq %rax, %r12
movq 0x8(%rsp), %rax
movq %r12, 0x20(%r14,%rax,8)
incl %r13d
cmpl %ebp, %r13d
jge 0x6607
leaq (%r15,%rax,8), %r15
addq $0x8, %r15
movq (%r15), %rsi
movl $0x3, %edx
movq %rbx, %rdi
callq 0x22f7
movq %rax, 0x18(%r12)
addq $0x8, %r15
incl %r13d
movq %rax, %r12
cmpl %ebp, %r13d
jl 0x65d5
jmp 0x6607
movl %r13d, %eax
movq $0x3, 0x20(%r14,%rax,8)
decl 0x2040(%rbx)
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/7402[P]randwords/main.c
// Function: print_words
bool print_words(int from_index, int to_index, int words_per_row, int word_count)
{
    bool error = false;
    
    int key_index_size = to_index - from_index + 1;;
    KeyIndex *key_index = (KeyIndex *)calloc(key_index_size, sizeof(KeyIndex));
    
    if (key_index != NULL) {
        bool needs_shuffle = true;
        int next_key_index = 0;
        
        srand((unsigned int)time(NULL));
        for (int k = 0; k < key_index_size; k++) key_index[k].words_index = (short)(from_index + k);
        
        for (int word_num = 1; word_num <= word_count; word_num++) {
            if (needs_shuffle) {
                for (int k = 0; k < key_index_size; k++) key_index[k].rand_key = (short)rand();
                qsort(key_index, key_index_size, sizeof(KeyIndex), compare);
                next_key_index = 0;
                needs_shuffle = false;
            }
            
            printf("%s", word(key_index[next_key_index++].words_index));

            if (word_num % words_per_row == 0 || word_num == word_count) {
                printf("\n");
                
            } else {
                printf(" ");
            }

            if (next_key_index >= key_index_size) needs_shuffle = true;
        }

        free(key_index);
        key_index = NULL;
    }
    
    return error;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, 0x8(%rsp)
movl %edx, 0xc(%rsp)
movl %esi, %ebx
movl %edi, %r15d
subl %edi, %ebx
leal 0x1(%rbx), %r13d
movslq %r13d, %rdi
movl $0x4, %esi
movq %rdi, 0x18(%rsp)
callq 0x1e090
testq %rax, %rax
je 0x1e5e0
movq %rax, %r12
xorl %edi, %edi
callq 0x1e0b0
movl %eax, %edi
callq 0x1e080
movq %rbx, 0x10(%rsp)
testl %ebx, %ebx
js 0x1e510
movl %r15d, %eax
xorl %ecx, %ecx
leal (%rax,%rcx), %edx
movw %dx, 0x2(%r12,%rcx,4)
incq %rcx
cmpq %rcx, %r13
jne 0x1e4ff
cmpl $0x0, 0x8(%rsp)
jle 0x1e5d8
movb $0x1, %bpl
movl $0x1, %r15d
xorl %r14d, %r14d
testb $0x1, %bpl
je 0x1e566
cmpl $0x0, 0x10(%rsp)
js 0x1e548
xorl %ebx, %ebx
callq 0x1e0e0
movw %ax, (%r12,%rbx,4)
incq %rbx
cmpq %rbx, %r13
jne 0x1e536
movl $0x4, %edx
movq %r12, %rdi
movq 0x18(%rsp), %rsi
leaq 0x95(%rip), %rcx        # 0x1e5f1
callq 0x1e060
xorl %ebp, %ebp
xorl %r14d, %r14d
movslq %r14d, %rax
movq %rax, 0x20(%rsp)
incl %r14d
movswl 0x2(%r12,%rax,4), %edi
callq 0x1e602
leaq 0xad1(%rip), %rdi       # 0x1f054
movq %rax, %rsi
xorl %eax, %eax
callq 0x1e070
movl %r15d, %eax
cltd
idivl 0xc(%rsp)
testl %edx, %edx
movl $0x20, %edi
movl $0xa, %eax
cmovel %eax, %edi
movl 0x8(%rsp), %ebx
cmpl %ebx, %r15d
cmovel %eax, %edi
callq 0x1e040
movq 0x20(%rsp), %rax
cmpl 0x10(%rsp), %eax
movzbl %bpl, %ebp
movl $0x1, %eax
cmovgel %eax, %ebp
leal 0x1(%r15), %eax
cmpl %ebx, %r15d
movl %eax, %r15d
jne 0x1e527
movq %r12, %rdi
callq 0x1e030
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/theck01[P]offbrand_lib/src/classes/obint.c
// Function: obint_new
obint * obint_new(int64_t num){

  uint64_t i, ds;
  int64_t partial_num;
  obint *instance;

  /* find the number of digits in the primitive, ensuring at least one for 0
   * case */
  ds = 1;
  partial_num = num/10;
  while(partial_num){
    partial_num /= 10;
    ds++;
  }

  ds = ds ? ds : 1;

  instance = obint_create_default(ds);
  if(num < 0){
    instance->sign = -1;
    num *= -1;
  }

  for(i = 0; i < ds; i++){
    instance->digits[i] = num%10;
    num /= 10;
  }

  return instance;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x9(%rdi), %rax
movl $0x1, %ebx
cmpq $0x13, %rax
jb 0x24d5
movabsq $0x6666666666666667, %rcx # imm = 0x6666666666666667
movq %r14, %rax
imulq %rcx
movq %rdx, %rsi
shrq $0x3f, %rsi
sarq $0x2, %rdx
leaq (%rdx,%rsi), %rax
incq %rbx
addq %rsi, %rdx
addq $0x9, %rdx
cmpq $0x12, %rdx
ja 0x24b3
cmpq $0x1, %rbx
adcq $0x0, %rbx
movq %rbx, %rdi
callq 0x2531
movq %rax, %rcx
testq %r14, %r14
jns 0x24f4
movb $-0x1, 0x8(%rcx)
negq %r14
xorl %esi, %esi
movabsq $-0x3333333333333333, %rdi # imm = 0xCCCCCCCCCCCCCCCD
movq %r14, %rax
mulq %rdi
shrq $0x3, %rdx
leal (%rdx,%rdx), %eax
leal (%rax,%rax,4), %eax
subl %eax, %r14d
movq 0x10(%rcx), %rax
movb %r14b, (%rax,%rsi)
incq %rsi
movq %rdx, %r14
cmpq %rsi, %rbx
jne 0x2500
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/theck01[P]offbrand_lib/src/classes/obint.c
// Function: obint_create_default
obint * obint_create_default(uint64_t num_digits){

  static const char classname[] = "obint";
  obint *new_instance = malloc(sizeof(obint));
  assert(new_instance != NULL);

  /* initialize base class data */
  ob_init_base((obj *)new_instance, &obint_destroy, &obint_hash,
               &obint_compare, &obint_display, classname);

  new_instance->sign = 1; /* positive by default */

  new_instance->digits = malloc(sizeof(int8_t)*num_digits);
  assert(new_instance->digits != NULL);
  memset(new_instance->digits, 0, num_digits);

  new_instance->num_digits = num_digits;

  return new_instance;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x20, %edi
callq 0x1140
testq %rax, %rax
je 0x25a7
movq %rax, %r14
leaq 0x12a9(%rip), %rsi      # 0x37fa
leaq 0x1303(%rip), %rdx      # 0x385b
leaq 0x13eb(%rip), %rcx      # 0x394a
leaq 0x14e5(%rip), %r8       # 0x3a4b
leaq 0x43b8(%rip), %r9       # 0x6925
movq %rax, %rdi
callq 0x5064
movb $0x1, 0x8(%r14)
movq %rbx, %rdi
callq 0x1140
movq %rax, 0x10(%r14)
testq %rax, %rax
je 0x25c6
movq %rax, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x10b0
movq %rbx, 0x18(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x41b2(%rip), %rdi      # 0x6760
leaq 0x3e57(%rip), %rsi      # 0x640c
leaq 0x41b9(%rip), %rcx      # 0x6775
movl $0x167, %edx            # imm = 0x167
callq 0x10a0
leaq 0x41ce(%rip), %rdi      # 0x679b
leaq 0x3e38(%rip), %rsi      # 0x640c
leaq 0x419a(%rip), %rcx      # 0x6775
movl $0x170, %edx            # imm = 0x170
callq 0x10a0
// File: /workspace/github_c_makefile_star2_O1/theck01[P]offbrand_lib/src/classes/obint.c
// Function: obint_value
int64_t obint_value(const obint *a){

  uint64_t i, most_sig;
  int64_t val;

  assert(a != NULL);

  most_sig = obint_most_sig(a);
  val = 0;
  for(i=most_sig; i<= most_sig; i--){
    val *= 10;
    val += a->digits[i];
  }

  return val*a->sign;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x262c
movq 0x10(%rdi), %rcx
movq 0x18(%rdi), %rax
leaq -0x1(%rax), %rdx
cmpq $0x1, %rax
je 0x2607
cmpb $0x0, -0x1(%rcx,%rax)
movq %rdx, %rax
je 0x25f3
xorl %eax, %eax
movq %rdx, %rsi
leaq (%rax,%rax,4), %rax
movsbq (%rcx,%rsi), %r8
leaq (%r8,%rax,2), %rax
decq %rsi
cmpq %rdx, %rsi
jbe 0x260c
movsbq 0x8(%rdi), %rcx
imulq %rcx, %rax
popq %rcx
retq
leaq 0x3dcf(%rip), %rdi      # 0x6402
leaq 0x3dd2(%rip), %rsi      # 0x640c
leaq 0x3ddf(%rip), %rcx      # 0x6420
movl $0x34, %edx
callq 0x10a0
// File: /workspace/github_c_makefile_star2_O1/theck01[P]offbrand_lib/src/classes/obint.c
// Function: obint_most_sig
uint64_t obint_most_sig(const obint *a){

  uint64_t i;

  i = a->num_digits - 1;
  while(!a->digits[i] && i>0) i--;
  return i;
}

// Assembly:
movq 0x10(%rdi), %rcx
movq 0x18(%rdi), %rdx
leaq -0x1(%rdx), %rax
cmpq $0x1, %rdx
je 0x2667
cmpb $0x0, -0x1(%rcx,%rdx)
movq %rax, %rdx
je 0x2653
retq
// File: /workspace/github_c_makefile_star2_O1/theck01[P]offbrand_lib/src/classes/obint.c
// Function: obint_from_string
obint * obint_from_string(const obstring *numstr){

  int8_t offset, sign;

  int32_t num;
  uint32_t strlen, i;
  uint64_t digits;
  obint *instance;

  assert(numstr != NULL);

  strlen = obstring_length(numstr);
  if(obstring_char_at_index(numstr, 0) == '-'){
    sign = -1;
    digits = strlen - 1;
    offset = 1;
  }
  else{
    sign = 1;
    digits = strlen;
    offset = 0;
  }
  assert(strlen > 0);

  instance = obint_create_default(digits);
  instance->sign = sign;
  for(i=0 ; i<digits; i++){
    num = obstring_char_at_index(numstr, i+offset) - '0';
    assert(num >= 0 && num <= 9);
    instance->digits[digits-i-1] = num;
  }

  /* zero is defined to be positive */
  if(obint_is_zero(instance)) instance->sign = 1;

  return instance;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x2733
movq %rdi, %rbx
callq 0x3e1b
movl %eax, %r14d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3e44
movl %eax, %ebp
xorl %eax, %eax
cmpb $0x2d, %bpl
sete %cl
testl %r14d, %r14d
je 0x2752
movb %cl, %al
subl %eax, %r14d
cmpb $0x2d, %bpl
sete %r12b
negb %r12b
orb $0x1, %r12b
movq %r14, %rdi
callq 0x2531
movq %rax, %r15
movb %r12b, 0x8(%rax)
testq %r14, %r14
je 0x26f7
xorl %r12d, %r12d
cmpb $0x2d, %bpl
sete %r12b
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3e44
addb $-0x30, %al
cmpb $0xa, %al
jae 0x2714
movq 0x10(%r15), %rcx
movb %al, -0x1(%rcx,%r14)
incq %r12
decq %r14
jne 0x26d5
movq %r15, %rdi
callq 0x2771
testb %al, %al
je 0x2708
movb $0x1, 0x8(%r15)
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3d6d(%rip), %rdi      # 0x6488
leaq 0x3cea(%rip), %rsi      # 0x640c
leaq 0x3d29(%rip), %rcx      # 0x6452
movl $0x5d, %edx
callq 0x10a0
leaq 0x3d09(%rip), %rdi      # 0x6443
leaq 0x3ccb(%rip), %rsi      # 0x640c
leaq 0x3d0a(%rip), %rcx      # 0x6452
movl $0x4a, %edx
callq 0x10a0
leaq 0x3d24(%rip), %rdi      # 0x647d
leaq 0x3cac(%rip), %rsi      # 0x640c
leaq 0x3ceb(%rip), %rcx      # 0x6452
movl $0x57, %edx
callq 0x10a0
// File: /workspace/github_c_makefile_star2_O1/theck01[P]offbrand_lib/src/classes/obint.c
// Function: obint_is_zero
uint8_t obint_is_zero(const obint *a){

  uint64_t most_sig;

  assert(a != NULL);

  most_sig = obint_most_sig(a);
  return most_sig == 0 && a->digits[0] == 0;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x27a4
movq 0x10(%rdi), %rax
movq 0x18(%rdi), %rcx
leaq -0x1(%rcx), %rdx
cmpq $0x1, %rcx
je 0x2793
cmpb $0x0, -0x1(%rax,%rcx)
movq %rdx, %rcx
je 0x277f
testq %rdx, %rdx
je 0x279c
xorl %eax, %eax
jmp 0x27a2
cmpb $0x0, (%rax)
sete %al
popq %rcx
retq
leaq 0x3c57(%rip), %rdi      # 0x6402
leaq 0x3c5a(%rip), %rsi      # 0x640c
leaq 0x3d2e(%rip), %rcx      # 0x64e7
movl $0x96, %edx
callq 0x10a0
// File: /workspace/github_c_makefile_star2_O1/theck01[P]offbrand_lib/src/classes/obint.c
// Function: obint_to_string
obstring * obint_to_string(const obint *a){

  uint8_t offset = 0;
  uint64_t most_sig, i;
  char *str;
  obstring *result;

  assert(a != NULL);

  if(a->sign == -1) offset = 1;
  most_sig = obint_most_sig(a);
  str = malloc(sizeof(char)*(most_sig+2+offset));

  /* generate cstring from int */
  str[0] = '-'; /* non-negatives will overwrite value in following loop */
  for(i=most_sig; i<=most_sig; i--) str[most_sig-i+offset] = a->digits[i] + '0';
  str[most_sig+1+offset] = '\0';

  result = obstring_new(str);
  free(str);

  return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x285f
movb 0x8(%rdi), %al
movq 0x18(%rdi), %rcx
movq 0x10(%rdi), %r14
incq %rcx
leaq -0x1(%rcx), %r15
cmpq $0x2, %rcx
je 0x27f7
cmpb $0x0, -0x2(%r14,%rcx)
movq %r15, %rcx
je 0x27e2
xorl %r12d, %r12d
cmpb $-0x1, %al
sete %r12b
leaq (%r12,%r15), %rdi
incq %rdi
callq 0x1140
movq %rax, %rbx
movb $0x2d, (%rax)
addq %r12, %rax
leaq -0x1(%r15), %rcx
movq %rcx, %rdx
movb (%r14,%rdx), %sil
addb $0x30, %sil
movb %sil, (%rax)
decq %rdx
incq %rax
cmpq %rcx, %rdx
jbe 0x281c
movq %rbx, %rax
addq %r12, %rax
movb $0x0, (%r15,%rax)
movq %rbx, %rdi
callq 0x3c04
movq %rax, %r14
movq %rbx, %rdi
callq 0x1030
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x3b9c(%rip), %rdi      # 0x6402
leaq 0x3b9f(%rip), %rsi      # 0x640c
leaq 0x3c29(%rip), %rcx      # 0x649d
movl $0x6f, %edx
callq 0x10a0
// File: /workspace/github_c_makefile_star2_O1/theck01[P]offbrand_lib/src/classes/obint.c
// Function: obint_copy
obint * obint_copy(const obint *a){

  uint64_t i, most_sig;
  obint *copy;

  assert(a != NULL);

  most_sig = obint_most_sig(a);

  copy = obint_create_default(most_sig+1);
  for(i=0; i<= most_sig; i++) copy->digits[i] = a->digits[i];
  copy->sign = a->sign;

  return copy;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x28dc
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movq 0x18(%rdi), %rcx
leaq -0x1(%rcx), %r14
cmpq $0x1, %rcx
je 0x28a6
cmpb $0x0, -0x1(%rax,%rcx)
movq %r14, %rcx
je 0x2892
leaq 0x1(%r14), %rdi
callq 0x2531
movq $-0x1, %rcx
movq 0x10(%rbx), %rdx
movb 0x1(%rdx,%rcx), %dl
movq 0x10(%rax), %rsi
movb %dl, 0x1(%rsi,%rcx)
incq %rcx
cmpq %r14, %rcx
jb 0x28b6
movb 0x8(%rbx), %cl
movb %cl, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x3b1f(%rip), %rdi      # 0x6402
leaq 0x3b22(%rip), %rsi      # 0x640c
leaq 0x3bd5(%rip), %rcx      # 0x64c6
movl $0x86, %edx
callq 0x10a0
// File: /workspace/github_c_makefile_star2_O1/theck01[P]offbrand_lib/src/classes/obint.c
// Function: obint_add
obint * obint_add(const obint *a, const obint *b){

  int8_t cmp_result;
  obint *result;

  assert(a != NULL);
  assert(b != NULL);

  /* a and b are  of same sign */
  if((obint_is_negative(a) && obint_is_negative(b)) ||
     (!obint_is_negative(a) && !obint_is_negative(b))){
    result = obint_add_unsigned(a,b);
    result->sign = a->sign;
    return result;
  }

  /* a and b are of opposite sign */
  cmp_result = obint_compare_magnitudes(a,b);
  if(cmp_result == OB_LESS_THAN){
    result = obint_subtract_unsigned(b,a);
    result->sign = b->sign;
    return result;
  }
  else if(cmp_result == OB_GREATER_THAN){
    result = obint_subtract_unsigned(a,b);
    result->sign = a->sign;
    return result;
  }

  /* a and b are equal and opposite, result is 0 */
  return obint_new(0);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x29c2
movq %rsi, %r14
testq %rsi, %rsi
je 0x29e1
movq %rdi, %rbx
movb 0x8(%rdi), %al
cmpb $-0x1, %al
je 0x2954
cmpb $-0x1, 0x8(%r14)
jne 0x2989
jmp 0x295f
cmpb $-0x1, 0x8(%r14)
je 0x2989
cmpb $-0x1, %al
jne 0x294b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2bb5
cmpb $0x1, %al
je 0x29a2
movzbl %al, %eax
cmpl $0xff, %eax
jne 0x29af
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2c16
movb 0x8(%r14), %cl
jmp 0x2997
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2a00
movb 0x8(%rbx), %cl
movb %cl, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2c16
jmp 0x2994
movl $0x1, %edi
callq 0x2531
movq 0x10(%rax), %rcx
movb $0x0, (%rcx)
jmp 0x299a
leaq 0x3a39(%rip), %rdi      # 0x6402
leaq 0x3a3c(%rip), %rsi      # 0x640c
leaq 0x3b5e(%rip), %rcx      # 0x6535
movl $0xa8, %edx
callq 0x10a0
leaq 0x3b7c(%rip), %rdi      # 0x6564
leaq 0x3a1d(%rip), %rsi      # 0x640c
leaq 0x3b3f(%rip), %rcx      # 0x6535
movl $0xa9, %edx
callq 0x10a0
// File: /workspace/github_c_makefile_star2_O1/theck01[P]offbrand_lib/src/classes/obint.c
// Function: obint_compare_magnitudes
int8_t obint_compare_magnitudes(const obint *a, const obint *b){

  uint64_t i,j;

  i = obint_most_sig(a);
  j = obint_most_sig(b);

  if(i < j) return OB_LESS_THAN;
  if(i > j) return OB_GREATER_THAN;

  /* number of digits is equal, resort to digit by digit comparision */
  for( ; i<a->num_digits; i--){
    if(a->digits[i] < b->digits[i]) return OB_LESS_THAN;
    if(a->digits[i] > b->digits[i]) return OB_GREATER_THAN;
  }

  return OB_EQUAL_TO;
}

// Assembly:
movq 0x10(%rdi), %rcx
movq 0x18(%rdi), %rdx
movq %rdx, %rax
leaq -0x1(%rax), %rdi
cmpq $0x1, %rax
je 0x2bd4
cmpb $0x0, -0x1(%rcx,%rax)
movq %rdi, %rax
je 0x2bc0
movq 0x10(%rsi), %r8
movq 0x18(%rsi), %rax
leaq -0x1(%rax), %rsi
cmpq $0x1, %rax
je 0x2bf1
cmpb $0x0, -0x1(%r8,%rax)
movq %rsi, %rax
je 0x2bdc
movb $-0x1, %al
cmpq %rsi, %rdi
jb 0x2bfc
jbe 0x2bfd
movb $0x1, %al
retq
cmpq %rdx, %rdi
jae 0x2c13
movb (%r8,%rdi), %sil
cmpb %sil, (%rcx,%rdi)
jl 0x2bfc
jg 0x2bfa
decq %rdi
jmp 0x2bfd
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/theck01[P]offbrand_lib/src/classes/obint.c
// Function: obint_subtract_unsigned
obint * obint_subtract_unsigned(const obint *a, const obint *b){

  uint64_t i, a_most_sig, b_most_sig;
  obint *result;

  result = obint_copy(a);

  a_most_sig = obint_most_sig(a);
  b_most_sig = obint_most_sig(b);

  for(i=0; i<=b_most_sig; i++){
    /* perform borrow operation if needed */
    if(result->digits[i] < b->digits[i]){
      result->digits[i+1]--;
      result->digits[i] += 10;
    }

    result->digits[i] -= b->digits[i];
  }

  /* propagate any final borrow */
  while(i < a_most_sig && result->digits[i] < 0){
    result->digits[i+1]--;
    result->digits[i] += 10;
    i++;
  }

  return result;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x287e
movq 0x10(%r14), %rdx
movq 0x18(%r14), %rsi
leaq -0x1(%rsi), %rcx
cmpq $0x1, %rsi
je 0x2c41
cmpb $0x0, -0x1(%rdx,%rsi)
movq %rcx, %rsi
je 0x2c2d
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rdi
leaq -0x1(%rdi), %rdx
cmpq $0x1, %rdi
je 0x2c5d
cmpb $0x0, -0x1(%rsi,%rdi)
movq %rdx, %rdi
je 0x2c49
xorl %edi, %edi
movq 0x10(%rax), %rsi
movb (%rsi,%rdi), %r8b
movq 0x10(%rbx), %r9
cmpb (%r9,%rdi), %r8b
jge 0x2c7d
decb 0x1(%rsi,%rdi)
movq 0x10(%rax), %rsi
addb $0xa, (%rsi,%rdi)
movq 0x10(%rbx), %rsi
movb (%rsi,%rdi), %sil
movq 0x10(%rax), %r8
subb %sil, (%r8,%rdi)
leaq 0x1(%rdi), %rsi
cmpq %rdx, %rdi
movq %rsi, %rdi
jb 0x2c5f
cmpq %rcx, %rsi
jae 0x2cc0
movq 0x10(%rax), %rdx
cmpb $0x0, (%rdx,%rsi)
jns 0x2cc0
decb 0x1(%rdx,%rsi)
movq 0x10(%rax), %rdx
addb $0xa, (%rdx,%rsi)
leaq 0x1(%rsi), %rdx
movq %rdx, %rsi
cmpq %rcx, %rdx
jb 0x2c9e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/theck01[P]offbrand_lib/src/classes/obint.c
// Function: obint_add_primitive
obint * obint_add_primitive(const obint *a, int64_t b){

  obint *wrapper, *result;

  assert(a != NULL);

  wrapper = obint_new(b);
  result = obint_add(a, wrapper);
  ob_release((obj *)wrapper);

  return result;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2d00
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x2490
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2928
movq %rax, %rbx
movq %r14, %rdi
callq 0x51fa
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x36fb(%rip), %rdi      # 0x6402
leaq 0x36fe(%rip), %rsi      # 0x640c
leaq 0x3859(%rip), %rcx      # 0x656e
movl $0xc9, %edx
callq 0x10a0