LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/generator.c
// Function: EmitMulToMemory
static void EmitMulToMemory(struct Node *op, int dst, int src, int size) {
  if (size == 4) {
    // rdx:rax <- rax * r/m
    printf("xor rdx, rdx\n");
    printf("mov rax, %s\n", reg_names_64[dst]);
    printf("mov eax, [rax]\n");
    printf("imul %s\n", reg_names_64[src]);
    printf("mov [%s], eax\n", reg_names_64[dst]);
    return;
  }
  ErrorWithToken(op, "Assigning %d bytes is not implemented.", size);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x4, %ecx
jne 0x6c0c
movl %edx, %ebx
movl %esi, %ebp
leaq 0x560d(%rip), %rdi      # 0xc1bb
callq 0x2060
movslq %ebp, %r14
leaq 0xa543(%rip), %r15      # 0x11100
movq (%r15,%r14,8), %rsi
leaq 0x5165(%rip), %rdi      # 0xbd2d
xorl %eax, %eax
callq 0x2090
leaq 0x55d6(%rip), %rdi      # 0xc1ac
callq 0x2060
movslq %ebx, %rax
movq (%r15,%rax,8), %rsi
leaq 0x5151(%rip), %rdi      # 0xbd3a
xorl %eax, %eax
callq 0x2090
movq (%r15,%r14,8), %rsi
leaq 0x5453(%rip), %rdi      # 0xc04e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2090
leaq 0x4dda(%rip), %rsi      # 0xb9ed
movl %ecx, %edx
xorl %eax, %eax
callq 0x470c
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/generator.c
// Function: EmitDivToMemory
static void EmitDivToMemory(struct Node *op, int dst, int src, int size) {
  if (size == 4) {
    // rax <- rdx:rax / r/m
    printf("xor rdx, rdx\n");
    printf("mov eax, [%s]\n", reg_names_64[dst]);
    printf("idiv %s\n", reg_names_64[src]);
    printf("mov [%s], eax\n", reg_names_64[dst]);
    return;
  }
  ErrorWithToken(op, "Assigning %d bytes is not implemented.", size);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x4, %ecx
jne 0x6c85
movl %edx, %ebx
movl %esi, %ebp
leaq 0x5588(%rip), %rdi      # 0xc1bb
callq 0x2060
movslq %ebp, %r14
leaq 0xa4be(%rip), %r15      # 0x11100
movq (%r15,%r14,8), %rsi
leaq 0x5410(%rip), %rdi      # 0xc05d
xorl %eax, %eax
callq 0x2090
movslq %ebx, %rax
movq (%r15,%rax,8), %rsi
leaq 0x50e1(%rip), %rdi      # 0xbd43
xorl %eax, %eax
callq 0x2090
movq (%r15,%r14,8), %rsi
leaq 0x53da(%rip), %rdi      # 0xc04e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2090
leaq 0x4d61(%rip), %rsi      # 0xb9ed
movl %ecx, %edx
xorl %eax, %eax
callq 0x470c
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/generator.c
// Function: EmitModToMemory
static void EmitModToMemory(struct Node *op, int dst, int src, int size) {
  if (size == 4) {
    // rdx <- rdx:rax % r/m
    printf("xor rdx, rdx\n");
    printf("mov eax, [%s]\n", reg_names_64[dst]);
    printf("idiv %s\n", reg_names_64[src]);
    printf("mov [%s], edx\n", reg_names_64[dst]);
    return;
  }
  ErrorWithToken(op, "Assigning %d bytes is not implemented.", size);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x4, %ecx
jne 0x6cfe
movl %edx, %ebx
movl %esi, %ebp
leaq 0x550f(%rip), %rdi      # 0xc1bb
callq 0x2060
movslq %ebp, %r14
leaq 0xa445(%rip), %r15      # 0x11100
movq (%r15,%r14,8), %rsi
leaq 0x5397(%rip), %rdi      # 0xc05d
xorl %eax, %eax
callq 0x2090
movslq %ebx, %rax
movq (%r15,%rax,8), %rsi
leaq 0x5068(%rip), %rdi      # 0xbd43
xorl %eax, %eax
callq 0x2090
movq (%r15,%r14,8), %rsi
leaq 0x537f(%rip), %rdi      # 0xc06c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2090
leaq 0x4ce8(%rip), %rsi      # 0xb9ed
movl %ecx, %edx
xorl %eax, %eax
callq 0x470c
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/generator.c
// Function: EmitLShiftMemory
static void EmitLShiftMemory(struct Node *op, int dst, int src, int size) {
  if (size == 4) {
    printf("mov ecx, %s\n", reg_names_32[src]);
    printf("shl dword ptr [%s], cl\n", reg_names_64[dst]);
    return;
  }
  ErrorWithToken(op, "Assigning %d bytes is not implemented.", size);
}

// Assembly:
pushq %rbx
cmpl $0x4, %ecx
jne 0x6d4f
movl %esi, %ebx
movslq %edx, %rax
leaq 0xa440(%rip), %rcx      # 0x11160
movq (%rcx,%rax,8), %rsi
leaq 0x5350(%rip), %rdi      # 0xc07b
xorl %eax, %eax
callq 0x2090
movslq %ebx, %rax
leaq 0xa3c4(%rip), %rcx      # 0x11100
movq (%rcx,%rax,8), %rsi
leaq 0x5341(%rip), %rdi      # 0xc088
xorl %eax, %eax
popq %rbx
jmp 0x2090
leaq 0x4c97(%rip), %rsi      # 0xb9ed
movl %ecx, %edx
xorl %eax, %eax
callq 0x470c
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/generator.c
// Function: EmitRShiftMemory
static void EmitRShiftMemory(struct Node *op, int dst, int src, int size) {
  if (size == 4) {
    printf("mov ecx, %s\n", reg_names_32[src]);
    printf("shr dword ptr [%s], cl\n", reg_names_64[dst]);
    return;
  }
  ErrorWithToken(op, "Assigning %d bytes is not implemented.", size);
}

// Assembly:
pushq %rbx
cmpl $0x4, %ecx
jne 0x6da0
movl %esi, %ebx
movslq %edx, %rax
leaq 0xa3ef(%rip), %rcx      # 0x11160
movq (%rcx,%rax,8), %rsi
leaq 0x52ff(%rip), %rdi      # 0xc07b
xorl %eax, %eax
callq 0x2090
movslq %ebx, %rax
leaq 0xa373(%rip), %rcx      # 0x11100
movq (%rcx,%rax,8), %rsi
leaq 0x5308(%rip), %rdi      # 0xc0a0
xorl %eax, %eax
popq %rbx
jmp 0x2090
leaq 0x4c46(%rip), %rsi      # 0xb9ed
movl %ecx, %edx
xorl %eax, %eax
callq 0x470c
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/parser.c
// Function: ParsePrimaryExpr
struct Node *ParsePrimaryExpr() {
  struct Node *t;
  if ((t = ConsumeToken(kTokenIntegerConstant)) ||
      (t = ConsumeToken(kTokenIdent)) ||
      (t = ConsumeToken(kTokenCharLiteral)) ||
      (t = ConsumeToken(kTokenStringLiteral))) {
    struct Node *op = AllocNode(kASTExpr);
    op->op = t;
    return op;
  }
  if ((t = ConsumePunctuator("("))) {
    struct Node *op = AllocNode(kASTExpr);
    op->op = t;
    op->right = ParseExpr();
    if (!op->right) ErrorWithToken(t, "Expected expr after this token");
    ExpectPunctuator(")");
    return op;
  }
  return NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl $0x3, %edi
callq 0x93c9
testq %rax, %rax
jne 0x6e60
movl $0x4, %edi
callq 0x93c9
testq %rax, %rax
jne 0x6e60
movl $0x17, %edi
callq 0x93c9
testq %rax, %rax
jne 0x6e60
movl $0x18, %edi
callq 0x93c9
testq %rax, %rax
je 0x6e7f
movq %rax, %rbx
movl $0x4, %edi
callq 0x3f11
movq %rax, %r14
movq %rbx, 0x10(%rax)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x473e(%rip), %rdi      # 0xb5c4
callq 0x9490
testq %rax, %rax
je 0x6ec0
movq %rax, %rbx
movl $0x4, %edi
callq 0x3f11
movq %rax, %r14
movq %rbx, 0x10(%rax)
callq 0x6ed6
movq %rax, 0x20(%r14)
testq %rax, %rax
je 0x6ec5
leaq 0x59bc(%rip), %rdi      # 0xc875
callq 0x94d4
jmp 0x6e74
xorl %r14d, %r14d
jmp 0x6e74
leaq 0x52fc(%rip), %rsi      # 0xc1c8
movq %rbx, %rdi
xorl %eax, %eax
callq 0x470c
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/parser.c
// Function: ParseExpr
struct Node *ParseExpr() {
  struct Node *op = ParseAssignExpr();
  if (!op) return NULL;
  struct Node *t;
  while ((t = ConsumePunctuator(","))) {
    op = CreateASTBinOp(t, op, ParseAssignExpr());
  }
  return op;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
callq 0x764b
testq %rax, %rax
je 0x6f2b
movq %rax, %rbx
leaq 0x432b(%rip), %rdi      # 0xb21a
callq 0x9490
testq %rax, %rax
je 0x6f2d
movq %rax, %r15
leaq 0x4317(%rip), %r14      # 0xb21a
callq 0x764b
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x3f27
movq %rax, %rbx
movq %r14, %rdi
callq 0x9490
movq %rax, %r15
testq %rax, %rax
jne 0x6f03
jmp 0x6f2d
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/parser.c
// Function: ParsePostfixExpr
struct Node *ParsePostfixExpr() {
  struct Node *n = ParsePrimaryExpr();
  while (n) {
    struct Node *t;
    if (ConsumePunctuator("(")) {
      struct Node *args = AllocList();
      if (!ConsumePunctuator(")")) {
        do {
          struct Node *arg_expr = ParseAssignExpr();
          if (!arg_expr)
            ErrorWithToken(NextToken(), "Expected expression here");
          PushToList(args, arg_expr);
        } while (ConsumePunctuator(","));
        ExpectPunctuator(")");
      }
      struct Node *nn = AllocNode(kASTExprFuncCall);
      nn->func_expr = n;
      nn->arg_expr_list = args;
      n = nn;
      continue;
    }
    if ((t = ConsumePunctuator("["))) {
      n = CreateASTBinOp(t, n, ParseExpr());
      ExpectPunctuator("]");
      continue;
    }
    if ((t = ConsumePunctuator(".")) || (t = ConsumePunctuator("->"))) {
      struct Node *right = ConsumeToken(kTokenIdent);
      assert(right);
      n = CreateASTBinOp(t, n, right);
      continue;
    }
    if ((t = ConsumePunctuator("++"))) {
      n = CreateASTUnaryPostfixOp(n, t);
      continue;
    }
    if ((t = ConsumePunctuator("--"))) {
      n = CreateASTUnaryPostfixOp(n, t);
      continue;
    }
    break;
  }
  return n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x6e20
testq %rax, %rax
je 0x7093
movq %rax, %r13
leaq 0x466b(%rip), %rbx      # 0xb5c4
leaq 0x4639(%rip), %r14      # 0xb599
leaq 0x590e(%rip), %r12      # 0xc875
leaq 0x42ac(%rip), %r15      # 0xb21a
movq %rbx, %rdi
callq 0x9490
testq %rax, %rax
je 0x6fdd
xorl %eax, %eax
callq 0x47d2
movq %rax, %rbp
movq %r12, %rdi
callq 0x9490
testq %rax, %rax
jne 0x6fc0
callq 0x764b
testq %rax, %rax
je 0x70a8
movq %rbp, %rdi
movq %rax, %rsi
callq 0x485a
movq %r15, %rdi
callq 0x9490
testq %rax, %rax
jne 0x6f92
movq %r12, %rdi
callq 0x94d4
movl $0x5, %edi
callq 0x3f11
movq %r13, 0xb0(%rax)
movq %rbp, 0xb8(%rax)
movq %rax, %r13
jmp 0x700f
movq %r14, %rdi
callq 0x9490
testq %rax, %rax
je 0x701a
movq %rax, %rbp
callq 0x6ed6
movq %rbp, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x3f27
movq %rax, %r13
leaq 0x51af(%rip), %rdi      # 0xc1b9
callq 0x94d4
testq %r13, %r13
jne 0x6f6e
jmp 0x7093
leaq 0x4682(%rip), %rdi      # 0xb6a3
callq 0x9490
testq %rax, %rax
jne 0x703c
leaq 0x405b(%rip), %rdi      # 0xb08d
callq 0x9490
testq %rax, %rax
je 0x7061
movq %rax, %rbp
movl $0x4, %edi
callq 0x93c9
testq %rax, %rax
je 0x70be
movq %rbp, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x3f27
jmp 0x6fd8
leaq 0x413f(%rip), %rdi      # 0xb1a7
callq 0x9490
testq %rax, %rax
jne 0x7083
leaq 0x412b(%rip), %rdi      # 0xb1a4
callq 0x9490
testq %rax, %rax
je 0x7096
movq %r13, %rdi
movq %rax, %rsi
callq 0x3fb7
jmp 0x6fd8
xorl %r13d, %r13d
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x9527
leaq 0x5133(%rip), %rsi      # 0xc1e7
movq %rax, %rdi
xorl %eax, %eax
callq 0x470c
leaq 0x513b(%rip), %rdi      # 0xc200
leaq 0x513a(%rip), %rsi      # 0xc206
movl $0x3e, %edx
callq 0x46d0
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/parser.c
// Function: ParseUnaryExpr
struct Node *ParseUnaryExpr() {
  struct Node *t;
  if ((t = ConsumePunctuator("+")) || (t = ConsumePunctuator("-")) ||
      (t = ConsumePunctuator("~")) || (t = ConsumePunctuator("!")) ||
      (t = ConsumePunctuator("&")) || (t = ConsumePunctuator("*"))) {
    return CreateASTUnaryPrefixOp(t, ParseCastExpr());
  } else if ((t = ConsumePunctuator("--")) || (t = ConsumePunctuator("++")) ||
             (t = ConsumeToken(kTokenKwSizeof))) {
    return CreateASTUnaryPrefixOp(t, ParseUnaryExpr());
  }
  return ParsePostfixExpr();
}

// Assembly:
pushq %rbx
leaq 0x40ca(%rip), %rdi      # 0xb1a8
callq 0x9490
testq %rax, %rax
jne 0x7172
leaq 0x40b2(%rip), %rdi      # 0xb1a5
callq 0x9490
testq %rax, %rax
jne 0x7172
leaq 0x4b69(%rip), %rdi      # 0xbc6d
callq 0x9490
testq %rax, %rax
jne 0x7172
leaq 0x4b62(%rip), %rdi      # 0xbc77
callq 0x9490
testq %rax, %rax
jne 0x7172
leaq 0x4bd6(%rip), %rdi      # 0xbcfc
callq 0x9490
testq %rax, %rax
jne 0x7172
leaq 0x4098(%rip), %rdi      # 0xb1cf
callq 0x9490
testq %rax, %rax
jne 0x7172
leaq 0x405c(%rip), %rdi      # 0xb1a4
callq 0x9490
testq %rax, %rax
jne 0x7172
leaq 0x404e(%rip), %rdi      # 0xb1a7
callq 0x9490
testq %rax, %rax
jne 0x7172
movl $0x10, %edi
callq 0x93c9
testq %rax, %rax
je 0x7186
movq %rax, %rbx
callq 0x70d6
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
jmp 0x3f72
popq %rbx
jmp 0x6f36
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/parser.c
// Function: ParseMulExpr
struct Node *ParseMulExpr() {
  struct Node *op = ParseCastExpr();
  if (!op) return NULL;
  struct Node *t;
  while ((t = ConsumePunctuator("*")) || (t = ConsumePunctuator("/")) ||
         (t = ConsumePunctuator("%"))) {
    op = CreateASTBinOp(t, op, ParseCastExpr());
  }
  return op;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
callq 0x70d6
testq %rax, %rax
je 0x71fe
movq %rax, %rbx
leaq 0x4021(%rip), %r14      # 0xb1cf
leaq 0x5191(%rip), %r15      # 0xc346
leaq 0x4b90(%rip), %r12      # 0xbd4c
movq %r14, %rdi
callq 0x9490
testq %rax, %rax
jne 0x71e3
movq %r15, %rdi
callq 0x9490
testq %rax, %rax
jne 0x71e3
movq %r12, %rdi
callq 0x9490
testq %rax, %rax
je 0x7200
movq %rax, %r13
callq 0x70d6
movq %r13, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x3f27
movq %rax, %rbx
jmp 0x71bc
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/parser.c
// Function: ParseAddExpr
struct Node *ParseAddExpr() {
  struct Node *op = ParseMulExpr();
  if (!op) return NULL;
  struct Node *t;
  while ((t = ConsumePunctuator("+")) || (t = ConsumePunctuator("-"))) {
    op = CreateASTBinOp(t, op, ParseMulExpr());
  }
  return op;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
callq 0x7191
testq %rax, %rax
je 0x7265
movq %rax, %rbx
leaq 0x3f7f(%rip), %r14      # 0xb1a8
leaq 0x3f75(%rip), %r15      # 0xb1a5
movq %r14, %rdi
callq 0x9490
testq %rax, %rax
jne 0x724a
movq %r15, %rdi
callq 0x9490
testq %rax, %rax
je 0x7267
movq %rax, %r12
callq 0x7191
movq %r12, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x3f27
movq %rax, %rbx
jmp 0x7230
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/parser.c
// Function: ParseShiftExpr
struct Node *ParseShiftExpr() {
  struct Node *op = ParseAddExpr();
  if (!op) return NULL;
  struct Node *t;
  while ((t = ConsumePunctuator("<<")) || (t = ConsumePunctuator(">>"))) {
    op = CreateASTBinOp(t, op, ParseAddExpr());
  }
  return op;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
callq 0x720d
testq %rax, %rax
je 0x72ce
movq %rax, %rbx
leaq 0x4ac9(%rip), %r14      # 0xbd5b
leaq 0x4ade(%rip), %r15      # 0xbd77
movq %r14, %rdi
callq 0x9490
testq %rax, %rax
jne 0x72b3
movq %r15, %rdi
callq 0x9490
testq %rax, %rax
je 0x72d0
movq %rax, %r12
callq 0x720d
movq %r12, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x3f27
movq %rax, %rbx
jmp 0x7299
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/parser.c
// Function: ParseRelExpr
struct Node *ParseRelExpr() {
  struct Node *op = ParseShiftExpr();
  if (!op) return NULL;
  struct Node *t;
  while ((t = ConsumePunctuator("<")) || (t = ConsumePunctuator(">")) ||
         (t = ConsumePunctuator("<=")) || (t = ConsumePunctuator(">="))) {
    op = CreateASTBinOp(t, op, ParseShiftExpr());
  }
  return op;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x7276
testq %rax, %rax
je 0x7362
movq %rax, %rbx
leaq 0x4a5e(%rip), %r14      # 0xbd5c
leaq 0x3d89(%rip), %r15      # 0xb08e
leaq 0x4a0e(%rip), %r12      # 0xbd1a
leaq 0x4a0b(%rip), %r13      # 0xbd1e
movq %r14, %rdi
callq 0x9490
testq %rax, %rax
jne 0x7347
movq %r15, %rdi
callq 0x9490
testq %rax, %rax
jne 0x7347
movq %r12, %rdi
callq 0x9490
testq %rax, %rax
jne 0x7347
movq %r13, %rdi
callq 0x9490
testq %rax, %rax
je 0x7364
movq %rax, %rbp
callq 0x7276
movq %rbp, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x3f27
movq %rax, %rbx
jmp 0x7313
xorl %ebx, %ebx
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/hikalium[P]compilium/parser.c
// Function: ParseEqExpr
struct Node *ParseEqExpr() {
  struct Node *op = ParseRelExpr();
  if (!op) return NULL;
  struct Node *t;
  while ((t = ConsumePunctuator("==")) || (t = ConsumePunctuator("!="))) {
    op = CreateASTBinOp(t, op, ParseRelExpr());
  }
  return op;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
callq 0x72df
testq %rax, %rax
je 0x73ce
movq %rax, %rbx
leaq 0x49f7(%rip), %r14      # 0xbd89
leaq 0x49f3(%rip), %r15      # 0xbd8c
movq %r14, %rdi
callq 0x9490
testq %rax, %rax
jne 0x73b3
movq %r15, %rdi
callq 0x9490
testq %rax, %rax
je 0x73d0
movq %rax, %r12
callq 0x72df
movq %r12, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x3f27
movq %rax, %rbx
jmp 0x7399
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/parser.c
// Function: ParseAndExpr
struct Node *ParseAndExpr() {
  struct Node *op = ParseEqExpr();
  if (!op) return NULL;
  struct Node *t;
  while ((t = ConsumePunctuator("&"))) {
    op = CreateASTBinOp(t, op, ParseEqExpr());
  }
  return op;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
callq 0x7376
testq %rax, %rax
je 0x7434
movq %rax, %rbx
leaq 0x4904(%rip), %rdi      # 0xbcfc
callq 0x9490
testq %rax, %rax
je 0x7436
movq %rax, %r15
leaq 0x48f0(%rip), %r14      # 0xbcfc
callq 0x7376
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x3f27
movq %rax, %rbx
movq %r14, %rdi
callq 0x9490
movq %rax, %r15
testq %rax, %rax
jne 0x740c
jmp 0x7436
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/parser.c
// Function: ParseXorExpr
struct Node *ParseXorExpr() {
  struct Node *op = ParseAndExpr();
  if (!op) return NULL;
  struct Node *t;
  while ((t = ConsumePunctuator("^"))) {
    op = CreateASTBinOp(t, op, ParseAndExpr());
  }
  return op;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
callq 0x73df
testq %rax, %rax
je 0x7494
movq %rax, %rbx
leaq 0x4943(%rip), %rdi      # 0xbd9b
callq 0x9490
testq %rax, %rax
je 0x7496
movq %rax, %r15
leaq 0x492f(%rip), %r14      # 0xbd9b
callq 0x73df
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x3f27
movq %rax, %rbx
movq %r14, %rdi
callq 0x9490
movq %rax, %r15
testq %rax, %rax
jne 0x746c
jmp 0x7496
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/parser.c
// Function: ParseOrExpr
struct Node *ParseOrExpr() {
  struct Node *op = ParseXorExpr();
  if (!op) return NULL;
  struct Node *t;
  while ((t = ConsumePunctuator("|"))) {
    op = CreateASTBinOp(t, op, ParseXorExpr());
  }
  return op;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
callq 0x743f
testq %rax, %rax
je 0x74f4
movq %rax, %rbx
leaq 0x4847(%rip), %rdi      # 0xbcff
callq 0x9490
testq %rax, %rax
je 0x74f6
movq %rax, %r15
leaq 0x4833(%rip), %r14      # 0xbcff
callq 0x743f
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x3f27
movq %rax, %rbx
movq %r14, %rdi
callq 0x9490
movq %rax, %r15
testq %rax, %rax
jne 0x74cc
jmp 0x74f6
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/parser.c
// Function: ParseBoolAndExpr
struct Node *ParseBoolAndExpr() {
  struct Node *op = ParseOrExpr();
  if (!op) return NULL;
  struct Node *t;
  while ((t = ConsumePunctuator("&&"))) {
    op = CreateASTBinOp(t, op, ParseOrExpr());
  }
  return op;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
callq 0x749f
testq %rax, %rax
je 0x7554
movq %rax, %rbx
leaq 0x47e3(%rip), %rdi      # 0xbcfb
callq 0x9490
testq %rax, %rax
je 0x7556
movq %rax, %r15
leaq 0x47cf(%rip), %r14      # 0xbcfb
callq 0x749f
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x3f27
movq %rax, %rbx
movq %r14, %rdi
callq 0x9490
movq %rax, %r15
testq %rax, %rax
jne 0x752c
jmp 0x7556
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/parser.c
// Function: ParseBoolOrExpr
struct Node *ParseBoolOrExpr() {
  struct Node *op = ParseBoolAndExpr();
  if (!op) return NULL;
  struct Node *t;
  while ((t = ConsumePunctuator("||"))) {
    op = CreateASTBinOp(t, op, ParseBoolAndExpr());
  }
  return op;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
callq 0x74ff
testq %rax, %rax
je 0x75b4
movq %rax, %rbx
leaq 0x4786(%rip), %rdi      # 0xbcfe
callq 0x9490
testq %rax, %rax
je 0x75b6
movq %rax, %r15
leaq 0x4772(%rip), %r14      # 0xbcfe
callq 0x74ff
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x3f27
movq %rax, %rbx
movq %r14, %rdi
callq 0x9490
movq %rax, %r15
testq %rax, %rax
jne 0x758c
jmp 0x75b6
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/parser.c
// Function: ParseConditionalExpr
struct Node *ParseConditionalExpr() {
  struct Node *expr = ParseBoolOrExpr();
  if (!expr) return NULL;
  struct Node *t;
  if ((t = ConsumePunctuator("?"))) {
    struct Node *op = AllocNode(kASTExpr);
    op->op = t;
    op->cond = expr;
    op->left = ParseConditionalExpr();
    if (!op->left)
      ErrorWithToken(t, "Expected true-expr for this conditional expr");
    ExpectPunctuator(":");
    op->right = ParseConditionalExpr();
    if (!op->right)
      ErrorWithToken(t, "Expected false-expr for this conditional expr");
    return op;
  }
  return expr;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
callq 0x755f
testq %rax, %rax
je 0x762e
movq %rax, %r14
leaq 0x4c37(%rip), %rdi      # 0xc20f
callq 0x9490
testq %rax, %rax
je 0x7631
movq %rax, %rbx
movl $0x4, %edi
callq 0x3f11
movq %rax, %r15
movq %rbx, 0x10(%rax)
movq %r14, 0x30(%rax)
callq 0x75bf
movq %rax, 0x18(%r15)
testq %rax, %rax
je 0x763a
leaq 0x4c2f(%rip), %rdi      # 0xc23e
callq 0x94d4
callq 0x75bf
movq %rax, 0x20(%r15)
movq %r15, %r14
testq %rax, %rax
jne 0x7631
leaq 0x4c14(%rip), %rsi      # 0xc240
jmp 0x7641
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x4bd0(%rip), %rsi      # 0xc211
movq %rbx, %rdi
xorl %eax, %eax
callq 0x470c
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/parser.c
// Function: ParseAssignExpr
struct Node *ParseAssignExpr() {
  struct Node *left = ParseConditionalExpr();
  if (!left) return NULL;
  struct Node *t;
  if ((t = ConsumePunctuator("=")) || (t = ConsumePunctuator("+=")) ||
      (t = ConsumePunctuator("-=")) || (t = ConsumePunctuator("*=")) ||
      (t = ConsumePunctuator("/=")) || (t = ConsumePunctuator("%=")) ||
      (t = ConsumePunctuator("<<=")) || (t = ConsumePunctuator(">>="))) {
    struct Node *right = ParseAssignExpr();
    if (!right) ErrorWithToken(t, "Expected expr after this token");
    return CreateASTBinOp(t, left, right);
  }
  return left;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x75bf
testq %rax, %rax
je 0x770a
movq %rax, %rbx
leaq 0x4726(%rip), %rdi      # 0xbd8d
callq 0x9490
testq %rax, %rax
jne 0x76e8
leaq 0x4692(%rip), %rdi      # 0xbd0a
callq 0x9490
testq %rax, %rax
jne 0x76e8
leaq 0x4684(%rip), %rdi      # 0xbd0d
callq 0x9490
testq %rax, %rax
jne 0x76e8
leaq 0x4676(%rip), %rdi      # 0xbd10
callq 0x9490
testq %rax, %rax
jne 0x76e8
leaq 0x4668(%rip), %rdi      # 0xbd13
callq 0x9490
testq %rax, %rax
jne 0x76e8
leaq 0x465a(%rip), %rdi      # 0xbd16
callq 0x9490
testq %rax, %rax
jne 0x76e8
leaq 0x464c(%rip), %rdi      # 0xbd19
callq 0x9490
testq %rax, %rax
jne 0x76e8
leaq 0x463f(%rip), %rdi      # 0xbd1d
callq 0x9490
testq %rax, %rax
je 0x770c
movq %rax, %r14
callq 0x764b
testq %rax, %rax
je 0x7717
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3f27
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x4aaa(%rip), %rsi      # 0xc1c8
movq %r14, %rdi
xorl %eax, %eax
callq 0x470c
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/parser.c
// Function: ParseExprStmt
struct Node *ParseExprStmt() {
  struct Node *expr = ParseExpr();
  struct Node *t;
  if ((t = ConsumePunctuator(";"))) {
    return CreateASTExprStmt(t, expr);
  } else if (expr) {
    ExpectPunctuator(";");
  }
  return NULL;
}

// Assembly:
pushq %rbx
callq 0x6ed6
movq %rax, %rbx
leaq 0x5585(%rip), %rdi      # 0xccbd
callq 0x9490
testq %rax, %rax
je 0x774e
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
jmp 0x4020
testq %rbx, %rbx
je 0x775f
leaq 0x5563(%rip), %rdi      # 0xccbd
callq 0x94d4
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/parser.c
// Function: ParseSelectionStmt
struct Node *ParseSelectionStmt() {
  struct Node *t;
  if ((t = ConsumeToken(kTokenKwIf))) {
    ExpectPunctuator("(");
    struct Node *expr = ParseExpr();
    assert(expr);
    ExpectPunctuator(")");
    struct Node *stmt_true = ParseStmt();
    assert(stmt_true);
    struct Node *stmt = AllocNode(kASTSelectionStmt);
    stmt->op = t;
    stmt->cond = expr;
    stmt->if_true_stmt = stmt_true;
    if (ConsumeToken(kTokenKwElse)) {
      stmt->if_else_stmt = ParseStmt();
    }
    return stmt;
  }
  return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl $0xc, %edi
callq 0x93c9
testq %rax, %rax
je 0x77e2
movq %rax, %rbx
leaq 0x3e40(%rip), %rdi      # 0xb5c4
callq 0x94d4
callq 0x6ed6
testq %rax, %rax
je 0x77f4
movq %rax, %r14
leaq 0x50d8(%rip), %rdi      # 0xc875
callq 0x94d4
callq 0x79f9
testq %rax, %rax
je 0x780c
movq %rax, %r12
movl $0x9, %edi
callq 0x3f11
movq %rax, %r15
movq %rbx, 0x10(%rax)
movq %r14, 0x30(%rax)
movq %r12, 0x48(%rax)
movl $0x9, %edi
callq 0x93c9
testq %rax, %rax
je 0x77e5
callq 0x79f9
movq %rax, 0x50(%r15)
jmp 0x77e5
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x4a6e(%rip), %rdi      # 0xc269
leaq 0x4a04(%rip), %rsi      # 0xc206
movl $0x103, %edx            # imm = 0x103
callq 0x46d0
leaq 0x4a5b(%rip), %rdi      # 0xc26e
leaq 0x49ec(%rip), %rsi      # 0xc206
movl $0x106, %edx            # imm = 0x106
callq 0x46d0
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/parser.c
// Function: ParseJumpStmt
struct Node *ParseJumpStmt() {
  // jump-statement
  struct Node *t;
  if ((t = ConsumeToken(kTokenKwBreak)) ||
      (t = ConsumeToken(kTokenKwContinue))) {
    ExpectPunctuator(";");
    struct Node *stmt = AllocNode(kASTJumpStmt);
    stmt->op = t;
    return stmt;
  }
  if ((t = ConsumeToken(kTokenKwReturn))) {
    struct Node *expr = ParseExpr();
    ExpectPunctuator(";");
    struct Node *stmt = AllocNode(kASTJumpStmt);
    stmt->op = t;
    stmt->right = expr;
    return stmt;
  }
  return NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl $0x5, %edi
callq 0x93c9
testq %rax, %rax
jne 0x7846
movl $0x8, %edi
callq 0x93c9
testq %rax, %rax
je 0x786b
movq %rax, %rbx
leaq 0x546d(%rip), %rdi      # 0xccbd
callq 0x94d4
movl $0x8, %edi
callq 0x3f11
movq %rbx, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0xf, %edi
callq 0x93c9
testq %rax, %rax
je 0x78a5
movq %rax, %rbx
callq 0x6ed6
movq %rax, %r14
leaq 0x5431(%rip), %rdi      # 0xccbd
callq 0x94d4
movl $0x8, %edi
callq 0x3f11
movq %rbx, 0x10(%rax)
movq %r14, 0x20(%rax)
jmp 0x7863
xorl %eax, %eax
jmp 0x7863
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/parser.c
// Function: ParseIterationStmt
struct Node *ParseIterationStmt() {
  struct Node *t;
  if ((t = ConsumeToken(kTokenKwFor))) {
    ExpectPunctuator("(");
    struct Node *init = ParseDeclBody();
    if (!init) init = ParseExpr();
    ExpectPunctuator(";");
    struct Node *cond = ParseExpr();
    ExpectPunctuator(";");
    struct Node *updt = ParseExpr();
    ExpectPunctuator(")");
    struct Node *body = ParseStmt();
    assert(body);

    struct Node *stmt = AllocNode(kASTForStmt);
    stmt->op = t;
    stmt->init = init;
    stmt->cond = cond;
    stmt->updt = updt;
    stmt->body = body;
    return stmt;
  }
  if ((t = ConsumeToken(kTokenKwWhile))) {
    ExpectPunctuator("(");
    struct Node *cond = ParseExpr();
    assert(cond);
    ExpectPunctuator(")");
    struct Node *body = ParseStmt();
    assert(body);

    struct Node *stmt = AllocNode(kASTWhileStmt);
    stmt->op = t;
    stmt->cond = cond;
    stmt->body = body;
    return stmt;
  }
  return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl $0xb, %edi
callq 0x93c9
testq %rax, %rax
je 0x7949
movq %rax, %rbx
leaq 0x3cf5(%rip), %rdi      # 0xb5c4
callq 0x94d4
callq 0x7e68
movq %rax, %r14
testq %rax, %rax
jne 0x78e9
callq 0x6ed6
movq %rax, %r14
leaq 0x53cd(%rip), %r15      # 0xccbd
movq %r15, %rdi
callq 0x94d4
callq 0x6ed6
movq %rax, %r12
movq %r15, %rdi
callq 0x94d4
callq 0x6ed6
movq %rax, %r13
leaq 0x4f5e(%rip), %rdi      # 0xc875
callq 0x94d4
callq 0x79f9
testq %rax, %rax
je 0x79b1
movq %rax, %r15
movl $0xe, %edi
callq 0x3f11
movq %rbx, 0x10(%rax)
movq %r14, 0x28(%rax)
movq %r12, 0x30(%rax)
movq %r13, 0x38(%rax)
jmp 0x799f
movl $0x16, %edi
callq 0x93c9
testq %rax, %rax
je 0x79ad
movq %rax, %rbx
leaq 0x3c62(%rip), %rdi      # 0xb5c4
callq 0x94d4
callq 0x6ed6
testq %rax, %rax
je 0x79c9
movq %rax, %r14
leaq 0x4efa(%rip), %rdi      # 0xc875
callq 0x94d4
callq 0x79f9
testq %rax, %rax
je 0x79e1
movq %rax, %r15
movl $0xf, %edi
callq 0x3f11
movq %rbx, 0x10(%rax)
movq %r14, 0x30(%rax)
movq %r15, 0x40(%rax)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
xorl %eax, %eax
jmp 0x79a3
leaq 0x48c0(%rip), %rdi      # 0xc278
leaq 0x4847(%rip), %rsi      # 0xc206
movl $0x134, %edx            # imm = 0x134
callq 0x46d0
leaq 0x48ad(%rip), %rdi      # 0xc27d
leaq 0x482f(%rip), %rsi      # 0xc206
movl $0x141, %edx            # imm = 0x141
callq 0x46d0
leaq 0x4890(%rip), %rdi      # 0xc278
leaq 0x4817(%rip), %rsi      # 0xc206
movl $0x144, %edx            # imm = 0x144
callq 0x46d0
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/parser.c
// Function: ParseStmt
struct Node *ParseStmt() {
  struct Node *stmt;
  if ((stmt = ParseExprStmt()) || (stmt = ParseJumpStmt()) ||
      (stmt = ParseSelectionStmt()) || (stmt = ParseCompStmt()) ||
      (stmt = ParseIterationStmt()))
    return stmt;
  return NULL;
}

// Assembly:
pushq %rax
callq 0x7728
testq %rax, %rax
jne 0x7a22
callq 0x7824
testq %rax, %rax
jne 0x7a22
callq 0x7763
testq %rax, %rax
jne 0x7a22
callq 0x7ec1
testq %rax, %rax
je 0x7a24
popq %rcx
retq
popq %rax
jmp 0x78a9
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/parser.c
// Function: ParseDecltor
struct Node *ParseDecltor() {
  struct Node *n = AllocNode(kASTDecltor);
  struct Node *pointer = NULL;
  struct Node *t;
  while ((t = ConsumePunctuator("*"))) {
    pointer = CreateTypePointer(pointer);
  }
  n->left = pointer;
  n->right = ParseDirectDecltor();
  return n;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl $0xc, %edi
callq 0x3f11
movq %rax, %rbx
leaq 0x3446(%rip), %rdi      # 0xb1cf
callq 0x9490
xorl %r14d, %r14d
testq %rax, %rax
je 0x7db5
leaq 0x3432(%rip), %r15      # 0xb1cf
movq %r14, %rdi
callq 0x4205
movq %rax, %r14
movq %r15, %rdi
callq 0x9490
testq %rax, %rax
jne 0x7d9d
movq %r14, 0x18(%rbx)
callq 0x7bd6
movq %rax, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/parser.c
// Function: ParseInitDecltor
struct Node *ParseInitDecltor() {
  struct Node *decltor = ParseDecltor();
  if (!decltor) return NULL;
  struct Node *t;
  if (!(t = ConsumePunctuator("="))) return decltor;
  struct Node *init_expr = ParseAssignExpr();
  assert(init_expr);
  decltor->decltor_init_expr = CreateASTBinOp(t, NULL, init_expr);
  return decltor;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x7d70
movq %rax, %rbx
testq %rax, %rax
je 0x7e0b
leaq 0x3faa(%rip), %rdi      # 0xbd8d
callq 0x9490
testq %rax, %rax
je 0x7e0b
movq %rax, %r14
callq 0x764b
testq %rax, %rax
je 0x7e16
movq %r14, %rdi
xorl %esi, %esi
movq %rax, %rdx
callq 0x3f27
movq %rax, 0x58(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x44ad(%rip), %rdi      # 0xc2ca
leaq 0x43e2(%rip), %rsi      # 0xc206
movl $0x1e1, %edx            # imm = 0x1E1
callq 0x46d0
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/parser.c
// Function: ParseParamDecl
struct Node *ParseParamDecl() {
  struct Node *decl_specs = ParseDeclSpecs();
  if (!decl_specs) return NULL;
  struct Node *n = AllocNode(kASTDecl);
  n->op = decl_specs;
  n->right = ParseDecltor();
  return n;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x7a2a
testq %rax, %rax
je 0x7e5b
movq %rax, %r14
movl $0xd, %edi
callq 0x3f11
movq %rax, %rbx
movq %r14, 0x10(%rax)
callq 0x7d70
movq %rax, 0x20(%rbx)
jmp 0x7e5d
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/parser.c
// Function: ParseDeclBody
struct Node *ParseDeclBody() {
  struct Node *decl_specs = ParseDeclSpecs();
  if (!decl_specs) return NULL;
  struct Node *n = AllocNode(kASTDecl);
  n->op = decl_specs;
  n->right = ParseInitDecltor();
  return n;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x7a2a
testq %rax, %rax
je 0x7e95
movq %rax, %r14
movl $0xd, %edi
callq 0x3f11
movq %rax, %rbx
movq %r14, 0x10(%rax)
callq 0x7dcb
movq %rax, 0x20(%rbx)
jmp 0x7e97
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/parser.c
// Function: ParseDecl
struct Node *ParseDecl() {
  struct Node *decl_body = ParseDeclBody();
  if (!decl_body) return NULL;
  ExpectPunctuator(";");
  return decl_body;
}

// Assembly:
pushq %rbx
callq 0x7e68
movq %rax, %rbx
testq %rax, %rax
je 0x7ebc
leaq 0x4e06(%rip), %rdi      # 0xccbd
callq 0x94d4
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/parser.c
// Function: ParseCompStmt
struct Node *ParseCompStmt() {
  struct Node *t;
  if (!(t = ConsumePunctuator("{"))) return NULL;
  struct Node *list = AllocList();
  list->op = t;
  struct Node *stmt;
  while ((stmt = ParseDecl()) || (stmt = ParseStmt())) {
    PushToList(list, stmt);
  }
  ExpectPunctuator("}");
  return list;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0x43d8(%rip), %rdi      # 0xc2a5
callq 0x9490
testq %rax, %rax
je 0x7f2e
movq %rax, %r14
xorl %eax, %eax
callq 0x47d2
movq %rax, %rbx
movq %r14, 0x10(%rax)
leaq 0x4dce(%rip), %r14      # 0xccbd
callq 0x7e68
testq %rax, %rax
je 0x7f06
movq %rax, %r15
movq %r14, %rdi
callq 0x94d4
jmp 0x7f13
callq 0x79f9
movq %rax, %r15
testq %rax, %rax
je 0x7f20
movq %rbx, %rdi
movq %r15, %rsi
callq 0x485a
jmp 0x7eef
leaq 0x4380(%rip), %rdi      # 0xc2a7
callq 0x94d4
jmp 0x7f30
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/parser.c
// Function: Parse
struct Node *Parse(struct Node **head_token) {
  InitParser(head_token);
  struct Node *list = AllocList();
  struct Node *decl_body;
  while ((decl_body = ParseDeclBody())) {
    if (ConsumePunctuator(";")) {
      PushToList(list, decl_body);
      assert(IsASTList(decl_body->op));
      if (IsASTDeclOfTypedef(decl_body)) {
        // typedef case
        struct Node *typedef_type = CreateTypeFromDecl(decl_body);
        struct Node *typedef_name =
            GetIdentifierTokenFromTypeAttr(typedef_type);
        PrintASTNode(typedef_name);
        PushKeyValueToList(ord_idents, CreateTokenStr(typedef_name),
                           GetTypeWithoutAttr(typedef_type));
      }
      continue;
    }
    struct Node *func_def = ParseFuncDef(decl_body);
    if (!func_def) {
      ErrorWithToken(NextToken(), "Unexpected token");
    }
    PushToList(list, func_def);
  }
  struct Node *t;
  if (!(t = NextToken())) return list;
  ErrorWithToken(t, "Unexpected token");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
callq 0x9835
movq %rax, %rdi
callq 0x9356
xorl %eax, %eax
callq 0x47d2
movq %rax, 0x93e7(%rip)      # 0x11380
xorl %eax, %eax
callq 0x47d2
movq %rax, %rbx
callq 0x7e68
testq %rax, %rax
je 0x806e
movq %rax, %r15
leaq 0x4d02(%rip), %r14      # 0xccbd
movq %r14, %rdi
callq 0x9490
testq %rax, %rax
je 0x8038
movq %rbx, %rdi
movq %r15, %rsi
callq 0x485a
movq 0x10(%r15), %rdi
callq 0x3eb4
testb %al, %al
je 0x809b
movq %r15, %rdi
callq 0x3ec3
testb %al, %al
je 0x805d
movq %r15, %rdi
callq 0xa629
movq %rax, %r15
movq %rax, %rdi
callq 0xa0c1
movq %rax, %r12
movq %rax, %rdi
callq 0x441a
movq 0x936b(%rip), %r13      # 0x11380
movq %r12, %rdi
callq 0x91d7
movq %rax, %r12
movq %r15, %rdi
callq 0xa0a1
movq %r13, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x488d
jmp 0x805d
callq 0x7ec1
testq %rax, %rax
je 0x8085
movq %r15, %rdi
movq %rax, %rsi
callq 0x404f
testq %rax, %rax
je 0x8085
movq %rbx, %rdi
movq %rax, %rsi
callq 0x485a
callq 0x7e68
movq %rax, %r15
testq %rax, %rax
jne 0x7fbb
callq 0x9527
testq %rax, %rax
jne 0x808a
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x9527
leaq 0x425c(%rip), %rsi      # 0xc2ed
movq %rax, %rdi
xorl %eax, %eax
callq 0x470c
leaq 0x4232(%rip), %rdi      # 0xc2d4
leaq 0x415d(%rip), %rsi      # 0xc206
movl $0x21e, %edx            # imm = 0x21E
callq 0x46d0
nop
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/preprocessor.c
// Function: CreateJoinedString
static char *CreateJoinedString(const char *s1, const char *s2) {
  assert(s1 && s2);
  char *s = malloc(strlen(s1) + strlen(s2) + 1);
  assert(s);
  strcpy(s, s1);
  strcat(s, s2);
  return s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x89c6
movq %rsi, %rbx
testq %rsi, %rsi
je 0x89c6
movq %rdi, %r14
callq 0x2080
movq %rax, %r15
movq %rbx, %rdi
callq 0x2080
leaq (%r15,%rax), %rdi
incq %rdi
callq 0x2140
testq %rax, %rax
je 0x89de
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x2050
movq %r15, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x2190
leaq 0x3adb(%rip), %rdi      # 0xc4a8
leaq 0x3935(%rip), %rsi      # 0xc309
movl $0x40, %edx
callq 0x46d0
leaq 0x39fe(%rip), %rdi      # 0xc3e3
leaq 0x391d(%rip), %rsi      # 0xc309
movl $0x42, %edx
callq 0x46d0
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/preprocessor.c
// Function: CreateStrFromTokenRange
static const char *CreateStrFromTokenRange(struct Node *begin,
                                           struct Node *end) {
  assert(begin);
  int len = 0;
  for (struct Node *t = begin; t && t != end; t = t->next_token) {
    len += t->length;
  }
  return strndup(begin->begin, len);
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x8a34
movq %rsi, %rax
xorl %esi, %esi
cmpq %rax, %rdi
je 0x8a27
movq %rdi, %rcx
movslq 0x120(%rcx), %rdx
movslq %esi, %rsi
addq %rdx, %rsi
movq 0x110(%rcx), %rcx
testq %rcx, %rcx
je 0x8a27
cmpq %rax, %rcx
jne 0x8a09
movq 0x118(%rdi), %rdi
popq %rax
jmp 0x20e0
leaq 0x3a76(%rip), %rdi      # 0xc4b1
leaq 0x38c7(%rip), %rsi      # 0xc309
movl $0xc, %edx
callq 0x46d0
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/preprocessor.c
// Function: PreprocessRemoveBlock
static void PreprocessRemoveBlock(void) {
  for (struct Node *t = PeekToken(); t; t = t->next_token) {
    if (!IsEqualTokenWithCStr(t, "#")) {
      continue;
    }
    t = SkipDelimiterTokensInLogicalLine(t->next_token);
    if (!IsEqualTokenWithCStr(t, "endif") && !IsEqualTokenWithCStr(t, "else")) {
      continue;
    }
    RemoveTokensTo(t);
    break;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
callq 0x937c
testq %rax, %rax
je 0x8abe
movq %rax, %rbx
leaq 0x389f(%rip), %r14      # 0xc307
leaq 0x3981(%rip), %r15      # 0xc3f0
leaq 0x3975(%rip), %r12      # 0xc3eb
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9210
testl %eax, %eax
je 0x8ab2
movq 0x110(%rbx), %rdi
callq 0x892e
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
callq 0x9210
testl %eax, %eax
jne 0x8aca
movq %rbx, %rdi
movq %r12, %rsi
callq 0x9210
testl %eax, %eax
jne 0x8aca
movq 0x110(%rbx), %rbx
testq %rbx, %rbx
jne 0x8a76
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x955f
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/struct.c
// Function: AddMemberOfStructFromDecl
void AddMemberOfStructFromDecl(struct Node *struct_spec, struct Node *decl) {
  struct Node *struct_member = AllocNode(kNodeStructMember);
  struct_member->struct_member_decl = decl;
  struct Node *type = CreateTypeFromDecl(decl);
  assert(type && type->left);
  const char *name = CreateTokenStr(type->left);
  struct Node *dict = struct_spec->struct_member_dict;
  PushKeyValueToList(dict, name, struct_member);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movl $0x2, %edi
callq 0x3f11
movq %rax, %r14
movq %r15, 0x78(%rax)
movq %r15, %rdi
callq 0xa629
testq %rax, %rax
je 0x8c5d
movq 0x18(%rax), %rdi
testq %rdi, %rdi
je 0x8c5d
callq 0x91d7
movq 0x68(%rbx), %rdi
movq %rax, %rsi
movq %r14, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x488d
leaq 0x3881(%rip), %rdi      # 0xc4e5
leaq 0x3871(%rip), %rsi      # 0xc4dc
movl $0x2c, %edx
callq 0x46d0
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/struct.c
// Function: FindStructMember
struct Node *FindStructMember(struct Node *struct_type,
                              struct Node *key_token) {
  assert(key_token->type == kNodeToken);
  struct_type = GetTypeWithoutAttr(struct_type);
  assert(struct_type && struct_type->type == kTypeStruct);
  assert(struct_type->type_struct_spec);
  assert(struct_type->type_struct_spec->struct_member_dict);
  assert(struct_type->type_struct_spec->struct_member_dict->type == kASTList);
  return GetNodeByTokenKey(struct_type->type_struct_spec->struct_member_dict,
                           key_token);
}

// Assembly:
pushq %rbx
cmpl $0x1, (%rsi)
jne 0x8cc8
movq %rsi, %rbx
callq 0xa0a1
testq %rax, %rax
je 0x8cb0
cmpl $0x19, (%rax)
jne 0x8cb0
movq 0xf0(%rax), %rax
testq %rax, %rax
je 0x8ce0
movq 0x68(%rax), %rdi
testq %rdi, %rdi
je 0x8cf8
cmpl $0x6, (%rdi)
jne 0x8d10
movq %rbx, %rsi
popq %rbx
jmp 0x496e
leaq 0x385f(%rip), %rdi      # 0xc516
leaq 0x381e(%rip), %rsi      # 0xc4dc
movl $0x36, %edx
callq 0x46d0
leaq 0x3829(%rip), %rdi      # 0xc4f8
leaq 0x3806(%rip), %rsi      # 0xc4dc
movl $0x34, %edx
callq 0x46d0
leaq 0x385f(%rip), %rdi      # 0xc546
leaq 0x37ee(%rip), %rsi      # 0xc4dc
movl $0x37, %edx
callq 0x46d0
leaq 0x3865(%rip), %rdi      # 0xc564
leaq 0x37d6(%rip), %rsi      # 0xc4dc
movl $0x38, %edx
callq 0x46d0
leaq 0x387f(%rip), %rdi      # 0xc596
leaq 0x37be(%rip), %rsi      # 0xc4dc
movl $0x39, %edx
callq 0x46d0
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/symbol.c
// Function: GetLastLocalVarOffset
int GetLastLocalVarOffset(struct SymbolEntry *e) {
  for (; e; e = e->prev) {
    if (e->type != kSymbolLocalVar) continue;
    assert(e->value && e->value->type == kASTLocalVar);
    return e->value->byte_offset;
  }
  return 0;
}

// Assembly:
pushq %rax
xorl %eax, %eax
testq %rdi, %rdi
je 0x8d6b
cmpl $0x0, (%rdi)
je 0x8d57
movq 0x8(%rdi), %rdi
jmp 0x8d47
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x8d6d
cmpl $0x12, (%rax)
jne 0x8d6d
movl 0xa8(%rax), %eax
popq %rcx
retq
leaq 0x38c7(%rip), %rdi      # 0xc63b
leaq 0x38eb(%rip), %rsi      # 0xc666
movl $0x15, %edx
callq 0x46d0
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/symbol.c
// Function: AddLocalVar
struct Node *AddLocalVar(struct SymbolEntry **ctx, const char *key,
                         struct Node *var_type) {
  assert(ctx);
  int ofs = GetLastLocalVarOffset(*ctx);
  ofs += GetSizeOfType(var_type);
  int align = GetSizeOfType(var_type);
  ofs = (ofs + align - 1) / align * align;
  struct Node *local_var = CreateASTLocalVar(ofs, var_type);
  struct SymbolEntry *e = AllocSymbolEntry(kSymbolLocalVar, key, local_var);
  PushSymbol(ctx, e);
  return local_var;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x8e02
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x8d44
movl %eax, %ebp
movq %r15, %rdi
callq 0xa1c5
movl %eax, %r12d
addl %ebp, %r12d
movq %r15, %rdi
callq 0xa1c5
movl %eax, %ecx
leal (%rcx,%r12), %edi
decl %edi
movl %edi, %eax
cltd
idivl %ecx
subl %edx, %edi
movq %r15, %rsi
callq 0x4199
movq %rax, %r15
movl $0x1, %edi
movl $0x20, %esi
callq 0x20f0
movq %r14, 0x10(%rax)
movq %r15, 0x18(%rax)
movq (%rbx), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%rbx)
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3866(%rip), %rdi      # 0xc66f
leaq 0x3856(%rip), %rsi      # 0xc666
movl $0x1d, %edx
callq 0x46d0
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/symbol.c
// Function: FindExternVar
struct Node *FindExternVar(struct SymbolEntry *e, struct Node *key_token) {
  // returns ASTNode which represents Type
  for (; e; e = e->prev) {
    if (e->type != kSymbolExternVar) continue;
    if (!IsEqualTokenWithCStr(key_token, e->key)) continue;
    return e->value;
  }
  return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x8e4d
movq %rsi, %r15
movq %rdi, %r14
xorl %ebx, %ebx
cmpl $0x2, (%r14)
jne 0x8e42
movq 0x10(%r14), %rsi
movq %r15, %rdi
callq 0x9210
testl %eax, %eax
jne 0x8e51
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0x8e2c
jmp 0x8e55
xorl %ebx, %ebx
jmp 0x8e55
movq 0x18(%r14), %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/symbol.c
// Function: FindGlobalVar
struct Node *FindGlobalVar(struct SymbolEntry *e, struct Node *key_token) {
  // returns ASTNode which represents Type
  for (; e; e = e->prev) {
    if (e->type != kSymbolGlobalVar) continue;
    if (!IsEqualTokenWithCStr(key_token, e->key)) continue;
    return e->value;
  }
  return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x8e91
movq %rsi, %r15
movq %rdi, %r14
xorl %ebx, %ebx
cmpl $0x1, (%r14)
jne 0x8e86
movq 0x10(%r14), %rsi
movq %r15, %rdi
callq 0x9210
testl %eax, %eax
jne 0x8e95
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0x8e70
jmp 0x8e99
xorl %ebx, %ebx
jmp 0x8e99
movq 0x18(%r14), %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/symbol.c
// Function: FindLocalVar
struct Node *FindLocalVar(struct SymbolEntry *e, struct Node *key_token) {
  for (; e; e = e->prev) {
    if (e->type != kSymbolLocalVar) continue;
    if (!IsEqualTokenWithCStr(key_token, e->key)) continue;
    return e->value;
  }
  return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x8ed5
movq %rsi, %r15
movq %rdi, %r14
xorl %ebx, %ebx
cmpl $0x0, (%r14)
jne 0x8eca
movq 0x10(%r14), %rsi
movq %r15, %rdi
callq 0x9210
testl %eax, %eax
jne 0x8ed9
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0x8eb4
jmp 0x8edd
xorl %ebx, %ebx
jmp 0x8edd
movq 0x18(%r14), %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/symbol.c
// Function: FindFuncDef
struct Node *FindFuncDef(struct SymbolEntry *e, struct Node *key_token) {
  for (; e; e = e->prev) {
    if (e->type != kSymbolFuncDef) continue;
    if (!IsEqualTokenWithCStr(key_token, e->key)) continue;
    return e->value;
  }
  return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x8f71
movq %rsi, %r15
movq %rdi, %r14
xorl %ebx, %ebx
cmpl $0x3, (%r14)
jne 0x8f66
movq 0x10(%r14), %rsi
movq %r15, %rdi
callq 0x9210
testl %eax, %eax
jne 0x8f75
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0x8f50
jmp 0x8f79
xorl %ebx, %ebx
jmp 0x8f79
movq 0x18(%r14), %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/hikalium[P]compilium/symbol.c
// Function: FindFuncDeclType
struct Node *FindFuncDeclType(struct SymbolEntry *e, struct Node *key_token) {
  for (; e; e = e->prev) {
    if (e->type != kSymbolFuncDeclType) continue;
    if (!IsEqualTokenWithCStr(key_token, e->key)) continue;
    return e->value;
  }
  return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x900d
movq %rsi, %r15
movq %rdi, %r14
xorl %ebx, %ebx
cmpl $0x4, (%r14)
jne 0x9002
movq 0x10(%r14), %rsi
movq %r15, %rdi
callq 0x9210
testl %eax, %eax
jne 0x9011
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0x8fec
jmp 0x9015
xorl %ebx, %ebx
jmp 0x9015
movq 0x18(%r14), %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq