LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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, %r14
pushq $0x18
popq %rdi
callq 0x10b0
testq %rax, %rax
je 0x1ddb
movq %rax, %r15
leaq 0x265(%rip), %rsi       # 0x2000
leaq 0x2c8(%rip), %rdx       # 0x206a
leaq 0x390(%rip), %r8        # 0x2139
leaq 0x36b8(%rip), %r9       # 0x5468
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x31d8
movq %r14, %rdi
callq 0x33df
movq %r14, 0x8(%r15)
movq %rbx, %rdi
callq 0x33df
movq %rbx, 0x10(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x37a9(%rip), %rdi      # 0x558b
leaq 0x3698(%rip), %rsi      # 0x5481
leaq 0x37b0(%rip), %rcx      # 0x55a0
movl $0xda, %edx
callq 0x1050
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1ebd
testq %rsi, %rsi
je 0x1edc
movq %rdi, %r14
movq 0x18(%rdi), %rdi
movq %rsi, (%rsp)
callq 0x3589
movq 0x8(%rax), %rdi
callq 0x32ba
movzbl 0x8(%r14), %ecx
leaq 0x35b4(%rip), %r12      # 0x53f0
movl (%r12,%rcx,4), %ecx
xorl %ebx, %ebx
xorl %edx, %edx
divq %rcx
movq %rdx, %r15
pushq $0x1
popq %r13
pushq $0x2
popq %rbp
movq 0x10(%r14), %rdi
movq %r15, %rsi
callq 0x2a4a
testq %rax, %rax
je 0x1e9f
movq %r13, %rcx
testq %rbx, %rbx
je 0x1e7f
cmpq $0x1, %rbx
jne 0x1e75
movq %rbp, %rcx
jmp 0x1e7f
imulq %rbx, %rbx
decq %rbx
movq %rbx, %rcx
addq %rcx, %r15
movzbl 0x8(%r14), %eax
movl (%r12,%rax,4), %esi
movq %r15, %rax
xorl %edx, %edx
divq %rsi
incl 0x20(%r14)
movq %rcx, %rbx
movq %rdx, %r15
jmp 0x1e51
movq 0x10(%r14), %rdi
movq (%rsp), %rsi
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2899
leaq 0x35f2(%rip), %rdi      # 0x54b6
leaq 0x35b6(%rip), %rsi      # 0x5481
leaq 0x3a26(%rip), %rcx      # 0x58f8
movl $0x1b7, %edx            # imm = 0x1B7
callq 0x1050
leaq 0x3a4a(%rip), %rdi      # 0x592d
leaq 0x3597(%rip), %rsi      # 0x5481
leaq 0x3a07(%rip), %rcx      # 0x58f8
movl $0x1b8, %edx            # imm = 0x1B8
callq 0x1050
// File: /workspace/github_c_makefile_star2_O2/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 0x1f30
movq %rdi, %rbx
callq 0x1c19
movq 0x10(%rbx), %rdi
movq %rax, %rsi
callq 0x2a4a
testq %rax, %rax
je 0x1f2c
movq 0x18(%rbx), %rdi
movq %rax, %rsi
callq 0x3589
movq 0x10(%rax), %rax
jmp 0x1f2e
xorl %eax, %eax
popq %rbx
retq
leaq 0x357f(%rip), %rdi      # 0x54b6
leaq 0x3543(%rip), %rsi      # 0x5481
leaq 0x35c1(%rip), %rcx      # 0x5506
movl $0x91, %edx
callq 0x1050
// File: /workspace/github_c_makefile_star2_O2/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 0x1f85
movq %rdi, %rbx
callq 0x1c19
movq 0x10(%rbx), %rdi
movq %rax, %rsi
callq 0x2a4a
testq %rax, %rax
je 0x1f83
movq 0x18(%rbx), %rdi
movq %rax, %rsi
callq 0x3ff5
movq %rbx, %rdi
popq %rbx
jmp 0x1a88
popq %rbx
retq
leaq 0x352a(%rip), %rdi      # 0x54b6
leaq 0x34ee(%rip), %rsi      # 0x5481
leaq 0x359a(%rip), %rcx      # 0x5534
movl $0xa2, %edx
callq 0x1050
// File: /workspace/github_c_makefile_star2_O2/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 0x1fe1
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x33aa
movq 0x18(%rbx), %rdi
callq 0x33aa
movzbl 0x8(%rbx), %eax
leaq 0x3426(%rip), %rcx      # 0x53f0
movl (%rcx,%rax,4), %edi
callq 0x2724
movq %rax, 0x10(%rbx)
callq 0x3474
movq %rax, 0x18(%rbx)
popq %rbx
retq
leaq 0x34ce(%rip), %rdi      # 0x54b6
leaq 0x3492(%rip), %rsi      # 0x5481
leaq 0x357b(%rip), %rcx      # 0x5571
movl $0xca, %edx
callq 0x1050
// File: /workspace/github_c_makefile_star2_O2/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 0x202c
movq %rdi, %rbx
leaq 0x3458(%rip), %rsi      # 0x5468
callq 0x3422
testb %al, %al
je 0x204b
movq 0x8(%rbx), %rdi
callq 0x33aa
movq 0x10(%rbx), %rdi
popq %rbx
jmp 0x33aa
leaq 0x36b8(%rip), %rdi      # 0x56eb
leaq 0x3447(%rip), %rsi      # 0x5481
leaq 0x36b5(%rip), %rcx      # 0x56f6
movl $0x12a, %edx            # imm = 0x12A
callq 0x1050
leaq 0x36c3(%rip), %rdi      # 0x5715
leaq 0x3428(%rip), %rsi      # 0x5481
leaq 0x3696(%rip), %rcx      # 0x56f6
movl $0x12b, %edx            # imm = 0x12B
callq 0x1050
// File: /workspace/github_c_makefile_star2_O2/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 0x20fb
movq %rdi, %rbx
leaq 0x33e6(%rip), %rsi      # 0x5468
callq 0x3422
testb %al, %al
je 0x211a
cmpb $0x1, 0x6ff2(%rip)      # 0x9088
jne 0x20a1
movq 0x6ff1(%rip), %r15      # 0x9090
jmp 0x20c5
xorl %edi, %edi
callq 0x10a0
movl %eax, %edi
callq 0x1070
callq 0x10d0
movslq %eax, %r15
movq %r15, 0x6fd2(%rip)      # 0x9090
movb $0x1, 0x6fc3(%rip)      # 0x9088
movq 0x8(%rbx), %rdi
callq 0x32ba
movq %rax, %r14
addq %r15, %r14
movq 0x10(%rbx), %rdi
callq 0x32ba
addq %r14, %rax
leaq (%rax,%rax,8), %rax
movq %rax, %rcx
shrq $0xb, %rcx
xorq %rax, %rcx
imulq $0x8001, %rcx, %rax     # imm = 0x8001
popq %rbx
popq %r14
popq %r15
retq
leaq 0x3527(%rip), %rdi      # 0x5629
leaq 0x3378(%rip), %rsi      # 0x5481
leaq 0x3521(%rip), %rcx      # 0x5631
movl $0x101, %edx            # imm = 0x101
callq 0x1050
leaq 0x3537(%rip), %rdi      # 0x5658
leaq 0x3359(%rip), %rsi      # 0x5481
leaq 0x3502(%rip), %rcx      # 0x5631
movl $0x102, %edx            # imm = 0x102
callq 0x1050
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x21a2
movq %rdi, %rbx
leaq 0x331b(%rip), %rsi      # 0x5468
callq 0x3422
testb %al, %al
je 0x21c1
movq 0x6e9b(%rip), %r15      # 0x8ff8
movq (%r15), %rcx
leaq 0x3570(%rip), %rdi      # 0x56d7
pushq $0x8
popq %rsi
pushq $0x1
popq %r14
movq %r14, %rdx
callq 0x10c0
movq 0x8(%rbx), %rdi
callq 0x3355
movq (%r15), %rcx
leaq 0x3557(%rip), %rdi      # 0x56e0
pushq $0xa
popq %rsi
movq %r14, %rdx
callq 0x10c0
movq 0x10(%rbx), %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3355
leaq 0x34d3(%rip), %rdi      # 0x567c
leaq 0x32d1(%rip), %rsi      # 0x5481
leaq 0x34d6(%rip), %rcx      # 0x568d
movl $0x11a, %edx            # imm = 0x11A
callq 0x1050
leaq 0x34ea(%rip), %rdi      # 0x56b2
leaq 0x32b2(%rip), %rsi      # 0x5481
leaq 0x34b7(%rip), %rcx      # 0x568d
movl $0x11b, %edx            # imm = 0x11B
callq 0x1050
// File: /workspace/github_c_makefile_star2_O2/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 0x220c
movq %rdi, %rbx
leaq 0x3283(%rip), %rsi      # 0x5473
callq 0x3422
testb %al, %al
je 0x222b
movq 0x10(%rbx), %rdi
callq 0x33aa
movq 0x18(%rbx), %rdi
popq %rbx
jmp 0x33aa
leaq 0x34d8(%rip), %rdi      # 0x56eb
leaq 0x3267(%rip), %rsi      # 0x5481
leaq 0x364d(%rip), %rcx      # 0x586e
movl $0x19a, %edx            # imm = 0x19A
callq 0x1050
leaq 0x3656(%rip), %rdi      # 0x5888
leaq 0x3248(%rip), %rsi      # 0x5481
leaq 0x362e(%rip), %rcx      # 0x586e
movl $0x19b, %edx            # imm = 0x19B
callq 0x1050
// File: /workspace/github_c_makefile_star2_O2/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 0x2303
movq %rdi, %rbx
leaq 0x3211(%rip), %rsi      # 0x5473
callq 0x3422
testb %al, %al
je 0x2322
cmpb $0x1, 0x6e22(%rip)      # 0x9098
jne 0x2281
movq 0x6e21(%rip), %r14      # 0x90a0
jmp 0x22a5
xorl %edi, %edi
callq 0x10a0
movl %eax, %edi
callq 0x1070
callq 0x10d0
movslq %eax, %r14
movq %r14, 0x6e02(%rip)      # 0x90a0
movb $0x1, 0x6df3(%rip)      # 0x9098
movq 0x18(%rbx), %rdi
callq 0x355d
testq %rax, %rax
je 0x22fa
movq %rax, %r15
movq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0x3589
movq %rax, %rdi
callq 0x32ba
addq %rax, %r14
movq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0x3682
testb %al, %al
jne 0x22b6
movq %r15, %rdi
callq 0x33aa
leaq (%r14,%r14,8), %rax
movq %rax, %rcx
shrq $0xb, %rcx
xorq %rax, %rcx
imulq $0x8001, %rcx, %r14     # imm = 0x8001
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x331f(%rip), %rdi      # 0x5629
leaq 0x3170(%rip), %rsi      # 0x5481
leaq 0x3446(%rip), %rcx      # 0x575e
movl $0x153, %edx            # imm = 0x153
callq 0x1050
leaq 0x3457(%rip), %rdi      # 0x5780
leaq 0x3151(%rip), %rsi      # 0x5481
leaq 0x3427(%rip), %rcx      # 0x575e
movl $0x154, %edx            # imm = 0x154
callq 0x1050
// File: /workspace/github_c_makefile_star2_O2/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 0x239f
movq %rsi, %rbx
testq %rsi, %rsi
je 0x23be
movq %rdi, %r14
leaq 0x3117(%rip), %rsi      # 0x5473
callq 0x3422
testb %al, %al
je 0x23dd
leaq 0x3107(%rip), %rsi      # 0x5473
movq %rbx, %rdi
callq 0x3422
testb %al, %al
je 0x23fc
movq %r14, %rdi
callq 0x32ba
movq %rax, %r14
movq %rbx, %rdi
callq 0x32ba
cmpq %rax, %r14
setne %al
addb %al, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x33f9(%rip), %rdi      # 0x579f
leaq 0x30d4(%rip), %rsi      # 0x5481
leaq 0x33ed(%rip), %rcx      # 0x57a1
movl $0x172, %edx            # imm = 0x172
callq 0x1050
leaq 0x340b(%rip), %rdi      # 0x57d0
leaq 0x30b5(%rip), %rsi      # 0x5481
leaq 0x33ce(%rip), %rcx      # 0x57a1
movl $0x173, %edx            # imm = 0x173
callq 0x1050
leaq 0x33ee(%rip), %rdi      # 0x57d2
leaq 0x3096(%rip), %rsi      # 0x5481
leaq 0x33af(%rip), %rcx      # 0x57a1
movl $0x174, %edx            # imm = 0x174
callq 0x1050
leaq 0x33e8(%rip), %rdi      # 0x57eb
leaq 0x3077(%rip), %rsi      # 0x5481
leaq 0x3390(%rip), %rcx      # 0x57a1
movl $0x175, %edx            # imm = 0x175
callq 0x1050
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x24b9
movq %rdi, %rbx
leaq 0x3040(%rip), %rsi      # 0x5473
callq 0x3422
testb %al, %al
je 0x24d8
movq 0x6bb1(%rip), %r15      # 0x8ff8
movq (%r15), %rcx
leaq 0x33f3(%rip), %rdi      # 0x5844
pushq $0x1c
popq %rsi
pushq $0x1
popq %rdx
callq 0x10c0
movq 0x18(%rbx), %rdi
callq 0x355d
testq %rax, %rax
jne 0x2470
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq 0x18(%rbx), %rdi
movq %r14, %rsi
callq 0x3589
movq %rax, %rdi
callq 0x3355
movq 0x18(%rbx), %rdi
movq %r14, %rsi
callq 0x3682
testb %al, %al
jne 0x2473
movq (%r15), %rcx
leaq 0x33c0(%rip), %rdi      # 0x5861
pushq $0xc
popq %rsi
pushq $0x1
popq %rdx
callq 0x10c0
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x33aa
leaq 0x31bc(%rip), %rdi      # 0x567c
leaq 0x2fba(%rip), %rsi      # 0x5481
leaq 0x3336(%rip), %rcx      # 0x5804
movl $0x181, %edx            # imm = 0x181
callq 0x1050
leaq 0x3345(%rip), %rdi      # 0x5824
leaq 0x2f9b(%rip), %rsi      # 0x5481
leaq 0x3317(%rip), %rcx      # 0x5804
movl $0x182, %edx            # imm = 0x182
callq 0x1050
// File: /workspace/github_c_makefile_star2_O2/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 0x2720
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 0x2150
pushq $0xa
popq %rdi
callq 0x2040
addq $0xd8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x5bb5(%rip), %rdi      # 0x9468
xorl %eax, %eax
callq 0x26c5
movl 0x4(%rbx), %eax
decl %eax
cmpl $0x8, %eax
jae 0x38f4
movl $0x8b, %ecx
btl %eax, %ecx
jae 0x38f4
movl %eax, %eax
leaq 0x587d(%rip), %rcx      # 0x9154
movslq (%rcx,%rax,4), %rdi
addq %rcx, %rdi
xorl %eax, %eax
callq 0x26c5
leaq 0x5ac7(%rip), %rdi      # 0x93b3
xorl %eax, %eax
popq %rbx
jmp 0x26c5
leaq 0x5a27(%rip), %rdi      # 0x9322
leaq 0x59f8(%rip), %rsi      # 0x92fa
leaq 0x647f(%rip), %rcx      # 0x9d88
pushq $0x27
popq %rdx
callq 0x20d0
// File: /workspace/github_c_makefile_star2_O2/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 0x647e(%rip), %rdi      # 0x9d9a
xorl %eax, %eax
callq 0x26c5
leaq 0x5b3e(%rip), %rdi      # 0x9468
xorl %eax, %eax
callq 0x26c5
cmpl $0x2, (%rbx)
jne 0x3960
leaq 0x6467(%rip), %rdi      # 0x9da4
xorl %eax, %eax
callq 0x26c5
leaq 0x6466(%rip), %rdi      # 0x9db1
xorl %eax, %eax
callq 0x26c5
leaq 0x6464(%rip), %rdi      # 0x9dbd
xorl %eax, %eax
callq 0x26c5
movl 0x4(%rbx), %eax
decl %eax
cmpl $0x8, %eax
jae 0x399a
movl $0x8b, %ecx
btl %eax, %ecx
jae 0x399a
movl %eax, %eax
leaq 0x57f7(%rip), %rcx      # 0x9174
movslq (%rcx,%rax,4), %rdi
addq %rcx, %rdi
xorl %eax, %eax
callq 0x26c5
leaq 0x6492(%rip), %rdi      # 0x9e24
xorl %eax, %eax
popq %rbx
jmp 0x26c5
leaq 0x5981(%rip), %rdi      # 0x9322
leaq 0x5952(%rip), %rsi      # 0x92fa
leaq 0x6462(%rip), %rcx      # 0x9e11
pushq $0x48
popq %rdx
callq 0x20d0
// File: /workspace/github_c_makefile_star2_O2/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 0x5aa6(%rip), %rdi      # 0x9468
xorl %eax, %eax
callq 0x26c5
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x39d7
movl 0x4(%rax), %esi
jmp 0x39da
pushq $0x1
popq %rsi
leaq 0x648b(%rip), %rdi      # 0x9e6c
xorl %eax, %eax
callq 0x26c5
leaq 0x59c4(%rip), %rdi      # 0x93b3
xorl %eax, %eax
popq %rbx
jmp 0x26c5
// File: /workspace/github_c_makefile_star2_O2/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
movq %rdi, %r14
movw $0xa, (%rsp)
pushq $0x1
popq %rbx
leaq 0x608c(%rip), %r15      # 0xa560
testq %r14, %r14
je 0x44fd
movq %r14, %rdi
callq 0x3c17
movslq %ebx, %rcx
leaq (%rsp,%rcx), %rdi
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x21b0
addl %eax, %ebx
movq 0x30(%r14), %r14
jmp 0x44d4
movq %rsp, %rdi
movl %ebx, %esi
callq 0x4903
addq $0x2710, %rsp           # imm = 0x2710
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 $0x2718, %rsp           # imm = 0x2718
movq %rdi, %r14
movq 0x8(%rdi), %rdi
callq 0x3bec
movq %rax, %r12
movq 0x10(%r14), %rcx
leaq 0x602a(%rip), %rsi      # 0xa569
xorl %r15d, %r15d
movq %rsp, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x21b0
movl %eax, %ebx
movq %r12, %rdi
callq 0x2030
leaq 0x28(%r14), %rbp
pushq $0x1
popq %r12
pushq $0x10
popq %r13
movq (%rbp), %rbp
testq %rbp, %rbp
je 0x4589
movq %r12, %rdi
movq %r13, %rsi
callq 0x2100
movq %r15, (%rax)
movq 0x8(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq %rax, %r15
jmp 0x4565
leaq 0x5fe8(%rip), %r12      # 0xa578
movq %r15, %rax
movslq %ebx, %rbx
testq %rax, %rax
je 0x45fb
movq %rax, %rbp
movq 0x8(%rax), %rax
movq (%rax), %rdi
callq 0x3bec
movq %rax, %r13
leaq (%rsp,%rbx), %rdi
movq 0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq %r12, %rsi
movq %r13, %rdx
xorl %eax, %eax
callq 0x21b0
addl %eax, %ebx
movq %r13, %rdi
callq 0x2030
cmpq $0x0, (%rbp)
movl $0x0, %eax
je 0x4593
movslq %ebx, %rbx
movw $0x20, (%rsp,%rbx)
incl %ebx
movq (%rbp), %rax
jmp 0x4593
movq (%r15), %r12
movq %r15, %rdi
callq 0x2030
movq %r12, %r15
testq %r15, %r15
jne 0x45ed
movq 0x18(%r14), %rdi
callq 0x44b5
movq %rax, %r14
leaq (%rsp,%rbx), %rdi
leaq 0x5f67(%rip), %rsi      # 0xa57e
movq %rax, %rdx
xorl %eax, %eax
callq 0x21b0
leal (%rax,%rbx), %ecx
movslq %ecx, %rcx
movl $0x29202323, (%rsp,%rcx) # imm = 0x29202323
movw $0x29, 0x4(%rsp,%rcx)
addl %eax, %ebx
addl $0x5, %ebx
movq %r14, %rdi
callq 0x2030
movq %rsp, %rdi
movl %ebx, %esi
callq 0x4903
addq $0x2718, %rsp           # imm = 0x2718
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %r14
leaq 0x5ef7(%rip), %r15      # 0xa58b
testq %rbx, %rbx
je 0x46ce
movl $0xc8, %esi
movq %r14, %rdi
callq 0x2100
movl $0x20, (%rax)
movq 0x8(%rbx), %rcx
movq %rcx, 0x78(%rax)
movq %rax, %rdi
callq 0x3c17
movq %r15, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x20c0
movq (%rbx), %rbx
jmp 0x4694
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4757
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 0x4815
movl %eax, %ebp
movq 0xa873(%rip), %r13      # 0xeff8
movq (%r13), %rdi
leaq 0xace0(%rip), %rax      # 0xf470
movq (%rax), %rdx
leaq 0x5f02(%rip), %rsi      # 0xa69c
xorl %eax, %eax
callq 0x2120
movq (%r13), %r12
movq %r15, %rdi
callq 0x4836
leaq 0x5db1(%rip), %rsi      # 0xa565
movq %r12, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x2120
movq (%r13), %rdi
leaq 0x5eda(%rip), %rsi      # 0xa6a6
leaq 0x56b8(%rip), %rcx      # 0x9e8b
movl %ebp, %edx
xorl %eax, %eax
callq 0x2120
movq (%r13), %rcx
leaq 0x5ec3(%rip), %rdi      # 0xa6aa
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
callq 0x21d0
movq (%r13), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x21a0
movq (%r13), %rsi
pushq $0xa
popq %rdi
callq 0x20f0
pushq $0x1
popq %rdi
callq 0x21c0
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leal 0x1(%rbx), %eax
movslq %eax, %rdi
pushq $0x1
popq %rsi
callq 0x2100
xorl %ecx, %ecx
testl %ebx, %ebx
cmovlel %ecx, %ebx
cmpq %rcx, %rbx
je 0x4932
movb (%r14,%rcx), %dl
movb %dl, (%rax,%rcx)
incq %rcx
jmp 0x4921
movb $0x0, (%rax,%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/pocari[P]compilerbook-9cc/parser.c
// Function: consume_end
bool consume_end() {
  if (consume("}")) {
    return true;
  }

  Token *tmp = token;
  if (consume(",") && consume("}")) {
    return true;;
  }
  token = tmp;
  return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0x5d63(%rip), %rdi      # 0xa6ad
callq 0x498f
movb $0x1, %bl
testq %rax, %rax
jne 0x4987
leaq 0xab23(%rip), %r14      # 0xf480
movq (%r14), %r15
leaq 0x5d48(%rip), %rdi      # 0xa6af
callq 0x498f
testq %rax, %rax
je 0x4982
leaq 0x5d35(%rip), %rdi      # 0xa6ad
callq 0x498f
testq %rax, %rax
jne 0x4987
movq %r15, (%r14)
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/pocari[P]compilerbook-9cc/parser.c
// Function: consume
static Token *consume(char *op) {
  Token *tk = token;
  if (!peek_token(op)) {
    return NULL;
  }
  token = token->next;
  return tk;
}

// Assembly:
pushq %rax
callq 0x4ea0
testb %al, %al
je 0x49ac
leaq 0xaae0(%rip), %rcx      # 0xf480
movq (%rcx), %rax
movq 0x8(%rax), %rdx
movq %rdx, (%rcx)
jmp 0x49ae
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xaac5(%rip), %rbx      # 0xf480
movq (%rbx), %r14
leaq 0x5ce8(%rip), %rdi      # 0xa6ad
callq 0x498f
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x49fb
leaq 0x5cd4(%rip), %rdi      # 0xa6af
callq 0x498f
testq %rax, %rax
je 0x49f9
leaq 0x5cc1(%rip), %rdi      # 0xa6ad
callq 0x498f
testq %rax, %rax
setne %al
jmp 0x49fb
xorl %eax, %eax
movq %r14, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x17
popq %rdi
callq 0x4e7e
movq %rax, %r14
movq %rbx, 0x78(%rax)
movq %rax, %rdi
callq 0x8a4d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/pocari[P]compilerbook-9cc/parser.c
// Function: new_node
static Node *new_node(NodeKind kind, Token *tok) {
  Node *node = calloc(1, sizeof(Node));
  node->kind = kind;
  node->tok = tok;
  return node;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
pushq $0x1
popq %rdi
movl $0xc8, %esi
callq 0x2100
movl %ebp, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xa5d4(%rip), %rax      # 0xf480
movq (%rax), %r15
cmpl $0x1, (%r15)
jne 0x4edc
movq %rdi, %rbx
movslq 0x20(%r15), %r14
callq 0x20b0
cmpq %r14, %rax
jne 0x4edc
movq 0x18(%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2160
testl %eax, %eax
sete %al
jmp 0x4ede
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x59c2(%rip), %r15      # 0xae17
movq %r15, %rdi
callq 0x498f
testq %rax, %rax
je 0x546f
movq %rbx, %rdi
callq 0x8990
movq %rax, %rbx
jmp 0x5455
leaq 0x5100(%rip), %rdi      # 0xa576
callq 0x498f
testq %rax, %rax
je 0x54d2
pushq $0x1
popq %rdi
pushq $0x30
popq %rsi
callq 0x2100
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x5443
movq %rax, %r14
leaq 0x50e6(%rip), %rdi      # 0xa589
callq 0x5644
movq %rbx, %rdi
callq 0x67f9
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
popq %rbx
popq %r14
popq %r15
retq
callq 0x56c6
movq %rax, (%r14)
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: is_type
static bool is_type(Token *tk) {
  if (is_builtin_type(tk)) {
    return true;
  }

  // ビルトインでなくても、typedefか構造体かenumかtypedefされた型ならtrueを返す
  // 型の途中でtypedef/static/externが出てくる場合もあるのでtypedef/static/extern自体も型名の一つとしてtrueにしておき
  // 詳細はbasetype関数で判断する
  switch (tk->kind) {
    case TK_TYPEDEF:
    case TK_STRUCT:
    case TK_ENUM:
    case TK_STATIC:
    case TK_EXTERN:
      return true;
    default:
      return (bool)find_typedef(tk);
  }
}

// Assembly:
movl (%rdi), %ecx
leal -0xa(%rcx), %edx
movb $0x1, %al
cmpl $0x6, %edx
jae 0x54f4
retq
addl $-0x10, %ecx
cmpl $0x8, %ecx
jae 0x5506
movl $0xe3, %edx
btl %ecx, %edx
jb 0x54f3
pushq %rax
callq 0x5517
testq %rax, %rax
setne %al
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rdi, %r14
leaq 0x9f17(%rip), %r12      # 0xf440
xorl %ebx, %ebx
movq (%r12), %r12
testq %r12, %r12
je 0x556a
cmpq $0x0, 0x10(%r12)
jne 0x552b
movq 0x8(%r12), %r15
movq %r15, %rdi
callq 0x20b0
movslq 0x20(%r14), %rcx
cmpq %rcx, %rax
jne 0x552b
movq 0x18(%r14), %rsi
movq %r15, %rdi
movq %rax, %rdx
callq 0x2060
testl %eax, %eax
jne 0x552b
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_O2/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 %rbx
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x1
popq %rdi
pushq $0x20
popq %rsi
callq 0x2100
movq %rax, %r15
movq 0x18(%r14), %rdi
movl 0x20(%r14), %esi
callq 0x4903
movq %rax, 0x8(%r15)
movq %rbx, 0x10(%r15)
movq 0x9e0e(%rip), %rax      # 0xf438
movq %rax, (%r15)
movl 0x9dfd(%rip), %eax      # 0xf430
movl %eax, 0x18(%r15)
movq %r15, 0x9dfa(%rip)      # 0xf438
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x9e2a(%rip), %r15      # 0xf480
movq (%r15), %r12
movl (%r12), %ebp
cmpl $0x1, %ebp
jne 0x5699
movslq 0x20(%r12), %r14
movq %rbx, %rdi
callq 0x20b0
cmpq %r14, %rax
jne 0x5699
movq 0x18(%r12), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2160
testl %eax, %eax
jne 0x5699
movq 0x8(%r12), %rax
movq %rax, (%r15)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x18(%r12), %r14
movl %ebp, %edi
callq 0x8148
movq (%r15), %rcx
movl 0x20(%rcx), %r8d
leaq 0x5143(%rip), %rsi      # 0xa7f6
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
movq %rbx, %r9
xorl %eax, %eax
callq 0x46f0
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
leaq 0x9db2(%rip), %rbx      # 0xf480
movq (%rbx), %rax
cmpl $0x2, (%rax)
movq 0x18(%rax), %rdi
jne 0x56ee
movl 0x20(%rax), %esi
callq 0x4903
movq (%rbx), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, (%rbx)
popq %rbx
retq
leaq 0x5186(%rip), %rsi      # 0xa87b
xorl %eax, %eax
callq 0x46f0
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
callq 0x5b0e
movq %rax, %rbx
leaq 0x4e99(%rip), %r14      # 0xa8f5
pushq $0xb
popq %rbp
movq %r14, %rdi
callq 0x498f
testq %rax, %rax
je 0x5a89
movq %rax, %r15
callq 0x5b0e
movl %ebp, %edi
movq %rbx, %rsi
movq %rax, %rdx
movq %r15, %rcx
callq 0x5adf
movq %rax, %rbx
jmp 0x5a5f
leaq 0x4e63(%rip), %rdi      # 0xa8f3
callq 0x498f
testq %rax, %rax
je 0x5ad3
movq %rax, %r14
callq 0x7590
movq %rax, %r15
leaq 0x3a75(%rip), %rdi      # 0x9521
callq 0x5644
callq 0x5a45
movq %rax, %r12
pushq $0x30
popq %rdi
movq %r14, %rsi
callq 0x4e7e
movq %rbx, 0x38(%rax)
movq %r15, 0x40(%rax)
movq %r12, 0x48(%rax)
movq %rax, %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rcx, %rsi
callq 0x4e7e
movq %rax, %r15
movq %r14, 0x18(%rax)
movq %rbx, 0x20(%rax)
movq %rax, %rdi
callq 0x8a4d
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
pushq %rax
callq 0x5b5f
movq %rax, %r14
leaq 0x4dd4(%rip), %rbx      # 0xa8f8
pushq $0xc
popq %rbp
movq %rbx, %rdi
callq 0x498f
testq %rax, %rax
je 0x5b51
movq %rax, %r15
callq 0x5b5f
movl %ebp, %edi
movq %r14, %rsi
movq %rax, %rdx
movq %r15, %rcx
callq 0x5adf
movq %rax, %r14
jmp 0x5b27
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
pushq %rax
callq 0x5bb0
movq %rax, %r14
leaq 0x4d81(%rip), %rbx      # 0xa8f6
pushq $0xd
popq %rbp
movq %rbx, %rdi
callq 0x498f
testq %rax, %rax
je 0x5ba2
movq %rax, %r15
callq 0x5bb0
movl %ebp, %edi
movq %r14, %rsi
movq %rax, %rdx
movq %r15, %rcx
callq 0x5adf
movq %rax, %r14
jmp 0x5b78
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
pushq %rax
callq 0x5c01
movq %rax, %r14
leaq 0x4d35(%rip), %rbx      # 0xa8fb
pushq $0x11
popq %rbp
movq %rbx, %rdi
callq 0x498f
testq %rax, %rax
je 0x5bf3
movq %rax, %r15
callq 0x5c01
movl %ebp, %edi
movq %r14, %rsi
movq %rax, %rdx
movq %r15, %rcx
callq 0x5adf
movq %rax, %r14
jmp 0x5bc9
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
pushq %rax
callq 0x5c52
movq %rax, %r14
leaq 0x4ce2(%rip), %rbx      # 0xa8f9
pushq $0xe
popq %rbp
movq %rbx, %rdi
callq 0x498f
testq %rax, %rax
je 0x5c44
movq %rax, %r15
callq 0x5c52
movl %ebp, %edi
movq %r14, %rsi
movq %rax, %rdx
movq %r15, %rcx
callq 0x5adf
movq %rax, %r14
jmp 0x5c1a
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x5cd0
movq %rax, %r12
leaq 0x4c91(%rip), %rbx      # 0xa8fd
leaq 0x4c8d(%rip), %r14      # 0xa900
pushq $0x13
popq %rbp
pushq $0x12
popq %r15
movq %rbx, %rdi
callq 0x498f
testq %rax, %rax
je 0x5c94
movq %rax, %r13
callq 0x5cd0
movl %r15d, %edi
jmp 0x5cab
movq %r14, %rdi
callq 0x498f
testq %rax, %rax
je 0x5cbe
movq %rax, %r13
callq 0x5cd0
movl %ebp, %edi
movq %r12, %rsi
movq %rax, %rdx
movq %r13, %rcx
callq 0x5adf
movq %rax, %r12
jmp 0x5c7a
movq %r12, %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: relational
static Node *relational() {
  Token *tk;
  Node *node = shift();

  for (;;) {
    if (tk = consume("<=")) {
      node = new_bin_node(ND_LTE, node, shift(), tk);
    } else if (tk = consume(">=")) {
      node = new_bin_node(ND_LTE, shift(), node, tk);
    } else if (tk = consume("<")) {
      node = new_bin_node(ND_LT, node, shift(), tk);
    } else if (tk = consume(">")) {
      node = new_bin_node(ND_LT, shift(), node, tk);
    } else {
      return node;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x5d8f
movq %rax, %r12
leaq 0x4cda(%rip), %rbx      # 0xa9c4
leaq 0x4cd7(%rip), %r14      # 0xa9c8
pushq $0x9
popq %rbp
pushq $0xa
popq %r13
movq %rbx, %rdi
callq 0x498f
testq %rax, %rax
je 0x5d18
movq %rax, %r15
callq 0x5d8f
movl %r13d, %edi
movq %r12, %rsi
movq %rax, %rdx
jmp 0x5d36
movq %r14, %rdi
callq 0x498f
testq %rax, %rax
je 0x5d43
movq %rax, %r15
callq 0x5d8f
movl %r13d, %edi
movq %rax, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x5adf
movq %rax, %r12
jmp 0x5cf8
leaq 0x4bba(%rip), %rdi      # 0xa904
callq 0x498f
testq %rax, %rax
je 0x5d60
movq %rax, %r15
callq 0x5d8f
movl %ebp, %edi
jmp 0x5d10
leaq 0x4c15(%rip), %rdi      # 0xa97c
callq 0x498f
testq %rax, %rax
je 0x5d7d
movq %rax, %r15
callq 0x5d8f
movl %ebp, %edi
jmp 0x5d30
movq %r12, %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: shift
static Node *shift() {
  Token *tk;
  Node *node = add();
  for (;;) {
    if (tk = consume("<<")) {
      node = new_bin_node(ND_A_LSHIFT, node, add(), tk);
    } else if (tk = consume(">>")) {
      node = new_bin_node(ND_A_RSHIFT, node, add(), tk);
    } else {
      return node;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x5e0d
movq %rax, %r12
leaq 0x4b5a(%rip), %rbx      # 0xa903
leaq 0x4b56(%rip), %r14      # 0xa906
pushq $0x10
popq %rbp
pushq $0xf
popq %r15
movq %rbx, %rdi
callq 0x498f
testq %rax, %rax
je 0x5dd1
movq %rax, %r13
callq 0x5e0d
movl %r15d, %edi
jmp 0x5de8
movq %r14, %rdi
callq 0x498f
testq %rax, %rax
je 0x5dfb
movq %rax, %r13
callq 0x5e0d
movl %ebp, %edi
movq %r12, %rsi
movq %rax, %rdx
movq %r13, %rcx
callq 0x5adf
movq %rax, %r12
jmp 0x5db7
movq %r12, %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: add
static Node *add() {
  Token *tk;
  Node *node = mul();

  for (;;) {
    if (tk = consume("+")) {
      node = new_add_node(node, mul(), tk);
    } else if (tk = consume("-")) {
      node = new_sub_node(node, mul(), tk);
    } else {
      return node;
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
callq 0x5fc9
movq %rax, %r15
leaq 0x4b0f(%rip), %rbx      # 0xa933
leaq 0x53c6(%rip), %r14      # 0xb1f1
movq %rbx, %rdi
callq 0x498f
testq %rax, %rax
je 0x5e53
movq %rax, %r12
callq 0x5fc9
movq %r15, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0x5e8a
movq %rax, %r15
jmp 0x5e2b
movq %r14, %rdi
callq 0x498f
testq %rax, %rax
je 0x5e7b
movq %rax, %r12
callq 0x5fc9
movq %r15, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0x5f34
movq %rax, %r15
jmp 0x5e2b
movq %r15, %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: new_add_node
static Node *new_add_node(Node *lhs, Node *rhs, Token *tk) {
  add_type(lhs);
  add_type(rhs);

  // int x
  // &x + 2
  // => & に intのサイズ(4) * 2 => xのアドレスの 8byte先
  //
  // int x
  // int *y = &x
  // int **z = &y
  // &z + 2
  // => & に intのポインタのサイズ(8) * 2 => zのアドレスの 16byte先
  if (is_integer(lhs->ty) && is_integer(rhs->ty)) {
    // num + num
    return new_bin_node(ND_ADD, lhs, rhs, tk);
  } else if (is_pointer(lhs->ty) && is_integer(rhs->ty)) {
    // ptr + num のケース
    return new_bin_node(ND_PTR_ADD, lhs, rhs, tk);
  } else if (is_integer(lhs->ty) && is_pointer(rhs->ty)){
    // num + ptrのケースなので、入れ替えてptr + num に正規化する
    return new_bin_node(ND_PTR_ADD, rhs, lhs, tk);
  }
  // ここに来た場合 ptr + ptr という不正なパターンになるので落とす
  error_at(token->str, "不正なaddパターンです。");
  return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x8a4d
movq %r14, %rdi
callq 0x8a4d
movq 0x10(%r15), %rdi
callq 0x8a39
testb %al, %al
je 0x5ec3
movq 0x10(%r14), %rdi
callq 0x8a39
testb %al, %al
je 0x5ec3
pushq $0x1
jmp 0x5edf
movq 0x10(%r15), %rdi
callq 0x8a2d
testb %al, %al
je 0x5ee8
movq 0x10(%r14), %rdi
callq 0x8a39
testb %al, %al
je 0x5ee8
pushq $0x2
popq %rdi
movq %r15, %rsi
movq %r14, %rdx
jmp 0x5f0b
movq 0x10(%r15), %rdi
callq 0x8a39
testb %al, %al
je 0x5f18
movq 0x10(%r14), %rdi
callq 0x8a2d
testb %al, %al
je 0x5f18
pushq $0x2
popq %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rbx, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x5adf
leaq 0x9561(%rip), %rax      # 0xf480
movq (%rax), %rax
movq 0x18(%rax), %rdi
leaq 0x4bf6(%rip), %rsi      # 0xab23
xorl %eax, %eax
callq 0x46f0
// File: /workspace/github_c_makefile_star2_O2/pocari[P]compilerbook-9cc/parser.c
// Function: new_sub_node
static Node *new_sub_node(Node *lhs, Node *rhs, Token *tk) {
  add_type(lhs);
  add_type(rhs);

  if (is_integer(lhs->ty) && is_integer(rhs->ty)) {
    // num - num
    return new_bin_node(ND_SUB, lhs, rhs, tk);
  } else if (is_pointer(lhs->ty) && is_pointer(rhs->ty)) {
    //  ptr - ptr
    return new_bin_node(ND_PTR_DIFF, lhs, rhs, tk);
  } else if (is_pointer(lhs->ty) && is_integer(rhs->ty)) {
    // ptr - num
    return new_bin_node(ND_PTR_SUB, lhs, rhs, tk);
  }
  // ここに来た場合 num - ptr になってしまうので、エラーにする
  error("不正な演算です: num - ptr");
  return NULL; // error で落ちるので実際にはreturnされない
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x8a4d
movq %r14, %rdi
callq 0x8a4d
movq 0x10(%r15), %rdi
callq 0x8a39
testb %al, %al
je 0x5f6d
movq 0x10(%r14), %rdi
callq 0x8a39
testb %al, %al
je 0x5f6d
pushq $0x3
jmp 0x5fa7
movq 0x10(%r15), %rdi
callq 0x8a2d
testb %al, %al
je 0x5f8b
movq 0x10(%r14), %rdi
callq 0x8a2d
testb %al, %al
je 0x5f8b
pushq $0x5
jmp 0x5fa7
movq 0x10(%r15), %rdi
callq 0x8a2d
testb %al, %al
je 0x5fbb
movq 0x10(%r14), %rdi
callq 0x8a39
testb %al, %al
je 0x5fbb
pushq $0x4
popq %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x5adf
leaq 0x4b83(%rip), %rdi      # 0xab45
xorl %eax, %eax
callq 0x485f