LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/pocari[P]compilerbook-9cc/parser.c
// Function: mul
static Node *mul() {
  Token *tk;
  Node *node = cast();

  for (;;) {
    if (tk = consume("*")) {
      node = new_bin_node(ND_MUL, node, cast(), tk);
    } else if (tk = consume("/")) {
      node = new_bin_node(ND_DIV, node, cast(), tk);
    } else if (tk = consume("%")) {
      node = new_bin_node(ND_MOD, node, cast(), tk);
    } else {
      return node;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x6067
movq %rax, %rbp
leaq 0x4e34(%rip), %rbx      # 0xae17
leaq 0x4e30(%rip), %r14      # 0xae1a
pushq $0x7
popq %r12
pushq $0x6
popq %r13
movq %rbx, %rdi
callq 0x498f
testq %rax, %rax
je 0x600c
movq %rax, %r15
callq 0x6067
movl %r13d, %edi
jmp 0x6042
movq %r14, %rdi
callq 0x498f
testq %rax, %rax
je 0x6026
movq %rax, %r15
callq 0x6067
movl %r12d, %edi
jmp 0x6042
leaq 0x48dc(%rip), %rdi      # 0xa909
callq 0x498f
testq %rax, %rax
je 0x6055
movq %rax, %r15
callq 0x6067
pushq $0x8
popq %rdi
movq %rbp, %rsi
movq %rax, %rdx
movq %r15, %rcx
callq 0x5adf
movq %rax, %rbp
jmp 0x5ff2
movq %rbp, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pocari[P]compilerbook-9cc/parser.c
// Function: abstract_declarator
static Type *abstract_declarator(Type *ty) {
  while (consume("*")) {
    ty = pointer_to(ty);
  }
  if (consume("(")) {
    Type *placeholder = calloc(1, sizeof(Type));
    Type *new_ty = abstract_declarator(placeholder);
    expect(")");
    // 入れ子部分を全部パースした後に、その後に続く配列の [] などを含めた(type_suffix)型としてplaceholderを完成させる
    memcpy(placeholder, type_suffix(ty), sizeof(Type));
    return new_ty;
  }

  return type_suffix(ty);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x46a2(%rip), %r14      # 0xae17
movq %r14, %rdi
callq 0x498f
testq %rax, %rax
je 0x678f
movq %rbx, %rdi
callq 0x8990
movq %rax, %rbx
jmp 0x6775
leaq 0x3de0(%rip), %rdi      # 0xa576
callq 0x498f
testq %rax, %rax
je 0x67ef
pushq $0x1
popq %rdi
pushq $0x30
popq %rsi
callq 0x2100
movq %rax, %r14
movq %rax, %rdi
callq 0x6766
movq %rax, %r15
leaq 0x3dc9(%rip), %rdi      # 0xa589
callq 0x5644
movq %rbx, %rdi
callq 0x67f9
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movups %xmm0, (%r14)
movups %xmm1, 0x10(%r14)
movups %xmm2, 0x20(%r14)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x67f9
// File: /workspace/github_c_makefile_star2_O2/pocari[P]compilerbook-9cc/parser.c
// Function: type_suffix
static Type *type_suffix(Type *base) {
  if (!consume("[")) {
    return base;
  }

  int array_size = 0;
  int is_incomplete = true;
  if (!consume("]")) {
    //[の直後に"]"が来ていない場合、配列のサイズがあるはずなので、完全な方としてis_incompleteをfalseに
    is_incomplete = false;
    array_size = const_expr();
    expect("]");
  }

  Token *tk = token;
  base = type_suffix(base);
  // 不完全型許されるのは最初の配列の最初の次元のみなので、再帰で呼ばれた結果(=2次元以降)に関しては必ず完全になっていること
  if (base->is_incomplete) {
    error_at(tk->str, "incomplete element type(type_suffix)");
  }
  base = array_of(base, array_size);
  base->is_incomplete = is_incomplete;

  return base;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4100(%rip), %rdi      # 0xa90b
callq 0x498f
testq %rax, %rax
je 0x686d
leaq 0x2fa2(%rip), %rdi      # 0x97be
callq 0x498f
movq %rax, %r14
xorl %r15d, %r15d
testq %rax, %rax
jne 0x6840
callq 0x56fc
movq %rax, %r15
leaq 0x2f83(%rip), %rdi      # 0x97be
callq 0x5644
leaq 0x8c39(%rip), %rax      # 0xf480
movq (%rax), %r12
movq %rbx, %rdi
callq 0x67f9
cmpb $0x1, 0xc(%rax)
je 0x687c
movq %rax, %rdi
movl %r15d, %esi
callq 0x89cb
movq %rax, %rbx
testq %r14, %r14
setne 0xc(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x18(%r12), %rdi
leaq 0x4085(%rip), %rsi      # 0xa90d
xorl %eax, %eax
callq 0x46f0
// File: /workspace/github_c_makefile_star2_O2/pocari[P]compilerbook-9cc/parser.c
// Function: struct_ref
static Node *struct_ref(Node *lhs) {
  add_type(lhs);

  if (lhs->ty->kind != TY_STRUCT) {
    fprintf(stderr, "type_info: %s\n", type_info(lhs->ty));
    error_at(token->str, "not a struct(lhs->ty->kind: %d", lhs->ty->kind);
  }

  Token *tok = token;
  Member *m = find_member(lhs->ty, expect_ident());
  if (!m) {
    error_at(tok->str, "no such member");
  }

  Node *n = new_unary_node(ND_MEMBER, lhs, tok);
  n->member = m;

  return n;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x8a4d
movq 0x10(%rbx), %r14
cmpl $0x9, (%r14)
jne 0x692a
leaq 0x8bbb(%rip), %rax      # 0xf480
movq (%rax), %r15
callq 0x56c6
cmpl $0x9, (%r14)
jne 0x6972
movq %rax, %r12
addq $0x20, %r14
movq (%r14), %r14
testq %r14, %r14
je 0x6918
movq 0x10(%r14), %rdi
movq %r12, %rsi
callq 0x2110
testl %eax, %eax
jne 0x68de
pushq $0x23
popq %rdi
movq %r15, %rsi
callq 0x4e7e
movq %rbx, 0x18(%rax)
movq %r14, 0x98(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x18(%r15), %rdi
leaq 0x41b5(%rip), %rsi      # 0xaad8
xorl %eax, %eax
callq 0x46f0
movq 0x86c7(%rip), %rax      # 0xeff8
movq (%rax), %r15
movq %r14, %rdi
callq 0x3bec
leaq 0x4167(%rip), %rsi      # 0xaaaa
movq %r15, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x2120
leaq 0x8b29(%rip), %rax      # 0xf480
movq (%rax), %rax
movq 0x18(%rax), %rdi
movq 0x10(%rbx), %rax
movl (%rax), %edx
leaq 0x414e(%rip), %rsi      # 0xaab9
xorl %eax, %eax
callq 0x46f0
leaq 0x416e(%rip), %rdi      # 0xaae7
leaq 0x3d31(%rip), %rsi      # 0xa6b1
leaq 0x4178(%rip), %rcx      # 0xaaff
movl $0x950, %edx            # imm = 0x950
callq 0x20d0
// File: /workspace/github_c_makefile_star2_O2/pocari[P]compilerbook-9cc/parser.c
// Function: new_gvar
static Var *new_gvar(char *name, Type *type, bool emit, bool is_static) {
  Var *var = new_var(name, type, false);
  var->is_static = is_static;
  if (emit) {
    // 通常のグローバル変数や、文字列リテラルは.dataセクションに出力するように
    // VarListとして保存するが、関数定義などのND_CALLのときのチェックようにしか使わないものは
    // (new_varの中でやっている)スコープにのみいれて、
    // emit: false で呼び出してコード生成時に何も出力しないようにする。
    VarList *v = calloc(1, sizeof(VarList));
    v->var = var;
    v->next = globals;
    globals = v;
  }

  return var;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %ecx, %ebp
movl %edx, %r14d
xorl %edx, %edx
callq 0x6a7a
movq %rax, %rbx
movb %bpl, 0x20(%rax)
testl %r14d, %r14d
je 0x69cd
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x2100
movq %rbx, 0x8(%rax)
movq 0x8a65(%rip), %rcx      # 0xf428
movq %rcx, (%rax)
movq %rax, 0x8a5b(%rip)      # 0xf428
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pocari[P]compilerbook-9cc/parser.c
// Function: new_lvar
static Var *new_lvar(char *name, Type *type) {
  Var *var = new_var(name, type, true);

  VarList *v = calloc(1, sizeof(VarList));
  v->var = var;
  v->next = locals;

  // fprintf(stderr, "new_lvar:next ... %s\n", locals ? "nanika" : "NULL");
  locals = v;

  return var;
}

// Assembly:
pushq %rbx
pushq $0x1
popq %rdx
callq 0x6a7a
movq %rax, %rbx
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x2100
movq %rbx, 0x8(%rax)
movq 0x8a3b(%rip), %rcx      # 0xf450
movq %rcx, (%rax)
movq %rax, 0x8a31(%rip)      # 0xf450
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/pocari[P]compilerbook-9cc/parser.c
// Function: local_var_initializer
static Node *local_var_initializer(Var *var, Token *tk) {
  Node head = {};
  local_var_initializer_sub(&head, var, var->type, NULL);

  Node *node = new_node(ND_BLOCK, tk);
  node->body = head.next;

  return node;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movl $0xc8, %edx
movq %r15, %rdi
xorl %esi, %esi
callq 0x20e0
movq (%r14), %rdx
movq %r15, %rdi
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x7079
pushq $0x1a
popq %rdi
movq %rbx, %rsi
callq 0x4e7e
movq 0x30(%r15), %rcx
movq %rcx, 0x28(%rax)
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/pocari[P]compilerbook-9cc/parser.c
// Function: new_var
static Var *new_var(char *name, Type *type, bool is_local) {
  Var *var = calloc(1, sizeof(Var));
  var->type = type;
  var->name = name;
  var->is_local = is_local;

  // 今のscopeにこの変数を追加
  push_var_scope(name, var);

  return var;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x1
popq %rdi
pushq $0x28
popq %rsi
callq 0x2100
movq %rax, %r12
movq %r14, (%rax)
movq %r15, 0x8(%rax)
movb %bl, 0x14(%rax)
movq %r15, %rdi
callq 0x6abd
movq %r12, 0x10(%rax)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/pocari[P]compilerbook-9cc/parser.c
// Function: push_var_scope_helper
static VarScope *push_var_scope_helper(char *name) {
  VarScope *sc = calloc(1, sizeof(VarScope));

  sc->name = name;
  sc->next = var_scope;
  sc->depth = scope_depth;
  var_scope = sc;

  return sc;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rdi
pushq $0x30
popq %rsi
callq 0x2100
movq %rbx, 0x8(%rax)
movq 0x8969(%rip), %rcx      # 0xf440
movq %rcx, (%rax)
movl 0x8950(%rip), %ecx      # 0xf430
movl %ecx, 0x2c(%rax)
movq %rax, 0x8956(%rip)      # 0xf440
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/pocari[P]compilerbook-9cc/parser.c
// Function: new_init_val
static Initializer *new_init_val(Initializer *cur, int sz, long val) {
  Initializer *initializer = calloc(1, sizeof(Initializer));
  initializer->val = val;
  initializer->sz = sz;
  cur->next = initializer;
  return initializer;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
pushq $0x1
popq %rdi
pushq $0x28
popq %rsi
callq 0x2100
movq %rbx, 0x10(%rax)
movl %ebp, 0x8(%rax)
movq %rax, (%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pocari[P]compilerbook-9cc/parser.c
// Function: skip_excess_elements2
static void skip_excess_elements2() {
  for (;;) {
    if (consume("{")) {
      skip_excess_elements2();
    } else {
      // brace以外の場合は何か式があるはずなので読み飛ばす
      assign();
    }
    if (consume_end()) {
      return;
    }
    expect(",");
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x3474(%rip), %rbx      # 0xa316
leaq 0x3806(%rip), %r14      # 0xa6af
movq %rbx, %rdi
callq 0x498f
testq %rax, %rax
je 0x6ebd
callq 0x6e97
jmp 0x6ec2
callq 0x6edd
callq 0x493e
testb %al, %al
jne 0x6ed5
movq %r14, %rdi
callq 0x5644
jmp 0x6ea9
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/pocari[P]compilerbook-9cc/parser.c
// Function: lvar_init_zero
static Node *lvar_init_zero(Node *cur, Var *var, Type *ty, Designator *dseg) {
  if (ty->kind == TY_ARRAY) {
    // 配列の場合は各要素も再帰的に0にする
    for (int i = 0; i < ty->array_size; i++) {
      Designator desg2 = {dseg, i};
      cur = lvar_init_zero(cur, var, ty->ptr_to, &desg2);
    }
    return cur;
  }
  // 配列でない場合は、単純にその変数(入れ子の配列の場合はどこかの末端の要素)に0を代入するコードをnextにつなげていく
  cur->next = new_desg_node(var, dseg, new_num_node(0, token));
  return cur->next;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpl $0x8, (%rdx)
jne 0x7478
movq %rdx, %r12
xorl %ebp, %ebp
movq %rsp, %r13
cmpq %rbp, 0x18(%r12)
jle 0x749e
movq %r14, (%rsp)
movl %ebp, 0x8(%rsp)
andq $0x0, 0x10(%rsp)
movq 0x10(%r12), %rdx
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rcx
callq 0x7424
movq %rax, %rbx
incq %rbp
jmp 0x7448
leaq 0x8001(%rip), %rax      # 0xf480
movq (%rax), %rsi
xorl %edi, %edi
callq 0x688f
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x73e7
movq %rax, 0x30(%rbx)
movq %rax, %rbx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pocari[P]compilerbook-9cc/parser.c
// Function: new_desg_node_sub
static Node *new_desg_node_sub(Var *var, Designator *desg, Token *tk) {
  if (!desg) {
    return new_var_node(var, tk);
  }
  Node *node = new_desg_node_sub(var, desg->next, tk);
  if (desg->mem) {
    // dsegが構造体のメンバー参照なら、返ってきたnodeを構造体の変数とみなしてそのメンバー参照のastを作成
    node = new_unary_node(ND_MEMBER, node, tk);
    node->member = desg->mem;

    return node;
  }

  node = new_add_node(node, new_num_node(desg->idx, tk), tk);

  node = new_unary_node(ND_DEREF, node, tk);
  add_type(node);

  return node;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
testq %rsi, %rsi
je 0x74f4
movq %rsi, %r14
movq (%rsi), %rsi
movq %rbx, %rdx
callq 0x74b0
movq %rax, %r15
cmpq $0x0, 0x10(%r14)
je 0x7501
pushq $0x23
popq %rdi
movq %rbx, %rsi
callq 0x4e7e
movq %rax, %rbx
movq %r15, 0x18(%rax)
movq 0x10(%r14), %rax
movq %rax, 0x98(%rbx)
jmp 0x7538
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x4e55
movslq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x688f
movq %r15, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x5e8a
movq %rax, %r14
pushq $0x1f
popq %rdi
movq %rbx, %rsi
callq 0x4e7e
movq %rax, %rbx
movq %r14, 0x18(%rax)
movq %rax, %rdi
callq 0x8a4d
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/pocari[P]compilerbook-9cc/parser.c
// Function: find_var
static VarScope *find_var(Token *token) {
  for (VarScope *sc = var_scope; sc; sc = sc->next) {
    if (sc->type_def) {
      // typedef は変数じゃないので無視
      continue;
    }

    if (strlen(sc->name) == token->len &&
        strncmp(sc->name, token->str, token->len) == 0) {
      return sc;
    }
  }
  return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x7ef0(%rip), %rbx      # 0xf440
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x7587
cmpq $0x0, 0x18(%rbx)
jne 0x7550
movq 0x8(%rbx), %r15
movq %r15, %rdi
callq 0x20b0
movslq 0x20(%r14), %rcx
cmpq %rcx, %rax
jne 0x7550
movq 0x18(%r14), %rsi
movq %r15, %rdi
movq %rax, %rdx
callq 0x2060
testl %eax, %eax
jne 0x7550
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/pocari[P]compilerbook-9cc/parser.c
// Function: expr
static Node *expr() {
  Token *tk;
  Node *node = assign();

  while (tk = consume(",")) {
    // カンマがある場合、最後の式の値だけスタックに積みたいので、
    // カンマより左にある式の結果は全部式文(ND_EXPR_STMT)にして計算だけして結果は捨てる
    node = new_unary_node(ND_EXPR_STMT, node, node->tok);
    node = new_bin_node(ND_COMMA, node, assign(), tk);
  }

  return node;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x6edd
movq %rax, %r15
leaq 0x3105(%rip), %rbx      # 0xa6af
pushq $0x21
popq %rbp
pushq $0x25
popq %r14
movq %rbx, %rdi
callq 0x498f
testq %rax, %rax
je 0x75ee
movq %rax, %r12
movq 0x8(%r15), %rsi
movl %ebp, %edi
callq 0x4e7e
movq %rax, %r13
movq %r15, 0x18(%rax)
callq 0x6edd
movl %r14d, %edi
movq %r13, %rsi
movq %rax, %rdx
movq %r12, %rcx
callq 0x5adf
movq %rax, %r15
jmp 0x75b1
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pocari[P]compilerbook-9cc/parser.c
// Function: enter_scope
static Scope *enter_scope(void) {
  Scope *new_scope = calloc(1, sizeof(Scope));

  new_scope->var_scope = var_scope;
  new_scope->tag_scope = tag_scope;
  scope_depth++;

  return new_scope;
}

// Assembly:
pushq %rax
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x2100
movq 0x7e2d(%rip), %rcx      # 0xf440
movq %rcx, (%rax)
movq 0x7e1b(%rip), %rcx      # 0xf438
movq %rcx, 0x8(%rax)
incl 0x7e09(%rip)            # 0xf430
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/pocari[P]compilerbook-9cc/parser.c
// Function: read_expr_stmt
static Node *read_expr_stmt() {
  Node *node = new_node(ND_EXPR_STMT, token);
  node->kind = ND_EXPR_STMT;
  node->lhs = expr();
  return node;
}

// Assembly:
pushq %rbx
leaq 0x75dd(%rip), %rax      # 0xf480
movq (%rax), %rsi
pushq $0x21
popq %rdi
callq 0x4e7e
movq %rax, %rbx
movl $0x21, (%rax)
callq 0x7590
movq %rax, 0x18(%rbx)
movq %rbx, %rax
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/pocari[P]compilerbook-9cc/string_buffer.c
// Function: sb_init
string_buffer *sb_init() {
  string_buffer *sb = calloc(1, sizeof(string_buffer));

  sb->str_len = 0;
  sb->buf_len = 16;
  sb->buf = calloc(sb->buf_len, sizeof(char));

  return sb;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
pushq $0x1
popq %rbx
pushq $0x10
popq %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2100
movq %rax, %r15
movl $0x10, 0xc(%rax)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2100
movq %rax, (%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/pocari[P]compilerbook-9cc/test_func.c
// Function: add_all1
int add_all1(int x, ...) {
  va_list ap;
  va_start(ap, x);

  for (;;) {
    int y = va_arg(ap, int);
    if (y == 0)
      return x;
    x += y;
  }
}

// Assembly:
subq $0x58, %rsp
leaq -0x60(%rsp), %r10
movq %rsi, 0x8(%r10)
movq %rdx, 0x10(%r10)
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0x801b
movaps %xmm0, -0x30(%rsp)
movaps %xmm1, -0x20(%rsp)
movaps %xmm2, -0x10(%rsp)
movaps %xmm3, (%rsp)
movaps %xmm4, 0x10(%rsp)
movaps %xmm5, 0x20(%rsp)
movaps %xmm6, 0x30(%rsp)
movaps %xmm7, 0x40(%rsp)
movq %r10, -0x70(%rsp)
leaq 0x60(%rsp), %rdx
movq %rdx, -0x78(%rsp)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, -0x80(%rsp)
movl $0x8, %ecx
movl %edi, %eax
cmpl $0x28, %ecx
ja 0x8056
movq %rdx, %rsi
movl %ecx, %edx
addq %r10, %rdx
addl $0x8, %ecx
movl %ecx, -0x80(%rsp)
jmp 0x805f
leaq 0x8(%rdx), %rsi
movq %rsi, -0x78(%rsp)
movl (%rdx), %r8d
leal (%r8,%rax), %edi
movq %rsi, %rdx
testl %r8d, %r8d
jne 0x803e
addq $0x58, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/pocari[P]compilerbook-9cc/test_func.c
// Function: add_all2
int add_all2(int x, int y, ...) {
  va_list ap;
  va_start(ap, y);
  x = x + y;

  for (;;) {
    int y = va_arg(ap, int);
    if (y == 0)
      return x;
    x += y;
  }
}

// Assembly:
subq $0x58, %rsp
leaq -0x60(%rsp), %r10
movq %rdx, 0x10(%r10)
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0x80b7
movaps %xmm0, -0x30(%rsp)
movaps %xmm1, -0x20(%rsp)
movaps %xmm2, -0x10(%rsp)
movaps %xmm3, (%rsp)
movaps %xmm4, 0x10(%rsp)
movaps %xmm5, 0x20(%rsp)
movaps %xmm6, 0x30(%rsp)
movaps %xmm7, 0x40(%rsp)
movq %r10, -0x70(%rsp)
leaq 0x60(%rsp), %rdx
movq %rdx, -0x78(%rsp)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, -0x80(%rsp)
addl %esi, %edi
movl $0x10, %ecx
movl %edi, %eax
cmpl $0x28, %ecx
ja 0x80f4
movq %rdx, %rsi
movl %ecx, %edx
addq %r10, %rdx
addl $0x8, %ecx
movl %ecx, -0x80(%rsp)
jmp 0x80fd
leaq 0x8(%rdx), %rsi
movq %rsi, -0x78(%rsp)
movl (%rdx), %r8d
leal (%r8,%rax), %edi
movq %rsi, %rdx
testl %r8d, %r8d
jne 0x80dc
addq $0x58, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/pocari[P]compilerbook-9cc/tokenize.c
// Function: new_token
Token *new_token(TokenKind kind, Token *cur, char *str, int len) {
  Token *tok = calloc(1, sizeof(Token));
  tok->kind = kind;
  tok->str = str;
  tok->len = len;
  cur->next = tok;
  return tok;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %ebp
pushq $0x1
popq %rdi
pushq $0x38
popq %rsi
callq 0x2100
movl %ebp, (%rax)
movq %r14, 0x18(%rax)
movl %ebx, 0x20(%rax)
movq %rax, 0x8(%r15)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pocari[P]compilerbook-9cc/tokenize.c
// Function: dump_token
void dump_token(Token *t) {
  if (!t) {
    printf("## (NULL token)");
    return;
  }

  printf("## (Token kind: %*s ", 12 ,token_kind_to_s(t->kind));

  switch (t->kind) {
    case TK_NUM:
      printf("[%ld]", t->val);
      break;
    case TK_STR:
      printf("[contents: [%s], length(includes \\0): %d", t->contents, t->content_length);
      break;
    default:
      printf("[%s]", my_strndup(t->str, t->len));
      break;
  }
  printf(")\n");
}

// Assembly:
testq %rdi, %rdi
je 0x81b2
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %edi
callq 0x8148
leaq 0x2c44(%rip), %rdi      # 0xadd0
pushq $0xc
popq %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x20c0
movl (%rbx), %eax
cmpl $0x14, %eax
je 0x81c0
cmpl $0x3, %eax
jne 0x81d7
movq 0x10(%rbx), %rsi
leaq 0x214f(%rip), %rdi      # 0xa2ff
jmp 0x81ed
leaq 0x2c07(%rip), %rdi      # 0xadc0
xorl %eax, %eax
jmp 0x20c0
movq 0x28(%rbx), %rsi
movl 0x30(%rbx), %edx
leaq 0x2c17(%rip), %rdi      # 0xade5
xorl %eax, %eax
callq 0x20c0
jmp 0x81f4
movq 0x18(%rbx), %rdi
movl 0x20(%rbx), %esi
callq 0x4903
leaq 0x2c24(%rip), %rdi      # 0xae0e
movq %rax, %rsi
xorl %eax, %eax
callq 0x20c0
leaq 0x238e(%rip), %rdi      # 0xa589
popq %rbx
jmp 0x2070
// File: /workspace/github_c_makefile_star2_O2/pocari[P]compilerbook-9cc/tokenize.c
// Function: free_tokens
void free_tokens(Token *cur) {
  while (cur) {
    Token *tmp = cur->next;
    free(cur);
    cur  = tmp;
  }
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x8215
movq 0x8(%rdi), %rbx
callq 0x2030
movq %rbx, %rdi
jmp 0x8202
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/pocari[P]compilerbook-9cc/tokenize.c
// Function: tokenize_keyword
Keyword *tokenize_keyword(char *p) {
  for (int i = 0; i < sizeof(keywords) / sizeof(Keyword); i++) {
    Keyword *k = &keywords[i];
    int len = strlen(k->keyword);
    if (strncmp(p, k->keyword, len) == 0 && !is_alnum(p[len])) {
      return k;
    }
  }
  return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %ebx, %ebx
leaq 0x6ea1(%rip), %r13      # 0xf130
xorl %ebp, %ebp
cmpq $0x190, %rbp            # imm = 0x190
je 0x82d6
movq (%rbp,%r13), %r12
movq %r12, %rdi
callq 0x20b0
movslq %eax, %r15
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x2060
testl %eax, %eax
jne 0x82ca
movsbl (%r14,%r15), %edi
callq 0x8217
testb %al, %al
je 0x82d0
addq $0x10, %rbp
jmp 0x8291
addq %rbp, %r13
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_O2/pocari[P]compilerbook-9cc/tokenize.c
// Function: is_multi_char_operator
int is_multi_char_operator(char *p) {
  for (char **op = multi_char_ope; *op; op++) {
    if (starts_with(p, *op)) {
      return strlen(*op);
    }
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x6a49(%rip), %r15      # 0xed40
movq (%r15), %r14
testq %r14, %r14
je 0x831c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x824b
addq $0x8, %r15
testb %al, %al
je 0x82f7
movq %r14, %rdi
callq 0x20b0
jmp 0x831e
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/pocari[P]compilerbook-9cc/tokenize.c
// Function: read_file
char *read_file(char *path) {
  FILE *fp = fopen(path, "r");
  if (!fp) {
    error("cannot open %s: %s", path, strerror(errno));
  }

  // ファイルの最後の位置を調べてサイズ計算
  if (fseek(fp, 0, SEEK_END) == -1) {
    error("%s: fseek: %s", path, strerror(errno));
  }
  long file_size = ftell(fp);

  // 読むために先頭に戻す
  if (fseek(fp, 0, SEEK_SET) == -1) {
    error("%s: fseek: %s", path, strerror(errno));
  }

  // \n\0で終わらせるための2バイト追加で確保
  char *buf = calloc(1, file_size + 2);
  fread(buf, file_size, 1, fp);


  if (file_size == 0 || buf[file_size - 1] != '\n') {
    buf[file_size++] = '\n';
  }
  buf[file_size] = '\0';
  fclose(fp);

  return buf;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x1a7d(%rip), %rsi      # 0xa2f2
callq 0x2190
movq %rax, %rbx
testq %rax, %rax
jne 0x88a2
callq 0x2050
movl (%rax), %edi
callq 0x21e0
leaq 0x2607(%rip), %rdi      # 0xae9c
movq %r14, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x485f
pushq $0x2
popq %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2170
cmpl $-0x1, %eax
jne 0x88d4
callq 0x2050
movl (%rax), %edi
callq 0x21e0
leaq 0x25e8(%rip), %rdi      # 0xaeaf
movq %r14, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x485f
movq %rbx, %rdi
callq 0x2130
movq %rax, %r15
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2170
cmpl $-0x1, %eax
jne 0x8910
callq 0x2050
movl (%rax), %edi
callq 0x21e0
leaq 0x25ac(%rip), %rdi      # 0xaeaf
movq %r14, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x485f
leaq 0x2(%r15), %rsi
pushq $0x1
popq %r12
movq %r12, %rdi
callq 0x2100
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x2080
testq %r15, %r15
je 0x8941
cmpb $0xa, -0x1(%r14,%r15)
je 0x8949
movb $0xa, (%r14,%r15)
incq %r15
movb $0x0, (%r14,%r15)
movq %rbx, %rdi
callq 0x2090
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/pocari[P]compilerbook-9cc/type.c
// Function: new_type
static Type *new_type(TypeKind kind, int size, int align) {
  Type *t = calloc(1, sizeof(Type));
  t->kind = kind;
  t->size = size;
  t->align = align;

  return t;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movl %esi, %ebp
movl %edi, %r14d
pushq $0x1
popq %rdi
pushq $0x30
popq %rsi
callq 0x2100
movl %r14d, (%rax)
movl %ebp, 0x4(%rax)
movl %ebx, 0x8(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pocari[P]compilerbook-9cc/type.c
// Function: array_of
Type *array_of(Type *ptr_to, int array_size) {
  Type *ty = new_type(TY_ARRAY, ptr_to->size * array_size, ptr_to->align);
  ty->ptr_to = ptr_to;
  ty->array_size = array_size;
  return ty;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl 0x4(%rdi), %esi
imull %ebx, %esi
movl 0x8(%rdi), %edx
pushq $0x8
popq %rdi
callq 0x89a7
movq %r14, 0x10(%rax)
movslq %ebx, %rcx
movq %rcx, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/pocari[P]compilerbook-9cc/type.c
// Function: struct_type
Type *struct_type(void) {
  // 一旦サイズゼロ、アラインメント1バイトで作成
  // 実際には構造体のメンバーのパース時に、メンバー中で一番大きいアラインメントで上書きされる。
  Type *type = new_type(TY_STRUCT, 0, 1);
  type->is_incomplete = true;
  return type;
}

// Assembly:
pushq %rax
pushq $0x9
popq %rdi
pushq $0x1
popq %rdx
xorl %esi, %esi
callq 0x89a7
movb $0x1, 0xc(%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/giometti[P]mastering_UNIX_programming/chapter_06/binio.c
// Function: main
int main(void)
{
	FILE *fp;
	int outdata[4] = { 10, -3, 200, 0 };
	int indata[4];
	int n;

	/* Open a file for writing */
	fp = fopen("file.txt", "w");
	if (!fp) {
		perror("fopen");
		return -1;
	}

	/* Try to write data to file */
	n = fwrite(outdata, sizeof(int), 4, fp);
	if (n < 4) {
		fprintf(stderr, "cannot fwrite\n");
		return -1;
	}
	printf("written %d, %d, %d, %d\n",
		outdata[0], outdata[1],
		outdata[2], outdata[3]);

	/* Writing done */
	fclose(fp);

	/* Open a file for reading */
	fp = fopen("file.txt", "r");
	if (!fp) {
		perror("fopen");
		return -1;
	}

	/* Try to read data from file */
	n = fread(indata, sizeof(int), 4, fp);
	if (n < 4) {
		if (ferror(fp))
			fprintf(stderr, "cannot fread\n");
		if (feof(fp))
			fprintf(stderr, "too few data to read\n");
		return -1;
	}
	printf("read %d, %d, %d, %d\n",
		indata[0], indata[1],
		indata[2], indata[3]);

	/* Reading done */
	fclose(fp);

	return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x28, %rsp
movaps 0xe57(%rip), %xmm0      # 0x2010
movaps %xmm0, (%rsp)
leaq 0xe5c(%rip), %rdi       # 0x2020
leaq 0xe5e(%rip), %rsi       # 0x2029
callq 0x1080
testq %rax, %rax
je 0x12bb
movq %rax, %rbx
movq %rsp, %rdi
pushq $0x4
popq %rdx
movq %rdx, %rsi
movq %rax, %rcx
callq 0x10a0
cmpl $0x3, %eax
jle 0x12c9
movl (%rsp), %esi
movl 0x4(%rsp), %edx
movl 0x8(%rsp), %ecx
movl 0xc(%rsp), %r8d
leaq 0xe33(%rip), %rdi       # 0x2040
xorl %eax, %eax
callq 0x1060
movq %rbx, %rdi
callq 0x1050
leaq 0xdfd(%rip), %rdi       # 0x2020
leaq 0xe2e(%rip), %rsi       # 0x2058
callq 0x1080
testq %rax, %rax
je 0x12bb
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
pushq $0x4
popq %rdx
movq %rdx, %rsi
movq %rax, %rcx
callq 0x1040
cmpl $0x3, %eax
jg 0x1290
movq %rbx, %rdi
callq 0x1030
testl %eax, %eax
jne 0x12f1
movq %rbx, %rdi
callq 0x1070
pushq $-0x1
popq %rbp
testl %eax, %eax
je 0x12e8
movq 0x2d7f(%rip), %rax      # 0x3ff8
movq (%rax), %rcx
leaq 0xde5(%rip), %rdi       # 0x2068
pushq $0x15
popq %rsi
pushq $0x1
popq %rdx
callq 0x10a0
jmp 0x12e8
movl 0x10(%rsp), %esi
movl 0x14(%rsp), %edx
movl 0x18(%rsp), %ecx
movl 0x1c(%rsp), %r8d
leaq 0xdd6(%rip), %rdi       # 0x207e
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x1060
movq %rbx, %rdi
callq 0x1050
jmp 0x12e8
leaq 0xd69(%rip), %rdi       # 0x202b
callq 0x1090
jmp 0x12e5
movq 0x2d28(%rip), %rax      # 0x3ff8
movq (%rax), %rcx
leaq 0xd57(%rip), %rdi       # 0x2031
pushq $0xe
popq %rsi
pushq $0x1
popq %rdx
callq 0x10a0
pushq $-0x1
popq %rbp
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
movq 0x2d00(%rip), %rax      # 0x3ff8
movq (%rax), %rcx
leaq 0xd58(%rip), %rdi       # 0x205a
pushq $0xd
popq %rsi
pushq $0x1
popq %rdx
callq 0x10a0
jmp 0x1263
// File: /workspace/github_c_makefile_star2_O2/cirocosta[P]stress/src/context-switches.c
// Function: stick_self_to_core
int
stick_self_to_core(int cpu)
{
	cpu_set_t cpuset;

	CPU_ZERO(&cpuset);
	CPU_SET(cpu, &cpuset);
	return sched_setaffinity(0, sizeof(cpuset), &cpuset);
}

// Assembly:
subq $0x88, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, 0x70(%rsp)
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
cmpl $0x3ff, %edi            # imm = 0x3FF
ja 0x1736
pushq $0x1
popq %rax
movl %edi, %ecx
shlq %cl, %rax
shrl $0x6, %edi
orq %rax, (%rsp,%rdi,8)
movq %rsp, %rdx
movl $0x80, %esi
xorl %edi, %edi
callq 0x10b0
addq $0x88, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/cirocosta[P]stress/src/context-switches.c
// Function: thread_handler
void*
thread_handler(void* arg)
{
	(void)arg;
	int num_cores = sysconf(_SC_NPROCESSORS_ONLN);

	while (1) {
		int r = rand() % num_cores;
		int ndx = 0;

		while (++ndx < num_cores) {
			int n = 1000;
			_STRESS_MUST((stick_self_to_core(r) != -1),
			             "couldn't stick thread to cpu %d",
			             ndx);
			while (n-- > 0) {
				printf("Thread %lu is running on CPU %3d\n",
				       (unsigned long)pthread_self(),
				       sched_getcpu());
			}
		}
	}

	return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
pushq $0x54
popq %rdi
callq 0x1130
movq %rax, %r14
leaq 0x9d5(%rip), %r15       # 0x213f
callq 0x11b0
cltd
idivl %r14d
movl %edx, %ebp
xorl %ebx, %ebx
incl %ebx
cmpl %r14d, %ebx
jge 0x176a
movl %ebp, %edi
callq 0x16ee
cmpl $-0x1, %eax
je 0x17b6
movl $0xfffffc18, %r13d      # imm = 0xFFFFFC18
callq 0x1120
movq %rax, %r12
testl %r13d, %r13d
je 0x1777
callq 0x1150
movq %r15, %rdi
movq %r12, %rsi
movl %eax, %edx
xorl %eax, %eax
callq 0x1090
incl %r13d
jmp 0x1798
movq 0x283b(%rip), %r15      # 0x3ff8
movq (%r15), %rcx
leaq 0x859(%rip), %rdi       # 0x2020
pushq $0x9
popq %rsi
pushq $0x1
popq %r14
movq %r14, %rdx
callq 0x1180
movq (%r15), %rcx
leaq 0x846(%rip), %rdi       # 0x2026
pushq $0x3
popq %rsi
movq %r14, %rdx
callq 0x1180
movq (%r15), %rdi
leaq 0x913(%rip), %rsi       # 0x2108
movl %ebx, %edx
xorl %eax, %eax
callq 0x10f0
movq (%r15), %rcx
leaq 0x845(%rip), %rdi       # 0x204d
pushq $0x2
popq %rsi
movq %r14, %rdx
callq 0x1180
movq (%r15), %rdi
leaq 0x833(%rip), %rsi       # 0x2050
leaq 0x904(%rip), %rdx       # 0x2128
xorl %eax, %eax
callq 0x10f0
movq (%r15), %rdi
leaq 0x837(%rip), %rsi       # 0x206c
pushq $0x27
popq %rdx
xorl %eax, %eax
callq 0x10f0
movq (%r15), %rsi
pushq $0xa
popq %rdi
callq 0x10c0
movq (%r15), %rcx
leaq 0x825(%rip), %rdi       # 0x2079
pushq $0xa
popq %rsi
movq %r14, %rdx
callq 0x1180
pushq $0x1
popq %rdi
callq 0x1170
// File: /workspace/github_c_makefile_star2_O2/cirocosta[P]stress/src/context-switches.c
// Function: main
int
main()
{
	pthread_t threads[NTHREADS];

	srand(time(NULL));
	for (int i = 0; i < NTHREADS; i++) {
		_STRESS_MUST(
		  (!pthread_create(&threads[i], NULL, &thread_handler, NULL)),
		  "Unexpected error creating thread %d",
		  i);
	}

	for (int i = 0; i < NTHREADS; i++) {
		_STRESS_MUST((!pthread_join(threads[i], NULL)),
		             "Unexpected error waiting for thread %d",
		             i);
	}

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
xorl %ebx, %ebx
xorl %edi, %edi
callq 0x1100
movl %eax, %edi
callq 0x10e0
movq %rsp, %r14
leaq -0x140(%rip), %r15      # 0x174d
cmpq $0x32, %rbx
je 0x18af
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x1110
testl %eax, %eax
jne 0x18df
incq %rbx
addq $0x8, %r14
jmp 0x188d
xorl %r14d, %r14d
cmpq $0x32, %r14
je 0x18d0
movq (%rsp,%r14,8), %rdi
xorl %esi, %esi
callq 0x1190
testl %eax, %eax
jne 0x1988
incq %r14
jmp 0x18b2
xorl %eax, %eax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %r15
retq
movq 0x2712(%rip), %r15      # 0x3ff8
movq (%r15), %rcx
leaq 0x730(%rip), %rdi       # 0x2020
pushq $0x9
popq %rsi
pushq $0x1
popq %r14
movq %r14, %rdx
callq 0x1180
movq (%r15), %rcx
leaq 0x71d(%rip), %rdi       # 0x2026
pushq $0x3
popq %rsi
movq %r14, %rdx
callq 0x1180
movq (%r15), %rdi
leaq 0x843(%rip), %rsi       # 0x2161
movl %ebx, %edx
xorl %eax, %eax
callq 0x10f0
movq (%r15), %rcx
leaq 0x71c(%rip), %rdi       # 0x204d
pushq $0x2
popq %rsi
movq %r14, %rdx
callq 0x1180
movq (%r15), %rdi
leaq 0x70a(%rip), %rsi       # 0x2050
leaq 0x7db(%rip), %rdx       # 0x2128
xorl %eax, %eax
callq 0x10f0
movq (%r15), %rdi
leaq 0x70e(%rip), %rsi       # 0x206c
pushq $0x3d
popq %rdx
xorl %eax, %eax
callq 0x10f0
movq (%r15), %rsi
pushq $0xa
popq %rdi
callq 0x10c0
movq (%r15), %rcx
leaq 0x6fc(%rip), %rdi       # 0x2079
pushq $0xa
popq %rsi
movq %r14, %rdx
jmp 0x1a2c
movq 0x2669(%rip), %r15      # 0x3ff8
movq (%r15), %rcx
leaq 0x687(%rip), %rdi       # 0x2020
pushq $0x9
popq %rsi
pushq $0x1
popq %rbx
movq %rbx, %rdx
callq 0x1180
movq (%r15), %rcx
leaq 0x675(%rip), %rdi       # 0x2026
pushq $0x3
popq %rsi
movq %rbx, %rdx
callq 0x1180
movq (%r15), %rdi
leaq 0x7bf(%rip), %rsi       # 0x2185
movl %r14d, %edx
xorl %eax, %eax
callq 0x10f0
movq (%r15), %rcx
leaq 0x673(%rip), %rdi       # 0x204d
pushq $0x2
popq %rsi
movq %rbx, %rdx
callq 0x1180
movq (%r15), %rdi
leaq 0x661(%rip), %rsi       # 0x2050
leaq 0x732(%rip), %rdx       # 0x2128
xorl %eax, %eax
callq 0x10f0
movq (%r15), %rdi
leaq 0x665(%rip), %rsi       # 0x206c
pushq $0x43
popq %rdx
xorl %eax, %eax
callq 0x10f0
movq (%r15), %rsi
pushq $0xa
popq %rdi
callq 0x10c0
movq (%r15), %rcx
leaq 0x653(%rip), %rdi       # 0x2079
pushq $0xa
popq %rsi
movq %rbx, %rdx
callq 0x1180
pushq $0x1
popq %rdi
callq 0x1170
// File: /workspace/github_c_makefile_star2_O2/kieselsteini[P]PiXL-old/lua53.c
// Function: luaL_requiref
LUALIB_API void luaL_requiref (lua_State *L, const char *modname,
                               lua_CFunction openf, int glb) {
  luaL_getsubtable(L, LUA_REGISTRYINDEX, LUA_LOADED_TABLE);
  lua_getfield(L, -1, modname);  /* LOADED[modname] */
  if (!lua_toboolean(L, -1)) {  /* package not already loaded? */
    lua_pop(L, 1);  /* remove field */
    lua_pushcfunction(L, openf);
    lua_pushstring(L, modname);  /* argument to open function */
    lua_call(L, 1, 1);  /* call 'openf' to open module */
    lua_pushvalue(L, -1);  /* make copy of module (call result) */
    lua_setfield(L, -3, modname);  /* LOADED[modname] = module */
  }
  lua_remove(L, -2);  /* remove LOADED table */
  if (glb) {
    lua_pushvalue(L, -1);  /* copy of module */
    lua_setglobal(L, modname);  /* _G[modname] = module */
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1e3fd(%rip), %rdx     # 0x29ff6
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0xbb7b
pushq $-0x1
popq %r12
movq %r14, %rdi
movl %r12d, %esi
movq %rbx, %rdx
callq 0x86b4
movq %r14, %rdi
movl %r12d, %esi
callq 0x78dd
testl %eax, %eax
jne 0xbc6d
addq $-0x10, 0x10(%r14)
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x82d6
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7e73
movq 0x10(%r14), %rsi
addq $-0x20, %rsi
pushq $0x1
popq %rdx
movq %r14, %rdi
callq 0x93da
pushq $-0x1
popq %rsi
movq %r14, %rdi
callq 0x6d1f
pushq $-0x3
popq %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x8e94
pushq $-0x2
popq %rsi
pushq $-0x1
popq %rdx
movq %r14, %rdi
callq 0x6b97
addq $-0x10, 0x10(%r14)
testl %ebp, %ebp
je 0xbca2
pushq $-0x1
popq %rsi
movq %r14, %rdi
callq 0x6d1f
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x8b3e
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/kieselsteini[P]PiXL-old/lua53.c
// Function: luaL_checkversion_
LUALIB_API void luaL_checkversion_ (lua_State *L, lua_Number ver, size_t sz) {
  const lua_Number *v = lua_version(L);
  if (sz != LUAL_NUMSIZES)  /* check numeric types */
    luaL_error(L, "core and library have incompatible numeric types");
  if (v != lua_version(NULL))
    luaL_error(L, "multiple Lua VMs detected");
  else if (*v != ver)
    luaL_error(L, "version mismatch: app. needs %f, Lua core provides %f",
                  (LUAI_UACNUMBER)ver, (LUAI_UACNUMBER)*v);
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0xbf9d
cmpq $0x88, %rsi
jne 0xbfb4
movq 0x18(%rdi), %rax
leaq 0x1da6d(%rip), %rcx     # 0x299f8
cmpq %rcx, 0xd0(%rax)
je 0xbfa6
leaq 0x1e094(%rip), %rsi     # 0x2a02f
jmp 0xbfbb
cmpq $0x88, %rsi
jne 0xbfb4
ucomisd 0x1de02(%rip), %xmm0    # 0x29db0
jne 0xbfc2
jp 0xbfc2
popq %rax
retq
leaq 0x1e043(%rip), %rsi     # 0x29ffe
xorl %eax, %eax
callq 0xaa53
leaq 0x1e080(%rip), %rsi     # 0x2a049
movsd 0x1dddf(%rip), %xmm1    # 0x29db0
movb $0x2, %al
callq 0xaa53
// File: /workspace/github_c_makefile_star2_O2/kieselsteini[P]PiXL-old/lua53.c
// Function: luaK_prefix
void luaK_prefix (FuncState *fs, UnOpr op, expdesc *e, int line) {
  static const expdesc ef = {VKINT, {0}, NO_JUMP, NO_JUMP};
  switch (op) {
    case OPR_MINUS: case OPR_BNOT:  /* use 'ef' as fake 2nd operand */
      if (constfolding(fs, op + LUA_OPUNM, e, &ef))
        break;
      /* FALLTHROUGH */
    case OPR_LEN:
      codeunexpval(fs, cast(OpCode, op + OP_UNM), e, line);
      break;
    case OPR_NOT: codenot(fs, e); break;
    default: lua_assert(0);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
cmpl $0x2, %esi
jb 0xcd05
je 0xcd21
cmpl $0x3, %r15d
jne 0xccfc
addl $0x19, %r15d
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc879
movl %eax, %r12d
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc772
shll $0x17, %r12d
orl %r15d, %r12d
movq %rbx, %rdi
movl %r12d, %esi
callq 0xc2f5
movl %eax, 0x8(%r14)
movl $0xc, (%r14)
movq (%rbx), %rax
movq 0x48(%rax), %rax
movslq 0x20(%rbx), %rcx
movl %ebp, -0x4(%rax,%rcx,4)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leal 0xc(%r15), %esi
leaq 0x1cd00(%rip), %rcx     # 0x29a10
movq %rbx, %rdi
movq %r14, %rdx
callq 0xcdc4
testl %eax, %eax
jne 0xccfc
jmp 0xccb3
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc687
movl (%r14), %eax
decl %eax
cmpl $0xb, %eax
ja 0xcd98
leaq 0x1c473(%rip), %rcx     # 0x291b0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x3, (%r14)
jmp 0xcd98
movl $0x2, (%r14)
jmp 0xcd98
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14d5d
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc772
movl 0x8(%r14), %esi
shll $0x17, %esi
orl $0x1b, %esi
movq %rbx, %rdi
callq 0xc2f5
movl %eax, 0x8(%r14)
movl $0xc, (%r14)
jmp 0xcd98
movq %rbx, %rdi
movq %r14, %rsi
callq 0xcb72
movl 0x10(%r14), %esi
movl 0x14(%r14), %eax
movl %esi, 0x14(%r14)
movl %eax, 0x10(%r14)
movq %rbx, %rdi
callq 0x14d8e
movl 0x10(%r14), %esi
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x14d8e
// File: /workspace/github_c_makefile_star2_O2/kieselsteini[P]PiXL-old/lua53.c
// Function: tonumeral
static int tonumeral(const expdesc *e, TValue *v) {
  if (hasjumps(e))
    return 0;  /* not a numeral */
  switch (e->k) {
    case VKINT:
      if (v) setivalue(v, e->u.ival);
      return 1;
    case VKFLT:
      if (v) setfltvalue(v, e->u.nval);
      return 1;
    default: return 0;
  }
}

// Assembly:
movl 0x10(%rdi), %ecx
xorl %eax, %eax
cmpl 0x14(%rdi), %ecx
jne 0xcfac
movl (%rdi), %edx
pushq $0x1
popq %rcx
cmpl $0x5, %edx
je 0xcf96
cmpl $0x6, %edx
jne 0xcfac
testq %rsi, %rsi
je 0xcfaa
pushq $0x13
jmp 0xcf9d
testq %rsi, %rsi
je 0xcfaa
pushq $0x3
popq %rax
movsd 0x8(%rdi), %xmm0
movsd %xmm0, (%rsi)
movl %eax, 0x8(%rsi)
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/kieselsteini[P]PiXL-old/lua53.c
// Function: luaD_shrinkstack
void luaD_shrinkstack (lua_State *L) {
  int inuse = stackinuse(L);
  int goodsize = inuse + (inuse / 8) + 2*EXTRA_STACK;
  if (goodsize > LUAI_MAXSTACK)
    goodsize = LUAI_MAXSTACK;  /* respect stack limit */
  if (L->stacksize > LUAI_MAXSTACK)  /* had been handling stack overflow? */
    luaE_freeCI(L);  /* free all CIs (list grew because of an error) */
  else
    luaE_shrinkCI(L);  /* shrink list */
  /* if thread is currently not handling a stack overflow and its
     good size is smaller than current size, shrink its stack */
  if (inuse <= (LUAI_MAXSTACK - EXTRA_STACK) &&
      goodsize < L->stacksize)
    luaD_reallocstack(L, goodsize);
  else  /* don't change stack */
    condmovestack(L,{},{});  /* (change only for debugging) */
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %r14
leaq 0x20(%rdi), %rax
movq (%rax), %rax
testq %rax, %rax
je 0xdfab
movq 0x8(%rax), %rcx
cmpq %rcx, %r14
cmovbq %rcx, %r14
addq $0x10, %rax
jmp 0xdf92
subq 0x38(%rbx), %r14
shrq $0x4, %r14
leal 0x1(%r14), %eax
pushq $0x8
popq %rcx
cltd
idivl %ecx
addl %r14d, %eax
incl %eax
movl $0xf4236, %ebp          # imm = 0xF4236
cmpl %ebp, %eax
cmovll %eax, %ebp
cmpl $0xf4241, 0xb8(%rbx)    # imm = 0xF4241
jl 0xdfe2
movq %rbx, %rdi
callq 0xe011
jmp 0xdfea
movq %rbx, %rdi
callq 0xe04f
cmpl $0xf423a, %r14d         # imm = 0xF423A
jg 0xe00c
addl $0xa, %ebp
cmpl 0xb8(%rbx), %ebp
jge 0xe00c
movq %rbx, %rdi
movl %ebp, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0xddac
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/kieselsteini[P]PiXL-old/lua53.c
// Function: resume_error
static int resume_error (lua_State *L, const char *msg, int narg) {
  L->top -= narg;  /* remove args from the stack */
  setsvalue2s(L, L->top, luaS_new(L, msg));  /* push error message */
  api_incr_top(L);
  lua_unlock(L);
  return LUA_ERRRUN;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %r14
movslq %edx, %r15
shlq $0x4, %r15
movq %r14, %r12
subq %r15, %r12
movq %r12, 0x10(%rdi)
callq 0x7d9c
movq %rax, (%r12)
movzbl 0x8(%rax), %eax
orl $0x40, %eax
negq %r15
movl %eax, 0x8(%r14,%r15)
addq $0x10, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/kieselsteini[P]PiXL-old/lua53.c
// Function: resume
static void resume (lua_State *L, void *ud) {
  int n = *(cast(int*, ud));  /* number of arguments */
  StkId firstArg = L->top - n;  /* first argument */
  CallInfo *ci = L->ci;
  if (L->status == LUA_OK) {  /* starting a coroutine? */
    if (!luaD_precall(L, firstArg - 1, LUA_MULTRET))  /* Lua function? */
      luaV_execute(L);  /* call it */
  }
  else {  /* resuming from previous yield */
    lua_assert(L->status == LUA_YIELD);
    L->status = LUA_OK;  /* mark that it is running (again) */
    ci->func = restorestack(L, ci->extra);
    if (isLua(ci))  /* yielded inside a hook? */
      luaV_execute(L);  /* just continue running Lua code */
    else {  /* 'common' yield */
      if (ci->u.c.k != NULL) {  /* does it have a continuation function? */
        lua_unlock(L);
        n = (*ci->u.c.k)(L, LUA_YIELD, ci->u.c.ctx); /* call continuation */
        lua_lock(L);
        api_checknelems(L, n);
        firstArg = L->top - n;  /* yield results come from continuation */
      }
      luaD_poscall(L, ci, firstArg, n);  /* finish 'luaD_precall' */
    }
    unroll(L, NULL);  /* run continuation */
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq (%rsi), %rcx
movq %rcx, %rdx
shlq $0x4, %rdx
movq 0x10(%rdi), %rax
subq %rdx, %rax
cmpb $0x0, 0xc(%rdi)
je 0x102c6
movq 0x20(%rbx), %r14
movb $0x0, 0xc(%rbx)
movq 0x38(%rbx), %rdx
addq 0x38(%r14), %rdx
movq %rdx, (%r14)
testb $0x2, 0x42(%r14)
jne 0x102e4
movq 0x20(%r14), %r8
testq %r8, %r8
je 0x102b6
movq 0x30(%r14), %rdx
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq *%r8
movl %eax, %ecx
movq 0x10(%rbx), %rax
movslq %ecx, %rdx
shlq $0x4, %rdx
subq %rdx, %rax
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xe0cd
jmp 0x102ec
addq $-0x10, %rax
pushq $-0x1
popq %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0xe209
testl %eax, %eax
je 0x102fa
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
callq 0xe559
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10309
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xe559
// File: /workspace/github_c_makefile_star2_O2/kieselsteini[P]PiXL-old/lua53.c
// Function: setpath
static void setpath (lua_State *L, const char *fieldname,
                                   const char *envname,
                                   const char *dft) {
  const char *nver = lua_pushfstring(L, "%s%s", envname, LUA_VERSUFFIX);
  const char *path = getenv(nver);  /* use versioned name */
  if (path == NULL)  /* no environment variable? */
    path = getenv(envname);  /* try unversioned name */
  if (path == NULL || noenv(L))  /* no environment variable? */
    lua_pushstring(L, dft);  /* use default */
  else {
    /* replace ";;" by ";AUXMARK;" and then AUXMARK by default path */
    path = luaL_gsub(L, path, LUA_PATH_SEP LUA_PATH_SEP,
                              LUA_PATH_SEP AUXMARK LUA_PATH_SEP);
    luaL_gsub(L, path, AUXMARK, dft);
    lua_remove(L, -2); /* remove result from 1st 'gsub' */
  }
  setprogdir(L);
  lua_setfield(L, -3, fieldname);  /* package[fieldname] = path value */
  lua_pop(L, 1);  /* pop versioned variable name */
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x190b9(%rip), %rsi     # 0x2b1ff
leaq 0x190b7(%rip), %rcx     # 0x2b204
xorl %eax, %eax
callq 0x822d
movq %rax, %rdi
callq 0x65a0
testq %rax, %rax
jne 0x1216e
movq %r13, %rdi
callq 0x65a0
testq %rax, %rax
je 0x12199
movq %rax, %r12
leaq 0x1909a(%rip), %rdx     # 0x2b212
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x86b4
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x78dd
addq $-0x10, 0x10(%rbx)
testl %eax, %eax
je 0x121a6
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7e73
jmp 0x121e7
leaq 0x1905c(%rip), %rdx     # 0x2b209
leaq 0x19058(%rip), %rcx     # 0x2b20c
movq %rbx, %rdi
movq %r12, %rsi
callq 0xbcab
leaq 0x1904a(%rip), %rdx     # 0x2b210
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rcx
callq 0xbcab
pushq $-0x2
popq %rsi
pushq $-0x1
popq %rdx
movq %rbx, %rdi
callq 0x6b97
addq $-0x10, 0x10(%rbx)
pushq $-0x3
popq %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x8e94
addq $-0x10, 0x10(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq