LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/pedro-onate[P]eva/eva.c
// Function: es_symbol_intern
es_val_t es_symbol_intern(es_ctx_t* ctx, const char* cstr)
{
  es_symtab_t* symtab = &ctx->symtab;
  int id = symtab_find_or_create(symtab, cstr);
  if (id < 0) {
    return es_make_error(ctx, "symtab count exceeded");
  }
  return es_make_symbol(id);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movslq 0x42048(%rdi), %r12
testq %r12, %r12
jle 0x2bd7
movl %r12d, %r15d
xorl %r13d, %r13d
movq 0x2048(%rbx,%r13,8), %rdi
movq %r14, %rsi
callq 0x10e0
testl %eax, %eax
je 0x2c0b
incq %r13
cmpq %r13, %r15
jne 0x2bb2
cmpl $0x7fff, %r15d          # imm = 0x7FFF
jg 0x2c1f
movq %r14, %rdi
callq 0x1070
leaq 0x1(%rax), %rdi
callq 0x1100
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x1050
movq %r15, 0x2048(%rbx,%r12,8)
leal 0x1(%r12), %eax
movl %eax, 0x42048(%rbx)
jmp 0x2c0e
movl %r13d, %r12d
testl %r12d, %r12d
js 0x2c1f
leal 0x2(,%r12,8), %eax
cltq
jmp 0x2c3c
movl $0x18, %edx
movq %rbx, %rdi
movl $0x16, %esi
callq 0x2122
leaq 0x3857(%rip), %rcx      # 0x648f
movq %rcx, 0x10(%rax)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/pedro-onate[P]eva/eva.c
// Function: es_make_vector
es_val_t es_make_vector(es_ctx_t* ctx, int size)
{
  assert(size >= 0);
  es_vec_t* vector = es_alloc(ctx, ES_VECTOR_TYPE, sizeof(es_vec_t) + size * sizeof(es_val_t));
  vector->length = size;
  for(int i = 0; i < size; i++)
    vector->array[i] = es_undefined;
  return es_obj_to_val(vector);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testl %esi, %esi
js 0x2ee6
movl %esi, %ebx
movl %esi, %r14d
leaq 0x18(,%r14,8), %rdx
movl $0xd, %esi
callq 0x2122
movl %ebx, 0x10(%rax)
testl %ebx, %ebx
je 0x2ede
leal 0x1(%r14), %ecx
decq %r14
movq %r14, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
shrl %ecx
shlq $0x4, %rcx
movdqa 0x359c(%rip), %xmm1     # 0x6400
xorl %edx, %edx
movdqa 0x35a2(%rip), %xmm2     # 0x6410
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movdqa 0x35a2(%rip), %xmm4     # 0x6420
movdqa %xmm1, %xmm5
pxor %xmm2, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
movd %xmm5, %esi
notl %esi
testb $0x1, %sil
je 0x2eb9
movq $0x53, 0x18(%rax,%rdx)
pxor %xmm3, %xmm5
pextrw $0x4, %xmm5, %esi
testb $0x1, %sil
je 0x2ed1
movq $0x53, 0x20(%rax,%rdx)
paddq %xmm4, %xmm1
addq $0x10, %rdx
cmpq %rdx, %rcx
jne 0x2e7e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x35b8(%rip), %rdi      # 0x64a5
leaq 0x3552(%rip), %rsi      # 0x6446
leaq 0x35b4(%rip), %rcx      # 0x64af
movl $0x471, %edx            # imm = 0x471
callq 0x10a0
// File: /workspace/github_c_makefile_star2_O3/pedro-onate[P]eva/eva.c
// Function: es_vector_from_list
es_val_t es_vector_from_list(es_ctx_t* ctx, es_val_t list)
{
  es_val_t vector;
  int i, length;
  gc_root(ctx, list);
  length = es_list_length(list);
  vector = es_make_vector(ctx, length);
  for(i = 0; i < length; i++, list = es_cdr(list)) {
    es_vector_set(vector, i, es_car(list));
  }
  gc_unroot(ctx, 1);
  return vector;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %rax
movq %rsi, (%rax)
movslq 0x2040(%rdi), %rcx
leal 0x1(%rcx), %edx
movl %edx, 0x2040(%rdi)
movq %rax, 0x40(%rdi,%rcx,8)
xorl %r14d, %r14d
movl %esi, %eax
andl $0x7, %eax
cmpq $0x3, %rax
je 0x2fa2
testq %rax, %rax
jne 0x2fab
movl (%rsi), %eax
jmp 0x2fa7
movl %esi, %eax
sarl $0x3, %eax
testl %eax, %eax
je 0x2fb4
movq 0x18(%rsi), %rsi
incq %r14
jmp 0x2f8e
movq %rbx, %rdi
movl %r14d, %esi
callq 0x2e17
testl %r14d, %r14d
je 0x2feb
movq %rax, %rcx
addq $0x18, %rcx
movq (%rsp), %rdx
movq 0x10(%rdx), %rdx
movq %rdx, (%rcx)
movq (%rsp), %rdx
movq 0x18(%rdx), %rdx
movq %rdx, (%rsp)
addq $0x8, %rcx
decq %r14
jne 0x2fcf
decl 0x2040(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/pedro-onate[P]eva/eva.c
// Function: es_list_length
int es_list_length(es_val_t list)
{
  int i = 0;
  while(!es_is_nil(list)) {
    list = es_cdr(list);
    i++;
  }
  return i;
}

// Assembly:
xorl %eax, %eax
movl %edi, %ecx
andl $0x7, %ecx
cmpq $0x3, %rcx
je 0x300f
testq %rcx, %rcx
jne 0x3018
movl (%rdi), %ecx
jmp 0x3014
movl %edi, %ecx
sarl $0x3, %ecx
testl %ecx, %ecx
je 0x3020
movq 0x18(%rdi), %rdi
incl %eax
jmp 0x2ffb
retq
// File: /workspace/github_c_makefile_star2_O3/pedro-onate[P]eva/eva.c
// Function: es_make_env
es_val_t es_make_env(es_ctx_t* ctx, int size)
{
  size_t sz = sizeof(es_env_t) + sizeof(es_slot_t) * size;
  es_env_t* env = es_alloc(ctx, ES_ENV_TYPE, sz);
  env->count = 0;
  env->size  = size;
  return es_obj_to_val(env);
}

// Assembly:
pushq %rbx
movslq %esi, %rbx
movq %rbx, %rdx
shlq $0x4, %rdx
addq $0x18, %rdx
movl $0xf, %esi
callq 0x2122
movl $0x0, 0x10(%rax)
movl %ebx, 0x14(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/pedro-onate[P]eva/eva.c
// Function: env_reserve_loc
static int env_reserve_loc(es_ctx_t* ctx, es_val_t env, es_val_t sym, es_val_t init)
{
  int loc = es_env_loc(env, sym);
  if (loc > -1) {
    if (es_is_unbound(es_env_val_of(env, loc))) {
      env_set_val(env, loc, init);
    }
    return loc;
  }

  int size  = es_env_size(env);
  size_t count = es_env_count(env);

  if (count >= size) {
    int new_size = (size << 1) + size;
    gc_root3(ctx, env, sym, init);

    es_val_t new_env = es_make_env(ctx, new_size);

    for(int i = 0; i < count; i++) {
      es_env_val(new_env)->slots[i].sym = es_env_val(env)->slots[i].sym;
      es_env_val(new_env)->slots[i].val = es_env_val(env)->slots[i].val;
      es_env_val(new_env)->count++;
    }

    gc_unroot(ctx, 3);

    ctx->env = new_env;
    env = new_env;
  }

  es_env_val(env)->slots[es_env_val(env)->count].sym = sym;
  es_env_val(env)->slots[es_env_val(env)->count].val = init;
  return es_env_val(env)->count++;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq %rsi, 0x8(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movl 0x10(%rsi), %r14d
testl %r14d, %r14d
jle 0x3093
leaq 0x18(%rsi), %rdi
xorl %eax, %eax
cmpq %rdx, 0x8(%rdi)
je 0x3189
incq %rax
addq $0x10, %rdi
cmpq %rax, %r14
jne 0x307d
movl 0x14(%rsi), %eax
cmpl %eax, %r14d
jb 0x314e
leal (%rax,%rax,2), %eax
movslq 0x2040(%rbx), %rcx
leaq 0x8(%rsp), %rdx
movq %rdx, 0x40(%rbx,%rcx,8)
leaq 0x18(%rsp), %rdx
movq %rdx, 0x48(%rbx,%rcx,8)
leal 0x3(%rcx), %edx
movl %edx, 0x2040(%rbx)
leaq 0x10(%rsp), %rdx
movq %rdx, 0x50(%rbx,%rcx,8)
movslq %eax, %r15
movq %r15, %rdx
shlq $0x4, %rdx
addq $0x18, %rdx
movq %rbx, %rdi
movl $0xf, %esi
callq 0x2122
movq %rax, %rsi
movl $0x0, 0x10(%rax)
movl %r15d, 0x14(%rax)
testl %r14d, %r14d
je 0x3132
movq %r14, %rax
shlq $0x4, %rax
xorl %ecx, %ecx
movq 0x8(%rsp), %rdx
movq 0x20(%rdx,%rcx), %rdx
movq %rdx, 0x20(%rsi,%rcx)
movq 0x8(%rsp), %rdx
movq 0x18(%rdx,%rcx), %rdx
movq %rdx, 0x18(%rsi,%rcx)
addq $0x10, %rcx
cmpq %rcx, %rax
jne 0x3107
movl %r14d, 0x10(%rsi)
addl $-0x3, 0x2040(%rbx)
movq %rsi, 0x42080(%rbx)
movq %rsi, 0x8(%rsp)
movq 0x18(%rsp), %rdx
movl 0x10(%rsi), %r14d
movslq %r14d, %rax
shlq $0x4, %rax
movq %rdx, 0x20(%rsi,%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movslq 0x10(%rcx), %rdx
shlq $0x4, %rdx
movq %rax, 0x18(%rcx,%rdx)
movq 0x8(%rsp), %rcx
movl 0x10(%rcx), %eax
leal 0x1(%rax), %edx
movl %edx, 0x10(%rcx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq (%rdi), %rdx
movq %rdx, %rsi
andq $0x7, %rsi
je 0x319f
cmpl $0x3, %esi
jne 0x317f
sarl $0x3, %edx
jmp 0x31a1
movl (%rdx), %edx
cmpl $0x9, %edx
jne 0x317f
movq %rcx, (%rdi)
jmp 0x317f
// File: /workspace/github_c_makefile_star2_O3/pedro-onate[P]eva/eva.c
// Function: es_make_bytecode
es_val_t es_make_bytecode(es_ctx_t* ctx)
{
  es_bytecode_t* b = es_alloc(ctx, ES_BYTECODE_TYPE, sizeof(es_bytecode_t));
  b->inst       = malloc(1024 * sizeof(es_inst_t));
  b->inst_size  = 1024;
  b->cpool_size = ES_CONST_POOL_SIZE;
  b->next_const = 0;
  b->next_inst  = 0;
  return es_obj_to_val(b);
}

// Assembly:
pushq %rbx
movl $0x8028, %edx           # imm = 0x8028
movl $0x12, %esi
callq 0x2122
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 %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/pedro-onate[P]eva/eva.c
// Function: es_make_closure
es_val_t es_make_closure(es_ctx_t* ctx, es_val_t env, es_val_t proc)
{
  es_closure_t* closure;
  gc_root2(ctx, env, proc);
  closure = es_alloc(ctx, ES_CLOSURE_TYPE, sizeof(es_closure_t));
  closure->proc = proc;
  closure->env  = (es_args_t*)env;
  gc_unroot(ctx, 2);
  return es_obj_to_val(closure);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %rsi, (%r14)
movq %rsp, %r15
movq %rdx, (%r15)
movslq 0x2040(%rdi), %rax
movq %r14, 0x40(%rdi,%rax,8)
leal 0x2(%rax), %ecx
movl %ecx, 0x2040(%rdi)
movq %r15, 0x48(%rdi,%rax,8)
movl $0x20, %edx
movl $0x8, %esi
callq 0x2122
movq (%r15), %rcx
movq %rcx, 0x18(%rax)
movq (%r14), %rcx
movq %rcx, 0x10(%rax)
addl $-0x2, 0x2040(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/pedro-onate[P]eva/eva.c
// Function: es_mark_copy
void es_mark_copy(es_heap_t* heap, es_val_t* ref, char** next)
{
  assert(*next < heap->to_end);
  if (!is_obj(*ref))
    return;

  if (es_obj_is_reloc(*ref)) {
    *ref = es_obj_to_val(es_val_to_obj(*ref)->reloc); // Update stale reference to relocated object
  } else {
    size_t size = es_size_of(*ref);                // Get size of object
    *next = alignp(*next, ES_DEFAULT_ALIGNMENT); // Ensure next pointer is aligned
    memcpy(*next, (void*)*ref, size);                 // Copy object from_space from_space-space into to_space-space
    es_val_to_obj(*ref)->reloc = (es_obj_t*)*next;            // Leave forwarding pointer in old from_space-space object
    *ref = es_obj_to_val(es_val_to_obj(*ref)->reloc);                    // Update current reference to_space point to_space new object in to_space-space
    es_val_to_obj(*ref)->reloc = NULL;                        // Reset tombstone
    *next += size;                                 // Update next pointer
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq (%rdx), %r15
cmpq %rdi, %r15
jae 0x3889
movq %rsi, %r14
movq (%rsi), %r12
testb $0x7, %r12b
setne %al
testq %r12, %r12
sete %cl
orb %al, %cl
jne 0x387f
movq 0x8(%r12), %rax
testq %rax, %rax
je 0x3840
movq %rax, (%r14)
jmp 0x387f
movq %rdx, %rbx
movq %r12, %rdi
callq 0x3491
movq %rax, %r13
addq $0xf, %r15
andq $-0x10, %r15
movq %r15, (%rbx)
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x10f0
movq (%rbx), %rax
movq (%r14), %rcx
movq %rax, 0x8(%rcx)
movq %rax, (%r14)
movq $0x0, 0x8(%rax)
addq %r13, (%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x2fb4(%rip), %rdi      # 0x6844
leaq 0x2baf(%rip), %rsi      # 0x6446
leaq 0x2fbb(%rip), %rcx      # 0x6859
movl $0x1b8, %edx            # imm = 0x1B8
callq 0x10a0
// File: /workspace/github_c_makefile_star2_O3/pedro-onate[P]eva/eva.c
// Function: es_make_list
es_val_t es_make_list(es_ctx_t* ctx, ...)
{
  es_val_t list, tail, e;
  va_list argp;
  va_start(argp, ctx);
  e = va_arg(argp, es_val_t);
  if (es_val_to_obj(e) == NULL)
    return es_nil;
  tail = list = es_cons(ctx, e, es_nil);
  while(es_val_to_obj(e = va_arg(argp, es_val_t)) != NULL) {
    es_set_cdr(tail, es_cons(ctx, e, es_nil));
    tail = es_cdr(tail);
  }
  va_end(argp);
  return list;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x390b
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rdi, 0x10(%rsp)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rsp)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rsp)
movl $0x8, %ecx
cmpq $0x28, %rcx
ja 0x3948
movl $0x8, %eax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x3956
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %rsi
testq %rsi, %rsi
je 0x39b3
movl $0x3, %edx
movq %rbx, %rdi
callq 0x2298
movq %rax, %r14
movq %rax, %r15
movl (%rsp), %ecx
cmpq $0x28, %rcx
ja 0x398a
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x3998
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %rsi
testq %rsi, %rsi
je 0x39b9
movl $0x3, %edx
movq %rbx, %rdi
callq 0x2298
movq %rax, 0x18(%r15)
jmp 0x396e
movl $0x3, %r14d
movq %r14, %rax
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/pedro-onate[P]eva/eva.c
// Function: es_compile
es_val_t es_compile(es_ctx_t* ctx, es_val_t exp)
{
  int start;
  es_val_t b = ctx->bytecode;
  start = bytecode_label(b);
  compile(ctx, b, exp, 0, 0, es_nil);
  emit_halt(b);
  int end = bytecode_label(b);

  return es_make_proc(ctx, 0, 0, start, end);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rdx
movq %rdi, %rbx
movq 0x42060(%rdi), %r14
movl 0x8024(%r14), %ebp
movl $0x3, %r9d
movq %r14, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x3a7b
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x432f
movq (%rax), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x52f6
movl 0x8024(%r14), %r14d
movl $0x20, %edx
movq %rbx, %rdi
movl $0x11, %esi
callq 0x2122
movq $0x0, 0x10(%rax)
movl %ebp, 0x18(%rax)
movl %r14d, 0x1c(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/pedro-onate[P]eva/eva.c
// Function: es_load
es_val_t es_load(es_ctx_t* ctx, const char* file_name)
{
  es_val_t exp, port;
  port = es_make_port(ctx, fopen(file_name, "r"));
  es_ctx_set_oport(ctx, es_make_port(ctx, stdout));
  while(!es_is_eof_obj(exp = es_port_read(ctx, port))) {
    es_eval(ctx, exp);
  }
  es_port_close(port);
  return es_void;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x264a(%rip), %rsi      # 0x65bb
movq %rax, %rdi
callq 0x1120
movq %rax, %r15
movl $0x1848, %edx           # imm = 0x1848
movq %rbx, %rdi
movl $0xc, %esi
callq 0x2122
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 0x601b(%rip), %rax      # 0x9fd8
movq (%rax), %r12
movl $0x1848, %edx           # imm = 0x1848
movq %rbx, %rdi
movl $0xc, %esi
callq 0x2122
movq %rax, %r15
movq %r12, 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(%r15)
movq %r15, 0x42058(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x23fd
movl %eax, %ecx
andl $0x7, %ecx
cmpq $0x3, %rcx
je 0x401b
testq %rcx, %rcx
jne 0x4025
movl (%rax), %ecx
jmp 0x4020
movl %eax, %ecx
sarl $0x3, %ecx
cmpl $0x7, %ecx
je 0x4032
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4051
jmp 0x3ffc
movq 0x10(%r14), %rdi
callq 0x1060
movq $0x0, 0x10(%r14)
movl $0x5b, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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, %rbx
movq 0x42080(%rdi), %rdx
callq 0x4192
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3a09
movq %rax, %r14
leaq 0x18(%rsp), %rdi
xorl %esi, %esi
callq 0x1090
movq %rbx, %rdi
movl $0x1, %esi
movq %r14, %rdx
xorl %eax, %eax
callq 0x432f
cmpl $0x0, 0x42078(%rbx)
jne 0x40b6
movq %rax, %r14
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x1090
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x2421(%rip), %rdi      # 0x64de
leaq 0x2382(%rip), %rsi      # 0x6446
leaq 0x2420(%rip), %rcx      # 0x64eb
movl $0xa47, %edx            # imm = 0xA47
callq 0x10a0
// File: /workspace/github_c_makefile_star2_O3/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 %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl %r15d, %eax
andl $0x7, %eax
cmpq $0x3, %rax
je 0x40fc
testq %rax, %rax
jne 0x4106
movl (%r15), %eax
jmp 0x4102
movl %r15d, %eax
sarl $0x3, %eax
testl %eax, %eax
je 0x411e
movq 0x18(%r15), %rax
movl %eax, %ecx
andl $0x7, %ecx
cmpq $0x3, %rcx
je 0x412d
testq %rcx, %rcx
jne 0x4158
movl (%rax), %eax
jmp 0x4130
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
sarl $0x3, %eax
cmpl $0x6, %eax
jne 0x4158
movq 0x10(%r15), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x4192
movq %rax, %r12
movq 0x18(%r15), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x40d5
jmp 0x4179
movq 0x10(%r15), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x4192
movq %rax, %r12
movq 0x18(%r15), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x4192
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2298
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl %r15d, %eax
andl $0x7, %eax
cmpq $0x3, %rax
je 0x41ba
testq %rax, %rax
jne 0x4240
movl (%r15), %eax
jmp 0x41c0
movl %r15d, %eax
sarl $0x3, %eax
cmpl $0x6, %eax
jne 0x4240
movq 0x10(%r15), %rdx
movl %edx, %eax
andl $0x7, %eax
cmpq $0x3, %rax
je 0x41e2
cmpl $0x2, %eax
je 0x41ec
testq %rax, %rax
jne 0x422d
movl (%rdx), %eax
jmp 0x41e7
movl %edx, %eax
sarl $0x3, %eax
cmpl $0x3, %eax
jne 0x422d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x323e
movl %eax, %ecx
andl $0x7, %ecx
cmpq $0x3, %rcx
je 0x420b
testq %rcx, %rcx
jne 0x422d
movl (%rax), %ecx
jmp 0x4210
movl %eax, %ecx
sarl $0x3, %ecx
cmpl $0x14, %ecx
jne 0x422d
movq 0x10(%rax), %rsi
movq 0x18(%r15), %rdx
movq %r14, %rdi
callq 0x4249
movq %rax, %r15
jmp 0x41a0
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x40d5
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
movq %rdx, %rax
andq $0x7, %rax
je 0x4271
cmpl $0x3, %eax
jne 0x4280
movl %edx, %ecx
sarl $0x3, %ecx
jmp 0x4273
movl (%rdx), %ecx
movq 0x42070(%rbx), %rax
testl %ecx, %ecx
jne 0x4287
jmp 0x42a1
movq 0x42070(%rbx), %rax
movq 0x10(%rdx), %rcx
leaq 0x8(%rax), %rdi
movq %rdi, 0x42070(%rbx)
movq %rcx, (%rax)
movq 0x18(%rdx), %rdx
incl %ebp
jmp 0x425c
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 0x432f
movq (%rax), %rsi
movzwl %bp, %edx
movq %r14, %rdi
callq 0x52f6
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x432f
movq (%rax), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x52f6
movl 0x8024(%r14), %ebp
movl $0x20, %edx
movq %rbx, %rdi
movl $0x11, %esi
callq 0x2122
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 0x432f
// File: /workspace/github_c_makefile_star2_O3/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 0x558b(%rip), %rax      # 0x9fe0
movq (%rax), %r15
movl $0x1848, %edx           # imm = 0x1848
movq %rbx, %rdi
movl $0xc, %esi
callq 0x2122
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 0x5538(%rip), %rax      # 0x9fd8
movq (%rax), %r15
movl $0x1848, %edx           # imm = 0x1848
movq %rbx, %rdi
movl $0xc, %esi
callq 0x2122
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 0x1a2c(%rip), %rsi      # 0x6512
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1917
leaq 0x1a2d(%rip), %rsi      # 0x6524
leaq 0x1a35(%rip), %rdx      # 0x6533
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1917
leaq 0x1a2a(%rip), %rsi      # 0x6539
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1917
movq %rbx, %rdi
callq 0x3526
leaq 0x1a24(%rip), %r14      # 0x654c
leaq 0x1a23(%rip), %r15      # 0x6552
leaq 0x1816(%rip), %r13      # 0x634c
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x1917
movq 0x42050(%rbx), %rsi
movq %rbx, %rdi
callq 0x23fd
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4051
movq %rax, %r12
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1917
movq %rbx, %rdi
callq 0x3526
movl %r12d, %eax
andl $0x7, %eax
cmpq $0x5, %rax
ja 0x4bba
movslq (%r13,%rax,4), %rax
addq %r13, %rax
jmpq *%rax
movl (%r12), %r12d
jmp 0x4bc0
movl $0x1, %r12d
jmp 0x4bc0
movl $0x3, %r12d
jmp 0x4bc0
sarl $0x3, %r12d
jmp 0x4bc0
movl $0x2, %r12d
jmp 0x4bc0
movl $0x4, %r12d
jmp 0x4bc0
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
cmpl $0x7, %r12d
jne 0x4b36
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_O3/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 0x1ae3(%rip), %rdi      # 0x66da
xorl %eax, %eax
callq 0x1080
leaq 0x1ae5(%rip), %rdi      # 0x66ea
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1080
movl $0x5b, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2122
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 0x3a7b
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x432f
movq (%rax), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x52f6
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x432f
movq (%rax), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x52f6
xorl %r15d, %r15d
movl %r12d, %eax
andl $0x7, %eax
cmpq $0x3, %rax
je 0x5037
testq %rax, %rax
jne 0x5041
movl (%r12), %eax
jmp 0x503d
movl %r12d, %eax
sarl $0x3, %eax
testl %eax, %eax
je 0x5078
movq 0x10(%r12), %rsi
movq %r14, %rdi
callq 0x529c
movl %eax, %ebp
xorl %edi, %edi
xorl %esi, %esi
movl $0x1, %edx
xorl %eax, %eax
callq 0x432f
movq (%rax), %rsi
movzwl %bp, %edx
movq %r14, %rdi
callq 0x52f6
movq 0x18(%r12), %r12
incl %r15d
jmp 0x5020
movq %r14, %rdi
movq (%rsp), %rsi
callq 0x529c
movl %eax, %r12d
xorl %edi, %edi
xorl %esi, %esi
movl $0x1, %edx
xorl %eax, %eax
callq 0x432f
movq (%rax), %rsi
movl $0xffff, %ebp           # imm = 0xFFFF
andl %ebp, %r12d
movq %r14, %rdi
movq %r12, %rdx
callq 0x52f6
xorl %edi, %edi
xorl %esi, %esi
movl $0xc, %edx
xorl %eax, %eax
callq 0x432f
movq (%rax), %rsi
andl %ebp, %r15d
movq %r14, %rdi
movq %r15, %rdx
callq 0x52f6
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_O3/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 0x52d7
testl %eax, %eax
jle 0x52c0
xorl %ecx, %ecx
cmpq %rsi, 0x10(%rdi,%rcx,8)
je 0x52d3
incq %rcx
cmpq %rcx, %rax
jne 0x52b1
movslq %eax, %rcx
movq %rsi, 0x10(%rdi,%rcx,8)
leal 0x1(%rax), %ecx
movl %ecx, 0x8014(%rdi)
jmp 0x52d5
movl %ecx, %eax
popq %rcx
retq
leaq 0x141c(%rip), %rdi      # 0x66fa
leaq 0x1161(%rip), %rsi      # 0x6446
leaq 0x142c(%rip), %rcx      # 0x6718
movl $0x62c, %edx            # imm = 0x62C
callq 0x10a0
// File: /workspace/github_c_makefile_star2_O3/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
movl 0x8024(%rdi), %ecx
cmpl %eax, %ecx
jge 0x531d
movq 0x8018(%r15), %rax
jmp 0x534c
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)
movl 0x8024(%r15), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x8024(%r15)
movslq %ecx, %rcx
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_O3/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 0x432f
movl 0x10(%rax), %ecx
cmpl $0x2, %ecx
je 0x53d8
cmpl $0x1, %ecx
je 0x53b6
testl %ecx, %ecx
jne 0x53ff
movq 0x8(%rax), %rcx
leaq 0x13fe(%rip), %rdx      # 0x67a2
movq %r14, %rdi
movq %rbx, %rsi
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x1fc1
movq 0x8(%rax), %rcx
movswl 0x8(%r15), %r8d
leaq 0x1442(%rip), %rdx      # 0x6808
movq %r14, %rdi
movq %rbx, %rsi
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x1fc1
movq 0x8(%rax), %rcx
movswl 0x8(%r15), %r8d
movswl 0xa(%r15), %r9d
leaq 0x1421(%rip), %rdx      # 0x680e
movq %r14, %rdi
movq %rbx, %rsi
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x1fc1
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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)
movq 0x38(%rdi), %rax
movq %rax, 0x58(%rdi,%rdx,8)
leal 0x1(%rcx), %eax
movl %eax, 0x40(%rdi)
callq 0x5405
movl %eax, %ebp
movq %rbx, %rdi
callq 0x2871
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x58b2
pushq %rbx
movl %esi, %ebx
movl %edi, %eax
leaq 0xbe5(%rip), %rcx       # 0x63b4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpb $0x2d, %bl
ja 0x57f9
movl $0x1, %eax
movzbl %bl, %ecx
movabsq $0x280000000001, %rdx   # imm = 0x280000000001
btq %rcx, %rdx
jb 0x58b0
callq 0x1190
movq (%rax), %rcx
movslq %ebx, %rdx
movl $0x2, %eax
testb $0x8, 0x1(%rcx,%rdx,2)
jne 0x58b0
xorl %eax, %eax
cmpl $0x2e, %ebx
setne %al
addl $0x3, %eax
jmp 0x58b0
callq 0x1190
movq (%rax), %rcx
movslq %ebx, %rdx
movl $0x2, %eax
testb $0x8, 0x1(%rcx,%rdx,2)
jne 0x58b0
leaq 0x105a(%rip), %rdi      # 0x689c
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 0x58b0
leaq 0x102e(%rip), %rdi      # 0x689c
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 0x58b0
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_O3/pedro-onate[P]eva/eva.c
// Function: compile_lambda
static es_val_t compile_lambda(es_ctx_t* ctx, es_val_t bc, es_val_t formals, es_val_t body, int tail_pos, int next, es_val_t scope)
{
  int label1 = bytecode_label(bc);
  emit_jmp(bc, -1);
  int label2 = bytecode_label(bc);
  scope = make_scope(ctx, formals, scope);
  compile_seq(ctx, bc, body, 1, RETURN, scope);
  int label3 = bytecode_label(bc);
  int rest;
  int arity = lambda_arity(formals, &rest);
  es_val_t proc = es_make_proc(ctx, arity, rest, label2, label3);
  emit_closure(bc, alloc_const(bc, proc));
  es_bytecode_val(bc)->inst[label1].operand1 = label3 - label1;
  if (tail_pos) emit(bc, (es_inst_t){ opcode(next) });
  return es_void;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, 0x4(%rsp)
movl %r8d, 0xc(%rsp)
movq %rcx, %r13
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r15
movq 0x50(%rsp), %rbp
movslq 0x8024(%rsi), %rax
movq %rax, 0x10(%rsp)
xorl %r14d, %r14d
xorl %edi, %edi
xorl %esi, %esi
movl $0x9, %edx
xorl %eax, %eax
callq 0x432f
movq (%rax), %rsi
movl $0xffff, %edx           # imm = 0xFFFF
movq %rbx, %rdi
callq 0x52f6
movl 0x8024(%rbx), %eax
movl %eax, 0x8(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x5cf0
movq %r15, %rdi
movq %rax, %rsi
movq %rbp, %rdx
callq 0x2298
movl $0x1, %ebp
movq %r15, %rdi
movq %rbx, %rsi
movq %r13, %rdx
movl $0x1, %ecx
movl $0xd, %r8d
movq %rax, %r9
callq 0x5a84
movl 0x8024(%rbx), %r13d
movl %r12d, %eax
andl $0x7, %eax
cmpq $0x3, %rax
je 0x5977
cmpl $0x2, %eax
je 0x59dc
testq %rax, %rax
jne 0x5982
movl (%r12), %eax
jmp 0x597d
movl %r12d, %eax
sarl $0x3, %eax
cmpl $0x3, %eax
je 0x59dc
xorl %r14d, %r14d
movl %r12d, %eax
andl $0x7, %eax
cmpq $0x3, %rax
je 0x599c
testq %rax, %rax
jne 0x59c6
movl (%r12), %ecx
jmp 0x59a2
movl %r12d, %ecx
sarl $0x3, %ecx
cmpl $0x6, %ecx
jne 0x59b1
incl %r14d
movq 0x18(%r12), %r12
jmp 0x5985
cmpl $0x3, %eax
je 0x59cd
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testq %rax, %rax
jne 0x59d4
movl (%r12), %ecx
jmp 0x59d4
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
jmp 0x59d4
sarl $0x3, %r12d
movl %r12d, %ecx
xorl %ebp, %ebp
testl %ecx, %ecx
setne %bpl
movl $0x20, %edx
movq %r15, %rdi
movl $0x11, %esi
callq 0x2122
movl %r14d, 0x10(%rax)
movl %ebp, 0x14(%rax)
movl 0x8(%rsp), %ecx
movl %ecx, 0x18(%rax)
movl %r13d, 0x1c(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x529c
movl %eax, %ebp
xorl %edi, %edi
xorl %esi, %esi
movl $0xe, %edx
xorl %eax, %eax
callq 0x432f
movq (%rax), %rsi
movzwl %bp, %edx
movq %rbx, %rdi
callq 0x52f6
movq 0x10(%rsp), %rcx
subl %ecx, %r13d
movq 0x8018(%rbx), %rax
shlq $0x4, %rcx
movw %r13w, 0x8(%rax,%rcx)
cmpl $0x0, 0xc(%rsp)
je 0x5a75
xorl %edi, %edi
xorl %esi, %esi
movl 0x4(%rsp), %edx
xorl %eax, %eax
callq 0x432f
movq (%rax), %rsi
movq %rbx, %rdi
xorl %edx, %edx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x52f6
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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, %ecx
andl $0x7, %ecx
cmpq $0x3, %rcx
je 0x5aba
testq %rcx, %rcx
jne 0x5ac1
movl (%rax), %eax
jmp 0x5abd
sarl $0x3, %eax
testl %eax, %eax
je 0x5afd
movq 0x10(%r12), %rdx
movq %r13, %rdi
movq %r15, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %rbx, %r9
callq 0x3a7b
xorl %edi, %edi
xorl %esi, %esi
movl $0x2, %edx
xorl %eax, %eax
callq 0x432f
movq (%rax), %rsi
movq %r15, %rdi
xorl %edx, %edx
callq 0x52f6
movq 0x18(%r12), %r12
jmp 0x5aa1
movq 0x10(%r12), %rdx
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 0x3a7b
// File: /workspace/github_c_makefile_star2_O3/pedro-onate[P]eva/eva.c
// Function: compile_set
static es_val_t compile_set(es_ctx_t* ctx, es_val_t bc, es_val_t sym, es_val_t exp, int tail_pos, int next, es_val_t scope)
{
  compile(ctx, bc, exp, 0, 0, scope);
  int idx, depth;
  if (arg_idx(scope, sym, &idx, &depth)) {
    depth == 0 ? emit_arg_set(bc, idx) : emit_closed_set(bc, depth, idx);
  } else {
    emit_global_set(bc, env_reserve_loc(ctx, es_ctx_env(ctx), sym, es_unbound));
  }
  if (tail_pos) emit(bc, (es_inst_t){ opcode(next) });
  return es_void;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebp
movl %r8d, %r14d
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r12
movq 0x40(%rsp), %r13
movq %rcx, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %r13, %r9
callq 0x3a7b
leaq 0x4(%rsp), %rdx
movq %rsp, %rcx
movq %r13, %rdi
movq %r15, %rsi
callq 0x5d72
testl %eax, %eax
je 0x5b96
movl (%rsp), %r12d
movzwl 0x4(%rsp), %r15d
xorl %edi, %edi
xorl %esi, %esi
testl %r12d, %r12d
je 0x5bc7
movl $0x6, %edx
xorl %eax, %eax
callq 0x432f
shll $0x10, %r15d
movzwl %r12w, %ecx
orl %ecx, %r15d
jmp 0x5bd3
movq 0x42080(%r12), %rsi
movl $0x4b, %ecx
movq %r12, %rdi
movq %r15, %rdx
callq 0x3053
movl %eax, %r15d
xorl %edi, %edi
xorl %esi, %esi
movl $0x4, %edx
xorl %eax, %eax
callq 0x432f
movzwl %r15w, %r15d
jmp 0x5bd3
movl $0x8, %edx
xorl %eax, %eax
callq 0x432f
movq (%rax), %rsi
movl %r15d, %edx
movq %rbx, %rdi
callq 0x52f6
testl %r14d, %r14d
je 0x5c0e
xorl %edi, %edi
xorl %esi, %esi
movl %ebp, %edx
xorl %eax, %eax
callq 0x432f
movq (%rax), %rsi
movq %rbx, %rdi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x52f6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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, 0x4(%rsp)
movq %rsi, %rbx
movq %rdi, %r12
movq 0x10(%rdx), %r15
movq 0x18(%rdx), %rbp
xorl %r13d, %r13d
movq %rbp, %rax
movl %eax, %ecx
andl $0x7, %ecx
cmpq $0x3, %rcx
je 0x5c57
testq %rcx, %rcx
jne 0x5c60
movl (%rax), %ecx
jmp 0x5c5c
movl %eax, %ecx
sarl $0x3, %ecx
testl %ecx, %ecx
je 0x5c84
movq 0x18(%rax), %rax
incl %r13d
jmp 0x5c43
movq 0x10(%rbp), %rdx
movq %r12, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %r14, %r9
callq 0x3a7b
movq 0x18(%rbp), %rbp
movl %ebp, %eax
andl $0x7, %eax
cmpq $0x3, %rax
je 0x5c99
testq %rax, %rax
jne 0x5c69
movl (%rbp), %eax
jmp 0x5c9e
movl %ebp, %eax
sarl $0x3, %eax
testl %eax, %eax
jne 0x5c69
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %r14, %r9
callq 0x3a7b
movzwl %r13w, %r14d
cmpl $0x1, 0x4(%rsp)
movl $0xc, %edx
sbbl $0x0, %edx
xorl %edi, %edi
xorl %esi, %esi
xorl %eax, %eax
callq 0x432f
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 0x52f6
// File: /workspace/github_c_makefile_star2_O3/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 0x5d10
cmpl $0x2, %eax
je 0x5d43
testq %rax, %rax
jne 0x5d4d
movl (%rsi), %ecx
jmp 0x5d15
movl %esi, %ecx
sarl $0x3, %ecx
testl %ecx, %ecx
je 0x5d2c
cmpl $0x3, %eax
je 0x5d39
cmpl $0x2, %eax
je 0x5d43
testq %rax, %rax
jne 0x5d4d
movl (%rsi), %eax
jmp 0x5d3e
movl $0x3, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl %esi, %eax
sarl $0x3, %eax
cmpl $0x3, %eax
jne 0x5d4d
movl $0x3, %edx
movq %rbx, %rdi
jmp 0x5d66
movq 0x10(%rsi), %r14
movq 0x18(%rsi), %rsi
movq %rbx, %rdi
callq 0x5cf0
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2298
// File: /workspace/github_c_makefile_star2_O3/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, %r8d
andl $0x7, %r8d
cmpq $0x3, %r8
je 0x5d8b
testq %r8, %r8
jne 0x5d97
movl (%rdi), %r8d
jmp 0x5d92
movl %edi, %r8d
sarl $0x3, %r8d
testl %r8d, %r8d
je 0x5e0c
leaq 0x10(%rdi), %r9
xorl %r8d, %r8d
movq (%r9), %r9
movl %r9d, %r10d
andl $0x7, %r10d
cmpq $0x3, %r10
je 0x5db8
testq %r10, %r10
jne 0x5dc4
movl (%r9), %r10d
jmp 0x5dbf
movl %r9d, %r10d
sarl $0x3, %r10d
testl %r10d, %r10d
je 0x5dd3
cmpq %rsi, 0x10(%r9)
je 0x5e01
incl %r8d
addq $0x18, %r9
jmp 0x5d9e
movq 0x18(%rdi), %rdi
movl %edi, %r8d
andl $0x7, %r8d
cmpq $0x3, %r8
je 0x5dee
testq %r8, %r8
jne 0x5dfa
movl (%rdi), %r8d
jmp 0x5df5
movl %edi, %r8d
sarl $0x3, %r8d
testl %r8d, %r8d
je 0x5e0c
incl %eax
jmp 0x5d74
movl %r8d, (%rdx)
movl %eax, (%rcx)
movl $0x1, %eax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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, %r13d
movq %rdi, %rbx
leaq 0x10(%rsp), %rdx
movq %rsi, (%rdx)
movslq 0x2040(%rdi), %rax
leal 0x1(%rax), %ecx
movl %ecx, 0x2040(%rdi)
movq %rdx, 0x40(%rdi,%rax,8)
movslq %r8d, %r12
leaq 0x20(,%r12,8), %rdx
movl $0x10, %esi
callq 0x2122
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%r14)
movl %r12d, 0x18(%r14)
testl %r13d, %r13d
jle 0x5e92
movl %r13d, %eax
xorl %ecx, %ecx
movq (%r15,%rcx,8), %rdx
movq %rdx, 0x20(%r14,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x5e7c
movl %r13d, %r12d
jmp 0x5e95
xorl %r12d, %r12d
cmpl $0x0, 0x8(%rsp)
sete %al
cmpl %r13d, %ebp
setle %cl
orb %al, %cl
jne 0x5f02
movl %r12d, %eax
movq %rax, 0x8(%rsp)
movq (%r15,%rax,8), %rsi
movl $0x3, %edx
movq %rbx, %rdi
callq 0x2298
movq %rax, %r13
movq 0x8(%rsp), %rax
movq %r13, 0x20(%r14,%rax,8)
incl %r12d
cmpl %ebp, %r12d
jge 0x5f0e
leaq (%r15,%rax,8), %r15
addq $0x8, %r15
movq (%r15), %rsi
movl $0x3, %edx
movq %rbx, %rdi
callq 0x2298
movq %rax, 0x18(%r13)
addq $0x8, %r15
incl %r12d
movq %rax, %r13
cmpl %ebp, %r12d
jl 0x5edd
jmp 0x5f0e
movl %r12d, %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_O3/aparrish[P]rwet-examples-c/ap_getline.c
// Function: ap_getline
size_t ap_getline(char** linep, FILE* fp) {
	int current_index = 0;
	int length = 80;

	*linep = (char*)malloc(length);
	if (*linep == NULL) return -1;

	while (1) {
		int ch;
		ch = getc(fp);
		if (ch == EOF) {
			break;
		}
		/* if the string would be longer than the allocated buffer */
		/* + 2: one because current_index is zero-based, one for trailing \0 */
		if (current_index + 2 > length) {
			/* eighty more chars */
			size_t new_length = length + 80;
			char *new_linep;
			new_linep = (char*)realloc(*linep, new_length);
			if (new_linep == NULL) return -1;

			*linep = new_linep;
			length = new_length;
		}
		(*linep)[current_index] = ch;
		current_index++;
		if (ch == '\n') break;
	}
	(*linep)[current_index] = '\0';
	return current_index;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movl $0x50, %edi
callq 0x1090
movq %rax, (%rbx)
movq $-0x1, %r14
testq %rax, %rax
je 0x1cc9
movl $0x50, %r13d
xorl %r12d, %r12d
movq %r15, %rdi
callq 0x10e0
cmpl $-0x1, %eax
je 0x1cbe
movl %eax, %ebp
leal 0x2(%r12), %ecx
movq (%rbx), %rax
cmpl %r13d, %ecx
jle 0x1cb2
addl $0x50, %r13d
movslq %r13d, %rsi
movq %rax, %rdi
callq 0x10b0
testq %rax, %rax
je 0x1cc9
movq %rax, (%rbx)
movb %bpl, (%rax,%r12)
incq %r12
cmpl $0xa, %ebp
jne 0x1c7f
movq (%rbx), %rax
movslq %r12d, %r14
movb $0x0, (%rax,%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x24e5
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 0x24c3
cmpq $0x1, %rbx
adcq $0x0, %rbx
movq %rbx, %rdi
callq 0x2541
movq %rax, %rcx
testq %r14, %r14
jns 0x2504
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 0x2510
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq