LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/mtnygard[P]complisp/lisp.c
// Function: Compile_labels
int Compile_labels(Buffer *buf, ASTNode *bindings, ASTNode *body, Env *labels,
                   word body_pos) {
  if (AST_is_nil(bindings)) {
    Emit_backpatch_imm32(buf, body_pos);
    // Base case: no bindings; compile the body
    _(Compile_expr(buf, body, -kWordSize, NULL, labels));
    Buffer_write_arr(buf, kFunctionEpilogue, sizeof kFunctionEpilogue);
    return 0;
  }

  assert(AST_is_pair(bindings));
  // Get the next binding
  ASTNode *binding = AST_pair_car(bindings);
  ASTNode *name = AST_pair_car(binding);
  assert(AST_is_symbol(name));
  ASTNode *binding_code = AST_pair_car(AST_pair_cdr(binding));
  word function_location = Buffer_len(buf);
  // Compile the binding function
  _(Compile_code(buf, binding_code));
  // Bind the name to the location in the instruction strema
  Env entry = Env_bind(AST_symbol_cstr(name), function_location, labels);
  _(Compile_labels(buf, AST_pair_cdr(bindings), body, &entry, body_pos));
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r12
movq %rdx, %r14
movq %rdi, %rbx
cmpq $0x2f, %rsi
je 0x31ae
movq %rsi, %r13
movq %r8, -0x30(%rbp)
movq %r14, -0x38(%rbp)
movl %r13d, %eax
andl $0x7, %eax
cmpl $0x1, %eax
jne 0x31fd
movq %r13, %rdi
callq 0x15ee
movq %rax, %r15
movq %rax, %rdi
callq 0x15ee
movq %rax, %r14
andl $0x7, %eax
cmpl $0x5, %eax
jne 0x321c
movq %r15, %rdi
callq 0x15fc
movq %rax, %rdi
callq 0x15ee
movq 0x10(%rbx), %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2ffe
testl %eax, %eax
jne 0x31d3
movq %r14, %rdi
callq 0x1701
addq $0x8, %rax
leaq -0x50(%rbp), %r14
movq %rax, (%r14)
movq %r15, 0x8(%r14)
movq %r12, 0x10(%r14)
movq %r13, %rdi
callq 0x15fc
movq %rbx, %rdi
movq %rax, %rsi
movq -0x38(%rbp), %rdx
movq %r14, %rcx
movq -0x30(%rbp), %r8
callq 0x30e8
xorl %r15d, %r15d
negl %eax
sbbl %r15d, %r15d
jmp 0x31d7
movq %rbx, %rdi
movl %r8d, %esi
callq 0x1f1e
xorl %r15d, %r15d
pushq $-0x8
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
xorl %ecx, %ecx
movq %r12, %r8
callq 0x2007
testl %eax, %eax
je 0x31e9
pushq $-0x1
popq %r15
movl %r15d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x9ec0(%rip), %rsi      # 0xd0b0
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x1977
jmp 0x31d7
leaq 0xa69b(%rip), %rdi      # 0xd89f
leaq 0xa370(%rip), %rsi      # 0xd57b
leaq 0xa7d4(%rip), %rcx      # 0xd9e6
movl $0x3c7, %edx            # imm = 0x3C7
callq 0x1090
leaq 0xa6dd(%rip), %rdi      # 0xd900
leaq 0xa351(%rip), %rsi      # 0xd57b
leaq 0xa7b5(%rip), %rcx      # 0xd9e6
movl $0x3cb, %edx            # imm = 0x3CB
callq 0x1090
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x9e5e(%rip), %rsi      # 0xd0b1
pushq $0x3
popq %rdx
callq 0x1977
movl %r14d, %eax
andl $0x7, %eax
cmpl $0x1, %eax
jne 0x32f9
movq %r14, %rdi
callq 0x15ee
movl %eax, %ecx
andl $0x7, %ecx
cmpl $0x5, %ecx
jne 0x32f9
leaq 0xb1bb(%rip), %rsi      # 0xe43e
movq %rax, %rdi
callq 0x1754
testb %al, %al
je 0x32f9
movq %rbx, %rdi
movl $0xdeadbeef, %esi       # imm = 0xDEADBEEF
callq 0x1ee9
movq %rax, %r15
movq %r14, %rdi
callq 0x15fc
movq %rax, %rdi
callq 0x15ee
movq %rax, %r12
andl $0x7, %eax
cmpl $0x1, %eax
sete %al
cmpq $0x2f, %r12
sete %cl
orb %al, %cl
je 0x3337
movq %r14, %rdi
callq 0x15fc
movq %rax, %rdi
callq 0x15fc
movq %rax, %rdi
callq 0x15ee
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
movq %r15, %r8
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x30e8
xorl %r15d, %r15d
pushq $-0x8
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x2007
testl %eax, %eax
je 0x3319
pushq $-0x1
popq %r15
jmp 0x332b
leaq 0x9d90(%rip), %rsi      # 0xd0b0
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x1977
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xa6e8(%rip), %rdi      # 0xda26
leaq 0xa236(%rip), %rsi      # 0xd57b
leaq 0xa708(%rip), %rcx      # 0xda54
movl $0x3df, %edx            # imm = 0x3DF
callq 0x1090
// File: /workspace/github_c_makefile_star2_O2/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 0x33cd
movb $0x1, %al
movzbl %cl, %ecx
movl $0x3c000b, %edx         # imm = 0x3C000B
btl %ecx, %edx
jb 0x33e2
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_O2/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
incq %r12
xorl %edi, %edi
movsbq -0x1(%r15,%r12), %rcx
testb $0x8, 0x1(%rax,%rcx,2)
je 0x342d
imulq $0xa, %rdi, %rdx
leaq (%rdx,%rcx), %rdi
addq $-0x30, %rdi
movq %r12, (%r14)
incq %r12
jmp 0x340c
movslq %ebx, %rax
imulq %rax, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x12ac
// File: /workspace/github_c_makefile_star2_O2/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
xorl %r15d, %r15d
cmpq $0x20, %r15
je 0x34b6
movq (%rbx), %r12
movb (%r14,%r12), %r13b
movsbl %r13b, %edi
callq 0x3441
testb %al, %al
je 0x34b6
movb %r13b, -0x50(%rbp,%r15)
incq %r12
movq %r12, (%rbx)
incq %r15
jmp 0x348c
movb $0x0, -0x50(%rbp,%r15)
leaq -0x50(%rbp), %rdi
callq 0x16b4
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
movabsq $0x3f, %rax
cmpq $0x27, %rcx
je 0x3510
leaq 0x1(%rdx), %r8
movq %r8, (%rsi)
cmpb $0x27, 0x1(%rdi,%rdx)
jne 0x3510
addq $0x2, %rdx
movq %rdx, (%rsi)
shlq $0x8, %rcx
orq $0xf, %rcx
movq %rcx, %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3373
cmpb $0x29, %al
jne 0x353c
incq (%rbx)
pushq $0x2f
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
movq %rbx, %rsi
callq 0x35b4
cmpq $0x3f, %rax
je 0x3576
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3512
cmpq $0x3f, %rax
je 0x3595
movq %r15, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x160b
leaq 0xa4fe(%rip), %rdi      # 0xda7b
leaq 0x9ff7(%rip), %rsi      # 0xd57b
leaq 0xa503(%rip), %rcx      # 0xda8e
movl $0x442, %edx            # imm = 0x442
callq 0x1090
leaq 0xa515(%rip), %rdi      # 0xdab1
leaq 0x9fd8(%rip), %rsi      # 0xd57b
leaq 0xa4e4(%rip), %rcx      # 0xda8e
movl $0x444, %edx            # imm = 0x444
callq 0x1090
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x3373
movl %eax, %r15d
callq 0x11a0
movq (%rax), %rax
movsbq %r15b, %rcx
testb $0x8, 0x1(%rax,%rcx,2)
jne 0x3606
movzbl %r15b, %r12d
cmpb $0x2d, %r15b
je 0x361c
cmpl $0x2b, %r12d
jne 0x362c
movq (%rbx), %rcx
movsbq 0x1(%r14,%rcx), %rdx
testb $0x8, 0x1(%rax,%rdx,2)
je 0x362c
incq %rcx
movq %rcx, (%rbx)
pushq $0x1
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x33e9
movq (%rbx), %rcx
movsbq 0x1(%r14,%rcx), %rdx
testb $0x8, 0x1(%rax,%rdx,2)
jne 0x3677
movsbl %r15b, %edi
callq 0x33ae
testb %al, %al
je 0x364c
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3472
pushq $0x3f
popq %rax
cmpb $0x23, %r15b
je 0x3697
cmpl $0x28, %r12d
je 0x3681
cmpl $0x27, %r12d
jne 0x36c2
incq (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x34d4
incq %rcx
movq %rcx, (%rbx)
pushq $-0x1
jmp 0x3608
incq (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3512
movq (%rbx), %rcx
movzbl 0x1(%r14,%rcx), %edx
cmpl $0x66, %edx
je 0x36b8
cmpl $0x74, %edx
jne 0x36c2
addq $0x2, %rcx
movq %rcx, (%rbx)
movl $0x9f, %eax
jmp 0x36c2
addq $0x2, %rcx
movq %rcx, (%rbx)
pushq $0x1f
popq %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3706
movq (%rdi), %rax
testq %rax, %rax
je 0x3725
cmpl $0x1, 0x8(%rdi)
jne 0x3744
movq %rsi, %rdi
callq *%rax
cltq
popq %rbp
retq
leaq 0xa3b7(%rip), %rdi      # 0xdac4
leaq 0x9e67(%rip), %rsi      # 0xd57b
leaq 0xa3b5(%rip), %rcx      # 0xdad0
movl $0x474, %edx            # imm = 0x474
callq 0x1090
leaq 0xa3d3(%rip), %rdi      # 0xdaff
leaq 0x9e48(%rip), %rsi      # 0xd57b
leaq 0xa396(%rip), %rcx      # 0xdad0
movl $0x475, %edx            # imm = 0x475
callq 0x1090
leaq 0xa3c9(%rip), %rdi      # 0xdb14
leaq 0x9e29(%rip), %rsi      # 0xd57b
leaq 0xa377(%rip), %rcx      # 0xdad0
movl $0x476, %edx            # imm = 0x476
callq 0x1090
// File: /workspace/github_c_makefile_star2_O2/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 0xa316(%rip), %rdi      # 0xdb2e
callq 0x398c
testl %eax, %eax
je 0x3847
leaq 0xfaa8(%rip), %rdi      # 0x132d0
callq 0x10d0
movl %eax, %edi
testl %eax, %eax
jne 0x3842
addl $0x3, 0xf91a(%rip)      # 0x13154
andq $0x0, 0xf926(%rip)      # 0x13168
callq 0x3b3e
leaq 0xa2f8(%rip), %rdi      # 0xdb46
callq 0x398c
testl %eax, %eax
je 0x387d
leaq 0xfa72(%rip), %rdi      # 0x132d0
callq 0x10d0
movl %eax, %edi
testl %eax, %eax
jne 0x3878
addl $0x3, 0xf8e4(%rip)      # 0x13154
andq $0x0, 0xf8f0(%rip)      # 0x13168
callq 0x3b3e
leaq 0xa2da(%rip), %rdi      # 0xdb5e
callq 0x398c
testl %eax, %eax
je 0x38b3
leaq 0xfa3c(%rip), %rdi      # 0x132d0
callq 0x10d0
movl %eax, %edi
testl %eax, %eax
jne 0x38ae
addl $0x2, 0xf8ae(%rip)      # 0x13154
andq $0x0, 0xf8ba(%rip)      # 0x13168
callq 0x3b3e
leaq 0xa2b0(%rip), %rdi      # 0xdb6a
callq 0x398c
testl %eax, %eax
je 0x38e9
leaq 0xfa06(%rip), %rdi      # 0x132d0
callq 0x10d0
movl %eax, %edi
testl %eax, %eax
jne 0x38e4
addl $0x2, 0xf878(%rip)      # 0x13154
andq $0x0, 0xf884(%rip)      # 0x13168
callq 0x3b3e
leaq 0xa286(%rip), %rdi      # 0xdb76
callq 0x398c
testl %eax, %eax
je 0x391f
leaq 0xf9d0(%rip), %rdi      # 0x132d0
callq 0x10d0
movl %eax, %edi
testl %eax, %eax
jne 0x391a
addl $0x4, 0xf842(%rip)      # 0x13154
andq $0x0, 0xf84e(%rip)      # 0x13168
callq 0x3b3e
leaq 0xa25c(%rip), %rdi      # 0xdb82
callq 0x398c
testl %eax, %eax
je 0x3955
leaq 0xf99a(%rip), %rdi      # 0x132d0
callq 0x10d0
movl %eax, %edi
testl %eax, %eax
jne 0x3950
addl $0x2, 0xf80c(%rip)      # 0x13154
andq $0x0, 0xf818(%rip)      # 0x13168
callq 0x3b3e
leaq 0xb62d(%rip), %rdi      # 0xef89
callq 0x398c
testl %eax, %eax
je 0x398a
leaq 0xf964(%rip), %rdi      # 0x132d0
callq 0x10d0
movl %eax, %edi
testl %eax, %eax
jne 0x3985
incl 0xf7d7(%rip)            # 0x13154
andq $0x0, 0xf7e3(%rip)      # 0x13168
callq 0x3b3e
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xbdf8
movb 0x6e1e(%rip), %cl       # 0x13110
pushq $0x1
popq %rdi
movb 0x6e16(%rip), %dl       # 0x13111
leaq 0xd0e(%rip), %rsi       # 0xd010
cmpl %r14d, %edi
jge 0xc3da
movslq %edi, %rax
movq (%rbx,%rax,8), %rax
cmpb $0x2d, (%rax)
jne 0xc3b3
movzbl 0x1(%rax), %r9d
leal -0x73(%r9), %r8d
cmpl $0x2, %r8d
jb 0xc348
cmpl $0x61, %r9d
je 0xc383
cmpl $0x66, %r9d
je 0xc388
cmpl $0x6c, %r9d
je 0xc38d
cmpl $0x76, %r9d
je 0xc379
cmpl $0x78, %r9d
jne 0xc3ba
leal 0x1(%rdi), %r9d
cmpl %r14d, %r9d
jge 0xc47f
cmpl $0x5, %r8d
ja 0xc464
movslq (%rsi,%r8,4), %r10
addq %rsi, %r10
movslq %r9d, %r8
jmpq *%r10
movq (%rbx,%r8,8), %rax
movq %rax, 0x6e21(%rip)      # 0x13198
jmp 0xc3b0
incb %dl
movb %dl, 0x6d90(%rip)       # 0x13111
jmp 0xc3b3
orb $0x4, %cl
jmp 0xc390
orb $0x1, %cl
jmp 0xc390
orb $0x2, %cl
movb %cl, 0x6d7a(%rip)       # 0x13110
jmp 0xc3b3
movq (%rbx,%r8,8), %rax
movq %rax, 0x6e05(%rip)      # 0x131a8
jmp 0xc3b0
movq (%rbx,%r8,8), %rax
movq %rax, 0x6df0(%rip)      # 0x131a0
movl %r9d, %edi
incl %edi
jmp 0xc302
cmpl $0x2d, %r9d
jne 0xc44f
leaq 0x31fd(%rip), %rdi      # 0xf5c8
pushq $0x6
popq %rdx
movq %rax, %rsi
callq 0x1050
testl %eax, %eax
je 0xc455
leaq -0x8bd4(%rip), %rdi     # 0x380d
leaq 0x2271(%rip), %rsi      # 0xe659
callq 0xbe54
leaq -0x8653(%rip), %rdi     # 0x3da1
leaq 0x226b(%rip), %rsi      # 0xe666
callq 0xbe54
leaq -0x7049(%rip), %rdi     # 0x53be
leaq 0x2262(%rip), %rsi      # 0xe670
callq 0xbe54
leaq -0x6bf8(%rip), %rdi     # 0x5822
leaq 0x225c(%rip), %rsi      # 0xe67d
callq 0xbe54
leaq -0x832b(%rip), %rdi     # 0x4102
leaq 0x2258(%rip), %rsi      # 0xe68c
callq 0xbe54
callq 0xbfe9
xorl %eax, %eax
cmpl $0x0, 0x6d05(%rip)      # 0x1314c
setne %al
popq %rbx
popq %r14
popq %rbp
retq
cmpl $0x68, %r9d
jne 0xc464
movq (%rbx), %rdi
callq 0xc730
xorl %edi, %edi
callq 0x1180
movq 0x6b65(%rip), %rcx      # 0x12fd0
movq (%rcx), %rdi
leaq 0x315a(%rip), %rsi      # 0xf5cf
movq %rax, %rdx
xorl %eax, %eax
callq 0x1100
movq (%rbx), %rdi
callq 0xc730
pushq $0x1
popq %rdi
callq 0x1180
// File: /workspace/github_c_makefile_star2_O2/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 0xb781
cmpq $0x9f, %rbx
je 0xb7b9
cmpq $0x2f, %rbx
je 0xb7a4
cmpq $0x1f, %rbx
je 0xb7cc
movl %ebx, %eax
notl %eax
testb $0xf, %al
jne 0xb713
movq 0x78f0(%rip), %rax      # 0x12ff8
movq (%rax), %rsi
shrl $0x8, %ebx
movsbl %bl, %edi
jmp 0xb778
movl %ebx, %eax
andl $0x7, %eax
cmpl $0x1, %eax
jne 0xb7ec
movl %ebx, %ecx
andl $0x3, %ecx
je 0xb7ec
cmpl $0x7, %eax
je 0xb7ec
movq 0x78bc(%rip), %r14      # 0x12ff8
movq (%r14), %rsi
pushq $0x28
popq %rdi
callq 0x10c0
movq %rbx, %rdi
callq 0x15ee
movq %rax, %rdi
callq 0xb6c5
movq (%r14), %rsi
pushq $0x20
popq %rdi
callq 0x10c0
movq %rbx, %rdi
callq 0x15fc
movq %rax, %rdi
callq 0xb6c5
movq (%r14), %rsi
pushq $0x29
popq %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x10c0
movq 0x7870(%rip), %rax      # 0x12ff8
movq (%rax), %rdi
sarq $0x2, %rbx
leaq 0x2d67(%rip), %rsi      # 0xe4fd
movq %rbx, %rdx
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x1100
movq 0x784d(%rip), %rax      # 0x12ff8
movq (%rax), %rcx
leaq 0x2686(%rip), %rdi      # 0xde3b
pushq $0x3
jmp 0xb7df
movq 0x7838(%rip), %rax      # 0x12ff8
movq (%rax), %rcx
leaq 0x2d3a(%rip), %rdi      # 0xe504
jmp 0xb7dd
movq 0x7825(%rip), %rax      # 0x12ff8
movq (%rax), %rcx
leaq 0x2d24(%rip), %rdi      # 0xe501
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0x1190
movq 0x7805(%rip), %rax      # 0x12ff8
movq (%rax), %rcx
leaq 0x2d0a(%rip), %rdi      # 0xe507
pushq $0x11
jmp 0xb7df
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
callq 0x36cb
movq %rax, %rbx
movq %r14, %rdi
callq 0x1030
cmpq $0x3f, %rbx
je 0xb8cc
pushq $0x1
popq %rdi
callq 0x177a
leaq -0x48(%rbp), %rdi
movq %rax, (%rdi)
andl $0x0, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movq $0x1, 0x18(%rdi)
pushq $-0x8
popq %rdx
movq %rbx, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x2007
movl %eax, %r14d
movq %rbx, %rdi
callq 0x157f
testl %r14d, %r14d
js 0xb8f6
movq -0x48(%rbp), %r14
movq -0x38(%rbp), %r15
movq 0x7776(%rip), %r12      # 0x12ff8
leaq 0x2cae(%rip), %rbx      # 0xe537
xorl %r13d, %r13d
movq (%r12), %rsi
cmpq %r13, %r15
je 0xb8ac
movzbl (%r14,%r13), %edx
movq %rsi, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1100
incq %r13
jmp 0xb88c
pushq $0xa
popq %rdi
callq 0x10c0
leaq -0x48(%rbp), %rdi
callq 0x17e7
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x7725(%rip), %rax      # 0x12ff8
movq (%rax), %rcx
leaq 0x2c3c(%rip), %rdi      # 0xe519
pushq $0xd
popq %rsi
pushq $0x1
popq %rdx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1190
movq 0x76fb(%rip), %rax      # 0x12ff8
movq (%rax), %rcx
leaq 0x2c20(%rip), %rdi      # 0xe527
pushq $0xf
popq %rsi
pushq $0x1
popq %rdx
callq 0x1190
jmp 0xb8b4
// File: /workspace/github_c_makefile_star2_O2/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, 0x7a6e(%rip)      # 0x13398
jne 0xb93d
movl $0x1f40, %edi           # imm = 0x1F40
callq 0x1120
movq %rax, 0x7a5b(%rip)      # 0x13398
movq %rbx, %rdi
callq 0x36cb
cmpq $0x3f, %rax
je 0xb9d1
movq %rax, %rbx
pushq $0x1
popq %rdi
callq 0x177a
leaq -0x30(%rbp), %rdi
movq %rax, (%rdi)
andl $0x0, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movq $0x1, 0x18(%rdi)
movq %rbx, %rsi
callq 0x323b
movl %eax, %r14d
movq %rbx, %rdi
callq 0x157f
testl %r14d, %r14d
js 0xb9f5
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x180e
movq 0x79fb(%rip), %rsi      # 0x13398
movq %rbx, %rdi
callq 0x36e6
movq %rax, %rdi
callq 0xb6c5
movq 0x7644(%rip), %rax      # 0x12ff8
movq (%rax), %rsi
pushq $0xa
popq %rdi
callq 0x10c0
leaq -0x30(%rbp), %rdi
callq 0x17e7
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq 0x7620(%rip), %rax      # 0x12ff8
movq (%rax), %rcx
leaq 0x2b37(%rip), %rdi      # 0xe519
pushq $0xd
popq %rsi
pushq $0x1
popq %rdx
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x1190
movq 0x75fc(%rip), %rax      # 0x12ff8
movq (%rax), %rcx
leaq 0x2b21(%rip), %rdi      # 0xe527
pushq $0xf
popq %rsi
pushq $0x1
popq %rdx
callq 0x1190
jmp 0xb9bf
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %r12
movq 0x75a6(%rip), %r15      # 0x12fd8
leaq -0x30(%rbp), %r13
leaq -0x38(%rbp), %r14
movq 0x758f(%rip), %rax      # 0x12fd0
movq (%rax), %rcx
leaq 0x2af3(%rip), %rdi      # 0xe53e
pushq $0x6
popq %rsi
movq %r12, %rdx
callq 0x1190
andq $0x0, -0x30(%rbp)
andq $0x0, -0x38(%rbp)
movq (%r15), %rdx
movq %r13, %rdi
movq %r14, %rsi
callq 0x1170
testq %rax, %rax
js 0xba84
movq -0x30(%rbp), %rdi
callq *%rbx
movq -0x30(%rbp), %rdi
callq 0x1030
jmp 0xba3a
movq 0x756d(%rip), %rax      # 0x12ff8
movq (%rax), %rcx
leaq 0x2ab0(%rip), %rdi      # 0xe545
pushq $0x9
popq %rsi
pushq $0x1
popq %rdx
callq 0x1190
movq -0x30(%rbp), %rdi
callq 0x1030
movq 0x78e8(%rip), %rdi      # 0x13398
callq 0x1030
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_O2/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 0xc4ce
movq 0x8(%rbx), %r15
leaq 0x21ea(%rip), %rsi      # 0xe699
movq %r15, %rdi
callq 0x10f0
testl %eax, %eax
je 0xc4e3
leaq 0x21e7(%rip), %rsi      # 0xe6a9
movq %r15, %rdi
callq 0x10f0
testl %eax, %eax
je 0xc4ec
movl %r14d, %edi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xc2da
leaq -0xce9(%rip), %rdi      # 0xb801
jmp 0xc4f3
leaq -0xbdf(%rip), %rdi      # 0xb914
callq 0xba13
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x107351(%rip), %rax    # 0x161970
movq (%rax), %rsi
testq %rsi, %rsi
jne 0x5a631
leaq 0x8907a(%rip), %rsi     # 0xe36a8
movq %rsi, (%rax)
leaq 0x10a0b8(%rip), %rbx    # 0x1646f0
movq %rbx, %rdi
callq 0x58c40
movq 0x1078e9(%rip), %r15    # 0x161f30
leaq 0x109bf2(%rip), %r14    # 0x164240
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x590a0
movq %rbx, 0x10a085(%rip)    # 0x1646e8
leaq 0x10a09e(%rip), %r12    # 0x164708
leaq 0x89037(%rip), %rsi     # 0xe36a8
movq %r12, %rdi
callq 0x58c40
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x590a0
leaq 0x10a092(%rip), %r12    # 0x164720
leaq 0x88b9c(%rip), %rsi     # 0xe3231
movq %r12, %rdi
callq 0x58c40
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x590a0
leaq 0x10a086(%rip), %r12    # 0x164738
leaq 0x88b77(%rip), %rsi     # 0xe3230
movq %r12, %rdi
callq 0x58c40
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x590a0
leaq 0x10a07a(%rip), %r12    # 0x164750
leaq 0xbecd6(%rip), %rsi     # 0x1193b3
movq %r12, %rdi
callq 0x58c40
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x590a0
leaq 0x10a06e(%rip), %r13    # 0x164768
leaq 0x894c8(%rip), %rsi     # 0xe3bc9
movq %r13, %rdi
callq 0x58c40
movq %r15, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x590a0
leaq 0x10a062(%rip), %r13    # 0x164780
leaq 0x88b0e(%rip), %rsi     # 0xe3233
movq %r13, %rdi
callq 0x58c40
movq %r15, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x590a0
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x58280
movq %r14, %rdi
movq %r12, %rsi
callq 0x573e0
leaq 0x109f93(%rip), %rsi    # 0x1646f0
movq %rax, %rdi
callq 0x573e0
leaq 0x10a02c(%rip), %rdi    # 0x164798
movq %rax, %rsi
callq 0x58280
leaq 0x8(%rsp), %rdi
callq 0x5a588
movq 0x1077ab(%rip), %rdi    # 0x161f30
leaq 0x10a00c(%rip), %rsi    # 0x164798
leaq 0x109aad(%rip), %rdx    # 0x164240
callq 0x590a0
leaq 0x109f51(%rip), %rsi    # 0x1646f0
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x58280
leaq 0x109fb5(%rip), %rsi    # 0x164768
movq %rbx, %rdi
callq 0x573e0
leaq 0x109f2e(%rip), %rsi    # 0x1646f0
movq %rax, %rdi
callq 0x573e0
leaq 0x109fdf(%rip), %rdi    # 0x1647b0
movq %rax, %rsi
callq 0x58280
leaq 0x8(%rsp), %rdi
callq 0x5a588
movq 0x107746(%rip), %rdi    # 0x161f30
leaq 0x109fbf(%rip), %rsi    # 0x1647b0
leaq 0x109a48(%rip), %rdx    # 0x164240
callq 0x590a0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x5a80d
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5a588
movq %rbx, %rdi
callq 0x58260
// File: /workspace/github_c_makefile_star2_O2/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 0x5bb1e
movq 0x108ad0(%rip), %rbx    # 0x1645c0
testq %rbx, %rbx
jne 0x5bb0f
pushq $0x58
popq %rdi
callq 0x56700
movq %rax, %rbx
movq %rax, %rdi
callq 0x5bcee
movq %rbx, 0x108ab1(%rip)    # 0x1645c0
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x5c03a
xorl %eax, %eax
jmp 0x5bb21
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
pushq $0x58
popq %rsi
movq %rbx, %rdi
callq 0x564c0
movq %r14, %rdi
callq 0x58260
nop
// File: /workspace/github_c_makefile_star2_O2/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, 0x108a49(%rip)    # 0x1645b8
jne 0x5bb8b
pushq $0x58
popq %rdi
callq 0x56700
movq %rax, %rbx
movq %rax, %rdi
callq 0x5bd04
movq %rbx, 0x108a2d(%rip)    # 0x1645b8
movq 0x108a2e(%rip), %rbx    # 0x1645c0
testq %rbx, %rbx
jne 0x5bbb1
pushq $0x58
popq %rdi
callq 0x56700
movq %rax, %rbx
movq %rax, %rdi
callq 0x5bcee
movq %rbx, 0x108a0f(%rip)    # 0x1645c0
xorl %ebp, %ebp
movq %rsp, %r14
cmpl 0x8(%rbx), %ebp
jge 0x5bbe8
movq 0x1089f6(%rip), %r15    # 0x1645b8
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5c1b6
callq *(%rax)
movq %rax, (%rsp)
movq %r15, %rdi
movq %r14, %rsi
callq 0x5bd1a
incl %ebp
movq 0x1089da(%rip), %rbx    # 0x1645c0
jmp 0x5bbb6
xorl %ebx, %ebx
xorl %ebp, %ebp
movq 0x1089c5(%rip), %rdi    # 0x1645b8
cmpl 0x8(%rdi), %ebp
jge 0x5bc33
movl %ebp, %esi
callq 0x5c1b6
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
cmpl $-0x1, %eax
je 0x5bc11
incl %ebp
jmp 0x5bbec
pushq $-0x1
popq %rbx
testl %ebp, %ebp
jle 0x5bc33
decl %ebp
movq 0x108997(%rip), %rdi    # 0x1645b8
movl %ebp, %esi
callq 0x5c1b6
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x5bc14
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5bc42
movq %rax, %r14
pushq $0x58
popq %rsi
movq %rbx, %rdi
callq 0x564c0
movq %r14, %rdi
callq 0x58260
// File: /workspace/github_c_makefile_star2_O2/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
xorl %ebx, %ebx
movq 0x108956(%rip), %rdi    # 0x1645b8
cmpl 0x8(%rdi), %ebx
jge 0x5bc97
movl %ebx, %esi
callq 0x5c1b6
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x10893a(%rip), %rdi    # 0x1645b8
movl %ebx, %esi
callq 0x5c1b6
movq (%rax), %rdi
testq %rdi, %rdi
je 0x5bc93
movq (%rdi), %rax
callq *0x8(%rax)
incl %ebx
jmp 0x5bc5b
movq (%rdi), %rax
callq *0x20(%rax)
movq 0x108914(%rip), %rdi    # 0x1645b8
testq %rdi, %rdi
je 0x5bcaf
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x10890a(%rip), %rdi    # 0x1645c0
testq %rdi, %rdi
je 0x5bcc1
movq (%rdi), %rax
callq *0x8(%rax)
xorl %eax, %eax
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x105618(%rip), %rax    # 0x1618a8
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x20, %rdi
movq %rbx, %rsi
callq 0x58d30
movq 0x105516(%rip), %r14    # 0x1617c0
cmpl $0x0, 0x8(%r14)
jne 0x5c2c9
movq 0x105508(%rip), %rdi    # 0x1617c0
callq 0x583a0
movq 0x10577c(%rip), %rdi    # 0x161a40
callq 0x583a0
movq 0x105ab0(%rip), %rax    # 0x161d80
movzwl (%rax), %eax
movw %ax, 0x20(%rbx)
callq 0x56c60
movl %eax, 0x8(%rbx)
andq $0x0, 0x10(%rbx)
andw $0x0, 0x18(%rbx)
andl $0x0, 0x1c(%rbx)
andl $0x0, 0x30(%rbx)
movq %rsp, %rsi
movq %rbx, (%rsi)
movq %r14, %rdi
movl %eax, %edx
callq 0x5c736
cmpl $0x1, 0x8(%r14)
jne 0x5c345
pushq $0x68
popq %rdi
callq 0x56700
movq %rax, %rbx
movq %rax, %rdi
callq 0x56c00
movq 0x105116(%rip), %r14    # 0x161438
movq %rbx, (%r14)
addq $0x48, %rbx
movq 0x1052a8(%rip), %rsi    # 0x1615d8
movq %rbx, %rdi
callq 0x5c748
movq (%r14), %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x56100
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
pushq $0x68
popq %rsi
movq %rbx, %rdi
callq 0x564c0
movq %r14, %rdi
callq 0x58260
nop
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/classes/basic/object.cpp
// Function: smooth::Object::ObjectCleanup()
S::Void S::Object::ObjectCleanup()
{
	/* Loop through all deletable objects...
	 */
	for (Int i = 0; i < deletable.Length(); i++)
	{
		Object	*object = deletable.GetNth(i);

		if (object->IsObjectInUse()) continue;

		deletable.RemoveNth(i--);
		delete object;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
xorl %ebx, %ebx
movq 0x10569e(%rip), %r14    # 0x161a40
cmpl 0x8(%r14), %ebx
jge 0x5c3d5
movq %r14, %rdi
movl %ebx, %esi
callq 0x5c1b6
movq (%rax), %r15
cmpl $0x0, 0x1c(%r15)
jg 0x5c3d1
movq %r14, %rdi
movl %ebx, %esi
callq 0x5be3e
movq (%r15), %rax
movq %r15, %rdi
callq *0x10(%rax)
jmp 0x5c3a2
incl %ebx
jmp 0x5c3a2
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x1054be(%rip), %rax    # 0x1618a8
addq $0x10, %rax
movq %rax, (%rdi)
cmpb $0x0, 0x19(%rdi)
jne 0x5c406
movl 0x8(%rbx), %esi
movq 0x1053bf(%rip), %rdi    # 0x1617c0
callq 0x59f00
movq 0x1053b3(%rip), %rax    # 0x1617c0
cmpl $0x1, 0x8(%rax)
jne 0x5c42a
movq 0x10501e(%rip), %r14    # 0x161438
movq (%r14), %rdi
callq 0x5a518
movq (%r14), %rdi
callq 0x5a010
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
je 0x5c44d
movq %rbx, %rdi
callq 0x5a588
pushq $0x18
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x564c0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x5bffa
nop
// File: /workspace/github_c_makefile_star2_O2/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
movq %rdi, (%rsp)
pushq $-0x1
popq %rbp
testq %rdi, %rdi
je 0x5c4c6
movq %rdi, %rbx
movl 0x8(%rdi), %esi
movq 0x105346(%rip), %rdi    # 0x1617c0
callq 0x5c86e
cmpq $0x0, (%rax)
je 0x5c4c6
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movb $0x1, 0x19(%rbx)
movl 0x1c(%rbx), %ebp
movl 0x8(%rbx), %esi
movq 0x105322(%rip), %rdi    # 0x1617c0
callq 0x59f00
testl %ebp, %ebp
jle 0x5c4bb
movl 0x8(%rbx), %edx
movq 0x10558f(%rip), %rdi    # 0x161a40
movq %rsp, %rsi
callq 0x5c736
jmp 0x5c4c4
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x1052a3(%rip), %rdi    # 0x1617c0
callq 0x5c86e
movq (%rax), %r14
testq %r14, %r14
je 0x5c542
leaq 0x20(%r14), %rdi
movswl %bx, %esi
callq 0x58720
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
cmovneq %r14, %rax
jmp 0x5c544
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/classes/basic/object.cpp
// Function: smooth::Object::GetObject(smooth::String const&)
S::Object *S::Object::GetObject(const String &objectName)
{
	for (Int i = 0; i < GetNOfObjects(); i++)
	{
		Object	*object = GetNthObject(i);

		if (object->name != NIL && *(object->name) == objectName) return object;
	}

	return NIL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
xorl %ebx, %ebx
movq 0x105260(%rip), %r12    # 0x1617c0
xorl %ebp, %ebp
cmpl 0x8(%r12), %ebp
jge 0x5c58f
movl %ebp, %edi
callq 0x59b10
movq 0x10(%rax), %rdi
testq %rdi, %rdi
je 0x5c588
movq %rax, %r15
movq %r14, %rsi
callq 0x56960
testb %al, %al
jne 0x5c58c
incl %ebp
jmp 0x5c562
movq %r15, %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x5a1e0
testq %rax, %rax
je 0x5c5b9
pushq $-0x1
popq %rax
jmp 0x5c5e8
movq 0x10(%r14), %r15
testq %r15, %r15
jne 0x5c5db
pushq $0x18
popq %rdi
callq 0x56700
movq %rax, %r15
movq %rax, %rdi
xorl %esi, %esi
callq 0x5a180
movq %r15, 0x10(%r14)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x56630
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
pushq $0x18
popq %rsi
movq %r15, %rdi
callq 0x564c0
movq %rbx, %rdi
callq 0x58260
// File: /workspace/github_c_makefile_star2_O2/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 0x10(%rdi), %r15
testq %r15, %r15
jne 0x5c783
movq %rdi, %r14
pushq $0x58
popq %rdi
callq 0x56700
movq %rax, %r15
movq %rax, %rdi
callq 0x5c808
movq %r15, 0x10(%r14)
movq %r15, %rdi
callq 0x583a0
movq 0x10(%r14), %r15
pushq $0x10
popq %rdi
callq 0x56700
leaq 0xf91fe(%rip), %rcx     # 0x155990
movq %rcx, (%rax)
movq %rbx, 0x8(%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %r15, %rdi
callq 0x5c03a
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
pushq $0x58
popq %rsi
movq %r15, %rdi
callq 0x564c0
movq %rbx, %rdi
callq 0x58260
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x5df48
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x5a180
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x5cf26
movq (%rax), %rdi
jmp 0x5cf28
xorl %edi, %edi
movslq 0x18(%rsp), %rsi
callq 0x572e0
testq %rax, %rax
je 0x5cf52
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x5cf46
movq (%rax), %rsi
jmp 0x5cf48
xorl %esi, %esi
leaq 0x20(%rsp), %rdi
callq 0x57010
leaq 0x38(%rsp), %rdi
xorl %esi, %esi
callq 0x5a180
leaq 0x38(%rsp), %rsi
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
callq 0x59fb0
leaq 0x38(%rsp), %rdi
callq 0x5a588
leaq 0x20(%rsp), %rdi
callq 0x5a588
leaq 0x8(%rsp), %rdi
callq 0x5df9a
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
retq
jmp 0x5cfa8
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x5a588
jmp 0x5cfab
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x5a588
jmp 0x5cfba
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5df9a
movq %rbx, %rdi
callq 0x58260
// File: /workspace/github_c_makefile_star2_O2/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 0x56480
xorl %ebx, %ebx
testb %al, %al
jne 0x5db5f
movq %rsp, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x57f20
pushq $0x1
popq %rbp
xorl %r12d, %r12d
leaq 0x18(%rsp), %r14
leaq 0xa46ea(%rip), %r15     # 0x1021c6
movq %rbx, %rdi
callq 0x58370
cmpl %eax, %ebp
jg 0x5db4c
movq %rbx, %rdi
movl %ebp, %esi
callq 0x59cc0
cmpl $0x5c, (%rax)
je 0x5db15
movq %rbx, %rdi
movl %ebp, %esi
callq 0x59cc0
cmpl $0x2f, (%rax)
je 0x5db15
movq %rbx, %rdi
movl %ebp, %esi
callq 0x59cc0
cmpl $0x0, (%rax)
jne 0x5db48
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x59e40
movq %r14, %rdi
movq %r15, %rsi
callq 0x58b90
movq %rax, %rdi
movl $0x1ff, %esi            # imm = 0x1FF
callq 0x56e20
testl %eax, %eax
sete %r12b
movq %r14, %rdi
callq 0x5a588
incl %ebp
jmp 0x5dadc
andb $0x1, %r12b
decb %r12b
movsbl %r12b, %ebx
movq %rsp, %rdi
callq 0x5a588
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5db7f
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x5a588
jmp 0x5db82
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5a588
movq %rbx, %rdi
callq 0x58260
// File: /workspace/github_c_makefile_star2_O2/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 0x56480
testb %al, %al
je 0x5dc11
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x57f20
leaq 0xa4601(%rip), %rsi     # 0x1021c6
movq %r15, %rdi
callq 0x58b90
movq %rax, %r14
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x57f20
leaq 0xa45e4(%rip), %rsi     # 0x1021c6
movq %rsp, %rdi
callq 0x58b90
movq %r14, %rdi
movq %rax, %rsi
callq 0x59ee0
movl %eax, %ebx
movq %rsp, %rdi
callq 0x5a588
leaq 0x18(%rsp), %rdi
callq 0x5a588
xorl %eax, %eax
negl %ebx
sbbl %eax, %eax
jmp 0x5dc14
pushq $-0x1
popq %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5a588
jmp 0x5dc30
jmp 0x5dc2d
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x5a588
movq %rbx, %rdi
callq 0x58260
// File: /workspace/github_c_makefile_star2_O2/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 0x56710
movq %rbx, %rdi
xorl %esi, %esi
callq 0x57310
movl $0x76c, %esi            # imm = 0x76C
addl 0x14(%r14), %esi
movl 0xc(%r14), %ecx
movl 0x10(%r14), %edx
incl %edx
movq %rbx, %rdi
callq 0x58d20
movl 0x8(%rsp), %esi
movl (%rsp), %ecx
movl 0x4(%rsp), %edx
movq %rbx, %rdi
callq 0x56910
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x57ca0
movq %r14, %rdi
callq 0x58260