LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/cogbee[P]vmir-latest/src/vmir_libc.c
// Function: fmt_sn
static void
fmt_sn(void *opaque, const char *str, int len)
{
  fmt_sn_aux_t *aux = opaque;
  aux->total += len;
  if(aux->remain == 0)
    return;

  // Figure out how much to copy, we always reserve one byte for trailing 0
  int to_copy = VMIR_MIN(aux->remain - 1, len);

  memcpy(aux->dst, str, to_copy);
  aux->dst += to_copy;
  aux->remain -= to_copy;
}

// Assembly:
addl %edx, 0xc(%rdi)
movl 0x8(%rdi), %eax
testl %eax, %eax
je 0xd949
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
decl %eax
cmpl %edx, %eax
cmovael %edx, %eax
movq (%rdi), %rdi
movslq %eax, %r14
movq %r14, %rdx
callq 0x3360
addq %r14, (%rbx)
subl %r14d, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/cogbee[P]vmir-latest/src/vmir_libc.c
// Function: vmir_heap_merge_next
static void
vmir_heap_merge_next(heap_t *h, heap_block_t *hb)
{
  heap_block_t *next = TAILQ_NEXT(hb, hb_link);
  if(next == NULL || next->hb_magic != HEAP_MAGIC_FREE)
    return;
  assert(next > hb);
  TAILQ_REMOVE(&h->h_blocks, next, hb_link);
  hb->hb_size += next->hb_size;
}

