LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_value.c
// Function: value_create_const32
static ir_valuetype_t
value_create_const32(ir_unit_t *iu, int v, ir_type_code_t code)
{
  int type = type_find_by_code(iu, code);
  int ret = value_append(iu);
  ir_value_t *iv = VECTOR_ITEM(&iu->iu_values, ret);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x1f410
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1eb20
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x180(%rax), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl $0x3, (%rax)
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x24(%rax)
movl -0x14(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x30(%rax)
movl -0x20(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_wasm_parser.c
// Function: wbs_get_v32
static int32_t
wbs_get_v32(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);

  if(shift < 32 && (b & 0x40))
    v |= - (1 << shift);

  return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1e210
movb %al, -0xd(%rbp)
movzbl -0xd(%rbp), %eax
andl $0x7f, %eax
movl -0x14(%rbp), %ecx
shll %cl, %eax
orl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x14(%rbp), %eax
addl $0x7, %eax
movl %eax, -0x14(%rbp)
movzbl -0xd(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0x1f18a
cmpl $0x20, -0x14(%rbp)
jae 0x1f1e7
movzbl -0xd(%rbp), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x1f1e7
movl -0x14(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, %ecx
xorl %eax, %eax
subl %ecx, %eax
orl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_value.c
// Function: value_create_const64
__attribute__((unused))
static ir_valuetype_t
value_create_const64(ir_unit_t *iu, uint64_t v, ir_type_code_t code)
{
  int type = type_find_by_code(iu, code);
  int ret = value_append(iu);
  ir_value_t *iv = VECTOR_ITEM(&iu->iu_values, ret);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x1f410
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1eb20
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq 0x180(%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl $0x3, (%rax)
movl -0x20(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x24(%rax)
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x30(%rax)
movl -0x24(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_wasm_parser.c
// Function: wbs_get_v64
static int64_t
wbs_get_v64(wasm_bytestream_t *wbs)
{
  uint64_t v = 0;
  uint8_t b;
  unsigned int shift = 0;
  do {
    b = wbs_get_byte(wbs);
    v |= (int64_t)(0x7f & b) << shift;
    shift += 7;
  } while(b & 0x80);

  if(shift < 64 && (b & 0x40)) {
    v |= - (1LL << shift);
  }
  return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1e210
movb %al, -0x11(%rbp)
movzbl -0x11(%rbp), %eax
andl $0x7f, %eax
cltq
movl -0x18(%rbp), %ecx
shlq %cl, %rax
orq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x18(%rbp), %eax
addl $0x7, %eax
movl %eax, -0x18(%rbp)
movzbl -0x11(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0x1f28b
cmpl $0x40, -0x18(%rbp)
jae 0x1f2f4
movzbl -0x11(%rbp), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x1f2f4
movl -0x18(%rbp), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, %rcx
xorl %eax, %eax
subq %rcx, %rax
orq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_wasm_parser.c
// Function: wbs_get_u64
static uint64_t
wbs_get_u64(wasm_bytestream_t *wbs)
{
  if(wbs->ptr + 8 > wbs->end)
    return 0;

  uint64_t r;
  memcpy(&r, wbs->ptr, 8);
  wbs->ptr += 8;
  return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
addq $0x8, %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0x1f327
movq $0x0, -0x8(%rbp)
jmp 0x1f34b
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x8, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movslq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x170(%rcx), %rax
jae 0x1f46a
movq -0x8(%rbp), %rax
movq 0x168(%rax), %rax
movslq -0x10(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x1f45d
movl -0x10(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
jmp 0x1f45f
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1f426
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %r8d
leaq 0x1f837(%rip), %rsi     # 0x3ecb0
movl $0x14f, %edx            # imm = 0x14F
leaq 0x1f92d(%rip), %rcx     # 0x3edb2
movb $0x0, %al
callq 0x18220
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x188(%rcx), %rax
jb 0x1f4e0
leaq -0x60(%rbp), %rdi
movl -0x1c(%rbp), %ecx
movl $0x40, %esi
leaq 0x1f91e(%rip), %rdx     # 0x3ede5
movb $0x0, %al
callq 0x3180
movq -0x10(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x18e90
movl %eax, -0x4(%rbp)
jmp 0x1f50f
movq -0x18(%rbp), %rax
movq 0x180(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x68(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x1f520
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdx, -0xc(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movslq -0xc(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq 0x188(%rcx), %rax
jb 0x1fc87
leaq -0x60(%rbp), %rdi
movl -0xc(%rbp), %ecx
movl $0x40, %esi
leaq 0x1f17a(%rip), %rdx     # 0x3ede5
movb $0x0, %al
callq 0x3180
movq -0x18(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x18e90
movl %eax, -0x4(%rbp)
jmp 0x1fd1f
movslq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq 0x170(%rcx), %rax
jb 0x1fcca
leaq -0xa0(%rbp), %rdi
movl -0x8(%rbp), %ecx
movl $0x40, %esi
leaq 0x1f1ef(%rip), %rdx     # 0x3ee9d
movb $0x0, %al
callq 0x3180
movq -0x18(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x18e90
movl %eax, -0x4(%rbp)
jmp 0x1fd1f
movq -0x20(%rbp), %rax
movq 0x180(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0xa8(%rbp)
movq -0x20(%rbp), %rax
movq 0x168(%rax), %rax
movslq -0x8(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0xb0(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0xa8(%rbp), %rdx
movq -0xb0(%rbp), %rcx
callq 0x1f520
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x108(%rax)
je 0x1fdcb
movq -0x8(%rbp), %rax
movq 0x108(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x32d0
cmpl $0x0, %eax
je 0x1fdcb
movq -0x8(%rbp), %rax
movl $0x0, 0x104(%rax)
jmp 0x1fddf
movq -0x8(%rbp), %rax
movl 0x100(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x104(%rax)
movq -0x10(%rbp), %rax
movl $0x8, 0x2c(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x30(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %esi
callq 0x1ee20
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x14(%rcx), %eax
jge 0x1fe3f
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %esi
callq 0x20950
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1fe10
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x68, %esi
movl $0x1, %edx
callq 0x20c10
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x1c0(%rax), %rax
movl 0x10(%rax), %esi
callq 0x1ee20
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x20889
movq -0x18(%rbp), %rax
movl $0xffffffff, 0x58(%rax) # imm = 0xFFFFFFFF
jmp 0x208ad
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1ea10
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq %rcx, 0x58(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_vm.c
// Function: function_process
static void
function_process(ir_unit_t *iu, ir_function_t *f)
{
  //  assert(iu->iu_next_value == VECTOR_LEN(&iu->iu_values));
  if(iu->iu_debug_flags_func & VMIR_DBG_DUMP_PARSED_FUNCTION)
    function_print(iu, iu->iu_current_function, "parsed");

  transform_function(iu, f);

  if(iu->iu_debug_flags_func & VMIR_DBG_DUMP_LOWERED_FUNCTION)
    function_print(iu, iu->iu_current_function, "lowered");

  vm_emit_function(iu, f);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x104(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x208fd
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x1c0(%rax), %rsi
leaq 0x1eae6(%rip), %rdx     # 0x3f3de
callq 0x22140
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x240b0
movq -0x8(%rbp), %rax
movl 0x104(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x20937
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x1c0(%rax), %rsi
leaq 0x1eab3(%rip), %rdx     # 0x3f3e5
callq 0x22140
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x24170
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_value.c
// Function: value_alloc_function_arg
static void
value_alloc_function_arg(ir_unit_t *iu, int type)
{
  int val = value_append(iu);
  ir_value_t *iv = VECTOR_ITEM(&iu->iu_values, val);
  iv->iv_class = IR_VC_REGFRAME;
  iv->iv_type = type;

  ir_function_t *f = iu->iu_current_function;
  int size = value_regframe_size(iu, type);
  f->if_callarg_size -= size;
  iv->iv_reg = f->if_callarg_size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1eb20
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x180(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x5, (%rax)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x24(%rax)
movq -0x8(%rbp), %rax
movq 0x1c0(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x209e0
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %edx
movq -0x20(%rbp), %rax
movl 0x30(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x30(%rax)
movq -0x20(%rbp), %rax
movl 0x30(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x30(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x1ee20
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
addl $-0x2, %eax
subl $0x4, %eax
jb 0x20a77
jmp 0x20a42
movl -0x24(%rbp), %eax
subl $0x6, %eax
je 0x20a80
jmp 0x20a4c
movl -0x24(%rbp), %eax
subl $0x7, %eax
je 0x20a89
jmp 0x20a56
movl -0x24(%rbp), %eax
subl $0x8, %eax
je 0x20a77
jmp 0x20a60
movl -0x24(%rbp), %eax
subl $0x9, %eax
je 0x20a80
jmp 0x20a6a
movl -0x24(%rbp), %eax
addl $-0xb, %eax
subl $0x1, %eax
ja 0x20aa5
jmp 0x20a77
movl $0x1, -0x4(%rbp)
jmp 0x20adb
movl $0x2, -0x4(%rbp)
jmp 0x20adb
movq -0x20(%rbp), %rax
cmpl $0x20, 0x8(%rax)
jg 0x20a9c
movl $0x1, -0x4(%rbp)
jmp 0x20adb
movl $0x2, -0x4(%rbp)
jmp 0x20adb
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4760
movq -0x30(%rbp), %rdi
movq %rax, %r8
leaq 0x1dc9c(%rip), %rsi     # 0x3e764
movl $0x190, %edx            # imm = 0x190
leaq 0x1e41e(%rip), %rcx     # 0x3eef2
movb $0x0, %al
callq 0x18220
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x20bb0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x20b60
jmp 0x20b16
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
je 0x20b3b
movq -0x18(%rbp), %rcx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
jmp 0x20b47
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x20b9a
jmp 0x20b62
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x50(%rax)
jmp 0x20b9a
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_function.c
// Function: bb_make
static ir_bb_t *
bb_make(ir_function_t *f)
{
  ir_bb_t *ib = calloc(1, sizeof(ir_bb_t));
  TAILQ_INIT(&ib->ib_instrs);
  ib->ib_id = f->if_num_bbs++;
  return ib;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, %edi
movl $0x58, %esi
callq 0x32c0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rcx
addq $0x10, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movl 0x40(%rax), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x40(%rax)
movq -0x10(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_instr.c
// Function: instr_add
static void *
instr_add(ir_bb_t *ib, size_t size, instr_class_t ic)
{
  ir_instr_t *ii = instr_create(size, ic);
  ii->ii_bb = ib;
  TAILQ_INSERT_TAIL(&ib->ib_instrs, ii, ii_link);
  return ii;
}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1eb20
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x180(%rax), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0x4, (%rax)
movq -0x20(%rbp), %rax
movl $0xffffffff, 0x38(%rax) # imm = 0xFFFFFFFF
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x24(%rax)
movl -0x18(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_value.c
// Function: value_create_zero
static ir_valuetype_t
value_create_zero(ir_unit_t *iu, int type)
{
  int ret = value_append(iu);
  ir_value_t *iv = VECTOR_ITEM(&iu->iu_values, ret);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1eb20
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x180(%rax), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0x3, (%rax)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x24(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x30(%rax)
movl -0x18(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_instr.c
// Function: instr_create
static void *
instr_create(size_t size, instr_class_t ic)
{
  ir_instr_t *ii = calloc(1, size);
  LIST_INIT(&ii->ii_values);
  ii->ii_class = ic;
  ii->ii_ret.value = -1;
  ii->ii_ret.type = -1;
  return ii;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rsi
movl $0x1, %edi
callq 0x32c0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, 0x20(%rax)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x18(%rbp), %rax
movl $0xffffffff, 0x2c(%rax) # imm = 0xFFFFFFFF
movq -0x18(%rbp), %rax
movl $0xffffffff, 0x30(%rax) # imm = 0xFFFFFFFF
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x38, %edi
callq 0x3360
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x20(%rbp), %rcx
movq %rax, 0x10(%rcx)
cmpq $0x0, %rax
je 0x20e6d
movq -0x20(%rbp), %rcx
addq $0x10, %rcx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rcx
addq $0x20, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0x20e8b
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
je 0x20eb0
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rcx
addq $0x8, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl $0x60, %esi
movl $0x15, %edx
callq 0x20c10
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1ea10
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq %rcx, 0x58(%rax)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x2c(%rax)
movq -0x20(%rbp), %rax
movl 0x5c(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x20cf0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_wasm_parser.c
// Function: wasm_branch
static ir_bb_t *
wasm_branch(ir_unit_t *iu, ir_bb_t *ib, int code, int relative_depth,
            const label_stack_frame_t *lsf)
{
  ir_bb_t *next = bb_add_named(iu->iu_current_function, ib, "Branch split");

  ir_instr_br_t *i = instr_add(ib, sizeof(ir_instr_br_t), IR_IC_BR);

  i->true_branch = bb_from_relative_depth(lsf, relative_depth);

  switch(code) {
  case 0xc:
    i->condition.value = -1;
    break;
  case 0xd:
    i->false_branch = next->ib_id;
    i->condition = vstack_pop(iu);
    break;
  }
  return next;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x1c0(%rax), %rdi
movq -0x10(%rbp), %rsi
leaq 0x1df3f(%rip), %rdx     # 0x3ef9f
callq 0x1fe50
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl $0x68, %esi
movl $0x8, %edx
callq 0x20c10
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x22390
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x60(%rax)
movl -0x14(%rbp), %eax
movl %eax, -0x3c(%rbp)
subl $0xc, %eax
je 0x210ac
jmp 0x210a2
movl -0x3c(%rbp), %eax
subl $0xd, %eax
je 0x210b9
jmp 0x210eb
movq -0x30(%rbp), %rax
movl $0xffffffff, 0x58(%rax) # imm = 0xFFFFFFFF
jmp 0x210eb
movq -0x28(%rbp), %rax
movl 0x28(%rax), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x64(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1ea10
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, -0x38(%rbp)
movq -0x38(%rbp), %rcx
movq %rcx, 0x58(%rax)
movq -0x28(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_wasm_parser.c
// Function: wasm_branch_table
static ir_bb_t *
wasm_branch_table(ir_unit_t *iu, ir_bb_t *ib, wasm_bytestream_t *wbs,
                  const label_stack_frame_t *lsf)
{
  ir_bb_t *next = bb_add_named(iu->iu_current_function, ib, "Branch-table split");

  const int paths = wbs_get_vu32(wbs);

  ir_instr_switch_t *i = instr_add(ib, sizeof(ir_instr_switch_t) +
                                   sizeof(ir_instr_path_t) * paths, IR_IC_SWITCH);
  i->value = vstack_pop(iu);
  i->num_paths = paths;

  for(int n = 0; n < paths; n++) {
    i->paths[n].v64 = n;
    i->paths[n].block = bb_from_relative_depth(lsf, wbs_get_vu32(wbs));
  }
  i->defblock = bb_from_relative_depth(lsf, wbs_get_vu32(wbs));
  return next;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x1c0(%rax), %rdi
movq -0x10(%rbp), %rsi
leaq 0x1de7e(%rip), %rdx     # 0x3efac
callq 0x1fe50
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1d450
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
shlq $0x4, %rsi
addq $0x68, %rsi
movl $0xc, %edx
callq 0x20c10
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1ea10
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, -0x40(%rbp)
movq -0x40(%rbp), %rcx
movq %rcx, 0x58(%rax)
movl -0x2c(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x64(%rax)
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x211f7
movslq -0x44(%rbp), %rcx
movq -0x38(%rbp), %rax
addq $0x68, %rax
movslq -0x44(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1d450
movq -0x58(%rbp), %rdi
movl %eax, %esi
callq 0x22390
movl %eax, %ecx
movq -0x38(%rbp), %rax
addq $0x68, %rax
movslq -0x44(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, 0x8(%rax)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x21196
movq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1d450
movq -0x60(%rbp), %rdi
movl %eax, %esi
callq 0x22390
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x60(%rax)
movq -0x28(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_wasm_parser.c
// Function: wasm_select
static void
wasm_select(ir_unit_t *iu, ir_bb_t *ib)
{
  ir_instr_select_t *i = instr_add(ib, sizeof(ir_instr_select_t), IR_IC_SELECT);

  i->pred        = vstack_pop(iu);
  i->false_value = vstack_pop(iu);
  i->true_value  = vstack_pop(iu);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x70, %esi
movl $0xe, %edx
callq 0x20c10
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1ea10
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, 0x68(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1ea10
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq %rcx, 0x60(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1ea10
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq %rcx, 0x58(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x5c(%rax), %esi
movq -0x18(%rbp), %rdx
callq 0x22410
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x2c(%rax), %rsi
callq 0x1f360
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_wasm_parser.c
// Function: wasm_load_global
static void
wasm_load_global(ir_unit_t *iu, ir_bb_t *ib, const ir_valuetype_t global_var)
{
  const int pointee_type = value_get(iu, global_var.value)->iv_gvar->ig_type;
  ir_instr_load_t *i = instr_add(ib, sizeof(ir_instr_load_t), IR_IC_LOAD);
  i->ptr = global_var;
  i->immediate_offset = 0;
  i->value_offset.value = -1;
  i->cast = -1;
  i->load_type = pointee_type;
  value_alloc_instr_ret(iu, pointee_type, &i->super);
  vstack_push(iu, i->super.ii_ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl -0x8(%rbp), %esi
callq 0x20ee0
movq 0x30(%rax), %rax
movl 0x10(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
movl $0x78, %esi
movl $0x4, %edx
callq 0x20c10
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x8(%rbp), %rcx
movq %rcx, 0x58(%rax)
movq -0x28(%rbp), %rax
movl $0x0, 0x60(%rax)
movq -0x28(%rbp), %rax
movl $0xffffffff, 0x64(%rax) # imm = 0xFFFFFFFF
movq -0x28(%rbp), %rax
movb $-0x1, 0x74(%rax)
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x70(%rax)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x28(%rbp), %rdx
callq 0x22410
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x2c(%rax), %rsi
callq 0x1f360
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_wasm_parser.c
// Function: wasm_store_global
static void
wasm_store_global(ir_unit_t *iu, ir_bb_t *ib, const ir_valuetype_t global_var)
{
  ir_instr_store_t *st = instr_add(ib, sizeof(ir_instr_store_t), IR_IC_STORE);
  st->value = vstack_pop(iu);
  st->ptr = global_var;
  st->immediate_offset = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl $0x70, %esi
movl $0x5, %edx
callq 0x20c10
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1ea10
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq %rcx, 0x60(%rax)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movq %rcx, 0x58(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x68(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_wasm_parser.c
// Function: wasm_store
static void
wasm_store(ir_unit_t *iu, ir_bb_t *ib, int code, wasm_bytestream_t *wbs)
{
  int type;
  switch(code) {
  case 0x36: type = WASM_TYPE_I32; break;
  case 0x37: type = WASM_TYPE_I64; break;
  case 0x38: type = WASM_TYPE_F32; break;
  case 0x39: type = WASM_TYPE_F64; break;
  case 0x3a: type = WASM_TYPE_I8;  break;
  case 0x3b: type = WASM_TYPE_I16; break;
  case 0x3c: type = WASM_TYPE_I8;  break;
  case 0x3d: type = WASM_TYPE_I16; break;
  case 0x3e: type = WASM_TYPE_I32; break;
  default:
    parser_error(iu, "Can't handle store 0x%x", code);
  }

  /* int flags =*/ wbs_get_vu32(wbs);
  int offset = wbs_get_vu32(wbs);

  ir_instr_store_t *i = instr_add(ib, sizeof(ir_instr_store_t), IR_IC_STORE);
  i->value = vstack_pop(iu);
  i->ptr = vstack_pop(iu);
  i->value.type = type;
  i->immediate_offset = offset;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl -0x14(%rbp), %eax
addl $-0x36, %eax
movl %eax, %ecx
movq %rcx, -0x48(%rbp)
subl $0x8, %eax
ja 0x2189d
movq -0x48(%rbp), %rax
leaq 0x1ba01(%rip), %rcx     # 0x3d244
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, -0x24(%rbp)
jmp 0x218bf
movl $0x2, -0x24(%rbp)
jmp 0x218bf
movl $0x3, -0x24(%rbp)
jmp 0x218bf
movl $0x4, -0x24(%rbp)
jmp 0x218bf
movl $0x5, -0x24(%rbp)
jmp 0x218bf
movl $0x6, -0x24(%rbp)
jmp 0x218bf
movl $0x5, -0x24(%rbp)
jmp 0x218bf
movl $0x6, -0x24(%rbp)
jmp 0x218bf
movl $0x1, -0x24(%rbp)
jmp 0x218bf
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %r8d
leaq 0x1cf30(%rip), %rsi     # 0x3e7dc
movl $0x335, %edx            # imm = 0x335
leaq 0x1d71e(%rip), %rcx     # 0x3efd6
movb $0x0, %al
callq 0x18220
movq -0x20(%rbp), %rdi
callq 0x1d450
movq -0x20(%rbp), %rdi
callq 0x1d450
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl $0x70, %esi
movl $0x5, %edx
callq 0x20c10
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1ea10
movq %rax, %rcx
movq -0x58(%rbp), %rax
movq %rcx, -0x38(%rbp)
movq -0x38(%rbp), %rcx
movq %rcx, 0x60(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1ea10
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, -0x40(%rbp)
movq -0x40(%rbp), %rcx
movq %rcx, 0x58(%rax)
movl -0x24(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x64(%rax)
movl -0x28(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x68(%rax)
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1eb20
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x180(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl $0x4, (%rax)
movl -0xc(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x24(%rax)
movq -0x28(%rbp), %rax
movl $0xffffffff, 0x38(%rax) # imm = 0xFFFFFFFF
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x2c(%rax)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x1, %edx
callq 0x20e00
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rax
imulq $0xc, %rax, %rsi
addq $0x70, %rsi
movl $0x16, %edx
callq 0x20c10
movq %rax, -0x28(%rbp)
movl -0x18(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x60(%rax)
movl -0x14(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x6c(%rax)
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jl 0x22538
movq -0x28(%rbp), %rax
addq $0x70, %rax
movslq -0x2c(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1ea10
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x34(%rbp)
movq -0x34(%rbp), %rcx
movq %rcx, (%rax)
movl -0x2c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x224f5
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x28(%rbp), %rdx
callq 0x22410
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x2c(%rax), %rsi
callq 0x1f360
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rsi
movl -0xc(%rbp), %edx
xorl %eax, %eax
movl %eax, %edi
callq 0x18ef0
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x18e00
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rsi
movl -0xc(%rbp), %edx
leaq -0x18(%rbp), %rdi
callq 0x18ef0
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
xorl %eax, %eax
movl %eax, %edi
callq 0x22620
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x18e00
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
leaq -0x20(%rbp), %rdi
callq 0x22620
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x23f98
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
cmpq $0x0, -0x8(%rbp)
jne 0x24007
movq -0x10(%rbp), %rdx
leaq -0x30(%rbp), %rcx
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0x3100
movl %eax, -0x14(%rbp)
jmp 0x24031
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x33d0
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edx
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, (%rax)
movl -0x14(%rbp), %eax
addq $0xe0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_value.c
// Function: value_function
static ir_function_t *__attribute__((unused))
value_function(ir_unit_t *iu, int id)
{
  if(id >= VECTOR_LEN(&iu->iu_values))
    return NULL;
  const ir_value_t *iv = VECTOR_ITEM(&iu->iu_values, id);
  if(iv->iv_class != IR_VC_FUNCTION)
    return NULL;
  return iv->iv_func;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movslq -0x14(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x188(%rcx), %rax
jb 0x24066
movq $0x0, -0x8(%rbp)
jmp 0x2409c
movq -0x10(%rbp), %rax
movq 0x180(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x1, (%rax)
je 0x24090
movq $0x0, -0x8(%rbp)
jmp 0x2409c
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_transform.c
// Function: transform_function
static void
transform_function(ir_unit_t *iu, ir_function_t *f)
{
  replace_instructions(iu, f);

  function_bind_instr_inputs(iu, f);

  construct_cfg(f);

  break_crtitical_edges(f);

  combine_instructions(iu, f);

  exit_ssa(iu, f);

  int call_arg_base = iu->iu_next_value;
  int num_call_args = prepare_calls(iu, f);

  legalize_temporary_values(iu, f);

  legalize_instructions(iu, f);

  eliminate_dead_code(iu, f);

  liveness_analysis(iu, f);

  finalize_call_args(iu, f, call_arg_base, num_call_args);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x24590
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x246e0
movq -0x10(%rbp), %rdi
callq 0x24aa0
movq -0x10(%rbp), %rdi
callq 0x24c40
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x24cf0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x24dd0
movq -0x8(%rbp), %rax
movl 0x198(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x24e20
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x24ee0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x25060
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x250f0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x25380
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
callq 0x25480
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_transform.c
// Function: replace_instructions
static void
replace_instructions(ir_unit_t *iu, ir_function_t *f)
{
  ir_bb_t *bb;
  TAILQ_FOREACH(bb, &f->if_bbs, ib_link) {
    ir_instr_t *ii;
    TAILQ_FOREACH(ii, &bb->ib_instrs, ii_link) {
      if(ii->ii_class == IR_IC_GEP)
        ii = replace_gep_with_lea(iu, (ir_instr_gep_t *)ii);
      if(ii->ii_class == IR_IC_STORE) {
        merge_lea_into_store(iu, (ir_instr_store_t *)ii);
        ii = split_const_store_aggregate(iu, (ir_instr_store_t *)ii);
      }
      if(ii->ii_class == IR_IC_LOAD)
        merge_lea_into_load(iu, (ir_instr_load_t *)ii);
      if(ii->ii_class == IR_IC_PHI)
        ii = replace_single_path_phi(iu, (ir_instr_phi_t *)ii);
      if(ii->ii_class == IR_IC_CALL || ii->ii_class == IR_IC_INVOKE)
        ii = replace_call(iu, (ir_instr_call_t *)ii, f);
      if(ii->ii_class == IR_IC_BINOP)
        binop_prep_args(iu, (ir_instr_binary_t *)ii);
      if(ii->ii_class == IR_IC_CMP2)
        registerify_cmp(iu, (ir_instr_binary_t *)ii);
      if(ii->ii_class == IR_IC_CAST)
        binop_transform_cast(iu, (ir_instr_unary_t *)ii);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x246d5
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x246c3
movq -0x20(%rbp), %rax
cmpl $0x6, 0x28(%rax)
jne 0x245e9
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x25510
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x5, 0x28(%rax)
jne 0x24611
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x258d0
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x259a0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x4, 0x28(%rax)
jne 0x24628
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x25ba0
movq -0x20(%rbp), %rax
cmpl $0x9, 0x28(%rax)
jne 0x24643
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x25cd0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0xa, 0x28(%rax)
je 0x24657
movq -0x20(%rbp), %rax
cmpl $0xb, 0x28(%rax)
jne 0x2466c
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x25d60
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x2, 0x28(%rax)
jne 0x24683
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x25fb0
movq -0x20(%rbp), %rax
cmpl $0x7, 0x28(%rax)
jne 0x2469a
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x26060
movq -0x20(%rbp), %rax
cmpl $0x3, 0x28(%rax)
jne 0x246b1
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x260d0
jmp 0x246b3
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x245c3
jmp 0x246c5
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x245ac
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_transform.c
// Function: break_crtitical_edges
static void
break_crtitical_edges(ir_function_t *f)
{
  ir_bb_edge_t *ibe;
  LIST_FOREACH(ibe, &f->if_edges, ibe_function_link) {
    // If first instruction in destination block is not a phi
    if(TAILQ_FIRST(&ibe->ibe_to->ib_instrs)->ii_class != IR_IC_PHI)
      continue;

    ir_bb_t *from = ibe->ibe_from;
    int count = 0;
    ir_bb_edge_t *c;
    LIST_FOREACH(c, &from->ib_outgoing_edges, ibe_from_link) {
      count++;
      if(count >= 2)
        break;
    }
    if(count < 2)
      continue;

    break_critical_edge(f, ibe);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x24ce3
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x10(%rax), %rax
cmpl $0x9, 0x28(%rax)
je 0x24c77
jmp 0x24cd2
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x24cbd
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x2, -0x1c(%rbp)
jl 0x24cae
jmp 0x24cbd
jmp 0x24cb0
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x24c96
cmpl $0x2, -0x1c(%rbp)
jge 0x24cc5
jmp 0x24cd2
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x26a50
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x24c58
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)