LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x8(%rdi), %rcx
movq %rax, (%rcx)
movq 0x30(%rdi), %rdi
testq %rdi, %rdi
je 0xef5e
callq 0xefe9
movq 0x30(%rbx), %rdi
jmp 0xef49
callq 0xefe9
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
jne 0xef59
jmp 0xef6e
callq 0xef89
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
jne 0xef69
movq 0x50(%rbx), %rdi
callq 0x3030
movq %rbx, %rdi
popq %rbx
jmp 0x3030
// File: /workspace/github_c_makefile_star2_O1/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 0xefa1
callq 0xf035
movq 0x20(%rbx), %rdi
jmp 0xef91
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 0xefce
leaq 0x8(%rax), %rdx
jmp 0xefd6
movq 0x10(%rbx), %rdx
addq $0x18, %rdx
movq %rcx, (%rdx)
movq 0x8(%rbx), %rcx
movq %rax, (%rcx)
movq %rbx, %rdi
popq %rbx
jmp 0x3030
// File: /workspace/github_c_makefile_star2_O1/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
testq %rax, %rax
je 0xeff9
movq 0x8(%rdi), %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rdi), %rcx
movq %rax, (%rcx)
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0xf011
movq 0x18(%rdi), %rcx
movq %rcx, 0x18(%rax)
movq 0x18(%rdi), %rcx
movq %rax, (%rcx)
movq 0x20(%rdi), %rax
testq %rax, %rax
je 0xf029
movq 0x28(%rdi), %rcx
movq %rcx, 0x28(%rax)
movq 0x28(%rdi), %rcx
movq %rax, (%rcx)
jmp 0x3030
// File: /workspace/github_c_makefile_star2_O1/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
cmpq %r12, 0x188(%rdi)
jb 0xf119
movl %esi, %ebx
movq %rdi, %r14
cmpq %r12, 0x188(%rdi)
jbe 0xf108
xorl %r13d, %r13d
movq 0x180(%r14), %rax
movq (%rax,%r12,8), %r15
testq %r15, %r15
je 0xf0fc
movq %r13, (%rax,%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 0xf0d1
callq 0xf035
jmp 0xf0c1
cmpl $0x2, (%r15)
jne 0xf0ed
movq 0x30(%r15), %rax
movq 0x20(%rax), %rdi
callq 0x3030
movq 0x30(%r15), %rdi
callq 0x3030
movl $0x0, (%r15)
movq %r15, %rdi
callq 0x3030
incq %r12
cmpq %r12, 0x188(%r14)
ja 0xf093
movl %ebx, 0x198(%r14)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x1637a(%rip), %rdi     # 0x2549a
leaq 0x16399(%rip), %rsi     # 0x254c0
leaq 0x163a3(%rip), %rcx     # 0x254d1
movl $0xe5, %edx
callq 0x31e0
// File: /workspace/github_c_makefile_star2_O1/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 0xf16a
movq (%rdi), %rax
testq %rax, %rax
movq %rax, %rcx
cmoveq %rbx, %rcx
movq 0x8(%rdi), %rdx
movq %rdx, 0x8(%rcx)
movq 0x8(%rdi), %rcx
movq %rax, (%rcx)
callq 0x3030
movq (%rbx), %rdi
jmp 0xf13f
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xf188
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 0xf177
retq
// File: /workspace/github_c_makefile_star2_O1/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), %rdx
movq 0x8(%rsi), %rax
xorl %r14d, %r14d
xorl %ecx, %ecx
movb $-0x1, %sil
cmpq %rax, %rdx
jae 0xf1ca
movb (%rdx), %sil
incq %rdx
movq %rdx, (%rbx)
movl %esi, %r8d
andb $0x7f, %r8b
movzbl %r8b, %r8d
shll %cl, %r8d
orl %r8d, %r14d
addl $0x7, %ecx
testb %sil, %sil
js 0xf1b9
movq (%rbx), %r15
subq %r15, %rax
cmpq %r14, %rax
jl 0xf223
movl %r14d, %edi
incl %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 0x1630e(%rip), %rsi     # 0x25538
leaq 0x1631e(%rip), %rcx     # 0x2554f
movl $0xa7, %edx
xorl %eax, %eax
callq 0xca73
// File: /workspace/github_c_makefile_star2_O1/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
movb $-0x1, %al
cmpq 0x8(%rsi), %rcx
jae 0xf250
movb (%rcx), %al
incq %rcx
movq %rcx, (%rsi)
movzbl %al, %r8d
leal -0x7c(%r8), %eax
cmpl $0x4, %eax
jae 0xf266
movl $0x80, %eax
subl %r8d, %eax
retq
xorl %eax, %eax
cmpl $0x40, %r8d
je 0xf265
pushq %rax
movq 0x10(%rsi), %r9
notq %r9
addq (%rsi), %r9
leaq 0x162b8(%rip), %rsi     # 0x25538
leaq 0x16322(%rip), %rcx     # 0x255a9
movl $0xc1, %edx
xorl %eax, %eax
callq 0xca73
// File: /workspace/github_c_makefile_star2_O1/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 0x1634b(%rip), %rsi     # 0x255fb
movq %r14, %rdi
callq 0x3300
leaq 0x1e6f1(%rip), %r15     # 0x2d9b0
testl %eax, %eax
je 0xf2ef
xorl %r12d, %r12d
cmpq $0x39, %r12
je 0xf2fb
movq 0x10(%r15), %rsi
addq $0x10, %r15
movq %r14, %rdi
callq 0x3300
incq %r12
testl %eax, %eax
jne 0xf2c6
decq %r12
cmpq $0x39, %r12
setb %al
jmp 0xf2f1
movb $0x1, %al
movq 0x8(%r15), %rcx
movq %rcx, 0x38(%rbx)
jmp 0xf2fe
setb %al
movzbl %al, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/cogbee[P]vmir-latest/src/vmir_type.c
// Function: type_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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq 0x170(%rdi), %r15
testq %r15, %r15
setne %cl
je 0xf35e
movq 0x168(%r14), %rsi
addq $0x8, %rsi
xorl %edi, %edi
movb $0x1, %r8b
cmpl $0xb, -0x8(%rsi)
jne 0xf348
cmpl %ebx, (%rsi)
jne 0xf348
xorl %r8d, %r8d
movl %edi, %eax
testb %r8b, %r8b
je 0xf35e
incq %rdi
addq $0x28, %rsi
cmpq %rdi, %r15
seta %cl
jne 0xf336
jmp 0xf35e
testb $0x1, %cl
jne 0xf3cf
testl %edx, %edx
je 0xf3ca
movl $0x1, 0x368(%r14)
leaq 0x1(%r15), %r12
cmpq 0x178(%r14), %r12
jbe 0xf3a8
leaq (%r12,%r12), %rax
movq %rax, 0x178(%r14)
movq %r12, %rax
shlq $0x4, %rax
leaq (%rax,%rax,4), %rsi
movq 0x168(%r14), %rdi
callq 0x33c0
movq %rax, 0x168(%r14)
movq %r12, 0x170(%r14)
movq 0x168(%r14), %rax
leaq (%r15,%r15,4), %rcx
movl $0xb, (%rax,%rcx,8)
movl %ebx, 0x8(%rax,%rcx,8)
movl %r15d, %eax
jmp 0xf3cf
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/cogbee[P]vmir-latest/src/vmir_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 0xf40d
movq %rbx, %rdi
movl %r14d, %esi
callq 0xf563
movl %eax, %r12d
movl $0x1, %edi
movl $0x30, %esi
callq 0x32f0
movq %rax, %r15
movl %r14d, 0x10(%rax)
movq %rbx, %rdi
callq 0xf5a0
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 0xf67c
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 0xf67c
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_O1/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 0xf4ff
movq %rsi, %r14
movq %rdi, %rbx
movzbl (%rax), %r8d
incq %rax
movq %rax, (%r14)
leal -0x41(%r8), %eax
cmpl $0x4, %eax
jae 0xf4f9
movq %rbx, %rdi
movl %r8d, %esi
movq %r14, %rdx
callq 0xf7ed
movq (%r14), %rax
cmpq 0x8(%r14), %rax
jb 0xf4cd
jmp 0xf4ff
cmpl $0xb, %r8d
jne 0xf507
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1602a(%rip), %rsi     # 0x25538
leaq 0x165b2(%rip), %rcx     # 0x25ac7
movq %rbx, %rdi
movl $0x506, %edx            # imm = 0x506
xorl %eax, %eax
callq 0xca73
// File: /workspace/github_c_makefile_star2_O1/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 0xf548
movq 0x5c8(%rdi), %rcx
leaq -0x1(%rax), %rdx
movq %rdx, 0x5d0(%rdi)
movq -0x8(%rcx,%rax,8), %rax
retq
pushq %rax
leaq 0x15fe8(%rip), %rsi     # 0x25538
leaq 0x165d4(%rip), %rcx     # 0x25b2b
movl $0x1c5, %edx            # imm = 0x1C5
xorl %eax, %eax
callq 0xca73
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq 0x198(%rdi), %r12
movq 0x188(%rdi), %r15
cmpq %r12, %r15
jne 0xf616
movl $0x1, %edi
movl $0x48, %esi
callq 0x32f0
movq %rax, %r14
leaq 0x1(%r15), %r12
cmpq 0x190(%rbx), %r12
jbe 0xf602
leaq (%r12,%r12), %rax
movq %rax, 0x190(%rbx)
movq %r12, %rsi
shlq $0x4, %rsi
movq 0x180(%rbx), %rdi
callq 0x33c0
movq %rax, 0x180(%rbx)
movq %r12, 0x188(%rbx)
movq 0x180(%rbx), %rax
movq %r14, (%rax,%r15,8)
jmp 0xf63e
jbe 0xf65d
movq 0x180(%rbx), %r15
movq (%r15,%r12,8), %r14
testq %r14, %r14
jne 0xf63e
movl $0x1, %edi
movl $0x48, %esi
callq 0x32f0
movq %rax, %r14
movq %rax, (%r15,%r12,8)
movl 0x198(%rbx), %eax
movl %eax, 0x20(%r14)
leal 0x1(%rax), %ecx
movl %ecx, 0x198(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x163f3(%rip), %rdi     # 0x25a57
leaq 0x15e55(%rip), %rsi     # 0x254c0
leaq 0x16414(%rip), %rcx     # 0x25a86
movl $0xfe, %edx
callq 0x31e0
// File: /workspace/github_c_makefile_star2_O1/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 0xf71f
leaq 0x14658(%rip), %rcx     # 0x23d24
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x4, %eax
jmp 0xf71d
movl $0x1, %eax
jmp 0xf71d
movl $0x8, %eax
jmp 0xf71d
movl 0xc(%rsi), %esi
movq %rbx, %rdi
popq %rbx
jmp 0xf563
movl $0x2, %eax
jmp 0xf71d
movl 0x20(%rsi), %eax
jmp 0xf71d
xorl %eax, %eax
jmp 0xf71d
movl 0x8(%rsi), %ecx
movl $0x4, %eax
cmpl $0x21, %ecx
jl 0xf71d
movl $0x8, %eax
cmpl $0x41, %ecx
jge 0xf71f
popq %rbx
retq
movq %rbx, %rdi
callq 0x4112
leaq 0x162de(%rip), %rsi     # 0x25a0c
leaq 0x162e7(%rip), %rcx     # 0x25a1c
movq %rbx, %rdi
movl $0x1e1, %edx            # imm = 0x1E1
movq %rax, %r8
xorl %eax, %eax
callq 0xca73
// File: /workspace/github_c_makefile_star2_O1/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 0xf7c2
leaq 0x145f4(%rip), %rcx     # 0x23d54
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x4, %eax
jmp 0xf7ba
movl $0x1, %eax
jmp 0xf7ba
movl $0x8, %eax
jmp 0xf7ba
movl 0xc(%r14), %esi
movq %rbx, %rdi
callq 0xf67c
imull 0x8(%r14), %eax
jmp 0xf7ba
movl $0x2, %eax
jmp 0xf7ba
movl 0x1c(%r14), %eax
jmp 0xf7ba
xorl %eax, %eax
jmp 0xf7ba
movl 0x8(%r14), %ecx
movl $0x4, %eax
cmpl $0x21, %ecx
jl 0xf7ba
movl $0x8, %eax
cmpl $0x41, %ecx
jge 0xf7c2
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4112
leaq 0x16238(%rip), %rsi     # 0x25a0c
leaq 0x162c9(%rip), %rcx     # 0x25aa4
movq %rbx, %rdi
movl $0x17d, %edx            # imm = 0x17D
movq %rax, %r8
xorl %eax, %eax
callq 0xca73
// File: /workspace/github_c_makefile_star2_O1/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 0xf97c
leaq 0x14576(%rip), %rcx     # 0x23d84
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 0xf833
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 0xf822
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 0xf88a
movq (%rdx), %rax
leaq 0x4(%rax), %rcx
xorl %ebp, %ebp
cmpq 0x8(%rdx), %rcx
ja 0xf882
movl (%rax), %ebp
movq %rcx, (%rdx)
movq %rbx, %rdi
movl $0x8, %esi
callq 0xf9fe
movl %eax, %r14d
movq %rbx, %rdi
callq 0xf5a0
movq 0x180(%rbx), %rcx
movslq %eax, %rdx
movq (%rcx,%rdx,8), %rcx
movl $0x3, (%rcx)
movl %r14d, 0x24(%rcx)
movl %ebp, 0x30(%rcx)
jmp 0xf964
movq (%rdx), %rax
leaq 0x8(%rax), %rcx
cmpq 0x8(%rdx), %rcx
jbe 0xf92a
xorl %r15d, %r15d
jmp 0xf930
movq (%rdx), %rax
movq 0x8(%rdx), %rsi
xorl %r15d, %r15d
xorl %ecx, %ecx
movb $-0x1, %dil
cmpq %rsi, %rax
jae 0xf8e9
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 0xf8d8
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 0xf938
movq (%rax), %r15
movq %rcx, (%rdx)
movq %rbx, %rdi
movl $0x9, %esi
callq 0xf9fe
movl %eax, %r14d
movq %rbx, %rdi
callq 0xf5a0
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 0xf999
leaq 0x15bb5(%rip), %rsi     # 0x25538
leaq 0x16167(%rip), %rcx     # 0x25af1
movq %rbx, %rdi
movl $0x356, %edx            # imm = 0x356
xorl %eax, %eax
callq 0xca73
// File: /workspace/github_c_makefile_star2_O1/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
setne %sil
je 0xfa4c
movq 0x168(%rdi), %rdx
xorl %eax, %eax
cmpl %r8d, (%rdx)
je 0xfa45
addq $0x28, %rdx
leaq -0x1(%rcx), %rsi
xorl %eax, %eax
cmpq %rax, %rsi
je 0xfa4c
leaq 0x28(%rdx), %r9
incq %rax
cmpl %r8d, (%rdx)
movq %r9, %rdx
jne 0xfa2a
cmpq %rax, %rcx
seta %sil
testb %sil, %sil
je 0xfa4c
popq %rcx
retq
leaq 0x15fb9(%rip), %rsi     # 0x25a0c
leaq 0x160b4(%rip), %rcx     # 0x25b0e
movl $0x14f, %edx            # imm = 0x14F
xorl %eax, %eax
callq 0xca73
// File: /workspace/github_c_makefile_star2_O1/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 0xfa99
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 0xfae5
movl %edx, %ecx
leaq 0x1609f(%rip), %rdx     # 0x25b41
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 0xfad8
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_O1/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 0x101ed
movq %rcx, %rdi
sarq $0x20, %rdi
cmpq 0x170(%rsi), %rdi
jae 0x101f6
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 0xfae5
leaq 0x1594d(%rip), %rdx     # 0x25b41
jmp 0x10201
shrq $0x20, %rcx
leaq 0x159f3(%rip), %rdx     # 0x25bf4
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 0x10237
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_O1/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 0x10270
movq 0x20(%r14), %rsi
callq 0x3300
xorl %ecx, %ecx
testl %eax, %eax
jne 0x10276
movl 0x100(%rbx), %ecx
movl %ecx, 0x104(%rbx)
movq $0x8, 0x2c(%r14)
movl 0x10(%r14), %r8d
cmpq %r8, 0x170(%rbx)
jbe 0x10316
movq 0x168(%rbx), %rax
leaq (%r8,%r8,4), %rcx
cmpl $0x0, 0x14(%rax,%rcx,8)
jle 0x10307
leaq (%rax,%rcx,8), %r14
xorl %r15d, %r15d
movq 0x8(%r14), %rax
movl (%rax,%r15,4), %ebp
movq %rbx, %rdi
callq 0xf5a0
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 0x11e5f
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 0x102ae
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x156ef(%rip), %rsi     # 0x25a0c
leaq 0x15721(%rip), %rcx     # 0x25a45
movq %rbx, %rdi
movl $0x7c, %edx
xorl %eax, %eax
callq 0xca73
// File: /workspace/github_c_makefile_star2_O1/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
xorl %eax, %eax
movq %rax, 0x20(%r14)
movabsq $-0xffffffff, %rcx      # imm = 0xFFFFFFFF00000001
movq %rcx, 0x28(%r14)
movl $0xffffffff, 0x30(%r14) # imm = 0xFFFFFFFF
movq %r15, 0x10(%r14)
movq %rax, (%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 0x119ee
movq 0x168(%rbx), %rax
leaq (%r8,%r8,4), %rcx
cmpl $0x0, 0x10(%rax,%rcx,8)
je 0x119e0
movq %rbx, %rdi
callq 0xf524
movq %rax, 0x58(%r14)
jmp 0x119e8
movl $0xffffffff, 0x58(%r14) # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %r15
retq
leaq 0x14017(%rip), %rsi     # 0x25a0c
leaq 0x14049(%rip), %rcx     # 0x25a45
movq %rbx, %rdi
movl $0x7c, %edx
xorl %eax, %eax
callq 0xca73
// File: /workspace/github_c_makefile_star2_O1/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 0x11eb6
movq 0x168(%rbx), %rcx
leaq (%rax,%rax,4), %rax
leaq (%rcx,%rax,8), %rsi
movl (%rsi), %ecx
cmpl $0xc, %ecx
ja 0x11ed6
movl $0x1, %eax
movl $0x193c, %edx           # imm = 0x193C
btl %ecx, %edx
jb 0x11eb4
movl $0x240, %eax            # imm = 0x240
btl %ecx, %eax
jae 0x11ea4
movl $0x2, %eax
jmp 0x11eb4
cmpl $0x7, %ecx
jne 0x11ed6
xorl %eax, %eax
cmpl $0x21, 0x8(%rsi)
setge %al
incl %eax
popq %rbx
retq
movl %esi, %r8d
leaq 0x13b4c(%rip), %rsi     # 0x25a0c
leaq 0x13b7e(%rip), %rcx     # 0x25a45
movq %rbx, %rdi
movl $0x7c, %edx
xorl %eax, %eax
callq 0xca73
movq %rbx, %rdi
callq 0x4112
leaq 0x135db(%rip), %rsi     # 0x254c0
leaq 0x13d5d(%rip), %rcx     # 0x25c49
movq %rbx, %rdi
movl $0x190, %edx            # imm = 0x190
movq %rax, %r8
xorl %eax, %eax
callq 0xca73
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %edi
movl $0x58, %esi
callq 0x32f0
leaq 0x10(%rax), %rcx
movq $0x0, 0x10(%rax)
movq %rcx, 0x18(%rax)
movl 0x40(%rbx), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x40(%rbx)
movl %ecx, 0x28(%rax)
testq %r14, %r14
je 0x11f59
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 0x11f6f
movq $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_O1/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
movl $0x38, %edi
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 0x11fee
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 0x12009
movq %rax, 0x8(%rcx)
movq %rax, (%rbx)
movq %rbx, 0x8(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
xorl %eax, %eax
movq %rax, 0x20(%r12)
movabsq $-0xffffffeb, %rcx      # imm = 0xFFFFFFFF00000015
movq %rcx, 0x28(%r12)
movl $0xffffffff, 0x30(%r12) # imm = 0xFFFFFFFF
movq %r14, 0x10(%r12)
movq %rax, (%r12)
movq 0x18(%r14), %rax
movq %rax, 0x8(%r12)
movq %r12, (%rax)
movq %r12, 0x18(%r14)
movq %r15, %rdi
callq 0xf524
movq %rax, 0x58(%r12)
movl %ebx, 0x2c(%r12)
movl 0x5c(%r12), %eax
movl %eax, 0x30(%r12)
movq %r15, %rdi
movq %r12, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x11f77
// File: /workspace/github_c_makefile_star2_O1/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 0x12335
cmpb $0x0, 0x2a(%r13)
leaq 0x13cec(%rip), %rcx     # 0x25dfc
leaq 0x13c9d(%rip), %r8      # 0x25db4
cmoveq %rcx, %r8
leaq 0x13c72(%rip), %rdi     # 0x25d94
movq %r14, %rsi
movq %r12, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3190
movq 0x48(%r13), %r15
testq %r15, %r15
je 0x12247
leaq 0x13cb7(%rip), %r12     # 0x25dfd
leaq 0x13ca8(%rip), %r13     # 0x25df5
leaq 0x13c98(%rip), %rbp     # 0x25dec
movq 0x50(%r15), %rcx
testq %rcx, %rcx
leaq 0x13c6f(%rip), %rdx     # 0x25dd1
leaq 0x13c93(%rip), %rdi     # 0x25dfc
cmoveq %rdi, %rdx
cmoveq %rdi, %rcx
leaq 0x13c5a(%rip), %r8      # 0x25dd2
cmoveq %rdi, %r8
cmpb $0x0, 0x2d(%r15)
leaq 0x13c4c(%rip), %r9      # 0x25dd4
cmoveq %rdi, %r9
cmpb $0x0, 0x2e(%r15)
movl 0x28(%r15), %esi
leaq 0x13c3f(%rip), %rax     # 0x25ddb
cmoveq %rdi, %rax
movq %rax, (%rsp)
leaq 0x13c17(%rip), %rdi     # 0x25dc2
xorl %eax, %eax
callq 0x3190
movq 0x30(%r15), %r14
testq %r14, %r14
je 0x121d2
movq 0x30(%r14), %rax
movl 0x28(%rax), %esi
movq %rbp, %rdi
xorl %eax, %eax
callq 0x3190
movq 0x10(%r14), %r14
jmp 0x121b6
movl $0xa, %edi
callq 0x3040
movq 0x10(%r15), %r14
testq %r14, %r14
je 0x12204
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x1237b
movq %r13, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x3190
movq (%r14), %r14
jmp 0x121e0
leaq 0x13bef(%rip), %rdi     # 0x25dfa
xorl %eax, %eax
callq 0x3190
movq 0x38(%r15), %r14
testq %r14, %r14
je 0x12231
movq 0x38(%r14), %rax
movl 0x28(%rax), %esi
movq %r12, %rdi
xorl %eax, %eax
callq 0x3190
movq (%r14), %r14
jmp 0x12216
movl $0xa, %edi
callq 0x3040
movq (%r15), %r15
testq %r15, %r15
jne 0x12154
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/cogbee[P]vmir-latest/src/vmir_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 0xf5a0
movq 0x180(%r14), %rcx
cltq
movq (%rcx,%rax,8), %rdi
movl $0x4, (%rdi)
movl %ebp, 0x24(%rdi)
movl $0xffffffff, 0x38(%rdi) # imm = 0xFFFFFFFF
movl %eax, 0x2c(%rbx)
movl %ebp, 0x30(%rbx)
movq %rbx, %rsi
movl $0x1, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x11fb1
// File: /workspace/github_c_makefile_star2_O1/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, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
movl $0x1, %edi
movl $0x7c, %esi
callq 0x32f0
movq %rax, %r12
xorl %eax, %eax
movq %rax, 0x20(%r12)
movabsq $-0xffffffea, %rcx      # imm = 0xFFFFFFFF00000016
movq %rcx, 0x28(%r12)
movl $0xffffffff, 0x30(%r12) # imm = 0xFFFFFFFF
movq %r15, 0x10(%r12)
movq %rax, (%r12)
movq 0x18(%r15), %rax
movq %rax, 0x8(%r12)
movq %r12, (%rax)
movq %r12, 0x18(%r15)
movl %r14d, 0x60(%r12)
movl $0x1, 0x6c(%r12)
movq %rbx, %rdi
callq 0xf524
movq %rax, 0x70(%r12)
movq %rbx, %rdi
movl %ebp, %esi
movq %r12, %rdx
callq 0x12256
movq 0x2c(%r12), %rsi
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xf999
// File: /workspace/github_c_makefile_star2_O1/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 0xd2c1
movq %r14, %rdi
movl %eax, %esi
callq 0xd275
movq %rax, %r15
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
movq %r14, %rsi
movl %ebx, %edx
callq 0xd2c1
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x123c9
movq %r15, %rdi
movl %eax, %esi
callq 0xd275
movq %rax, %r12
movq %rsp, %rdi
movq %rax, (%rdi)
movq %r15, %rsi
movq %r14, %rdx
movl %ebx, %ecx
callq 0x123c9
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/cogbee[P]vmir-latest/src/vmir.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 0x133cc
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 0x1340a
movq %rdi, %rbx
movq (%rdi), %rdi
movq %rsp, %rdx
movq %r10, %rsi
callq 0x3400
movslq %eax, %rcx
addq %rcx, (%rbx)
jmp 0x13419
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_O1/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 0x16aa1
movl (%rsi), %eax
cmpl $0x3, %eax
je 0x16a65
cmpl $0x2, %eax
jne 0x16abe
movq 0x30(%rsi), %rax
movl 0x28(%rax), %eax
jmp 0x16a8f
movq 0x168(%rbx), %rax
leaq (%r8,%r8,4), %rcx
movl (%rax,%rcx,8), %eax
cmpl $0xb, %eax
ja 0x16abe
movl $0x938, %ecx            # imm = 0x938
btl %eax, %ecx
jb 0x16a8c
movl $0x2c0, %ecx            # imm = 0x2C0
btl %eax, %ecx
jae 0x16a91
movl 0x30(%rsi), %eax
popq %rbx
retq
cmpl $0x2, %eax
jne 0x16abe
xorl %eax, %eax
cmpl $0x0, 0x30(%rsi)
setne %al
jmp 0x16a8f
leaq 0xef64(%rip), %rsi      # 0x25a0c
leaq 0xef96(%rip), %rcx      # 0x25a45
movq %rbx, %rdi
movl $0x7c, %edx
xorl %eax, %eax
callq 0xca73
movq %rbx, %rdi
callq 0x16bfb
leaq 0xe9f3(%rip), %rsi      # 0x254c0
leaq 0xf6fc(%rip), %rcx      # 0x261d0
movq %rbx, %rdi
movl $0x1d5, %edx            # imm = 0x1D5
movq %rax, %r8
xorl %eax, %eax
callq 0xca73
// File: /workspace/github_c_makefile_star2_O1/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 0x16bae
movq 0x180(%rbx), %rax
movq (%rax,%r8,8), %r13
movl (%r13), %eax
leal -0x4(%rax), %ecx
cmpl $0x2, %ecx
jb 0x16b9f
addl $-0x2, %eax
cmpl $0x1, %eax
ja 0x16bcb
movq %rdx, %r14
movq %rsi, %r15
movq 0x10(%rsi), %rbp
movl $0x1, %edi
movl $0x60, %esi
callq 0x32f0
movq %rax, %r12
movq $0x0, 0x20(%rax)
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 0x12256
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 0xe90b(%rip), %rsi      # 0x254c0
leaq 0xf0b8(%rip), %rcx      # 0x25c74
movq %rbx, %rdi
movl $0x143, %edx            # imm = 0x143
xorl %eax, %eax
callq 0xca73
movl 0x24(%r13), %esi
movq %rbx, %rdi
callq 0x12335
movl (%r13), %r9d
leaq 0xf532(%rip), %rsi      # 0x26114
leaq 0xf60e(%rip), %rcx      # 0x261f7
movq %rbx, %rdi
movl $0x35, %edx
movq %rax, %r8
xorl %eax, %eax
callq 0xca73
// File: /workspace/github_c_makefile_star2_O1/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 0xfae5
movq %r14, %rdi
movl %eax, %esi
callq 0xd275
movq %rax, %r15
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
movq %r14, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0xfae5
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/cogbee[P]vmir-latest/src/vmir_instr.c
// Function: instr_add_after
static void *
instr_add_after(size_t size, instr_class_t ic, ir_instr_t *after)
{
  ir_bb_t *ib = after->ii_bb;
  ir_instr_t *ii = instr_create(size, ic);
  ii->ii_bb = ib;
  TAILQ_INSERT_AFTER(&ib->ib_instrs,  after, ii, ii_link);
  return ii;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %rsi
movq 0x10(%rdx), %r14
movl $0x1, %edi
callq 0x32f0
movq $0x0, 0x20(%rax)
movl %ebp, 0x28(%rax)
movq $-0x1, 0x2c(%rax)
movq %r14, 0x10(%rax)
movq (%rbx), %rcx
movq %rcx, (%rax)
addq $0x18, %r14
leaq 0x8(%rcx), %rdx
testq %rcx, %rcx
cmoveq %r14, %rdx
movq %rax, (%rdx)
movq %rax, (%rbx)
movq %rbx, 0x8(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x16d0f
movl %r8d, %eax
cmpq %rax, 0x188(%rdi)
jbe 0x16d10
movq 0x180(%rdi), %rcx
movq (%rcx,%rax,8), %rdi
cmpl $0x4, (%rdi)
jne 0x16d0f
movq %rdx, %rsi
xorl %edx, %edx
jmp 0x11fb1
retq
pushq %rax
leaq 0xe7a8(%rip), %rsi      # 0x254c0
leaq 0xef55(%rip), %rcx      # 0x25c74
movl $0x143, %edx            # imm = 0x143
xorl %eax, %eax
callq 0xca73
// File: /workspace/github_c_makefile_star2_O1/cogbee[P]vmir-latest/src/vmir_transform.c
// Function: 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 0x16d4a
cmpl %edx, 0x28(%r15)
jne 0x16d3a
jmp 0x16d4d
xorl %r15d, %r15d
testl %ecx, %ecx
je 0x16d5d
cmpb $0x0, 0x2c(%r15)
jne 0x16dcd
movb $0x1, 0x2c(%r15)
movl $0x40, %edi
callq 0x3380
movq 0x58(%r14), %rcx
addq $0x58, %r14
movq %rcx, 0x20(%rax)
testq %rcx, %rcx
je 0x16d80
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 0x16d9f
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 0x16dc6
movq %rax, %rdx
addq $0x10, %rdx
movq %rdx, 0x18(%rcx)
movq %rax, (%r15)
movq %r15, 0x18(%rax)
popq %rbx
popq %r14
popq %r15
retq