LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/mtnygard[P]complisp/lisp.c
// Function: Compile_expr
int Compile_expr(Buffer *buf, ASTNode *node, word stack_index, Env *varenv,
                 Env *labels) {
  if (AST_is_integer(node)) {
    word value = AST_get_integer(node);
    Emit_mov_reg_imm32(buf, kRax, Object_encode_integer(value));
    return 0;
  }
  if (AST_is_char(node)) {
    char value = AST_get_char(node);
    Emit_mov_reg_imm32(buf, kRax, Object_encode_char(value));
    return 0;
  }
  if (AST_is_bool(node)) {
    bool value = AST_get_bool(node);
    Emit_mov_reg_imm32(buf, kRax, Object_encode_bool(value));
    return 0;
  }
  if (AST_is_nil(node)) {
    Emit_mov_reg_imm32(buf, kRax, Object_nil());
    return 0;
  }
  if (AST_is_pair(node)) {
    return Compile_call(buf, AST_pair_car(node), AST_pair_cdr(node),
                        stack_index, varenv, labels);
  }
  if (AST_is_symbol(node)) {
    const char *symbol = AST_symbol_cstr(node);
    word value;
    if (Env_find(varenv, symbol, &value)) {
      Emit_load_reg_indirect(buf, kRax, Ind(kRsp, value));
      return 0;
    }
    return -1;
  }
  assert(0 && "unexpected node type");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testb $0x3, %r14b
je 0x2b16
movl %r14d, %eax
andl $0x3f, %eax
cmpq $0x1f, %rax
je 0x2b2e
cmpl $0xf, %eax
jne 0x2b46
movswl %r14w, %edx
andl $0xffffff00, %edx       # imm = 0xFFFFFF00
orl $0xf, %edx
xorl %r12d, %r12d
movq %rbx, %rdi
xorl %esi, %esi
jmp 0x2b95
sarq $0x2, %r14
movq %r14, %rdi
callq 0x170c
xorl %r12d, %r12d
movq %rbx, %rdi
xorl %esi, %esi
movl %eax, %edx
jmp 0x2b95
andl $0x80, %r14d
orl $0x1f, %r14d
xorl %r12d, %r12d
movq %rbx, %rdi
xorl %esi, %esi
movl %r14d, %edx
jmp 0x2b95
cmpq $0x2f, %r14
je 0x2b88
movq %rcx, %r15
movl %r14d, %eax
andl $0x7, %eax
cmpq $0x5, %rax
je 0x2ba6
cmpl $0x1, %eax
jne 0x2bf1
movq %r8, %r9
movq %rdx, %rcx
andq $-0x8, %r14
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
movq %r15, %r8
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2c10
xorl %r12d, %r12d
movq %rbx, %rdi
xorl %esi, %esi
movl $0x2f, %edx
callq 0x1f98
movl %r12d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
testq %r15, %r15
je 0x2b9a
andq $-0x8, %r14
addq $0x8, %r14
movq (%r15), %rdi
movq %r14, %rsi
callq 0x10f0
testl %eax, %eax
je 0x2bd3
movq 0x10(%r15), %r15
testq %r15, %r15
jne 0x2bb9
jmp 0x2b9a
movq 0x8(%r15), %rax
movzbl %al, %edx
shlq $0x20, %rdx
orq $0x4, %rdx
xorl %r12d, %r12d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x27ca
jmp 0x2b9a
leaq 0xcb06(%rip), %rdi      # 0xf6fe
leaq 0xc97c(%rip), %rsi      # 0xf57b
leaq 0xcb14(%rip), %rcx      # 0xf71a
movl $0x2aa, %edx            # imm = 0x2AA
callq 0x1090
// File: /workspace/github_c_makefile_star2_O3/mtnygard[P]complisp/lisp.c
// Function: Compile_if
int Compile_if(Buffer *buf, ASTNode *cond, ASTNode *consequent,
               ASTNode *alternate, word stack_index, Env *varenv, Env *labels) {
  _(Compile_expr(buf, cond, stack_index, varenv, labels));
  Emit_cmp_reg_imm32(buf, kRax, Object_false());
  word alternate_pos = Emit_jcc(buf, kEqual, kLabelPlaceholder);
  _(Compile_expr(buf, consequent, stack_index, varenv, labels));
  word end_pos = Emit_jmp(buf, kLabelPlaceholder);
  Emit_backpatch_imm32(buf, alternate_pos);
  _(Compile_expr(buf, alternate, stack_index, varenv, labels));
  Emit_backpatch_imm32(buf, end_pos);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r12
movq %r8, %r15
movq %rcx, %r14
movq %rdx, %r13
movq %rdi, %rbx
movq 0x10(%rbp), %r8
movq %r15, %rdx
movq %r9, %rcx
callq 0x2ad7
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
testl %eax, %eax
jne 0x372c
movq %r14, -0x38(%rbp)
movq %rbx, %rdi
xorl %esi, %esi
movl $0x1f, %edx
callq 0x2400
movq %rbx, %rdi
movl $0x4, %esi
movl $0xdeadbeef, %edx       # imm = 0xDEADBEEF
callq 0x2832
movq %rax, -0x30(%rbp)
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %r12, %rcx
movq 0x10(%rbp), %r14
movq %r14, %r8
callq 0x2ad7
testl %eax, %eax
je 0x3688
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
jmp 0x372c
movq %r15, %r13
movq %r12, %r15
movl $0x1, %esi
movq %rbx, %rdi
callq 0x1df5
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%rbx)
movb $-0x17, (%rax,%rcx)
movq 0x10(%rbx), %r12
movq %rbx, %rdi
movl $0xdeadbeef, %esi       # imm = 0xDEADBEEF
callq 0x1eab
movl 0x10(%rbx), %eax
movslq -0x30(%rbp), %rdx
subl %edx, %eax
addl $-0x4, %eax
xorl %ecx, %ecx
movl %eax, %esi
shrl %cl, %esi
movq (%rbx), %rdi
movb %sil, (%rdi,%rdx)
addq $0x8, %rcx
incq %rdx
cmpq $0x20, %rcx
jne 0x36cd
movq %rbx, %rdi
movq -0x38(%rbp), %rsi
movq %r13, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0x2ad7
testl %eax, %eax
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
jne 0x372c
movl 0x10(%rbx), %eax
movslq %r12d, %rdx
subl %edx, %eax
addl $-0x4, %eax
xorl %r8d, %r8d
xorl %ecx, %ecx
movl %eax, %esi
shrl %cl, %esi
movq (%rbx), %rdi
movb %sil, (%rdi,%rdx)
addq $0x8, %rcx
incq %rdx
cmpq $0x20, %rcx
jne 0x3714
movl %r8d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mtnygard[P]complisp/lisp.c
// Function: Compile_cons
int Compile_cons(Buffer *buf, ASTNode *car, ASTNode *cdr, int stack_index,
                 Env *varenv, Env *labels) {
  // Compile and store car on the stack
  _(Compile_expr(buf, car, stack_index, varenv, labels));
  Emit_store_reg_indirect(buf, Ind(kRbp, stack_index), kRax);
  // Compile and store cdr
  _(Compile_expr(buf, cdr, stack_index - kWordSize, varenv, labels));
  Emit_store_reg_indirect(buf, Ind(kHeapPointer, kCdrOffset), kRax);
  // Fetch car and store in heap
  Emit_load_reg_indirect(buf, kRax, Ind(kRbp, stack_index));
  Emit_store_reg_indirect(buf, Ind(kHeapPointer, kCarOffset), kRax);

  // Store tagged pointer in tax
  Emit_mov_reg_reg(buf, kRax, kHeapPointer);
  Emit_or_reg_imm8(buf, kRax, kPairTag);
  // Bump the heap pointer
  Emit_add_reg_imm32(buf, kHeapPointer, kPairSize);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movq %r8, %r12
movl %ecx, %r13d
movq %rdx, %r15
movq %rdi, %rbx
movslq %ecx, %rdx
movq %r8, %rcx
movq %r9, %r8
callq 0x2ad7
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testl %eax, %eax
jne 0x3817
movq %r15, -0x30(%rbp)
movzbl %r13b, %r15d
shlq $0x20, %r15
orq $0x5, %r15
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x25ce
addl $-0x8, %r13d
movslq %r13d, %rdx
movq %rbx, %rdi
movq -0x30(%rbp), %rsi
movq %r12, %rcx
movq %r14, %r8
callq 0x2ad7
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testl %eax, %eax
jne 0x3817
movabsq $0x800000006, %rsi      # imm = 0x800000006
movq %rbx, %rdi
xorl %edx, %edx
callq 0x25ce
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x27ca
movl $0x6, %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x25ce
movq %rbx, %rdi
xorl %esi, %esi
movl $0x6, %edx
callq 0x2914
movq %rbx, %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x22be
movq %rbx, %rdi
movl $0x6, %esi
movl $0x10, %edx
callq 0x2050
xorl %ecx, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mtnygard[P]complisp/lisp.c
// Function: list_length
word list_length(ASTNode *node) {
  if (AST_is_nil(node)) {
    return 0;
  }
  assert(AST_is_pair(node));
  return 1 + list_length(AST_pair_cdr(node));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
cmpq $0x2f, %rdi
je 0x384b
movl %edi, %ecx
andl $0x7, %ecx
cmpl $0x1, %ecx
jne 0x384d
andq $-0x8, %rdi
movq 0x8(%rdi), %rdi
incq %rax
jmp 0x382e
popq %rbp
retq
leaq 0xbdc2(%rip), %rdi      # 0xf616
leaq 0xbd20(%rip), %rsi      # 0xf57b
leaq 0xbef2(%rip), %rcx      # 0xf754
movl $0x2d6, %edx            # imm = 0x2D6
callq 0x1090
// File: /workspace/github_c_makefile_star2_O3/mtnygard[P]complisp/lisp.c
// Function: Compile_labelcall
int Compile_labelcall(Buffer *buf, ASTNode *callable, ASTNode *args,
                      word stack_index, Env *varenv, Env *labels, word nargs,
                      word rsp_adjust) {
  if (AST_is_nil(args)) {
    const char *symbol = AST_symbol_cstr(callable);
    word code_address;
    if (!Env_find(labels, symbol, &code_address)) {
      return -1;
    }
    Emit_rsp_adjust(buf, rsp_adjust);
    Emit_call_imm32(buf, code_address);
    Emit_rsp_adjust(buf, -rsp_adjust);
    return 0;
  }

  assert(AST_is_pair(args));
  ASTNode *arg = AST_pair_car(args);
  _(Compile_expr(buf, arg, stack_index, varenv, labels));
  Emit_store_reg_indirect(buf, Ind(kRsp, stack_index), kRax);
  return Compile_labelcall(buf, callable, AST_pair_cdr(args),
                           stack_index - kWordSize, varenv, labels, nargs,
                           rsp_adjust);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r14
movq %r8, -0x38(%rbp)
movq %rsi, -0x30(%rbp)
movq %rdi, %rbx
cmpq $0x2f, %rdx
je 0x3903
movq %rcx, %r12
movq %rdx, %r15
movq %rcx, %r13
shlq $0x20, %r13
movl %r15d, %eax
andl $0x7, %eax
cmpl $0x1, %eax
jne 0x398c
andq $-0x8, %r15
movq (%r15), %rsi
movq %rbx, %rdi
movq %r12, %rdx
movq -0x38(%rbp), %rcx
movq %r14, %r8
callq 0x2ad7
testl %eax, %eax
jne 0x3947
movq %r13, %rsi
movabsq $0xff00000000, %rax     # imm = 0xFF00000000
andq %rax, %rsi
orq $0x4, %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x25ce
movq 0x8(%r15), %r15
addq $-0x8, %r12
movabsq $-0x800000000, %rax     # imm = 0xFFFFFFF800000000
addq %rax, %r13
cmpq $0x2f, %r15
jne 0x389e
movq -0x30(%rbp), %r13
movl %r13d, %eax
andl $0x7, %eax
cmpl $0x5, %eax
jne 0x39ab
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
testq %r14, %r14
je 0x397a
movq 0x18(%rbp), %r12
andq $-0x8, %r13
addq $0x8, %r13
movq (%r14), %rdi
movq %r13, %rsi
callq 0x10f0
testl %eax, %eax
je 0x394f
movq 0x10(%r14), %r14
testq %r14, %r14
jne 0x392d
jmp 0x397a
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
jmp 0x397a
movq 0x8(%r14), %r14
movq %rbx, %rdi
movq %r12, %rsi
callq 0x299a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x29c2
negq %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x299a
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xbddd(%rip), %rdi      # 0xf770
leaq 0xbbe1(%rip), %rsi      # 0xf57b
leaq 0xbde1(%rip), %rcx      # 0xf782
movl $0x2e9, %edx            # imm = 0x2E9
callq 0x1090
leaq 0xbc93(%rip), %rdi      # 0xf645
leaq 0xbbc2(%rip), %rsi      # 0xf57b
leaq 0xbc99(%rip), %rcx      # 0xf659
movl $0x110, %edx            # imm = 0x110
callq 0x1090
// File: /workspace/github_c_makefile_star2_O3/mtnygard[P]complisp/lisp.c
// Function: Compile_let
int Compile_let(Buffer *buf, ASTNode *bindings, ASTNode *body, word stack_index,
                Env *binding_env, Env *body_env, Env *labels) {
  if (AST_is_nil(bindings)) {
    // Base case: no bindings (or none left)
    _(Compile_expr(buf, body, stack_index, body_env, labels));
    return 0;
  }
  assert(AST_is_pair(bindings));
  // Unpack the binding
  ASTNode *binding = AST_pair_car(bindings);
  ASTNode *name = AST_pair_car(binding);
  assert(AST_is_symbol(name));
  ASTNode *binding_expr = AST_pair_car(AST_pair_cdr(binding));
  // Evaluate the RHS, store result on stack
  _(Compile_expr(buf, binding_expr, stack_index, binding_env, labels));
  Emit_store_reg_indirect(buf, Ind(kRsp, stack_index), kRax);
  // Bind the name to a stack offset
  Env entry = Env_bind(AST_symbol_cstr(name), stack_index, body_env);
  _(Compile_let(buf, AST_pair_cdr(bindings), body, stack_index - kWordSize,
                binding_env, &entry, labels));
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %rbx
movq %rdi, %r15
movq 0x10(%rbp), %r10
cmpq $0x2f, %rsi
je 0x3ade
movq %rsi, %r13
movl %r13d, %eax
andl $0x7, %eax
cmpl $0x1, %eax
jne 0x3b1f
andq $-0x8, %r13
movq (%r13), %rax
movl %eax, %ecx
andl $0x7, %ecx
cmpl $0x1, %ecx
jne 0x3b00
andq $-0x8, %rax
movq (%rax), %r12
movl %r12d, %ecx
andl $0x7, %ecx
cmpl $0x5, %ecx
jne 0x3b3e
movq %r9, -0x40(%rbp)
movq %rdx, -0x48(%rbp)
movq 0x8(%rax), %rax
movl %eax, %ecx
andl $0x7, %ecx
cmpl $0x1, %ecx
jne 0x3b00
andq $-0x8, %rax
movq (%rax), %rsi
movq %r15, %rdi
movq %rbx, %rdx
movq %r8, %rcx
movq %r8, -0x38(%rbp)
movq %r10, %r8
movq %r10, -0x30(%rbp)
callq 0x2ad7
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
testl %eax, %eax
jne 0x3acc
movzbl %bl, %esi
shlq $0x20, %rsi
orq $0x4, %rsi
xorl %r14d, %r14d
movq %r15, %rdi
xorl %edx, %edx
callq 0x25ce
andq $-0x8, %r12
addq $0x8, %r12
leaq -0x60(%rbp), %r9
movq %r12, (%r9)
movq %rbx, 0x8(%r9)
movq -0x40(%rbp), %rax
movq %rax, 0x10(%r9)
movq 0x8(%r13), %rsi
addq $-0x8, %rbx
movq -0x30(%rbp), %rax
movq %rax, (%rsp)
movq %r15, %rdi
movq -0x48(%rbp), %rdx
movq %rbx, %rcx
movq -0x38(%rbp), %r8
callq 0x39ca
negl %eax
sbbl %r14d, %r14d
movl %r14d, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
movq %rdx, %rsi
movq %rbx, %rdx
movq %r9, %rcx
movq %r10, %r8
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2ad7
leaq 0xbb0f(%rip), %rdi      # 0xf616
leaq 0xba6d(%rip), %rsi      # 0xf57b
leaq 0xbb13(%rip), %rcx      # 0xf628
movl $0xf0, %edx
callq 0x1090
leaq 0xbd79(%rip), %rdi      # 0xf89f
leaq 0xba4e(%rip), %rsi      # 0xf57b
leaq 0xbd81(%rip), %rcx      # 0xf8b5
movl $0x386, %edx            # imm = 0x386
callq 0x1090
leaq 0xbdbb(%rip), %rdi      # 0xf900
leaq 0xba2f(%rip), %rsi      # 0xf57b
leaq 0xbd62(%rip), %rcx      # 0xf8b5
movl $0x38a, %edx            # imm = 0x38A
callq 0x1090
// File: /workspace/github_c_makefile_star2_O3/mtnygard[P]complisp/lisp.c
// Function: Compile_compare_imm32
void Compile_compare_imm32(Buffer *buf, int32_t value) {
  Emit_cmp_reg_imm32(buf, kRax, value);
  Emit_mov_reg_imm32(buf, kRax, 0);
  Emit_setcc_imm8(buf, kEqual, kAl);
  Emit_shl_reg_imm8(buf, kRax, kBoolShift);
  Emit_or_reg_imm8(buf, kRax, kBoolTag);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %esi, %edx
movq %rdi, %rbx
xorl %esi, %esi
callq 0x2400
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1f98
movq %rbx, %rdi
movl $0x4, %esi
xorl %edx, %edx
callq 0x2492
movq %rbx, %rdi
xorl %esi, %esi
movl $0x7, %edx
callq 0x217c
movq %rbx, %rdi
xorl %esi, %esi
movl $0x1f, %edx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x22be
// File: /workspace/github_c_makefile_star2_O3/mtnygard[P]complisp/lisp.c
// Function: Compile_code_impl
int Compile_code_impl(Buffer *buf, ASTNode *formals, ASTNode *body,
                      word stack_index, Env *varenv) {
  if (AST_is_nil(formals)) {
    _(Compile_expr(buf, body, stack_index, varenv, NULL));
    Buffer_write_arr(buf, kFunctionEpilogue, sizeof kFunctionEpilogue);
    return 0;
  }

  assert(AST_is_pair(formals));
  ASTNode *name = AST_pair_car(formals);
  assert(AST_is_symbol(name));
  Env entry = Env_bind(AST_symbol_cstr(name), stack_index, varenv);
  return Compile_code_impl(buf, AST_pair_cdr(formals), body,
                           stack_index - kWordSize, &entry);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
cmpq $0x2f, %rsi
je 0x3c0f
movl %esi, %eax
andl $0x7, %eax
cmpl $0x1, %eax
jne 0x3c57
andq $-0x8, %rsi
movq (%rsi), %rdi
movl %edi, %eax
andl $0x7, %eax
cmpl $0x5, %eax
jne 0x3c76
andq $-0x8, %rdi
addq $0x8, %rdi
leaq -0x20(%rbp), %rax
movq %rdi, (%rax)
movq %rcx, 0x8(%rax)
movq %r8, 0x10(%rax)
movq 0x8(%rsi), %rsi
addq $-0x8, %rcx
movq %rbx, %rdi
movq %rax, %r8
callq 0x3bae
jmp 0x3c50
movq %rbx, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
movq %r8, %rcx
xorl %r8d, %r8d
callq 0x2ad7
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0x3c50
movl $0x1, %esi
movq %rbx, %rdi
callq 0x1df5
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%rbx)
movb $-0x3d, (%rax,%rcx)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
leaq 0xbcb6(%rip), %rdi      # 0xf914
leaq 0xb916(%rip), %rsi      # 0xf57b
leaq 0xbcbd(%rip), %rcx      # 0xf929
movl $0x3ab, %edx            # imm = 0x3AB
callq 0x1090
leaq 0xbc83(%rip), %rdi      # 0xf900
leaq 0xb8f7(%rip), %rsi      # 0xf57b
leaq 0xbc9e(%rip), %rcx      # 0xf929
movl $0x3ad, %edx            # imm = 0x3AD
callq 0x1090
// File: /workspace/github_c_makefile_star2_O3/mtnygard[P]complisp/lisp.c
// Function: Compile_code
int Compile_code(Buffer *buf, ASTNode *code) {
  assert(AST_is_pair(code));
  ASTNode *code_sym = AST_pair_car(code);
  assert(AST_is_symbol(code_sym));
  assert(AST_symbol_matches(code_sym, "code"));
  ASTNode *formals = AST_pair_car(AST_pair_cdr(code));
  ASTNode *code_body = AST_pair_car(AST_pair_cdr(AST_pair_cdr(code)));
  return Compile_code_impl(buf, formals, code_body, -kWordSize, NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movl %r14d, %eax
andl $0x7, %eax
cmpl $0x1, %eax
jne 0x3d39
movq %rdi, %rbx
andq $-0x8, %r14
movq (%r14), %rdi
movl %edi, %eax
andl $0x7, %eax
cmpl $0x5, %eax
jne 0x3d58
leaq 0xbcef(%rip), %rsi      # 0xf9bc
callq 0x1c97
testb %al, %al
je 0x3d77
movq 0x8(%r14), %rax
movl %eax, %ecx
andl $0x7, %ecx
cmpl $0x1, %ecx
jne 0x3d1a
andq $-0x8, %rax
movq 0x8(%rax), %rcx
movl %ecx, %edx
andl $0x7, %edx
cmpl $0x1, %edx
jne 0x3d1a
movq (%rax), %rsi
andq $-0x8, %rcx
movq (%rcx), %rdx
movq %rbx, %rdi
movq $-0x8, %rcx
xorl %r8d, %r8d
popq %rbx
popq %r14
popq %rbp
jmp 0x3bae
leaq 0xb8f5(%rip), %rdi      # 0xf616
leaq 0xb853(%rip), %rsi      # 0xf57b
leaq 0xb8f9(%rip), %rcx      # 0xf628
movl $0xf0, %edx
callq 0x1090
leaq 0xbc2c(%rip), %rdi      # 0xf96c
leaq 0xb834(%rip), %rsi      # 0xf57b
leaq 0xbc30(%rip), %rcx      # 0xf97e
movl $0x3b4, %edx            # imm = 0x3B4
callq 0x1090
leaq 0xbc45(%rip), %rdi      # 0xf9a4
leaq 0xb815(%rip), %rsi      # 0xf57b
leaq 0xbc11(%rip), %rcx      # 0xf97e
movl $0x3b6, %edx            # imm = 0x3B6
callq 0x1090
leaq 0xbc43(%rip), %rdi      # 0xf9c1
leaq 0xb7f6(%rip), %rsi      # 0xf57b
leaq 0xbbf2(%rip), %rcx      # 0xf97e
movl $0x3b7, %edx            # imm = 0x3B7
callq 0x1090
// File: /workspace/github_c_makefile_star2_O3/mtnygard[P]complisp/lisp.c
// Function: Compile_entry
WARN_UNUSED int Compile_entry(Buffer *buf, ASTNode *node) {
  Buffer_write_arr(buf, kEntryPrologue, sizeof kEntryPrologue);
  if (AST_is_pair(node)) {
    // Assume it's (labels ...)
    ASTNode *labels_sym = AST_pair_car(node);
    if (AST_is_symbol(labels_sym) && AST_symbol_matches(labels_sym, "labels")) {
      // Jump to body
      word body_pos = Emit_jmp(buf, kLabelPlaceholder);
      ASTNode *bindings = AST_pair_car(AST_pair_cdr(node));
      assert(AST_is_pair(bindings) || AST_is_nil(bindings));
      ASTNode *body = AST_pair_car(AST_pair_cdr(AST_pair_cdr(node)));
      _(Compile_labels(buf, bindings, body, /*labels=*/NULL, body_pos));
      return 0;
    }
  }
  _(Compile_expr(buf, node, /*stack_index=*/-kWordSize, /*varenv=*/NULL,
                 /*labels=*/NULL));
  Buffer_write_arr(buf, kFunctionEpilogue, sizeof kFunctionEpilogue);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorl %r15d, %r15d
leaq 0xb151(%rip), %r12      # 0xf0b1
movb (%r15,%r12), %r13b
movl $0x1, %esi
movq %rbx, %rdi
callq 0x1df5
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%rbx)
movb %r13b, (%rax,%rcx)
incq %r15
cmpq $0x3, %r15
jne 0x3f60
movl %r14d, %eax
andl $0x7, %eax
cmpl $0x1, %eax
jne 0x405c
movq %r14, %r15
andq $-0x8, %r15
movq (%r15), %rdi
movl %edi, %eax
andl $0x7, %eax
cmpl $0x5, %eax
jne 0x405c
leaq 0xc483(%rip), %rsi      # 0x1043e
callq 0x1c97
testb %al, %al
je 0x405c
movl $0x1, %esi
movq %rbx, %rdi
callq 0x1df5
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%rbx)
movb $-0x17, (%rax,%rcx)
movq 0x10(%rbx), %r14
movq %rbx, %rdi
movl $0xdeadbeef, %esi       # imm = 0xDEADBEEF
callq 0x1eab
movq 0x8(%r15), %rax
movl %eax, %ecx
andl $0x7, %ecx
cmpl $0x1, %ecx
jne 0x40af
andq $-0x8, %rax
movq (%rax), %rsi
movl %esi, %ecx
andl $0x7, %ecx
cmpl $0x1, %ecx
sete %cl
cmpq $0x2f, %rsi
sete %dl
orb %cl, %dl
je 0x40ce
movq 0x8(%rax), %rax
movl %eax, %ecx
andl $0x7, %ecx
cmpl $0x1, %ecx
jne 0x40af
andq $-0x8, %rax
movq (%rax), %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
movq %r14, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3d96
movq %rbx, %rdi
movq %r14, %rsi
movq $-0x8, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x2ad7
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0x40a0
movl $0x1, %esi
movq %rbx, %rdi
callq 0x1df5
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%rbx)
movb $-0x3d, (%rax,%rcx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xb560(%rip), %rdi      # 0xf616
leaq 0xb4be(%rip), %rsi      # 0xf57b
leaq 0xb564(%rip), %rcx      # 0xf628
movl $0xf0, %edx
callq 0x1090
leaq 0xb951(%rip), %rdi      # 0xfa26
leaq 0xb49f(%rip), %rsi      # 0xf57b
leaq 0xb971(%rip), %rcx      # 0xfa54
movl $0x3df, %edx            # imm = 0x3DF
callq 0x1090
// File: /workspace/github_c_makefile_star2_O3/mtnygard[P]complisp/lisp.c
// Function: starts_symbol
bool starts_symbol(char c) {
  switch (c) {
  case '+':
  case '-':
  case '*':
  case '<':
  case '>':
  case '=':
  case '?':
    return true;
  default:
    return isalpha(c);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
leal -0x2a(%rbx), %ecx
cmpb $0x16, %cl
jae 0x4170
movb $0x1, %al
movzbl %cl, %ecx
movl $0x3c000b, %edx         # imm = 0x3C000B
btl %ecx, %edx
jb 0x4185
callq 0x11a0
movq (%rax), %rax
movsbq %bl, %rcx
movb 0x1(%rax,%rcx,2), %al
andb $0x4, %al
shrb $0x2, %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mtnygard[P]complisp/lisp.c
// Function: read_integer
ASTNode *read_integer(char *input, word *pos, int sign) {
  char c = '\0';
  word result = 0;
  for (char c = input[*pos]; isdigit(c); c = next(input, pos)) {
    result *= 10;
    result += c - '0';
  }
  return AST_new_integer(result * sign);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %r12
callq 0x11a0
movq (%rax), %rax
movsbq (%r15,%r12), %rdx
testb $0x8, 0x1(%rax,%rdx,2)
jne 0x41ba
xorl %ecx, %ecx
jmp 0x41dd
incq %r12
xorl %ecx, %ecx
leaq (%rcx,%rcx,4), %rcx
leaq (%rdx,%rcx,2), %rcx
addq $-0x30, %rcx
movq %r12, (%r14)
movsbq (%r15,%r12), %rdx
incq %r12
testb $0x8, 0x1(%rax,%rdx,2)
jne 0x41bf
movslq %ebx, %rdi
imulq %rcx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x170c
// File: /workspace/github_c_makefile_star2_O3/mtnygard[P]complisp/lisp.c
// Function: read_symbol
ASTNode *read_symbol(char *input, word *pos) {
  char buf[ATOM_MAX + 1];
  word length = 0;
  for (length = 0; length < ATOM_MAX && is_symbol_char(input[*pos]); length++) {
    buf[length] = input[*pos];
    advance(pos);
  }
  buf[length] = '\0';
  return AST_new_symbol(buf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %r12
addq %r12, %r14
incq %r12
xorl %r15d, %r15d
movb (%r14,%r15), %r13b
movsbl %r13b, %edi
callq 0x41f1
testb %al, %al
je 0x4286
movb %r13b, -0x50(%rbp,%r15)
leaq (%r12,%r15), %rax
movq %rax, (%rbx)
incq %r15
cmpq $0x20, %r15
jne 0x425a
movl $0x20, %r15d
movb $0x0, -0x50(%rbp,%r15)
leaq -0x50(%rbp), %rdi
callq 0x1b9c
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mtnygard[P]complisp/lisp.c
// Function: read_char
ASTNode *read_char(char *input, word *pos) {
  char c = input[*pos];
  if (c == '\'') {
    return AST_error();
  }
  advance(pos);
  if (input[*pos] != '\'') {
    return AST_error();
  }
  advance(pos);
  return AST_new_char(c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq (%rsi), %rdx
movsbq (%rdi,%rdx), %rcx
movl $0x3f, %eax
cmpq $0x27, %rcx
je 0x42db
leaq 0x1(%rdx), %r8
movq %r8, (%rsi)
cmpb $0x27, 0x1(%rdi,%rdx)
jne 0x42db
addq $0x2, %rdx
movq %rdx, (%rsi)
shlq $0x8, %rcx
orq $0xf, %rcx
movq %rcx, %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mtnygard[P]complisp/lisp.c
// Function: read_list
ASTNode *read_list(char *input, word *pos) {
  char c = skip_whitespace(input, pos);
  if (c == ')') {
    advance(pos);
    return AST_nil();
  }
  ASTNode *car = read_rec(input, pos);
  assert(car != AST_error());
  ASTNode *cdr = read_list(input, pos);
  assert(cdr != AST_error());
  return AST_new_pair(car, cdr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x410a
cmpb $0x29, %al
jne 0x4309
incq (%rbx)
movl $0x2f, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4381
cmpq $0x3f, %rax
je 0x4343
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x42dd
cmpq $0x3f, %rax
je 0x4362
movq %r15, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1aa0
leaq 0xb731(%rip), %rdi      # 0xfa7b
leaq 0xb22a(%rip), %rsi      # 0xf57b
leaq 0xb736(%rip), %rcx      # 0xfa8e
movl $0x442, %edx            # imm = 0x442
callq 0x1090
leaq 0xb748(%rip), %rdi      # 0xfab1
leaq 0xb20b(%rip), %rsi      # 0xf57b
leaq 0xb717(%rip), %rcx      # 0xfa8e
movl $0x444, %edx            # imm = 0x444
callq 0x1090
// File: /workspace/github_c_makefile_star2_O3/mtnygard[P]complisp/lisp.c
// Function: read_rec
ASTNode *read_rec(char *input, word *pos) {
  char c = skip_whitespace(input, pos);
  if (isdigit(c)) {
    return read_integer(input, pos, 1);
  }
  if (c == '+' && isdigit(input[*pos + 1])) {
    advance(pos);
    return read_integer(input, pos, 1);
  }
  if (c == '-' && isdigit(input[*pos + 1])) {
    advance(pos);
    return read_integer(input, pos, -1);
  }
  if (starts_symbol(c)) {
    return read_symbol(input, pos);
  }
  if (c == '\'') {
    advance(pos);
    return read_char(input, pos);
  }
  if (c == '#' && input[*pos + 1] == 't') {
    advance(pos);
    advance(pos);
    return AST_new_bool(true);
  }
  if (c == '#' && input[*pos + 1] == 'f') {
    advance(pos);
    advance(pos);
    return AST_new_bool(false);
  }
  if (c == '(') {
    advance(pos);
    return read_list(input, pos);
  }
  return AST_error();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x410a
movl %eax, %r15d
callq 0x11a0
movq (%rax), %rdx
movsbq %r15b, %rax
movzwl (%rdx,%rax,2), %eax
btl $0xb, %eax
jb 0x4490
movzbl %r15b, %ecx
cmpl $0x3b, %ecx
jle 0x43d9
leal -0x3c(%rcx), %edx
cmpl $0x4, %edx
jae 0x4412
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4237
cmpl $0x2a, %ecx
je 0x43c4
cmpl $0x2b, %ecx
je 0x4476
cmpl $0x2d, %ecx
jne 0x4412
movq (%rbx), %rax
movsbq 0x1(%r14,%rax), %rcx
testb $0x8, 0x1(%rdx,%rcx,2)
je 0x43c4
incq %rax
movq %rax, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
jmp 0x449b
btl $0xa, %eax
jb 0x43c4
movl $0x3f, %eax
cmpb $0x23, %r15b
je 0x44c2
cmpl $0x28, %ecx
je 0x44aa
cmpl $0x27, %ecx
jne 0x44ef
movq (%rbx), %rdx
leaq 0x1(%rdx), %rcx
movq %rcx, (%rbx)
movsbq 0x1(%r14,%rdx), %rcx
cmpq $0x27, %rcx
je 0x44ef
leaq 0x2(%rdx), %rsi
movq %rsi, (%rbx)
cmpb $0x27, 0x2(%r14,%rdx)
jne 0x44ef
addq $0x3, %rdx
movq %rdx, (%rbx)
shlq $0x8, %rcx
orq $0xf, %rcx
movq %rcx, %rax
jmp 0x44ef
movq (%rbx), %rax
movsbq 0x1(%r14,%rax), %rcx
testb $0x8, 0x1(%rdx,%rcx,2)
je 0x43c4
incq %rax
movq %rax, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x418c
incq (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x42dd
movq (%rbx), %rcx
movzbl 0x1(%r14,%rcx), %edx
cmpl $0x66, %edx
je 0x44e3
cmpl $0x74, %edx
jne 0x44ef
addq $0x2, %rcx
movq %rcx, (%rbx)
movl $0x9f, %eax
jmp 0x44ef
addq $0x2, %rcx
movq %rcx, (%rbx)
movl $0x1f, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mtnygard[P]complisp/lisp.c
// Function: Testing_execute_entry
uword Testing_execute_entry(Buffer *buf, uword *heap) {
  assert(buf != NULL);
  assert(buf->address != NULL);
  assert(buf->state == kExecutable);
  // The pointer-pointer cast is allowed but the underlying
  // data-to-function-pointer back-and-forth is only guaranteed to work on
  // POSIX systems (because of eg dlsym).
  JitFunction function = *(JitFunction *)(&buf->address);
  return function(heap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x4538
movq (%rdi), %rax
testq %rax, %rax
je 0x4557
cmpl $0x1, 0x8(%rdi)
jne 0x4576
movq %rsi, %rdi
callq *%rax
cltq
popq %rbp
retq
leaq 0xb585(%rip), %rdi      # 0xfac4
leaq 0xb035(%rip), %rsi      # 0xf57b
leaq 0xb583(%rip), %rcx      # 0xfad0
movl $0x474, %edx            # imm = 0x474
callq 0x1090
leaq 0xb5a1(%rip), %rdi      # 0xfaff
leaq 0xb016(%rip), %rsi      # 0xf57b
leaq 0xb564(%rip), %rcx      # 0xfad0
movl $0x475, %edx            # imm = 0x475
callq 0x1090
leaq 0xb597(%rip), %rdi      # 0xfb14
leaq 0xaff7(%rip), %rsi      # 0xf57b
leaq 0xb545(%rip), %rcx      # 0xfad0
movl $0x476, %edx            # imm = 0x476
callq 0x1090
// File: /workspace/github_c_makefile_star2_O3/mtnygard[P]complisp/lisp.c
// Function: object_tests
SUITE(object_tests) {
  RUN_TEST(encode_positive_integer);
  RUN_TEST(encode_negative_integer);
  RUN_TEST(encode_char);
  RUN_TEST(decode_char);
  RUN_TEST(encode_bool);
  RUN_TEST(decode_bool);
  RUN_TEST(address);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xb4c3(%rip), %rdi      # 0xfb2e
callq 0x47f4
testl %eax, %eax
je 0x469d
leaq 0x10c55(%rip), %rdi     # 0x152d0
callq 0x10d0
movl %eax, %edi
testl %eax, %eax
jne 0x4698
addl $0x3, 0x10ac7(%rip)     # 0x15154
movq $0x0, 0x10ad0(%rip) # 0x15168
callq 0x49b2
leaq 0xb4a2(%rip), %rdi      # 0xfb46
callq 0x47f4
testl %eax, %eax
je 0x46d6
leaq 0x10c1c(%rip), %rdi     # 0x152d0
callq 0x10d0
movl %eax, %edi
testl %eax, %eax
jne 0x46d1
addl $0x3, 0x10a8e(%rip)     # 0x15154
movq $0x0, 0x10a97(%rip) # 0x15168
callq 0x49b2
leaq 0xb481(%rip), %rdi      # 0xfb5e
callq 0x47f4
testl %eax, %eax
je 0x470f
leaq 0x10be3(%rip), %rdi     # 0x152d0
callq 0x10d0
movl %eax, %edi
testl %eax, %eax
jne 0x470a
addl $0x2, 0x10a55(%rip)     # 0x15154
movq $0x0, 0x10a5e(%rip) # 0x15168
callq 0x49b2
leaq 0xb454(%rip), %rdi      # 0xfb6a
callq 0x47f4
testl %eax, %eax
je 0x4748
leaq 0x10baa(%rip), %rdi     # 0x152d0
callq 0x10d0
movl %eax, %edi
testl %eax, %eax
jne 0x4743
addl $0x2, 0x10a1c(%rip)     # 0x15154
movq $0x0, 0x10a25(%rip) # 0x15168
callq 0x49b2
leaq 0xb427(%rip), %rdi      # 0xfb76
callq 0x47f4
testl %eax, %eax
je 0x4781
leaq 0x10b71(%rip), %rdi     # 0x152d0
callq 0x10d0
movl %eax, %edi
testl %eax, %eax
jne 0x477c
addl $0x4, 0x109e3(%rip)     # 0x15154
movq $0x0, 0x109ec(%rip) # 0x15168
callq 0x49b2
leaq 0xb3fa(%rip), %rdi      # 0xfb82
callq 0x47f4
testl %eax, %eax
je 0x47ba
leaq 0x10b38(%rip), %rdi     # 0x152d0
callq 0x10d0
movl %eax, %edi
testl %eax, %eax
jne 0x47b5
addl $0x2, 0x109aa(%rip)     # 0x15154
movq $0x0, 0x109b3(%rip) # 0x15168
callq 0x49b2
leaq 0xc7c8(%rip), %rdi      # 0x10f89
callq 0x47f4
testl %eax, %eax
je 0x47f2
leaq 0x10aff(%rip), %rdi     # 0x152d0
callq 0x10d0
movl %eax, %edi
testl %eax, %eax
jne 0x47ed
incl 0x10972(%rip)           # 0x15154
movq $0x0, 0x1097b(%rip) # 0x15168
callq 0x49b2
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mtnygard[P]complisp/lisp.c
// Function: print_value
void print_value(uword object) {
  if (Object_is_integer(object)) {
    fprintf(stderr, "%ld", Object_decode_integer(object));
    return;
  }
  if (object == Object_false()) {
    fprintf(stderr, "#f");
    return;
  }
  if (object == Object_true()) {
    fprintf(stderr, "#t");
    return;
  }
  if (object == Object_nil()) {
    fprintf(stderr, "nil");
    return;
  }
  if (Object_is_char(object)) {
    fprintf(stderr, "%c", Object_decode_char(object));
    return;
  }
  if (AST_is_heap_object((ASTNode *)object) && AST_is_pair((ASTNode *)object)) {
    fprintf(stderr, "(");
    print_value((uword)AST_pair_car((ASTNode *)object));
    fprintf(stderr, " ");
    print_value((uword)AST_pair_cdr((ASTNode *)object));
    fprintf(stderr, ")");
    return;
  }
  fprintf(stderr, "Unprintable value");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
testb $0x3, %bl
je 0xd39c
cmpq $0x9f, %rbx
je 0xd3ad
cmpq $0x2f, %rbx
je 0xd3a6
cmpq $0x1f, %rbx
je 0xd3b4
movl %ebx, %eax
notl %eax
testb $0xf, %al
jne 0xd33f
movq 0x7cc4(%rip), %rax      # 0x14ff8
movq (%rax), %rsi
shrl $0x8, %ebx
movsbl %bl, %edi
jmp 0xd393
movl %ebx, %eax
andl $0x7, %eax
movq 0x7cad(%rip), %r14      # 0x14ff8
movq (%r14), %rsi
cmpl $0x1, %eax
jne 0xd3bb
movl %ebx, %ecx
andl $0x3, %ecx
je 0xd3bb
cmpl $0x7, %eax
je 0xd3bb
movl $0x28, %edi
callq 0x10c0
andq $-0x8, %rbx
movq (%rbx), %rdi
callq 0xd2f1
movq (%r14), %rsi
movl $0x20, %edi
callq 0x10c0
movq 0x8(%rbx), %rdi
callq 0xd2f1
movq (%r14), %rsi
movl $0x29, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x10c0
movq %rbx, %rdi
callq 0x149c
jmp 0xd3c3
callq 0x13e7
jmp 0xd3c3
callq 0x1416
jmp 0xd3c3
callq 0x1445
jmp 0xd3c3
movq %rsi, %rdi
callq 0x1474
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mtnygard[P]complisp/lisp.c
// Function: print_assembly
void print_assembly(char *line) {
  // Parse the line
  ASTNode *node = Reader_read(line);
  free(line);
  if (AST_is_error(node)) {
    fprintf(stderr, "Parse error.\n");
    return;
  }

  // Compile the line
  Buffer buf;
  Buffer_init(&buf, 1);
  int result = Compile_expr(&buf, node, /*stack_index=*/-kWordSize, NULL, NULL);
  AST_heap_free(node);
  if (result < 0) {
    fprintf(stderr, "Compile error.\n");
    Buffer_deinit(&buf);
    return;
  }

  // Print the assembled code
  for (size_t i = 0; i < buf.len; i++) {
    fprintf(stderr, "%.02x ", buf.address[i]);
  }
  fprintf(stderr, "\n");

  Buffer_deinit(&buf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
leaq -0x30(%rbp), %rsi
movq $0x0, (%rsi)
callq 0x4381
movq %rax, %rbx
movq %r14, %rdi
callq 0x1030
cmpq $0x3f, %rbx
je 0xd47d
movl $0x1, %edi
callq 0x1cd8
leaq -0x30(%rbp), %rdi
movq %rax, (%rdi)
movl $0x0, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movq $0x1, 0x18(%rdi)
movq %rbx, %rsi
movq $-0x8, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x2ad7
movl %eax, %r14d
movq %rbx, %rdi
callq 0x19d5
testl %r14d, %r14d
js 0xd484
movq -0x30(%rbp), %rbx
movq -0x20(%rbp), %rsi
testq %rsi, %rsi
jne 0xd4aa
movq 0x7b9d(%rip), %rax      # 0x14ff8
movq (%rax), %rsi
movl $0xa, %edi
callq 0x10c0
movq -0x18(%rbp), %rsi
movq %rbx, %rdi
callq 0x1150
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x150f
jmp 0xd474
movq 0x7b6d(%rip), %rax      # 0x14ff8
movq (%rax), %rcx
leaq 0x3092(%rip), %rdi      # 0x10527
movl $0xf, %esi
movl $0x1, %edx
callq 0x1190
movq -0x30(%rbp), %rbx
jmp 0xd468
movq %rbx, %rdi
callq 0x14c0
jmp 0xd454
// File: /workspace/github_c_makefile_star2_O3/mtnygard[P]complisp/lisp.c
// Function: evaluate_expr
void evaluate_expr(char *line) {
  if (!heap) {
    heap = malloc(1000 * kWordSize);
  }

  // Parse the line
  ASTNode *node = Reader_read(line);
  if (AST_is_error(node)) {
    fprintf(stderr, "Parse error.\n");
    return;
  }

  // Compile the line
  Buffer buf;
  Buffer_init(&buf, 1);
  int compile_result = Compile_entry(&buf, node);
  AST_heap_free(node);
  if (compile_result < 0) {
    fprintf(stderr, "Compile error.\n");
    Buffer_deinit(&buf);
    return;
  }

  // Execute the code
  Buffer_make_executable(&buf);
  uword result = Testing_execute_entry(&buf, heap);

  // Print the result
  print_value(result);
  fprintf(stderr, "\n");

  // Clean up
  Buffer_deinit(&buf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x7ece(%rip)      # 0x15398
jne 0xd4dd
movl $0x1f40, %edi           # imm = 0x1F40
callq 0x1120
movq %rax, 0x7ebb(%rip)      # 0x15398
leaq -0x30(%rbp), %rsi
movq $0x0, (%rsi)
movq %rbx, %rdi
callq 0x4381
cmpq $0x3f, %rax
je 0xd599
movq %rax, %rbx
movl $0x1, %edi
callq 0x1cd8
leaq -0x30(%rbp), %rdi
movq %rax, (%rdi)
movl $0x0, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movq $0x1, 0x18(%rdi)
movq %rbx, %rsi
callq 0x3f42
movl %eax, %r14d
movq %rbx, %rdi
callq 0x19d5
testl %r14d, %r14d
js 0xd5a0
leaq -0x30(%rbp), %rbx
movq (%rbx), %rdi
movq 0x10(%rbx), %rsi
movl $0x4, %edx
callq 0x1160
movl $0x1, 0x8(%rbx)
movq 0x7e38(%rip), %rsi      # 0x15398
movq %rbx, %rdi
callq 0x4518
movq %rax, %rdi
callq 0xd2f1
movq 0x7a81(%rip), %rax      # 0x14ff8
movq (%rax), %rsi
movl $0xa, %edi
callq 0x10c0
movq (%rbx), %rdi
movq 0x18(%rbx), %rsi
callq 0x1150
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x1576
jmp 0xd590
leaq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x153e
jmp 0xd590
// File: /workspace/github_c_makefile_star2_O3/mtnygard[P]complisp/lisp.c
// Function: run_tests
int run_tests(int argc, char **argv) {
  GREATEST_MAIN_BEGIN();
  RUN_SUITE(object_tests);
  RUN_SUITE(ast_tests);
  RUN_SUITE(buffer_tests);
  RUN_SUITE(compiler_tests);
  RUN_SUITE(reader_tests);
  GREATEST_MAIN_END();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl %edi, %r14d
callq 0xd8a1
cmpl $0x2, %r14d
jl 0xdf73
movb 0x7281(%rip), %cl       # 0x15111
movl $0x1, %edi
movb 0x7275(%rip), %dl       # 0x15110
leaq 0x116e(%rip), %rsi      # 0xf010
movslq %edi, %rax
movq (%rbx,%rax,8), %rax
cmpb $0x2d, (%rax)
jne 0xdf68
movzbl 0x1(%rax), %r8d
cmpl $0x72, %r8d
jle 0xdf08
leal -0x73(%r8), %r9d
cmpl $0x2, %r9d
jb 0xded7
cmpl $0x76, %r8d
je 0xdf23
cmpl $0x78, %r8d
jne 0xe021
leal 0x1(%rdi), %r8d
cmpl %r14d, %r8d
jge 0xe03c
cmpl $0x5, %r9d
ja 0xe021
movslq (%rsi,%r9,4), %r9
addq %rsi, %r9
jmpq *%r9
movslq %r8d, %rax
movq (%rbx,%rax,8), %rax
movq %rax, 0x7292(%rip)      # 0x15198
jmp 0xdf65
cmpl $0x65, %r8d
jle 0xdf2d
cmpl $0x66, %r8d
je 0xdf3c
cmpl $0x6c, %r8d
jne 0xe00c
orb $0x2, %dl
jmp 0xdf3f
incb %cl
movb %cl, 0x71e6(%rip)       # 0x15111
jmp 0xdf68
cmpl $0x61, %r8d
jne 0xdfe8
orb $0x4, %dl
jmp 0xdf3f
orb $0x1, %dl
movb %dl, 0x71cb(%rip)       # 0x15110
jmp 0xdf68
movslq %r8d, %rax
movq (%rbx,%rax,8), %rax
movq %rax, 0x7253(%rip)      # 0x151a8
jmp 0xdf65
movslq %r8d, %rax
movq (%rbx,%rax,8), %rax
movq %rax, 0x723b(%rip)      # 0x151a0
movl %r8d, %edi
incl %edi
cmpl %r14d, %edi
jl 0xdea2
leaq -0x991a(%rip), %rdi     # 0x4660
leaq 0x26d8(%rip), %rsi      # 0x10659
callq 0xd8ff
leaq -0x935e(%rip), %rdi     # 0x4c2f
leaq 0x26d2(%rip), %rsi      # 0x10666
callq 0xd8ff
leaq -0x7c3b(%rip), %rdi     # 0x6365
leaq 0x26c9(%rip), %rsi      # 0x10670
callq 0xd8ff
leaq -0x774a(%rip), %rdi     # 0x6869
leaq 0x26c3(%rip), %rsi      # 0x1067d
callq 0xd8ff
leaq -0x8fde(%rip), %rdi     # 0x4fe8
leaq 0x26bf(%rip), %rsi      # 0x1068c
callq 0xd8ff
callq 0xdafc
xorl %eax, %eax
cmpl $0x0, 0x716c(%rip)      # 0x1514c
setne %al
popq %rbx
popq %r14
popq %rbp
retq
cmpl $0x2d, %r8d
jne 0xe021
leaq 0x35d3(%rip), %rdi      # 0x115c8
movl $0x6, %edx
movq %rax, %rsi
callq 0x1050
testl %eax, %eax
jne 0xdf73
jmp 0xe012
cmpl $0x68, %r8d
jne 0xe021
movq (%rbx), %rdi
callq 0xe2ff
xorl %edi, %edi
callq 0x1180
movq 0x6fa8(%rip), %rcx      # 0x14fd0
movq (%rcx), %rdi
leaq 0x359d(%rip), %rsi      # 0x115cf
movq %rax, %rdx
xorl %eax, %eax
callq 0x1100
movq (%rbx), %rdi
callq 0xe2ff
movl $0x1, %edi
callq 0x1180
// File: /workspace/github_c_makefile_star2_O3/mtnygard[P]complisp/lisp.c
// Function: main
int main(int argc, char **argv) {
  if (argc == 2) {
    if (strcmp(argv[1], "--repl-assembly") == 0) {
      return repl(print_assembly);
    }
    if (strcmp(argv[1], "--repl-eval") == 0) {
      return repl(evaluate_expr);
    }
  }
  return run_tests(argc, argv);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
cmpl $0x2, %edi
jne 0xe08c
movq 0x8(%rbx), %r14
leaq 0x2631(%rip), %rsi      # 0x10699
movq %r14, %rdi
callq 0x10f0
testl %eax, %eax
je 0xe098
leaq 0x262e(%rip), %rsi      # 0x106a9
movq %r14, %rdi
callq 0x10f0
testl %eax, %eax
je 0xe0a1
movl $0x2, %edi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0xde6e
leaq -0xcd7(%rip), %rdi      # 0xd3c8
jmp 0xe0a8
leaq -0xbf4(%rip), %rdi      # 0xd4b4
callq 0x11c0
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/files/directory.cpp
// Function: GLOBAL__sub_I_directory.cpp
const char *S::Directory::GetDirectoryDelimiter()
{
	if (directoryDelimiter == NIL)
	{
#ifdef __WIN32__
		directoryDelimiter = (char *) "\\";
#else
		directoryDelimiter = (char *) "/";
#endif
	}

	return directoryDelimiter;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq 0x112608(%rip), %rax    # 0x16b970
movq (%rax), %rsi
testq %rsi, %rsi
jne 0x5937a
leaq 0x9a373(%rip), %rsi     # 0xf36ea
movq %rsi, (%rax)
leaq 0x1151af(%rip), %rbx    # 0x16e530
movq %rbx, %rdi
callq 0x579f0
movq 0x112ba0(%rip), %r15    # 0x16bf30
leaq 0x114ce9(%rip), %r14    # 0x16e080
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x57e10
movq %rbx, 0x11517c(%rip)    # 0x16e528
leaq 0x115195(%rip), %r12    # 0x16e548
leaq 0x9a330(%rip), %rsi     # 0xf36ea
movq %r12, %rdi
callq 0x579f0
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x57e10
leaq 0x115189(%rip), %r12    # 0x16e560
leaq 0x99e6c(%rip), %rsi     # 0xf324a
movq %r12, %rdi
callq 0x579f0
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x57e10
leaq 0x11517d(%rip), %r12    # 0x16e578
leaq 0x99e47(%rip), %rsi     # 0xf3249
movq %r12, %rdi
callq 0x579f0
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x57e10
leaq 0x115171(%rip), %r12    # 0x16e590
leaq 0xd025d(%rip), %rsi     # 0x129683
movq %r12, %rdi
callq 0x579f0
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x57e10
leaq 0x115165(%rip), %r13    # 0x16e5a8
leaq 0x9a79f(%rip), %rsi     # 0xf3be9
movq %r13, %rdi
callq 0x579f0
movq %r15, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x57e10
leaq 0x115159(%rip), %r13    # 0x16e5c0
leaq 0x99dde(%rip), %rsi     # 0xf324c
movq %r13, %rdi
callq 0x579f0
movq %r15, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x57e10
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x570b0
movq %r14, %rdi
movq %r12, %rsi
callq 0x562f0
leaq 0x11508a(%rip), %rsi    # 0x16e530
movq %rax, %rdi
callq 0x562f0
leaq 0x115123(%rip), %rdi    # 0x16e5d8
movq %rax, %rsi
callq 0x570b0
leaq 0x8(%rsp), %rdi
callq 0x59200
movq 0x112a62(%rip), %rdi    # 0x16bf30
leaq 0x115103(%rip), %rsi    # 0x16e5d8
leaq 0x114ba4(%rip), %rdx    # 0x16e080
callq 0x57e10
leaq 0x115048(%rip), %rsi    # 0x16e530
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x570b0
leaq 0x1150ac(%rip), %rsi    # 0x16e5a8
movq %rbx, %rdi
callq 0x562f0
leaq 0x115025(%rip), %rsi    # 0x16e530
movq %rax, %rdi
callq 0x562f0
leaq 0x1150d6(%rip), %rdi    # 0x16e5f0
movq %rax, %rsi
callq 0x570b0
leaq 0x8(%rsp), %rdi
callq 0x59200
movq 0x1129fd(%rip), %rdi    # 0x16bf30
leaq 0x1150b6(%rip), %rsi    # 0x16e5f0
leaq 0x114b3f(%rip), %rdx    # 0x16e080
callq 0x57e10
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x59556
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x59200
movq %rbx, %rdi
callq 0x57090
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/backends/backend.cpp
// Function: smooth::Backends::Backend::AddBackend(smooth::Backends::Backend* (*)())
S::Int S::Backends::Backend::AddBackend(Backend *(*backend)())
{
	if (backend == NIL) return Error();

	if (backend_creators == NIL) backend_creators = new Array<Backend *(*)(), Void *>;

	backend_creators->Add(backend);

	return Success();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, (%rsp)
testq %rdi, %rdi
je 0x5a9ac
movq 0x113aa0(%rip), %rbx    # 0x16e400
testq %rbx, %rbx
jne 0x5a99d
movl $0x58, %edi
callq 0x556b0
movq %rax, %rbx
movq %rax, %rdi
callq 0x55d90
leaq 0x104e7f(%rip), %rax    # 0x15f800
movq %rax, 0x40(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rbx)
leaq 0x104dcd(%rip), %rax    # 0x15f760
movq %rax, (%rbx)
movq %rbx, 0x113a63(%rip)    # 0x16e400
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x5aed8
xorl %eax, %eax
jmp 0x5a9b1
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movl $0x58, %esi
movq %rbx, %rdi
callq 0x55480
movq %r14, %rdi
callq 0x57090
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/backends/backend.cpp
// Function: smooth::Backends::Backend::InitBackends()
S::Int S::Backends::Backend::InitBackends()
{
	if (backends == NIL)		backends = new Array<Backend *, Void *>;
	if (backend_creators == NIL)	backend_creators = new Array<Backend *(*)(), Void *>;

	for (Int i = 0; i < backend_creators->Length(); i++)
	{
		backends->Add(backend_creators->GetNth(i)());
	}

	for (Int i = 0; i < backends->Length(); i++)
	{
		if (backends->GetNth(i)->Init() == Error())
		{
			/* Deinit already initialized backends and return.
			 */
			for (Int j = i - 1; j >= 0; j--) backends->GetNth(j)->Deinit();

			return Error();
		}
	}

	return Success();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpq $0x0, 0x1139f7(%rip)    # 0x16e3f8
jne 0x5aa3b
movl $0x58, %edi
callq 0x556b0
movq %rax, %rbx
movq %rax, %rdi
callq 0x55d90
leaq 0x104de1(%rip), %rax    # 0x15f800
movq %rax, 0x40(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rbx)
leaq 0x104dff(%rip), %rax    # 0x15f830
movq %rax, (%rbx)
movq %rbx, 0x1139bd(%rip)    # 0x16e3f8
movq 0x1139be(%rip), %rbx    # 0x16e400
testq %rbx, %rbx
jne 0x5aa7f
movl $0x58, %edi
callq 0x556b0
movq %rax, %rbx
movq %rax, %rdi
callq 0x55d90
leaq 0x104d9d(%rip), %rax    # 0x15f800
movq %rax, 0x40(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rbx)
leaq 0x104ceb(%rip), %rax    # 0x15f760
movq %rax, (%rbx)
movq %rbx, 0x113981(%rip)    # 0x16e400
cmpl $0x0, 0x8(%rbx)
jle 0x5aaba
xorl %ebp, %ebp
movq %rsp, %r14
movq 0x113967(%rip), %r15    # 0x16e3f8
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5b074
callq *(%rax)
movq %rax, (%rsp)
movq %r15, %rdi
movq %r14, %rsi
callq 0x5aed8
incl %ebp
movq 0x11394b(%rip), %rbx    # 0x16e400
cmpl 0x8(%rbx), %ebp
jl 0x5aa8a
movq 0x113937(%rip), %rdi    # 0x16e3f8
cmpl $0x0, 0x8(%rdi)
jle 0x5aaec
xorl %ebx, %ebx
movl %ebx, %esi
callq 0x5b074
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
cmpl $-0x1, %eax
je 0x5aaf0
incl %ebx
movq 0x113911(%rip), %rdi    # 0x16e3f8
cmpl 0x8(%rdi), %ebx
jl 0x5aac9
xorl %ebp, %ebp
jmp 0x5ab1a
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testl %ebx, %ebx
je 0x5ab1a
incl %ebx
leal -0x2(%rbx), %esi
movq 0x1138f3(%rip), %rdi    # 0x16e3f8
callq 0x5b074
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
decl %ebx
cmpl $0x1, %ebx
jg 0x5aafb
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5ab29
movq %rax, %r14
movl $0x58, %esi
movq %rbx, %rdi
callq 0x55480
movq %r14, %rdi
callq 0x57090
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/classes/backends/backend.cpp
// Function: smooth::Backends::Backend::DeinitBackends()
S::Int S::Backends::Backend::DeinitBackends()
{
	for (Int i = 0; i < backends->Length(); i++)
	{
		backends->GetNth(i)->Deinit();

		delete backends->GetNth(i);
	}

	backends->RemoveAll();

	delete backends;
	delete backend_creators;

	return Success();
}

// Assembly:
pushq %rbx
movq 0x1138ae(%rip), %rdi    # 0x16e3f8
cmpl $0x0, 0x8(%rdi)
jle 0x5ab8c
xorl %ebx, %ebx
movl %ebx, %esi
callq 0x5b074
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x11388f(%rip), %rdi    # 0x16e3f8
movl %ebx, %esi
callq 0x5b074
movq (%rax), %rdi
testq %rdi, %rdi
je 0x5ab7e
movq (%rdi), %rax
callq *0x8(%rax)
incl %ebx
movq 0x113871(%rip), %rdi    # 0x16e3f8
cmpl 0x8(%rdi), %ebx
jl 0x5ab52
movq (%rdi), %rax
callq *0x20(%rax)
movq 0x11385f(%rip), %rdi    # 0x16e3f8
testq %rdi, %rdi
je 0x5aba4
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x113855(%rip), %rdi    # 0x16e400
testq %rdi, %rdi
je 0x5abb6
movq (%rdi), %rax
callq *0x8(%rax)
xorl %eax, %eax
popq %rbx
retq