LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0xeeac
cmpl $0xf4eef4ee, (%rax)     # imm = 0xF4EEF4EE
jne 0xeeac
cmpq %rsi, %rax
jbe 0xeead
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 0x16657(%rip), %rdi     # 0x2550c
leaq 0x164ba(%rip), %rsi     # 0x25376
leaq 0x16653(%rip), %rcx     # 0x25516
movl $0xd7, %edx
callq 0x31e0
// File: /workspace/github_c_makefile_star2_O3/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
movq 0x8(%rdi), %rcx
addq $0x50, %rsi
leaq 0x8(%rax), %rdx
testq %rax, %rax
cmoveq %rsi, %rdx
movq %rcx, (%rdx)
movq %rax, (%rcx)
movq 0x30(%rdi), %rdi
testq %rdi, %rdi
je 0xef06
callq 0xef8d
movq 0x30(%rbx), %rdi
jmp 0xeef1
callq 0xef8d
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
jne 0xef01
jmp 0xef16
callq 0xef31
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
jne 0xef11
movq 0x50(%rbx), %rdi
callq 0x3030
movq %rbx, %rdi
popq %rbx
jmp 0x3030
// File: /workspace/github_c_makefile_star2_O3/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
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0xef49
callq 0xefcd
movq 0x20(%rbx), %rdi
jmp 0xef39
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 0xef76
leaq 0x8(%rax), %rdx
jmp 0xef7e
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_O3/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 0xef9d
movq %rcx, 0x8(%rax)
movq %rax, (%rcx)
movq 0x10(%rdi), %rax
movq 0x18(%rdi), %rcx
testq %rax, %rax
je 0xefb1
movq %rcx, 0x18(%rax)
movq %rax, (%rcx)
movq 0x20(%rdi), %rax
movq 0x28(%rdi), %rcx
testq %rax, %rax
je 0xefc5
movq %rcx, 0x28(%rax)
movq %rax, (%rcx)
jmp 0x3030
// File: /workspace/github_c_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
movslq %esi, %r12
movq 0x188(%rdi), %rax
cmpq %r12, %rax
jb 0xf0a1
movl %esi, %ebx
movq %rdi, %r14
jbe 0xf090
xorl %r13d, %r13d
movq 0x180(%r14), %rcx
movq (%rcx,%r12,8), %r15
testq %r15, %r15
je 0xf088
movq %r13, (%rcx,%r12,8)
movq 0x10(%r15), %rdi
callq 0x3030
movq %r13, 0x10(%r15)
movq 0x18(%r15), %rdi
callq 0x3030
movq %r13, 0x18(%r15)
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0xf05d
callq 0xefcd
jmp 0xf04d
cmpl $0x2, (%r15)
jne 0xf079
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
cmpq %r12, %rax
ja 0xf01f
movl %ebx, 0x198(%r14)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x164a2(%rip), %rdi     # 0x2554a
leaq 0x164c1(%rip), %rsi     # 0x25570
leaq 0x164cb(%rip), %rcx     # 0x25581
movl $0xe5, %edx
callq 0x31e0
// File: /workspace/github_c_makefile_star2_O3/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 (%rdi), %rdi
testq %rdi, %rdi
je 0xf0ee
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
movq (%rbx), %rdi
jmp 0xf0c7
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 (%rsi), %r14
movq 0x8(%rsi), %rax
xorl %r15d, %r15d
xorl %ecx, %ecx
movb $-0x1, %dl
cmpq %rax, %r14
jae 0xf14d
movb (%r14), %dl
incq %r14
movq %r14, (%rbx)
movl %edx, %esi
andb $0x7f, %sil
movzbl %sil, %esi
shll %cl, %esi
orl %esi, %r15d
addl $0x7, %ecx
testb %dl, %dl
js 0xf13d
subq %r14, %rax
cmpq %r15, %rax
jl 0xf1a0
movl %r15d, %edi
incl %edi
callq 0x3380
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x3360
addq %r15, %r14
movq %r14, (%rbx)
movb $0x0, (%r12,%r15)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x16441(%rip), %rsi     # 0x255e8
leaq 0x16451(%rip), %rcx     # 0x255ff
movl $0xa7, %edx
xorl %eax, %eax
callq 0xca98
// File: /workspace/github_c_makefile_star2_O3/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 0xf1e9
movzbl (%rcx), %r8d
incq %rcx
movq %rcx, (%rsi)
leal -0x7c(%r8), %eax
cmpl $0x4, %eax
jae 0xf1df
movl $0x80, %eax
subl %r8d, %eax
retq
xorl %eax, %eax
cmpl $0x40, %r8d
je 0xf1de
jmp 0xf1ef
movl $0xff, %r8d
pushq %rax
movq 0x10(%rsi), %r9
notq %r9
addq %rcx, %r9
leaq 0x163e7(%rip), %rsi     # 0x255e8
leaq 0x16451(%rip), %rcx     # 0x25659
movl $0xc1, %edx
xorl %eax, %eax
callq 0xca98
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x0, 0x38(%rdi)
movq 0x20(%rdi), %r14
leaq 0x1647a(%rip), %rsi     # 0x256ab
movq %r14, %rdi
callq 0x3300
testl %eax, %eax
je 0xf273
movq $-0x1, %r12
leaq 0x1e765(%rip), %r15     # 0x2d9b0
cmpq $0x38, %r12
je 0xf289
movq 0x10(%r15), %rsi
addq $0x10, %r15
movq %r14, %rdi
callq 0x3300
incq %r12
testl %eax, %eax
jne 0xf24b
xorl %eax, %eax
cmpq $0x39, %r12
setb %al
jmp 0xf27f
leaq 0x1e736(%rip), %r15     # 0x2d9b0
movl $0x1, %eax
movq 0x8(%r15), %rcx
movq %rcx, 0x38(%rbx)
jmp 0xf28b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
testq %rbx, %rbx
je 0xf2d2
movq 0x168(%r14), %rax
addq $0x8, %rax
xorl %ecx, %ecx
cmpl $0xb, -0x8(%rax)
jne 0xf2c6
cmpl %ebp, (%rax)
je 0xf339
incq %rcx
addq $0x28, %rax
cmpq %rcx, %rbx
jne 0xf2bc
testl %edx, %edx
je 0xf332
movl $0x1, 0x368(%r14)
leaq 0x1(%rbx), %r15
movq 0x168(%r14), %rax
cmpq 0x178(%r14), %rbx
jb 0xf31a
leaq (%r15,%r15), %rcx
movq %rcx, 0x178(%r14)
movq %r15, %rcx
shlq $0x4, %rcx
leaq (%rcx,%rcx,4), %rsi
movq %rax, %rdi
callq 0x33c0
movq %rax, 0x168(%r14)
movq %r15, 0x170(%r14)
leaq (%rbx,%rbx,4), %rcx
movl $0xb, (%rax,%rcx,8)
movl %ebp, 0x8(%rax,%rcx,8)
jmp 0xf33b
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0xf33b
movl %ecx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xf37a
movq %rbx, %rdi
movl %r14d, %esi
callq 0xf4d0
movl %eax, %r12d
movl $0x1, %edi
movl $0x30, %esi
callq 0x32f0
movq %rax, %r15
movl %r14d, 0x10(%rax)
movq %rbx, %rdi
callq 0xf50d
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 0xf5f0
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 0xf5f0
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_O3/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 $0x0, 0x5d0(%rdi)
movl 0x198(%rdi), %eax
movl %eax, 0x19c(%rdi)
movq (%rsi), %rax
cmpq 0x8(%rsi), %rax
jae 0xf46c
movq %rsi, %r14
movq %rdi, %rbx
movzbl (%rax), %r8d
incq %rax
movq %rax, (%r14)
leal -0x41(%r8), %eax
cmpl $0x4, %eax
jae 0xf466
movq %rbx, %rdi
movl %r8d, %esi
movq %r14, %rdx
callq 0xf761
movq (%r14), %rax
cmpq 0x8(%r14), %rax
jb 0xf43a
jmp 0xf46c
cmpl $0xb, %r8d
jne 0xf474
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1616d(%rip), %rsi     # 0x255e8
leaq 0x166f5(%rip), %rcx     # 0x25b77
movq %rbx, %rdi
movl $0x506, %edx            # imm = 0x506
xorl %eax, %eax
callq 0xca98
// File: /workspace/github_c_makefile_star2_O3/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 0xf4b5
movq 0x5c8(%rdi), %rcx
leaq -0x1(%rax), %rdx
movq %rdx, 0x5d0(%rdi)
movq -0x8(%rcx,%rax,8), %rax
retq
pushq %rax
leaq 0x1612b(%rip), %rsi     # 0x255e8
leaq 0x16717(%rip), %rcx     # 0x25bdb
movl $0x1c5, %edx            # imm = 0x1C5
xorl %eax, %eax
callq 0xca98
// File: /workspace/github_c_makefile_star2_O3/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 0xf58c
movl $0x1, %edi
movl $0x48, %esi
callq 0x32f0
movq %rax, %r15
leaq 0x1(%r12), %r13
movq 0x180(%rbx), %rax
cmpq 0x190(%rbx), %r13
jbe 0xf57f
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 0xf5b6
jbe 0xf5d1
movq 0x180(%rbx), %r13
movq (%r13,%r12,8), %r15
testq %r15, %r15
jne 0xf5b6
movl $0x1, %edi
movl $0x48, %esi
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 0x1652f(%rip), %rdi     # 0x25b07
leaq 0x15f91(%rip), %rsi     # 0x25570
leaq 0x16550(%rip), %rcx     # 0x25b36
movl $0xfe, %edx
callq 0x31e0
// File: /workspace/github_c_makefile_star2_O3/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 0xf693
leaq 0x14708(%rip), %rcx     # 0x23d48
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x4, %eax
jmp 0xf691
movl $0x1, %eax
jmp 0xf691
movl $0x8, %eax
jmp 0xf691
movl 0xc(%rsi), %esi
movq %rbx, %rdi
popq %rbx
jmp 0xf4d0
movl $0x2, %eax
jmp 0xf691
movl 0x20(%rsi), %eax
jmp 0xf691
xorl %eax, %eax
jmp 0xf691
movl 0x8(%rsi), %ecx
movl $0x4, %eax
cmpl $0x21, %ecx
jl 0xf691
movl $0x8, %eax
cmpl $0x41, %ecx
jae 0xf693
popq %rbx
retq
movq %rbx, %rdi
callq 0x415e
leaq 0x1641a(%rip), %rsi     # 0x25abc
leaq 0x16423(%rip), %rcx     # 0x25acc
movq %rbx, %rdi
movl $0x1e1, %edx            # imm = 0x1E1
movq %rax, %r8
xorl %eax, %eax
callq 0xca98
// File: /workspace/github_c_makefile_star2_O3/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 0xf736
leaq 0x146a4(%rip), %rcx     # 0x23d78
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x4, %eax
jmp 0xf72e
movl $0x1, %eax
jmp 0xf72e
movl $0x8, %eax
jmp 0xf72e
movl 0xc(%r14), %esi
movq %rbx, %rdi
callq 0xf5f0
imull 0x8(%r14), %eax
jmp 0xf72e
movl $0x2, %eax
jmp 0xf72e
movl 0x1c(%r14), %eax
jmp 0xf72e
xorl %eax, %eax
jmp 0xf72e
movl 0x8(%r14), %ecx
movl $0x4, %eax
cmpl $0x21, %ecx
jl 0xf72e
movl $0x8, %eax
cmpl $0x41, %ecx
jae 0xf736
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
movq %r14, %rsi
callq 0x415e
leaq 0x16374(%rip), %rsi     # 0x25abc
leaq 0x16405(%rip), %rcx     # 0x25b54
movq %rbx, %rdi
movl $0x17d, %edx            # imm = 0x17D
movq %rax, %r8
xorl %eax, %eax
callq 0xca98
// File: /workspace/github_c_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r8d
movq %rdi, %rbx
leal -0x41(%r8), %eax
cmpl $0x3, %eax
ja 0xf8f0
leaq 0x14626(%rip), %rcx     # 0x23da8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rdx), %rax
movq 0x8(%rdx), %rsi
xorl %ebp, %ebp
xorl %ecx, %ecx
movb $-0x1, %dil
cmpq %rsi, %rax
jae 0xf7a7
movb (%rax), %dil
incq %rax
movq %rax, (%rdx)
movl %edi, %r8d
andb $0x7f, %r8b
movzbl %r8b, %r8d
shll %cl, %r8d
orl %r8d, %ebp
addl $0x7, %ecx
testb %dil, %dil
js 0xf796
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
shll %cl, %eax
xorl %edx, %edx
cmpb $0x40, %dil
cmovbl %edx, %eax
cmpl $0x20, %ecx
cmovael %edx, %eax
orl %eax, %ebp
movq %rbx, %rdi
movl $0x5, %esi
jmp 0xf7fe
movq (%rdx), %rax
leaq 0x4(%rax), %rcx
xorl %ebp, %ebp
cmpq 0x8(%rdx), %rcx
ja 0xf7f6
movl (%rax), %ebp
movq %rcx, (%rdx)
movq %rbx, %rdi
movl $0x8, %esi
callq 0xf96e
movl %eax, %r14d
movq %rbx, %rdi
callq 0xf50d
movq 0x180(%rbx), %rcx
movslq %eax, %rdx
movq (%rcx,%rdx,8), %rcx
movl $0x3, (%rcx)
movl %r14d, 0x24(%rcx)
movl %ebp, 0x30(%rcx)
jmp 0xf8d8
movq (%rdx), %rax
leaq 0x8(%rax), %rcx
cmpq 0x8(%rdx), %rcx
jbe 0xf89e
xorl %r15d, %r15d
jmp 0xf8a4
movq (%rdx), %rax
movq 0x8(%rdx), %rsi
xorl %r15d, %r15d
xorl %ecx, %ecx
movb $-0x1, %dil
cmpq %rsi, %rax
jae 0xf85d
movb (%rax), %dil
incq %rax
movq %rax, (%rdx)
movl %edi, %r8d
andb $0x7f, %r8b
movzbl %r8b, %r8d
shlq %cl, %r8
orq %r8, %r15
addl $0x7, %ecx
testb %dil, %dil
js 0xf84c
movq $-0x1, %rax
shlq %cl, %rax
xorl %edx, %edx
cmpb $0x40, %dil
cmovbq %rdx, %rax
cmpl $0x40, %ecx
cmovaeq %rdx, %rax
orq %rax, %r15
movq %rbx, %rdi
movl $0x6, %esi
jmp 0xf8ac
movq (%rax), %r15
movq %rcx, (%rdx)
movq %rbx, %rdi
movl $0x9, %esi
callq 0xf96e
movl %eax, %r14d
movq %rbx, %rdi
callq 0xf50d
movq 0x180(%rbx), %rcx
movslq %eax, %rdx
movq (%rcx,%rdx,8), %rcx
movl $0x3, (%rcx)
movl %r14d, 0x24(%rcx)
movq %r15, 0x30(%rcx)
shlq $0x20, %r14
movl %eax, %esi
orq %r14, %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xf90d
leaq 0x15cf1(%rip), %rsi     # 0x255e8
leaq 0x162a3(%rip), %rcx     # 0x25ba1
movq %rbx, %rdi
movl $0x356, %edx            # imm = 0x356
xorl %eax, %eax
callq 0xca98
// File: /workspace/github_c_makefile_star2_O3/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
testq %rcx, %rcx
je 0xf998
movq 0x168(%rdi), %rdx
xorl %eax, %eax
cmpl %r8d, (%rdx)
je 0xf9b2
incq %rax
addq $0x28, %rdx
cmpq %rax, %rcx
jne 0xf987
leaq 0x1611d(%rip), %rsi     # 0x25abc
leaq 0x16218(%rip), %rcx     # 0x25bbe
movl $0x14f, %edx            # imm = 0x14F
xorl %eax, %eax
callq 0xca98
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movslq %edx, %rax
cmpq %rax, 0x188(%rsi)
jbe 0xf9e7
movq 0x180(%rsi), %rcx
movq (%rcx,%rax,8), %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xfa33
movl %edx, %ecx
leaq 0x16201(%rip), %rdx     # 0x25bf1
movq %rsp, %r14
movl $0x40, %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x31a0
movq %r14, %rdi
callq 0x3170
movq %rax, %r14
testq %rbx, %rbx
je 0xfa26
movq (%rbx), %rdi
movslq %r14d, %r15
movq %rsp, %rsi
movq %r15, %rdx
callq 0x3360
addq %r15, (%rbx)
movl %r14d, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rcx
movq %rdi, %rbx
movslq %ecx, %rax
cmpq 0x188(%rsi), %rax
jae 0x10164
movq %rcx, %rdi
sarq $0x20, %rdi
cmpq 0x170(%rsi), %rdi
jae 0x1016d
movq 0x180(%rsi), %rcx
movq (%rcx,%rax,8), %rdx
leaq (%rdi,%rdi,4), %rcx
shlq $0x3, %rcx
addq 0x168(%rsi), %rcx
movq %rbx, %rdi
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xfa33
leaq 0x15a86(%rip), %rdx     # 0x25bf1
jmp 0x10178
shrq $0x20, %rcx
leaq 0x15b2c(%rip), %rdx     # 0x25ca4
movq %rsp, %r14
movl $0x40, %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x31a0
movq %r14, %rdi
callq 0x3170
movq %rax, %r14
testq %rbx, %rbx
je 0x101ae
movq (%rbx), %rdi
movslq %r14d, %r15
movq %rsp, %rsi
movq %r15, %rdx
callq 0x3360
addq %r15, (%rbx)
movl %r14d, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x101e7
movq 0x20(%r14), %rsi
callq 0x3300
xorl %ecx, %ecx
testl %eax, %eax
jne 0x101ed
movl 0x100(%rbx), %ecx
movl %ecx, 0x104(%rbx)
movq $0x8, 0x2c(%r14)
movl 0x10(%r14), %r8d
cmpq %r8, 0x170(%rbx)
jbe 0x1028d
movq 0x168(%rbx), %rax
leaq (%r8,%r8,4), %rcx
cmpl $0x0, 0x14(%rax,%rcx,8)
jle 0x1027e
leaq (%rax,%rcx,8), %r14
xorl %r15d, %r15d
movq 0x8(%r14), %rax
movl (%rax,%r15,4), %ebp
movq %rbx, %rdi
callq 0xf50d
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 0x11c49
shll $0x2, %eax
movl 0x30(%r13), %ecx
subl %eax, %ecx
movl %ecx, 0x30(%r13)
movl %ecx, 0x30(%r12)
incq %r15
movslq 0x14(%r14), %rax
cmpq %rax, %r15
jl 0x10225
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x15828(%rip), %rsi     # 0x25abc
leaq 0x1585a(%rip), %rcx     # 0x25af5
movq %rbx, %rdi
movl $0x7c, %edx
xorl %eax, %eax
callq 0xca98
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movl $0x1, %edi
movl $0x68, %esi
callq 0x32f0
movq %rax, %r14
movabsq $-0xffffffff, %rax      # imm = 0xFFFFFFFF00000001
movq %rax, 0x28(%r14)
movl $0xffffffff, 0x30(%r14) # imm = 0xFFFFFFFF
movq %r15, 0x10(%r14)
movq 0x18(%r15), %rax
movq %rax, 0x8(%r14)
movq %r14, (%rax)
movq %r14, 0x18(%r15)
movq 0x1c0(%rbx), %rax
movl 0x10(%rax), %r8d
cmpq %r8, 0x170(%rbx)
jbe 0x117d9
movq 0x168(%rbx), %rax
leaq (%r8,%r8,4), %rcx
cmpl $0x0, 0x10(%rax,%rcx,8)
je 0x117cb
movq %rbx, %rdi
callq 0xf491
movq %rax, 0x58(%r14)
jmp 0x117d3
movl $0xffffffff, 0x58(%r14) # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %r15
retq
leaq 0x142dc(%rip), %rsi     # 0x25abc
leaq 0x1430e(%rip), %rcx     # 0x25af5
movq %rbx, %rdi
movl $0x7c, %edx
xorl %eax, %eax
callq 0xca98
// File: /workspace/github_c_makefile_star2_O3/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
movl %esi, %eax
cmpq %rax, 0x170(%rdi)
jbe 0x11ca0
movq 0x168(%rbx), %rcx
leaq (%rax,%rax,4), %rax
leaq (%rcx,%rax,8), %rsi
movl (%rsi), %ecx
cmpl $0xc, %ecx
ja 0x11cc0
movl $0x1, %eax
movl $0x193c, %edx           # imm = 0x193C
btl %ecx, %edx
jb 0x11c9e
movl $0x240, %eax            # imm = 0x240
btl %ecx, %eax
jae 0x11c8e
movl $0x2, %eax
jmp 0x11c9e
cmpl $0x7, %ecx
jne 0x11cc0
xorl %eax, %eax
cmpl $0x21, 0x8(%rsi)
setge %al
incl %eax
popq %rbx
retq
movl %esi, %r8d
leaq 0x13e12(%rip), %rsi     # 0x25abc
leaq 0x13e44(%rip), %rcx     # 0x25af5
movq %rbx, %rdi
movl $0x7c, %edx
xorl %eax, %eax
callq 0xca98
movq %rbx, %rdi
callq 0x415e
leaq 0x138a1(%rip), %rsi     # 0x25570
leaq 0x14023(%rip), %rcx     # 0x25cf9
movq %rbx, %rdi
movl $0x190, %edx            # imm = 0x190
movq %rax, %r8
xorl %eax, %eax
callq 0xca98
// File: /workspace/github_c_makefile_star2_O3/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, %rbx
movq %rdi, %r14
movl $0x1, %edi
movl $0x58, %esi
callq 0x32f0
leaq 0x10(%rax), %rcx
movq %rcx, 0x18(%rax)
movl 0x40(%r14), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x40(%r14)
movl %ecx, 0x28(%rax)
testq %rbx, %rbx
je 0x11d3d
movq (%rbx), %rcx
addq $0x50, %r14
leaq 0x8(%rcx), %rdx
testq %rcx, %rcx
cmoveq %r14, %rdx
movq %rcx, (%rax)
movq %rax, (%rdx)
movq %rax, (%rbx)
movq %rbx, 0x8(%rax)
jmp 0x11d4c
movq 0x50(%r14), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%rcx)
movq %rax, 0x50(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, %edi
movl $0x60, %esi
callq 0x32f0
movq %rax, %r12
movabsq $-0xffffffeb, %rax      # imm = 0xFFFFFFFF00000015
movq %rax, 0x28(%r12)
movl $0xffffffff, 0x30(%r12) # imm = 0xFFFFFFFF
movq %r14, 0x10(%r12)
movq 0x18(%r14), %rax
movq %rax, 0x8(%r12)
movq %r12, (%rax)
movq %r12, 0x18(%r14)
movq %r15, %rdi
callq 0xf491
movq %rax, 0x58(%r12)
movl %ebx, 0x2c(%r12)
shrq $0x20, %rax
movl %eax, 0x30(%r12)
movq %r15, %rdi
movq %r12, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x11d54
// File: /workspace/github_c_makefile_star2_O3/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, %r14
movq %rsi, %r13
movq %rdi, %rbx
movq 0x20(%rsi), %r12
movl 0x10(%rsi), %esi
callq 0x120fa
cmpb $0x0, 0x2a(%r13)
leaq 0x13f65(%rip), %rcx     # 0x25e46
leaq 0x13f16(%rip), %r8      # 0x25dfe
cmoveq %rcx, %r8
leaq 0x13eeb(%rip), %rdi     # 0x25dde
movq %r14, %rsi
movq %r12, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3190
movq 0x48(%r13), %r15
testq %r15, %r15
je 0x12018
leaq 0x13f30(%rip), %r12     # 0x25e47
leaq 0x13f21(%rip), %r13     # 0x25e3f
leaq 0x13f11(%rip), %rbp     # 0x25e36
movq 0x50(%r15), %rcx
testq %rcx, %rcx
leaq 0x13ee8(%rip), %rdx     # 0x25e1b
leaq 0x13f0c(%rip), %rdi     # 0x25e46
cmoveq %rdi, %rdx
cmoveq %rdi, %rcx
leaq 0x13ed3(%rip), %r8      # 0x25e1c
cmoveq %rdi, %r8
cmpb $0x0, 0x2d(%r15)
leaq 0x13ec5(%rip), %r9      # 0x25e1e
cmoveq %rdi, %r9
cmpb $0x0, 0x2e(%r15)
movl 0x28(%r15), %esi
leaq 0x13eb8(%rip), %rax     # 0x25e25
cmoveq %rdi, %rax
movq %rax, (%rsp)
leaq 0x13e90(%rip), %rdi     # 0x25e0c
xorl %eax, %eax
callq 0x3190
movq 0x30(%r15), %r14
testq %r14, %r14
je 0x11fa3
movq 0x30(%r14), %rax
movl 0x28(%rax), %esi
movq %rbp, %rdi
xorl %eax, %eax
callq 0x3190
movq 0x10(%r14), %r14
jmp 0x11f87
movl $0xa, %edi
callq 0x3040
movq 0x10(%r15), %r14
testq %r14, %r14
je 0x11fd5
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x12140
movq %r13, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x3190
movq (%r14), %r14
jmp 0x11fb1
leaq 0x13e68(%rip), %rdi     # 0x25e44
xorl %eax, %eax
callq 0x3190
movq 0x38(%r15), %r14
testq %r14, %r14
je 0x12002
movq 0x38(%r14), %rax
movl 0x28(%rax), %esi
movq %r12, %rdi
xorl %eax, %eax
callq 0x3190
movq (%r14), %r14
jmp 0x11fe7
movl $0xa, %edi
callq 0x3040
movq (%r15), %r15
testq %r15, %r15
jne 0x11f25
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r12
pushq %rbx
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, %edi
movl $0x7c, %esi
callq 0x32f0
movq %rax, %r12
movabsq $-0xffffffea, %rax      # imm = 0xFFFFFFFF00000016
movq %rax, 0x28(%r12)
movl $0xffffffff, 0x30(%r12) # imm = 0xFFFFFFFF
movq %r14, 0x10(%r12)
movq 0x18(%r14), %rax
movq %rax, 0x8(%r12)
movq %r12, (%rax)
movq %r12, 0x18(%r14)
movl %ebp, 0x60(%r12)
movl $0x1, 0x6c(%r12)
movq %r15, %rdi
callq 0xf491
movq %rax, 0x70(%r12)
movq %r15, %rdi
movl %ebx, %esi
movq %r12, %rdx
callq 0x12027
movq 0x2c(%r12), %rsi
movq %r15, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xf90d
// File: /workspace/github_c_makefile_star2_O3/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 0xd2e5
movq %r14, %rdi
movl %eax, %esi
callq 0xd299
movq %rax, %r15
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
movq %r14, %rsi
movl %ebx, %edx
callq 0xd2e5
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1218e
movq %r15, %rdi
movl %eax, %esi
callq 0xd299
movq %rax, %r12
movq %rsp, %rdi
movq %rax, (%rdi)
movq %r15, %rsi
movq %r14, %rdx
movl %ebx, %ecx
callq 0x1218e
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
movl 0x24(%rsi), %r8d
cmpq %r8, 0x170(%rdi)
jbe 0x16a93
movl (%rsi), %eax
cmpl $0x3, %eax
je 0x16a57
cmpl $0x2, %eax
jne 0x16ab0
movq 0x30(%rsi), %rax
movl 0x28(%rax), %eax
jmp 0x16a81
movq 0x168(%rbx), %rax
leaq (%r8,%r8,4), %rcx
movl (%rax,%rcx,8), %eax
cmpl $0xb, %eax
ja 0x16ab0
movl $0x938, %ecx            # imm = 0x938
btl %eax, %ecx
jb 0x16a7e
movl $0x2c0, %ecx            # imm = 0x2C0
btl %eax, %ecx
jae 0x16a83
movl 0x30(%rsi), %eax
popq %rbx
retq
cmpl $0x2, %eax
jne 0x16ab0
xorl %eax, %eax
cmpl $0x0, 0x30(%rsi)
setne %al
jmp 0x16a81
leaq 0xf022(%rip), %rsi      # 0x25abc
leaq 0xf054(%rip), %rcx      # 0x25af5
movq %rbx, %rdi
movl $0x7c, %edx
xorl %eax, %eax
callq 0xca98
movq %rbx, %rdi
callq 0x16be1
leaq 0xeab1(%rip), %rsi      # 0x25570
leaq 0xf754(%rip), %rcx      # 0x2621a
movq %rbx, %rdi
movl $0x1d5, %edx            # imm = 0x1D5
movq %rax, %r8
xorl %eax, %eax
callq 0xca98
// File: /workspace/github_c_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdx), %r8d
cmpq %r8, 0x188(%rdi)
jbe 0x16b94
movq 0x180(%rbx), %rax
movq (%rax,%r8,8), %r13
movl (%r13), %eax
leal -0x4(%rax), %ecx
cmpl $0x2, %ecx
jb 0x16b85
addl $-0x2, %eax
cmpl $0x1, %eax
ja 0x16bb1
movq %rdx, %r14
movq %rsi, %r15
movq 0x10(%rsi), %rbp
movl $0x1, %edi
movl $0x60, %esi
callq 0x32f0
movq %rax, %r12
movabsq $-0xffffffeb, %rax      # imm = 0xFFFFFFFF00000015
movq %rax, 0x28(%r12)
movl $0xffffffff, 0x30(%r12) # imm = 0xFFFFFFFF
movq %rbp, 0x10(%r12)
movq 0x8(%r15), %rax
movq %rax, 0x8(%r12)
movq %r15, (%r12)
movq %r12, (%rax)
movq %r12, 0x8(%r15)
movl 0x24(%r13), %esi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x12027
movq (%r14), %rax
movq %rax, 0x58(%r12)
movq 0x2c(%r12), %rax
movq %rax, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xe9d5(%rip), %rsi      # 0x25570
leaq 0xf182(%rip), %rcx      # 0x25d24
movq %rbx, %rdi
movl $0x143, %edx            # imm = 0x143
xorl %eax, %eax
callq 0xca98
movl 0x24(%r13), %esi
movq %rbx, %rdi
callq 0x120fa
movl (%r13), %r9d
leaq 0xf596(%rip), %rsi      # 0x2615e
leaq 0xf672(%rip), %rcx      # 0x26241
movq %rbx, %rdi
movl $0x35, %edx
movq %rax, %r8
xorl %eax, %eax
callq 0xca98
// File: /workspace/github_c_makefile_star2_O3/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 0xfa33
movq %r14, %rdi
movl %eax, %esi
callq 0xd299
movq %rax, %r15
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
movq %r14, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0xfa33
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/cogbee[P]vmir-latest/src/vmir_transform.c
// Function: instr_bind_input
static void
instr_bind_input(ir_unit_t *iu, ir_valuetype_t vt, ir_instr_t *ii)
{
  if(vt.value == -1)
    return;
  ir_value_t *iv = value_get(iu, vt.value);
  if(iv->iv_class != IR_VC_TEMPORARY)
    return;
  value_bind_instr(iv, ii, IVI_INPUT);
}

// Assembly:
movq %rsi, %r8
cmpl $-0x1, %r8d
je 0x16ca0
movl %r8d, %eax
cmpq %rax, 0x188(%rdi)
jbe 0x16ca1
movq 0x180(%rdi), %rcx
movq (%rcx,%rax,8), %rdi
cmpl $0x4, (%rdi)
jne 0x16ca0
movq %rdx, %rsi
xorl %edx, %edx
jmp 0x11d8e
retq
pushq %rax
leaq 0xe8c7(%rip), %rsi      # 0x25570
leaq 0xf074(%rip), %rcx      # 0x25d24
movl $0x143, %edx            # imm = 0x143
xorl %eax, %eax
callq 0xca98
// File: /workspace/github_c_makefile_star2_O3/cogbee[P]vmir-latest/src/vmir_transform.c
// Function: cfg_add_edge
static void
cfg_add_edge(ir_function_t *f, ir_bb_t *from, int bb, int mark)
{
  ir_bb_t *to = bb_find(f, bb);
  if(mark) {
    if(to->ib_mark)
      return;
    to->ib_mark = 1;
  }
  cfg_create_edge(f, from, to);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x48(%rdi), %r15
movq (%r15), %r15
testq %r15, %r15
je 0x16cd9
cmpl %edx, 0x28(%r15)
jne 0x16ccb
testl %ecx, %ecx
je 0x16ce9
cmpb $0x0, 0x2c(%r15)
jne 0x16d59
movb $0x1, 0x2c(%r15)
movl $0x40, %edi
callq 0x3380
movq 0x58(%r14), %rcx
addq $0x58, %r14
movq %rcx, 0x20(%rax)
testq %rcx, %rcx
je 0x16d0c
leaq 0x20(%rax), %rdx
movq %rdx, 0x28(%rcx)
movq %rax, (%r14)
movq %r14, 0x28(%rax)
movq %rbx, 0x30(%rax)
movq 0x38(%rbx), %rcx
addq $0x38, %rbx
movq %rcx, (%rax)
testq %rcx, %rcx
je 0x16d2b
movq %rax, 0x8(%rcx)
movq %rax, (%rbx)
movq %rbx, 0x8(%rax)
movq %r15, 0x38(%rax)
movq 0x30(%r15), %rcx
addq $0x30, %r15
movq %rcx, 0x10(%rax)
testq %rcx, %rcx
je 0x16d52
movq %rax, %rdx
addq $0x10, %rdx
movq %rdx, 0x18(%rcx)
movq %rax, (%r15)
movq %r15, 0x18(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rdi, %r14
movl 0x28(%rdi), %eax
cmpl $0xa, %eax
jle 0x16dae
cmpl $0xb, %eax
je 0x16de6
cmpl $0xc, %eax
je 0x16e05
cmpl $0x19, %eax
jne 0x16e61
movl 0x28(%rsi), %eax
cmpl %eax, 0x6c(%r14)
jne 0x16d98
movl 0x28(%rdx), %ecx
movl %ecx, 0x6c(%r14)
cmpl %eax, 0x70(%r14)
jne 0x16e3c
movl 0x28(%rdx), %eax
movl %eax, 0x70(%r14)
jmp 0x16e3c
cmpl $0x1, %eax
je 0x16e3c
cmpl $0x8, %eax
jne 0x16e61
movl 0x28(%rsi), %eax
cmpl %eax, 0x60(%r14)
jne 0x16dd0
movl 0x28(%rdx), %ecx
movl %ecx, 0x60(%r14)
cmpl $-0x1, 0x58(%r14)
je 0x16e3c
cmpl %eax, 0x64(%r14)
jne 0x16e3c
movl 0x28(%rdx), %eax
movl %eax, 0x64(%r14)
jmp 0x16e3c
movl 0x28(%rsi), %eax
cmpl %eax, 0x64(%r14)
jne 0x16df6
movl 0x28(%rdx), %ecx
movl %ecx, 0x64(%r14)
cmpl %eax, 0x68(%r14)
jne 0x16e3c
movl 0x28(%rdx), %eax
movl %eax, 0x68(%r14)
jmp 0x16e3c
movl 0x28(%rsi), %eax
cmpl %eax, 0x60(%r14)
jne 0x16e15
movl 0x28(%rdx), %ecx
movl %ecx, 0x60(%r14)
movslq 0x64(%r14), %rcx
testq %rcx, %rcx
jle 0x16e3c
shlq $0x4, %rcx
xorl %esi, %esi
cmpl %eax, 0x70(%r14,%rsi)
jne 0x16e33
movl 0x28(%rdx), %edi
movl %edi, 0x70(%r14,%rsi)
addq $0x10, %rsi
cmpq %rsi, %rcx
jne 0x16e24
movq 0x40(%r14), %rdi
testq %rdi, %rdi
je 0x16e59
callq 0x3030
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x16e76
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0xf576(%rip), %rdi      # 0x263de
movl %eax, %esi
xorl %eax, %eax
callq 0x3190
callq 0x3060
// File: /workspace/github_c_makefile_star2_O3/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 0x17088
movq 0x180(%rdi), %rcx
movq (%rcx,%rax,8), %rax
cmpl $0x4, (%rax)
jne 0x17084
movq 0x8(%rax), %rcx
testq %rcx, %rcx
je 0x17084
xorl %eax, %eax
movl 0x30(%rcx), %esi
testl %esi, %esi
je 0x17074
cmpl $0x1, %esi
jne 0x1707a
testq %rax, %rax
jne 0x17084
movq 0x28(%rcx), %rax
jmp 0x1707a
cmpq %rdx, 0x28(%rcx)
jne 0x17084
movq (%rcx), %rcx
testq %rcx, %rcx
jne 0x1705d
jmp 0x17086
xorl %eax, %eax
popq %rcx
retq
leaq 0xe4e1(%rip), %rsi      # 0x25570
leaq 0xec8e(%rip), %rcx      # 0x25d24
movl $0x143, %edx            # imm = 0x143
xorl %eax, %eax
callq 0xca98