LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/cogbee[P]vmir-latest/src/vmir_transform.c
// Function: bb_change_branch
static void
bb_change_branch(ir_bb_t *from, ir_bb_t *to, ir_bb_t *nb, ir_function_t *f)
{
  ir_instr_t *ii;

  ii = TAILQ_LAST(&from->ib_instrs, ir_instr_queue);
  switch(ii->ii_class) {
  case IR_IC_BR:
    {
      ir_instr_br_t *b = (ir_instr_br_t *)ii;
      if(b->true_branch == to->ib_id)
        b->true_branch = nb->ib_id;

      if(b->condition.value != -1) {
        if(b->false_branch == to->ib_id)
          b->false_branch = nb->ib_id;
      }
    }
    break;
  case IR_IC_CMP_BRANCH:
    {
      ir_instr_cmp_branch_t *icb = (ir_instr_cmp_branch_t *)ii;
      if(icb->true_branch == to->ib_id)
        icb->true_branch = nb->ib_id;

      if(icb->false_branch == to->ib_id)
        icb->false_branch = nb->ib_id;
    }
    break;
  case IR_IC_SWITCH:
    {
      ir_instr_switch_t *s = (ir_instr_switch_t *)ii;
      if(s->defblock == to->ib_id)
        s->defblock = nb->ib_id;

      for(int i = 0; i < s->num_paths; i++)
        if(s->paths[i].block == to->ib_id)
          s->paths[i].block = nb->ib_id;
    }
    break;
  case IR_IC_INVOKE:
    {
      ir_instr_invoke_t *s = (ir_instr_invoke_t *)ii;
      if(s->normal_dest == to->ib_id)
        s->normal_dest = nb->ib_id;

      if(s->unwind_dest == to->ib_id)
        s->unwind_dest = nb->ib_id;
    }
    break;
  case IR_IC_RET:
    break;
  default:
    printf("Unable to transform branch for instruction class %d\n",
           ii->ii_class);
    abort();
  }

  if(ii->ii_succ != NULL) {
    free(ii->ii_succ);
    liveness_set_succ(f, ii);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq 0x18(%rdi), %rax
movq 0x8(%rax), %rax
movq (%rax), %r14
movl 0x28(%r14), %eax
cmpl $0xa, %eax
jle 0x16e2b
cmpl $0xb, %eax
je 0x16e63
cmpl $0xc, %eax
je 0x16e82
cmpl $0x19, %eax
jne 0x16ede
movl 0x28(%rsi), %eax
cmpl %eax, 0x6c(%r14)
jne 0x16e15
movl 0x28(%rdx), %ecx
movl %ecx, 0x6c(%r14)
cmpl %eax, 0x70(%r14)
jne 0x16eb9
movl 0x28(%rdx), %eax
movl %eax, 0x70(%r14)
jmp 0x16eb9
cmpl $0x1, %eax
je 0x16eb9
cmpl $0x8, %eax
jne 0x16ede
movl 0x28(%rsi), %eax
cmpl %eax, 0x60(%r14)
jne 0x16e4d
movl 0x28(%rdx), %ecx
movl %ecx, 0x60(%r14)
cmpl $-0x1, 0x58(%r14)
je 0x16eb9
cmpl %eax, 0x64(%r14)
jne 0x16eb9
movl 0x28(%rdx), %eax
movl %eax, 0x64(%r14)
jmp 0x16eb9
movl 0x28(%rsi), %eax
cmpl %eax, 0x64(%r14)
jne 0x16e73
movl 0x28(%rdx), %ecx
movl %ecx, 0x64(%r14)
cmpl %eax, 0x68(%r14)
jne 0x16eb9
movl 0x28(%rdx), %eax
movl %eax, 0x68(%r14)
jmp 0x16eb9
movl 0x28(%rsi), %eax
cmpl %eax, 0x60(%r14)
jne 0x16e92
movl 0x28(%rdx), %ecx
movl %ecx, 0x60(%r14)
movslq 0x64(%r14), %rcx
testq %rcx, %rcx
jle 0x16eb9
shlq $0x4, %rcx
xorl %esi, %esi
cmpl %eax, 0x70(%r14,%rsi)
jne 0x16eb0
movl 0x28(%rdx), %edi
movl %edi, 0x70(%r14,%rsi)
addq $0x10, %rsi
cmpq %rsi, %rcx
jne 0x16ea1
movq 0x40(%r14), %rdi
testq %rdi, %rdi
je 0x16ed6
callq 0x3030
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x16ef3
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0xf4af(%rip), %rdi      # 0x26394
movl %eax, %esi
xorl %eax, %eax
callq 0x3190
callq 0x3060
// File: /workspace/github_c_makefile_star2_O1/cogbee[P]vmir-latest/src/vmir_transform.c
// Function: combine_get_upstream_instruction
static ir_instr_t *
combine_get_upstream_instruction(ir_unit_t *iu, ir_valuetype_t vt,
                                 ir_instr_t *target)
{
  ir_value_t *iv = value_get(iu, vt.value);
  if(iv->iv_class != IR_VC_TEMPORARY)
    return NULL;

  ir_instr_t *upstream = NULL;
  ir_value_instr_t *ivi;
  LIST_FOREACH(ivi, &iv->iv_instructions, ivi_value_link) {
    switch(ivi->ivi_relation) {
    case IVI_OUTPUT:
      if(upstream != NULL)
        return NULL; /* Multiple instructions write to this value
                      * Happens only when in non SSA form
                      */
      upstream = ivi->ivi_instr;
      break;
    case IVI_INPUT:
      if(ivi->ivi_instr != target)
        return NULL; // Other instruction is using the value
      break;
    }
  }

  return upstream;
}

// Assembly:
pushq %rax
movq %rsi, %r8
movl %r8d, %eax
cmpq %rax, 0x188(%rdi)
jbe 0x17128
movq 0x180(%rdi), %rcx
movq (%rcx,%rax,8), %rax
cmpl $0x4, (%rax)
jne 0x17124
movq 0x8(%rax), %rcx
testq %rcx, %rcx
je 0x17124
xorl %eax, %eax
movl 0x30(%rcx), %esi
testl %esi, %esi
je 0x17114
cmpl $0x1, %esi
jne 0x1711a
testq %rax, %rax
jne 0x17124
movq 0x28(%rcx), %rax
jmp 0x1711a
cmpq %rdx, 0x28(%rcx)
jne 0x17124
movq (%rcx), %rcx
testq %rcx, %rcx
jne 0x170fd
jmp 0x17126
xorl %eax, %eax
popq %rcx
retq
leaq 0xe391(%rip), %rsi      # 0x254c0
leaq 0xeb3e(%rip), %rcx      # 0x25c74
movl $0x143, %edx            # imm = 0x143
xorl %eax, %eax
callq 0xca73
// File: /workspace/github_c_makefile_star2_O1/cogbee[P]vmir-latest/src/vmir_transform.c
// Function: insert_move
static void
insert_move(ir_unit_t *iu, ir_valuetype_t to, ir_valuetype_t from,
            ir_instr_t *before)
{
  ir_instr_move_t *m =
    instr_add_before(sizeof(ir_instr_move_t), IR_IC_MOVE, before);
  m->super.ii_ret = to;
  m->value = from;
  value_bind_return_value(iu, &m->super);
  instr_bind_input(iu, m->value, &m->super);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq 0x10(%rcx), %rbp
movl $0x1, %edi
movl $0x60, %esi
callq 0x32f0
movq %rax, %r13
movq $0x0, 0x20(%rax)
movabsq $-0xffffffeb, %rax      # imm = 0xFFFFFFFF00000015
movq %rax, 0x28(%r13)
movl $0xffffffff, 0x30(%r13) # imm = 0xFFFFFFFF
movq %rbp, 0x10(%r13)
movq 0x8(%rbx), %rax
movq %rax, 0x8(%r13)
movq %rbx, (%r13)
movq %r13, (%rax)
movq %r13, 0x8(%rbx)
movq %r15, 0x2c(%r13)
movq %r14, 0x58(%r13)
movq %r12, %rdi
movq %r13, %rsi
callq 0x11f77
movq 0x58(%r13), %rsi
movq %r12, %rdi
movq %r13, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x16ce0
// File: /workspace/github_c_makefile_star2_O1/cogbee[P]vmir-latest/src/vmir_type.c
// Function: type_make
static int
type_make(ir_unit_t *iu, int code)
{
  for(int i = 0; i < VECTOR_LEN(&iu->iu_types); i++) {
    ir_type_t *it = &VECTOR_ITEM(&iu->iu_types, i);
    if(it->it_code == code)
      return i;
  }

  iu->iu_types_created = 1;

  ir_type_t it;
  int r = VECTOR_LEN(&iu->iu_types);
  it.it_code = code;
  VECTOR_PUSH_BACK(&iu->iu_types, it);
  return r;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq 0x170(%rdi), %r15
testq %r15, %r15
setne %dl
je 0x177e2
movq 0x168(%r14), %rcx
xorl %eax, %eax
cmpl %ebx, (%rcx)
je 0x177e2
addq $0x28, %rcx
xorl %eax, %eax
movl $0x1, %esi
movq %rsi, %rdx
cmpq %rsi, %r15
je 0x177da
leaq 0x1(%rdx), %rsi
cmpl %ebx, (%rcx)
leaq 0x28(%rcx), %rcx
cmovel %edx, %eax
jne 0x177c3
cmpq %rdx, %r15
seta %dl
jmp 0x177e2
testb %dl, %dl
jne 0x1783f
movl $0x1, 0x368(%r14)
leaq 0x1(%r15), %r12
cmpq 0x178(%r14), %r12
jbe 0x17827
leaq (%r12,%r12), %rax
movq %rax, 0x178(%r14)
movq %r12, %rax
shlq $0x4, %rax
leaq (%rax,%rax,4), %rsi
movq 0x168(%r14), %rdi
callq 0x33c0
movq %rax, 0x168(%r14)
movq %r12, 0x170(%r14)
movq 0x168(%r14), %rax
leaq (%r15,%r15,4), %rcx
movl %ebx, (%rax,%rcx,8)
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/cogbee[P]vmir-latest/src/vmir_type.c
// Function: type_get_pointee
static unsigned int
type_get_pointee(ir_unit_t *iu, unsigned int id)
{
  ir_type_t *it = type_get(iu, id);
  if(it->it_code != IR_TYPE_POINTER)
    parser_error(iu, "Type (%s) (index:%d) is not a pointer",
                 type_str_index(iu, id), id);
  if(it->it_pointer.pointee == -1)
    parser_error(iu, "Attempting to dereference void pointer");
  return it->it_pointer.pointee;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, %eax
cmpq %rax, 0x170(%rdi)
jbe 0x17882
movq 0x168(%rbx), %rcx
leaq (%rax,%rax,4), %rax
cmpl $0xb, (%rcx,%rax,8)
jne 0x178a2
leaq (%rcx,%rax,8), %rax
movl 0x8(%rax), %eax
cmpl $-0x1, %eax
je 0x178cf
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0xe183(%rip), %rsi      # 0x25a0c
leaq 0xe1b5(%rip), %rcx      # 0x25a45
movq %rbx, %rdi
movl $0x7c, %edx
movl %ebp, %r8d
xorl %eax, %eax
callq 0xca73
movq %rbx, %rdi
movl %ebp, %esi
callq 0x12335
leaq 0xe159(%rip), %rsi      # 0x25a0c
leaq 0xf027(%rip), %rcx      # 0x268e1
movq %rbx, %rdi
movl $0x8a, %edx
movq %rax, %r8
movl %ebp, %r9d
xorl %eax, %eax
callq 0xca73
leaq 0xe136(%rip), %rsi      # 0x25a0c
leaq 0xf02a(%rip), %rcx      # 0x26907
movq %rbx, %rdi
movl $0x8c, %edx
xorl %eax, %eax
callq 0xca73
// File: /workspace/github_c_makefile_star2_O1/cogbee[P]vmir-latest/src/vmir_transform.c
// Function: emit_partial_load
static ir_instr_t *
emit_partial_load(ir_unit_t *iu, ir_instr_load_t *orig, int offset,
                  ir_instr_t *after, ir_valuetype_t ret)
{
  assert(orig->cast == -1);

  ir_instr_load_t *n =
    instr_add_after(sizeof(ir_instr_load_t), IR_IC_LOAD, after);
  n->immediate_offset = orig->immediate_offset + offset;
  n->ptr = orig->ptr;
  n->value_offset = orig->value_offset;
  n->value_offset_multiply = orig->value_offset_multiply;
  n->super.ii_ret = ret;
  n->cast = -1;

  value_bind_return_value(iu, &n->super);

  instr_bind_input(iu, n->ptr, &n->super);
  if(n->value_offset.value >= 0)
    instr_bind_input(iu, n->value_offset, &n->super);
  return &n->super;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpb $-0x1, 0x74(%rsi)
jne 0x17986
movq %r8, %r15
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %rbx
movl $0x78, %edi
movl $0x4, %esi
movq %rcx, %rdx
callq 0x16c48
movq %rax, %r14
addl 0x60(%r12), %ebp
movl %ebp, 0x60(%rax)
movq 0x58(%r12), %rax
movq %rax, 0x58(%r14)
movq 0x64(%r12), %rax
movq %rax, 0x64(%r14)
movl 0x6c(%r12), %eax
movl %eax, 0x6c(%r14)
movq %r15, 0x2c(%r14)
movb $-0x1, 0x74(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x11f77
movq 0x58(%r14), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x16ce0
cmpl $0x0, 0x64(%r14)
js 0x1797a
movq 0x64(%r14), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x16ce0
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xefa1(%rip), %rdi      # 0x2692e
leaq 0xe780(%rip), %rsi      # 0x26114
leaq 0xefa4(%rip), %rcx      # 0x2693f
movl $0xb05, %edx            # imm = 0xB05
callq 0x31e0
// File: /workspace/github_c_makefile_star2_O1/cogbee[P]vmir-latest/src/vmir_transform.c
// Function: eliminate_dead_code_in_bb
static void
eliminate_dead_code_in_bb(ir_unit_t *iu, ir_function_t *f, ir_bb_t *ib)
{
  ir_instr_t *ii, *iip;
  ir_value_instr_t *ivi;
  for(ii = TAILQ_LAST(&ib->ib_instrs, ir_instr_queue); ii != NULL; ii = iip) {
    iip = TAILQ_PREV(ii, ir_instr_queue, ii_link);
    if(ii->ii_ret.value == -1 ||
       ii->ii_class == IR_IC_VMOP ||
       ii->ii_class == IR_IC_VAARG ||
       ii->ii_class == IR_IC_CALL ||
       ii->ii_class == IR_IC_INVOKE)
      continue;

    if(ii->ii_ret.value < 1)
      continue; // Maybe need to deal with multiple ret values in the future?

    ir_value_t *output = value_get(iu, ii->ii_ret.value);

    LIST_FOREACH(ivi, &output->iv_instructions, ivi_value_link) {
      if(ivi->ivi_relation == IVI_INPUT)
        break; // Someone is using our output for input ->
    }
    if(ivi != NULL)
      continue; // -> thus continue

    instr_destroy(ii);
    output->iv_class = IR_VC_DEAD;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x18(%rsi), %rax
movq 0x8(%rax), %rax
movq (%rax), %r14
testq %r14, %r14
je 0x17a33
movq %rdi, %rbx
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
movl $0x408c00, %ebp         # imm = 0x408C00
movq %r14, %rdi
movq 0x8(%r14), %rax
movq 0x8(%rax), %rax
movq (%rax), %r14
movl 0x2c(%rdi), %r8d
cmpq %r15, %r8
je 0x179ef
movl 0x28(%rdi), %eax
cmpl $0x16, %eax
ja 0x179f6
btl %eax, %ebp
jae 0x179f6
testq %r14, %r14
jne 0x179cb
jmp 0x17a33
testl %r8d, %r8d
jle 0x179ef
cmpq %r8, 0x188(%rbx)
jbe 0x17a3c
movq 0x180(%rbx), %rax
movq (%rax,%r8,8), %r12
leaq 0x8(%r12), %rax
movq (%rax), %rax
testq %rax, %rax
je 0x17a24
cmpl $0x0, 0x30(%rax)
jne 0x17a14
jmp 0x179ef
callq 0xef89
movl $0xc, (%r12)
jmp 0x179ef
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xda7d(%rip), %rsi      # 0x254c0
leaq 0xe22a(%rip), %rcx      # 0x25c74
movq %rbx, %rdi
movl $0x143, %edx            # imm = 0x143
xorl %eax, %eax
callq 0xca73
// File: /workspace/github_c_makefile_star2_O1/cogbee[P]vmir-latest/src/vmir_transform.c
// Function: liveness_set_value
static void
liveness_set_value(uint32_t *bs, ir_unit_t *iu, ir_valuetype_t vt)
{
  int value = vt.value;
  ir_value_t *iv = VECTOR_ITEM(&iu->iu_values, value);
  if(iv->iv_class != IR_VC_TEMPORARY)
    return;

  value -= iu->iu_first_func_value;
  assert(value >= 0);

  bitset(bs, value);
}

// Assembly:
movq 0x180(%rsi), %rax
movslq %edx, %rcx
movq (%rax,%rcx,8), %rax
cmpl $0x4, (%rax)
jne 0x17d7e
subl 0x19c(%rsi), %edx
js 0x17d7f
movl $0x1, %eax
movl %edx, %ecx
shll %cl, %eax
shrl $0x5, %edx
orl %eax, (%rdi,%rdx,4)
retq
pushq %rax
leaq 0xecb2(%rip), %rdi      # 0x26a39
leaq 0xe386(%rip), %rsi      # 0x26114
leaq 0xecaf(%rip), %rcx      # 0x26a44
movl $0x537, %edx            # imm = 0x537
callq 0x31e0
// File: /workspace/github_c_makefile_star2_O1/cogbee[P]vmir-latest/src/vmir_value.c
// Function: value_get_const64
static uint64_t __attribute__((unused))
value_get_const64(ir_unit_t *iu, const ir_value_t *iv)
{
  assert(iv->iv_class == IR_VC_CONSTANT);

  ir_type_t *it = type_get(iu, iv->iv_type);
  switch(it->it_code) {
  case IR_TYPE_INT1:
    return !!iv->iv_u32;
  case IR_TYPE_INT8:
  case IR_TYPE_INT16:
  case IR_TYPE_INT32:
  case IR_TYPE_POINTER:
    return iv->iv_u32;
  case IR_TYPE_INTx:
  case IR_TYPE_INT64:
  case IR_TYPE_DOUBLE:
    return iv->iv_u64;
  default:
    parser_error(iu, "Unable to get_constant for type %s",
                 type_str(iu, it));
  }
}

// Assembly:
pushq %rbx
cmpl $0x3, (%rsi)
jne 0x1d531
movq %rdi, %rbx
movl 0x24(%rsi), %r8d
cmpq %r8, 0x170(%rdi)
jbe 0x1d550
movq 0x168(%rbx), %rax
leaq (%r8,%r8,4), %rcx
movl (%rax,%rcx,8), %edx
cmpl $0xb, %edx
ja 0x1d56d
movl $0x838, %edi            # imm = 0x838
btl %edx, %edi
jb 0x1d51c
movl $0x2c0, %edi            # imm = 0x2C0
btl %edx, %edi
jae 0x1d521
movq 0x30(%rsi), %rax
jmp 0x1d51f
movl 0x30(%rsi), %eax
popq %rbx
retq
cmpl $0x2, %edx
jne 0x1d56d
xorl %eax, %eax
cmpl $0x0, 0x30(%rsi)
setne %al
jmp 0x1d51f
leaq 0x987a(%rip), %rdi      # 0x26db2
leaq 0x7f81(%rip), %rsi      # 0x254c0
leaq 0x988b(%rip), %rcx      # 0x26dd1
movl $0x207, %edx            # imm = 0x207
callq 0x31e0
leaq 0x84b5(%rip), %rsi      # 0x25a0c
leaq 0x84e7(%rip), %rcx      # 0x25a45
movq %rbx, %rdi
movl $0x7c, %edx
xorl %eax, %eax
callq 0xca73
leaq (%rax,%rcx,8), %rsi
movq %rbx, %rdi
callq 0x4112
leaq 0x7f40(%rip), %rsi      # 0x254c0
leaq 0x9886(%rip), %rcx      # 0x26e0d
movq %rbx, %rdi
movl $0x218, %edx            # imm = 0x218
movq %rax, %r8
xorl %eax, %eax
callq 0xca73
// File: /workspace/github_c_makefile_star2_O1/cogbee[P]vmir-latest/src/vmir_vm.c
// Function: emit_op3
static void
emit_op3(ir_unit_t *iu, vm_op_t op,
         uint16_t a1, uint16_t a2, uint16_t a3)
{
  emit_i16(iu, vm_resolve(op));
  emit_i16(iu, a1);
  emit_i16(iu, a2);
  emit_i16(iu, a3);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %r8d, %ebp
movl %ecx, %r14d
movl %edx, %r15d
movq %rdi, %rbx
leaq 0x6(%rsp), %rdi
movw %si, (%rdi)
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x4193
movq 0x438(%rbx), %rdx
movq 0x440(%rbx), %rcx
leaq 0x2(%rcx), %rsi
addq 0x448(%rbx), %rdx
cmpq %rdx, %rsi
jae 0x1d62f
movw %ax, (%rcx)
movq %rsi, 0x440(%rbx)
leaq 0x4(%rcx), %rax
cmpq %rdx, %rax
jae 0x1d62f
movw %r15w, 0x2(%rcx)
movq %rax, 0x440(%rbx)
leaq 0x6(%rcx), %rax
cmpq %rdx, %rax
jae 0x1d62f
movw %r14w, 0x4(%rcx)
movq %rax, 0x440(%rbx)
addq $0x8, %rcx
cmpq %rdx, %rcx
jae 0x1d62f
movw %bp, (%rax)
movq %rcx, 0x440(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x9610(%rip), %rsi      # 0x26c46
leaq 0x964b(%rip), %rcx      # 0x26c88
movq %rbx, %rdi
movl $0x926, %edx            # imm = 0x926
xorl %eax, %eax
callq 0xca73
// File: /workspace/github_c_makefile_star2_O1/cogbee[P]vmir-latest/src/vmir_vm.c
// Function: emit_i8
static void
emit_i8(ir_unit_t *iu, uint8_t i8)
{
  if(iu->iu_text_ptr + 2 >= iu->iu_text_alloc + iu->iu_text_alloc_memsize)
    parser_error(iu, "Function too big");
  *(uint8_t *)iu->iu_text_ptr = i8;
  iu->iu_text_ptr += 2; // We always align to 16 bits
}

// Assembly:
movq 0x438(%rdi), %rcx
movq 0x440(%rdi), %rax
leaq 0x2(%rax), %rdx
addq 0x448(%rdi), %rcx
cmpq %rcx, %rdx
jae 0x1d70f
movb %sil, (%rax)
addq $0x2, 0x440(%rdi)
retq
pushq %rax
leaq 0x952f(%rip), %rsi      # 0x26c46
leaq 0x956a(%rip), %rcx      # 0x26c88
movl $0x93f, %edx            # imm = 0x93F
xorl %eax, %eax
callq 0xca73
// File: /workspace/github_c_makefile_star2_O1/cogbee[P]vmir-latest/src/vmir_vm.c
// Function: emit_op4
static void
emit_op4(ir_unit_t *iu, vm_op_t op,
         uint16_t a1, uint16_t a2, uint16_t a3, uint16_t a4)
{
  emit_i16(iu, vm_resolve(op));
  emit_i16(iu, a1);
  emit_i16(iu, a2);
  emit_i16(iu, a3);
  emit_i16(iu, a4);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %r9d, %ebp
movl %r8d, %r14d
movl %ecx, %r15d
movl %edx, %r12d
movq %rdi, %rbx
leaq 0xe(%rsp), %rdi
movw %si, (%rdi)
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x4193
movq 0x438(%rbx), %rdx
movq 0x440(%rbx), %rcx
leaq 0x2(%rcx), %rsi
addq 0x448(%rbx), %rdx
cmpq %rdx, %rsi
jae 0x1d868
movw %ax, (%rcx)
movq %rsi, 0x440(%rbx)
leaq 0x4(%rcx), %rax
cmpq %rdx, %rax
jae 0x1d868
movw %r12w, 0x2(%rcx)
movq %rax, 0x440(%rbx)
leaq 0x6(%rcx), %rax
cmpq %rdx, %rax
jae 0x1d868
movw %r15w, 0x4(%rcx)
movq %rax, 0x440(%rbx)
leaq 0x8(%rcx), %rax
cmpq %rdx, %rax
jae 0x1d868
movw %r14w, 0x6(%rcx)
movq %rax, 0x440(%rbx)
addq $0xa, %rcx
cmpq %rdx, %rcx
jae 0x1d868
movw %bp, (%rax)
movq %rcx, 0x440(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x93d7(%rip), %rsi      # 0x26c46
leaq 0x9412(%rip), %rcx      # 0x26c88
movq %rbx, %rdi
movl $0x926, %edx            # imm = 0x926
xorl %eax, %eax
callq 0xca73
// File: /workspace/github_c_makefile_star2_O1/cogbee[P]vmir-latest/src/vmir_type.c
// Function: type_bitwidth
static unsigned int
type_bitwidth(ir_unit_t *iu, const ir_type_t *it)
{
  switch(it->it_code) {
  case IR_TYPE_VOID:
    return 0;
  case IR_TYPE_INT1:
    return 1;
  case IR_TYPE_INT8:
    return 8;
  case IR_TYPE_INT16:
    return 16;
  case IR_TYPE_INT32:
    return 32;
  case IR_TYPE_INT64:
    return 64;
  case IR_TYPE_INTx:
    return it->it_bits;

  default:
    parser_error(iu, "Unable to compute bitwidth of type %s\n",
                 type_str(iu, it));
  }
}

// Assembly:
movl (%rsi), %eax
decl %eax
cmpl $0x6, %eax
ja 0x1d8c3
leaq 0x6ddf(%rip), %rcx      # 0x24674
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
xorl %eax, %eax
retq
movl $0x20, %eax
retq
movl $0x8, %eax
retq
movl $0x10, %eax
retq
movl $0x1, %eax
retq
movl $0x40, %eax
retq
movl 0x8(%rsi), %eax
retq
pushq %rbx
movq %rdi, %rbx
callq 0x4112
leaq 0x8139(%rip), %rsi      # 0x25a0c
leaq 0x9968(%rip), %rcx      # 0x27242
movq %rbx, %rdi
movl $0x1b5, %edx            # imm = 0x1B5
movq %rax, %r8
xorl %eax, %eax
callq 0xca73
// File: /workspace/github_c_makefile_star2_O1/cogbee[P]vmir-latest/src/vmir_vm.c
// Function: bb_to_offset_delta
static int16_t
bb_to_offset_delta(ir_unit_t *iu, ir_function_t *f, int bbi, int off)
{
  ir_bb_t *bb = bb_find(f, bbi);
  if(bb == NULL) {
    vmir_log(iu, VMIR_LOG_FAIL, "%s() basic block %d not found during fixup",
             f->if_name, bbi);
    abort();
  }
  // The 2 is here because we need to compensate that the instruction
  // stream is past the opcode when the branch is executed
  int o = bb->ib_text_offset - (off + 2);

  assert(o >= INT16_MIN);
  assert(o <= INT16_MAX);
  return o;
}

// Assembly:
pushq %rax
movl %edx, %r8d
leaq 0x48(%rsi), %rax
movq (%rax), %rax
testq %rax, %rax
je 0x1d904
cmpl %r8d, 0x28(%rax)
jne 0x1d8f4
jmp 0x1d906
xorl %eax, %eax
testq %rax, %rax
je 0x1d923
movl 0x20(%rax), %eax
subl %ecx, %eax
addl $-0x2, %eax
cmpl $0xffff7fff, %eax       # imm = 0xFFFF7FFF
jle 0x1d93c
cmpl $0x8000, %eax           # imm = 0x8000
jge 0x1d95b
popq %rcx
retq
movq 0x20(%rsi), %rcx
leaq 0x9bc1(%rip), %rdx      # 0x274ef
xorl %esi, %esi
xorl %eax, %eax
callq 0x4045
callq 0x3060
leaq 0x9bd7(%rip), %rdi      # 0x2751a
leaq 0x92fc(%rip), %rsi      # 0x26c46
leaq 0x9bd8(%rip), %rcx      # 0x27529
movl $0x1258, %edx           # imm = 0x1258
callq 0x31e0
leaq 0x9c0a(%rip), %rdi      # 0x2756c
leaq 0x92dd(%rip), %rsi      # 0x26c46
leaq 0x9bb9(%rip), %rcx      # 0x27529
movl $0x1259, %edx           # imm = 0x1259
callq 0x31e0
// File: /workspace/github_c_makefile_star2_O1/cogbee[P]vmir-latest/src/vmir_bitstream.c
// Function: read_vbr
static uint32_t
read_vbr(bcbitstream_t *bs, int width)
{
  assert(width > 0);

  uint32_t ret = 0;
  const uint32_t cont = (1 << (width - 1));
  const uint32_t mask = cont - 1;
  int stride = 0;

  while(1) {
    uint32_t x = read_bits(bs, width);
    ret |= (x & mask) << stride;
    if(cont & x) {
      stride += width - 1;
      assert(stride < 32);
    } else {
      break;
    }
  }
  return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testl %esi, %esi
jle 0x1da04
movl %esi, %ebx
movq %rdi, %r14
leal -0x1(%rbx), %ecx
movl $0x1, %r13d
movl %ecx, 0x4(%rsp)
shll %cl, %r13d
leal -0x1(%r13), %ebp
xorl %r15d, %r15d
xorl %r12d, %r12d
movq %r14, %rdi
movl %ebx, %esi
callq 0xc0fb
movl %eax, %edx
andl %ebp, %edx
movl %r15d, %ecx
shll %cl, %edx
testl %r13d, %eax
je 0x1d9cb
addl 0x4(%rsp), %r15d
cmpl $0x20, %r15d
jge 0x1d9e5
orl %edx, %r12d
testl %r13d, %eax
jne 0x1d9a8
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x9c9f(%rip), %rdi      # 0x2768b
leaq 0x9c5b(%rip), %rsi      # 0x2764e
leaq 0x9c69(%rip), %rcx      # 0x27663
movl $0x5c, %edx
callq 0x31e0
leaq 0x9c39(%rip), %rdi      # 0x27644
leaq 0x9c3c(%rip), %rsi      # 0x2764e
leaq 0x9c4a(%rip), %rcx      # 0x27663
movl $0x50, %edx
callq 0x31e0
// File: /workspace/github_c_makefile_star2_O1/cogbee[P]vmir-latest/src/vmir_bitcode_parser.c
// Function: blockinfo_find
static ir_blockinfo_t *
blockinfo_find(ir_unit_t *iu, int id)
{
  ir_blockinfo_t *ib;
  LIST_FOREACH(ib, &iu->iu_blockinfos, ib_link) {
    if(ib->ib_id == id)
      return ib;
  }
  ib = calloc(1, sizeof(ir_blockinfo_t));
  ib->ib_id = id;
  LIST_INSERT_HEAD(&iu->iu_blockinfos, ib, ib_link);
  TAILQ_INIT(&ib->ib_abbrevs);
  return ib;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
addq $0x138, %rbx            # imm = 0x138
movq %rbx, %rax
movq (%rax), %rax
testq %rax, %rax
je 0x1da44
cmpl %ebp, 0x10(%rax)
jne 0x1da35
jmp 0x1da7f
movl $0x1, %edi
movl $0x28, %esi
callq 0x32f0
movl %ebp, 0x10(%rax)
movq (%rbx), %rcx
movq %rcx, (%rax)
testq %rcx, %rcx
je 0x1da65
movq %rax, 0x8(%rcx)
movq %rax, (%rbx)
movq %rbx, 0x8(%rax)
movq %rax, %rcx
addq $0x18, %rcx
movq $0x0, 0x18(%rax)
movq %rcx, 0x20(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/cogbee[P]vmir-latest/src/vmir_bitcode_parser.c
// Function: blockinfo_rec_handler
static void
blockinfo_rec_handler(ir_unit_t *iu, int op,
                      unsigned int argc, const int64_t *argv)
{
  ir_block_t *ib = LIST_FIRST(&iu->iu_blocks);
  switch(op) {

  case 1: // SETBID
    if(argc != 1)
      parser_error(iu, "Bad number of args (%d) for SETBID", argc);

    ib->ib_blockinfo = blockinfo_find(iu, argv[0]);
    break;
  }
}

// Assembly:
pushq %rbx
cmpl $0x1, %esi
jne 0x1daa6
movl %edx, %r8d
cmpl $0x1, %edx
jne 0x1daa8
movq 0x140(%rdi), %rbx
movl (%rcx), %esi
callq 0x1da23
movq %rax, 0x20(%rbx)
popq %rbx
retq
leaq 0x9adc(%rip), %rsi      # 0x2758b
leaq 0x9be1(%rip), %rcx      # 0x27697
movl $0x60, %edx
xorl %eax, %eax
callq 0xca73
// File: /workspace/github_c_makefile_star2_O1/cogbee[P]vmir-latest/src/vmir_bitcode_parser.c
// Function: paramattr_rec_handler
static void
paramattr_rec_handler(ir_unit_t *iu, int op,
                      unsigned int argc, const int64_t *argv)
{
  int off;
  const char *ctx = "paramattr";

  switch(op) {
  case 2:
    off = VECTOR_LEN(&iu->iu_attrsets);
    VECTOR_RESIZE(&iu->iu_attrsets, off + 1);
    ir_attrset_t *ias = &VECTOR_ITEM(&iu->iu_attrsets, off);
    ias->ias_list = malloc(argc * sizeof(const ir_attr_t *));
    ias->ias_size = argc;
    for(int i = 0; i < argc; i++) {
      const ir_attr_t *ia;
      LIST_FOREACH(ia, &iu->iu_attribute_groups, ia_link) {
        if(ia->ia_group_id == argv[i])
          break;
      }

      if(ia == NULL)
        parser_error(iu, "%s: Group %d not found",
                            ctx, (int)argv[i]);

      ias->ias_list[i] = ia;
    }
    break;

  default:
    parser_error(iu, "Unknown op %d in paramattr", op);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x2, %esi
jne 0x1dfae
movq %rcx, %r14
movl %edx, %ebp
movq 0x158(%rbx), %r12
leal 0x1(%r12), %eax
movslq %eax, %r15
cmpq %r15, 0x160(%rbx)
jae 0x1df15
addl %eax, %eax
movslq %eax, %rsi
movq %rsi, 0x160(%rbx)
shlq $0x4, %rsi
movq 0x150(%rbx), %rdi
callq 0x33c0
movq %rax, 0x150(%rbx)
movq %r15, 0x158(%rbx)
movq 0x150(%rbx), %r15
movslq %r12d, %r12
shlq $0x4, %r12
movl %ebp, %r13d
leaq (,%r13,8), %rdi
callq 0x3380
movq %rax, 0x8(%r15,%r12)
movl %ebp, (%r15,%r12)
testl %ebp, %ebp
je 0x1df75
leaq 0x148(%rbx), %rcx
xorl %eax, %eax
movq %rcx, %rdx
movq (%rdx), %rdx
testq %rdx, %rdx
je 0x1df84
movl 0x10(%rdx), %esi
cmpq %rsi, (%r14,%rax,8)
jne 0x1df53
movq 0x8(%r15,%r12), %rsi
movq %rdx, (%rsi,%rax,8)
incq %rax
cmpq %r13, %rax
jne 0x1df50
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %eax
movl (%r14,%rax,8), %r9d
leaq 0x95fa(%rip), %rsi      # 0x2758b
leaq 0x979b(%rip), %rcx      # 0x27733
leaq 0x97bc(%rip), %r8       # 0x2775b
movq %rbx, %rdi
movl $0x16b, %edx            # imm = 0x16B
xorl %eax, %eax
callq 0xca73
movl %esi, %r8d
leaq 0x95d3(%rip), %rsi      # 0x2758b
leaq 0x978b(%rip), %rcx      # 0x2774a
movq %rbx, %rdi
movl $0x172, %edx            # imm = 0x172
xorl %eax, %eax
callq 0xca73
// File: /workspace/github_c_makefile_star2_O1/cogbee[P]vmir-latest/src/vmir_bitcode_parser.c
// Function: value_symtab_rec_handler
static void
value_symtab_rec_handler(ir_unit_t *iu, int op,
                         unsigned int argc, const int64_t *argv)
{
  unsigned int vid;
  char *str;
  switch(op) {
  case 1: // VST_CODE_ENTRY
    if(argc < 2)
      parser_error(iu, "Bad args to VST_CODE_ENTRY");

    vid = argv[0];
    str = read_str_from_argv(argc - 1, argv + 1);
    set_value_name(iu, vid, str);
    break;

  case 2: // VST_CODE_BBENTRY
    break;

  case 3: // VST_CODE_FNENTRY
    if(argc < 3)
      break;
    // cogbee
      // parser_error(iu, "Bad args to VST_CODE_FNENTRY");

    vid = argv[0];
    str = read_str_from_argv(argc - 2, argv + 2);
    set_value_name(iu, vid, str);
    break;

  default:
    parser_error(iu, "Unknown op %d in symtab\n", op);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r14
movl %edx, %r15d
movq %rdi, %rbx
cmpl $0x3, %esi
je 0x1f9a2
movl %esi, %r8d
cmpl $0x2, %esi
je 0x1f9a8
cmpl $0x1, %r8d
jne 0x1f9f4
cmpl $0x1, %r15d
jbe 0x1fa11
movl (%r14), %ebp
movl %r15d, %edi
decl %r15d
callq 0x3380
movb $0x0, (%rax,%r15)
testl %r15d, %r15d
je 0x1f9df
xorl %ecx, %ecx
movb 0x8(%r14,%rcx,8), %dl
movb %dl, (%rax,%rcx)
incq %rcx
cmpq %rcx, %r15
jne 0x1f990
jmp 0x1f9df
cmpl $0x3, %r15d
jae 0x1f9b1
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl (%r14), %ebp
leal -0x2(%r15), %r12d
decl %r15d
movq %r15, %rdi
callq 0x3380
movb $0x0, (%rax,%r12)
testl %r12d, %r12d
je 0x1f9df
xorl %ecx, %ecx
movb 0x10(%r14,%rcx,8), %dl
movb %dl, (%rax,%rcx)
incq %rcx
cmpq %rcx, %r12
jne 0x1f9cf
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x20c18
leaq 0x7b90(%rip), %rsi      # 0x2758b
leaq 0x827a(%rip), %rcx      # 0x27c7c
movq %rbx, %rdi
movl $0x1ec, %edx            # imm = 0x1EC
xorl %eax, %eax
callq 0xca73
leaq 0x7b73(%rip), %rsi      # 0x2758b
leaq 0x8242(%rip), %rcx      # 0x27c61
movq %rbx, %rdi
movl $0x1d6, %edx            # imm = 0x1D6
xorl %eax, %eax
callq 0xca73
// File: /workspace/github_c_makefile_star2_O1/cogbee[P]vmir-latest/src/vmir_bitcode_parser.c
// Function: strtab_rec_handler
static void strtab_rec_handler(ir_unit_t *iu, int op, 
                  unsigned int argc, const int64_t *argv) {

  // Set Function name.
  for(int i = 0; i < VECTOR_LEN(&iu->iu_functions); i++) {
    ir_function_t *f = VECTOR_ITEM(&iu->iu_functions, i);
    int str_offset = f->str_offset;
    int str_size = f->str_size;
    f->if_name = read_str_from_argv(str_size, argv + str_offset);
    // printf("f->f_name=%s\n", f->if_name);

    if(f->if_ext_func == NULL) {
      if(!vmop_resolve(f)) {
        f->if_ext_func =
          (void *)iu->iu_external_function_resolver(f->if_name, iu->iu_opaque);
      }
    }
  }

  // Set global variable name.
  for(int i = 0; i < VECTOR_LEN(&iu->iu_values); i++) {
    ir_value_t *iv = VECTOR_ITEM(&iu->iu_values, i);
    if(iv == NULL)
      continue;
    if (iv->iv_class == IR_VC_GLOBALVAR) {
      iv->iv_gvar->ig_name = read_str_from_argv(iv->iv_gvar->str_size, argv + iv->iv_gvar->str_offset);
      // printf("iv->iv_gvar->ig_name=%s\n", iv->iv_gvar->ig_name);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, (%rsp)
movq %rdi, %r14
cmpq $0x0, 0x2e0(%rdi)
je 0x1fe7d
xorl %r12d, %r12d
movq 0x2d8(%r14), %rax
movq (%rax,%r12,8), %r15
movslq 0x14(%r15), %rbp
movl 0x18(%r15), %r13d
leal 0x1(%r13), %edi
callq 0x3380
movb $0x0, (%rax,%r13)
testq %r13, %r13
je 0x1fe4b
movq (%rsp), %rcx
leaq (%rcx,%rbp,8), %rcx
xorl %edx, %edx
movb (%rcx,%rdx,8), %sil
movb %sil, (%rax,%rdx)
incq %rdx
cmpq %rdx, %r13
jne 0x1fe3b
movq %rax, 0x20(%r15)
cmpq $0x0, 0x70(%r15)
jne 0x1fe71
movq %r15, %rdi
callq 0xf293
testl %eax, %eax
jne 0x1fe71
movq 0x20(%r15), %rdi
movq 0x48(%r14), %rsi
callq *(%r14)
movq %rax, 0x70(%r15)
incq %r12
cmpq %r12, 0x2e0(%r14)
ja 0x1fe0b
movq 0x188(%r14), %r15
testq %r15, %r15
je 0x1fee9
movq 0x180(%r14), %r14
xorl %r12d, %r12d
movq (%r14,%r12,8), %r13
testq %r13, %r13
je 0x1fee1
cmpl $0x2, (%r13)
jne 0x1fee1
movq 0x30(%r13), %rax
movl 0x18(%rax), %ebp
movslq 0x14(%rax), %rbx
leal 0x1(%rbp), %edi
callq 0x3380
movb $0x0, (%rax,%rbp)
testq %rbp, %rbp
je 0x1fed9
movq (%rsp), %rcx
leaq (%rcx,%rbx,8), %rcx
xorl %edx, %edx
movb (%rcx,%rdx,8), %sil
movb %sil, (%rax,%rdx)
incq %rdx
cmpq %rdx, %rbp
jne 0x1fec9
movq 0x30(%r13), %rcx
movq %rax, 0x20(%rcx)
incq %r12
cmpq %r15, %r12
jne 0x1fe93
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/cogbee[P]vmir-latest/src/vmir_bitstream.c
// Function: printargs
static void
printargs(const int64_t *argv, unsigned int argc)
{
  int i, x;
  int64_t v;
  for(x = 0; x < 2; x++) {
    for(i = 0; i < argc; i++) {
      v = argv[i];
      if(x == 0) {
        printf("%c", (v >= ' ' && v <= 0x7f) ? (char)v : '.');
      } else {
        printf("<0x%" PRIx64 ">", v);
      }
    }
    printf("\n");
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl %esi, 0x4(%rsp)
movl %esi, %r12d
movl $0x2e, %ebp
leaq 0x7811(%rip), %r15      # 0x2772b
xorl %r13d, %r13d
cmpl $0x0, 0x4(%rsp)
je 0x1ff57
xorl %ebx, %ebx
movq (%r14,%rbx,8), %rsi
testl %r13d, %r13d
je 0x1ff3b
movq %r15, %rdi
xorl %eax, %eax
callq 0x3190
jmp 0x1ff4f
leaq -0x20(%rsi), %rax
cmpq $0x60, %rax
movsbl %sil, %edi
cmovael %ebp, %edi
callq 0x3040
incq %rbx
cmpq %rbx, %r12
jne 0x1ff26
movl $0xa, %edi
callq 0x3040
leal 0x1(%r13), %eax
testl %r13d, %r13d
movl %eax, %r13d
je 0x1ff1d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/cogbee[P]vmir-latest/src/vmir_bitstream.c
// Function: read_zstr_from_argv
static char *
read_zstr_from_argv(unsigned int *argcp, const int64_t **argvp)
{
  int len = 0;
  const int64_t *argv = *argvp;
  int argc = *argcp;
  for(len = 0; len < argc; len++) {
    if(argv[len] == 0)
      break;
  }
  if(len == argc)
    return NULL;
  len++;
  char *s = malloc(len);

  *argvp = argv + len;
  *argcp = argc - len;


  for(len = 0; len < argc; len++) {
    s[len] = argv[len];
    if(argv[len] == 0)
      break;
  }
  return s;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %r15
movl (%rdi), %r12d
xorl %r13d, %r13d
testl %r12d, %r12d
jle 0x1ffad
cmpq $0x0, (%r15,%r13,8)
je 0x1ffad
incq %r13
cmpq %r13, %r12
jne 0x1ff9b
movl %r12d, %r13d
cmpl %r12d, %r13d
jne 0x1ffb6
xorl %eax, %eax
jmp 0x1fff8
movl %r13d, %ebp
leaq 0x1(%rbp), %rdi
callq 0x3380
leaq (%r15,%rbp,8), %rcx
addq $0x8, %rcx
movq %rcx, (%r14)
notl %r13d
addl %r12d, %r13d
movl %r13d, (%rbx)
testl %r12d, %r12d
jle 0x1fff8
decq %r12
xorl %ecx, %ecx
movq (%r15,%rcx,8), %rdx
movb %dl, (%rax,%rcx)
testq %rdx, %rdx
je 0x1fff8
leaq 0x1(%rcx), %rdx
cmpq %rcx, %r12
movq %rdx, %rcx
jne 0x1ffe0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/cogbee[P]vmir-latest/src/vmir_bitcode_instr.c
// Function: parse_store
static void
parse_store(ir_unit_t *iu, unsigned int argc, const int64_t *argv,
            int old)
{
  ir_bb_t *ib = iu->iu_current_bb;

  ir_instr_store_t *i = instr_add(ib, sizeof(ir_instr_store_t), IR_IC_STORE);
  i->immediate_offset = 0;
  i->ptr   = instr_get_vtp(iu, &argc, &argv);
  if(old)
    i->value = instr_get_value(iu, &argc, &argv,
                               type_get_pointee(iu, i->ptr.type));
  else
    i->value = instr_get_vtp(iu, &argc, &argv);

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebp
movq %rdi, %rbx
leaq 0xc(%rsp), %r15
movl %esi, (%r15)
leaq 0x10(%rsp), %r12
movq %rdx, (%r12)
movq 0x1c8(%rdi), %r13
movl $0x1, %edi
movl $0x70, %esi
callq 0x32f0
movq %rax, %r14
xorl %eax, %eax
movq %rax, 0x20(%r14)
movabsq $-0xfffffffb, %rcx      # imm = 0xFFFFFFFF00000005
movq %rcx, 0x28(%r14)
movl $0xffffffff, 0x30(%r14) # imm = 0xFFFFFFFF
movq %r13, 0x10(%r14)
movq %rax, (%r14)
movq 0x18(%r13), %rax
movq %rax, 0x8(%r14)
movq %r14, (%rax)
movq %r14, 0x18(%r13)
movl $0x0, 0x68(%r14)
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x20a91
movq %rax, 0x58(%r14)
testl %ebp, %ebp
je 0x200d1
movl 0x5c(%r14), %esi
movq %rbx, %rdi
callq 0x1784b
movl 0xc(%rsp), %ecx
testl %ecx, %ecx
jle 0x200f6
movq 0x10(%rsp), %rdx
leaq 0x8(%rdx), %rsi
movq %rsi, 0x10(%rsp)
decl %ecx
movl %ecx, 0xc(%rsp)
movl 0x198(%rbx), %ecx
subl (%rdx), %ecx
shlq $0x20, %rax
orq %rax, %rcx
movq %rcx, 0x60(%r14)
jmp 0x200e7
leaq 0xc(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x20a91
movq %rax, 0x60(%r14)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x78d2(%rip), %rsi      # 0x279cf
leaq 0x7968(%rip), %rcx      # 0x27a6c
movq %rbx, %rdi
movl $0x3c, %edx
xorl %eax, %eax
callq 0xca73
// File: /workspace/github_c_makefile_star2_O1/cogbee[P]vmir-latest/src/vmir_bitcode_instr.c
// Function: parse_landingpad
static void
parse_landingpad(ir_unit_t *iu, unsigned int argc, const int64_t *argv,
                 int old)
{
  ir_bb_t *ib = iu->iu_current_bb;

  unsigned int type = instr_get_uint(iu, &argc, &argv);

  if(old) {
    instr_get_vtp(iu, &argc, &argv);
  }
  unsigned int is_clean_up = instr_get_uint(iu, &argc, &argv);
  unsigned int num_clauses = instr_get_uint(iu, &argc, &argv);

  ir_instr_landingpad_t *i =
    instr_add(ib, sizeof(ir_instr_landingpad_t) +
              sizeof(ir_instr_landingpad_clause_t) * num_clauses,
              IR_IC_LANDINGPAD);

  i->type = type;
  //  i->personality = personality;
  i->is_clean_up = is_clean_up;
  i->num_clauses = num_clauses;

  for(int j = 0; j < num_clauses; j++) {
    i->clauses[j].clause = instr_get_uint(iu, &argc, &argv);
    i->clauses[j].is_catch = instr_get_uint(iu, &argc, &argv);
  }

  value_alloc_instr_ret(iu, i->type, &i->super);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl %esi, 0x4(%rsp)
movq %rdx, 0x8(%rsp)
testl %esi, %esi
jle 0x20a74
movq 0x1c8(%rbx), %r14
leaq 0x8(%rdx), %rax
movq %rax, 0x8(%rsp)
decl %esi
movl %esi, 0x4(%rsp)
movl (%rdx), %ebp
testl %ecx, %ecx
je 0x20949
leaq 0x4(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x20a91
movl 0x4(%rsp), %eax
testl %eax, %eax
jle 0x20a74
movq 0x8(%rsp), %rcx
leaq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rsp)
leal -0x1(%rax), %edx
movl %edx, 0x4(%rsp)
cmpl $0x1, %eax
je 0x20a74
movl (%rcx), %r12d
leaq 0x10(%rcx), %rdx
movq %rdx, 0x8(%rsp)
addl $-0x2, %eax
movl %eax, 0x4(%rsp)
movq 0x8(%rcx), %r15
movl %r15d, %eax
leaq 0x68(,%rax,8), %rsi
movl $0x1, %edi
callq 0x32f0
xorl %ecx, %ecx
movq %rcx, 0x20(%rax)
movabsq $-0xffffffee, %rdx      # imm = 0xFFFFFFFF00000012
movq %rdx, 0x28(%rax)
movl $0xffffffff, 0x30(%rax) # imm = 0xFFFFFFFF
movq %r14, 0x10(%rax)
movq %rcx, (%rax)
movq 0x18(%r14), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%rcx)
movq %rax, 0x18(%r14)
movl %ebp, 0x58(%rax)
movl %r12d, 0x60(%rax)
movl %r15d, 0x64(%rax)
movl 0x4(%rsp), %ecx
movq 0x8(%rsp), %rdx
testl %r15d, %r15d
je 0x20a37
movl %ecx, %esi
subl %r15d, %esi
subl %r15d, %esi
movl %r15d, %r9d
addq %r9, %r9
leaq -0x1(%rcx), %r10
xorl %r8d, %r8d
movl %ecx, %r11d
movq %rdx, %rdi
testl %r11d, %r11d
jle 0x20a59
movl (%rdx,%r8,8), %r14d
movl %r14d, 0x6c(%rax,%r8,4)
cmpl %r8d, %r10d
je 0x20a60
addq $0x10, %rdi
addl $-0x2, %r11d
movl 0x8(%rdx,%r8,8), %r14d
movl %r14d, 0x68(%rax,%r8,4)
addq $0x2, %r8
cmpq %r8, %r9
jne 0x20a04
movq %rdi, %rdx
movl %esi, %ecx
movl %ecx, 0x4(%rsp)
movq %rdx, 0x8(%rsp)
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x12256
movl %r11d, 0x4(%rsp)
jmp 0x20a6f
notl %r8d
addl %ecx, %r8d
movl %r8d, 0x4(%rsp)
addq $0x8, %rdi
movq %rdi, 0x8(%rsp)
leaq 0x6f54(%rip), %rsi      # 0x279cf
leaq 0x6ffd(%rip), %rcx      # 0x27a7f
movq %rbx, %rdi
movl $0x69, %edx
xorl %eax, %eax
callq 0xca73
// File: /workspace/github_c_makefile_star2_O1/cogbee[P]vmir-latest/src/vmir_bitcode_instr.c
// Function: instr_get_vtp
static ir_valuetype_t
instr_get_vtp(ir_unit_t *iu, unsigned int *argcp, const int64_t **argvp)
{
  const int64_t *argv = *argvp;
  int argc = *argcp;
  if(argc < 1)
    parser_error(iu, "Missing value code");

  unsigned int val = iu->iu_next_value - argv[0];
  int type;

  if(val < iu->iu_next_value) {
    *argvp = argv + 1;
    *argcp = argc - 1;
    type = VECTOR_ITEM(&iu->iu_values, val)->iv_type;
  } else {

    type = argv[1];

    if(val >= VECTOR_LEN(&iu->iu_values)) {
      size_t prevsize = VECTOR_LEN(&iu->iu_values);
      VECTOR_RESIZE(&iu->iu_values, val + 1);
      for(int i = prevsize; i <= val; i++) {
        VECTOR_ITEM(&iu->iu_values, i) = NULL;
      }
    }
    ir_value_t *iv = VECTOR_ITEM(&iu->iu_values, val);

    if(iv == NULL) {
      iv = calloc(1, sizeof(ir_value_t));
      VECTOR_ITEM(&iu->iu_values, val) = iv;
      iv->iv_class = IR_VC_UNDEF;
    }
    iv->iv_type = type;

    *argvp = argv + 2;
    *argcp = argc - 2;
  }
  ir_valuetype_t r = {.type = type, .value = val};
  return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r12
movl (%rsi), %ebp
testl %ebp, %ebp
jle 0x20bdd
movq (%rdx), %r14
movl 0x198(%r12), %ecx
movl %ecx, %r15d
subl (%r14), %r15d
leaq 0x8(%r14), %rax
movl %r15d, %ebx
cmpl %ecx, %r15d
jae 0x20ae5
movq %rax, (%rdx)
decl %ebp
movl %ebp, (%rsi)
movq 0x180(%r12), %rax
movq (%rax,%rbx,8), %rax
movl 0x24(%rax), %r13d
jmp 0x20bc4
movl (%rax), %r13d
movq 0x188(%r12), %rax
cmpq %rbx, %rax
ja 0x20b7a
leal 0x1(%r15), %ecx
cmpq %rcx, 0x190(%r12)
jae 0x20b53
movq %rsi, 0x8(%rsp)
leal (%rcx,%rcx), %esi
movq %rsi, 0x190(%r12)
shlq $0x3, %rsi
movq 0x180(%r12), %rdi
movq %rdx, 0x20(%rsp)
movq %rax, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
callq 0x33c0
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %rdx
movq 0x8(%rsp), %rsi
movq %rax, 0x180(%r12)
movq 0x18(%rsp), %rax
movq %rcx, 0x188(%r12)
cmpl %eax, %r15d
jb 0x20b7a
cltq
movq 0x180(%r12), %rcx
movq $0x0, (%rcx,%rax,8)
incq %rax
cmpl %eax, %r15d
jae 0x20b62
movq 0x180(%r12), %r15
movq (%r15,%rbx,8), %rax
testq %rax, %rax
jne 0x20bb4
movl $0x1, %edi
movq %rsi, 0x8(%rsp)
movl $0x48, %esi
movq %rdx, %r12
callq 0x32f0
movq %r12, %rdx
movq 0x8(%rsp), %rsi
movq %rax, (%r15,%rbx,8)
movl $0x0, (%rax)
movl %r13d, 0x24(%rax)
addq $0x10, %r14
movq %r14, (%rdx)
addl $-0x2, %ebp
movl %ebp, (%rsi)
shlq $0x20, %r13
orq %r13, %rbx
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6deb(%rip), %rsi      # 0x279cf
leaq 0x6e81(%rip), %rcx      # 0x27a6c
movq %r12, %rdi
movl $0xc, %edx
xorl %eax, %eax
callq 0xca73
// File: /workspace/github_c_makefile_star2_O1/cogbee[P]vmir-latest/src/vmir_type.c
// Function: type_struct_layout
static void
type_struct_layout(ir_unit_t *iu, ir_type_t *it)
{
  int offset = 0;
  int ba = 1; // Biggest alignment
  const int packed = it->it_struct.packed;

  for(int i = 0; i < it->it_struct.num_elements; i++) {
    ir_type_t *ty = type_get(iu, it->it_struct.elements[i].type);

    if(ty->it_code == IR_TYPE_STRUCT && !ty->it_struct.computed)
      type_struct_layout(iu, ty);

    int s = type_sizeof_ptr(iu, ty);

    if(!packed) {
      int a = type_alignment_ptr(iu, ty);
      offset = VMIR_ALIGN(offset, a);
      ba = VMIR_MAX(ba, a);
    }
    it->it_struct.elements[i].offset = offset;
    offset += s;
  }
  it->it_struct.size = packed ? offset : VMIR_ALIGN(offset, ba);
  it->it_struct.alignment = ba;
  it->it_struct.computed = 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movb 0x24(%rsi), %al
movb %al, 0xf(%rsp)
cmpl $0x0, 0x18(%rsi)
jle 0x213ad
movq %rdi, %r14
movl $0x1, %eax
movq %rax, 0x10(%rsp)
xorl %ebp, %ebp
xorl %r13d, %r13d
movq 0x8(%rbx), %rax
movl (%rax,%rbp,8), %r8d
cmpq %r8, 0x170(%r14)
jbe 0x213ed
movq 0x168(%r14), %rax
leaq (%r8,%r8,4), %rcx
leaq (%rax,%rcx,8), %r12
cmpl $0x0, (%r12)
jne 0x2134e
cmpb $0x0, 0x25(%r12)
jne 0x2134e
movq %r14, %rdi
movq %r12, %rsi
callq 0x212dc
movq %r14, %rdi
movq %r12, %rsi
callq 0xf747
movl %eax, %r15d
cmpb $0x0, 0xf(%rsp)
jne 0x2138c
movq %r14, %rdi
movq %r12, %rsi
callq 0xf6b9
leal (%rax,%r13), %ecx
decl %ecx
movl %eax, %r13d
negl %r13d
andl %ecx, %r13d
movq 0x10(%rsp), %rcx
cmpl %eax, %ecx
cmovgl %ecx, %eax
movq %rax, 0x10(%rsp)
movq 0x8(%rbx), %rax
movl %r13d, 0x4(%rax,%rbp,8)
addl %r13d, %r15d
incq %rbp
movslq 0x18(%rbx), %rax
movl %r15d, %r13d
cmpq %rax, %rbp
jl 0x21310
jmp 0x213ba
xorl %r15d, %r15d
movl $0x1, %eax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdx
leal (%r15,%rdx), %eax
decl %eax
movl %edx, %ecx
negl %ecx
andl %eax, %ecx
cmpb $0x0, 0xf(%rsp)
cmovnel %r15d, %ecx
movl %ecx, 0x1c(%rbx)
movl %edx, 0x20(%rbx)
movb $0x1, 0x25(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4618(%rip), %rsi      # 0x25a0c
leaq 0x464a(%rip), %rcx      # 0x25a45
movq %r14, %rdi
movl $0x7c, %edx
xorl %eax, %eax
callq 0xca73
// File: /workspace/github_c_makefile_star2_O1/cogbee[P]vmir-latest/src/vmir_bitstream.c
// Function: read_vbr64
static uint64_t
read_vbr64(bcbitstream_t *bs, int width)
{
  assert(width > 0);

  uint64_t ret = 0;
  const uint32_t cont = (1 << (width - 1));
  const uint32_t mask = cont - 1;
  int stride = 0;

  while(1) {
    uint32_t x = read_bits(bs, width);
    ret |= (uint64_t)(x & mask) << stride;
    if(cont & x) {
      stride += width - 1;
      assert(stride < 64);
    } else {
      break;
    }
  }
  return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testl %esi, %esi
jle 0x21495
movl %esi, %ebx
movq %rdi, %r14
leal -0x1(%rbx), %ecx
movl $0x1, %r13d
movl %ecx, 0x4(%rsp)
shll %cl, %r13d
leal -0x1(%r13), %ebp
xorl %r15d, %r15d
xorl %r12d, %r12d
movq %r14, %rdi
movl %ebx, %esi
callq 0xc0fb
movl %eax, %edx
andl %ebp, %edx
movl %r15d, %ecx
shlq %cl, %rdx
testl %r13d, %eax
je 0x2145c
addl 0x4(%rsp), %r15d
cmpl $0x40, %r15d
jge 0x21476
orq %rdx, %r12
testl %r13d, %eax
jne 0x21438
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6ac2(%rip), %rdi      # 0x27f3f
leaq 0x61ca(%rip), %rsi      # 0x2764e
leaq 0x6a8a(%rip), %rcx      # 0x27f15
movl $0x77, %edx
callq 0x31e0
leaq 0x61a8(%rip), %rdi      # 0x27644
leaq 0x61ab(%rip), %rsi      # 0x2764e
leaq 0x6a6b(%rip), %rcx      # 0x27f15
movl $0x6b, %edx
callq 0x31e0
// File: /workspace/github_c_makefile_star2_O1/cogbee[P]vmir-latest/src/vmir_libc.c
// Function: vmir_sysio_open
static vmir_errcode_t
vmir_sysio_open(void *opaque, const char *path, vmir_openflags_t flags,
                intptr_t *fh)
{
  int fs = O_CLOEXEC;
  fs |= flags & VMIR_FS_OPEN_CREATE ? O_CREAT  : 0;
  fs |= flags & VMIR_FS_OPEN_TRUNC  ? O_TRUNC  : 0;
  fs |= flags & VMIR_FS_OPEN_APPEND ? O_APPEND : 0;

  if((flags & (VMIR_FS_OPEN_READ | VMIR_FS_OPEN_WRITE)) ==
     (VMIR_FS_OPEN_READ | VMIR_FS_OPEN_WRITE))
    fs |= O_RDWR;
  else if(flags & VMIR_FS_OPEN_READ)
    fs |= O_RDONLY;
  else if(flags & VMIR_FS_OPEN_WRITE)
    fs |= O_WRONLY;
  else
    return VMIR_ERR_INVALID_ARGS;

  int fd = open(path, fs, 0644);
  if(fd == -1) {
    return VMIR_ERR_FS_ERROR;
  }
  *fh = fd;
  return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ecx
shll $0x4, %ecx
andl $0x40, %ecx
movl %edx, %eax
andl $0x18, %eax
shll $0x6, %eax
orl %ecx, %eax
movl %edx, %ecx
notl %ecx
testb $0x3, %cl
jne 0x217ee
orl $0x80002, %eax          # imm = 0x80002
jmp 0x21809
testb $0x1, %dl
jne 0x21804
movl $0xfffffffd, %ebp       # imm = 0xFFFFFFFD
testb $0x2, %dl
je 0x2182d
orl $0x80001, %eax          # imm = 0x80001
jmp 0x21809
orl $0x80000, %eax          # imm = 0x80000
xorl %ebp, %ebp
movq %rsi, %rdi
movl %eax, %esi
movl $0x1a4, %edx            # imm = 0x1A4
xorl %eax, %eax
callq 0x3410
cmpl $-0x1, %eax
je 0x21828
cltq
movq %rax, (%rbx)
jmp 0x2182d
movl $0xfffffffc, %ebp       # imm = 0xFFFFFFFC
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/cogbee[P]vmir-latest/tlsf/tlsf.c
// Function: tlsf_walk_heap
void tlsf_walk_heap(tlsf_pool pool, tlsf_walker walker, void* user)
{
	tlsf_walker heap_walker = walker ? walker : default_walker;
	block_header_t* block =
		offset_to_block(pool, sizeof(pool_t) - block_header_overhead);

	while (block && !block_is_last(block))
	{
		heap_walker(
			block_to_ptr(block),
			block_size(block),
			!block_is_free(block),
			user);
		block = block_next(block);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
testq %rsi, %rsi
leaq 0x149(%rip), %r12       # 0x21c8e
cmovneq %rsi, %r12
addq $0x1980, %r14           # imm = 0x1980
je 0x21b92
movq %rdx, %rbx
movq 0x8(%r14), %rdx
cmpq $0x4, %rdx
jb 0x21b92
leaq 0x10(%r14), %r15
movq %rdx, %rsi
andq $-0x4, %rsi
notl %edx
andl $0x1, %edx
movq %r15, %rdi
movq %rbx, %rcx
callq *%r12
movq 0x8(%r14), %rax
cmpq $0x3, %rax
jbe 0x21b9e
andq $-0x4, %rax
addq %rax, %r15
addq $-0x8, %r15
movq %r15, %r14
jne 0x21b55
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x6a02(%rip), %rdi      # 0x285a7
leaq 0x666e(%rip), %rsi      # 0x2821a
leaq 0x6a0a(%rip), %rcx      # 0x285bd
movl $0xf8, %edx
callq 0x31e0