LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0xb15d(%rip), %r12      # 0xf0d1
movb (%r15,%r12), %r13b
movl $0x1, %esi
movq %rbx, %rdi
callq 0x1e13
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 0x3f74
movl %r14d, %eax
andl $0x7, %eax
cmpl $0x1, %eax
jne 0x4074
movq %r14, %r12
andq $-0x8, %r12
movq (%r12), %rdi
movl %edi, %eax
andl $0x7, %eax
movb $0x1, %r13b
cmpl $0x5, %eax
jne 0x406f
leaq 0xc489(%rip), %rsi      # 0x1045c
callq 0x1cb5
testb %al, %al
je 0x406f
movl $0x1, %esi
movq %rbx, %rdi
callq 0x1e13
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%rbx)
movb $-0x17, (%rax,%rcx)
movq 0x10(%rbx), %r15
movq %rbx, %rdi
movl $0xdeadbeef, %esi       # imm = 0xDEADBEEF
callq 0x1ec9
movq 0x8(%r12), %rax
movl %eax, %ecx
andl $0x7, %ecx
cmpl $0x1, %ecx
jne 0x40c8
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 0x40e7
movq 0x8(%rax), %rax
movl %eax, %ecx
andl $0x7, %ecx
cmpl $0x1, %ecx
jne 0x40c8
andq $-0x8, %rax
movq (%rax), %rdx
xorl %r13d, %r13d
movq %rbx, %rdi
xorl %ecx, %ecx
movq %r15, %r8
callq 0x3db1
movl %eax, %r15d
jmp 0x406f
testb %r13b, %r13b
je 0x40b6
movq %rbx, %rdi
movq %r14, %rsi
movq $-0x8, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x2af5
testl %eax, %eax
cmovnel %eax, %r15d
jne 0x40b6
movl $0x1, %esi
movq %rbx, %rdi
callq 0x1e13
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%rbx)
movb $-0x3d, (%rax,%rcx)
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xb567(%rip), %rdi      # 0xf636
leaq 0xb4c5(%rip), %rsi      # 0xf59b
leaq 0xb56b(%rip), %rcx      # 0xf648
movl $0xf0, %edx
callq 0x1090
leaq 0xb956(%rip), %rdi      # 0xfa44
leaq 0xb4a6(%rip), %rsi      # 0xf59b
leaq 0xb976(%rip), %rcx      # 0xfa72
movl $0x3df, %edx            # imm = 0x3DF
callq 0x1090
// File: /workspace/github_c_makefile_star2_O1/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 0x418c
movb $0x1, %al
movzbl %cl, %ecx
movl $0x3c000b, %edx         # imm = 0x3C000B
btl %ecx, %edx
jb 0x41a1
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_O1/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 0x41d6
xorl %ecx, %ecx
jmp 0x41fc
movq (%r14), %rsi
incq %rsi
xorl %ecx, %ecx
leaq (%rcx,%rcx,4), %rcx
leaq (%rdx,%rcx,2), %rcx
addq $-0x30, %rcx
movq %rsi, (%r14)
movsbq (%r15,%rsi), %rdx
incq %rsi
testb $0x8, 0x1(%rax,%rdx,2)
jne 0x41de
movslq %ebx, %rdi
imulq %rcx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x172c
// File: /workspace/github_c_makefile_star2_O1/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 0x4210
testb %al, %al
je 0x42ab
movb %r13b, -0x50(%rbp,%r15)
leaq (%r12,%r15), %rax
movq %rax, (%rbx)
incq %r15
cmpq $0x20, %r15
jne 0x427f
movl $0x20, %r15d
movb $0x0, -0x50(%rbp,%r15)
leaq -0x50(%rbp), %rdi
callq 0x1bba
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4300
leaq 0x1(%rdx), %r8
movq %r8, (%rsi)
cmpb $0x27, 0x1(%rdi,%rdx)
jne 0x4300
addq $0x2, %rdx
movq %rdx, (%rsi)
shlq $0x8, %rcx
orq $0xf, %rcx
movq %rcx, %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4123
cmpb $0x29, %al
jne 0x432e
incq (%rbx)
movl $0x2f, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
movq %rbx, %rsi
callq 0x43a6
cmpq $0x3f, %rax
je 0x4368
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4302
cmpq $0x3f, %rax
je 0x4387
movq %r15, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1abe
leaq 0xb72a(%rip), %rdi      # 0xfa99
leaq 0xb225(%rip), %rsi      # 0xf59b
leaq 0xb72f(%rip), %rcx      # 0xfaac
movl $0x442, %edx            # imm = 0x442
callq 0x1090
leaq 0xb741(%rip), %rdi      # 0xfacf
leaq 0xb206(%rip), %rsi      # 0xf59b
leaq 0xb710(%rip), %rcx      # 0xfaac
movl $0x444, %edx            # imm = 0x444
callq 0x1090
// File: /workspace/github_c_makefile_star2_O1/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 0x4123
movl %eax, %r15d
callq 0x11a0
movq (%rax), %rdx
movsbq %r15b, %rax
movzwl (%rdx,%rax,2), %eax
btl $0xb, %eax
jb 0x44f5
movzbl %r15b, %ecx
cmpl $0x3b, %ecx
jle 0x4402
leal -0x3c(%rcx), %edx
cmpl $0x4, %edx
jae 0x446d
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x425c
cmpl $0x2a, %ecx
je 0x43ed
cmpl $0x2b, %ecx
je 0x443d
cmpl $0x2d, %ecx
jne 0x446d
movq (%rbx), %rsi
movsbq 0x1(%r14,%rsi), %rdi
testb $0x8, 0x1(%rdx,%rdi,2)
jne 0x44dc
cmpb $0x3f, %r15b
ja 0x446d
movabsq $-0xfffd40000000000, %rdx # imm = 0xF0002C0000000000
btq %rcx, %rdx
jb 0x43ed
jmp 0x446d
movq (%rbx), %rsi
movsbq 0x1(%r14,%rsi), %rdi
testb $0x8, 0x1(%rdx,%rdi,2)
jne 0x44ef
cmpb $0x3f, %r15b
ja 0x446d
movabsq $-0xffff40000000000, %rsi # imm = 0xF0000C0000000000
btq %rcx, %rsi
jb 0x43ed
cmpq $0x2d, %rcx
je 0x4411
btl $0xa, %eax
jb 0x43ed
movl $0x3f, %eax
cmpb $0x23, %r15b
je 0x450f
cmpl $0x28, %ecx
je 0x4544
cmpl $0x27, %ecx
jne 0x455c
movq (%rbx), %rdx
leaq 0x1(%rdx), %rcx
movq %rcx, (%rbx)
movsbq 0x1(%r14,%rdx), %rcx
cmpq $0x27, %rcx
je 0x455c
leaq 0x2(%rdx), %rsi
movq %rsi, (%rbx)
cmpb $0x27, 0x2(%r14,%rdx)
jne 0x455c
addq $0x3, %rdx
movq %rdx, (%rbx)
shlq $0x8, %rcx
orq $0xf, %rcx
movq %rcx, %rax
jmp 0x455c
incq %rsi
movq %rsi, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
jmp 0x4500
incq %rsi
movq %rsi, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x41a8
movq (%rbx), %rcx
movzbl 0x1(%r14,%rcx), %edx
cmpl $0x66, %edx
je 0x4530
cmpl $0x74, %edx
jne 0x453e
addq $0x2, %rcx
movq %rcx, (%rbx)
movl $0x9f, %eax
jmp 0x455c
addq $0x2, %rcx
movq %rcx, (%rbx)
movl $0x1f, %eax
jmp 0x455c
cmpb $0x28, %r15b
jne 0x455c
incq (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4302
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x45a5
movq (%rdi), %rax
testq %rax, %rax
je 0x45c4
cmpl $0x1, 0x8(%rdi)
jne 0x45e3
movq %rsi, %rdi
callq *%rax
cltq
popq %rbp
retq
leaq 0xb536(%rip), %rdi      # 0xfae2
leaq 0xafe8(%rip), %rsi      # 0xf59b
leaq 0xb534(%rip), %rcx      # 0xfaee
movl $0x474, %edx            # imm = 0x474
callq 0x1090
leaq 0xb552(%rip), %rdi      # 0xfb1d
leaq 0xafc9(%rip), %rsi      # 0xf59b
leaq 0xb515(%rip), %rcx      # 0xfaee
movl $0x475, %edx            # imm = 0x475
callq 0x1090
leaq 0xb548(%rip), %rdi      # 0xfb32
leaq 0xafaa(%rip), %rsi      # 0xf59b
leaq 0xb4f6(%rip), %rcx      # 0xfaee
movl $0x476, %edx            # imm = 0x476
callq 0x1090
// File: /workspace/github_c_makefile_star2_O1/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 0xb474(%rip), %rdi      # 0xfb4c
callq 0x486f
testl %eax, %eax
je 0x470c
leaq 0x10be8(%rip), %rdi     # 0x152d0
callq 0x10d0
movl %eax, %edi
testl %eax, %eax
jne 0x4707
addl $0x3, 0x10a5a(%rip)     # 0x15154
movq $0x0, 0x10a63(%rip) # 0x15168
xorl %edi, %edi
callq 0x4a32
leaq 0xb451(%rip), %rdi      # 0xfb64
callq 0x486f
testl %eax, %eax
je 0x4747
leaq 0x10bad(%rip), %rdi     # 0x152d0
callq 0x10d0
movl %eax, %edi
testl %eax, %eax
jne 0x4742
addl $0x3, 0x10a1f(%rip)     # 0x15154
movq $0x0, 0x10a28(%rip) # 0x15168
xorl %edi, %edi
callq 0x4a32
leaq 0xb42e(%rip), %rdi      # 0xfb7c
callq 0x486f
testl %eax, %eax
je 0x4782
leaq 0x10b72(%rip), %rdi     # 0x152d0
callq 0x10d0
movl %eax, %edi
testl %eax, %eax
jne 0x477d
addl $0x2, 0x109e4(%rip)     # 0x15154
movq $0x0, 0x109ed(%rip) # 0x15168
xorl %edi, %edi
callq 0x4a32
leaq 0xb3ff(%rip), %rdi      # 0xfb88
callq 0x486f
testl %eax, %eax
je 0x47bd
leaq 0x10b37(%rip), %rdi     # 0x152d0
callq 0x10d0
movl %eax, %edi
testl %eax, %eax
jne 0x47b8
addl $0x2, 0x109a9(%rip)     # 0x15154
movq $0x0, 0x109b2(%rip) # 0x15168
xorl %edi, %edi
callq 0x4a32
leaq 0xb3d0(%rip), %rdi      # 0xfb94
callq 0x486f
testl %eax, %eax
je 0x47f8
leaq 0x10afc(%rip), %rdi     # 0x152d0
callq 0x10d0
movl %eax, %edi
testl %eax, %eax
jne 0x47f3
addl $0x4, 0x1096e(%rip)     # 0x15154
movq $0x0, 0x10977(%rip) # 0x15168
xorl %edi, %edi
callq 0x4a32
leaq 0xb3a1(%rip), %rdi      # 0xfba0
callq 0x486f
testl %eax, %eax
je 0x4833
leaq 0x10ac1(%rip), %rdi     # 0x152d0
callq 0x10d0
movl %eax, %edi
testl %eax, %eax
jne 0x482e
addl $0x2, 0x10933(%rip)     # 0x15154
movq $0x0, 0x1093c(%rip) # 0x15168
xorl %edi, %edi
callq 0x4a32
leaq 0xc76d(%rip), %rdi      # 0x10fa7
callq 0x486f
testl %eax, %eax
je 0x486d
leaq 0x10a86(%rip), %rdi     # 0x152d0
callq 0x10d0
movl %eax, %edi
testl %eax, %eax
jne 0x4868
incl 0x108f9(%rip)           # 0x15154
movq $0x0, 0x10902(%rip) # 0x15168
xorl %edi, %edi
callq 0x4a32
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xd680
cmpq $0x9f, %rbx
je 0xd691
cmpq $0x2f, %rbx
je 0xd68a
cmpq $0x1f, %rbx
je 0xd698
movl %ebx, %eax
notl %eax
testb $0xf, %al
jne 0xd623
movq 0x79e0(%rip), %rax      # 0x14ff8
movq (%rax), %rsi
shrl $0x8, %ebx
movsbl %bl, %edi
jmp 0xd677
movl %ebx, %eax
andl $0x7, %eax
movq 0x79c9(%rip), %r14      # 0x14ff8
movq (%r14), %rsi
cmpl $0x1, %eax
jne 0xd69f
movl %ebx, %ecx
andl $0x3, %ecx
je 0xd69f
cmpl $0x7, %eax
je 0xd69f
movl $0x28, %edi
callq 0x10c0
andq $-0x8, %rbx
movq (%rbx), %rdi
callq 0xd5d5
movq (%r14), %rsi
movl $0x20, %edi
callq 0x10c0
movq 0x8(%rbx), %rdi
callq 0xd5d5
movq (%r14), %rsi
movl $0x29, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x10c0
movq %rbx, %rdi
callq 0x1451
jmp 0xd6a7
callq 0x139c
jmp 0xd6a7
callq 0x13cb
jmp 0xd6a7
callq 0x13fa
jmp 0xd6a7
movq %rsi, %rdi
callq 0x1429
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
leaq -0x38(%rbp), %rsi
movq $0x0, (%rsi)
callq 0x43a6
movq %rax, %rbx
movq %r14, %rdi
callq 0x1030
cmpq $0x3f, %rbx
je 0xd776
movl $0x1, %edi
callq 0x1cf6
leaq -0x28(%rbp), %r15
movq %rax, -0x10(%r15)
movl $0x0, -0x8(%r15)
movq $0x0, (%r15)
movq $0x1, 0x8(%r15)
leaq -0x38(%rbp), %rdi
movq %rbx, %rsi
movq $-0x8, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x2af5
movl %eax, %r14d
movq %rbx, %rdi
callq 0x19ef
testl %r14d, %r14d
js 0xd77d
movq -0x28(%rbp), %rsi
testq %rsi, %rsi
jne 0xd78c
movq 0x78b6(%rip), %rax      # 0x14ff8
movq (%rax), %rsi
movl $0xa, %edi
callq 0x10c0
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1150
movq $0x0, -0x38(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x14fc
jmp 0xd76b
leaq -0x20(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x14c4
jmp 0xd75c
leaq -0x38(%rbp), %rdi
callq 0x1475
jmp 0xd73b
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x7be9(%rip)      # 0x15398
jne 0xd7c2
movl $0x1f40, %edi           # imm = 0x1F40
callq 0x1120
movq %rax, 0x7bd6(%rip)      # 0x15398
leaq -0x38(%rbp), %rsi
movq $0x0, (%rsi)
movq %rbx, %rdi
callq 0x43a6
cmpq $0x3f, %rax
je 0xd894
movq %rax, %rbx
movl $0x1, %edi
callq 0x1cf6
leaq -0x28(%rbp), %r15
movq %rax, -0x10(%r15)
movl $0x0, -0x8(%r15)
movq $0x0, (%r15)
movq $0x1, 0x8(%r15)
leaq -0x38(%rbp), %rdi
movq %rbx, %rsi
callq 0x3f56
movl %eax, %r14d
movq %rbx, %rdi
callq 0x19ef
testl %r14d, %r14d
js 0xd89b
leaq -0x38(%rbp), %rbx
movq (%rbx), %rdi
movq 0x10(%rbx), %rsi
movl $0x4, %edx
callq 0x1160
movl $0x1, 0x8(%rbx)
movq 0x7b4e(%rip), %rsi      # 0x15398
movq %rbx, %rdi
callq 0x4585
movq %rax, %rdi
callq 0xd5d5
movq 0x7797(%rip), %rax      # 0x14ff8
movq (%rax), %rsi
movl $0xa, %edi
callq 0x10c0
movq (%rbx), %rdi
movq 0x18(%rbx), %rsi
callq 0x1150
movq $0x0, -0x38(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x1563
jmp 0xd889
leaq -0x20(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x152b
jmp 0xd87a
// File: /workspace/github_c_makefile_star2_O1/mtnygard[P]complisp/lisp.c
// Function: repl
int repl(REPL_Callback callback) {
  do {
    // Read a line
    fprintf(stdout, "lisp> ");
    char *line = NULL;
    size_t size = 0;
    ssize_t nchars = getline(&line, &size, stdin);
    if (nchars < 0) {
      fprintf(stderr, "Goodbye.\n");
      free(line);
      free(heap);
      break;
    }

    callback(line);
    free(line);
  } while (true);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorl %r14d, %r14d
leaq -0x30(%rbp), %r15
leaq -0x38(%rbp), %r12
movq 0x7700(%rip), %rax      # 0x14fd0
movq (%rax), %rcx
movl $0x6, %esi
movl $0x1, %edx
leaq 0x2c78(%rip), %rdi      # 0x1055c
callq 0x1190
movq %r14, -0x30(%rbp)
movq %r14, -0x38(%rbp)
movq 0x76e0(%rip), %rax      # 0x14fd8
movq (%rax), %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x1170
movq %rax, %r13
testq %rax, %rax
js 0xd926
movq -0x30(%rbp), %rdi
callq *%rbx
movq %r15, %rax
movq (%rax), %rdi
callq 0x1030
testq %r13, %r13
jns 0xd8c9
jmp 0xd937
movq %r15, %rdi
callq 0x1592
leaq 0x7a63(%rip), %rax      # 0x15398
jmp 0xd917
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %r14d
callq 0xdc48
cmpl $0x2, %r14d
jl 0xe377
movb 0x6ef5(%rip), %dil      # 0x15110
movl $0x1, %r12d
movb 0x6ee9(%rip), %r15b     # 0x15111
movq %rbx, -0x30(%rbp)
movslq %r12d, %rax
movq (%rbx,%rax,8), %r13
cmpb $0x2d, (%r13)
jne 0xe344
movzbl 0x1(%r13), %eax
cmpl $0x72, %eax
jg 0xe258
cmpl $0x65, %eax
jle 0xe2a1
cmpl $0x66, %eax
jne 0xe31e
jmp 0xe298
leal -0x73(%rax), %edx
cmpl $0x2, %edx
jb 0xe272
cmpl $0x76, %eax
je 0xe334
cmpl $0x78, %eax
jne 0xe400
leal 0x1(%r12), %ecx
cmpl %r14d, %ecx
jge 0xe41b
cmpl $0x67, %eax
jg 0xe2f9
cmpl $0x2d, %eax
je 0xe2b5
cmpl $0x61, %eax
je 0xe2af
cmpl $0x66, %eax
jne 0xe400
orb $0x1, %dil
jmp 0xe32b
cmpl $0x2d, %eax
je 0xe2b5
cmpl $0x61, %eax
jne 0xe400
orb $0x4, %dil
jmp 0xe32b
movl %edi, %ebx
movl $0x6, %edx
leaq 0x3323(%rip), %rdi      # 0x115e6
movq %r13, %rsi
callq 0x1050
testl %eax, %eax
je 0xe42d
movl $0x2, %edx
leaq 0x330e(%rip), %rdi      # 0x115ed
movq %r13, %rsi
callq 0x1050
testl %eax, %eax
movl %ebx, %edi
movq -0x30(%rbp), %rbx
jne 0xe400
xorl %eax, %eax
jmp 0xe340
cmpl $0x5, %edx
ja 0xe31e
leaq 0xd2b(%rip), %r8        # 0xf030
movslq (%r8,%rdx,4), %rax
addq %r8, %rax
jmpq *%rax
movslq %ecx, %rax
movq (%rbx,%rax,8), %rax
movq %rax, 0x6e7c(%rip)      # 0x15198
jmp 0xe370
cmpl $0x6c, %eax
jne 0xe3f6
orb $0x2, %dil
movb %dil, 0x6dde(%rip)      # 0x15110
jmp 0xe33e
incb %r15b
movb %r15b, 0x6dd3(%rip)     # 0x15111
movb $0x1, %al
testb %al, %al
je 0xe377
incl %r12d
cmpl %r14d, %r12d
jl 0xe22c
jmp 0xe377
movslq %ecx, %rax
movq (%rbx,%rax,8), %rax
movq %rax, 0x6e40(%rip)      # 0x151a0
jmp 0xe370
movslq %ecx, %rax
movq (%rbx,%rax,8), %rax
movq %rax, 0x6e38(%rip)      # 0x151a8
movb $0x1, %al
movl %ecx, %r12d
jmp 0xe340
leaq -0x9cb1(%rip), %rdi     # 0x46cd
leaq 0x22f2(%rip), %rsi      # 0x10677
callq 0xdca6
leaq -0x96e2(%rip), %rdi     # 0x4caf
leaq 0x22ec(%rip), %rsi      # 0x10684
callq 0xdca6
leaq -0x8054(%rip), %rdi     # 0x6350
leaq 0x22e3(%rip), %rsi      # 0x1068e
callq 0xdca6
leaq -0x7b53(%rip), %rdi     # 0x6864
leaq 0x22dd(%rip), %rsi      # 0x1069b
callq 0xdca6
leaq -0x9362(%rip), %rdi     # 0x5068
leaq 0x22d9(%rip), %rsi      # 0x106aa
callq 0xdca6
callq 0xdea3
xorl %eax, %eax
cmpl $0x0, 0x6d68(%rip)      # 0x1514c
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x68, %eax
jne 0xe400
movq (%rbx), %rdi
jmp 0xe434
movq 0x6bc9(%rip), %rax      # 0x14fd0
movq (%rax), %rdi
leaq 0x31df(%rip), %rsi      # 0x115f0
movq %r13, %rdx
xorl %eax, %eax
callq 0x1100
movq (%rbx), %rdi
callq 0xe701
movl $0x1, %edi
callq 0x1180
movq -0x30(%rbp), %rax
movq (%rax), %rdi
callq 0xe701
xorl %edi, %edi
callq 0x1180
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %r14d
cmpl $0x2, %edi
jne 0xe47f
movq 0x8(%rbx), %r15
leaq 0x2257(%rip), %rsi      # 0x106b7
movq %r15, %rdi
callq 0x10f0
testl %eax, %eax
je 0xe494
leaq 0x2254(%rip), %rsi      # 0x106c7
movq %r15, %rdi
callq 0x10f0
testl %eax, %eax
je 0xe49d
movl %r14d, %edi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xe1f1
leaq -0xdef(%rip), %rdi      # 0xd6ac
jmp 0xe4a4
leaq -0xd0d(%rip), %rdi      # 0xd797
callq 0xd8aa
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x113608(%rip), %rax    # 0x16c970
cmpq $0x0, (%rax)
jne 0x59378
leaq 0x9b313(%rip), %rcx     # 0xf4688
movq %rcx, (%rax)
movq (%rax), %rsi
leaq 0x1161ae(%rip), %rbx    # 0x16f530
movq %rbx, %rdi
callq 0x579f0
movq 0x113b9f(%rip), %r15    # 0x16cf30
leaq 0x115ce8(%rip), %r14    # 0x16f080
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x57e10
movq %rbx, 0x11617b(%rip)    # 0x16f528
leaq 0x116194(%rip), %r12    # 0x16f548
leaq 0x9b2cd(%rip), %rsi     # 0xf4688
movq %r12, %rdi
callq 0x579f0
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x57e10
leaq 0x116188(%rip), %r12    # 0x16f560
leaq 0x9ae6b(%rip), %rsi     # 0xf424a
movq %r12, %rdi
callq 0x579f0
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x57e10
leaq 0x11617c(%rip), %r12    # 0x16f578
leaq 0x9ae46(%rip), %rsi     # 0xf4249
movq %r12, %rdi
callq 0x579f0
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x57e10
leaq 0x116170(%rip), %r12    # 0x16f590
leaq 0xd103c(%rip), %rsi     # 0x12a463
movq %r12, %rdi
callq 0x579f0
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x57e10
leaq 0x116164(%rip), %r13    # 0x16f5a8
leaq 0x9b726(%rip), %rsi     # 0xf4b71
movq %r13, %rdi
callq 0x579f0
movq %r15, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x57e10
leaq 0x116158(%rip), %r13    # 0x16f5c0
leaq 0x9addd(%rip), %rsi     # 0xf424c
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 0x116089(%rip), %rsi    # 0x16f530
movq %rax, %rdi
callq 0x562f0
leaq 0x116122(%rip), %rdi    # 0x16f5d8
movq %rax, %rsi
callq 0x570b0
leaq 0x8(%rsp), %rdi
callq 0x59200
movq 0x113a61(%rip), %rdi    # 0x16cf30
leaq 0x116102(%rip), %rsi    # 0x16f5d8
leaq 0x115ba3(%rip), %rdx    # 0x16f080
callq 0x57e10
leaq 0x116047(%rip), %rsi    # 0x16f530
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x570b0
leaq 0x1160ab(%rip), %rsi    # 0x16f5a8
movq %rbx, %rdi
callq 0x562f0
leaq 0x116024(%rip), %rsi    # 0x16f530
movq %rax, %rdi
callq 0x562f0
leaq 0x1160d5(%rip), %rdi    # 0x16f5f0
movq %rax, %rsi
callq 0x570b0
leaq 0x8(%rsp), %rdi
callq 0x59200
movq 0x1139fc(%rip), %rdi    # 0x16cf30
leaq 0x1160b5(%rip), %rsi    # 0x16f5f0
leaq 0x115b3e(%rip), %rdx    # 0x16f080
callq 0x57e10
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x59557
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x59200
movq %rbx, %rdi
callq 0x57090
// File: /workspace/github_c_makefile_star2_O1/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 0x5a9ae
cmpq $0x0, 0x114a9f(%rip)    # 0x16f400
jne 0x5a99b
movl $0x58, %edi
callq 0x556b0
movq %rax, %rbx
movq %rax, %rdi
callq 0x55d90
leaq 0x105e61(%rip), %rax    # 0x1607e0
movq %rax, 0x40(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rbx)
leaq 0x105daf(%rip), %rax    # 0x160740
movq %rax, (%rbx)
movq %rbx, 0x114a65(%rip)    # 0x16f400
movq 0x114a5e(%rip), %rdi    # 0x16f400
movq %rsp, %rsi
callq 0x5af08
xorl %eax, %eax
jmp 0x5a9b3
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_O1/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, 0x1149f5(%rip)    # 0x16f3f8
jne 0x5aa3d
movl $0x58, %edi
callq 0x556b0
movq %rax, %rbx
movq %rax, %rdi
callq 0x55d90
leaq 0x105dbf(%rip), %rax    # 0x1607e0
movq %rax, 0x40(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rbx)
leaq 0x105ddd(%rip), %rax    # 0x160810
movq %rax, (%rbx)
movq %rbx, 0x1149bb(%rip)    # 0x16f3f8
cmpq $0x0, 0x1149bb(%rip)    # 0x16f400
jne 0x5aa7f
movl $0x58, %edi
callq 0x556b0
movq %rax, %rbx
movq %rax, %rdi
callq 0x55d90
leaq 0x105d7d(%rip), %rax    # 0x1607e0
movq %rax, 0x40(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rbx)
leaq 0x105ccb(%rip), %rax    # 0x160740
movq %rax, (%rbx)
movq %rbx, 0x114981(%rip)    # 0x16f400
movq 0x11497a(%rip), %rdi    # 0x16f400
cmpl $0x0, 0x8(%rdi)
jle 0x5aabe
xorl %ebx, %ebx
movq %rsp, %r14
movq 0x114960(%rip), %r15    # 0x16f3f8
movl %ebx, %esi
callq 0x5b0a4
callq *(%rax)
movq %rax, (%rsp)
movq %r15, %rdi
movq %r14, %rsi
callq 0x5af08
incl %ebx
movq 0x114947(%rip), %rdi    # 0x16f400
cmpl 0x8(%rdi), %ebx
jl 0x5aa91
movq 0x114933(%rip), %rdi    # 0x16f3f8
cmpl $0x0, 0x8(%rdi)
setg %bpl
jle 0x5ab34
xorl %ebx, %ebx
xorl %esi, %esi
callq 0x5b0a4
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
cmpl $-0x1, %eax
je 0x5ab0f
xorl %ebx, %ebx
incl %ebx
movq 0x114907(%rip), %rdi    # 0x16f3f8
cmpl 0x8(%rdi), %ebx
setl %bpl
jge 0x5ab34
movl %ebx, %esi
callq 0x5b0a4
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
cmpl $-0x1, %eax
jne 0x5aae8
testl %ebx, %ebx
je 0x5ab34
incl %ebx
leal -0x2(%rbx), %esi
movq 0x1148d9(%rip), %rdi    # 0x16f3f8
callq 0x5b0a4
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
decl %ebx
cmpl $0x1, %ebx
jg 0x5ab15
movzbl %bpl, %eax
negl %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5ab47
movq %rax, %r14
movl $0x58, %esi
movq %rbx, %rdi
callq 0x55480
movq %r14, %rdi
callq 0x57090
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x114890(%rip), %rdi    # 0x16f3f8
cmpl $0x0, 0x8(%rdi)
jle 0x5abaa
xorl %ebx, %ebx
movl %ebx, %esi
callq 0x5b0a4
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x114871(%rip), %rdi    # 0x16f3f8
movl %ebx, %esi
callq 0x5b0a4
movq (%rax), %rdi
testq %rdi, %rdi
je 0x5ab9c
movq (%rdi), %rax
callq *0x8(%rax)
incl %ebx
movq 0x114853(%rip), %rdi    # 0x16f3f8
cmpl 0x8(%rdi), %ebx
jl 0x5ab70
movq (%rdi), %rax
callq *0x20(%rax)
movq 0x114841(%rip), %rdi    # 0x16f3f8
testq %rdi, %rdi
je 0x5abc2
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x114837(%rip), %rdi    # 0x16f400
testq %rdi, %rdi
je 0x5abd4
movq (%rdi), %rax
callq *0x8(%rax)
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/basic/object.cpp
// Function: smooth::Object::Object()
S::Object::Object() : type(this)
{
	/* Enable R/W locking for object lists.
	 */
	if (objects.Length() == 0)
	{
		objects.EnableLocking();
		deletable.EnableLocking();
	}

	type	       = classID;

	handle	       = RequestObjectHandle();
	name	       = NIL;

	lockingEnabled = False;

	isDeletable    = False;
	isObjectInUse  = 0;

	flags	       = 0;

	objects.Add(this, handle);

	/* Create periodical cleanup timer if we
	 * just created the first object.
	 */
	if (objects.Length() == 1)
	{
		cleanupTimer = new System::Timer();

		cleanupTimer->onInterval.Connect(&Object::ObjectCleanup);
		cleanupTimer->Start(1000);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x111713(%rip), %rax    # 0x16c8a8
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x20(%rdi), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x57ad0
movq 0x11160e(%rip), %r14    # 0x16c7c0
cmpl $0x0, 0x8(%r14)
jne 0x5b1d1
movq 0x111600(%rip), %rdi    # 0x16c7c0
callq 0x571b0
movq 0x111874(%rip), %rdi    # 0x16ca40
callq 0x571b0
movq 0x111ba8(%rip), %rax    # 0x16cd80
movzwl (%rax), %eax
movw %ax, (%r15)
leaq 0x1140c2(%rip), %rax    # 0x16f2a8
cmpb $0x1, (%rax)
jne 0x5b1fb
movq 0x111526(%rip), %rax    # 0x16c718
movl (%rax), %edx
leal 0x1(%rdx), %ecx
movl %ecx, (%rax)
jmp 0x5b20b
movq 0x111516(%rip), %rdi    # 0x16c718
callq 0x578f0
movl %eax, %edx
decl %edx
movl %edx, 0x8(%rbx)
movq $0x0, 0x10(%rbx)
movw $0x0, 0x18(%rbx)
xorl %eax, %eax
movl %eax, 0x1c(%rbx)
movl %eax, 0x30(%rbx)
leaq 0x8(%rsp), %rsi
movq %rbx, (%rsi)
movq %r14, %rdi
callq 0x5af72
cmpl $0x1, 0x8(%r14)
jne 0x5b27a
movl $0x68, %edi
callq 0x556b0
movq %rax, %rbx
movq %rax, %rdi
callq 0x55b80
movq 0x1111e1(%rip), %r14    # 0x16c438
movq %rbx, (%r14)
addq $0x48, %rbx
movq 0x111373(%rip), %rsi    # 0x16c5d8
movq %rbx, %rdi
callq 0x5b676
movq (%r14), %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x55100
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movl $0x68, %esi
movq %rbx, %rdi
callq 0x55480
movq %r14, %rdi
callq 0x57090
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/basic/object.cpp
// Function: smooth::Object::~Object()
S::Object::~Object()
{
	/* Try to remove ourself from the object list
	 * as DeleteObject might not have been called.
	 */
	if (!isDeletable) objects.Remove(handle);

	/* Free periodical cleanup timer if the timer
	 * itself is the only remaining object.
	 */
	if (objects.Length() == 1)
	{
		cleanupTimer->Stop();

		DeleteObject(cleanupTimer);
	}

	/* Delete name string if it was created.
	 */
	if (name != NIL) delete name;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x111586(%rip), %rax    # 0x16c8a8
addq $0x10, %rax
movq %rax, (%rdi)
cmpb $0x0, 0x19(%rdi)
jne 0x5b33e
movl 0x8(%rbx), %esi
movq 0x111487(%rip), %rdi    # 0x16c7c0
callq 0x58bb0
movq 0x11147b(%rip), %rax    # 0x16c7c0
cmpl $0x1, 0x8(%rax)
jne 0x5b362
movq 0x1110e6(%rip), %r14    # 0x16c438
movq (%r14), %rdi
callq 0x59190
movq (%r14), %rdi
callq 0x58cc0
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
je 0x5b387
movq %rbx, %rdi
callq 0x59200
movl $0x18, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x55480
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x5aede
nop
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/basic/object.cpp
// Function: smooth::Object::DeleteObject(smooth::Object*)
S::Int S::Object::DeleteObject(Object *object)
{
	if (object == NIL || objects.Get(object->handle) == NIL) return Error();

	/* Notify object that it will be deleted soon.
	 */
	object->EnqueueForDeletion();
	object->isDeletable = True;

	if (!object->IsObjectInUse())
	{
		/* Delete object immediately if
		 * it is not currently in use.
		 */
		objects.Remove(object->handle);
		delete object;
	}
	else
	{
		/* Remove object from object list and add
		 * it to the list of objects to delete.
		 */
		objects.Remove(object->handle);
		deletable.Add(object, object->handle);
	}

	return Success();
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testq %rdi, %rdi
je 0x5b401
movq %rdi, %rbx
movl 0x8(%rdi), %esi
movq 0x11140e(%rip), %rdi    # 0x16c7c0
callq 0x5b7ae
cmpq $0x0, (%rax)
je 0x5b401
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movb $0x1, 0x19(%rbx)
movl 0x1c(%rbx), %ebp
movl 0x8(%rbx), %esi
movq 0x1113ea(%rip), %rdi    # 0x16c7c0
callq 0x58bb0
testl %ebp, %ebp
jle 0x5b3f6
movl 0x8(%rbx), %edx
movq %rsp, %rsi
movq %rbx, (%rsi)
movq 0x111651(%rip), %rdi    # 0x16ca40
callq 0x5af72
jmp 0x5b3ff
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/basic/object.cpp
// Function: smooth::Object::GetObject(int, short)
S::Object *S::Object::GetObject(Int objectHandle, Short objectType)
{
	Object	*object = objects.Get(objectHandle);

	if (object == NIL) return NIL;

	if (object->GetObjectType() == objectType) return object;
	else					   return NIL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %esi
movq 0x111367(%rip), %rdi    # 0x16c7c0
callq 0x5b7ae
movq (%rax), %r14
testq %r14, %r14
je 0x5b47e
leaq 0x20(%r14), %rdi
movswl %bx, %esi
callq 0x57520
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
cmovneq %r14, %rax
jmp 0x5b480
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/basic/object.cpp
// Function: smooth::Object::SetName(smooth::String const&)
S::Int S::Object::SetName(const String &nName)
{
	if (GetObject(nName) != NIL) return Error();

	if (name == NIL) name = new String();

	*name = nName;

	return Success();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x58e80
movq %rax, %rcx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testq %rcx, %rcx
jne 0x5b53a
cmpq $0x0, 0x10(%r14)
jne 0x5b52c
movl $0x18, %edi
callq 0x556b0
movq %rax, %r15
movq %rax, %rdi
xorl %esi, %esi
callq 0x58e20
movq %r15, 0x10(%r14)
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x555f0
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x18, %esi
movq %r15, %rdi
callq 0x55480
movq %rbx, %rdi
callq 0x57090
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/basic/../../include/smooth/system/../templates/signals/signal.h
// Function: int smooth::Signal0<void>::Connect<void>(void (*)())
Int Connect(slotReturnTYPE (*proc)(SIGNALS_ARGUMENT_TYPES))
			{
				if (slotsN == NIL)
				{
					slotsN = new Array<Void *>();
					slotsN->EnableLocking();
				}

				slotsN->Add(new SIGNALS_SLOT_GLOBAL_CLASS_NAME<slotReturnTYPE SIGNALS_CONDITIONAL_COMMA SIGNALS_ARGUMENT_TYPES>(proc));

				return Success();
			}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x10(%rdi)
jne 0x5b6ca
movl $0x58, %edi
callq 0x556b0
movq %rax, %r15
movq %rax, %rdi
callq 0x55d90
leaq 0x105138(%rip), %rax    # 0x1607e0
movq %rax, 0x40(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%r15)
leaq 0x105245(%rip), %rax    # 0x160900
movq %rax, (%r15)
movq %r15, 0x10(%r14)
movq %r15, %rdi
callq 0x571b0
movq 0x10(%r14), %r14
movl $0x10, %edi
callq 0x556b0
leaq 0x105271(%rip), %rcx    # 0x160950
movq %rcx, (%rax)
movq %rbx, 0x8(%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x5af08
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x58, %esi
movq %r15, %rdi
callq 0x55480
movq %rbx, %rdi
callq 0x57090
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/files/directory.cpp
// Function: smooth::Directory::GetActiveDirectory()
S::Directory S::Directory::GetActiveDirectory()
{
#ifdef __WIN32__
	Buffer<wchar_t>	 buffer(32768 + 1);

	GetCurrentDirectory(buffer.Size(), buffer);

	String		 dir = (wchar_t *) buffer;
#else
	Buffer<char>	 buffer(PATH_MAX + 1);
	String		 dir;

	if (getcwd(buffer, buffer.Size()) != NIL) dir = buffer;
#endif

	return Directory(NIL, dir);
}

// Assembly:
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
movl $0x1001, %esi           # imm = 0x1001
callq 0x5cfaa
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x58e20
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x5bf0c
movq (%rax), %rdi
jmp 0x5bf0e
xorl %edi, %edi
movslq 0x18(%rsp), %rsi
callq 0x561f0
testq %rax, %rax
je 0x5bf38
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x5bf2c
movq (%rax), %rsi
jmp 0x5bf2e
xorl %esi, %esi
leaq 0x20(%rsp), %rdi
callq 0x55f40
leaq 0x38(%rsp), %rdi
xorl %esi, %esi
callq 0x58e20
leaq 0x38(%rsp), %rsi
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
callq 0x58c60
leaq 0x38(%rsp), %rdi
callq 0x59200
leaq 0x20(%rsp), %rdi
callq 0x59200
leaq 0x104d67(%rip), %rax    # 0x160cd8
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
callq 0x5d862
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
retq
jmp 0x5bf98
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x59200
jmp 0x5bf9b
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x59200
jmp 0x5bfaa
movq %rax, %rbx
leaq 0x104d27(%rip), %rax    # 0x160cd8
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
callq 0x5d862
movq %rbx, %rdi
callq 0x57090
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/files/directory.cpp
// Function: smooth::Directory::Create()
S::Int S::Directory::Create()
{
	if (Exists()) return Success();

	Bool	 result	   = False;
	String	 directory = *this;

	for (Int i = 1; i <= directory.Length(); i++)
	{
		if (directory[i] == '\\' || directory[i] == '/' || directory[i] == 0)
		{
			String	 path = directory.Head(i);

#ifdef __WIN32__
			result = CreateDirectory(MakeExtendedPath(path), NIL);
#else
			if (mkdir(path.ConvertTo("UTF-8"), 0777) == 0) result = True;
			else					       result = False;
#endif
		}
	}

	if (result == False) return Error();
	else		     return Success();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
callq 0x55440
xorl %ebx, %ebx
testb %al, %al
jne 0x5cbbb
movq %rsp, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x56d90
movl $0x1, %ebp
xorl %r12d, %r12d
leaq 0x18(%rsp), %r14
leaq 0xb65ee(%rip), %r15     # 0x113126
movq %rbx, %rdi
callq 0x57180
cmpl %eax, %ebp
jg 0x5cba8
movq %rbx, %rdi
movl %ebp, %esi
callq 0x58990
cmpl $0x5c, (%rax)
je 0x5cb71
movq %rbx, %rdi
movl %ebp, %esi
callq 0x58990
cmpl $0x2f, (%rax)
je 0x5cb71
movq %rbx, %rdi
movl %ebp, %esi
callq 0x58990
cmpl $0x0, (%rax)
jne 0x5cba4
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x58b00
movq %r14, %rdi
movq %r15, %rsi
callq 0x57940
movq %rax, %rdi
movl $0x1ff, %esi            # imm = 0x1FF
callq 0x55d70
testl %eax, %eax
sete %r12b
movq %r14, %rdi
callq 0x59200
incl %ebp
jmp 0x5cb38
andb $0x1, %r12b
decb %r12b
movsbl %r12b, %ebx
movq %rsp, %rdi
callq 0x59200
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5cbdb
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x59200
jmp 0x5cbde
movq %rax, %rbx
movq %rsp, %rdi
callq 0x59200
movq %rbx, %rdi
callq 0x57090
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/files/directory.cpp
// Function: smooth::Directory::Move(smooth::Directory const&)
S::Int S::Directory::Move(const Directory &destination)
{
	if (!Exists()) return Error();

#ifdef __WIN32__
	Bool	 result = MoveFile(MakeExtendedPath(*this), MakeExtendedPath(destination));
#else
	Bool	 result = (rename(String(*this).ConvertTo("UTF-8"), String(destination).ConvertTo("UTF-8")) == 0);
#endif

	if (result == False) return Error();
	else		     return Success();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x55440
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testb %cl, %cl
je 0x5cc74
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x56d90
leaq 0xb64fc(%rip), %rsi     # 0x113126
movq %r15, %rdi
callq 0x57940
movq %rax, %r14
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x56d90
leaq 0xb64df(%rip), %rsi     # 0x113126
movq %rsp, %rdi
callq 0x57940
movq %r14, %rdi
movq %rax, %rsi
callq 0x58ba0
movl %eax, %ebx
movq %rsp, %rdi
callq 0x59200
leaq 0x18(%rsp), %rdi
callq 0x59200
xorl %eax, %eax
negl %ebx
sbbl %eax, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x59200
jmp 0x5cc90
jmp 0x5cc8d
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x59200
movq %rbx, %rdi
callq 0x57090
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/files/file.cpp
// Function: smooth::FileTimeToDateTime(long const&)
DateTime FileTimeToDateTime(const FileTime &fileTime)
	{
		tm	 time;

		localtime_r(&fileTime, &time);

		DateTime	 dateTime;

		dateTime.SetYMD(time.tm_year + 1900, time.tm_mon + 1, time.tm_mday);
		dateTime.SetHMS(time.tm_hour, time.tm_min, time.tm_sec);

		return dateTime;
	}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %rsi, %rdi
movq %r14, %rsi
callq 0x556c0
movq %rbx, %rdi
xorl %esi, %esi
callq 0x56220
movl $0x76c, %esi            # imm = 0x76C
addl 0x14(%r14), %esi
movl 0xc(%r14), %ecx
movl 0x10(%r14), %edx
incl %edx
movq %rbx, %rdi
callq 0x57ac0
movl 0x8(%rsp), %esi
movl (%rsp), %ecx
movl 0x4(%rsp), %edx
movq %rbx, %rdi
callq 0x558b0
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x56b30
movq %r14, %rdi
callq 0x57090
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/files/file.cpp
// Function: smooth::DateTimeToFileTime(smooth::DateTime const&)
FileTime DateTimeToFileTime(const DateTime &dateTime)
	{
		tm	 time;

		memset(&time, 0, sizeof(time));

		time.tm_year  = dateTime.GetYear() - 1900;
		time.tm_mon   = dateTime.GetMonth() - 1;
		time.tm_mday  = dateTime.GetDay();

		time.tm_hour  = dateTime.GetHour();
		time.tm_min   = dateTime.GetMinute();
		time.tm_sec   = dateTime.GetSecond();

		time.tm_isdst = -1;

		return mktime(&time);
	}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r14
xorps %xmm0, %xmm0
movq %rsp, %rbx
movaps %xmm0, 0x20(%rbx)
movaps %xmm0, 0x10(%rbx)
movaps %xmm0, (%rbx)
movq $0x0, 0x30(%rbx)
callq 0x58c70
addl $0xfffff894, %eax       # imm = 0xFFFFF894
movl %eax, 0x14(%rbx)
movq %r14, %rdi
callq 0x563d0
decl %eax
movl %eax, 0x10(%rbx)
movq %r14, %rdi
callq 0x56930
movl %eax, 0xc(%rbx)
movq %r14, %rdi
callq 0x57c70
movl %eax, 0x8(%rbx)
movq %r14, %rdi
callq 0x58e40
movl %eax, 0x4(%rbx)
movq %r14, %rdi
callq 0x55700
movl %eax, (%rbx)
movl $0xffffffff, 0x20(%rbx) # imm = 0xFFFFFFFF
movq %rbx, %rdi
callq 0x56300
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/classes/files/file.cpp
// Function: smooth::GetFileTime(smooth::File const&, long*, long*, long*)
Bool GetFileTime(const File &file, FileTime *cTime, FileTime *aTime, FileTime *wTime)
	{
		if (!file.Exists()) return False;

		struct stat	 info;

		if (stat(String(file).ConvertTo("UTF-8"), &info) != 0) return False;

		if (cTime != NIL) *cTime = info.st_mtime;
		if (aTime != NIL) *aTime = info.st_atime;
		if (wTime != NIL) *wTime = info.st_mtime;

		return True;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0x56ef0
testb %al, %al
je 0x5da1b
movq %rsp, %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x58fa0
leaq 0xb575a(%rip), %rsi     # 0x113126
movq %r13, %rdi
callq 0x57940
leaq 0x18(%rsp), %rsi
movq %rax, %rdi
callq 0x58620
movl %eax, %ebp
movq %rsp, %rdi
callq 0x59200
testl %ebp, %ebp
sete %al
jne 0x5da1d
testq %r15, %r15
je 0x5d9ff
movq 0x70(%rsp), %rcx
movq %rcx, (%r15)
testq %r14, %r14
je 0x5da0c
movq 0x60(%rsp), %rcx
movq %rcx, (%r14)
testq %rbx, %rbx
je 0x5da1d
movq 0x70(%rsp), %rcx
movq %rcx, (%rbx)
jmp 0x5da1d
xorl %eax, %eax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x59200
movq %rbx, %rdi
callq 0x57090