// Assembly:
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0xdfce
cmpl $0xf4eef4ee, (%rax)     # imm = 0xF4EEF4EE
jne 0xdfce
cmpq %rsi, %rax
jbe 0xdfcf
movq 0x8(%rax), %rcx
movq 0x10(%rax), %rdx
addq $0x8, %rdi
leaq 0x10(%rcx), %r8
testq %rcx, %rcx
cmoveq %rdi, %r8
movq %rdx, (%r8)
movq %rcx, (%rdx)
movl 0x4(%rax), %eax
addl %eax, 0x4(%rsi)
retq
pushq %rax
leaq 0x1266b(%rip), %rdi     # 0x20642
leaq 0x124ce(%rip), %rsi     # 0x204ac
leaq 0x12667(%rip), %rcx     # 0x2064c
movl $0xd7, %edx
callq 0x31e0
// File: /workspace/github_c_makefile_star2_O2/cogbee[P]vmir-latest/src/vmir_function.c
// Function: bb_destroy
static void
bb_destroy(ir_bb_t *ib, ir_function_t *f)
{
  ir_instr_t *ii;

  TAILQ_REMOVE(&f->if_bbs, ib, ib_link);

  ibe_destroy_list(&ib->ib_incoming_edges);
  ibe_destroy_list(&ib->ib_outgoing_edges);

  while((ii = TAILQ_FIRST(&ib->ib_instrs)) != NULL) {
    instr_destroy(ii);
  }
  free(ib->ib_name);
  free(ib);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
addq $0x50, %rsi
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmoveq %rsi, %rcx
movq 0x8(%rdi), %rdx
movq %rdx, (%rcx)
movq %rax, (%rdx)
addq $0x30, %rdi
callq 0xe043
leaq 0x38(%rbx), %rdi
callq 0xe043
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0xe031
callq 0xe058
jmp 0xe021
movq 0x50(%rbx), %rdi
callq 0x3030
movq %rbx, %rdi
popq %rbx
jmp 0x3030
// File: /workspace/github_c_makefile_star2_O2/cogbee[P]vmir-latest/src/vmir_instr.c
// Function: instr_destroy
static void
instr_destroy(ir_instr_t *ii)
{
  instr_bind_clear(ii);
  free(ii->ii_rets);
  free(ii->ii_succ);
  free(ii->ii_liveness);

  TAILQ_REMOVE(&ii->ii_bb->ib_instrs, ii, ii_link);
  free(ii);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0xe0e5
movq 0x18(%rbx), %rdi
callq 0x3030
movq 0x40(%rbx), %rdi
callq 0x3030
movq 0x38(%rbx), %rdi
callq 0x3030
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
testq %rax, %rax
je 0xe08e
leaq 0x8(%rax), %rdx
jmp 0xe096
movq 0x10(%rbx), %rdx
addq $0x18, %rdx
movq %rcx, (%rdx)
movq %rax, (%rcx)
movq %rbx, %rdi
popq %rbx
jmp 0x3030
// File: /workspace/github_c_makefile_star2_O2/cogbee[P]vmir-latest/src/vmir_function.c
// Function: ibe_destroy
static void
ibe_destroy(ir_bb_edge_t *ibe)
{
  LIST_REMOVE(ibe, ibe_from_link);
  LIST_REMOVE(ibe, ibe_to_link);
  LIST_REMOVE(ibe, ibe_function_link);
  free(ibe);
}

// Assembly:
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
testq %rax, %rax
je 0xe0b5
movq %rcx, 0x8(%rax)
movq %rax, (%rcx)
movq 0x10(%rdi), %rax
movq 0x18(%rdi), %rcx
testq %rax, %rax
je 0xe0c9
movq %rcx, 0x18(%rax)
movq %rax, (%rcx)
movq 0x20(%rdi), %rax
movq 0x28(%rdi), %rcx
testq %rax, %rax
je 0xe0dd
movq %rcx, 0x28(%rax)
movq %rax, (%rcx)
jmp 0x3030
// File: /workspace/github_c_makefile_star2_O2/cogbee[P]vmir-latest/src/vmir_value.c
// Function: value_resize
static void
value_resize(ir_unit_t *iu, int newsize)
{
  assert(newsize <= VECTOR_LEN(&iu->iu_values));
  for(int i = newsize; i < VECTOR_LEN(&iu->iu_values); i++) {
    ir_value_t *iv = VECTOR_ITEM(&iu->iu_values, i);
    if(iv == NULL)
      continue;
    VECTOR_ITEM(&iu->iu_values, i) = NULL;
    value_clear(iv);
    free(iv);
  }
  iu->iu_next_value = newsize;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movslq %esi, %r12
movq 0x188(%rdi), %rax
cmpq %r12, %rax
jb 0xe1d0
movl %esi, %ebx
movq %rdi, %r14
cmpq %r12, %rax
jbe 0xe1bd
movq 0x180(%r14), %rcx
movq (%rcx,%r12,8), %r15
testq %r15, %r15
je 0xe1b8
andq $0x0, (%rcx,%r12,8)
movq 0x10(%r15), %rdi
callq 0x3030
andq $0x0, 0x10(%r15)
movq 0x18(%r15), %rdi
callq 0x3030
andq $0x0, 0x18(%r15)
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0xe18d
callq 0xe0fb
jmp 0xe17d
cmpl $0x2, (%r15)
jne 0xe1a9
movq 0x30(%r15), %rax
movq 0x20(%rax), %rdi
callq 0x3030
movq 0x30(%r15), %rdi
callq 0x3030
movq %r15, %rdi
callq 0x3030
movq 0x188(%r14), %rax
incq %r12
jmp 0xe147
movl %ebx, 0x198(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x124a9(%rip), %rdi     # 0x20680
leaq 0x124c8(%rip), %rsi     # 0x206a6
leaq 0x124d2(%rip), %rcx     # 0x206b7
movl $0xe5, %edx
callq 0x31e0
// File: /workspace/github_c_makefile_star2_O2/cogbee[P]vmir-latest/src/vmir_bitcode_parser.c
// Function: abbrev_queue_free
static void
abbrev_queue_free(struct ir_abbrev_queue *iaq)
{
  ir_abbrev_t *ia;
  while((ia = TAILQ_FIRST(iaq)) != NULL) {
    TAILQ_REMOVE(iaq, ia, ia_link);
    free(ia);
  }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xe21a
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
testq %rax, %rax
movq %rax, %rdx
cmoveq %rbx, %rdx
movq %rcx, 0x8(%rdx)
movq %rax, (%rcx)
callq 0x3030
jmp 0xe1f3
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/cogbee[P]vmir-latest/src/vmir_wasm_parser.c
// Function: wbs_get_vu32
static uint32_t
wbs_get_vu32(wasm_bytestream_t *wbs)
{
  uint32_t v = 0;
  uint8_t b;
  unsigned int shift = 0;
  do {
    b = wbs_get_byte(wbs);
    v |= (0x7f & b) << shift;
    shift += 7;
  } while(b & 0x80);
  return v;
}

// Assembly:
movq (%rdi), %rdx
movq 0x8(%rdi), %rsi
xorl %eax, %eax
xorl %ecx, %ecx
movb $-0x1, %r8b
cmpq %rsi, %rdx
jae 0xe238
movb (%rdx), %r8b
incq %rdx
movq %rdx, (%rdi)
movl %r8d, %r9d
andb $0x7f, %r9b
movzbl %r9b, %r9d
shll %cl, %r9d
orl %r9d, %eax
addl $0x7, %ecx
testb %r8b, %r8b
js 0xe227
retq
// File: /workspace/github_c_makefile_star2_O2/cogbee[P]vmir-latest/src/vmir_wasm_parser.c
// Function: wbs_get_string
static char *
wbs_get_string(ir_unit_t *iu, wasm_bytestream_t *wbs)
{
  uint32_t len = wbs_get_vu32(wbs);

  if(len > (wbs->end - wbs->ptr))
    parser_error(iu, "String length too long");

  char *mem = malloc(len + 1);
  memcpy(mem, wbs->ptr, len);
  wbs->ptr += len;
  mem[len] = 0;
  return mem;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r12
movq %rsi, %rdi
callq 0xe21c
movl %eax, %r14d
movq (%rbx), %r15
movq 0x8(%rbx), %rax
subq %r15, %rax
cmpq %r14, %rax
jl 0xe2ae
leal 0x1(%r14), %edi
callq 0x3380
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x3360
addq %r14, %r15
movq %r15, (%rbx)
movb $0x0, (%r12,%r14)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x12469(%rip), %rsi     # 0x2071e
leaq 0x12479(%rip), %rcx     # 0x20735
movq %r12, %rdi
movl $0xa7, %edx
xorl %eax, %eax
callq 0xbed2
// File: /workspace/github_c_makefile_star2_O2/cogbee[P]vmir-latest/src/vmir_wasm_parser.c
// Function: wasm_parse_value_type
static int
wasm_parse_value_type(ir_unit_t *iu, wasm_bytestream_t *wbs)
{
  const uint8_t arg_type = wbs_get_byte(wbs);
  switch(arg_type) {
  case 0x40:
    return 0;
  case 0x7f:
  case 0x7e:
  case 0x7d:
  case 0x7c:
    return 0x7f - arg_type + 1;
  default:
    parser_error(iu, "Bad type code (byte) 0x%x at 0x%zx",
                 arg_type, wbs->ptr - wbs->start - 1);
    break;
  }
}

// Assembly:
movq (%rsi), %rcx
cmpq 0x8(%rsi), %rcx
jae 0xe2fa
movzbl (%rcx), %r8d
incq %rcx
movq %rcx, (%rsi)
leal -0x7c(%r8), %eax
cmpl $0x4, %eax
jae 0xe2f0
movl $0x80, %eax
subl %r8d, %eax
retq
xorl %eax, %eax
cmpl $0x40, %r8d
je 0xe2ef
jmp 0xe300
movl $0xff, %r8d
pushq %rax
movq 0x10(%rsi), %r9
notq %r9
addq %rcx, %r9
leaq 0x1240c(%rip), %rsi     # 0x2071e
leaq 0x12476(%rip), %rcx     # 0x2078f
movl $0xc1, %edx
xorl %eax, %eax
callq 0xbed2
// File: /workspace/github_c_makefile_star2_O2/cogbee[P]vmir-latest/src/vmir_vm.c
// Function: vmop_resolve
static int
vmop_resolve(ir_function_t *f)
{
  f->if_vmop = 0;

  for(int i = 0; i < VMIR_ARRAYSIZE(vmop_map); i++) {
    const vmop_tab_t *vt = &vmop_map[i];
    if(!strcmp(f->if_name, vt->name)) {
      f->if_vmop = vt->vmop;
      f->if_vmop_args = vt->vmop_args;
      return 1;
    }
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
andl $0x0, 0x38(%rdi)
movq 0x20(%rdi), %r14
leaq 0x1c671(%rip), %r15     # 0x2a9b0
xorl %ecx, %ecx
movq %rcx, %r12
cmpq $0x3a, %rcx
je 0xe36a
movq (%r15), %rsi
movq %r14, %rdi
callq 0x3300
leaq 0x1(%r12), %rcx
addq $0x10, %r15
testl %eax, %eax
jne 0xe341
movq -0x8(%r15), %rax
movq %rax, 0x38(%rbx)
xorl %eax, %eax
cmpq $0x3a, %r12
setb %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/cogbee[P]vmir-latest/src/vmir_type.c
// Function: type_make_pointer
static int
type_make_pointer(ir_unit_t *iu, int type, int may_create)
{
  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 == IR_TYPE_POINTER && it->it_pointer.pointee == type)
      return i;
  }
  if(!may_create)
    return -1;

  iu->iu_types_created = 1;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %r14
movq 0x170(%rdi), %rbx
pushq $0x8
popq %rcx
xorl %eax, %eax
cmpq %rax, %rbx
je 0xe3b8
movq 0x168(%r14), %rsi
cmpl $0xb, -0x8(%rsi,%rcx)
jne 0xe3af
cmpl %ebp, (%rsi,%rcx)
je 0xe411
incq %rax
addq $0x28, %rcx
jmp 0xe397
testl %edx, %edx
je 0xe415
movl $0x1, 0x368(%r14)
leaq 0x1(%rbx), %r15
movq 0x168(%r14), %rax
cmpq 0x178(%r14), %rbx
jb 0xe3f9
leaq (%r15,%r15), %rcx
movq %rcx, 0x178(%r14)
imulq $0x50, %r15, %rsi
movq %rax, %rdi
callq 0x33c0
movq %rax, 0x168(%r14)
movq %r15, 0x170(%r14)
imulq $0x28, %rbx, %rcx
movl $0xb, (%rax,%rcx)
movl %ebp, 0x8(%rax,%rcx)
jmp 0xe418
movl %eax, %ebx
jmp 0xe418
pushq $-0x1
popq %rbx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/cogbee[P]vmir-latest/src/vmir_value.c
// Function: value_create_global
static int
value_create_global(ir_unit_t *iu, int pointee_type, int pointer_type,
                    int alignment, int offset, int size)
{
  if(alignment == 0)
    alignment = type_alignment(iu, pointee_type);

  ir_globalvar_t *ig = calloc(1, sizeof(ir_globalvar_t));
  ig->ig_type = pointee_type;

  const int val_id = value_append(iu);
  ir_value_t *iv = VECTOR_ITEM(&iu->iu_values, val_id);
  iv->iv_class = IR_VC_GLOBALVAR;
  iv->iv_type = pointer_type;
  iv->iv_gvar = ig;
  iu->iu_data_ptr = VMIR_ALIGN(iu->iu_data_ptr, alignment);
  ig->ig_addr = iu->iu_data_ptr;
  ig->ig_size = type_sizeof(iu, pointee_type);
  ig->str_offset = offset;
  ig->str_size = size;
  iu->iu_data_ptr += type_sizeof(iu, pointee_type);
  return val_id;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, 0x4(%rsp)
movl %r8d, (%rsp)
movl %ecx, %r12d
movl %edx, %r13d
movl %esi, %r14d
movq %rdi, %rbx
testl %ecx, %ecx
jne 0xe457
movq %rbx, %rdi
movl %r14d, %esi
callq 0xe59d
movl %eax, %r12d
pushq $0x1
popq %rdi
pushq $0x30
popq %rsi
callq 0x32f0
movq %rax, %r15
movl %r14d, 0x10(%rax)
movq %rbx, %rdi
callq 0xe5b2
movq 0x180(%rbx), %rcx
movslq %eax, %rbp
movq (%rcx,%rbp,8), %rax
movl $0x2, (%rax)
movl %r13d, 0x24(%rax)
movq %r15, 0x30(%rax)
movl 0x88(%rbx), %eax
addl %r12d, %eax
decl %eax
negl %r12d
andl %eax, %r12d
movl %r12d, 0x88(%rbx)
movl %r12d, 0x28(%r15)
movq %rbx, %rdi
movl %r14d, %esi
callq 0xe68d
movl %eax, 0x2c(%r15)
movl (%rsp), %eax
movl %eax, 0x14(%r15)
movl 0x4(%rsp), %eax
movl %eax, 0x18(%r15)
movq %rbx, %rdi
movl %r14d, %esi
callq 0xe68d
addl %eax, 0x88(%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/cogbee[P]vmir-latest/src/vmir_wasm_parser.c
// Function: parse_init_expr
static void
parse_init_expr(ir_unit_t *iu, wasm_bytestream_t *wbs)
{
  vstack_clear(iu);
  iu->iu_first_func_value = iu->iu_next_value;

  while(wbs->ptr < wbs->end) {
    const uint8_t code = wbs_get_byte(wbs);
    if(code == 0xb)
      break;

    switch(code) {
    case 0x41 ... 0x44:
      wasm_const(iu, code, wbs);
      break;

    default:
      parser_error(iu, "Init expression: Can't handle opcode 0x%x", code);
    }
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
andq $0x0, 0x5d0(%rdi)
movq %rsi, %r14
movl 0x198(%rdi), %eax
movl %eax, 0x19c(%rdi)
movq (%r14), %rax
cmpq 0x8(%r14), %rax
jae 0xe539
movzbl (%rax), %r8d
incq %rax
movq %rax, (%r14)
leal -0x41(%r8), %eax
cmpl $0x4, %eax
jae 0xe533
movq %rbx, %rdi
movl %r8d, %esi
movq %r14, %rdx
callq 0xe7db
jmp 0xe507
cmpl $0xb, %r8d
jne 0xe541
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x121d6(%rip), %rsi     # 0x2071e
leaq 0x1275e(%rip), %rcx     # 0x20cad
movq %rbx, %rdi
movl $0x506, %edx            # imm = 0x506
xorl %eax, %eax
callq 0xbed2
// File: /workspace/github_c_makefile_star2_O2/cogbee[P]vmir-latest/src/vmir_wasm_parser.c
// Function: vstack_pop
static ir_valuetype_t
vstack_pop(ir_unit_t *iu)
{
  if(iu->iu_wasm_value_stack.vh_length == 0)
    parser_error(iu, "Value stack underflow");
  ir_valuetype_t vt =
    iu->iu_wasm_value_stack.vh_p[--iu->iu_wasm_value_stack.vh_length];
  //  printf("vstack pop %s\n", value_str_vt(iu, vt));
  return vt;
}

// Assembly:
movq 0x5d0(%rdi), %rax
testq %rax, %rax
je 0xe582
movq 0x5c8(%rdi), %rcx
leaq -0x1(%rax), %rdx
movq %rdx, 0x5d0(%rdi)
movq -0x8(%rcx,%rax,8), %rax
retq
pushq %rax
leaq 0x12194(%rip), %rsi     # 0x2071e
leaq 0x12780(%rip), %rcx     # 0x20d11
movl $0x1c5, %edx            # imm = 0x1C5
xorl %eax, %eax
callq 0xbed2
// File: /workspace/github_c_makefile_star2_O2/cogbee[P]vmir-latest/src/vmir_value.c
// Function: value_append
static int
value_append(ir_unit_t *iu)
{
  ir_value_t *iv;

  if(iu->iu_next_value == VECTOR_LEN(&iu->iu_values)) {
    iv = calloc(1, sizeof(ir_value_t));
    VECTOR_PUSH_BACK(&iu->iu_values, iv);
  } else {
    assert(iu->iu_next_value < VECTOR_LEN(&iu->iu_values));

    if(VECTOR_ITEM(&iu->iu_values, iu->iu_next_value) == NULL) {
      iv = calloc(1, sizeof(ir_value_t));
      VECTOR_ITEM(&iu->iu_values, iu->iu_next_value) = iv;
    } else {
      iv = VECTOR_ITEM(&iu->iu_values, iu->iu_next_value);
    }
  }
  iv->iv_id = iu->iu_next_value;
  return iu->iu_next_value++;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl 0x198(%rdi), %r14d
movslq %r14d, %r12
cmpq %r12, 0x188(%rdi)
jne 0xe62d
pushq $0x1
popq %rdi
pushq $0x48
popq %rsi
callq 0x32f0
movq %rax, %r15
leaq 0x1(%r12), %r13
movq 0x180(%rbx), %rax
cmpq 0x190(%rbx), %r13
jbe 0xe620
leaq (,%r13,2), %rcx
movq %rcx, 0x190(%rbx)
movq %r13, %rsi
shlq $0x4, %rsi
movq %rax, %rdi
callq 0x33c0
movq %rax, 0x180(%rbx)
movl 0x198(%rbx), %r14d
movq %r13, 0x188(%rbx)
movq %r15, (%rax,%r12,8)
jmp 0xe653
jbe 0xe66e
movq 0x180(%rbx), %r13
movq (%r13,%r12,8), %r15
testq %r15, %r15
jne 0xe653
pushq $0x1
popq %rdi
pushq $0x48
popq %rsi
callq 0x32f0
movq %rax, %r15
movq %rax, (%r13,%r12,8)
movl %r14d, 0x20(%r15)
leal 0x1(%r14), %eax
movl %eax, 0x198(%rbx)
movl %r14d, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x125c8(%rip), %rdi     # 0x20c3d
leaq 0x1202a(%rip), %rsi     # 0x206a6
leaq 0x125e9(%rip), %rcx     # 0x20c6c
movl $0xfe, %edx
callq 0x31e0
// File: /workspace/github_c_makefile_star2_O2/cogbee[P]vmir-latest/src/vmir_type.c
// Function: type_alignment_ptr
static unsigned int
type_alignment_ptr(ir_unit_t *iu, const ir_type_t *it)
{
  switch(it->it_code) {
  case IR_TYPE_VOID:
    return 0;
  case IR_TYPE_INT1:
  case IR_TYPE_INT8:
    return 1;
  case IR_TYPE_INT16:
    return 2;
  case IR_TYPE_INT32:
  case IR_TYPE_FLOAT:
    return 4;
  case IR_TYPE_INT64:
  case IR_TYPE_DOUBLE:
    return 8;
  case IR_TYPE_INTx:
    if(it->it_bits <= 32)
      return 4;
    if(it->it_bits <= 64) {
      return 8;
    }
    goto bad;
  case IR_TYPE_POINTER:
    return 4;

  case IR_TYPE_STRUCT:
    return it->it_struct.alignment;

  case IR_TYPE_ARRAY:
    return type_alignment(iu, it->it_array.element_type);

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

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl (%rsi), %eax
cmpq $0xb, %rax
ja 0xe6f1
leaq 0x1073f(%rip), %rcx     # 0x1edf4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
pushq $0x4
jmp 0xe6ee
pushq $0x1
jmp 0xe6ee
movl 0xc(%rsi), %esi
movq %rbx, %rdi
popq %rbx
jmp 0xe59d
pushq $0x2
jmp 0xe6ee
movl 0x20(%rsi), %eax
jmp 0xe6ef
xorl %eax, %eax
jmp 0xe6ef
movl 0x8(%rsi), %eax
cmpl $0x21, %eax
jl 0xe6be
cmpl $0x41, %eax
jae 0xe6f1
pushq $0x8
popq %rax
popq %rbx
retq
movq %rbx, %rdi
callq 0x408f
leaq 0x124f2(%rip), %rsi     # 0x20bf2
leaq 0x124fb(%rip), %rcx     # 0x20c02
movq %rbx, %rdi
movl $0x1e1, %edx            # imm = 0x1E1
movq %rax, %r8
xorl %eax, %eax
callq 0xbed2
// File: /workspace/github_c_makefile_star2_O2/cogbee[P]vmir-latest/src/vmir_type.c
// Function: type_sizeof_ptr
static unsigned int
type_sizeof_ptr(ir_unit_t *iu, const ir_type_t *it)
{
  switch(it->it_code) {
  case IR_TYPE_VOID:
    return 0;
  case IR_TYPE_INT1:
  case IR_TYPE_INT8:
    return 1;
  case IR_TYPE_INT16:
    return 2;
  case IR_TYPE_INT32:
  case IR_TYPE_FLOAT:
    return 4;
  case IR_TYPE_INT64:
  case IR_TYPE_DOUBLE:
    return 8;

  case IR_TYPE_INTx:
    if(it->it_bits <= 32)
      return 4;
    if(it->it_bits <= 64) {
      return 8;
    }
    goto bad;

  case IR_TYPE_POINTER:
    return 4;
  case IR_TYPE_STRUCT:
    return it->it_struct.size;

  case IR_TYPE_ARRAY:

    return type_sizeof(iu, it->it_array.element_type) *
      it->it_array.num_elements;

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %eax
cmpq $0xb, %rax
ja 0xe7b0
leaq 0x106bf(%rip), %rcx     # 0x1ee24
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
pushq $0x4
jmp 0xe7a7
pushq $0x1
jmp 0xe7a7
movl 0xc(%r14), %esi
movq %rbx, %rdi
callq 0xe68d
imull 0x8(%r14), %eax
jmp 0xe7a8
pushq $0x2
jmp 0xe7a7
movl 0x1c(%r14), %eax
jmp 0xe7a8
xorl %eax, %eax
jmp 0xe7a8
movl 0x8(%r14), %eax
cmpl $0x21, %eax
jl 0xe76e
cmpl $0x41, %eax
jae 0xe7b0
pushq $0x8
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
movq %r14, %rsi
callq 0x408f
leaq 0x12430(%rip), %rsi     # 0x20bf2
leaq 0x124c1(%rip), %rcx     # 0x20c8a
movq %rbx, %rdi
movl $0x17d, %edx            # imm = 0x17D
movq %rax, %r8
xorl %eax, %eax
callq 0xbed2
// File: /workspace/github_c_makefile_star2_O2/cogbee[P]vmir-latest/src/vmir_wasm_parser.c
// Function: wasm_const
static void
wasm_const(ir_unit_t *iu, int code, wasm_bytestream_t *wbs)
{
  ir_valuetype_t vt;

  switch(code) {
  case 0x41:
    vt = value_create_const32(iu, wbs_get_v32(wbs), IR_TYPE_INT32);
    break;
  case 0x42:
    vt = value_create_const64(iu, wbs_get_v64(wbs), IR_TYPE_INT64);
    break;
  case 0x43:
    vt = value_create_const32(iu, wbs_get_u32(wbs), IR_TYPE_FLOAT);
    break;
  case 0x44:
    vt = value_create_const64(iu, wbs_get_u64(wbs), IR_TYPE_DOUBLE);
    break;
  default:
    parser_error(iu, "Can't handle const type 0x%x", code);
  }
  vstack_push(iu, vt);
}

// Assembly:
pushq %rbx
movl %esi, %r8d
movq %rdi, %rbx
leal -0x41(%r8), %eax
cmpl $0x3, %eax
ja 0xe8f0
leaq 0x1065e(%rip), %rcx     # 0x1ee54
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rdx), %rax
movq 0x8(%rdx), %rdi
xorl %esi, %esi
xorl %ecx, %ecx
movb $-0x1, %r8b
cmpq %rdi, %rax
jae 0xe81b
movb (%rax), %r8b
incq %rax
movq %rax, (%rdx)
movl %r8d, %r9d
andb $0x7f, %r9b
movzbl %r9b, %r9d
shll %cl, %r9d
orl %r9d, %esi
addl $0x7, %ecx
testb %r8b, %r8b
js 0xe80a
pushq $-0x1
popq %rax
shll %cl, %eax
xorl %edx, %edx
cmpb $0x40, %r8b
cmovbl %edx, %eax
cmpl $0x20, %ecx
cmovael %edx, %eax
orl %eax, %esi
pushq $0x5
jmp 0xe864
movq (%rdx), %rax
leaq 0x4(%rax), %rcx
xorl %esi, %esi
cmpq 0x8(%rdx), %rcx
ja 0xe862
movl (%rax), %esi
movq %rcx, (%rdx)
pushq $0x8
popq %rdx
movq %rbx, %rdi
callq 0xe90d
jmp 0xe8e4
movq (%rdx), %rax
leaq 0x8(%rax), %rcx
cmpq 0x8(%rdx), %rcx
jbe 0xe8d3
xorl %esi, %esi
jmp 0xe8d9
movq (%rdx), %rax
movq 0x8(%rdx), %rdi
xorl %esi, %esi
xorl %ecx, %ecx
movb $-0x1, %r8b
cmpq %rdi, %rax
jae 0xe89c
movb (%rax), %r8b
incq %rax
movq %rax, (%rdx)
movl %r8d, %r9d
andb $0x7f, %r9b
movzbl %r9b, %r9d
shlq %cl, %r9
orq %r9, %rsi
addl $0x7, %ecx
testb %r8b, %r8b
js 0xe88b
pushq $-0x1
popq %rax
shlq %cl, %rax
xorl %edx, %edx
cmpb $0x40, %r8b
cmovbq %rdx, %rax
cmpl $0x40, %ecx
cmovaeq %rdx, %rax
orq %rax, %rsi
pushq $0x6
jmp 0xe8db
movq (%rax), %rsi
movq %rcx, (%rdx)
pushq $0x9
popq %rdx
movq %rbx, %rdi
callq 0xe952
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
jmp 0xe999
leaq 0x11e27(%rip), %rsi     # 0x2071e
leaq 0x123d9(%rip), %rcx     # 0x20cd7
movq %rbx, %rdi
movl $0x356, %edx            # imm = 0x356
xorl %eax, %eax
callq 0xbed2
// File: /workspace/github_c_makefile_star2_O2/cogbee[P]vmir-latest/src/vmir_value.c
// Function: value_create_const32
static ir_valuetype_t
value_create_const32(ir_unit_t *iu, int v, ir_type_code_t code)
{
  int type = type_find_by_code(iu, code);
  int ret = value_append(iu);
  ir_value_t *iv = VECTOR_ITEM(&iu->iu_values, ret);

  iv->iv_class = IR_VC_CONSTANT;
  iv->iv_type = type;
  iv->iv_u32 = v;
  return (ir_valuetype_t) {.value = ret, .type = type};
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl %edx, %esi
callq 0xe9fa
movl %eax, %r15d
movq %r14, %rdi
callq 0xe5b2
movq 0x180(%r14), %rcx
cltq
movq (%rcx,%rax,8), %rcx
movl $0x3, (%rcx)
movl %r15d, 0x24(%rcx)
movl %ebx, 0x30(%rcx)
shlq $0x20, %r15
movl %eax, %eax
orq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/cogbee[P]vmir-latest/src/vmir_value.c
// Function: value_create_const64
__attribute__((unused))
static ir_valuetype_t
value_create_const64(ir_unit_t *iu, uint64_t v, ir_type_code_t code)
{
  int type = type_find_by_code(iu, code);
  int ret = value_append(iu);
  ir_value_t *iv = VECTOR_ITEM(&iu->iu_values, ret);

  iv->iv_class = IR_VC_CONSTANT;
  iv->iv_type = type;
  iv->iv_u64 = v;
  return (ir_valuetype_t) {.value = ret, .type = type};
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl %edx, %esi
callq 0xe9fa
movl %eax, %r15d
movq %r14, %rdi
callq 0xe5b2
movq 0x180(%r14), %rcx
cltq
movq (%rcx,%rax,8), %rcx
movl $0x3, (%rcx)
movl %r15d, 0x24(%rcx)
movq %rbx, 0x30(%rcx)
shlq $0x20, %r15
movl %eax, %eax
orq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/cogbee[P]vmir-latest/src/vmir_type.c
// Function: type_find_by_code
static int
type_find_by_code(ir_unit_t *iu, ir_type_code_t code)
{
  for(int i = 0; i < VECTOR_LEN(&iu->iu_types); i++) {
    if(VECTOR_ITEM(&iu->iu_types, i).it_code == code)
      return i;
  }
  parser_error(iu, "Unable to find type class %d", code);
}

// Assembly:
pushq %rax
movl %esi, %r8d
movq 0x170(%rdi), %rcx
xorl %edx, %edx
xorl %eax, %eax
cmpq %rax, %rcx
je 0xea26
movq 0x168(%rdi), %rsi
cmpl %r8d, (%rsi,%rdx)
je 0xea24
incq %rax
addq $0x28, %rdx
jmp 0xea09
popq %rcx
retq
leaq 0x121c5(%rip), %rsi     # 0x20bf2
leaq 0x122c0(%rip), %rcx     # 0x20cf4
movl $0x14f, %edx            # imm = 0x14F
xorl %eax, %eax
callq 0xbed2
// File: /workspace/github_c_makefile_star2_O2/cogbee[P]vmir-latest/src/vmir_value.c
// Function: value_print_id
static int
value_print_id(char **dstp, ir_unit_t *iu, int value)
{
  if(value >= VECTOR_LEN(&iu->iu_values)) {
    char tmpbuf[64];
    snprintf(tmpbuf, sizeof(tmpbuf), ">>BADVALUE:%d<<", value);
    return addstr(dstp, tmpbuf);
  }
  ir_value_t *iv = VECTOR_ITEM(&iu->iu_values, value);
  return value_print(dstp, iu, iv, NULL);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movslq %edx, %rax
cmpq %rax, 0x188(%rsi)
jbe 0xea6f
movq 0x180(%rsi), %rcx
movq (%rcx,%rax,8), %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
addq $0x48, %rsp
popq %rbx
popq %r14
jmp 0xea9b
movl %edx, %ecx
leaq 0x122af(%rip), %rdx     # 0x20d27
movq %rsp, %r14
pushq $0x40
popq %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x31a0
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc58c
addq $0x48, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/cogbee[P]vmir-latest/src/vmir_value.c
// Function: value_print_vt
static int
value_print_vt(char **dstp, ir_unit_t *iu, ir_valuetype_t vt)
{
  if(vt.value >= VECTOR_LEN(&iu->iu_values)) {
    char tmpbuf[64];
    snprintf(tmpbuf, sizeof(tmpbuf), ">>BADVALUE:%d<<", vt.value);
    return addstr(dstp, tmpbuf);
  }

  if(vt.type >= VECTOR_LEN(&iu->iu_types)) {
    char tmpbuf[64];
    snprintf(tmpbuf, sizeof(tmpbuf), ">>BADTYPE:%d<<", vt.type);
    return addstr(dstp, tmpbuf);
  }

  ir_value_t *iv = VECTOR_ITEM(&iu->iu_values, vt.value);
  const ir_type_t *it = &VECTOR_ITEM(&iu->iu_types, vt.type);
  return value_print(dstp, iu, iv, it);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rcx
movq %rdi, %rbx
movslq %ecx, %rax
cmpq 0x188(%rsi), %rax
jae 0xefd2
movq %rcx, %rdi
sarq $0x20, %rdi
cmpq 0x170(%rsi), %rdi
jae 0xefdb
movq 0x180(%rsi), %rcx
movq (%rcx,%rax,8), %rdx
imulq $0x28, %rdi, %rcx
addq 0x168(%rsi), %rcx
movq %rbx, %rdi
addq $0x48, %rsp
popq %rbx
popq %r14
jmp 0xea9b
leaq 0x11d4e(%rip), %rdx     # 0x20d27
jmp 0xefe6
shrq $0x20, %rcx
leaq 0x11df9(%rip), %rdx     # 0x20ddf
movq %rsp, %r14
pushq $0x40
popq %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x31a0
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc58c
addq $0x48, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/cogbee[P]vmir-latest/src/vmir_function.c
// Function: function_prepare_parse
static void
function_prepare_parse(ir_unit_t *iu, ir_function_t *f)
{
  if(iu->iu_debugged_function != NULL &&
     strcmp(iu->iu_debugged_function, f->if_name))
    iu->iu_debug_flags_func = 0;
  else
    iu->iu_debug_flags_func = iu->iu_debug_flags;

  f->if_regframe_size = 8; // Make space for temporary register for VM use
  f->if_callarg_size = 0;

  ir_type_t *it = type_get(iu, f->if_type);

  for(int i = 0; i < it->it_function.num_parameters; i++)
    value_alloc_function_arg(iu, it->it_function.parameters[i]);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x108(%rdi), %rdi
testq %rdi, %rdi
je 0xf035
movq 0x20(%r14), %rsi
callq 0x3300
xorl %ecx, %ecx
testl %eax, %eax
jne 0xf03b
movl 0x100(%rbx), %ecx
movl %ecx, 0x104(%rbx)
movq $0x8, 0x2c(%r14)
movl 0x10(%r14), %esi
movq %rbx, %rdi
callq 0xe719
movq %rax, %r14
xorl %r15d, %r15d
movslq 0x14(%r14), %rax
cmpq %rax, %r15
jge 0xf0b6
movq 0x8(%r14), %rax
movl (%rax,%r15,4), %ebp
movq %rbx, %rdi
callq 0xe5b2
movq 0x180(%rbx), %rcx
cltq
movq (%rcx,%rax,8), %r12
movl $0x5, (%r12)
movl %ebp, 0x24(%r12)
movq 0x1c0(%rbx), %r13
movq %rbx, %rdi
movl %ebp, %esi
callq 0x100e4
shll $0x2, %eax
movl 0x30(%r13), %ecx
subl %eax, %ecx
movl %ecx, 0x30(%r13)
movl %ecx, 0x30(%r12)
incq %r15
jmp 0xf05b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/cogbee[P]vmir-latest/src/vmir_wasm_parser.c
// Function: wasm_return
static void
wasm_return(ir_unit_t *iu, ir_bb_t *ib)
{
  ir_instr_unary_t *i = instr_add(ib, sizeof(ir_instr_unary_t), IR_IC_RET);
  const ir_type_t *it = type_get(iu, iu->iu_current_function->if_type);

  if(it->it_function.return_type == 0) {
    i->value.value = -1;
  } else {
    i->value = vstack_pop(iu);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
pushq $0x68
popq %rsi
pushq $0x1
popq %rdx
movq %rax, %rdi
callq 0x101c5
movq %rax, %r14
movq 0x1c0(%rbx), %rax
movl 0x10(%rax), %esi
movq %rbx, %rdi
callq 0xe719
cmpl $0x0, 0x10(%rax)
je 0xfced
movq %rbx, %rdi
callq 0xe55e
movq %rax, 0x58(%r14)
jmp 0xfcf2
orl $-0x1, 0x58(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/cogbee[P]vmir-latest/src/vmir_value.c
// Function: value_regframe_slots
static int
value_regframe_slots(ir_unit_t *iu, int type)
{
  ir_type_t *it = type_get(iu, type);

  switch(it->it_code) {
  case IR_TYPE_INT1:
  case IR_TYPE_INT8:
  case IR_TYPE_INT16:
  case IR_TYPE_INT32:
  case IR_TYPE_FLOAT:
  case IR_TYPE_POINTER:
  case IR_TYPE_FUNCTION:
    return 1;
  case IR_TYPE_INT64:
  case IR_TYPE_DOUBLE:
    return 2;
  case IR_TYPE_INTx:
    if(it->it_bits <= 32)
      return 1;
    else
      return 2;

  default:
    parser_error(iu, "Can't determine regframe slots for type %s",
                 type_str(iu, it));
  }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0xe719
movl (%rax), %ecx
cmpl $0xc, %ecx
ja 0x10125
movl $0x193c, %edx           # imm = 0x193C
btl %ecx, %edx
jae 0x10102
pushq $0x1
jmp 0x1010e
movl $0x240, %edx            # imm = 0x240
btl %ecx, %edx
jae 0x10113
pushq $0x2
popq %rcx
movl %ecx, %eax
popq %rbx
retq
cmpl $0x7, %ecx
jne 0x10125
xorl %ecx, %ecx
cmpl $0x21, 0x8(%rax)
setge %cl
incl %ecx
jmp 0x1010f
movq %rbx, %rdi
movq %rax, %rsi
callq 0x408f
leaq 0x1056f(%rip), %rsi     # 0x206a6
leaq 0x10cf6(%rip), %rcx     # 0x20e34
movq %rbx, %rdi
movl $0x190, %edx            # imm = 0x190
movq %rax, %r8
xorl %eax, %eax
callq 0xbed2
// File: /workspace/github_c_makefile_star2_O2/cogbee[P]vmir-latest/src/vmir_function.c
// Function: bb_add
static ir_bb_t *
bb_add(ir_function_t *f, ir_bb_t *after)
{
  ir_bb_t *ib = bb_make(f);
  if(after != NULL)
    TAILQ_INSERT_AFTER(&f->if_bbs, after, ib, ib_link);
  else
    TAILQ_INSERT_TAIL(&f->if_bbs, ib, ib_link);
  return ib;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x101a0
testq %r14, %r14
je 0x10185
movq (%r14), %rcx
addq $0x50, %rbx
leaq 0x8(%rcx), %rdx
testq %rcx, %rcx
cmoveq %rbx, %rdx
movq %rcx, (%rax)
movq %rax, (%rdx)
movq %rax, (%r14)
movq %r14, 0x8(%rax)
jmp 0x10198
andq $0x0, (%rax)
movq 0x50(%rbx), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%rcx)
movq %rax, 0x50(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/cogbee[P]vmir-latest/src/vmir_function.c
// Function: bb_make
static ir_bb_t *
bb_make(ir_function_t *f)
{
  ir_bb_t *ib = calloc(1, sizeof(ir_bb_t));
  TAILQ_INIT(&ib->ib_instrs);
  ib->ib_id = f->if_num_bbs++;
  return ib;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rdi
pushq $0x58
popq %rsi
callq 0x32f0
leaq 0x10(%rax), %rcx
movq %rcx, 0x18(%rax)
movl 0x40(%rbx), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x40(%rbx)
movl %ecx, 0x28(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/cogbee[P]vmir-latest/src/vmir_instr.c
// Function: instr_add
static void *
instr_add(ir_bb_t *ib, size_t size, instr_class_t ic)
{
  ir_instr_t *ii = instr_create(size, ic);
  ii->ii_bb = ib;
  TAILQ_INSERT_TAIL(&ib->ib_instrs, ii, ii_link);
  return ii;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq %rsi, %rdi
movl %edx, %esi
callq 0x10277
movq %rbx, 0x10(%rax)
andq $0x0, (%rax)
movq 0x18(%rbx), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%rcx)
movq %rax, 0x18(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/cogbee[P]vmir-latest/src/vmir_value.c
// Function: value_alloc_temporary
static ir_valuetype_t
value_alloc_temporary(ir_unit_t *iu, int type)
{
  int val = value_append(iu);
  ir_value_t *iv = VECTOR_ITEM(&iu->iu_values, val);
  iv->iv_class = IR_VC_TEMPORARY;
  iv->iv_precolored = -1;
  iv->iv_type = type;
  return (ir_valuetype_t) {.value = val, .type = type};
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0xe5b2
movq 0x180(%r14), %rcx
cltq
movq (%rcx,%rax,8), %rcx
movl $0x4, (%rcx)
orl $-0x1, 0x38(%rcx)
movl %ebx, 0x24(%rcx)
shlq $0x20, %rbx
movl %eax, %eax
orq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/cogbee[P]vmir-latest/src/vmir_value.c
// Function: value_create_zero
static ir_valuetype_t
value_create_zero(ir_unit_t *iu, int type)
{
  int ret = value_append(iu);
  ir_value_t *iv = VECTOR_ITEM(&iu->iu_values, ret);

  iv->iv_class = IR_VC_CONSTANT;
  iv->iv_type = type;
  iv->iv_u64 = 0;
  return (ir_valuetype_t) {.value = ret, .type = type};
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0xe5b2
movq 0x180(%r14), %rcx
cltq
movq (%rcx,%rax,8), %rcx
movl $0x3, (%rcx)
movl %ebx, 0x24(%rcx)
andq $0x0, 0x30(%rcx)
shlq $0x20, %rbx
movl %eax, %eax
orq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/cogbee[P]vmir-latest/src/vmir_instr.c
// Function: instr_create
static void *
instr_create(size_t size, instr_class_t ic)
{
  ir_instr_t *ii = calloc(1, size);
  LIST_INIT(&ii->ii_values);
  ii->ii_class = ic;
  ii->ii_ret.value = -1;
  ii->ii_ret.type = -1;
  return ii;
}

// Assembly:
pushq %rbx
movl %esi, %ebx
movq %rdi, %rsi
pushq $0x1
popq %rdi
callq 0x32f0
movl %ebx, 0x28(%rax)
orq $-0x1, 0x2c(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/cogbee[P]vmir-latest/src/vmir_value.c
// Function: value_bind_instr
static void
value_bind_instr(ir_value_t *iv, ir_instr_t *ii, int relation)
{
  ir_value_instr_t *ivi = malloc(sizeof(ir_value_instr_t));
  ivi->ivi_instr = ii;
  ivi->ivi_value = iv;
  ivi->ivi_relation = relation;
  LIST_INSERT_HEAD(&ii->ii_values,       ivi, ivi_instr_link);
  LIST_INSERT_HEAD(&iv->iv_instructions, ivi, ivi_value_link);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x38
popq %rdi
callq 0x3380
movq %r14, 0x28(%rax)
movq %rbx, 0x20(%rax)
movl %ebp, 0x30(%rax)
movq 0x20(%r14), %rcx
addq $0x20, %r14
movq %rcx, 0x10(%rax)
testq %rcx, %rcx
je 0x102ca
movq %rax, %rdx
addq $0x10, %rdx
movq %rdx, 0x18(%rcx)
movq %rax, (%r14)
movq %r14, 0x18(%rax)
movq 0x8(%rbx), %rcx
addq $0x8, %rbx
movq %rcx, (%rax)
testq %rcx, %rcx
je 0x102e5
movq %rax, 0x8(%rcx)
movq %rax, (%rbx)
movq %rbx, 0x8(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/cogbee[P]vmir-latest/src/vmir_wasm_parser.c
// Function: wasm_set_local
static void
wasm_set_local(ir_unit_t *iu, ir_bb_t *ib, const int localvar)
{
  ir_instr_move_t *move = instr_add(ib, sizeof(ir_instr_move_t), IR_IC_MOVE);
  move->value = vstack_pop(iu);

  move->super.ii_ret.value = localvar;
  move->super.ii_ret.type = move->value.type;
  value_bind_return_value(iu, &move->super);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %rax
movq %rdi, %r14
pushq $0x60
popq %rsi
pushq $0x15
popq %rdx
movq %rax, %rdi
callq 0x101c5
movq %rax, %r15
movq %r14, %rdi
callq 0xe55e
movq %rax, 0x58(%r15)
movl %ebx, 0x2c(%r15)
shrq $0x20, %rax
movl %eax, 0x30(%r15)
movq %r14, %rdi
movq %r15, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x10225
// File: /workspace/github_c_makefile_star2_O2/cogbee[P]vmir-latest/src/vmir_function.c
// Function: function_print
static void
function_print(ir_unit_t *iu, ir_function_t *f, const char *what)
{
  printf("\nDump of %s function %s (%s)%s\n", what,
         f->if_name, type_str_index(iu, f->if_type),
         f->if_full_jit ? ", Fully JITed" : "");
  ir_bb_t *ib;
  TAILQ_FOREACH(ib, &f->if_bbs, ib_link) {
    ir_instr_t *ii;
    printf(".%d:%s%s%s%s%s", ib->ib_id,
           ib->ib_name ? " \"" : "",
           ib->ib_name ?: "",
           ib->ib_name ? "\"" : "",
           ib->ib_jit ? " (JIT)" : "",
           ib->ib_only_jit_sucessors ? " (Only JIT succ)" : "");

    ir_bb_edge_t *ibe;
    LIST_FOREACH(ibe, &ib->ib_incoming_edges, ibe_to_link) {
      printf(" pred:%d", ibe->ibe_from->ib_id);
    }
    printf("\n");
    TAILQ_FOREACH(ii, &ib->ib_instrs, ii_link) {
      printf("\t%s\n", instr_str(iu, ii, 0));
    }
    printf("\t\t");
    LIST_FOREACH(ibe, &ib->ib_outgoing_edges, ibe_from_link) {
      printf(" next:%d", ibe->ibe_to->ib_id);
    }
    printf("\n");
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rsi), %r12
movl 0x10(%rsi), %esi
callq 0x105cd
cmpb $0x0, 0x2a(%rbx)
leaq 0x10bc1(%rip), %rcx     # 0x20f81
leaq 0x10b72(%rip), %r8      # 0x20f39
cmoveq %rcx, %r8
leaq 0x10b47(%rip), %rdi     # 0x20f19
movq %r15, %rsi
movq %r12, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3190
addq $0x48, %rbx
leaq 0x10b95(%rip), %r13     # 0x20f82
leaq 0x10b86(%rip), %r15     # 0x20f7a
leaq 0x10b76(%rip), %r12     # 0x20f71
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x104f2
movq 0x50(%rbx), %rcx
testq %rcx, %rcx
leaq 0x10b41(%rip), %rdx     # 0x20f56
leaq 0x10b65(%rip), %rdi     # 0x20f81
cmoveq %rdi, %rdx
cmoveq %rdi, %rcx
leaq 0x10b2c(%rip), %r8      # 0x20f57
cmoveq %rdi, %r8
cmpb $0x0, 0x2d(%rbx)
leaq 0x10b1f(%rip), %r9      # 0x20f59
cmoveq %rdi, %r9
cmpb $0x0, 0x2e(%rbx)
movl 0x28(%rbx), %esi
leaq 0x10b14(%rip), %rax     # 0x20f60
cmoveq %rdi, %rax
movq %rax, (%rsp)
leaq 0x10aec(%rip), %rdi     # 0x20f47
xorl %eax, %eax
callq 0x3190
leaq 0x30(%rbx), %rbp
movq (%rbp), %rbp
testq %rbp, %rbp
je 0x10486
movq 0x30(%rbp), %rax
movl 0x28(%rax), %esi
movq %r12, %rdi
xorl %eax, %eax
callq 0x3190
addq $0x10, %rbp
jmp 0x10466
pushq $0xa
popq %rdi
callq 0x3040
leaq 0x10(%rbx), %rbp
movq (%rbp), %rbp
testq %rbp, %rbp
je 0x104b7
movq %r14, %rdi
movq %rbp, %rsi
xorl %edx, %edx
callq 0x10613
movq %r15, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x3190
jmp 0x10492
leaq 0x10ac1(%rip), %rdi     # 0x20f7f
xorl %eax, %eax
callq 0x3190
leaq 0x38(%rbx), %rbp
movq (%rbp), %rbp
testq %rbp, %rbp
je 0x104e5
movq 0x38(%rbp), %rax
movl 0x28(%rax), %esi
movq %r13, %rdi
xorl %eax, %eax
callq 0x3190
jmp 0x104c9
pushq $0xa
popq %rdi
callq 0x3040
jmp 0x103fb
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/cogbee[P]vmir-latest/src/vmir_value.c
// Function: value_alloc_instr_ret
static void
value_alloc_instr_ret(ir_unit_t *iu, int type, struct ir_instr *ii)
{
  int val = value_append(iu);
  ir_value_t *iv = VECTOR_ITEM(&iu->iu_values, val);
  iv->iv_class = IR_VC_TEMPORARY;
  iv->iv_type = type;
  iv->iv_precolored = -1;
  ii->ii_ret.value = val;
  ii->ii_ret.type = type;

  value_bind_instr(iv, ii, IVI_OUTPUT);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
callq 0xe5b2
movq 0x180(%r14), %rcx
cltq
movq (%rcx,%rax,8), %rdi
movl $0x4, (%rdi)
movl %ebp, 0x24(%rdi)
orl $-0x1, 0x38(%rdi)
movl %eax, 0x2c(%rbx)
movl %ebp, 0x30(%rbx)
pushq $0x1
popq %rdx
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x1028f
// File: /workspace/github_c_makefile_star2_O2/cogbee[P]vmir-latest/src/vmir_wasm_parser.c
// Function: wasm_vmop
static void
wasm_vmop(ir_unit_t *iu, ir_bb_t *ib, int num_args, int vmop, int return_type)
{
  ir_instr_call_t *i =
    instr_add(ib, sizeof(ir_instr_call_t) +
              sizeof(ir_instr_arg_t) * num_args, IR_IC_VMOP);
  i->vmop = vmop;
  i->argc = num_args;
  for(int j = num_args - 1; j >= 0; j--) {
    i->argv[j].value = vstack_pop(iu);
  }

  value_alloc_instr_ret(iu, return_type, &i->super);
  vstack_push(iu, i->super.ii_ret);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %rax
movq %rdi, %r14
pushq $0x7c
popq %rsi
pushq $0x16
popq %rdx
movq %rax, %rdi
callq 0x101c5
movq %rax, %r15
movl %ebp, 0x60(%rax)
movl $0x1, 0x6c(%rax)
movq %r14, %rdi
callq 0xe55e
movq %rax, 0x70(%r15)
movq %r14, %rdi
movl %ebx, %esi
movq %r15, %rdx
callq 0x10532
movq 0x2c(%r15), %rsi
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xe999
// File: /workspace/github_c_makefile_star2_O2/cogbee[P]vmir-latest/src/vmir_type.c
// Function: type_str_index
static const char *
type_str_index(ir_unit_t *iu, int id)
{
  int l = type_print_id(NULL, iu, id);
  char *dst = tmpstr(iu, l);
  const char *ret = dst;
  type_print_id(&dst, iu, id);
  return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
xorl %edi, %edi
movq %r14, %rsi
movl %ebx, %edx
callq 0xc5cd
movq %r14, %rdi
movl %eax, %esi
callq 0xc540
movq %rax, %r15
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
movq %r14, %rsi
movl %ebx, %edx
callq 0xc5cd
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/cogbee[P]vmir-latest/src/vmir_instr.c
// Function: instr_str
static const char *
instr_str(ir_unit_t *iu, const ir_instr_t *ii, int flags)
{
  int len = instr_print(NULL, iu, ii, flags);
  char *dst = tmpstr(iu, len);
  const char *ret = dst;
  instr_print(&dst, iu, ii, flags);
  return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
xorl %edi, %edi
movq %r15, %rsi
movq %r14, %rdx
movl %ebx, %ecx
callq 0x10661
movq %r15, %rdi
movl %eax, %esi
callq 0xc540
movq %rax, %r12
movq %rsp, %rdi
movq %rax, (%rdi)
movq %r15, %rsi
movq %r14, %rdx
movl %ebx, %ecx
callq 0x10661
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/cogbee[P]vmir-latest/src/vmir.c
// Function: addstrf
static int __attribute__((warn_unused_result))
addstrf(char **dst, const char *fmt, ...)
{
  int len = 0;
  va_list ap;
  va_start(ap, fmt);
  if(dst == NULL) {
    len = vsnprintf(NULL, 0, fmt, ap);
  } else {
    len = vsprintf(*dst, fmt, ap);
    *dst += len;
  }
  va_end(ap);
  return len;
}

// Assembly:
pushq %rbx
subq $0xd0, %rsp
movq %rsi, %r10
leaq 0x20(%rsp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x11477
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsi, 0x10(%rsp)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rsp)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rsp)
testq %rdi, %rdi
je 0x114b5
movq %rdi, %rbx
movq (%rdi), %rdi
movq %rsp, %rdx
movq %r10, %rsi
callq 0x3400
movslq %eax, %rcx
addq %rcx, (%rbx)
jmp 0x114c4
movq %rsp, %rcx
xorl %edi, %edi
xorl %esi, %esi
movq %r10, %rdx
callq 0x3120
addq $0xd0, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/cogbee[P]vmir-latest/src/vmir_value.c
// Function: value_function
static ir_function_t *__attribute__((unused))
value_function(ir_unit_t *iu, int id)
{
  if(id >= VECTOR_LEN(&iu->iu_values))
    return NULL;
  const ir_value_t *iv = VECTOR_ITEM(&iu->iu_values, id);
  if(iv->iv_class != IR_VC_FUNCTION)
    return NULL;
  return iv->iv_func;
}

// Assembly:
movslq %esi, %rax
cmpq %rax, 0x188(%rdi)
jbe 0x114ee
movq 0x180(%rdi), %rcx
movq (%rcx,%rax,8), %rax
cmpl $0x1, (%rax)
jne 0x114ee
movq 0x30(%rax), %rax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/cogbee[P]vmir-latest/src/vmir_value.c
// Function: value_get_const32
static uint32_t __attribute__((unused))
value_get_const32(ir_unit_t *iu, const ir_value_t *iv)
{
  ir_type_t *it = type_get(iu, iv->iv_type);

  switch(iv->iv_class) {

  case IR_VC_GLOBALVAR:
    return iv->iv_gvar->ig_addr;

  case IR_VC_CONSTANT:
    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:
    case IR_TYPE_FLOAT:
      return iv->iv_u32;
    case IR_TYPE_INTx:
    case IR_TYPE_INT64:
  case IR_TYPE_DOUBLE:
      return iv->iv_u64;
    default:
      break;
    }
    break;
  default:
    break;
  }

  parser_error(iu, "Unable to value_get_const for value %s",
               value_str(iu, iv));
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x24(%rsi), %esi
callq 0xe719
movl (%r14), %ecx
cmpl $0x3, %ecx
je 0x1402e
cmpl $0x2, %ecx
jne 0x14066
movq 0x30(%r14), %rax
movl 0x28(%rax), %eax
jmp 0x1404d
movl (%rax), %eax
cmpl $0xb, %eax
ja 0x14066
movl $0x938, %ecx            # imm = 0x938
btl %eax, %ecx
jb 0x14049
movl $0x2c0, %ecx            # imm = 0x2C0
btl %eax, %ecx
jae 0x14055
movl 0x30(%r14), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
cmpl $0x2, %eax
jne 0x14066
xorl %eax, %eax
cmpl $0x0, 0x30(%r14)
setne %al
jmp 0x1404d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14155
leaq 0xc62e(%rip), %rsi      # 0x206a6
leaq 0xd306(%rip), %rcx      # 0x21385
movq %rbx, %rdi
movl $0x1d5, %edx            # imm = 0x1D5
movq %rax, %r8
xorl %eax, %eax
callq 0xbed2
// File: /workspace/github_c_makefile_star2_O2/cogbee[P]vmir-latest/src/vmir_instr.c
// Function: instr_add_before
static void *
instr_add_before(size_t size, instr_class_t ic, ir_instr_t *before)
{
  ir_bb_t *ib = before->ii_bb;
  ir_instr_t *ii = instr_create(size, ic);
  ii->ii_bb = ib;
  TAILQ_INSERT_BEFORE(before, ii, ii_link);
  return ii;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq 0x10(%rdx), %r14
callq 0x10277
movq %r14, 0x10(%rax)
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%rax)
movq %rbx, (%rax)
movq %rax, (%rcx)
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/cogbee[P]vmir-latest/src/vmir_transform.c
// Function: registerify
static void
registerify(ir_unit_t *iu, ir_instr_t *ii, ir_valuetype_t *vtp)
{
  ir_value_t *v = value_get(iu, vtp->value);
  ir_instr_move_t *move;

  switch(v->iv_class) {
  case IR_VC_TEMPORARY:
  case IR_VC_REGFRAME:
    return;

  case IR_VC_GLOBALVAR:
  case IR_VC_CONSTANT:
    move = instr_add_before(sizeof(ir_instr_move_t), IR_IC_MOVE, ii);
    value_alloc_instr_ret(iu, v->iv_type, &move->super);
    move->value = *vtp;
    *vtp = move->super.ii_ret;
    break;

  default:
    parser_error(iu, "Unable convert %s (class %d) into register",
                 type_str_index(iu, v->iv_type),
                 v->iv_class);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movl (%rdx), %esi
callq 0x102f1
movq %rax, %r15
movl (%rax), %eax
leal -0x4(%rax), %ecx
cmpl $0x2, %ecx
jb 0x1411c
addl $-0x2, %eax
cmpl $0x1, %eax
ja 0x14128
pushq $0x60
popq %rdi
pushq $0x15
popq %rsi
movq %r12, %rdx
callq 0x14091
movq %rax, %r12
movl 0x24(%r15), %esi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x10532
movq (%r14), %rax
movq %rax, 0x58(%r12)
movq 0x2c(%r12), %rax
movq %rax, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl 0x24(%r15), %esi
movq %rbx, %rdi
callq 0x105cd
movl (%r15), %r9d
leaq 0xd18b(%rip), %rsi      # 0x212c9
leaq 0xd267(%rip), %rcx      # 0x213ac
pushq $0x35
popq %rdx
movq %rbx, %rdi
movq %rax, %r8
xorl %eax, %eax
callq 0xbed2
// File: /workspace/github_c_makefile_star2_O2/cogbee[P]vmir-latest/src/vmir_value.c
// Function: value_str
static const char *
value_str(ir_unit_t *iu, const ir_value_t *iv)
{
  int len = value_print(NULL, iu, iv, NULL);
  char *dst = tmpstr(iu, len);
  const char *ret = dst;
  value_print(&dst, iu, iv, NULL);
  return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorl %edi, %edi
movq %r14, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0xea9b
movq %r14, %rdi
movl %eax, %esi
callq 0xc540
movq %rax, %r15
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
movq %r14, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0xea9b
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/cogbee[P]vmir-latest/src/vmir_value.c
// Function: value_get_assigning_instr
static ir_instr_t *
value_get_assigning_instr(ir_unit_t *iu, ir_value_t *iv)
{
  ir_value_instr_t *ivi;
  LIST_FOREACH(ivi, &iv->iv_instructions, ivi_value_link)
    if(ivi->ivi_relation == IVI_OUTPUT)
      return ivi->ivi_instr;
  return NULL;
}

// Assembly:
addq $0x8, %rdi
xorl %eax, %eax
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x141ba
cmpl $0x1, 0x30(%rdi)
jne 0x141a8
movq 0x28(%rdi), %rax
retq