LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/theck01[P]offbrand_lib/src/classes/obmap.c
// Function: obmap_replace_pair_value
void obmap_replace_pair_value(obmap_pair *mp, obj *value){

  assert(mp);

  ob_retain(value);
  ob_release(mp->value);
  mp->value = value;
  return;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1fbe
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x3623
movq 0x10(%r14), %rdi
callq 0x35ee
movq %rbx, 0x10(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x3604(%rip), %rdi      # 0x55c9
leaq 0x34b5(%rip), %rsi      # 0x5481
leaq 0x3623(%rip), %rcx      # 0x55f6
movl $0xf1, %edx
callq 0x1050
// File: /workspace/github_c_makefile_star2_O1/theck01[P]offbrand_lib/src/classes/obmap.c
// Function: obmap_increase_size
void obmap_increase_size(obmap *to_size){

  assert(to_size);
  assert(to_size->cap_idx < NUM_CAPACITIES-1); /* cannot resize beyond largest
                                                  capacity */

  to_size->cap_idx+=2;
  if(to_size->cap_idx >= NUM_CAPACITIES) to_size->cap_idx = NUM_CAPACITIES-1;
  to_size->collisions = 0; /* before resize reset collisions */

  obmap_rehash(to_size);
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x200a
movb 0x8(%rdi), %al
cmpb $0x19, %al
jae 0x2029
leal 0x2(%rax), %ecx
cmpb $0x18, %al
movzbl %cl, %eax
movl $0x19, %ecx
cmovnel %eax, %ecx
movb %cl, 0x8(%rdi)
movl $0x0, 0x20(%rdi)
popq %rax
jmp 0x1d49
leaq 0x3899(%rip), %rdi      # 0x58aa
leaq 0x3469(%rip), %rsi      # 0x5481
leaq 0x3893(%rip), %rcx      # 0x58b2
movl $0x1a6, %edx            # imm = 0x1A6
callq 0x1050
leaq 0x38a4(%rip), %rdi      # 0x58d4
leaq 0x344a(%rip), %rsi      # 0x5481
leaq 0x3874(%rip), %rcx      # 0x58b2
movl $0x1a7, %edx            # imm = 0x1A7
callq 0x1050
// File: /workspace/github_c_makefile_star2_O1/theck01[P]offbrand_lib/src/classes/obmap.c
// Function: obmap_new_pair
obmap_pair * obmap_new_pair(obj *key, obj *value){

  static const char classname[] = "obmap_pair";
  obmap_pair *new_instance = malloc(sizeof(obmap_pair));
  assert(new_instance != NULL);

  /* initialize base class data */
  ob_init_base((obj *)new_instance, &obmap_destroy_pair, &obmap_hash_pair, NULL,
           &obmap_display_pair, classname);

  ob_retain(key);
  new_instance->key = key;
  ob_retain(value);
  new_instance->value = value;

  return new_instance;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
movl $0x18, %edi
callq 0x10b0
testq %rax, %rax
je 0x20ac
movq %rax, %r14
leaq 0x26a(%rip), %rsi       # 0x22d6
leaq 0x2cd(%rip), %rdx       # 0x2340
leaq 0x395(%rip), %r8        # 0x240f
leaq 0x33e7(%rip), %r9       # 0x5468
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x3458
movq %r15, %rdi
callq 0x3623
movq %r15, 0x8(%r14)
movq %rbx, %rdi
callq 0x3623
movq %rbx, 0x10(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x34d8(%rip), %rdi      # 0x558b
leaq 0x33c7(%rip), %rsi      # 0x5481
leaq 0x34df(%rip), %rcx      # 0x55a0
movl $0xda, %edx
callq 0x1050
// File: /workspace/github_c_makefile_star2_O1/theck01[P]offbrand_lib/src/classes/obmap.c
// Function: obmap_add_to_table
void obmap_add_to_table(obmap *m, obdeque_iterator *it){

  ob_hash_t hash_value, offset;
  obmap_pair *pair;

  assert(m);
  assert(it);

  pair = (obmap_pair *)obdeque_obj_at_iterator(m->pairs, it);
  hash_value = ob_hash(pair->key)%MAP_CAPACITIES[m->cap_idx];
  offset = 0;

  while(obvector_obj_at_index(m->hash_table, hash_value)){
    offset = obmap_offset_collision(offset);
    hash_value = (hash_value+offset)%MAP_CAPACITIES[m->cap_idx];
    m->collisions++;
  }

  obvector_store_at_index(m->hash_table, (obj *)it, hash_value);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x2193
movq %rsi, %rbx
testq %rsi, %rsi
je 0x21b2
movq %rdi, %r14
movq 0x18(%rdi), %rdi
movq %rbx, %rsi
callq 0x3816
movq 0x8(%rax), %rdi
callq 0x352c
movzbl 0x8(%r14), %ecx
leaq 0x32e3(%rip), %r12      # 0x53f0
movl (%r12,%rcx,4), %ecx
xorl %edx, %edx
divq %rcx
movq %rdx, %r15
movq 0x10(%r14), %rdi
movq %rdx, %rsi
callq 0x2cbf
testq %rax, %rax
je 0x217b
xorl %r13d, %r13d
testq %r13, %r13
je 0x2140
cmpq $0x1, %r13
jne 0x2148
movl $0x2, %r13d
jmp 0x214f
movl $0x1, %r13d
jmp 0x214f
imulq %r13, %r13
decq %r13
addq %r13, %r15
movzbl 0x8(%r14), %eax
movl (%r12,%rax,4), %ecx
movq %r15, %rax
xorl %edx, %edx
divq %rcx
incl 0x20(%r14)
movq 0x10(%r14), %rdi
movq %rdx, %r15
movq %rdx, %rsi
callq 0x2cbf
testq %rax, %rax
jne 0x212d
movq 0x10(%r14), %rdi
movq %rbx, %rsi
movq %r15, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2add
leaq 0x331c(%rip), %rdi      # 0x54b6
leaq 0x32e0(%rip), %rsi      # 0x5481
leaq 0x3750(%rip), %rcx      # 0x58f8
movl $0x1b7, %edx            # imm = 0x1B7
callq 0x1050
leaq 0x3774(%rip), %rdi      # 0x592d
leaq 0x32c1(%rip), %rsi      # 0x5481
leaq 0x3731(%rip), %rcx      # 0x58f8
movl $0x1b8, %edx            # imm = 0x1B8
callq 0x1050
// File: /workspace/github_c_makefile_star2_O1/theck01[P]offbrand_lib/src/classes/obmap.c
// Function: obmap_lookup
obj * obmap_lookup(const obmap *m, const obj *key){

  obdeque_iterator *it;
  obmap_pair *mp;
  ob_hash_t hash_value;

  assert(m);

  hash_value = obmap_find_key(m, key);
  it = (obdeque_iterator *)obvector_obj_at_index(m->hash_table, hash_value);

  if(!it) return NULL;

  mp = (obmap_pair *)obdeque_obj_at_iterator(m->pairs, it);
  return mp->value;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x2206
movq %rdi, %rbx
callq 0x1edc
movq 0x10(%rbx), %rdi
movq %rax, %rsi
callq 0x2cbf
testq %rax, %rax
je 0x2202
movq 0x18(%rbx), %rdi
movq %rax, %rsi
callq 0x3816
movq 0x10(%rax), %rax
jmp 0x2204
xorl %eax, %eax
popq %rbx
retq
leaq 0x32a9(%rip), %rdi      # 0x54b6
leaq 0x326d(%rip), %rsi      # 0x5481
leaq 0x32eb(%rip), %rcx      # 0x5506
movl $0x91, %edx
callq 0x1050
// File: /workspace/github_c_makefile_star2_O1/theck01[P]offbrand_lib/src/classes/obmap.c
// Function: obmap_remove
void obmap_remove(obmap *m, obj *key){

  obdeque_iterator *it;
  ob_hash_t hash_value;

  assert(m);

  hash_value = obmap_find_key(m, key);
  it = (obdeque_iterator *)obvector_obj_at_index(m->hash_table, hash_value);

  if(!it) return;

  obdeque_remove_at_iterator(m->pairs, it);
  obmap_rehash(m);

  return;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x225b
movq %rdi, %rbx
callq 0x1edc
movq 0x10(%rbx), %rdi
movq %rax, %rsi
callq 0x2cbf
testq %rax, %rax
je 0x2259
movq 0x18(%rbx), %rdi
movq %rax, %rsi
callq 0x439b
movq %rbx, %rdi
popq %rbx
jmp 0x1d49
popq %rbx
retq
leaq 0x3254(%rip), %rdi      # 0x54b6
leaq 0x3218(%rip), %rsi      # 0x5481
leaq 0x32c4(%rip), %rcx      # 0x5534
movl $0xa2, %edx
callq 0x1050
// File: /workspace/github_c_makefile_star2_O1/theck01[P]offbrand_lib/src/classes/obmap.c
// Function: obmap_clear
void obmap_clear(obmap *m){

  assert(m);

  ob_release((obj *)m->hash_table);
  ob_release((obj *)m->pairs);

  m->hash_table = obvector_new(MAP_CAPACITIES[m->cap_idx]);
  m->pairs = obdeque_new();
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x22b7
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x35ee
movq 0x18(%rbx), %rdi
callq 0x35ee
movzbl 0x8(%rbx), %eax
leaq 0x3150(%rip), %rcx      # 0x53f0
movl (%rcx,%rax,4), %edi
callq 0x2954
movq %rax, 0x10(%rbx)
callq 0x36cc
movq %rax, 0x18(%rbx)
popq %rbx
retq
leaq 0x31f8(%rip), %rdi      # 0x54b6
leaq 0x31bc(%rip), %rsi      # 0x5481
leaq 0x32a5(%rip), %rcx      # 0x5571
movl $0xca, %edx
callq 0x1050
// File: /workspace/github_c_makefile_star2_O1/theck01[P]offbrand_lib/src/classes/obmap.c
// Function: obmap_destroy_pair
void obmap_destroy_pair(obj *to_dealloc){

  /* cast generic obj to obmap */
  obmap_pair *instance = (obmap_pair *)to_dealloc;

  assert(to_dealloc);
  assert(ob_has_class(to_dealloc, "obmap_pair"));

  ob_release((obj *)instance->key);
  ob_release((obj *)instance->value);

  return;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x2302
movq %rdi, %rbx
leaq 0x3182(%rip), %rsi      # 0x5468
callq 0x3668
testb %al, %al
je 0x2321
movq 0x8(%rbx), %rdi
callq 0x35ee
movq 0x10(%rbx), %rdi
popq %rbx
jmp 0x35ee
leaq 0x33e2(%rip), %rdi      # 0x56eb
leaq 0x3171(%rip), %rsi      # 0x5481
leaq 0x33df(%rip), %rcx      # 0x56f6
movl $0x12a, %edx            # imm = 0x12A
callq 0x1050
leaq 0x33ed(%rip), %rdi      # 0x5715
leaq 0x3152(%rip), %rsi      # 0x5481
leaq 0x33c0(%rip), %rcx      # 0x56f6
movl $0x12b, %edx            # imm = 0x12B
callq 0x1050
// File: /workspace/github_c_makefile_star2_O1/theck01[P]offbrand_lib/src/classes/obmap.c
// Function: obmap_hash_pair
ob_hash_t obmap_hash_pair(const obj *to_hash){

  static int8_t init = 0;
  static ob_hash_t seed = 0;

  ob_hash_t value;
  obmap_pair *instance = (obmap_pair *)to_hash;

  assert(to_hash);
  assert(ob_has_class(to_hash, "obmap_pair"));

  if(init == 0){
    srand(time(NULL));
    seed = rand();
    init = 1;
  }

  value = seed;

  value += ob_hash(instance->key);
  value += ob_hash(instance->value);

  value += value << 3;
  value ^= value >> 11;
  value += value << 15;

  return value;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x23d1
movq %rdi, %rbx
leaq 0x3110(%rip), %rsi      # 0x5468
callq 0x3668
testb %al, %al
je 0x23f0
cmpb $0x0, 0x6d1c(%rip)      # 0x9088
jne 0x2391
xorl %edi, %edi
callq 0x10a0
movl %eax, %edi
callq 0x1070
callq 0x10d0
cltq
movq %rax, 0x6d06(%rip)      # 0x9090
movb $0x1, 0x6cf7(%rip)      # 0x9088
movq 0x6cf8(%rip), %r15      # 0x9090
movq 0x8(%rbx), %rdi
callq 0x352c
movq %rax, %r14
addq %r15, %r14
movq 0x10(%rbx), %rdi
callq 0x352c
addq %r14, %rax
leaq (%rax,%rax,8), %rax
movq %rax, %rcx
shrq $0xb, %rcx
xorq %rax, %rcx
movq %rcx, %rax
shlq $0xf, %rax
addq %rcx, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x3251(%rip), %rdi      # 0x5629
leaq 0x30a2(%rip), %rsi      # 0x5481
leaq 0x324b(%rip), %rcx      # 0x5631
movl $0x101, %edx            # imm = 0x101
callq 0x1050
leaq 0x3261(%rip), %rdi      # 0x5658
leaq 0x3083(%rip), %rsi      # 0x5481
leaq 0x322c(%rip), %rcx      # 0x5631
movl $0x102, %edx            # imm = 0x102
callq 0x1050
// File: /workspace/github_c_makefile_star2_O1/theck01[P]offbrand_lib/src/classes/obmap.c
// Function: obmap_display_pair
void obmap_display_pair(const obj *to_print){

  obmap_pair *mp = (obmap_pair *)to_print;

  assert(to_print != NULL);
  assert(ob_has_class(to_print, "obmap_pair"));

  fprintf(stderr, "  [key]\n");
  ob_display(mp->key);
  fprintf(stderr, "  [value]\n");
  ob_display(mp->value);
  return;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x2432
movq %rdi, %rbx
leaq 0x3049(%rip), %rsi      # 0x5468
callq 0x3668
testb %al, %al
je 0x2451
movq %rbx, %rdi
callq 0x10f0
popq %rbx
retq
leaq 0x3243(%rip), %rdi      # 0x567c
leaq 0x3041(%rip), %rsi      # 0x5481
leaq 0x3246(%rip), %rcx      # 0x568d
movl $0x11a, %edx            # imm = 0x11A
callq 0x1050
leaq 0x325a(%rip), %rdi      # 0x56b2
leaq 0x3022(%rip), %rsi      # 0x5481
leaq 0x3227(%rip), %rcx      # 0x568d
movl $0x11b, %edx            # imm = 0x11B
callq 0x1050
// File: /workspace/github_c_makefile_star2_O1/theck01[P]offbrand_lib/src/classes/obmap.c
// Function: obmap_destroy
void obmap_destroy(obj *to_dealloc){

  /* cast generic obj to obmap */
  obmap *instance = (obmap *)to_dealloc;

  assert(to_dealloc);
  assert(ob_has_class(to_dealloc, "obmap"));

  ob_release((obj *)instance->hash_table);
  ob_release((obj *)instance->pairs);

  return;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x249c
movq %rdi, %rbx
leaq 0x2ff3(%rip), %rsi      # 0x5473
callq 0x3668
testb %al, %al
je 0x24bb
movq 0x10(%rbx), %rdi
callq 0x35ee
movq 0x18(%rbx), %rdi
popq %rbx
jmp 0x35ee
leaq 0x3248(%rip), %rdi      # 0x56eb
leaq 0x2fd7(%rip), %rsi      # 0x5481
leaq 0x33bd(%rip), %rcx      # 0x586e
movl $0x19a, %edx            # imm = 0x19A
callq 0x1050
leaq 0x33c6(%rip), %rdi      # 0x5888
leaq 0x2fb8(%rip), %rsi      # 0x5481
leaq 0x339e(%rip), %rcx      # 0x586e
movl $0x19b, %edx            # imm = 0x19B
callq 0x1050
// File: /workspace/github_c_makefile_star2_O1/theck01[P]offbrand_lib/src/classes/obmap.c
// Function: obmap_hash
ob_hash_t obmap_hash(const obj *to_hash){

  static int8_t init = 0;
  static ob_hash_t seed = 0;

  ob_hash_t value;
  obdeque_iterator *it;
  obmap *instance = (obmap *)to_hash;

  assert(to_hash);
  assert(ob_has_class(to_hash, "obmap"));

  if(init == 0){
    srand(time(NULL));
    seed = rand();
    init = 1;
  }

  value = seed;

  it = obdeque_head_iterator(instance->pairs);
  if(!it) return value;

  /* perform commutative hash, so order of addition to table does not matter */
  do{
    value += ob_hash(obdeque_obj_at_iterator(instance->pairs, it));
  }while(obdeque_iterate_next(instance->pairs, it));

  ob_release((obj *)it);

  value += value << 3;
  value ^= value >> 11;
  value += value << 15;

  return value;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x2593
movq %rdi, %rbx
leaq 0x2f81(%rip), %rsi      # 0x5473
callq 0x3668
testb %al, %al
je 0x25b2
cmpb $0x0, 0x6b92(%rip)      # 0x9098
jne 0x252b
xorl %edi, %edi
callq 0x10a0
movl %eax, %edi
callq 0x1070
callq 0x10d0
cltq
movq %rax, 0x6b7c(%rip)      # 0x90a0
movb $0x1, 0x6b6d(%rip)      # 0x9098
movq 0x6b6e(%rip), %r14      # 0x90a0
movq 0x18(%rbx), %rdi
callq 0x37e8
testq %rax, %rax
je 0x258a
movq %rax, %r15
movq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0x3816
movq %rax, %rdi
callq 0x352c
addq %rax, %r14
movq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0x390f
testb %al, %al
jne 0x2543
movq %r15, %rdi
callq 0x35ee
leaq (%r14,%r14,8), %rax
movq %rax, %rcx
shrq $0xb, %rcx
xorq %rax, %rcx
movq %rcx, %r14
shlq $0xf, %r14
addq %rcx, %r14
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x308f(%rip), %rdi      # 0x5629
leaq 0x2ee0(%rip), %rsi      # 0x5481
leaq 0x31b6(%rip), %rcx      # 0x575e
movl $0x153, %edx            # imm = 0x153
callq 0x1050
leaq 0x31c7(%rip), %rdi      # 0x5780
leaq 0x2ec1(%rip), %rsi      # 0x5481
leaq 0x3197(%rip), %rcx      # 0x575e
movl $0x154, %edx            # imm = 0x154
callq 0x1050
// File: /workspace/github_c_makefile_star2_O1/theck01[P]offbrand_lib/src/classes/obmap.c
// Function: obmap_compare
int8_t obmap_compare(const obj *a, const obj *b){

  assert(a);
  assert(b);
  assert(ob_has_class(a, "obmap"));
  assert(ob_has_class(b, "obmap"));

  if(ob_hash(a) == ob_hash(b)) return OB_EQUAL_TO;
  return OB_NOT_EQUAL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x262f
movq %rsi, %rbx
testq %rsi, %rsi
je 0x264e
movq %rdi, %r14
leaq 0x2e87(%rip), %rsi      # 0x5473
callq 0x3668
testb %al, %al
je 0x266d
leaq 0x2e77(%rip), %rsi      # 0x5473
movq %rbx, %rdi
callq 0x3668
testb %al, %al
je 0x268c
movq %r14, %rdi
callq 0x352c
movq %rax, %r14
movq %rbx, %rdi
callq 0x352c
cmpq %rax, %r14
setne %al
addb %al, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x3169(%rip), %rdi      # 0x579f
leaq 0x2e44(%rip), %rsi      # 0x5481
leaq 0x315d(%rip), %rcx      # 0x57a1
movl $0x172, %edx            # imm = 0x172
callq 0x1050
leaq 0x317b(%rip), %rdi      # 0x57d0
leaq 0x2e25(%rip), %rsi      # 0x5481
leaq 0x313e(%rip), %rcx      # 0x57a1
movl $0x173, %edx            # imm = 0x173
callq 0x1050
leaq 0x315e(%rip), %rdi      # 0x57d2
leaq 0x2e06(%rip), %rsi      # 0x5481
leaq 0x311f(%rip), %rcx      # 0x57a1
movl $0x174, %edx            # imm = 0x174
callq 0x1050
leaq 0x3158(%rip), %rdi      # 0x57eb
leaq 0x2de7(%rip), %rsi      # 0x5481
leaq 0x3100(%rip), %rcx      # 0x57a1
movl $0x175, %edx            # imm = 0x175
callq 0x1050
// File: /workspace/github_c_makefile_star2_O1/theck01[P]offbrand_lib/src/classes/obmap.c
// Function: obmap_display
void obmap_display(const obj *to_print){

  obmap *m = (obmap *)to_print;
  obdeque_iterator *it;

  assert(to_print != NULL);
  assert(ob_has_class(to_print, "obmap"));
  fprintf(stderr, "obmap with key-value pairs:\n");

  it = obdeque_head_iterator(m->pairs);

  if(!it) return;

  do{
    ob_display(obdeque_obj_at_iterator(m->pairs, it));
  }while(obdeque_iterate_next(m->pairs, it));

  fprintf(stderr, "  [map end]\n");

  ob_release((obj *)it);

  return;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x26ce
movq %rdi, %rbx
leaq 0x2db8(%rip), %rsi      # 0x5473
callq 0x3668
testb %al, %al
je 0x26ed
movq %rbx, %rdi
callq 0x1144
popq %rbx
retq
leaq 0x2fa7(%rip), %rdi      # 0x567c
leaq 0x2da5(%rip), %rsi      # 0x5481
leaq 0x3121(%rip), %rcx      # 0x5804
movl $0x181, %edx            # imm = 0x181
callq 0x1050
leaq 0x3130(%rip), %rdi      # 0x5824
leaq 0x2d86(%rip), %rsi      # 0x5481
leaq 0x3102(%rip), %rcx      # 0x5804
movl $0x182, %edx            # imm = 0x182
callq 0x1050
// File: /workspace/github_c_makefile_star2_O1/pocari[P]compilerbook-9cc/codegen.c
// Function: printfln
static int printfln(char *fmt, ...) {
  va_list ap;
  va_start(ap, fmt);
  int n = vprintf(fmt, ap);
  putchar('\n');

  return n + 1;
}

// Assembly:
subq $0xd8, %rsp
leaq 0x20(%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 0x2810
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rsi
movq %r10, 0x10(%rsi)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rsi)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rsi)
callq 0x2160
movl $0xa, %edi
callq 0x2040
addq $0xd8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/pocari[P]compilerbook-9cc/codegen.c
// Function: load
static void load(Type *t) {
  printfln("  pop rax"); // スタックにつまれている、変数のアドレスをraxにロード
  // 変数のアドレスにある値をraxにロード
  int sz = t->size;
  if (sz == 1) {
    printfln("  movsx rax, BYTE PTR [rax]");
  } else if (sz == 2) {
    printfln("  movsx rax, WORD PTR [rax]");
  } else if (sz == 4) {
    printfln("  movsxd rax, DWORD PTR [rax]");
  } else if (sz == 8) {
    printfln("  mov rax, [rax]");
  } else {
    assert(false);
  }

  printfln("  push rax"); // 変数の値(rax)をスタックに積む
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x7ac0(%rip), %rdi      # 0xb468
xorl %eax, %eax
callq 0x27b5
movl 0x4(%rbx), %eax
decl %eax
cmpl $0x8, %eax
jae 0x39e9
movl $0x8b, %ecx
btl %eax, %ecx
jae 0x39e9
movl %eax, %eax
leaq 0x7788(%rip), %rcx      # 0xb154
movslq (%rcx,%rax,4), %rdi
addq %rcx, %rdi
xorl %eax, %eax
callq 0x27b5
leaq 0x79d2(%rip), %rdi      # 0xb3b3
xorl %eax, %eax
popq %rbx
jmp 0x27b5
leaq 0x7932(%rip), %rdi      # 0xb322
leaq 0x7903(%rip), %rsi      # 0xb2fa
leaq 0x838a(%rip), %rcx      # 0xbd88
movl $0x27, %edx
callq 0x20d0
// File: /workspace/github_c_makefile_star2_O1/pocari[P]compilerbook-9cc/codegen.c
// Function: store
static void store(Type *t) {
  printfln("  pop rdi"); // rhsの結果
  printfln("  pop rax"); // 左辺の変数のアドレス

  if (t->kind == TY_BOOL) {
    // booleanの場合はrdiが
    // 0のときは0
    // それ以外は固定で1をrdiに設定する
    printfln("  cmp rdi, 0");
    // cmp の比較で rdi != 0 のときだけ rdiの下位8bit に1をセット
    printfln("  setne dil");
    // rdiの上位56bitはクリアして1を代入
    printfln("  movzb rdi, dil");
  }

  int sz = t->size;
  // 左辺の変数にrhsの結果を代入
  if (sz == 1) {
    printfln("  mov [rax], dil");
  } else if (sz == 2) {
    printfln("  mov [rax], di");
  } else if (sz == 4) {
    printfln("  mov [rax], edi");
  } else if (sz == 8) {
    printfln("  mov [rax], rdi");
  } else {
    assert(false);
  }
  printfln("  push rdi"); // この代入結果自体もスタックに積む(右結合でどんどん左に伝搬していくときの右辺値になる)
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x8387(%rip), %rdi      # 0xbd9a
xorl %eax, %eax
callq 0x27b5
leaq 0x7a47(%rip), %rdi      # 0xb468
xorl %eax, %eax
callq 0x27b5
cmpl $0x2, (%rbx)
jne 0x3a57
leaq 0x8370(%rip), %rdi      # 0xbda4
xorl %eax, %eax
callq 0x27b5
leaq 0x836f(%rip), %rdi      # 0xbdb1
xorl %eax, %eax
callq 0x27b5
leaq 0x836d(%rip), %rdi      # 0xbdbd
xorl %eax, %eax
callq 0x27b5
movl 0x4(%rbx), %eax
decl %eax
cmpl $0x8, %eax
jae 0x3a91
movl $0x8b, %ecx
btl %eax, %ecx
jae 0x3a91
movl %eax, %eax
leaq 0x7700(%rip), %rcx      # 0xb174
movslq (%rcx,%rax,4), %rdi
addq %rcx, %rdi
xorl %eax, %eax
callq 0x27b5
leaq 0x839b(%rip), %rdi      # 0xbe24
xorl %eax, %eax
popq %rbx
jmp 0x27b5
leaq 0x788a(%rip), %rdi      # 0xb322
leaq 0x785b(%rip), %rsi      # 0xb2fa
leaq 0x836b(%rip), %rcx      # 0xbe11
movl $0x48, %edx
callq 0x20d0
// File: /workspace/github_c_makefile_star2_O1/pocari[P]compilerbook-9cc/codegen.c
// Function: inc
static void inc(Type *ty) {
  printfln("  pop rax");
  // ポインタの場合はそのポインタが指す先の型のサイズ分インクリメントする。(int *x; x++ が4バイト先に進むような場合)
  // ポインタでない場合は単に値を1増やす int i = 0; i++; でiが1になる みたいな場合
  printfln("  add rax, %ld\n", ty->ptr_to ? ty->ptr_to->size : 1);
  printfln("  push rax");
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x79ad(%rip), %rdi      # 0xb468
xorl %eax, %eax
callq 0x27b5
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x3ad0
movl 0x4(%rax), %esi
jmp 0x3ad5
movl $0x1, %esi
leaq 0x8390(%rip), %rdi      # 0xbe6c
xorl %eax, %eax
callq 0x27b5
leaq 0x78c9(%rip), %rdi      # 0xb3b3
xorl %eax, %eax
popq %rbx
jmp 0x27b5
// File: /workspace/github_c_makefile_star2_O1/pocari[P]compilerbook-9cc/debug.c
// Function: node_ast_helper
char *node_ast_helper(Node *body) {
  char *tmp_bufs[1000];// 文の数
  char buf[10000];// ast dumpの文字列バッファ

  int n = 0;
  int i = 0;

  n += sprintf(buf + n, "\n");
  for (Node *nd = body; nd; nd = nd->next) {
    char *tmp = tmp_bufs[i] = node_ast(nd);
    n += sprintf(buf + n, "##   %s\n", tmp);
  }
  char *ret = my_strndup(buf, n);
  for (int j = 0; j < i; j++) {
    free(tmp_bufs[j]);
  }
  return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x2710, %rsp           # imm = 0x2710
movw $0xa, (%rsp)
testq %rdi, %rdi
je 0x462e
movq %rdi, %r14
movl $0x1, %ebx
leaq 0x7f5b(%rip), %r15      # 0xc560
movq %r14, %rdi
callq 0x3d2c
movslq %ebx, %rbx
leaq (%rsp,%rbx), %rdi
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x21c0
addl %eax, %ebx
movq 0x30(%r14), %r14
testq %r14, %r14
jne 0x4605
jmp 0x4633
movl $0x1, %ebx
movq %rsp, %rdi
movl %ebx, %esi
callq 0x4ae3
addq $0x2710, %rsp           # imm = 0x2710
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/pocari[P]compilerbook-9cc/debug.c
// Function: function_body_ast
char *function_body_ast(Function *f) {
  int n = 0;
  char buf[10000];

  char *ti = type_info(f->return_type);
  n = sprintf(buf + n, "(def (%s) %s (", ti, f->name);
  free(ti);

  int i = 0;
  VarList* reverse_params = NULL;
  // f->paramsは最後の引数からのリンクリストになってるのでダンプ用には逆順にする。
  for (VarList *cur = f->params; cur; cur = cur->next) {
    VarList *vl = calloc(1, sizeof(VarList));
    vl->next = reverse_params;
    vl->var = cur->var;
    reverse_params = vl;
  }

  // 逆順にしたリストからastダンプ
  for (VarList *p = reverse_params; p; p = p->next) {
    char *ti = type_info(p->var->type);
    n += sprintf(buf + n, "%s %s", ti, p->var->name);
    free(ti);
    if (p->next) {
      n += sprintf(buf + n, " ");
    }
  }
  // 逆順のリストはもういらないので捨てる。(そこに紐づくLVar は別途freeされるので無視する)
  VarList *rp = reverse_params;
  while (rp) {
    VarList *tmp = rp->next;
    free(rp);
    rp = tmp;
  }

  char *body_ast = node_ast_helper(f->body);
  n += sprintf(buf + n, ") ( %s", body_ast);
  n += sprintf(buf + n, "## ))");
  free(body_ast);

  return my_strndup(buf, n);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4e38, %rsp           # imm = 0x4E38
movq %rdi, %r15
movq 0x8(%rdi), %rdx
leaq 0x2720(%rsp), %r14
xorl %ebx, %ebx
movq %r14, %rdi
xorl %esi, %esi
callq 0x3b56
movq %r14, %rdi
movl %eax, %esi
callq 0x4ae3
movq %rax, %r12
movq 0x10(%r15), %rcx
leaq 0x7edb(%rip), %rsi      # 0xc569
leaq 0x10(%rsp), %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x21c0
movl %eax, %r14d
movq %r12, %rdi
callq 0x2030
movq %r15, 0x8(%rsp)
movq 0x28(%r15), %r15
testq %r15, %r15
je 0x46e1
xorl %r12d, %r12d
movl $0x1, %edi
movl $0x10, %esi
callq 0x2100
movq %rax, %rbx
movq %r12, (%rax)
movq 0x8(%r15), %rax
movq %rax, 0x8(%rbx)
movq (%r15), %r15
movq %rbx, %r12
testq %r15, %r15
jne 0x46b9
testq %rbx, %rbx
je 0x475d
leaq 0x2720(%rsp), %r12
leaq 0x7e83(%rip), %r13      # 0xc578
movq %rbx, %r15
movq 0x8(%r15), %rax
movq (%rax), %rdx
movq %r12, %rdi
xorl %esi, %esi
callq 0x3b56
movq %r12, %rdi
movl %eax, %esi
callq 0x4ae3
movq %rax, %rbp
movslq %r14d, %r14
leaq (%rsp,%r14), %rdi
addq $0x10, %rdi
movq 0x8(%r15), %rax
movq 0x8(%rax), %rcx
movq %r13, %rsi
movq %rbp, %rdx
xorl %eax, %eax
callq 0x21c0
addl %eax, %r14d
movq %rbp, %rdi
callq 0x2030
cmpq $0x0, (%r15)
je 0x4755
movslq %r14d, %r14
movw $0x20, 0x10(%rsp,%r14)
incl %r14d
movq (%r15), %r15
testq %r15, %r15
jne 0x46f8
testq %rbx, %rbx
je 0x4775
movq (%rbx), %r15
movq %rbx, %rdi
callq 0x2030
movq %r15, %rbx
testq %r15, %r15
jne 0x4762
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x45df
movq %rax, %rbx
movslq %r14d, %r14
leaq (%rsp,%r14), %rdi
addq $0x10, %rdi
leaq 0x7de6(%rip), %rsi      # 0xc57e
movq %rax, %rdx
xorl %eax, %eax
callq 0x21c0
leal (%rax,%r14), %ecx
movslq %ecx, %rcx
movl $0x29202323, 0x10(%rsp,%rcx) # imm = 0x29202323
movw $0x29, 0x14(%rsp,%rcx)
leal (%rax,%r14), %ebp
addl $0x5, %ebp
movq %rbx, %rdi
callq 0x2030
leaq 0x10(%rsp), %rdi
movl %ebp, %esi
callq 0x4ae3
addq $0x4e38, %rsp           # imm = 0x4E38
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/pocari[P]compilerbook-9cc/debug.c
// Function: dump_globals
void dump_globals(VarList *vars) {
  VarList *v = vars;
  while (v) {
    Node *dummy = calloc(1, sizeof(Node));
    dummy->kind = ND_VAR_DECL; // ローカル変数の宣言のダンプを使い回す
    dummy->var = v->var;
    printf("## %s\n", node_ast(dummy));
    v = v->next;
  }
}

// Assembly:
testq %rdi, %rdi
je 0x485c
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x7d70(%rip), %r14      # 0xc58b
movl $0x1, %edi
movl $0xc8, %esi
callq 0x2100
movl $0x20, (%rax)
movq 0x8(%rbx), %rcx
movq %rcx, 0x78(%rax)
movq %rax, %rdi
callq 0x3d2c
movq %r14, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x20c0
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0x481b
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/pocari[P]compilerbook-9cc/parser.c
// Function: error_at
void error_at(char *loc, char *fmt, ...) {
  va_list ap;
  va_start(ap, fmt);

  int column = get_pos_by_line(loc);
  fprintf(stderr, "file: %s\n", filename);
  fprintf(stderr, "%s\n", get_error_lines(loc));
  fprintf(stderr, "%*s", column, "");
  fprintf(stderr, "^ ");
  vfprintf(stderr, fmt, ap);
  fprintf(stderr, "\n");

  exit(1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x20(%rsp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x48e3
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %r14
movq %rsi, 0x10(%r14)
leaq 0x110(%rsp), %rax
movq %rax, 0x8(%r14)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%r14)
callq 0x49a9
movl %eax, %ebp
movq 0xb6e7(%rip), %r13      # 0xfff8
movq (%r13), %rdi
leaq 0xbb54(%rip), %rax      # 0x10470
movq (%rax), %rdx
leaq 0x7d2e(%rip), %rsi      # 0xc654
xorl %eax, %eax
callq 0x2120
movq (%r13), %r12
movq %r15, %rdi
callq 0x49d0
leaq 0x7c25(%rip), %rsi      # 0xc565
movq %r12, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x2120
movq (%r13), %rdi
leaq 0x7d06(%rip), %rsi      # 0xc65e
leaq 0x752c(%rip), %rcx      # 0xbe8b
movl %ebp, %edx
xorl %eax, %eax
callq 0x2120
movq (%r13), %rcx
leaq 0x7cef(%rip), %rdi      # 0xc662
movl $0x2, %esi
movl $0x1, %edx
callq 0x21e0
movq (%r13), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x21b0
movq (%r13), %rsi
movl $0xa, %edi
callq 0x20f0
movl $0x1, %edi
callq 0x21d0
// File: /workspace/github_c_makefile_star2_O1/pocari[P]compilerbook-9cc/parser.c
// Function: get_pos_by_line
static int get_pos_by_line(char *loc) {
  // locがその行で何桁目か返す
  char *p = user_input;
  int column = 0;

  while (p != loc) {
    if (*p == '\n') {
      column = 0;
    } else {
      column++;
    }
    p++;
  }

  return column;
}

// Assembly:
leaq 0xbac8(%rip), %rax      # 0x10478
movq (%rax), %rcx
cmpq %rdi, %rcx
je 0x49cd
xorl %edx, %edx
xorl %eax, %eax
incl %eax
cmpb $0xa, (%rcx)
cmovel %edx, %eax
incq %rcx
cmpq %rdi, %rcx
jne 0x49bc
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/pocari[P]compilerbook-9cc/parser.c
// Function: get_error_lines
static char *get_error_lines(char *loc) {
  int pos = 0;
  char *p = user_input;

  while (p != loc) {
    pos++;
    p++;
  }

  // locまできたら、その行の行末または文字列の最後まですすめる
  while (*p && *p != '\n') {
    pos++;
    p++;
  }

  return my_strndup(user_input, pos);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0xba9c(%rip), %rax      # 0x10478
movq (%rax), %r14
movl %edi, %ebx
subl %r14d, %ebx
xorl %eax, %eax
subq %r14, %rdi
cmovel %eax, %ebx
cmovneq %rdi, %rax
addq %r14, %rax
movzbl (%rax), %ecx
testl %ecx, %ecx
je 0x4a07
cmpl $0xa, %ecx
je 0x4a07
incq %rax
incq %rbx
jmp 0x49f3
leal 0x1(%rbx), %edi
movl $0x1, %esi
callq 0x2100
movq %rax, %r15
testl %ebx, %ebx
je 0x4a2b
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2150
jmp 0x4a2d
xorl %ebx, %ebx
movb $0x0, (%r15,%rbx)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/pocari[P]compilerbook-9cc/parser.c
// Function: my_strndup
char *my_strndup(char *str, int len) {
  char *buf = calloc(len + 1, sizeof(char));

  int i;
  for (i = 0; i < len; i++) {
    buf[i] = str[i];
  }
  buf[i] = '\0';

  return buf;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %r15d
movq %rdi, %r14
leal 0x1(%r15), %eax
movslq %eax, %rdi
movl $0x1, %esi
callq 0x2100
movq %rax, %rbx
testl %r15d, %r15d
jle 0x4b1a
movl %r15d, %r15d
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2150
jmp 0x4b1d
xorl %r15d, %r15d
movb $0x0, (%rbx,%r15)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/pocari[P]compilerbook-9cc/parser.c
// Function: consume_end
static Token *consume(char *op) {
  Token *tk = token;
  if (!peek_token(op)) {
    return NULL;
  }
  token = token->next;
  return tk;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x7b2f(%rip), %rdi      # 0xc665
callq 0x5244
testb %al, %al
je 0x4b57
leaq 0xb93a(%rip), %rax      # 0x10480
movq (%rax), %rcx
movq 0x8(%rcx), %rdx
movq %rdx, (%rax)
movb $0x1, %al
testq %rcx, %rcx
jne 0x4ba3
leaq 0xb922(%rip), %rbx      # 0x10480
movq (%rbx), %r14
leaq 0x7aff(%rip), %rdi      # 0xc667
callq 0x5244
testb %al, %al
je 0x4b9e
movq 0x8(%r14), %rax
movq %rax, (%rbx)
testq %r14, %r14
je 0x4b9e
leaq 0x7ae1(%rip), %rdi      # 0xc665
callq 0x5244
testb %al, %al
je 0x4b9e
movq (%rbx), %rcx
movq 0x8(%rcx), %rax
movq %rax, (%rbx)
movb $0x1, %al
testq %rcx, %rcx
jne 0x4ba3
movq %r14, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/pocari[P]compilerbook-9cc/parser.c
// Function: peek_end
bool peek_end() {
  Token *tmp = token;
  bool result = false;

  if (consume("}")) {
    result = true;
  } else if (consume(",") && consume("}")) {
    result =  true;;
  }

  token = tmp;
  return result;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0xb8ca(%rip), %rbx      # 0x10480
movq (%rbx), %r14
leaq 0x7aa5(%rip), %rdi      # 0xc665
callq 0x5244
testb %al, %al
je 0x4bd7
movq 0x8(%r14), %rax
movq %rax, (%rbx)
movb $0x1, %al
testq %r14, %r14
jne 0x4c1a
leaq 0x7a89(%rip), %rdi      # 0xc667
callq 0x5244
testb %al, %al
je 0x4c18
movq (%rbx), %rax
movq 0x8(%rax), %rcx
movq %rcx, (%rbx)
testq %rax, %rax
je 0x4c18
leaq 0x7a68(%rip), %rdi      # 0xc665
callq 0x5244
testb %al, %al
je 0x4c18
movq (%rbx), %rax
movq 0x8(%rax), %rcx
movq %rcx, (%rbx)
testq %rax, %rax
setne %al
jmp 0x4c1a
xorl %eax, %eax
movq %r14, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/pocari[P]compilerbook-9cc/parser.c
// Function: new_var_node
Node *new_var_node(Var *var, Token *tk) {
  Node *node = new_node(ND_VAR, tk);
  node->var = var;
  add_type(node);
  return node;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %edi
movl $0xc8, %esi
callq 0x2100
movq %rax, %r15
movl $0x17, (%rax)
movq %rbx, 0x8(%rax)
movq %r14, 0x78(%rax)
movq %rax, %rdi
callq 0xa308
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/pocari[P]compilerbook-9cc/parser.c
// Function: peek_token
static bool peek_token(char *op) {
  if (token->kind != TK_RESERVED ||
      token->len != strlen(op) ||
      memcmp(token->str, op, token->len)) {
    return false;
  }
  return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0xb230(%rip), %rax      # 0x10480
movq (%rax), %r15
cmpl $0x1, (%r15)
jne 0x5280
movq %rdi, %rbx
movslq 0x20(%r15), %r14
callq 0x20b0
cmpq %r14, %rax
jne 0x5280
movq 0x18(%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2170
testl %eax, %eax
sete %al
jmp 0x5282
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/pocari[P]compilerbook-9cc/parser.c
// Function: declarator
static Type *declarator(Type *ty, char **name) {
  while (consume("*")) {
    ty = pointer_to(ty);
  }
  if (consume("(")) {
    Type *placeholder = calloc(1, sizeof(Type));
    Type *new_ty = declarator(placeholder, name);
    expect(")");
    // 入れ子部分を全部パースした後に、その後に続く配列の [] などを含めた(type_suffix)型としてplaceholderを完成させる
    memcpy(placeholder, type_suffix(ty), sizeof(Type));
    return new_ty;
  }

  *name = expect_ident();
  return type_suffix(ty);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x7402(%rip), %rdi      # 0xcde7
callq 0x5244
testb %al, %al
je 0x5a24
leaq 0xaa8b(%rip), %r12      # 0x10480
leaq 0x73eb(%rip), %r15      # 0xcde7
movq (%r12), %rax
movq 0x8(%rax), %rcx
movq %rcx, (%r12)
testq %rax, %rax
je 0x5a24
movq %rbx, %rdi
callq 0xa1fc
movq %rax, %rbx
movq %r15, %rdi
callq 0x5244
testb %al, %al
jne 0x59fc
leaq 0x6b4b(%rip), %rdi      # 0xc576
callq 0x5244
testb %al, %al
je 0x5aa6
leaq 0xaa45(%rip), %rax      # 0x10480
movq (%rax), %rcx
movq 0x8(%rcx), %rdx
movq %rdx, (%rax)
testq %rcx, %rcx
je 0x5aa6
movl $0x1, %edi
movl $0x30, %esi
callq 0x2100
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x59d0
movq %rax, %r14
leaq 0x6b18(%rip), %rdi      # 0xc589
callq 0x5c3c
movq %rbx, %rdi
callq 0x6fa2
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movups %xmm0, (%r15)
movups %xmm1, 0x10(%r15)
movups %xmm2, 0x20(%r15)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x5cc0
movq %rax, (%r14)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x6fa2
// File: /workspace/github_c_makefile_star2_O1/pocari[P]compilerbook-9cc/parser.c
// Function: find_typedef
static Type *find_typedef(Token *tk) {
  for (VarScope *sc = var_scope; sc; sc = sc->next) {
    if (sc->var) {
      // var はtypedefじゃないので無視
      continue;
    }

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0xa970(%rip), %r12      # 0x10440
testq %r12, %r12
je 0x5b13
movq %rdi, %r14
xorl %ebx, %ebx
cmpq $0x0, 0x10(%r12)
jne 0x5b08
movq 0x8(%r12), %r15
movq %r15, %rdi
callq 0x20b0
movslq 0x20(%r14), %rdx
cmpq %rdx, %rax
jne 0x5b08
movq 0x18(%r14), %rsi
movq %r15, %rdi
callq 0x2060
testl %eax, %eax
je 0x5b17
movq (%r12), %r12
testq %r12, %r12
jne 0x5ada
jmp 0x5b1c
xorl %ebx, %ebx
jmp 0x5b1c
movq 0x18(%r12), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/pocari[P]compilerbook-9cc/parser.c
// Function: find_tag
static TagScope *find_tag(Token *tk) {
  for (TagScope *sc = tag_scope; sc; sc = sc->next) {
    if (strlen(sc->name) == tk->len && strncmp(sc->name, tk->str, tk->len) == 0) {
      // fprintf(stderr, "tag: %s, sc_name: %s\n", my_strndup(tk->str, tk->len), sc->name);
      return sc;
    }
  }
  return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0xa8c7(%rip), %rbx      # 0x10438
testq %rbx, %rbx
je 0x5ba9
movq %rdi, %r14
movslq 0x20(%rdi), %r15
movq 0x8(%rbx), %r12
movq %r12, %rdi
callq 0x20b0
cmpq %r15, %rax
jne 0x5ba1
movq 0x18(%r14), %rsi
movq %r12, %rdi
movq %r15, %rdx
callq 0x2060
testl %eax, %eax
je 0x5ba9
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0x5b7d
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/pocari[P]compilerbook-9cc/parser.c
// Function: push_tag_scope
static void push_tag_scope(Token *tag_tok, Type *type) {
  TagScope *sc = calloc(1, sizeof(TagScope));

  sc->name = my_strndup(tag_tok->str, tag_tok->len);
  sc->ty = type;
  sc->next = tag_scope;
  sc->depth = scope_depth;

  tag_scope = sc;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
movl $0x1, %edi
movl $0x20, %esi
callq 0x2100
movq %rax, %r14
movq 0x18(%r15), %r13
movslq 0x20(%r15), %r15
leaq 0x1(%r15), %rdi
movl $0x1, %esi
callq 0x2100
movq %rax, %r12
testq %r15, %r15
jle 0x5c07
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x2150
jmp 0x5c0a
xorl %r15d, %r15d
movb $0x0, (%r12,%r15)
movq %r12, 0x8(%r14)
movq %rbx, 0x10(%r14)
movq 0xa81a(%rip), %rax      # 0x10438
movq %rax, (%r14)
movl 0xa809(%rip), %eax      # 0x10430
movl %eax, 0x18(%r14)
movq %r14, 0xa806(%rip)      # 0x10438
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/pocari[P]compilerbook-9cc/parser.c
// Function: expect
static void expect(char *op) {
  if (token->kind != TK_RESERVED ||
      token->len != strlen(op) ||
      memcmp(token->str, op, token->len)) {
    error_at(token->str, "'%c'(token->kind: %s, token->len: %d, op: %s)ではありません", op, token_kind_to_s(token->kind), token->len, op);
  }
  token = token->next;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0xa832(%rip), %r15      # 0x10480
movq (%r15), %r12
movl (%r12), %ebp
cmpl $0x1, %ebp
jne 0x5c93
movslq 0x20(%r12), %r14
movq %rbx, %rdi
callq 0x20b0
cmpq %r14, %rax
jne 0x5c93
movq 0x18(%r12), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2170
testl %eax, %eax
jne 0x5c93
movq (%r15), %rax
movq 0x8(%rax), %rax
movq %rax, (%r15)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x18(%r12), %r14
movl %ebp, %edi
callq 0x997c
movq (%r15), %rcx
movl 0x20(%rcx), %r8d
leaq 0x6b01(%rip), %rsi      # 0xc7ae
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
movq %rbx, %r9
xorl %eax, %eax
callq 0x487c
// File: /workspace/github_c_makefile_star2_O1/pocari[P]compilerbook-9cc/parser.c
// Function: expect_ident
static char *expect_ident() {
  if (token->kind != TK_IDENT) {
    error_at(token->str, "識別子ではありません。");
  }
  char *s = my_strndup(token->str, token->len);
  token = token->next;
  return s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leaq 0xa7b0(%rip), %r12      # 0x10480
movq (%r12), %rax
cmpl $0x2, (%rax)
jne 0x5d27
movq (%r12), %r13
movq 0x18(%r13), %r15
movslq 0x20(%r13), %rbx
leaq 0x1(%rbx), %rdi
movl $0x1, %esi
callq 0x2100
movq %rax, %r14
testq %rbx, %rbx
jle 0x5d0b
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x2150
jmp 0x5d0d
xorl %ebx, %ebx
movb $0x0, (%r14,%rbx)
movq 0x8(%r13), %rax
movq %rax, (%r12)
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x18(%rax), %rdi
leaq 0x6b01(%rip), %rsi      # 0xc833
xorl %eax, %eax
callq 0x487c
// File: /workspace/github_c_makefile_star2_O1/pocari[P]compilerbook-9cc/parser.c
// Function: ternary
static Node *ternary() {
  Token *tk;
  Node *node = logical_or();
  if (tk = consume("?")) {
    Node *true_expr = expr();
    expect(":");
    Node *false_expr = ternary();

    // ifと同じ構造で式になるのでthen, elsにstmtじゃなくてexprいれたら動いたので取り敢えずこれで
    Node *cond = node;
    node = new_node(ND_TERNARY, tk);
    node->cond = cond;
    node->then = true_expr;
    node->els = false_expr;

  }

  return node;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x620f
movq %rax, %rbx
leaq 0x67c3(%rip), %r14      # 0xc8ad
leaq 0xa38f(%rip), %r13      # 0x10480
movq %r14, %rdi
callq 0x5244
testb %al, %al
je 0x610b
movq (%r13), %rbp
movq 0x8(%rbp), %rax
movq %rax, (%r13)
jmp 0x610d
xorl %ebp, %ebp
testq %rbp, %rbp
je 0x614b
callq 0x620f
movq %rax, %r15
movl $0x1, %edi
movl $0xc8, %esi
callq 0x2100
movq %rax, %r12
movl $0xb, (%rax)
movq %rbp, 0x8(%rax)
movq %rbx, 0x18(%rax)
movq %r15, 0x20(%rax)
movq %rax, %rdi
callq 0xa308
movq %r12, %rbx
jmp 0x60f1
leaq 0x6759(%rip), %rdi      # 0xc8ab
callq 0x5244
testb %al, %al
je 0x616a
movq (%r13), %r12
movq 0x8(%r12), %rax
movq %rax, (%r13)
jmp 0x616d
xorl %r12d, %r12d
testq %r12, %r12
je 0x61b6
callq 0x8870
movq %rax, %r14
leaq 0x53a0(%rip), %rdi      # 0xb521
callq 0x5c3c
callq 0x60d0
movq %rax, %r15
movl $0x1, %edi
movl $0xc8, %esi
callq 0x2100
movl $0x30, (%rax)
movq %r12, 0x8(%rax)
movq %rbx, 0x38(%rax)
movq %r14, 0x40(%rax)
movq %r15, 0x48(%rax)
movq %rax, %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_O1/pocari[P]compilerbook-9cc/parser.c
// Function: new_bin_node
static Node *new_bin_node(NodeKind kind, Node *lhs, Node *rhs, Token *tk) {
  Node *node = new_node(kind, tk);
  node->lhs = lhs;
  node->rhs = rhs;

  add_type(node);

  return node;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %ebp
movl $0x1, %edi
movl $0xc8, %esi
callq 0x2100
movq %rax, %r12
movl %ebp, (%rax)
movq %rbx, 0x8(%rax)
movq %r15, 0x18(%rax)
movq %r14, 0x20(%rax)
movq %rax, %rdi
callq 0xa308
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/pocari[P]compilerbook-9cc/parser.c
// Function: logical_and
static Node *logical_and() {
  Token *tk;
  Node *node = bit_or();

  while (tk = consume("&&")) {
    node = new_bin_node(ND_AND, node, bit_or(), tk);
  }

  return node;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x629c
movq %rax, %r14
leaq 0x6687(%rip), %rbx      # 0xc8b0
leaq 0xa250(%rip), %r13      # 0x10480
movq %rbx, %rdi
callq 0x5244
testb %al, %al
je 0x624a
movq (%r13), %rbp
movq 0x8(%rbp), %rax
movq %rax, (%r13)
jmp 0x624c
xorl %ebp, %ebp
testq %rbp, %rbp
je 0x628a
callq 0x629c
movq %rax, %r15
movl $0x1, %edi
movl $0xc8, %esi
callq 0x2100
movq %rax, %r12
movl $0xc, (%rax)
movq %rbp, 0x8(%rax)
movq %r14, 0x18(%rax)
movq %r15, 0x20(%rax)
movq %rax, %rdi
callq 0xa308
movq %r12, %r14
jmp 0x6230
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/pocari[P]compilerbook-9cc/parser.c
// Function: bit_or
static Node *bit_or() {
  Token *tk;
  Node *node = bit_xor();

  while (tk = consume("|")) {
    node = new_bin_node(ND_BIT_OR, node, bit_xor(), tk);
  }

  return node;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x6329
movq %rax, %r14
leaq 0x65f8(%rip), %rbx      # 0xc8ae
leaq 0xa1c3(%rip), %r13      # 0x10480
movq %rbx, %rdi
callq 0x5244
testb %al, %al
je 0x62d7
movq (%r13), %rbp
movq 0x8(%rbp), %rax
movq %rax, (%r13)
jmp 0x62d9
xorl %ebp, %ebp
testq %rbp, %rbp
je 0x6317
callq 0x6329
movq %rax, %r15
movl $0x1, %edi
movl $0xc8, %esi
callq 0x2100
movq %rax, %r12
movl $0xd, (%rax)
movq %rbp, 0x8(%rax)
movq %r14, 0x18(%rax)
movq %r15, 0x20(%rax)
movq %rax, %rdi
callq 0xa308
movq %r12, %r14
jmp 0x62bd
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/pocari[P]compilerbook-9cc/parser.c
// Function: bit_xor
static Node *bit_xor() {
  Token *tk;
  Node *node = bit_and();

  while (tk = consume("^")) {
    node = new_bin_node(ND_BIT_XOR, node, bit_and(), tk);
  }

  return node;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x63b6
movq %rax, %r14
leaq 0x6570(%rip), %rbx      # 0xc8b3
leaq 0xa136(%rip), %r13      # 0x10480
movq %rbx, %rdi
callq 0x5244
testb %al, %al
je 0x6364
movq (%r13), %rbp
movq 0x8(%rbp), %rax
movq %rax, (%r13)
jmp 0x6366
xorl %ebp, %ebp
testq %rbp, %rbp
je 0x63a4
callq 0x63b6
movq %rax, %r15
movl $0x1, %edi
movl $0xc8, %esi
callq 0x2100
movq %rax, %r12
movl $0x11, (%rax)
movq %rbp, 0x8(%rax)
movq %r14, 0x18(%rax)
movq %r15, 0x20(%rax)
movq %rax, %rdi
callq 0xa308
movq %r12, %r14
jmp 0x634a
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/pocari[P]compilerbook-9cc/parser.c
// Function: bit_and
static Node *bit_and() {
  Token *tk;
  Node *node = equality();

  while (tk = consume("&")) {
    node = new_bin_node(ND_BIT_AND, node, equality(), tk);
  }

  return node;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x6443
movq %rax, %r14
leaq 0x64e1(%rip), %rbx      # 0xc8b1
leaq 0xa0a9(%rip), %r13      # 0x10480
movq %rbx, %rdi
callq 0x5244
testb %al, %al
je 0x63f1
movq (%r13), %rbp
movq 0x8(%rbp), %rax
movq %rax, (%r13)
jmp 0x63f3
xorl %ebp, %ebp
testq %rbp, %rbp
je 0x6431
callq 0x6443
movq %rax, %r15
movl $0x1, %edi
movl $0xc8, %esi
callq 0x2100
movq %rax, %r12
movl $0xe, (%rax)
movq %rbp, 0x8(%rax)
movq %r14, 0x18(%rax)
movq %r15, 0x20(%rax)
movq %rax, %rdi
callq 0xa308
movq %r12, %r14
jmp 0x63d7
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/pocari[P]compilerbook-9cc/parser.c
// Function: equality
static Node *equality() {
  Token *tk;
  Node *node = relational();

  for (;;) {
    if (tk = consume("==")) {
      node = new_bin_node(ND_EQL, node, relational(), tk);
    } else if (tk = consume("!=")) {
      node = new_bin_node(ND_NOT_EQL, node, relational(), tk);
    } else {
      return node;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x64fd
movq %rax, %r14
leaq 0xa023(%rip), %rbp      # 0x10480
leaq 0x6451(%rip), %rdi      # 0xc8b5
callq 0x5244
testb %al, %al
je 0x647b
movq (%rbp), %r15
movq 0x8(%r15), %rax
movq %rax, (%rbp)
jmp 0x647e
xorl %r15d, %r15d
movl $0x12, %ebx
testq %r15, %r15
jne 0x64b3
leaq 0x6429(%rip), %rdi      # 0xc8b8
callq 0x5244
testb %al, %al
je 0x64a6
movq (%rbp), %r15
movq 0x8(%r15), %rax
movq %rax, (%rbp)
jmp 0x64a9
xorl %r15d, %r15d
movl $0x13, %ebx
testq %r15, %r15
je 0x64eb
callq 0x64fd
movq %rax, %r12
movl $0x1, %edi
movl $0xc8, %esi
callq 0x2100
movq %rax, %r13
movl %ebx, (%rax)
movq %r15, 0x8(%rax)
movq %r14, 0x18(%rax)
movq %r12, 0x20(%rax)
movq %rax, %rdi
callq 0xa308
movq %r13, %r14
jmp 0x645d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq