LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/symbol.c
// Function: AddStructType
void AddStructType(struct SymbolEntry **ctx, const char *key,
                   struct Node *type) {
  assert(ctx);
  struct SymbolEntry *e = AllocSymbolEntry(kSymbolStructType, key, type);
  PushSymbol(ctx, e);
  PrintASTNode(type);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x9065
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl $0x1, %edi
movl $0x20, %esi
callq 0x20f0
movl $0x5, (%rax)
movq %r15, 0x10(%rax)
movq %rbx, 0x18(%rax)
movq (%r14), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%r14)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x441a
leaq 0x3603(%rip), %rdi      # 0xc66f
leaq 0x35f3(%rip), %rsi      # 0xc666
movl $0x7a, %edx
callq 0x46d0
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/symbol.c
// Function: FindStructType
struct Node *FindStructType(struct SymbolEntry *e, struct Node *key_token) {
  for (; e; e = e->prev) {
    if (e->type != kSymbolStructType) continue;
    if (!IsEqualTokenWithCStr(key_token, e->key)) continue;
    return e->value;
  }
  return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x90b0
movq %rsi, %r15
movq %rdi, %r14
xorl %ebx, %ebx
cmpl $0x5, (%r14)
jne 0x90a5
movq 0x10(%r14), %rsi
movq %r15, %rdi
callq 0x9210
testl %eax, %eax
jne 0x90b4
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0x908f
jmp 0x90b8
xorl %ebx, %ebx
jmp 0x90b8
movq 0x18(%r14), %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/token.c
// Function: AllocToken
struct Node *AllocToken(const char *src_str, int line, const char *begin,
                        int length, enum TokenType type) {
  struct Node *t = AllocNode(kNodeToken);
  t->begin = begin;
  t->length = length;
  t->token_type = type;
  t->src_str = src_str;
  t->line = line;
  return t;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %r12
movl $0x1, %edi
callq 0x3f11
movq %r14, 0x118(%rax)
movl %ebp, 0x120(%rax)
movl %ebx, 0x108(%rax)
movq %r12, 0x128(%rax)
movl %r15d, 0x130(%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/token.c
// Function: DuplicateToken
struct Node *DuplicateToken(struct Node *base_token) {
  assert(IsToken(base_token));
  struct Node *t = AllocNode(kNodeToken);
  memcpy(t, base_token, sizeof(*t));
  t->next_token = NULL;
  return t;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x9178
movq %rdi, %rbx
cmpl $0x1, (%rdi)
jne 0x9178
movl $0x1, %edi
callq 0x3f11
movq %rax, %r14
movl $0x138, %edx            # imm = 0x138
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2130
movq $0x0, 0x110(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x350a(%rip), %rdi      # 0xc689
leaq 0x3517(%rip), %rsi      # 0xc69d
movl $0x15, %edx
callq 0x46d0
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/token.c
// Function: DuplicateTokenSequence
struct Node *DuplicateTokenSequence(struct Node *base_head) {
  struct Node *dup_head = NULL;
  struct Node **dup_head_holder = &dup_head;
  while (base_head) {
    *dup_head_holder = DuplicateToken(base_head);
    dup_head_holder = &(*dup_head_holder)->next_token;
    base_head = base_head->next_token;
  }
  return dup_head;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq $0x0, (%rsp)
testq %rdi, %rdi
je 0x91cd
movq %rdi, %rbx
movq %rsp, %r14
movq %rbx, %rdi
callq 0x9134
movq %rax, (%r14)
addq $0x110, %rax            # imm = 0x110
movq 0x110(%rbx), %rbx
movq %rax, %r14
testq %rbx, %rbx
jne 0x91a7
movq (%rsp), %rax
jmp 0x91cf
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/token.c
// Function: PrintTokenSequence
void PrintTokenSequence(struct Node *t) {
  if (!t) return;
  assert(IsToken(t));
  for (; t; t = t->next_token) {
    if (t->token_type == kTokenZeroWidthNoBreakSpace) {
      continue;
    }
    fprintf(stderr, "%.*s", t->length, t->begin);
  }
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x92a1
movq %rdi, %rbx
cmpl $0x1, (%rdi)
je 0x928c
leaq 0x213b(%rip), %rdi      # 0xb3ac
leaq 0x3425(%rip), %rsi      # 0xc69d
movl $0x33, %edx
callq 0x46d0
movq %rbx, %rdi
callq 0x2e43
jmp 0x9295
cmpl $0x2, 0x108(%rbx)
jne 0x9282
movq 0x110(%rbx), %rbx
testq %rbx, %rbx
jne 0x928c
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/token.c
// Function: OutputTokenSequenceAsCSource
void OutputTokenSequenceAsCSource(struct Node *t) {
  if (!t) return;
  assert(IsToken(t));
  for (; t; t = t->next_token) {
    if (t->token_type == kTokenZeroWidthNoBreakSpace) {
      continue;
    }
    fprintf(stdout, "%.*s", t->length, t->begin);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x92f2
movq %rdi, %rbx
cmpl $0x1, (%rdi)
jne 0x92f8
movq 0x7d14(%rip), %r15      # 0x10fd0
leaq 0x33e2(%rip), %r14      # 0xc6a5
cmpl $0x2, 0x108(%rbx)
je 0x92e6
movq (%r15), %rdi
movl 0x120(%rbx), %edx
movq 0x118(%rbx), %rcx
movq %r14, %rsi
xorl %eax, %eax
callq 0x2110
movq 0x110(%rbx), %rbx
testq %rbx, %rbx
jne 0x92c3
popq %rbx
popq %r14
popq %r15
retq
leaq 0x20ad(%rip), %rdi      # 0xb3ac
leaq 0x3397(%rip), %rsi      # 0xc69d
movl $0x3e, %edx
callq 0x46d0
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/token.c
// Function: PrintTokenBrief
void PrintTokenBrief(struct Node *t) {
  assert(t);
  if (t->token_type == kTokenStringLiteral ||
      t->token_type == kTokenCharLiteral) {
    fprintf(stderr, "%.*s", t->length, t->begin);
    return;
  }
  fprintf(stderr, "<%.*s>", t->length, t->begin);
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x931d
callq 0x2e6b
popq %rax
retq
leaq 0x3270(%rip), %rdi      # 0xc594
leaq 0x3372(%rip), %rsi      # 0xc69d
movl $0x4c, %edx
callq 0x46d0
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/token.c
// Function: ConsumeToken
struct Node *ConsumeToken(enum TokenType type) {
  struct Node *t = *next_token_holder;
  if (!t || !IsTokenWithType(t, type)) return NULL;
  AdvanceTokenStream();
  return t;
}

// Assembly:
movq 0x7fb8(%rip), %rax      # 0x11388
movq (%rax), %rax
testq %rax, %rax
je 0x93f4
cmpl $0x1, (%rax)
jne 0x93f4
cmpl %edi, 0x108(%rax)
jne 0x93f4
leaq 0x110(%rax), %rcx
movq %rcx, 0x7f95(%rip)      # 0x11388
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/token.c
// Function: ConsumeTokenStr
struct Node *ConsumeTokenStr(const char *s) {
  struct Node *t = *next_token_holder;
  if (!t || !IsEqualTokenWithCStr(t, s)) return NULL;
  AdvanceTokenStream();
  return t;
}

// Assembly:
pushq %rbx
movq 0x7f89(%rip), %rax      # 0x11388
movq (%rax), %rbx
testq %rbx, %rbx
je 0x9426
movq %rdi, %rsi
movq %rbx, %rdi
callq 0x9210
testl %eax, %eax
je 0x9426
leaq 0x110(%rbx), %rax
movq %rax, 0x7f64(%rip)      # 0x11388
jmp 0x9428
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/token.c
// Function: ExpectTokenStr
struct Node *ExpectTokenStr(const char *s) {
  struct Node *t = *next_token_holder;
  if (!t) Error("Expect token %s but got EOF", s);
  if (!ConsumeTokenStr(s)) ErrorWithToken(t, "Expected token %s here", s);
  return t;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x7f4d(%rip), %rax      # 0x11388
movq (%rax), %r14
testq %r14, %r14
je 0x946b
movq %r14, %rdi
movq %rbx, %rsi
callq 0x9210
testl %eax, %eax
je 0x947c
leaq 0x110(%r14), %rax
movq %rax, 0x7f28(%rip)      # 0x11388
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x3278(%rip), %rdi      # 0xc6ea
movq %rbx, %rsi
xorl %eax, %eax
callq 0x45fc
leaq 0x3283(%rip), %rsi      # 0xc706
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x470c
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/token.c
// Function: ConsumePunctuator
struct Node *ConsumePunctuator(const char *s) {
  struct Node *t = *next_token_holder;
  if (!t || !IsTokenWithType(t, kTokenPunctuator) ||
      !IsEqualTokenWithCStr(t, s))
    return NULL;
  AdvanceTokenStream();
  return t;
}

// Assembly:
pushq %rbx
movq 0x7ef0(%rip), %rax      # 0x11388
movq (%rax), %rbx
testq %rbx, %rbx
je 0x94cd
cmpl $0x1, (%rbx)
jne 0x94cd
cmpl $0x19, 0x108(%rbx)
jne 0x94cd
movq %rdi, %rsi
movq %rbx, %rdi
callq 0x9210
testl %eax, %eax
je 0x94cd
leaq 0x110(%rbx), %rax
movq %rax, 0x7ebd(%rip)      # 0x11388
jmp 0x94cf
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/token.c
// Function: ExpectPunctuator
struct Node *ExpectPunctuator(const char *s) {
  struct Node *t = *next_token_holder;
  if (!t) Error("Expect token %s but got EOF", s);
  if (!ConsumePunctuator(s)) ErrorWithToken(t, "Expected token %s here", s);
  return t;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x7ea6(%rip), %rax      # 0x11388
movq (%rax), %r14
testq %r14, %r14
je 0x9502
movq %rbx, %rdi
callq 0x9490
testq %rax, %rax
je 0x9513
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x31e1(%rip), %rdi      # 0xc6ea
movq %rbx, %rsi
xorl %eax, %eax
callq 0x45fc
leaq 0x31ec(%rip), %rsi      # 0xc706
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x470c
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/token.c
// Function: InsertTokens
void InsertTokens(struct Node *seq_first) {
  // Insert token sequece (seq) at current cursor pos.
  if (!IsToken(seq_first)) return;
  struct Node *seq_last = seq_first;
  while (seq_last->next_token) seq_last = seq_last->next_token;
  seq_last->next_token = PeekToken();
  *next_token_holder = seq_first;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x95c6
cmpl $0x1, (%rdi)
jne 0x95c6
movq %rdi, %rcx
movq %rcx, %rax
movq 0x110(%rcx), %rcx
testq %rcx, %rcx
jne 0x959e
movq 0x7dd4(%rip), %rcx      # 0x11388
testq %rcx, %rcx
je 0x95c8
movq (%rcx), %rdx
movq %rdx, 0x110(%rax)
movq %rdi, (%rcx)
popq %rax
retq
leaq 0x3109(%rip), %rdi      # 0xc6d8
leaq 0x30c7(%rip), %rsi      # 0xc69d
movl $0x6d, %edx
callq 0x46d0
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/token.c
// Function: RemoveDelimiterTokens
struct Node **RemoveDelimiterTokens(struct Node **head_holder) {
  InitTokenStream(head_holder);
  for (;;) {
    struct Node *t = PeekToken();
    if (!t) break;
    if (ShouldRemoveToken(t)) {
      RemoveCurrentToken();
      continue;
    }
    AdvanceTokenStream();
  }
  return head_holder;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x9880
movq %rdi, 0x7b46(%rip)      # 0x11388
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x987b
movq %rdi, %rax
movl 0x108(%rcx), %edx
decl %edx
addq $0x110, %rcx            # imm = 0x110
cmpl $0x1, %edx
ja 0x9869
movq (%rcx), %rcx
movq %rcx, (%rax)
jmp 0x9873
movq %rcx, 0x7b18(%rip)      # 0x11388
movq %rcx, %rax
movq (%rax), %rcx
testq %rcx, %rcx
jne 0x984d
movq %rdi, %rax
popq %rcx
retq
leaq 0x2e3f(%rip), %rdi      # 0xc6c6
leaq 0x2e0f(%rip), %rsi      # 0xc69d
movl $0x63, %edx
callq 0x46d0
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/tokenizer.c
// Function: Tokenize
struct Node *Tokenize(const char *input) {
  // returns head of tokens.
  struct Node *token_head = NULL;
  struct Node **last_next_token = &token_head;
  const char *p = input;
  struct Node *t;
  int line = 1;
  while ((t = CreateNextToken(p, input, &line))) {
    *last_next_token = t;
    last_next_token = &t->next_token;
    p = t->begin + t->length;
  }
  return token_head;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq $0x0, 0x8(%rsp)
leaq 0x4(%rsp), %rdx
movl $0x1, (%rdx)
movq %rdi, %rsi
callq 0x98ae
testq %rax, %rax
je 0x9f33
leaq 0x8(%rsp), %r15
leaq 0x4(%rsp), %r14
movq %rax, (%r15)
leaq 0x110(%rax), %r15
movslq 0x120(%rax), %rdi
addq 0x118(%rax), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x98ae
testq %rax, %rax
jne 0x9f04
movq 0x8(%rsp), %rax
jmp 0x9f35
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/type.c
// Function: IsSameTypeExceptAttr
int IsSameTypeExceptAttr(struct Node *a, struct Node *b) {
  assert(a && b);
  a = GetTypeWithoutAttr(a);
  b = GetTypeWithoutAttr(b);
  if (a->type != b->type) return 0;
  if (a->type == kTypeBase) {
    assert(a->op && b->op);
    return a->op->type == b->op->type;
  } else if (a->type == kTypePointer) {
    return IsSameTypeExceptAttr(a->right, b->right);
  } else if (a->type == kTypeFunction) {
    if (!IsSameTypeExceptAttr(a->left, b->left)) return 0;
    if (GetSizeOfList(a->right) != GetSizeOfList(b->right)) return 0;
    for (int i = 0; i < GetSizeOfList(a->right); i++) {
      if (!IsSameTypeExceptAttr(GetNodeAt(a->right, i), GetNodeAt(b->right, i)))
        return 0;
    }
    return 1;
  }
  Error("IsSameTypeExceptAttr: Comparing non-type nodes");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x9fa5
movq %rsi, %rbx
testq %rsi, %rsi
je 0x9fa5
movq %rdi, %r14
xorl %ebp, %ebp
movl (%r14), %eax
cmpl $0x18, %eax
je 0x9f67
cmpl $0x15, %eax
jne 0x9f79
movq 0x20(%r14), %r14
testq %r14, %r14
jne 0x9f5a
xorl %r14d, %r14d
jmp 0x9f79
movq 0x20(%rbx), %rbx
movl (%rbx), %eax
cmpl $0x18, %eax
je 0x9f75
cmpl $0x15, %eax
je 0x9f75
cmpl %eax, (%r14)
jne 0xa070
cmpl $0x16, %eax
jne 0x9fbd
movq 0x20(%r14), %r14
testq %r14, %r14
je 0x9fa5
movq 0x20(%rbx), %rbx
testq %rbx, %rbx
jne 0x9f5a
leaq 0x2900(%rip), %rdi      # 0xc8ac
leaq 0x2900(%rip), %rsi      # 0xc8b3
movl $0x4, %edx
callq 0x46d0
cmpl $0x17, %eax
je 0x9ff1
cmpl $0x14, %eax
jne 0xa07b
movq 0x10(%r14), %rax
testq %rax, %rax
je 0xa089
movq 0x10(%rbx), %rcx
testq %rcx, %rcx
je 0xa089
movl (%rax), %eax
xorl %ebp, %ebp
cmpl (%rcx), %eax
sete %bpl
jmp 0xa070
movq 0x18(%r14), %rdi
movq 0x18(%rbx), %rsi
callq 0x9f40
testl %eax, %eax
je 0xa070
movq 0x20(%r14), %rdi
callq 0x48ee
movl %eax, %r15d
movq 0x20(%rbx), %rdi
callq 0x48ee
cmpl %eax, %r15d
jne 0xa070
movq 0x20(%r14), %rdi
callq 0x48ee
movl $0x1, %ebp
testl %eax, %eax
jle 0xa070
xorl %r15d, %r15d
movq 0x20(%r14), %rdi
movl %r15d, %esi
callq 0x4918
movq %rax, %r12
movq 0x20(%rbx), %rdi
movl %r15d, %esi
callq 0x4918
movq %r12, %rdi
movq %rax, %rsi
callq 0x9f40
testl %eax, %eax
je 0xa06e
incl %r15d
movq 0x20(%r14), %rdi
callq 0x48ee
cmpl %eax, %r15d
jl 0xa031
jmp 0xa070
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2847(%rip), %rdi      # 0xc8c9
xorl %eax, %eax
callq 0x45fc
leaq 0x282a(%rip), %rdi      # 0xc8ba
leaq 0x281c(%rip), %rsi      # 0xc8b3
movl $0x9, %edx
callq 0x46d0
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/type.c
// Function: EvalExprAsInt
int EvalExprAsInt(struct Node *n) {
  assert(n);
  if (IsTokenWithType(n->op, kTokenIntegerConstant)) {
    return strtol(n->op->begin, NULL, 0);
  }
  if (n->type == kASTExpr && IsEqualTokenWithCStr(n->op, "+")) {
    return EvalExprAsInt(n->left) + EvalExprAsInt(n->right);
  }
  assert(false);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xa17a
movq %rdi, %rbx
xorl %ebp, %ebp
leaq 0x1069(%rip), %r14      # 0xb1a8
movq 0x10(%rbx), %rdi
movl $0x3, %esi
callq 0x90d3
testb %al, %al
jne 0xa192
cmpl $0x4, (%rbx)
jne 0xa1ad
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x9210
testl %eax, %eax
je 0xa1ad
movq 0x18(%rbx), %rdi
callq 0xa12a
movq 0x20(%rbx), %rbx
addl %eax, %ebp
testq %rbx, %rbx
jne 0xa13f
leaq 0x2393(%rip), %rdi      # 0xc514
leaq 0x272b(%rip), %rsi      # 0xc8b3
movl $0x33, %edx
callq 0x46d0
movq 0x10(%rbx), %rax
movq 0x118(%rax), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2120
addl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xed3(%rip), %rdi       # 0xb087
leaq 0x26f8(%rip), %rsi      # 0xc8b3
movl $0x3a, %edx
callq 0x46d0
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/type.c
// Function: GetSizeOfType
int GetSizeOfType(struct Node *t) {
  t = GetTypeWithoutAttr(t);
  assert(t);
  if (t->type == kTypeBase) {
    assert(IsToken(t->op));
    switch (t->op->token_type) {
      case kTokenKwInt:
      case kTokenKwLong:
        return 4;
      case kTokenKwChar:
        return 1;
      case kTokenKwVoid:
        return 0;
      default:
        PrintASTNode(t->op);
        assert(false);
    }
  } else if (t->type == kTypePointer) {
    return 8;
  } else if (t->type == kTypeStruct) {
    if (!t->type_struct_spec) {
      ErrorWithToken(t->tag, "Cannot take sizeof incomplete struct");
    }
    return CalcStructSize(t->type_struct_spec);
  } else if (t->type == kTypeArray) {
    return GetSizeOfType(t->type_array_type_of) *
           EvalExprAsInt(t->type_array_index_decl);
  }
  PrintASTNode(t);
  assert(false);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xa1f7
movq %rdi, %rbx
leaq 0x26a1(%rip), %rax      # 0xc878
movl (%rbx), %ecx
addl $-0x14, %ecx
cmpl $0x6, %ecx
ja 0xa28e
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq 0x20(%rbx), %rbx
testq %rbx, %rbx
jne 0xa1d7
leaq 0x2396(%rip), %rdi      # 0xc594
leaq 0x26ae(%rip), %rsi      # 0xc8b3
movl $0x3f, %edx
callq 0x46d0
movq 0xf0(%rbx), %rdi
testq %rdi, %rdi
je 0xa2ae
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x8ae0
movq 0xf8(%rbx), %rdi
callq 0xa1c5
movl %eax, %ebp
movq 0x100(%rbx), %rdi
callq 0xa12a
imull %ebp, %eax
jmp 0xa283
movq 0x10(%rbx), %rdi
callq 0x90c4
testb %al, %al
je 0xa2c3
movq 0x10(%rbx), %rdi
movl 0x108(%rdi), %ecx
movl $0x4, %eax
leal -0xd(%rcx), %edx
cmpl $0x2, %edx
jb 0xa283
cmpl $0x15, %ecx
je 0xa28a
cmpl $0x6, %ecx
jne 0xa2db
movl $0x1, %eax
jmp 0xa283
movl $0x8, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
xorl %eax, %eax
jmp 0xa283
movq %rbx, %rdi
callq 0x441a
leaq 0xdea(%rip), %rdi       # 0xb087
leaq 0x260f(%rip), %rsi      # 0xc8b3
movl $0x5a, %edx
callq 0x46d0
movq 0xe8(%rbx), %rdi
leaq 0x2656(%rip), %rsi      # 0xc912
xorl %eax, %eax
callq 0x470c
leaq 0x2639(%rip), %rdi      # 0xc903
leaq 0x25e2(%rip), %rsi      # 0xc8b3
movl $0x41, %edx
callq 0x46d0
callq 0x441a
leaq 0xda0(%rip), %rdi       # 0xb087
leaq 0x25c5(%rip), %rsi      # 0xc8b3
movl $0x4c, %edx
callq 0x46d0
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/type.c
// Function: GetAlignOfType
int GetAlignOfType(struct Node *t) {
  t = GetTypeWithoutAttr(t);
  assert(t);
  if (t->type == kTypeBase) {
    assert(IsToken(t->op));
    switch (t->op->token_type) {
      case kTokenKwInt:
        return 4;
      case kTokenKwChar:
        return 1;
      default:
        assert(false);
    }
  } else if (t->type == kTypePointer) {
    return 8;
  } else if (t->type == kTypeStruct) {
    return CalcStructAlign(t->type_struct_spec);
  }
  PrintASTNode(t);
  assert(false);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0xa324
movq %rdi, %rbx
leaq 0x258c(%rip), %rax      # 0xc894
movl (%rbx), %ecx
addl $-0x14, %ecx
cmpl $0x5, %ecx
ja 0xa37d
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq 0x20(%rbx), %rbx
testq %rbx, %rbx
jne 0xa308
leaq 0x2269(%rip), %rdi      # 0xc594
leaq 0x2581(%rip), %rsi      # 0xc8b3
movl $0x5f, %edx
callq 0x46d0
movl $0x8, %eax
jmp 0xa37b
movq 0xf0(%rbx), %rdi
popq %rbx
jmp 0x8b47
movq 0x10(%rbx), %rdi
callq 0x90c4
testb %al, %al
je 0xa39d
movq 0x10(%rbx), %rax
movl 0x108(%rax), %ecx
movl $0x4, %eax
cmpl $0xd, %ecx
je 0xa37b
cmpl $0x6, %ecx
jne 0xa3b5
movl $0x1, %eax
popq %rbx
retq
movq %rbx, %rdi
callq 0x441a
leaq 0xcfb(%rip), %rdi       # 0xb087
leaq 0x2520(%rip), %rsi      # 0xc8b3
movl $0x70, %edx
callq 0x46d0
leaq 0x255f(%rip), %rdi      # 0xc903
leaq 0x2508(%rip), %rsi      # 0xc8b3
movl $0x61, %edx
callq 0x46d0
leaq 0xccb(%rip), %rdi       # 0xb087
leaq 0x24f0(%rip), %rsi      # 0xc8b3
movl $0x68, %edx
callq 0x46d0
// File: /workspace/github_c_makefile_star2_O3/jiribenes[P]scheme/src/core.c
// Function: arity_check
bool arity_check(vm_t *vm, const char *fn_name, value_t args, int n,
                 bool at_least) {
    int argc = cons_len(args);
    if (!at_least) {  // exactly
        if (argc != n) {
            error_runtime(vm, "%s: not enough args: %d expected, %d given!",
                          fn_name, n, argc);
            return false;
        }
    } else {  // at least
        if (argc < n) {
            error_runtime(vm, "%s: not enough args: >= %d expected, %d given!",
                          fn_name, n, argc);
            return false;
        }
    }
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %r8d, %ebp
movl %ecx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, %rdi
callq 0x4a8d
testl %ebp, %ebp
je 0x13aa
movb $0x1, %bpl
cmpl %ebx, %eax
jge 0x13cc
leaq 0x4ccc(%rip), %rsi      # 0x6074
jmp 0x13b8
movb $0x1, %bpl
cmpl %ebx, %eax
je 0x13cc
leaq 0x4c90(%rip), %rsi      # 0x6048
xorl %ebp, %ebp
movq %r15, %rdi
movq %r14, %rdx
movl %ebx, %ecx
movl %eax, %r8d
xorl %eax, %eax
callq 0x4cc4
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jiribenes[P]scheme/src/core.c
// Function: equal
static value_t equal(vm_t *vm, env_t *env, value_t args) {
    if (IS_NIL(args)) {
        return TRUE_VAL;
    }
    value_t eargs = eval_list(vm, env, args);
    value_t prev = NIL_VAL;
    value_t arg, iter;
    SCM_FOREACH (arg, AS_CONS(eargs), iter) {
        if (!IS_NIL(prev)) {
            // if we find a pair where the 'equal?' relation doesn't hold,
            // return false
            if (!val_equal(prev, arg)) {
                return FALSE_VAL;
            }
        }
        prev = arg;
    }
    return TRUE_VAL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movabsq $0x7ffc000000000001, %r12 # imm = 0x7FFC000000000001
leaq 0x1(%r12), %rbx
cmpq %r12, %rdx
je 0x2099
callq 0x5457
movq %rax, %r14
movabsq $0x3ffffffffffff, %rbp  # imm = 0x3FFFFFFFFFFFF
leaq 0x2(%r12), %r13
movq %r12, %rdi
andq %rbp, %r14
movq 0x10(%r14), %r15
cmpq %r12, %rdi
je 0x2088
movq %r15, %rsi
callq 0x4b9b
testb %al, %al
je 0x2096
movq 0x18(%r14), %r14
movq %r15, %rdi
cmpq %r12, %r14
jne 0x2070
jmp 0x2099
movq %r13, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jiribenes[P]scheme/src/core.c
// Function: builtin_define
static value_t builtin_define(vm_t *vm, env_t *env, value_t args) {
    cons_t *rest = AS_CONS(args);

    if (IS_SYMBOL(rest->car)) {  // (define <name> <body>)
        symbol_t *sym = AS_SYMBOL(rest->car);
        value_t body = AS_CONS(rest->cdr)->car;
        value_t val = eval(vm, env, body);

        if (IS_FUNCTION(val)) {
            // If <body> is a nameless function, set its name to <name>
            // (we won't do any renaming...)
            function_t *func = AS_FUNCTION(val);
            if (func->name == NULL) {
                func->name = sym;
            }
        }
        variable_add(vm, env, sym, val);

        return VOID_VAL;
    } else if (IS_CONS(rest->car)) {  // (define (<name> <params...>) <body...>)
        symbol_t *sym = AS_SYMBOL(AS_CONS(rest->car)->car);
        value_t params = AS_CONS(rest->car)->cdr;
        cons_t *body = AS_CONS(rest->cdr);

        function_t *func = function_new(vm, env, params, PTR_VAL(body));
        func->name = sym;

        variable_add(vm, env, sym, PTR_VAL(func));

        return VOID_VAL;
    } else {
        error_runtime(vm, "define: is wrong - first argument has to be"
                          "either a list or a symbol!");
        return NIL_VAL;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movabsq $0x7ffc000000000005, %rbx # imm = 0x7FFC000000000005
movabsq $0x3ffffffffffff, %r12  # imm = 0x3FFFFFFFFFFFF
andq %r12, %rdx
movq 0x10(%rdx), %r13
movq %r13, %rax
shrq $0x32, %rax
cmpl $0x3fff, %eax           # imm = 0x3FFF
jb 0x2550
movq %rsi, %r15
movabsq $-0x4000000000001, %rbp # imm = 0xFFFBFFFFFFFFFFFF
andq %r12, %r13
movl (%r13), %eax
testl %eax, %eax
je 0x2567
cmpl $0x2, %eax
jne 0x2550
movq 0x18(%rdx), %rax
andq %r12, %rax
movq 0x10(%rax), %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x5627
cmpq %rbp, %rax
jbe 0x2542
movq %rax, %rcx
andq %r12, %rcx
cmpl $0x4, (%rcx)
jne 0x2542
cmpq $0x0, 0x10(%rcx)
jne 0x2542
movq %r13, 0x10(%rcx)
movq %r14, %rdi
movq %r15, %rsi
movq %r13, %rdx
movq %rax, %rcx
jmp 0x259a
leaq 0x3e04(%rip), %rsi      # 0x635b
movq %r14, %rdi
xorl %eax, %eax
callq 0x4cc4
addq $-0x4, %rbx
jmp 0x259f
andq 0x10(%r13), %r12
movq 0x18(%r13), %rax
incq %rbp
movq 0x18(%rdx), %rcx
orq %rbp, %rcx
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x488b
movq %r12, 0x10(%rax)
orq %rax, %rbp
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rbp, %rcx
callq 0x518d
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jiribenes[P]scheme/src/core.c
// Function: lambda
static value_t lambda(vm_t *vm, env_t *env, value_t args) {
    // (lambda (<params...>) <body...>)

    if (IS_NIL(AS_CONS(args)->car)) {
        // no parameters -> (lambda () <body...>)
        value_t body = AS_CONS(args)->cdr;
        function_t *func = function_new(vm, env, NIL_VAL, body);
        return PTR_VAL(func);
    }

    if (IS_SYMBOL(AS_CONS(args)->car)) {
        // variadic -> (lambda param <body...>)
        value_t param = AS_CONS(args)->car;
        value_t body = AS_CONS(args)->cdr;
        function_t *func = function_new(vm, env, param, body);
        return PTR_VAL(func);
    }

    // TODO: Rewrite using SCM_FOREACH macro
    for (cons_t *cons = AS_CONS(AS_CONS(args)->car);;
         cons = AS_CONS(cons->cdr)) {
        if (!IS_CONS(cons->cdr) && !IS_NIL(cons->cdr) && IS_SYMBOL(cons->cdr)) {
            // variadic (lambda (a b . rest) <body...>)
            break;
        }

        if (!IS_SYMBOL(cons->car)) {
            error_runtime(vm, "lambda: all parameters must be symbols!");
            return NIL_VAL;
        }


        if (IS_NIL(cons->cdr)) {
            break;
        }
    }

    value_t params = AS_CONS(args)->car;
    value_t body = AS_CONS(args)->cdr;
    function_t *func = function_new(vm, env, params, body);
    return PTR_VAL(func);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movabsq $-0x4000000000001, %r14 # imm = 0xFFFBFFFFFFFFFFFF
movabsq $0x7ffc000000000001, %rbx # imm = 0x7FFC000000000001
movabsq $0x3ffffffffffff, %rcx  # imm = 0x3FFFFFFFFFFFF
andq %rcx, %rdx
movq 0x10(%rdx), %rax
cmpq %rbx, %rax
jne 0x25e8
movq 0x18(%rdx), %rcx
movq %rbx, %rdx
jmp 0x2638
movq %rax, %r8
cmpq %r14, %rax
jbe 0x25ff
movq %rax, %r8
andq %rcx, %r8
cmpl $0x2, (%r8)
movq %rax, %r8
je 0x2631
movq %r8, %r9
andq %rcx, %r9
movq 0x18(%r9), %r8
cmpq %r14, %r8
jbe 0x261a
movq %r8, %r10
andq %rcx, %r10
cmpl $0x2, (%r10)
je 0x2631
movq 0x10(%r9), %r9
cmpq %r14, %r9
jbe 0x2648
andq %rcx, %r9
cmpl $0x2, (%r9)
jne 0x2648
cmpq %rbx, %r8
jne 0x25ff
movq 0x18(%rdx), %rcx
movq %rax, %rdx
callq 0x488b
incq %r14
orq %rax, %r14
movq %r14, %rbx
jmp 0x2656
leaq 0x3d52(%rip), %rsi      # 0x63a1
xorl %eax, %eax
callq 0x4cc4
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/jiribenes[P]scheme/src/core.c
// Function: builtin_if
static value_t builtin_if(vm_t *vm, env_t *env, value_t args) {
    arity_check(vm, "if", args, 2, true);

    // First evaluate <condition>
    value_t condition = eval(vm, env, AS_CONS(args)->car);

    // if it's true, return <then>
    if (AS_BOOL(condition)) {
        value_t then = AS_CONS(AS_CONS(args)->cdr)->car;
        return eval(vm, env, then);
    }

    // If missing <otherwise> and <condition> is false, return false
    if (IS_NIL(AS_CONS(AS_CONS(args)->cdr)->cdr)) {
        return FALSE_VAL;
    }

    // Else do <otherwise>
    value_t otherwise = AS_CONS(AS_CONS(args)->cdr)->cdr;
    return begin(vm, env, otherwise);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, %rdi
callq 0x4a8d
cmpl $0x1, %eax
jg 0x26a0
leaq 0x39ed(%rip), %rsi      # 0x6074
leaq 0x3ada(%rip), %rdx      # 0x6168
movq %r14, %rdi
movl $0x2, %ecx
movl %eax, %r8d
xorl %eax, %eax
callq 0x4cc4
movabsq $0x7ffc000000000001, %r12 # imm = 0x7FFC000000000001
movabsq $0x3ffffffffffff, %r13  # imm = 0x3FFFFFFFFFFFF
andq %r13, %r15
movq 0x10(%r15), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5627
andq $-0x3, %rax
andq 0x18(%r15), %r13
cmpq %r12, %rax
jne 0x26ed
movq 0x18(%r13), %rdx
cmpq %r12, %rdx
jne 0x2705
addq $0x2, %r12
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x10(%r13), %rdx
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x5627
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x583d
// File: /workspace/github_c_makefile_star2_O3/jiribenes[P]scheme/src/core.c
// Function: builtin_set
static value_t builtin_set(vm_t *vm, env_t *env, value_t args) {
    // (set! <sym> <expr>)
    arity_check(vm, "set!", args, 2, false);
    value_t arg = AS_CONS(args)->car;
    if (!IS_SYMBOL(arg)) {
        error_runtime(vm, "set!: first argument must be a symbol!");
        return NIL_VAL;
    }

    symbol_t *sym = AS_SYMBOL(arg);

    arg = AS_CONS(AS_CONS(args)->cdr)->car;
    value_t val = eval(vm, env, arg);
    value_t result = find_replace(env, sym, val);

    if (IS_UNDEFINED(result)) {
        error_runtime(vm, "set!: assignment not allowed - %s is undefined!",
                      sym->name);
    }

    return VOID_VAL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
movq %rdx, %rdi
callq 0x4a8d
cmpl $0x2, %eax
je 0x2758
leaq 0x3909(%rip), %rsi      # 0x6048
leaq 0x3ab1(%rip), %rdx      # 0x61f7
movq %rbx, %rdi
movl $0x2, %ecx
movl %eax, %r8d
xorl %eax, %eax
callq 0x4cc4
movabsq $0x7ffc000000000005, %r14 # imm = 0x7FFC000000000005
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq %rax, %r12
movq 0x10(%r12), %r13
movq %r13, %rcx
shrq $0x32, %rcx
cmpl $0x3fff, %ecx           # imm = 0x3FFF
jb 0x27d2
andq %rax, %r13
cmpl $0x2, (%r13)
jne 0x27d2
andq 0x18(%r12), %rax
movq 0x10(%rax), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5627
movq %r15, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x55ae
leaq -0x1(%r14), %rcx
cmpq %rcx, %rax
jne 0x27e7
addq $0x20, %r13
leaq 0x3c2d(%rip), %rsi      # 0x63f0
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x4cc4
jmp 0x27e7
leaq 0x3bf0(%rip), %rsi      # 0x63c9
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4cc4
addq $-0x4, %r14
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/jiribenes[P]scheme/src/core.c
// Function: builtin_write
static value_t builtin_write(vm_t *vm, env_t *env, value_t args) {
    value_t eargs = eval_list(vm, env, args);
    arity_check(vm, "write", eargs, 1, false);
    write(stdout, AS_CONS(eargs)->car);
    return VOID_VAL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x5457
movq %rax, %rbx
movq %rax, %rdi
callq 0x4a8d
cmpl $0x1, %eax
je 0x2a38
leaq 0x3629(%rip), %rsi      # 0x6048
leaq 0x3749(%rip), %rdx      # 0x616f
movq %r14, %rdi
movl $0x1, %ecx
movl %eax, %r8d
xorl %eax, %eax
callq 0x4cc4
movq 0x7591(%rip), %rax      # 0x9fd0
movq (%rax), %rdi
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq %rax, %rbx
movq 0x10(%rbx), %rsi
callq 0x59fc
movabsq $0x7ffc000000000005, %rax # imm = 0x7FFC000000000005
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/jiribenes[P]scheme/src/core.c
// Function: builtin_display
static value_t builtin_display(vm_t *vm, env_t *env, value_t args) {
    value_t eargs = eval_list(vm, env, args);
    arity_check(vm, "display", eargs, 1, false);
    display(stdout, AS_CONS(eargs)->car);
    return VOID_VAL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x5457
movq %rax, %rbx
movq %rax, %rdi
callq 0x4a8d
cmpl $0x1, %eax
je 0x2aa6
leaq 0x35bb(%rip), %rsi      # 0x6048
leaq 0x36e1(%rip), %rdx      # 0x6175
movq %r14, %rdi
movl $0x1, %ecx
movl %eax, %r8d
xorl %eax, %eax
callq 0x4cc4
movq 0x7523(%rip), %rax      # 0x9fd0
movq (%rax), %rdi
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq %rax, %rbx
movq 0x10(%rbx), %rsi
callq 0x5e3b
movabsq $0x7ffc000000000005, %rax # imm = 0x7FFC000000000005
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/jiribenes[P]scheme/src/core.c
// Function: builtin_read
static value_t builtin_read(vm_t *vm, env_t *env, value_t args) {
    arity_check(vm, "read", args, 0, false);
    char line[1024];
    if (!fgets(line, 1024, stdin)) {
        return EOF_VAL;
    }
    return read_source(vm, line);
}

// Assembly:
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
movq %rdi, %rbx
movq %rdx, %rdi
callq 0x4a8d
testl %eax, %eax
je 0x2b59
leaq 0x3505(%rip), %rsi      # 0x6048
leaq 0x363b(%rip), %rdx      # 0x6185
movq %rbx, %rdi
xorl %ecx, %ecx
movl %eax, %r8d
xorl %eax, %eax
callq 0x4cc4
movq 0x7478(%rip), %rax      # 0x9fd8
movq (%rax), %rdx
movq %rsp, %rdi
movl $0x400, %esi            # imm = 0x400
callq 0x1110
testq %rax, %rax
je 0x2b82
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3848
jmp 0x2b8c
movabsq $0x7ffc000000000006, %rax # imm = 0x7FFC000000000006
addq $0x400, %rsp            # imm = 0x400
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/jiribenes[P]scheme/src/core.c
// Function: builtin_load
static value_t builtin_load(vm_t *vm, env_t *env, value_t args) {
    value_t eargs = eval_list(vm, env, args);
    arity_check(vm, "load", eargs, 1, false);
    value_t arg = AS_CONS(eargs)->car;
    if (!IS_STRING(arg)) {
        error_runtime(vm, "load: argument must be a string!");
        return UNDEFINED_VAL;
    }
    string_t *str = AS_STRING(arg);
    vm->config.load_fn(vm, env, str->value);
    return VOID_VAL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x5457
movq %rax, %r12
movq %rax, %rdi
callq 0x4a8d
cmpl $0x1, %eax
je 0x2bd8
leaq 0x3489(%rip), %rsi      # 0x6048
leaq 0x35c4(%rip), %rdx      # 0x618a
movq %rbx, %rdi
movl $0x1, %ecx
movl %eax, %r8d
xorl %eax, %eax
callq 0x4cc4
movabsq $0x7ffc000000000004, %r15 # imm = 0x7FFC000000000004
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq %rax, %r12
movq 0x10(%r12), %rdx
movq %rdx, %rcx
shrq $0x32, %rcx
cmpl $0x3fff, %ecx           # imm = 0x3FFF
jb 0x2c1d
andq %rax, %rdx
cmpl $0x1, (%rdx)
jne 0x2c1d
addq $0x18, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq *0x30(%rbx)
incq %r15
jmp 0x2c2e
leaq 0x3888(%rip), %rsi      # 0x64ac
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4cc4
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/jiribenes[P]scheme/src/core.c
// Function: builtin_or
static value_t builtin_or(vm_t *vm, env_t *env, value_t args) {
    if (IS_NIL(args)) {
        return FALSE_VAL;
    }
    value_t arg, iter;
    SCM_FOREACH (arg, AS_CONS(args), iter) {
        value_t earg = eval(vm, env, arg);
        if (!IS_BOOL(earg)) {
            error_runtime(vm, "or: argument is not a bool!");
            return UNDEFINED_VAL;
        }

        if (IS_TRUE(earg)) {
            return TRUE_VAL;
        }
    }
    return FALSE_VAL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movabsq $0x7ffc000000000002, %r13 # imm = 0x7FFC000000000002
leaq -0x1(%r13), %rbp
leaq 0x1(%r13), %rax
cmpq %rbp, %rdx
je 0x2cc0
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq %rax, (%rsp)
movabsq $0x3ffffffffffff, %rbx  # imm = 0x3FFFFFFFFFFFF
andq %rbx, %r15
movq 0x10(%r15), %rdx
movq %r14, %rdi
movq %r12, %rsi
callq 0x5627
movq %rax, %rcx
andq $-0x2, %rcx
cmpq %r13, %rcx
jne 0x2ca8
cmpq %r13, %rax
je 0x2cbd
movq 0x18(%r15), %r15
cmpq %rbp, %r15
jne 0x2c76
movq (%rsp), %rax
jmp 0x2cc0
leaq 0x381e(%rip), %rsi      # 0x64cd
movq %r14, %rdi
xorl %eax, %eax
callq 0x4cc4
addq $0x2, %r13
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jiribenes[P]scheme/src/core.c
// Function: builtin_and
static value_t builtin_and(vm_t *vm, env_t *env, value_t args) {
    if (IS_NIL(args)) {
        return TRUE_VAL;
    }
    value_t arg, iter;
    SCM_FOREACH (arg, AS_CONS(args), iter) {
        value_t earg = eval(vm, env, arg);
        if (!IS_BOOL(earg)) {
            error_runtime(vm, "and: argument is not a bool!");
            return UNDEFINED_VAL;
        }

        if (IS_FALSE(earg)) {
            return FALSE_VAL;
        }
    }
    return TRUE_VAL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movabsq $0x7ffc000000000002, %rbx # imm = 0x7FFC000000000002
leaq -0x1(%rbx), %r13
cmpq %r13, %rdx
je 0x2d4c
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
leaq 0x1(%rbx), %rbp
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq %rax, %r15
movq 0x10(%r15), %rdx
movq %r14, %rdi
movq %r12, %rsi
callq 0x5627
movq %rax, %rcx
andq $-0x2, %rcx
cmpq %rbx, %rcx
jne 0x2d32
cmpq %rbp, %rax
je 0x2d49
movq 0x18(%r15), %r15
cmpq %r13, %r15
jne 0x2cfa
jmp 0x2d4c
leaq 0x37b0(%rip), %rsi      # 0x64e9
movq %r14, %rdi
xorl %eax, %eax
callq 0x4cc4
addq $0x2, %rbx
jmp 0x2d4c
movq %rbp, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jiribenes[P]scheme/src/core.c
// Function: define_macro
static value_t define_macro(vm_t *vm, env_t *env, value_t args) {
    // (define-macro (<name> <params...>) <body...>)
    cons_t *rest = AS_CONS(args);
    if (!IS_CONS(rest->car)) {
        error_runtime(vm, "define-macro: first argument has to be a list!");
        return NIL_VAL;
    }

    symbol_t *sym = AS_SYMBOL(AS_CONS(rest->car)->car);
    value_t params = AS_CONS(rest->car)->cdr;
    cons_t *body = AS_CONS(rest->cdr);

    function_t *macro = macro_new(vm, env, params, PTR_VAL(body));
    macro->name = sym;

    variable_add(vm, env, sym, PTR_VAL(macro));

    return VOID_VAL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r14
movabsq $-0x4000000000000, %r12 # imm = 0xFFFC000000000000
movabsq $0x7ffc000000000001, %rbx # imm = 0x7FFC000000000001
movabsq $0x3ffffffffffff, %r13  # imm = 0x3FFFFFFFFFFFF
andq %r13, %rdx
movq 0x10(%rdx), %rax
leaq -0x1(%r12), %rcx
cmpq %rcx, %rax
jbe 0x2da1
andq %r13, %rax
cmpl $0x0, (%rax)
je 0x2dbf
leaq 0x375e(%rip), %rsi      # 0x6506
movq %r14, %rdi
xorl %eax, %eax
callq 0x4cc4
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rsi, %r15
andq 0x10(%rax), %r13
movq 0x18(%rax), %rax
movq 0x18(%rdx), %rcx
orq %r12, %rcx
movq %r14, %rdi
movq %rax, %rdx
callq 0x48e3
movq %r13, 0x10(%rax)
orq %rax, %r12
movq %r14, %rdi
movq %r15, %rsi
movq %r13, %rdx
movq %r12, %rcx
callq 0x518d
addq $0x4, %rbx
jmp 0x2db2
// File: /workspace/github_c_makefile_star2_O3/jiribenes[P]scheme/src/core.c
// Function: builtin_eval
static value_t builtin_eval(vm_t *vm, env_t *env, value_t args) {
    value_t eargs = eval_list(vm, env, args);
    arity_check(vm, "eval", eargs, 1, true);
    value_t first = AS_CONS(eargs)->car;
    if (cons_len(eargs) == 2) {
        value_t second = AS_CONS(AS_CONS(eargs)->cdr)->car;
        return eval(vm, (env_t *) AS_PTR(second), first);
    } else {
        return eval(vm, env, first);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x5457
movq %rax, %r15
movq %rax, %r12
movq %rax, %rdi
callq 0x4a8d
testl %eax, %eax
jg 0x2e42
leaq 0x324b(%rip), %rsi      # 0x6074
leaq 0x336c(%rip), %rdx      # 0x619c
movq %rbx, %rdi
movl $0x1, %ecx
movl %eax, %r8d
xorl %eax, %eax
callq 0x4cc4
movabsq $0x3ffffffffffff, %rbp  # imm = 0x3FFFFFFFFFFFF
andq %rbp, %r15
movq 0x10(%r15), %r13
movq %r12, %rdi
callq 0x4a8d
cmpl $0x2, %eax
jne 0x2e6e
movq 0x18(%r15), %rax
andq %rbp, %rax
andq 0x10(%rax), %rbp
movq %rbp, %r14
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5627
// File: /workspace/github_c_makefile_star2_O3/jiribenes[P]scheme/src/core.c
// Function: builtin_apply
static value_t builtin_apply(vm_t *vm, env_t *env, value_t args) {
    arity_check(vm, "apply", args, 2, false);
    value_t eargs = eval_list(vm, env, args);
    value_t fn = AS_CONS(eargs)->car;
    value_t fn_args = AS_CONS(AS_CONS(eargs)->cdr)->car;
    return apply(vm, env, fn, fn_args);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, %rdi
callq 0x4a8d
cmpl $0x2, %eax
je 0x2ec5
leaq 0x319c(%rip), %rsi      # 0x6048
leaq 0x32ee(%rip), %rdx      # 0x61a1
movq %r14, %rdi
movl $0x2, %ecx
movl %eax, %r8d
xorl %eax, %eax
callq 0x4cc4
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x5457
movabsq $0x3ffffffffffff, %rcx  # imm = 0x3FFFFFFFFFFFF
andq %rcx, %rax
movq 0x10(%rax), %rdx
andq 0x18(%rax), %rcx
movq 0x10(%rcx), %rcx
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x5319
// File: /workspace/github_c_makefile_star2_O3/jiribenes[P]scheme/src/core.c
// Function: builtin_gensym
static value_t builtin_gensym(vm_t *vm, env_t *env, value_t args) {
    arity_check(vm, "gensym", args, 0, false);
    char buffer[16];
    snprintf(buffer, sizeof(buffer), "g%u", vm->gensym_count++);
    return PTR_VAL(symbol_new(vm, buffer, 16));
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rdx, %rdi
callq 0x4a8d
testl %eax, %eax
je 0x2f8b
leaq 0x30d3(%rip), %rsi      # 0x6048
leaq 0x3232(%rip), %rdx      # 0x61ae
movq %rbx, %rdi
xorl %ecx, %ecx
movl %eax, %r8d
xorl %eax, %eax
callq 0x4cc4
movl 0x70(%rbx), %ecx
leal 0x1(%rcx), %eax
movl %eax, 0x70(%rbx)
leaq 0x359a(%rip), %rdx      # 0x6535
movq %rsp, %r14
movl $0x10, %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x10c0
movl $0x10, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x47ba
movabsq $-0x4000000000000, %rcx # imm = 0xFFFC000000000000
orq %rcx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/jiribenes[P]scheme/src/core.c
// Function: builtin_cons
static value_t builtin_cons(vm_t *vm, env_t *env, value_t args) {
    arity_check(vm, "cons", args, 2, false);

    value_t car = eval(vm, env, AS_CONS(args)->car);
    value_t cdr = eval(vm, env, AS_CONS(AS_CONS(args)->cdr)->car);

    value_t cons = cons_fn(vm, car, cdr);
    return cons;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, %rdi
callq 0x4a8d
cmpl $0x2, %eax
je 0x3061
leaq 0x3000(%rip), %rsi      # 0x6048
leaq 0x316c(%rip), %rdx      # 0x61bb
movq %rbx, %rdi
movl $0x2, %ecx
movl %eax, %r8d
xorl %eax, %eax
callq 0x4cc4
movabsq $0x3ffffffffffff, %r13  # imm = 0x3FFFFFFFFFFFF
andq %r13, %r15
movq 0x10(%r15), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5627
movq %rax, %r12
andq 0x18(%r15), %r13
movq 0x10(%r13), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5627
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x4a42
// File: /workspace/github_c_makefile_star2_O3/jiribenes[P]scheme/src/core.c
// Function: builtin_car
static value_t builtin_car(vm_t *vm, env_t *env, value_t args) {
    value_t eargs = eval_list(vm, env, args);
    arity_check(vm, "car", eargs, 1, false);
    value_t a = AS_CONS(eargs)->car;
    if (!IS_CONS(a)) {
        error_runtime(vm, "car: argument is not a cons cell!");
    }
    return AS_CONS(a)->car;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x5457
movq %rax, %r14
movq %rax, %rdi
callq 0x4a8d
cmpl $0x1, %eax
je 0x30e6
leaq 0x2f7b(%rip), %rsi      # 0x6048
leaq 0x30ec(%rip), %rdx      # 0x61c0
movq %rbx, %rdi
movl $0x1, %ecx
movl %eax, %r8d
xorl %eax, %eax
callq 0x4cc4
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq %rax, %r14
movq 0x10(%r14), %r14
movq %r14, %rcx
shrq $0x32, %rcx
andq %rax, %r14
cmpl $0x3fff, %ecx           # imm = 0x3FFF
jb 0x310f
cmpl $0x0, (%r14)
je 0x3120
leaq 0x3423(%rip), %rsi      # 0x6539
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4cc4
movq 0x10(%r14), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/jiribenes[P]scheme/src/core.c
// Function: builtin_cdr
static value_t builtin_cdr(vm_t *vm, env_t *env, value_t args) {
    value_t eargs = eval_list(vm, env, args);
    arity_check(vm, "cdr", eargs, 1, false);
    value_t a = AS_CONS(eargs)->car;
    if (!IS_CONS(a)) {
        error_runtime(vm, "cdr: argument is not a cons cell!");
    }
    return AS_CONS(a)->cdr;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x5457
movq %rax, %r14
movq %rax, %rdi
callq 0x4a8d
cmpl $0x1, %eax
je 0x3168
leaq 0x2ef9(%rip), %rsi      # 0x6048
leaq 0x306e(%rip), %rdx      # 0x61c4
movq %rbx, %rdi
movl $0x1, %ecx
movl %eax, %r8d
xorl %eax, %eax
callq 0x4cc4
movabsq $0x3ffffffffffff, %rax  # imm = 0x3FFFFFFFFFFFF
andq %rax, %r14
movq 0x10(%r14), %r14
movq %r14, %rcx
shrq $0x32, %rcx
andq %rax, %r14
cmpl $0x3fff, %ecx           # imm = 0x3FFF
jb 0x3191
cmpl $0x0, (%r14)
je 0x31a2
leaq 0x33c3(%rip), %rsi      # 0x655b
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4cc4
movq 0x18(%r14), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/jiribenes[P]scheme/src/core.c
// Function: builtin_vec_length
static value_t builtin_vec_length(vm_t *vm, env_t *env, value_t args) {
    // (vector-length <vec>)
    value_t eargs = eval_list(vm, env, args);
    arity_check(vm, "vector-length", eargs, 1, false);
    value_t arg = AS_CONS(eargs)->car;
    if (!IS_VECTOR(arg)) {
        error_runtime(vm, "vector-length: argument must be a vector");
        return UNDEFINED_VAL;
    }
    return NUM_VAL(AS_VECTOR(arg)->count);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x5457
movq %rax, %r14
movq %rax, %rdi
callq 0x4a8d
cmpl $0x1, %eax
je 0x324d
leaq 0x2e14(%rip), %rsi      # 0x6048
leaq 0x2f9c(%rip), %rdx      # 0x61d7
movq %rbx, %rdi
movl $0x1, %ecx
movl %eax, %r8d
xorl %eax, %eax
callq 0x4cc4
movabsq $0x3ffffffffffff, %rcx  # imm = 0x3FFFFFFFFFFFF
andq %rcx, %r14
movq 0x10(%r14), %rax
movq %rax, %rdx
shrq $0x32, %rdx
cmpl $0x3fff, %edx           # imm = 0x3FFF
jb 0x3284
andq %rcx, %rax
cmpl $0x6, (%rax)
jne 0x3284
movl 0x14(%rax), %eax
cvtsi2sd %rax, %xmm0
movq %xmm0, %rax
jmp 0x329f
leaq 0x32f2(%rip), %rsi      # 0x657d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4cc4
movabsq $0x7ffc000000000004, %rax # imm = 0x7FFC000000000004
addq $0x8, %rsp
popq %rbx
popq %r14
retq