LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/jflatow[P]jfdb/src/jfdb.c
// Function: read_prefix
static JFT_Stem *read_prefix(JFT_Stem *prefix, int omit, int argc, char **argv) {
  JFT_KeySize len, off = 0;
  for (int i = 0; i < argc; i++) {
    len = strlen(argv[i]);
    memcpy(prefix->data + off, argv[i], len);
    prefix->data[off + len] = 0;
    off += len + 1;
  }
  prefix->size += off - (argc && omit); // maybe omit trailing NULL
  return prefix;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movw $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x2dcd
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x10a0
movw %ax, -0x1a(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movzwl -0x1c(%rbp), %eax
cltq
addq %rax, %rdi
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movzwl -0x1a(%rbp), %eax
movl %eax, %edx
callq 0x1150
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movzwl -0x1c(%rbp), %ecx
movzwl -0x1a(%rbp), %edx
addl %edx, %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movzwl -0x1a(%rbp), %ecx
addl $0x1, %ecx
movzwl -0x1c(%rbp), %eax
addl %ecx, %eax
movw %ax, -0x1c(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x2d53
movzwl -0x1c(%rbp), %eax
movl %eax, -0x28(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x10(%rbp)
movb %al, -0x21(%rbp)
je 0x2de9
cmpl $0x0, -0xc(%rbp)
setne %al
movb %al, -0x21(%rbp)
movl -0x28(%rbp), %edx
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
subl %eax, %edx
movq -0x8(%rbp), %rax
movzwl 0x8(%rax), %ecx
addl %edx, %ecx
movw %cx, 0x8(%rax)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/openshmem-org[P]openshmem-examples/c++/hello.cxx
// Function: main
int
main(void)
{
    struct utsname u;

    uname(&u);

    shmem_init();

    const int me = shmem_my_pe();
    const int npes = shmem_n_pes();

    std::cout << u.nodename
              << " hello from PE " << me
              << " of " << npes
              << "\n";

    shmem_finalize();

    return 0;
}

// Assembly:
subq $0x198, %rsp            # imm = 0x198
movl $0x0, 0x194(%rsp)
leaq 0xe(%rsp), %rdi
callq 0x1030
callq 0x10b0
callq 0x1080
movl %eax, 0x8(%rsp)
callq 0x1060
movl %eax, 0x4(%rsp)
leaq 0xe(%rsp), %rsi
addq $0x41, %rsi
movq 0x2d95(%rip), %rdi      # 0x3fd8
callq 0x1070
movq %rax, %rdi
leaq 0xdb2(%rip), %rsi       # 0x2004
callq 0x1070
movq %rax, %rdi
movl 0x8(%rsp), %esi
callq 0x10a0
movq %rax, %rdi
leaq 0xda7(%rip), %rsi       # 0x2014
callq 0x1070
movq %rax, %rdi
movl 0x4(%rsp), %esi
callq 0x10a0
movq %rax, %rdi
leaq 0xd91(%rip), %rsi       # 0x2019
callq 0x1070
callq 0x1040
xorl %eax, %eax
addq $0x198, %rsp            # imm = 0x198
retq
// File: /workspace/github_c_makefile_star2_O0/theck01[P]offbrand_lib/src/classes/obmap.c
// Function: obmap_new_with_capacity
obmap * obmap_new_with_capacity(uint32_t capacity){

  obmap *m = obmap_create_default();

  uint32_t i = 0;
  while(MAP_CAPACITIES[i] < capacity && i < NUM_CAPACITIES - 1) i++;

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

  return m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
callq 0x1ad0
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq 0x49b9(%rip), %rax      # 0x6410
movl (%rax,%rcx,4), %ecx
xorl %eax, %eax
cmpl -0x4(%rbp), %ecx
movb %al, -0x15(%rbp)
jae 0x1a6e
cmpl $0x19, -0x14(%rbp)
setb %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x1a77
jmp 0x1a82
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1a4b
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq 0x4982(%rip), %rax      # 0x6410
movl (%rax,%rcx,4), %edi
callq 0x2e50
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
callq 0x4380
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movl -0x14(%rbp), %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theck01[P]offbrand_lib/src/classes/obmap.c
// Function: obmap_create_default
obmap * obmap_create_default(void){

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

  /* initialize base class data */
  ob_init_base((obj *)new_instance, &obmap_destroy, &obmap_hash,
           &obmap_compare, &obmap_display, classname);

  new_instance->hash_table = NULL;
  new_instance->pairs = NULL;
  new_instance->cap_idx = 0;
  new_instance->collisions = 0;

  return new_instance;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x28, %edi
callq 0x10a0
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1aef
jmp 0x1b0e
leaq 0x4ab5(%rip), %rdi      # 0x65ab
leaq 0x49a4(%rip), %rsi      # 0x64a1
movl $0x13b, %edx            # imm = 0x13B
leaq 0x4c5e(%rip), %rcx      # 0x6767
callq 0x1050
movq -0x8(%rbp), %rdi
leaq 0xbd7(%rip), %rsi       # 0x26f0
leaq 0xc70(%rip), %rdx       # 0x2790
leaq 0xdc9(%rip), %rcx       # 0x28f0
leaq 0xec2(%rip), %r8        # 0x29f0
leaq 0x495e(%rip), %r9       # 0x6493
callq 0x3e90
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/theck01[P]offbrand_lib/src/classes/obmap.c
// Function: obmap_copy
obmap * obmap_copy(const obmap *to_copy){

  obmap *copy;
  obmap_pair *mp;
  obdeque_iterator *it;

  assert(to_copy);

  copy = obmap_create_default();

  copy->cap_idx = to_copy->cap_idx;
  copy->collisions = to_copy->collisions;
  copy->pairs = obdeque_new();

  /* copy deque manually, internal objects need to be copied as well as Deque
   * itself */
  it = obdeque_head_iterator(to_copy->pairs);
  if(it){
    do{
       mp = obmap_copy_pair((obmap_pair *)obdeque_obj_at_iterator(to_copy->pairs, it));
       obdeque_add_at_tail(copy->pairs, (obj *)mp);
       ob_release((obj *)mp);
    }while(obdeque_iterate_next(to_copy->pairs, it));
  }
  ob_release((obj *)it);

  obmap_rehash(copy); /* cannot grab to_copy->hash_table directly, stored
                         iterators must point to values within copy, not to copy */

  return copy;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1b85
jmp 0x1ba4
leaq 0x490d(%rip), %rdi      # 0x6499
leaq 0x490e(%rip), %rsi      # 0x64a1
movl $0x4d, %edx
leaq 0x4916(%rip), %rcx      # 0x64b5
callq 0x1050
callq 0x1ad0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movb 0x8(%rax), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x8(%rax)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x20(%rax)
callq 0x4380
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x44e0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1c41
jmp 0x1bf3
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x4530
movq %rax, %rdi
callq 0x1c60
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x45f0
movq -0x18(%rbp), %rdi
callq 0x4190
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x46c0
cmpb $0x0, %al
jne 0x1bf3
jmp 0x1c41
movq -0x20(%rbp), %rdi
callq 0x4190
movq -0x10(%rbp), %rdi
callq 0x1cb0
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/theck01[P]offbrand_lib/src/classes/obmap.c
// Function: obmap_rehash
void obmap_rehash(obmap *m){

  obdeque_iterator *it, *it_copy;

  assert(m);

  ob_release((obj *)m->hash_table);
  m->hash_table = obvector_new(MAP_CAPACITIES[m->cap_idx]);

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

  do{
    it_copy = obdeque_copy_iterator(it);
    obmap_add_to_table(m, it_copy);
    ob_release((obj *)it_copy);
  }while(obdeque_iterate_next(m->pairs, it));

  ob_release((obj *)it);

  return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1cc5
jmp 0x1ce4
leaq 0x480a(%rip), %rdi      # 0x64d6
leaq 0x47ce(%rip), %rsi      # 0x64a1
movl $0xb4, %edx
leaq 0x4897(%rip), %rcx      # 0x6576
callq 0x1050
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x4190
movq -0x8(%rbp), %rax
movzbl 0x8(%rax), %eax
movl %eax, %ecx
leaq 0x470e(%rip), %rax      # 0x6410
movl (%rax,%rcx,4), %edi
callq 0x2e50
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x44e0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1d2f
jmp 0x1d72
jmp 0x1d31
movq -0x10(%rbp), %rdi
callq 0x4960
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2180
movq -0x18(%rbp), %rdi
callq 0x4190
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x46c0
cmpb $0x0, %al
jne 0x1d31
movq -0x10(%rbp), %rdi
callq 0x4190
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theck01[P]offbrand_lib/src/classes/obmap.c
// Function: obmap_insert
void obmap_insert(obmap *m, obj *key, obj *value){

  obmap_pair *mp;
  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 the key already exists in the map then overwrite the existing
   * value */
  if(it){
    mp = (obmap_pair *)obdeque_obj_at_iterator(m->pairs, it);
    obmap_replace_pair_value(mp, value);
    return;
  }

  /* if add operation will overload the map then resize the map */
  if((obdeque_length(m->pairs)+1)/MAP_CAPACITIES[m->cap_idx] > MAX_LOAD_FACTOR)
    obmap_increase_size(m);

  mp = obmap_new_pair(key, value);
  obdeque_add_at_tail(m->pairs, (obj *)mp);
  ob_release((obj *)mp); /* map deque has only reference to mp */

  assert(it = obdeque_tail_iterator(m->pairs));
  obmap_add_to_table(m, it);
  ob_release((obj *)it); /* map vector hash only reference to it */

  return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1d9d
jmp 0x1dbc
leaq 0x4732(%rip), %rdi      # 0x64d6
leaq 0x46f6(%rip), %rsi      # 0x64a1
movl $0x6e, %edx
leaq 0x4721(%rip), %rcx      # 0x64d8
callq 0x1050
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1f00
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x30(%rbp), %rsi
callq 0x3370
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x1e10
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x4530
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1fd0
jmp 0x1ef0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x4810
incq %rax
movq -0x8(%rbp), %rcx
movzbl 0x8(%rcx), %ecx
movl %ecx, %edx
leaq 0x45df(%rip), %rcx      # 0x6410
movl (%rcx,%rdx,4), %ecx
xorl %edx, %edx
divq %rcx
movq %rax, %xmm0
movaps 0x45ab(%rip), %xmm1     # 0x63f0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x45af(%rip), %xmm1     # 0x6400
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd 0x4580(%rip), %xmm1     # 0x63e8
ucomisd %xmm1, %xmm0
jbe 0x1e77
movq -0x8(%rbp), %rdi
callq 0x2030
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x20d0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x45f0
movq -0x20(%rbp), %rdi
callq 0x4190
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x4910
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x1ebb
jmp 0x1eda
leaq 0x463f(%rip), %rdi      # 0x6501
leaq 0x45d8(%rip), %rsi      # 0x64a1
movl $0x83, %edx
leaq 0x4603(%rip), %rcx      # 0x64d8
callq 0x1050
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x2180
movq -0x28(%rbp), %rdi
callq 0x4190
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theck01[P]offbrand_lib/src/classes/obmap.c
// Function: obmap_find_key
ob_hash_t obmap_find_key(const obmap *m, const obj *key){

  ob_hash_t hash_value, offset;
  obmap_pair *mp;
  obdeque_iterator *it;

  hash_value = ob_hash(key)%MAP_CAPACITIES[m->cap_idx];
  offset = 0;

  while((it = (obdeque_iterator *)obvector_obj_at_index(m->hash_table, hash_value))){
    mp = (obmap_pair *)obdeque_obj_at_iterator(m->pairs, it);
    if(ob_compare(mp->key, key) == OB_EQUAL_TO)
      break;
    offset = obmap_offset_collision(offset);
    hash_value = (hash_value+offset)%MAP_CAPACITIES[m->cap_idx];
  }

  return hash_value; /* the hash value where key is actually found */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3fd0
movq -0x8(%rbp), %rcx
movzbl 0x8(%rcx), %ecx
movl %ecx, %edx
leaq 0x44e6(%rip), %rcx      # 0x6410
movl (%rcx,%rdx,4), %ecx
xorl %edx, %edx
divq %rcx
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x3370
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x1fbd
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x30(%rbp), %rsi
callq 0x4530
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x4070
movsbl %al, %eax
cmpl $0x0, %eax
jne 0x1f89
jmp 0x1fbd
movq -0x20(%rbp), %rdi
callq 0x2af0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movzbl 0x8(%rcx), %ecx
movl %ecx, %edx
leaq 0x4461(%rip), %rcx      # 0x6410
movl (%rcx,%rdx,4), %ecx
xorl %edx, %edx
divq %rcx
movq %rdx, -0x18(%rbp)
jmp 0x1f3e
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1fe9
jmp 0x2008
leaq 0x45f9(%rip), %rdi      # 0x65e9
leaq 0x44aa(%rip), %rsi      # 0x64a1
movl $0xf1, %edx
leaq 0x4613(%rip), %rcx      # 0x6616
callq 0x1050
movq -0x10(%rbp), %rdi
callq 0x4210
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x4190
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2045
jmp 0x2064
leaq 0x488f(%rip), %rdi      # 0x68db
leaq 0x444e(%rip), %rsi      # 0x64a1
movl $0x1a6, %edx            # imm = 0x1A6
leaq 0x4884(%rip), %rcx      # 0x68e3
callq 0x1050
movq -0x8(%rbp), %rax
movzbl 0x8(%rax), %eax
cmpl $0x19, %eax
jae 0x2073
jmp 0x2092
leaq 0x488b(%rip), %rdi      # 0x6905
leaq 0x4420(%rip), %rsi      # 0x64a1
movl $0x1a7, %edx            # imm = 0x1A7
leaq 0x4856(%rip), %rcx      # 0x68e3
callq 0x1050
movq -0x8(%rbp), %rax
movzbl 0x8(%rax), %ecx
addl $0x2, %ecx
movb %cl, 0x8(%rax)
movq -0x8(%rbp), %rax
movzbl 0x8(%rax), %eax
cmpl $0x1a, %eax
jb 0x20b5
movq -0x8(%rbp), %rax
movb $0x19, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x8(%rbp), %rdi
callq 0x1cb0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x18, %edi
callq 0x10a0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x20f7
jmp 0x2116
leaq 0x44ad(%rip), %rdi      # 0x65ab
leaq 0x439c(%rip), %rsi      # 0x64a1
movl $0xda, %edx
leaq 0x44af(%rip), %rcx      # 0x65c0
callq 0x1050
movq -0x18(%rbp), %rdi
leaq 0x33f(%rip), %rsi       # 0x2460
leaq 0x3d8(%rip), %rdx       # 0x2500
xorl %eax, %eax
movl %eax, %ecx
leaq 0x4ed(%rip), %r8        # 0x2620
leaq 0x434e(%rip), %r9       # 0x6488
callq 0x3e90
movq -0x8(%rbp), %rdi
callq 0x4210
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0x4210
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2199
jmp 0x21b8
leaq 0x4336(%rip), %rdi      # 0x64d6
leaq 0x42fa(%rip), %rsi      # 0x64a1
movl $0x1b7, %edx            # imm = 0x1B7
leaq 0x4776(%rip), %rcx      # 0x6929
callq 0x1050
cmpq $0x0, -0x10(%rbp)
je 0x21c1
jmp 0x21e0
leaq 0x4796(%rip), %rdi      # 0x695e
leaq 0x42d2(%rip), %rsi      # 0x64a1
movl $0x1b8, %edx            # imm = 0x1B8
leaq 0x474e(%rip), %rcx      # 0x6929
callq 0x1050
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x4530
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3fd0
movq -0x8(%rbp), %rcx
movzbl 0x8(%rcx), %ecx
movl %ecx, %edx
leaq 0x41fd(%rip), %rcx      # 0x6410
movl (%rcx,%rdx,4), %ecx
xorl %edx, %edx
divq %rcx
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x3370
cmpq $0x0, %rax
je 0x227f
movq -0x20(%rbp), %rdi
callq 0x2af0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movzbl 0x8(%rcx), %ecx
movl %ecx, %edx
leaq 0x41ac(%rip), %rcx      # 0x6410
movl (%rcx,%rdx,4), %ecx
xorl %edx, %edx
divq %rcx
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x20(%rax)
jmp 0x2227
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x30b0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x22b9
jmp 0x22d8
leaq 0x4216(%rip), %rdi      # 0x64d6
leaq 0x41da(%rip), %rsi      # 0x64a1
movl $0x91, %edx
leaq 0x4253(%rip), %rcx      # 0x6526
callq 0x1050
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1f00
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x30(%rbp), %rsi
callq 0x3370
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x230f
movq $0x0, -0x8(%rbp)
jmp 0x2330
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x4530
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2359
jmp 0x2378
leaq 0x4176(%rip), %rdi      # 0x64d6
leaq 0x413a(%rip), %rsi      # 0x64a1
movl $0xa2, %edx
leaq 0x41e1(%rip), %rcx      # 0x6554
callq 0x1050
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1f00
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x3370
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x23a7
jmp 0x23c1
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x56e0
movq -0x8(%rbp), %rdi
callq 0x1cb0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x23e5
jmp 0x2404
leaq 0x40ea(%rip), %rdi      # 0x64d6
leaq 0x40ae(%rip), %rsi      # 0x64a1
movl $0xca, %edx
leaq 0x4192(%rip), %rcx      # 0x6591
callq 0x1050
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x4190
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x4190
movq -0x8(%rbp), %rax
movzbl 0x8(%rax), %eax
movl %eax, %ecx
leaq 0x3fe1(%rip), %rax      # 0x6410
movl (%rax,%rcx,4), %edi
callq 0x2e50
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
callq 0x4380
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x247d
jmp 0x249c
leaq 0x4292(%rip), %rdi      # 0x6716
leaq 0x4016(%rip), %rsi      # 0x64a1
movl $0x12a, %edx            # imm = 0x12A
leaq 0x428a(%rip), %rcx      # 0x6721
callq 0x1050
movq -0x8(%rbp), %rdi
leaq 0x41d1(%rip), %rsi      # 0x6678
callq 0x42b0
cmpb $0x0, %al
je 0x24b2
jmp 0x24d1
leaq 0x4287(%rip), %rdi      # 0x6740
leaq 0x3fe1(%rip), %rsi      # 0x64a1
movl $0x12b, %edx            # imm = 0x12B
leaq 0x4255(%rip), %rcx      # 0x6721
callq 0x1050
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4190
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x4190
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x251d
jmp 0x253c
leaq 0x4125(%rip), %rdi      # 0x6649
leaq 0x3f76(%rip), %rsi      # 0x64a1
movl $0x101, %edx            # imm = 0x101
leaq 0x411a(%rip), %rcx      # 0x6651
callq 0x1050
movq -0x8(%rbp), %rdi
leaq 0x4131(%rip), %rsi      # 0x6678
callq 0x42b0
cmpb $0x0, %al
je 0x2552
jmp 0x2571
leaq 0x412a(%rip), %rdi      # 0x6683
leaq 0x3f41(%rip), %rsi      # 0x64a1
movl $0x102, %edx            # imm = 0x102
leaq 0x40e5(%rip), %rcx      # 0x6651
callq 0x1050
movsbl 0x7b00(%rip), %eax      # 0xa078
cmpl $0x0, %eax
jne 0x25a2
xorl %eax, %eax
movl %eax, %edi
callq 0x1090
movl %eax, %edi
callq 0x1060
callq 0x10b0
cltq
movq %rax, 0x7ae5(%rip)      # 0xa080
movb $0x1, 0x7ad6(%rip)      # 0xa078
movq 0x7ad7(%rip), %rax      # 0xa080
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3fd0
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x3fd0
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
shlq $0x3, %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
shrq $0xb, %rax
xorq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
shlq $0xf, %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x263d
jmp 0x265c
leaq 0x4063(%rip), %rdi      # 0x66a7
leaq 0x3e56(%rip), %rsi      # 0x64a1
movl $0x11a, %edx            # imm = 0x11A
leaq 0x4061(%rip), %rcx      # 0x66b8
callq 0x1050
movq -0x8(%rbp), %rdi
leaq 0x4011(%rip), %rsi      # 0x6678
callq 0x42b0
cmpb $0x0, %al
je 0x2672
jmp 0x2691
leaq 0x4064(%rip), %rdi      # 0x66dd
leaq 0x3e21(%rip), %rsi      # 0x64a1
movl $0x11b, %edx            # imm = 0x11B
leaq 0x402c(%rip), %rcx      # 0x66b8
callq 0x1050
movq 0x7960(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
leaq 0x4060(%rip), %rsi      # 0x6702
movb $0x0, %al
callq 0x1080
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4110
movq 0x793b(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
leaq 0x4044(%rip), %rsi      # 0x670b
movb $0x0, %al
callq 0x1080
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x4110
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x270d
jmp 0x272c
leaq 0x4002(%rip), %rdi      # 0x6716
leaq 0x3d86(%rip), %rsi      # 0x64a1
movl $0x19a, %edx            # imm = 0x19A
leaq 0x4178(%rip), %rcx      # 0x689f
callq 0x1050
movq -0x8(%rbp), %rdi
leaq 0x4074(%rip), %rsi      # 0x67ab
callq 0x42b0
cmpb $0x0, %al
je 0x2742
jmp 0x2761
leaq 0x4170(%rip), %rdi      # 0x68b9
leaq 0x3d51(%rip), %rsi      # 0x64a1
movl $0x19b, %edx            # imm = 0x19B
leaq 0x4143(%rip), %rcx      # 0x689f
callq 0x1050
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x4190
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x4190
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x27ad
jmp 0x27cc
leaq 0x3e95(%rip), %rdi      # 0x6649
leaq 0x3ce6(%rip), %rsi      # 0x64a1
movl $0x153, %edx            # imm = 0x153
leaq 0x3fc2(%rip), %rcx      # 0x6789
callq 0x1050
movq -0x10(%rbp), %rdi
leaq 0x3fd4(%rip), %rsi      # 0x67ab
callq 0x42b0
cmpb $0x0, %al
je 0x27e2
jmp 0x2801
leaq 0x3fc8(%rip), %rdi      # 0x67b1
leaq 0x3cb1(%rip), %rsi      # 0x64a1
movl $0x154, %edx            # imm = 0x154
leaq 0x3f8d(%rip), %rcx      # 0x6789
callq 0x1050
movsbl 0x7880(%rip), %eax      # 0xa088
cmpl $0x0, %eax
jne 0x2832
xorl %eax, %eax
movl %eax, %edi
callq 0x1090
movl %eax, %edi
callq 0x1060
callq 0x10b0
cltq
movq %rax, 0x7865(%rip)      # 0xa090
movb $0x1, 0x7856(%rip)      # 0xa088
movq 0x7857(%rip), %rax      # 0xa090
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x44e0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x285f
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x28d8
jmp 0x2861
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x4530
movq %rax, %rdi
callq 0x3fd0
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x46c0
cmpb $0x0, %al
jne 0x2861
movq -0x20(%rbp), %rdi
callq 0x4190
movq -0x18(%rbp), %rax
shlq $0x3, %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
shrq $0xb, %rax
xorq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
shlq $0xf, %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2909
jmp 0x2928
leaq 0x3ec0(%rip), %rdi      # 0x67d0
leaq 0x3b8a(%rip), %rsi      # 0x64a1
movl $0x172, %edx            # imm = 0x172
leaq 0x3eaf(%rip), %rcx      # 0x67d2
callq 0x1050
cmpq $0x0, -0x18(%rbp)
je 0x2931
jmp 0x2950
leaq 0x3ec9(%rip), %rdi      # 0x6801
leaq 0x3b62(%rip), %rsi      # 0x64a1
movl $0x173, %edx            # imm = 0x173
leaq 0x3e87(%rip), %rcx      # 0x67d2
callq 0x1050
movq -0x10(%rbp), %rdi
leaq 0x3e50(%rip), %rsi      # 0x67ab
callq 0x42b0
cmpb $0x0, %al
je 0x2966
jmp 0x2985
leaq 0x3e96(%rip), %rdi      # 0x6803
leaq 0x3b2d(%rip), %rsi      # 0x64a1
movl $0x174, %edx            # imm = 0x174
leaq 0x3e52(%rip), %rcx      # 0x67d2
callq 0x1050
movq -0x18(%rbp), %rdi
leaq 0x3e1b(%rip), %rsi      # 0x67ab
callq 0x42b0
cmpb $0x0, %al
je 0x299b
jmp 0x29ba
leaq 0x3e7a(%rip), %rdi      # 0x681c
leaq 0x3af8(%rip), %rsi      # 0x64a1
movl $0x175, %edx            # imm = 0x175
leaq 0x3e1d(%rip), %rcx      # 0x67d2
callq 0x1050
movq -0x10(%rbp), %rdi
callq 0x3fd0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3fd0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jne 0x29e2
movb $0x0, -0x1(%rbp)
jmp 0x29e6
movb $0x2, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2a0d
jmp 0x2a2c
leaq 0x3c93(%rip), %rdi      # 0x66a7
leaq 0x3a86(%rip), %rsi      # 0x64a1
movl $0x181, %edx            # imm = 0x181
leaq 0x3e0e(%rip), %rcx      # 0x6835
callq 0x1050
movq -0x8(%rbp), %rdi
leaq 0x3d74(%rip), %rsi      # 0x67ab
callq 0x42b0
cmpb $0x0, %al
je 0x2a42
jmp 0x2a61
leaq 0x3e0c(%rip), %rdi      # 0x6855
leaq 0x3a51(%rip), %rsi      # 0x64a1
movl $0x182, %edx            # imm = 0x182
leaq 0x3dd9(%rip), %rcx      # 0x6835
callq 0x1050
movq 0x7590(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
leaq 0x3e03(%rip), %rsi      # 0x6875
movb $0x0, %al
callq 0x1080
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x44e0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2a93
jmp 0x2ae4
jmp 0x2a95
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x4530
movq %rax, %rdi
callq 0x4110
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x46c0
cmpb $0x0, %al
jne 0x2a95
movq 0x752e(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
leaq 0x3dbe(%rip), %rsi      # 0x6892
movb $0x0, %al
callq 0x1080
movq -0x18(%rbp), %rdi
callq 0x4190
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x2358
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rsi, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0xe0(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x30, -0x1c(%rbp)
movl $0x8, -0x20(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x2140
movl %eax, -0x24(%rbp)
movl $0xa, %edi
callq 0x2040
movl -0x24(%rbp), %eax
incl %eax
addq $0xe0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xb83d(%rip), %rdi      # 0xf3e0
movb $0x0, %al
callq 0x2320
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0xc(%rbp)
cmpl $0x1, -0xc(%rbp)
jne 0x3bca
leaq 0xc0d8(%rip), %rdi      # 0xfc99
movb $0x0, %al
callq 0x2320
jmp 0x3c31
cmpl $0x2, -0xc(%rbp)
jne 0x3be0
leaq 0xc0de(%rip), %rdi      # 0xfcb5
movb $0x0, %al
callq 0x2320
jmp 0x3c2f
cmpl $0x4, -0xc(%rbp)
jne 0x3bf6
leaq 0xc0e4(%rip), %rdi      # 0xfcd1
movb $0x0, %al
callq 0x2320
jmp 0x3c2d
cmpl $0x8, -0xc(%rbp)
jne 0x3c0c
leaq 0xc0ec(%rip), %rdi      # 0xfcef
movb $0x0, %al
callq 0x2320
jmp 0x3c2b
leaq 0xb66f(%rip), %rdi      # 0xf282
leaq 0xb640(%rip), %rsi      # 0xf25a
movl $0x27, %edx
leaq 0xc0da(%rip), %rcx      # 0xfd00
callq 0x20b0
jmp 0x3c2d
jmp 0x3c2f
jmp 0x3c31
leaq 0xb6db(%rip), %rdi      # 0xf313
movb $0x0, %al
callq 0x2320
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xc0af(%rip), %rdi      # 0xfd12
movb $0x0, %al
callq 0x2320
leaq 0xb76f(%rip), %rdi      # 0xf3e0
movb $0x0, %al
callq 0x2320
movq -0x8(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x3cab
leaq 0xc094(%rip), %rdi      # 0xfd1c
movb $0x0, %al
callq 0x2320
leaq 0xc093(%rip), %rdi      # 0xfd29
movb $0x0, %al
callq 0x2320
leaq 0xc091(%rip), %rdi      # 0xfd35
movb $0x0, %al
callq 0x2320
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0xc(%rbp)
cmpl $0x1, -0xc(%rbp)
jne 0x3ccb
leaq 0xc084(%rip), %rdi      # 0xfd46
movb $0x0, %al
callq 0x2320
jmp 0x3d32
cmpl $0x2, -0xc(%rbp)
jne 0x3ce1
leaq 0xc07f(%rip), %rdi      # 0xfd57
movb $0x0, %al
callq 0x2320
jmp 0x3d30
cmpl $0x4, -0xc(%rbp)
jne 0x3cf7
leaq 0xc079(%rip), %rdi      # 0xfd67
movb $0x0, %al
callq 0x2320
jmp 0x3d2e
cmpl $0x8, -0xc(%rbp)
jne 0x3d0d
leaq 0xc074(%rip), %rdi      # 0xfd78
movb $0x0, %al
callq 0x2320
jmp 0x3d2c
leaq 0xb56e(%rip), %rdi      # 0xf282
leaq 0xb53f(%rip), %rsi      # 0xf25a
movl $0x48, %edx
leaq 0xc062(%rip), %rcx      # 0xfd89
callq 0x20b0
jmp 0x3d2e
jmp 0x3d30
jmp 0x3d32
leaq 0xc063(%rip), %rdi      # 0xfd9c
movb $0x0, %al
callq 0x2320
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pocari[P]compilerbook-9cc/codegen.c
// Function: cast
static void cast(Node *node) {
  printfln(" pop rax");

  if (node->ty->kind == TY_BOOL) {
    printfln("  cmp rax, 0");
    printfln("  setne al");
  }

  if (node->ty->size == 1) {
    printfln("  movsx rax, al");
  } else if (node->ty->size == 2) {
    printfln("  movsx rax, ax");
  } else if (node->ty->size == 4) {
    printfln("  movsxd rax, eax");
  }

  printfln(" push rax");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xb67e(%rip), %rdi      # 0xf3e1
movb $0x0, %al
callq 0x2320
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x2, (%rax)
jne 0x3d93
leaq 0xb6d1(%rip), %rdi      # 0xf44f
movb $0x0, %al
callq 0x2320
leaq 0xc01b(%rip), %rdi      # 0xfda7
movb $0x0, %al
callq 0x2320
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x1, 0x4(%rax)
jne 0x3db1
leaq 0xc00a(%rip), %rdi      # 0xfdb2
movb $0x0, %al
callq 0x2320
jmp 0x3def
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x2, 0x4(%rax)
jne 0x3dcf
leaq 0xbffc(%rip), %rdi      # 0xfdc2
movb $0x0, %al
callq 0x2320
jmp 0x3ded
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x4, 0x4(%rax)
jne 0x3deb
leaq 0xbfee(%rip), %rdi      # 0xfdd2
movb $0x0, %al
callq 0x2320
jmp 0x3ded
jmp 0x3def
leaq 0xb51e(%rip), %rdi      # 0xf314
movb $0x0, %al
callq 0x2320
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xb5bd(%rip), %rdi      # 0xf3e0
movb $0x0, %al
callq 0x2320
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x3e45
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x4(%rax), %eax
movl %eax, -0xc(%rbp)
jmp 0x3e4f
movl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3e4f
movl -0xc(%rbp), %esi
leaq 0xbf8b(%rip), %rdi      # 0xfde4
movb $0x0, %al
callq 0x2320
leaq 0xb4ac(%rip), %rdi      # 0xf313
movb $0x0, %al
callq 0x2320
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x4690, %rsp           # imm = 0x4690
movq %rdi, -0x8(%rbp)
movl $0x0, -0x4664(%rbp)
movl $0x0, -0x4668(%rbp)
leaq -0x4660(%rbp), %rdi
movslq -0x4664(%rbp), %rax
addq %rax, %rdi
leaq 0xaf13(%rip), %rsi      # 0x10e0e
movb $0x0, %al
callq 0x2190
addl -0x4664(%rbp), %eax
movl %eax, -0x4664(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x4670(%rbp)
cmpq $0x0, -0x4670(%rbp)
je 0x5f8b
movq -0x4670(%rbp), %rdi
callq 0x4800
movslq -0x4668(%rbp), %rcx
movq %rax, -0x1f50(%rbp,%rcx,8)
movq %rax, -0x4678(%rbp)
leaq -0x4660(%rbp), %rdi
movslq -0x4664(%rbp), %rax
addq %rax, %rdi
movq -0x4678(%rbp), %rdx
leaq 0xa588(%rip), %rsi      # 0x104ec
movb $0x0, %al
callq 0x2190
addl -0x4664(%rbp), %eax
movl %eax, -0x4664(%rbp)
movq -0x4670(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x4670(%rbp)
jmp 0x5f19
leaq -0x4660(%rbp), %rdi
movl -0x4664(%rbp), %esi
callq 0x6690
movq %rax, -0x4680(%rbp)
movl $0x0, -0x4684(%rbp)
movl -0x4684(%rbp), %eax
cmpl -0x4668(%rbp), %eax
jge 0x5fe1
movslq -0x4684(%rbp), %rax
movq -0x1f50(%rbp,%rax,8), %rdi
callq 0x2030
movl -0x4684(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4684(%rbp)
jmp 0x5fae
movq -0x4680(%rbp), %rax
addq $0x4690, %rsp           # imm = 0x4690
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x632f
movl $0x1, %edi
movl $0xc8, %esi
callq 0x20e0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x20, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x78(%rax)
movq -0x18(%rbp), %rdi
callq 0x4800
movq %rax, %rsi
leaq 0xa1fc(%rip), %rdi      # 0x10517
movb $0x0, %al
callq 0x20a0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x62d4
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
testb %al, %al
je 0x63ab
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdx, -0xe0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rax
leaq -0xf0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq -0x8(%rbp), %rdi
callq 0x64d0
movl %eax, -0x34(%rbp)
movq 0xebf2(%rip), %rax      # 0x14ff8
movq (%rax), %rdi
leaq 0xf1b0(%rip), %rax      # 0x155c0
movq (%rax), %rdx
leaq 0xa1c6(%rip), %rsi      # 0x105e0
movb $0x0, %al
callq 0x2100
movq 0xebd0(%rip), %rax      # 0x14ff8
movq (%rax), %rax
movq %rax, -0xf8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6530
movq -0xf8(%rbp), %rdi
movq %rax, %rdx
leaq 0xa0a5(%rip), %rsi      # 0x104f1
movb $0x0, %al
callq 0x2100
movq 0xeb9e(%rip), %rax      # 0x14ff8
movq (%rax), %rdi
movl -0x34(%rbp), %edx
leaq 0xa183(%rip), %rsi      # 0x105ea
leaq 0xa9a1(%rip), %rcx      # 0x10e0f
movb $0x0, %al
callq 0x2100
movq 0xeb7c(%rip), %rax      # 0x14ff8
movq (%rax), %rdi
leaq 0xa168(%rip), %rsi      # 0x105ee
movb $0x0, %al
callq 0x2100
movq 0xeb64(%rip), %rax      # 0x14ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x2180
movq 0xeb4d(%rip), %rax      # 0x14ff8
movq (%rax), %rdi
leaq 0xa959(%rip), %rsi      # 0x10e0e
movb $0x0, %al
callq 0x2100
movl $0x1, %edi
callq 0x21a0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
leaq 0xf0e9(%rip), %rax      # 0x155c8
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x8(%rbp), %rax
je 0x6523
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0x650c
movl $0x0, -0x14(%rbp)
jmp 0x6515
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x64ed
movl -0x14(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)