LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: compile_let_is_not_let_star
TEST compile_let_is_not_let_star(Buffer *buf) {
  ASTNode *node = Reader_read("(let ((a 1) (b a)) a)");
  int compile_result = Compile_entry(buf, node);
  ASSERT_EQ(compile_result, -1);
  AST_heap_free(node);
  PASS();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x7e8e(%rip), %rdi      # 0x16401
callq 0x4e40
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4690
movl %eax, -0x1c(%rbp)
movl 0xcbb2(%rip), %eax      # 0x1b144
addl $0x1, %eax
movl %eax, 0xcba9(%rip)      # 0x1b144
cmpl $-0x1, -0x1c(%rbp)
je 0xe5e6
jmp 0xe5a3
leaq 0x60f9(%rip), %rax      # 0x146a3
movq %rax, 0xcb9f(%rip)      # 0x1b150
movl $0x85b, 0xcb8d(%rip)    # imm = 0x85B
leaq 0x7da0(%rip), %rax      # 0x16362
movq %rax, 0xcb8f(%rip)      # 0x1b158
movzbl 0xcb30(%rip), %eax      # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0xe5dd
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xe603
jmp 0xe5e8
movq -0x18(%rbp), %rdi
callq 0x1800
movq $0x0, 0xcb5c(%rip) # 0x1b158
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: compile_nested_if
TEST compile_nested_if(Buffer *buf) {
  ASTNode *node = Reader_read("(if (< 1 2) (if #f 3 4) 5)");
  int compile_result = Compile_entry(buf, node);
  ASSERT_EQ(compile_result, 0);
  Buffer_make_executable(buf);
  uword result = Testing_execute_expr(buf);
  ASSERT_EQ_FMT(Object_encode_integer(4), result, "0x%lx");
  AST_heap_free(node);
  PASS();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x7a52(%rip), %rdi      # 0x16475
callq 0x4e40
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4690
movl %eax, -0x1c(%rbp)
movl 0xc702(%rip), %eax      # 0x1b144
addl $0x1, %eax
movl %eax, 0xc6f9(%rip)      # 0x1b144
cmpl $0x0, -0x1c(%rbp)
je 0xea99
jmp 0xea53
leaq 0x5c49(%rip), %rax      # 0x146a3
movq %rax, 0xc6ef(%rip)      # 0x1b150
movl $0x89d, 0xc6dd(%rip)    # imm = 0x89D
leaq 0x7613(%rip), %rax      # 0x16085
movq %rax, 0xc6df(%rip)      # 0x1b158
movzbl 0xc680(%rip), %eax      # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0xea8d
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xebc5
jmp 0xea9b
movq -0x10(%rbp), %rdi
callq 0x1c50
movq -0x10(%rbp), %rdi
callq 0x4f20
movq %rax, -0x28(%rbp)
movl 0xc68d(%rip), %eax      # 0x1b144
addl $0x1, %eax
movl %eax, 0xc684(%rip)      # 0x1b144
movl $0x4, %edi
callq 0x1290
cmpq -0x28(%rbp), %rax
je 0xeba8
movq 0xc4f5(%rip), %rax      # 0x1afd0
movq (%rax), %rdi
leaq 0x6c49(%rip), %rsi      # 0x1572e
movb $0x0, %al
callq 0x1100
movq 0xc4dd(%rip), %rax      # 0x1afd0
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movl $0x4, %edi
callq 0x1290
movq -0x30(%rbp), %rdi
movq %rax, %rdx
leaq 0x77b6(%rip), %rsi      # 0x162c8
movb $0x0, %al
callq 0x1100
movq 0xc4b0(%rip), %rax      # 0x1afd0
movq (%rax), %rdi
leaq 0x6c10(%rip), %rsi      # 0x1573a
movb $0x0, %al
callq 0x1100
movq 0xc498(%rip), %rax      # 0x1afd0
movq (%rax), %rdi
movq -0x28(%rbp), %rdx
leaq 0x7782(%rip), %rsi      # 0x162c8
movb $0x0, %al
callq 0x1100
movq 0xc47c(%rip), %rax      # 0x1afd0
movq (%rax), %rdi
leaq 0x7e5e(%rip), %rsi      # 0x169bc
movb $0x0, %al
callq 0x1100
leaq 0x5b37(%rip), %rax      # 0x146a3
movq %rax, 0xc5dd(%rip)      # 0x1b150
movl $0x8a0, 0xc5cb(%rip)    # imm = 0x8A0
leaq 0x790c(%rip), %rax      # 0x16490
movq %rax, 0xc5cd(%rip)      # 0x1b158
movzbl 0xc56e(%rip), %eax      # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0xeb9f
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xebc5
jmp 0xebaa
movq -0x18(%rbp), %rdi
callq 0x1800
movq $0x0, 0xc59a(%rip) # 0x1b158
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: compile_code_with_one_param
TEST compile_code_with_one_param(Buffer *buf) {
  ASTNode *node = Reader_read("(code (x) x)");
  int compile_result = Compile_code(buf, node);
  ASSERT_EQ(compile_result, 0);
  // clang-format off
  byte expected[] = {
      // mov rax, [rsp-8]
      0x48, 0x8b, 0x44, 0x24, 0xf8,
      // ret
      0xc3,
  };
  // clang-format on
  EXPECT_EQUALS_BYTES(buf, expected);
  AST_heap_free(node);
  PASS();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x667e(%rip), %rdi      # 0x16791
callq 0x4e40
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x43c0
movl %eax, -0x1c(%rbp)
movl 0xb012(%rip), %eax      # 0x1b144
addl $0x1, %eax
movl %eax, 0xb009(%rip)      # 0x1b144
cmpl $0x0, -0x1c(%rbp)
je 0x10189
jmp 0x10143
leaq 0x4559(%rip), %rax      # 0x146a3
movq %rax, 0xafff(%rip)      # 0x1b150
movl $0x94b, 0xafed(%rip)    # imm = 0x94B
leaq 0x5f23(%rip), %rax      # 0x16085
movq %rax, 0xafef(%rip)      # 0x1b158
movzbl 0xaf90(%rip), %eax      # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0x1017d
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x102ac
jmp 0x1018b
movl 0x440f(%rip), %eax      # 0x145a0
movl %eax, -0x22(%rbp)
movw 0x4409(%rip), %ax       # 0x145a4
movw %ax, -0x1e(%rbp)
leaq -0x22(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq $0x6, -0x30(%rbp)
leaq 0xaf27(%rip), %rax      # 0x1b0e8
movq %rax, -0x48(%rbp)
movl 0xaf79(%rip), %eax      # 0x1b144
addl $0x1, %eax
movl %eax, 0xaf70(%rip)      # 0x1b144
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x48(%rbp), %rdx
leaq -0x40(%rbp), %rcx
callq 0x11f00
cmpl $0x0, %eax
jne 0x1028d
cmpq $0x0, -0x48(%rbp)
je 0x10203
movq -0x48(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x10248
jmp 0x10205
leaq 0x4497(%rip), %rax      # 0x146a3
movq %rax, 0xaf3d(%rip)      # 0x1b150
movl $0x954, 0xaf2b(%rip)    # imm = 0x954
leaq 0x58b9(%rip), %rax      # 0x15add
movq %rax, 0xaf2d(%rip)      # 0x1b158
movzbl 0xaece(%rip), %eax      # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0x1023f
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x102ac
jmp 0x1024a
leaq 0x4452(%rip), %rax      # 0x146a3
movq %rax, 0xaef8(%rip)      # 0x1b150
movl $0x954, 0xaee6(%rip)    # imm = 0x954
leaq 0x60de(%rip), %rax      # 0x16347
movq %rax, 0xaee8(%rip)      # 0x1b158
movzbl 0xae89(%rip), %eax      # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0x10284
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x102ac
jmp 0x1028f
jmp 0x10291
movq -0x18(%rbp), %rdi
callq 0x1800
movq $0x0, 0xaeb3(%rip) # 0x1b158
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mtnygard[P]complisp/lisp.c
// Function: compile_code_with_two_params
TEST compile_code_with_two_params(Buffer *buf) {
  ASTNode *node = Reader_read("(code (x y) (+ x y))");
  int compile_result = Compile_code(buf, node);
  ASSERT_EQ(compile_result, 0);
  // clang-format off
  byte expected[] = {
      // mov rax, [rsp-16]
      0x48, 0x8b, 0x44, 0x24, 0xf0,
      // mov [rsp-24], rax
      0x48, 0x89, 0x44, 0x24, 0xe8,
      // mov rax, [rsp-8]
      0x48, 0x8b, 0x44, 0x24, 0xf8,
      // add rax, [rsp-24]
      0x48, 0x03, 0x44, 0x24, 0xe8,
      // ret
      0xc3,
  };
  // clang-format on
  EXPECT_EQUALS_BYTES(buf, expected);
  AST_heap_free(node);
  PASS();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x64cb(%rip), %rdi      # 0x1679e
callq 0x4e40
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x43c0
movl %eax, -0x1c(%rbp)
movl 0xae52(%rip), %eax      # 0x1b144
addl $0x1, %eax
movl %eax, 0xae49(%rip)      # 0x1b144
cmpl $0x0, -0x1c(%rbp)
je 0x10349
jmp 0x10303
leaq 0x4399(%rip), %rax      # 0x146a3
movq %rax, 0xae3f(%rip)      # 0x1b150
movl $0x95c, 0xae2d(%rip)    # imm = 0x95C
leaq 0x5d63(%rip), %rax      # 0x16085
movq %rax, 0xae2f(%rip)      # 0x1b158
movzbl 0xadd0(%rip), %eax      # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0x1033d
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x10480
jmp 0x1034b
movq 0x425e(%rip), %rax      # 0x145b0
movq %rax, -0x40(%rbp)
movq 0x425b(%rip), %rax      # 0x145b8
movq %rax, -0x38(%rbp)
movl 0x4259(%rip), %eax      # 0x145c0
movl %eax, -0x30(%rbp)
movb 0x4254(%rip), %al       # 0x145c4
movb %al, -0x2c(%rbp)
leaq -0x40(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq $0x15, -0x48(%rbp)
leaq 0xad53(%rip), %rax      # 0x1b0e8
movq %rax, -0x60(%rbp)
movl 0xada5(%rip), %eax      # 0x1b144
addl $0x1, %eax
movl %eax, 0xad9c(%rip)      # 0x1b144
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x60(%rbp), %rdx
leaq -0x58(%rbp), %rcx
callq 0x11f00
cmpl $0x0, %eax
jne 0x10461
cmpq $0x0, -0x60(%rbp)
je 0x103d7
movq -0x60(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x1041c
jmp 0x103d9
leaq 0x42c3(%rip), %rax      # 0x146a3
movq %rax, 0xad69(%rip)      # 0x1b150
movl $0x96b, 0xad57(%rip)    # imm = 0x96B
leaq 0x56e5(%rip), %rax      # 0x15add
movq %rax, 0xad59(%rip)      # 0x1b158
movzbl 0xacfa(%rip), %eax      # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0x10413
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x10480
jmp 0x1041e
leaq 0x427e(%rip), %rax      # 0x146a3
movq %rax, 0xad24(%rip)      # 0x1b150
movl $0x96b, 0xad12(%rip)    # imm = 0x96B
leaq 0x5f0a(%rip), %rax      # 0x16347
movq %rax, 0xad14(%rip)      # 0x1b158
movzbl 0xacb5(%rip), %eax      # 0x1b100
andl $0x4, %eax
cmpl $0x0, %eax
je 0x10458
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x10480
jmp 0x10463
jmp 0x10465
movq -0x18(%rbp), %rdi
callq 0x1800
movq $0x0, 0xacdf(%rip) # 0x1b158
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4e40
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1030
movq -0x10(%rbp), %rdi
callq 0x1740
testb $0x1, %al
jne 0x11801
jmp 0x1181e
movq 0x97f0(%rip), %rax      # 0x1aff8
movq (%rax), %rdi
leaq 0x3e88(%rip), %rsi      # 0x1569a
movb $0x0, %al
callq 0x1100
jmp 0x118e2
leaq -0x30(%rbp), %rdi
movl $0x1, %esi
callq 0x1b80
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq $-0x8, %rdx
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rcx
callq 0x29f0
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1800
cmpl $0x0, -0x34(%rbp)
jge 0x1187d
movq 0x9797(%rip), %rax      # 0x1aff8
movq (%rax), %rdi
leaq 0x3e3d(%rip), %rsi      # 0x156a8
movb $0x0, %al
callq 0x1100
leaq -0x30(%rbp), %rdi
callq 0x1c00
jmp 0x118e2
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x118c1
movq 0x9762(%rip), %rax      # 0x1aff8
movq (%rax), %rdi
movq -0x30(%rbp), %rax
movq -0x40(%rbp), %rcx
movzbl (%rax,%rcx), %edx
leaq 0x3e0c(%rip), %rsi      # 0x156b8
movb $0x0, %al
callq 0x1100
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x11885
movq 0x9730(%rip), %rax      # 0x1aff8
movq (%rax), %rdi
leaq 0x50ea(%rip), %rsi      # 0x169bc
movb $0x0, %al
callq 0x1100
leaq -0x30(%rbp), %rdi
callq 0x1c00
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, 0x9a84(%rip)      # 0x1b388
jne 0x11917
movl $0x1f40, %edi           # imm = 0x1F40
callq 0x1120
movq %rax, 0x9a71(%rip)      # 0x1b388
movq -0x8(%rbp), %rdi
callq 0x4e40
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1740
testb $0x1, %al
jne 0x11933
jmp 0x11950
movq 0x96be(%rip), %rax      # 0x1aff8
movq (%rax), %rdi
leaq 0x3d56(%rip), %rsi      # 0x1569a
movb $0x0, %al
callq 0x1100
jmp 0x119e7
leaq -0x30(%rbp), %rdi
movl $0x1, %esi
callq 0x1b80
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x4690
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1800
cmpl $0x0, -0x34(%rbp)
jge 0x119a0
movq 0x9674(%rip), %rax      # 0x1aff8
movq (%rax), %rdi
leaq 0x3d1a(%rip), %rsi      # 0x156a8
movb $0x0, %al
callq 0x1100
leaq -0x30(%rbp), %rdi
callq 0x1c00
jmp 0x119e7
leaq -0x30(%rbp), %rdi
callq 0x1c50
movq 0x99d8(%rip), %rsi      # 0x1b388
leaq -0x30(%rbp), %rdi
callq 0x4e70
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x115f0
movq 0x962b(%rip), %rax      # 0x1aff8
movq (%rax), %rdi
leaq 0x4fe5(%rip), %rsi      # 0x169bc
movb $0x0, %al
callq 0x1100
leaq -0x30(%rbp), %rdi
callq 0x1c00
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq 0x95cd(%rip), %rax      # 0x1afd0
movq (%rax), %rdi
leaq 0x3cb2(%rip), %rsi      # 0x156bf
movb $0x0, %al
callq 0x1100
movq $0x0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq 0x95ad(%rip), %rax      # 0x1afd8
movq (%rax), %rdx
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x1160
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jge 0x11a75
movq 0x95ab(%rip), %rax      # 0x1aff8
movq (%rax), %rdi
leaq 0x3c6f(%rip), %rsi      # 0x156c6
movb $0x0, %al
callq 0x1100
movq -0x10(%rbp), %rdi
callq 0x1030
movq 0x991a(%rip), %rdi      # 0x1b388
callq 0x1030
jmp 0x11a94
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movq -0x10(%rbp), %rdi
callq 0x1030
movb $0x1, %al
testb $0x1, %al
jne 0x119fc
jmp 0x11a94
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x12480
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x12520
leaq -0xdbc7(%rip), %rdi     # 0x5060
leaq 0x2bac(%rip), %rsi      # 0x157da
callq 0x124f0
leaq -0xce8a(%rip), %rdi     # 0x5db0
leaq 0x2ba6(%rip), %rsi      # 0x157e7
callq 0x124f0
leaq -0xaa5d(%rip), %rdi     # 0x81f0
leaq 0x2b9d(%rip), %rsi      # 0x157f1
callq 0x124f0
leaq -0xa200(%rip), %rdi     # 0x8a60
leaq 0x2b97(%rip), %rsi      # 0x157fe
callq 0x124f0
leaq -0xc943(%rip), %rdi     # 0x6330
leaq 0x2b93(%rip), %rsi      # 0x1580d
callq 0x124f0
callq 0x12740
callq 0x11ff0
movl %eax, %edx
movl $0x1, %eax
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
jne 0x12d22
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x2b3f(%rip), %rsi      # 0x1581a
callq 0x10f0
cmpl $0x0, %eax
jne 0x12cf6
leaq -0x151c(%rip), %rdi     # 0x117d0
callq 0x119f0
movl %eax, -0x4(%rbp)
jmp 0x12d31
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x2b25(%rip), %rsi      # 0x1582a
callq 0x10f0
cmpl $0x0, %eax
jne 0x12d20
leaq -0x1426(%rip), %rdi     # 0x118f0
callq 0x119f0
movl %eax, -0x4(%rbp)
jmp 0x12d31
jmp 0x12d22
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x12c00
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x60d91
leaq -0x20(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x5a9c0
movq -0x50(%rbp), %rdi
callq 0x59680
movl %eax, -0x44(%rbp)
jmp 0x60d63
movl -0x44(%rbp), %eax
movl %eax, -0x4(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x5b5b0
jmp 0x60e32
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x5b5b0
jmp 0x60e3b
cmpq $0x0, 0x1aafe7(%rip)    # 0x20bd80
jne 0x60ddf
movl $0x58, %edi
callq 0x59820
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
callq 0x61410
jmp 0x60db6
movq -0x58(%rbp), %rax
movq %rax, 0x1aafbf(%rip)    # 0x20bd80
jmp 0x60ddf
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x58, %esi
callq 0x595b0
jmp 0x60e3b
movq 0x1aaf9a(%rip), %rdi    # 0x20bd80
leaq -0x10(%rbp), %rsi
callq 0x61450
leaq -0x40(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x5ca80
movq -0x68(%rbp), %rdi
callq 0x59680
movl %eax, -0x5c(%rbp)
jmp 0x60e0a
movl -0x5c(%rbp), %eax
movl %eax, -0x4(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x5a410
jmp 0x60e32
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x5a410
jmp 0x60e3b
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x5b6b0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x28(%rbp)
movq 0x1aac0c(%rip), %rdi    # 0x20bd78
callq 0x5c990
movl %eax, %ecx
movl -0x28(%rbp), %eax
cmpl %ecx, %eax
jge 0x611c5
movq 0x1aabf7(%rip), %rdi    # 0x20bd78
movl -0x4(%rbp), %esi
callq 0x61500
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x1aabdf(%rip), %rdi    # 0x20bd78
movl -0x4(%rbp), %esi
callq 0x61500
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x611b8
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x611ba
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x6115f
movq 0x1aabac(%rip), %rdi    # 0x20bd78
movq (%rdi), %rax
callq *0x20(%rax)
movq 0x1aab9f(%rip), %rax    # 0x20bd78
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x611ed
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x1aab8c(%rip), %rax    # 0x20bd80
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x61208
movq -0x40(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
leaq -0x18(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x5ca80
movq -0x50(%rbp), %rdi
callq 0x59680
movl %eax, -0x44(%rbp)
jmp 0x61223
leaq -0x18(%rbp), %rdi
callq 0x5a410
movl -0x44(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x5a410
movq -0x20(%rbp), %rdi
callq 0x5b6b0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x28(%rbp)
movq 0x1a6595(%rip), %rax    # 0x208880
addq $0x10, %rax
movq %rax, (%rsi)
movq %rsi, %rdi
addq $0x20, %rdi
callq 0x5c320
movq 0x1a6493(%rip), %rdi    # 0x208798
callq 0x5c990
cmpl $0x0, %eax
jne 0x62327
movq 0x1a6482(%rip), %rdi    # 0x208798
callq 0x5b830
movq 0x1a66fe(%rip), %rdi    # 0x208a20
callq 0x5b830
movq -0x28(%rbp), %rdi
movq 0x1a6a3e(%rip), %rax    # 0x208d70
movw (%rax), %ax
addq $0x20, %rdi
movswl %ax, %esi
callq 0x5a2e0
callq 0x59e10
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x8(%rax)
movq $0x0, 0x10(%rax)
movb $0x0, 0x18(%rax)
movb $0x0, 0x19(%rax)
movl $0x0, 0x1c(%rax)
movl $0x0, 0x30(%rax)
movq %rax, -0x10(%rbp)
movl 0x8(%rax), %edx
movq 0x1a641d(%rip), %rdi    # 0x208798
leaq -0x10(%rbp), %rsi
callq 0x62c40
movq 0x1a640d(%rip), %rdi    # 0x208798
callq 0x5c990
cmpl $0x1, %eax
jne 0x6240a
movl $0x68, %edi
callq 0x59820
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x59db0
jmp 0x623b0
movq -0x30(%rbp), %rcx
movq 0x1a6055(%rip), %rax    # 0x208410
movq %rcx, (%rax)
movq 0x1a604b(%rip), %rax    # 0x208410
movq (%rax), %rdi
addq $0x48, %rdi
movq 0x1a61dd(%rip), %rsi    # 0x2085b0
callq 0x62c80
movq 0x1a6031(%rip), %rax    # 0x208410
movq (%rax), %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x59120
jmp 0x6240a
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x68, %esi
callq 0x595b0
jmp 0x62410
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x5b6b0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x14(%rbp)
movq 0x1a6594(%rip), %rdi    # 0x208a20
callq 0x5c990
movl %eax, %ecx
movl -0x14(%rbp), %eax
cmpl %ecx, %eax
jge 0x624fd
movl -0x4(%rbp), %esi
movq 0x1a657c(%rip), %rdi    # 0x208a20
callq 0x62d80
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5d610
testb $0x1, %al
jne 0x624bf
jmp 0x624c1
jmp 0x624f2
movl -0x4(%rbp), %esi
movl %esi, %eax
addl $-0x1, %eax
movl %eax, -0x4(%rbp)
movq 0x1a654d(%rip), %rdi    # 0x208a20
callq 0x61860
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x624f0
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
jmp 0x624f2
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x6247f
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x1a6355(%rip), %rcx    # 0x208880
addq $0x10, %rcx
movq %rcx, (%rax)
testb $0x1, 0x19(%rax)
jne 0x6254f
movq -0x10(%rbp), %rax
movl 0x8(%rax), %esi
movq 0x1a6252(%rip), %rdi    # 0x208798
callq 0x5d7a0
jmp 0x6254d
jmp 0x6254f
movq 0x1a6242(%rip), %rdi    # 0x208798
callq 0x5c990
movl %eax, -0x14(%rbp)
jmp 0x62560
movl -0x14(%rbp), %eax
cmpl $0x1, %eax
jne 0x6258c
movq 0x1a5ea1(%rip), %rax    # 0x208410
movq (%rax), %rdi
callq 0x5de90
jmp 0x62579
movq 0x1a5e90(%rip), %rax    # 0x208410
movq (%rax), %rdi
callq 0x5d8d0
jmp 0x6258a
jmp 0x6258c
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x625c2
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x625c0
movq -0x20(%rbp), %rdi
callq 0x5df00
movq -0x20(%rbp), %rdi
movl $0x18, %esi
callq 0x595b0
jmp 0x625c2
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x61c50
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x625fc
movq -0x10(%rbp), %rax
movl 0x8(%rax), %esi
movq 0x1a61a7(%rip), %rdi    # 0x208798
callq 0x62db0
cmpq $0x0, (%rax)
jne 0x6264a
leaq -0x20(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x5a9c0
movq -0x50(%rbp), %rdi
callq 0x59680
movl %eax, -0x44(%rbp)
jmp 0x6261c
movl -0x44(%rbp), %eax
movl %eax, -0x4(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x5b5b0
jmp 0x62702
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x5b5b0
jmp 0x6270b
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *(%rax)
movq -0x10(%rbp), %rax
movb $0x1, 0x19(%rax)
movq -0x10(%rbp), %rdi
callq 0x5d610
testb $0x1, %al
jne 0x62695
movq -0x10(%rbp), %rax
movl 0x8(%rax), %esi
movq 0x1a6122(%rip), %rdi    # 0x208798
callq 0x5d7a0
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
je 0x62693
movq -0x58(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
jmp 0x626bf
movq -0x10(%rbp), %rax
movl 0x8(%rax), %esi
movq 0x1a60f5(%rip), %rdi    # 0x208798
callq 0x5d7a0
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edx
movq 0x1a636a(%rip), %rdi    # 0x208a20
leaq -0x10(%rbp), %rsi
callq 0x62c40
leaq -0x40(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x5ca80
movq -0x68(%rbp), %rdi
callq 0x59680
movl %eax, -0x5c(%rbp)
jmp 0x626da
movl -0x5c(%rbp), %eax
movl %eax, -0x4(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x5a410
jmp 0x62702
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x5a410
jmp 0x6270b
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x5b6b0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movl %edi, -0xc(%rbp)
movw %ax, -0xe(%rbp)
movl -0xc(%rbp), %esi
movq 0x1a5f6c(%rip), %rdi    # 0x208798
callq 0x62db0
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x62849
movq $0x0, -0x8(%rbp)
jmp 0x62876
movq -0x18(%rbp), %rdi
callq 0x5bb10
movq %rax, %rdi
movswl -0xe(%rbp), %esi
callq 0x5bc10
testb $0x1, %al
jne 0x62864
jmp 0x6286e
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x62876
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
callq 0x5bd10
movl %eax, %ecx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
jge 0x628ec
movl -0x14(%rbp), %edi
callq 0x5d300
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x628df
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x59ac0
testb $0x1, %al
jne 0x628d5
jmp 0x628df
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x628f4
jmp 0x628e1
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x62893
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5db20
cmpq $0x0, %rax
je 0x62978
leaq -0x28(%rbp), %rdi
movq %rdi, -0x60(%rbp)
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x5a9c0
movq -0x60(%rbp), %rdi
callq 0x59680
movl %eax, -0x54(%rbp)
jmp 0x6294a
movl -0x54(%rbp), %eax
movl %eax, -0x4(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x5b5b0
jmp 0x62a1e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x5b5b0
jmp 0x62a2a
movq -0x50(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x629ca
movl $0x18, %edi
callq 0x59820
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x68(%rbp)
xorl %esi, %esi
callq 0x5da90
jmp 0x629a0
movq -0x50(%rbp), %rax
movq -0x68(%rbp), %rcx
movq %rcx, 0x10(%rax)
jmp 0x629ca
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movl $0x18, %esi
callq 0x595b0
jmp 0x62a2a
movq -0x50(%rbp), %rax
movq -0x18(%rbp), %rsi
movq 0x10(%rax), %rdi
callq 0x59760
leaq -0x48(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x5ca80
movq -0x78(%rbp), %rdi
callq 0x59680
movl %eax, -0x6c(%rbp)
jmp 0x629f6
movl -0x6c(%rbp), %eax
movl %eax, -0x4(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x5a410
jmp 0x62a1e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x5a410
jmp 0x62a2a
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x5b6b0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, 0x10(%rax)
jne 0x62cf0
movl $0x58, %edi
callq 0x59820
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
callq 0x62ec0
jmp 0x62cba
movq -0x40(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%rax), %rdi
callq 0x5b830
jmp 0x62cf0
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x58, %esi
callq 0x595b0
jmp 0x62d71
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x58(%rbp)
movl $0x10, %edi
callq 0x59820
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rsi
callq 0x62f30
jmp 0x62d1b
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rsi
callq 0x62f00
leaq -0x38(%rbp), %rdi
callq 0x5ca80
leaq -0x38(%rbp), %rdi
callq 0x59680
movl %eax, -0x5c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x5a410
movl -0x5c(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x10, %esi
callq 0x595b0
movq -0x18(%rbp), %rdi
callq 0x5b6b0
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rdi
movl $0x1001, %esi           # imm = 0x1001
callq 0x65e10
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
callq 0x5da90
jmp 0x640a5
leaq -0x20(%rbp), %rdi
callq 0x65e90
movq %rax, -0x78(%rbp)
jmp 0x640b4
leaq -0x20(%rbp), %rdi
callq 0x65ed0
movl %eax, -0x7c(%rbp)
jmp 0x640c2
movq -0x78(%rbp), %rdi
movl -0x7c(%rbp), %eax
movslq %eax, %rsi
callq 0x5a5f0
cmpq $0x0, %rax
je 0x64119
leaq -0x20(%rbp), %rdi
callq 0x65e90
movq %rax, -0x88(%rbp)
jmp 0x640e9
movq -0x88(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x5a230
jmp 0x640fb
jmp 0x64119
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x6417f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x64176
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
callq 0x5da90
jmp 0x64126
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x5d860
jmp 0x64139
leaq -0x60(%rbp), %rdi
callq 0x5df00
leaq -0x38(%rbp), %rdi
callq 0x5df00
leaq -0x20(%rbp), %rdi
callq 0x65ef0
movq -0x68(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x5df00
leaq -0x38(%rbp), %rdi
callq 0x5df00
leaq -0x20(%rbp), %rdi
callq 0x65ef0
movq -0x40(%rbp), %rdi
callq 0x5b6b0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/files/directory.cpp
// Function: smooth::Directory::operator=(smooth::Directory const&)
S::Directory &S::Directory::operator =(const Directory &nDirectory)
{
	if (&nDirectory == this) return *this;

	dirName = nDirectory.dirName;
	dirPath = nDirectory.dirPath;

	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq %rax, -0x18(%rbp)
jne 0x64378
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x643a2
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x59760
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x18, %rsi
addq $0x18, %rdi
callq 0x59760
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/files/directory.cpp
// Function: smooth::Directory::GetCreateTime() const
S::DateTime S::Directory::GetCreateTime() const
{
	DateTime	 dateTime;

	if (!Exists()) return dateTime;

#ifdef __WIN32__
	WIN32_FIND_DATA	 findData;
	HANDLE		 handle = FindFirstFile(MakeExtendedPath(*this), &findData);

	FindClose(handle);

	SYSTEMTIME	 time;

	FileTimeToSystemTime(&findData.ftCreationTime, &time);

	dateTime.SetYMD(time.wYear, time.wMonth, time.wDay);
	dateTime.SetHMS(time.wHour, time.wMinute, time.wSecond);
#endif

	return dateTime;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movb $0x0, -0x11(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x5a620
movq -0x38(%rbp), %rdi
callq 0x59570
movb %al, -0x29(%rbp)
jmp 0x6508e
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x650bb
jmp 0x65097
movb $0x1, -0x11(%rbp)
movl $0x1, -0x28(%rbp)
jmp 0x650c6
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x5b070
jmp 0x650df
movb $0x1, -0x11(%rbp)
movl $0x1, -0x28(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x650d5
movq -0x48(%rbp), %rdi
callq 0x5b070
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x5b6b0
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/files/directory.cpp
// Function: smooth::Directory::Exists() const
S::Bool S::Directory::Exists() const
{
#ifdef __WIN32__
	/* Check if root directory of a drive
	 */
	if (dirPath[dirPath.Length() - 1] == ':' && dirName == NIL)
	{
		DWORD	 drives = GetLogicalDrives();

		if ((drives >> (dirPath.ToUpper()[0] - 'A')) & 1) return True;
		else						  return False;
	}

	WIN32_FIND_DATA	 findData;
	HANDLE		 handle = FindFirstFile(MakeExtendedPath(*this), &findData);

	if (handle == INVALID_HANDLE_VALUE) return False;

	FindClose(handle);

	if (!(findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) return False;
#else
	struct stat	 info;

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

	if (!S_ISDIR(info.st_mode)) return False;
#endif

	return True;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0xb8(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x5b330
movq -0xd8(%rbp), %rdi
leaq 0x140ac2(%rip), %rsi    # 0x1a5be6
callq 0x5c120
movq %rax, -0xd0(%rbp)
jmp 0x65132
movq -0xd0(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x5d0d0
movl %eax, -0xdc(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x5df00
movl -0xdc(%rbp), %eax
cmpl $0x0, %eax
je 0x65188
movb $0x0, -0x1(%rbp)
jmp 0x651a4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x5df00
jmp 0x651b2
movl -0x88(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x4000, %eax           # imm = 0x4000
je 0x651a0
movb $0x0, -0x1(%rbp)
jmp 0x651a4
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xe0, %rsp
popq %rbp
retq
movq -0xc0(%rbp), %rdi
callq 0x5b6b0
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x59570
testb $0x1, %al
jne 0x65541
leaq -0x28(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x5a9c0
movq -0xa0(%rbp), %rdi
callq 0x59680
movl %eax, -0x94(%rbp)
jmp 0x65510
movl -0x94(%rbp), %eax
movl %eax, -0x4(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x5b5b0
jmp 0x656c6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x5b5b0
jmp 0x656d2
movq -0x90(%rbp), %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x5b330
movq -0xb0(%rbp), %rdi
leaq 0x140680(%rip), %rsi    # 0x1a5be6
callq 0x5c120
movq %rax, -0xa8(%rbp)
jmp 0x65574
movq -0x18(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x5b330
jmp 0x65583
leaq 0x14065c(%rip), %rsi    # 0x1a5be6
leaq -0x68(%rbp), %rdi
callq 0x5c120
movq %rax, -0xb8(%rbp)
jmp 0x6559c
movq -0xb8(%rbp), %rsi
movq -0xa8(%rbp), %rdi
callq 0x5d780
cmpl $0x0, %eax
sete %al
movb %al, -0xb9(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x5df00
leaq -0x50(%rbp), %rdi
callq 0x5df00
movb -0xb9(%rbp), %al
andb $0x1, %al
movb %al, -0x35(%rbp)
movb -0x35(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x6566e
leaq -0x78(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x5a9c0
movq -0xc8(%rbp), %rdi
callq 0x59680
movl %eax, -0xc0(%rbp)
jmp 0x65612
movl -0xc0(%rbp), %eax
movl %eax, -0x4(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x5b5b0
jmp 0x656c6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x6564c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x5df00
leaq -0x50(%rbp), %rdi
callq 0x5df00
jmp 0x656d2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x5b5b0
jmp 0x656d2
leaq -0x88(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x5ca80
movq -0xd8(%rbp), %rdi
callq 0x59680
movl %eax, -0xcc(%rbp)
jmp 0x65695
movl -0xcc(%rbp), %eax
movl %eax, -0x4(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x5a410
jmp 0x656c6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x5a410
jmp 0x656d2
movl -0x4(%rbp), %eax
addq $0xe0, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x5b6b0
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/files/directory.cpp
// Function: smooth::Directory::Delete()
S::Int S::Directory::Delete()
{
#ifdef __WIN32__
	Bool	 result = RemoveDirectory(MakeExtendedPath(*this));
#else
	Bool	 result = (rmdir(String(*this).ConvertTo("UTF-8")) == 0);
#endif

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x5b330
movq -0x70(%rbp), %rdi
leaq 0x1404db(%rip), %rsi    # 0x1a5be6
callq 0x5c120
movq %rax, -0x68(%rbp)
jmp 0x65716
movq -0x68(%rbp), %rdi
callq 0x5a880
cmpl $0x0, %eax
sete %al
movb %al, -0x71(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5df00
movb -0x71(%rbp), %al
andb $0x1, %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x657a5
leaq -0x50(%rbp), %rdi
movq %rdi, -0x80(%rbp)
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x5a9c0
movq -0x80(%rbp), %rdi
callq 0x59680
movl %eax, -0x78(%rbp)
jmp 0x65766
movl -0x78(%rbp), %eax
movl %eax, -0x4(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x5b5b0
jmp 0x657f4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5df00
jmp 0x65800
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x5b5b0
jmp 0x65800
leaq -0x60(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x5ca80
movq -0x90(%rbp), %rdi
callq 0x59680
movl %eax, -0x84(%rbp)
jmp 0x657c9
movl -0x84(%rbp), %eax
movl %eax, -0x4(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x5a410
jmp 0x657f4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x5a410
jmp 0x65800
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x5b6b0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/classes/files/directory.cpp
// Function: smooth::Directory::SetActiveDirectory(smooth::Directory const&)
S::Int S::Directory::SetActiveDirectory(const Directory &directory)
{
#ifdef __WIN32__
	Bool	 result = SetCurrentDirectory(MakeExtendedPath(directory).Append(kBackslash));
#else
	Bool	 result = (chdir(String(directory).ConvertTo("UTF-8")) == 0);
#endif

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x5b330
movq -0x70(%rbp), %rdi
leaq 0x1402cb(%rip), %rsi    # 0x1a5be6
callq 0x5c120
movq %rax, -0x68(%rbp)
jmp 0x65926
movq -0x68(%rbp), %rdi
callq 0x5da80
cmpl $0x0, %eax
sete %al
movb %al, -0x71(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5df00
movb -0x71(%rbp), %al
andb $0x1, %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x659b5
leaq -0x50(%rbp), %rdi
movq %rdi, -0x80(%rbp)
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x5a9c0
movq -0x80(%rbp), %rdi
callq 0x59680
movl %eax, -0x78(%rbp)
jmp 0x65976
movl -0x78(%rbp), %eax
movl %eax, -0x4(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x5b5b0
jmp 0x65a04
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5df00
jmp 0x65a10
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x5b5b0
jmp 0x65a10
leaq -0x60(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x5ca80
movq -0x90(%rbp), %rdi
callq 0x59680
movl %eax, -0x84(%rbp)
jmp 0x659d9
movl -0x84(%rbp), %eax
movl %eax, -0x4(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x5a410
jmp 0x65a04
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x5a410
jmp 0x65a10
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x5b6b0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x59840
movq -0x68(%rbp), %rdi
movb $0x0, -0x49(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x5a620
movq -0x68(%rbp), %rdi
movl -0x34(%rbp), %esi
addl $0x76c, %esi            # imm = 0x76C
movl -0x3c(%rbp), %ecx
movl -0x38(%rbp), %edx
incl %edx
callq 0x5c310
jmp 0x672b5
movq -0x68(%rbp), %rdi
movl -0x40(%rbp), %esi
movl -0x48(%rbp), %ecx
movl -0x44(%rbp), %edx
callq 0x59a70
jmp 0x672c9
movb $0x1, -0x49(%rbp)
testb $0x1, -0x49(%rbp)
jne 0x672f5
jmp 0x672ec
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
callq 0x5b070
jmp 0x672ff
movq -0x68(%rbp), %rdi
callq 0x5b070
movq -0x70(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x5b6b0
nopl (%rax,%rax)