LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1ca1f
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
jmp 0x1ca2f
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
addq $0x30, %rdi
callq 0x1caa0
movq -0x8(%rbp), %rdi
addq $0x38, %rdi
callq 0x1caa0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x1ca78
movq -0x18(%rbp), %rdi
callq 0x1cad0
jmp 0x1ca5b
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rdi
callq 0x3030
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_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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1cc20
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1cb2b
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
jmp 0x1cb3f
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
callq 0x3030
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1cb89
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
jmp 0x1cb9d
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1cbbc
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, (%rax)
jmp 0x1cbd1
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x1cbf0
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
callq 0x3030
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movslq -0xc(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x188(%rcx), %rax
ja 0x1ccf2
jmp 0x1cd11
leaq 0x21a45(%rip), %rdi     # 0x3e73e
leaq 0x21a64(%rip), %rsi     # 0x3e764
movl $0xe5, %edx
leaq 0x21a69(%rip), %rcx     # 0x3e775
callq 0x31c0
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movslq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x188(%rcx), %rax
jae 0x1cd7c
movq -0x8(%rbp), %rax
movq 0x180(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1cd48
jmp 0x1cd71
movq -0x8(%rbp), %rax
movq 0x180(%rax), %rax
movslq -0x10(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x18(%rbp), %rdi
callq 0x1cdf0
movq -0x18(%rbp), %rdi
callq 0x3030
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1cd17
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x198(%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_clear
static void
value_clear(ir_value_t *iv)
{
  free(iv->iv_name);
  iv->iv_name = NULL;

  free(iv->iv_data);
  iv->iv_data = NULL;

  ir_value_instr_t *ivi;
  while((ivi = LIST_FIRST(&iv->iv_instructions)) != NULL)
    ivi_destroy(ivi);

  switch(iv->iv_class) {
  case IR_VC_GLOBALVAR:
    free(iv->iv_gvar->ig_name);
    free(iv->iv_gvar);
    break;
  default:
    break;
  }
  iv->iv_class = IR_VC_UNDEF;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x1ce4b
movq -0x10(%rbp), %rdi
callq 0x1cc50
jmp 0x1ce2e
movq -0x8(%rbp), %rax
movl (%rax), %eax
subl $0x2, %eax
jne 0x1ce78
jmp 0x1ce58
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x20(%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x3030
jmp 0x1ce7a
jmp 0x1ce7a
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x1cefb
jmp 0x1ceaf
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1cece
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
jmp 0x1cede
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x3030
jmp 0x1ce9c
addq $0x10, %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: wbs_get_u32
static uint32_t
wbs_get_u32(wasm_bytestream_t *wbs)
{
  if(wbs->ptr + 4 > wbs->end)
    return 0;

  uint32_t r;
  memcpy(&r, wbs->ptr, 4);
  wbs->ptr += 4;
  return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
addq $0x4, %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0x1cf36
movl $0x0, -0x4(%rbp)
jmp 0x1cf56
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x4, %rcx
movq %rcx, (%rax)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
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_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:
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 0x1d46a
movl -0xc(%rbp), %eax
addq $0x20, %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_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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1d450
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq -0x10(%rbp), %rdx
movq (%rdx), %rdx
subq %rdx, %rcx
cmpq %rcx, %rax
jle 0x1d504
movq -0x8(%rbp), %rdi
leaq 0x212eb(%rip), %rsi     # 0x3e7dc
movl $0xa7, %edx
leaq 0x212f6(%rip), %rcx     # 0x3e7f3
movb $0x0, %al
callq 0x18220
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x3360
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movl -0x14(%rbp), %eax
movl %eax, %edx
callq 0x3330
movl -0x14(%rbp), %edx
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movl %edx, %edx
addq %rdx, %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movb $0x0, (%rax,%rcx)
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_wasm_parser.c
// Function: wasm_parse_section_import_decl
static void
wasm_parse_section_import_decl(ir_unit_t *iu, wasm_bytestream_t *wbs)
{
  uint32_t count = wbs_get_vu32(wbs);
  for(uint32_t i = 0; i < count; i++) {
    char *module = wbs_get_string(iu, wbs);
    char *field  = wbs_get_string(iu, wbs);
    int kind = wbs_get_byte(wbs);
    switch(kind) {
    case 0:
      import_function(iu, module, field, wbs_get_vu32(wbs));
      break;
    case 1:
      import_table(iu, module, field, wbs);
      break;
    case 2:
      import_memory(iu, module, field, wbs);
      break;
    case 3:
      import_global(iu, module, field, wbs);
      break;
    default:
      parser_error(iu, "Import section can't handle kind %d for %s::%s",
                   kind, module, field);
    }
    free(module);
    free(field);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1d450
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x1d92e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1d4b0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1d4b0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1e210
movzbl %al, %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq %rax, -0x38(%rbp)
subq $0x3, %rax
ja 0x1d8e0
movq -0x38(%rbp), %rax
leaq 0x1f5d4(%rip), %rcx     # 0x3ce30
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1d450
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movl %eax, %ecx
callq 0x1e300
jmp 0x1d90e
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x10(%rbp), %rcx
callq 0x1e470
jmp 0x1d90e
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x10(%rbp), %rcx
callq 0x1e540
jmp 0x1d90e
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x10(%rbp), %rcx
callq 0x1e5d0
jmp 0x1d90e
movq -0x8(%rbp), %rdi
movl -0x2c(%rbp), %r8d
movq -0x20(%rbp), %r9
movq -0x28(%rbp), %rax
leaq 0x20ee5(%rip), %rsi     # 0x3e7dc
movl $0x152, %edx            # imm = 0x152
leaq 0x20f6d(%rip), %rcx     # 0x3e870
movq %rax, (%rsp)
movb $0x0, %al
callq 0x18220
movq -0x20(%rbp), %rdi
callq 0x3030
movq -0x28(%rbp), %rdi
callq 0x3030
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1d803
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_parse_section_functions
static void
wasm_parse_section_functions(ir_unit_t *iu, wasm_bytestream_t *wbs)
{
  uint32_t count = wbs_get_vu32(wbs);
  for(uint32_t i = 0; i < count; i++) {
    uint32_t type_index = wbs_get_vu32(wbs);
    uint32_t vmir_type = VECTOR_ITEM(&iu->iu_wasm_type_map, type_index);

    ir_function_t *f = calloc(1, sizeof(ir_function_t));

    TAILQ_INIT(&f->if_bbs);
    f->if_type = vmir_type;
    f->if_gfid = VECTOR_LEN(&iu->iu_functions);
    TAILQ_INSERT_TAIL(&iu->iu_functions_with_bodies, f, if_body_link);
    VECTOR_PUSH_BACK(&iu->iu_functions, f);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1d450
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x1dac6
movq -0x10(%rbp), %rdi
callq 0x1d450
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x580(%rax), %rax
movl -0x1c(%rbp), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0x20(%rbp)
movl $0x1, %edi
movl $0x90, %esi
callq 0x32c0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq $0x0, 0x48(%rax)
movq -0x28(%rbp), %rcx
addq $0x48, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x50(%rax)
movl -0x20(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x2e0(%rax), %rax
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x34(%rax)
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq 0x1b0(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x1b0(%rax), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x1b0(%rax)
jmp 0x1da1d
movq -0x8(%rbp), %rax
movq 0x2e0(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq -0x8(%rbp), %rcx
cmpq 0x2e8(%rcx), %rax
jbe 0x1da8c
movq -0x30(%rbp), %rcx
addq $0x1, %rcx
shlq %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x2e8(%rax)
movq -0x8(%rbp), %rax
movq 0x2e8(%rax), %rax
shlq $0x3, %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x2d8(%rax), %rdi
movq -0x38(%rbp), %rsi
callq 0x3390
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x2d8(%rax)
movq -0x30(%rbp), %rcx
addq $0x1, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x2e0(%rax)
movq -0x28(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x2d8(%rax), %rax
movq -0x30(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x1dab8
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1d963
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_wasm_parser.c
// Function: wasm_parse_section_table
static void
wasm_parse_section_table(ir_unit_t *iu, wasm_bytestream_t *wbs)
{
  uint32_t count = wbs_get_vu32(wbs);
  for(uint32_t i = 0; i < count; i++) {

    const uint8_t elem_type = wbs_get_byte(wbs);
    if(elem_type != 0x70)
      parser_error(iu, "Declared table is not of type 'anyfunc'");

    const uint32_t flags = wbs_get_vu32(wbs);
    if(flags)
      parser_error(iu, "Resizable table not supported");

    const uint32_t initial = wbs_get_vu32(wbs);
    printf("Declared table size:%u\n", initial);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1d450
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x1db8d
movq -0x10(%rbp), %rdi
callq 0x1e210
movb %al, -0x19(%rbp)
movzbl -0x19(%rbp), %eax
cmpl $0x70, %eax
je 0x1db32
movq -0x8(%rbp), %rdi
leaq 0x20cbd(%rip), %rsi     # 0x3e7dc
movl $0x165, %edx            # imm = 0x165
leaq 0x210c3(%rip), %rcx     # 0x3ebee
movb $0x0, %al
callq 0x18220
movq -0x10(%rbp), %rdi
callq 0x1d450
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0x1db62
movq -0x8(%rbp), %rdi
leaq 0x20c8d(%rip), %rsi     # 0x3e7dc
movl $0x169, %edx            # imm = 0x169
leaq 0x210bb(%rip), %rcx     # 0x3ec16
movb $0x0, %al
callq 0x18220
movq -0x10(%rbp), %rdi
callq 0x1d450
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %esi
leaq 0x210bc(%rip), %rdi     # 0x3ec34
movb $0x0, %al
callq 0x3170
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1daf3
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_parse_section_memory
static void
wasm_parse_section_memory(ir_unit_t *iu, wasm_bytestream_t *wbs)
{
  uint32_t count = wbs_get_vu32(wbs);
  for(uint32_t i = 0; i < count; i++) {
    const uint32_t flags = wbs_get_vu32(wbs);
    if(flags)
      parser_error(iu, "Resizable memory not supported");

    const uint32_t initial = wbs_get_vu32(wbs);
    printf("Declared memory size:%u\n", initial);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1d450
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x1dc23
movq -0x10(%rbp), %rdi
callq 0x1d450
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x1dbfb
movq -0x8(%rbp), %rdi
leaq 0x20bf4(%rip), %rsi     # 0x3e7dc
movl $0x17b, %edx            # imm = 0x17B
leaq 0x21058(%rip), %rcx     # 0x3ec4c
movb $0x0, %al
callq 0x18220
movq -0x10(%rbp), %rdi
callq 0x1d450
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %esi
leaq 0x2105a(%rip), %rdi     # 0x3ec6b
movb $0x0, %al
callq 0x3170
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1dbc3
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_wasm_parser.c
// Function: wasm_parse_section_exports
static void
wasm_parse_section_exports(ir_unit_t *iu, wasm_bytestream_t *wbs)
{
  uint32_t count = wbs_get_vu32(wbs);
  for(uint32_t i = 0; i < count; i++) {
    char *field  = wbs_get_string(iu, wbs);
    int kind = wbs_get_byte(wbs);
    unsigned int index = wbs_get_vu32(wbs);
    switch(kind) {
    case 0:
      export_function(iu, field, index);
      break;
    case 2:
      break;
    default:
      parser_error(iu, "Export section can't handle kind %d '%s' index %d",
                   kind, field, index);
    }
    free(field);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1d450
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x1df28
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1d4b0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1e210
movzbl %al, %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1d450
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x2c(%rbp)
testl %eax, %eax
je 0x1ded1
jmp 0x1dec7
movl -0x2c(%rbp), %eax
subl $0x2, %eax
je 0x1dee3
jmp 0x1dee5
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x28(%rbp), %edx
callq 0x1fd30
jmp 0x1df11
jmp 0x1df11
movq -0x8(%rbp), %rdi
movl -0x24(%rbp), %r8d
movq -0x20(%rbp), %r9
movl -0x28(%rbp), %eax
leaq 0x208e1(%rip), %rsi     # 0x3e7dc
movl $0x1a1, %edx            # imm = 0x1A1
leaq 0x20fa5(%rip), %rcx     # 0x3eeac
movl %eax, (%rsp)
movb $0x0, %al
callq 0x18220
movq -0x20(%rbp), %rdi
callq 0x3030
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1de83
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_wasm_parser.c
// Function: wasm_parse_section_data
static void
wasm_parse_section_data(ir_unit_t *iu, wasm_bytestream_t *wbs)
{
  uint32_t count = wbs_get_vu32(wbs);
  for(uint32_t i = 0; i < count; i++) {
    const uint32_t index = wbs_get_vu32(wbs);

    parse_init_expr(iu, wbs); // Will leave value on vstack
    const uint32_t offset =
      value_get_const32(iu, value_get(iu, vstack_pop(iu).value));
    value_resize(iu, iu->iu_first_func_value);

    const uint32_t size = wbs_get_vu32(wbs);
    if(index == 0) {
      memcpy(iu->iu_mem + offset, wbs->ptr, size);
      iu->iu_data_ptr = MAX(iu->iu_data_ptr, offset + size);
    }
    wbs->ptr += size;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1d450
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x1e1fd
movq -0x10(%rbp), %rdi
callq 0x1d450
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1e960
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1ea10
movq -0x40(%rbp), %rdi
movq %rax, -0x28(%rbp)
movl -0x28(%rbp), %esi
callq 0x20ee0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x261a0
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x19c(%rax), %esi
callq 0x1ccd0
movq -0x10(%rbp), %rdi
callq 0x1d450
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x1e1dd
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movl -0x20(%rbp), %eax
addq %rax, %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movl -0x2c(%rbp), %eax
movl %eax, %edx
callq 0x3330
movq -0x8(%rbp), %rax
movl 0x88(%rax), %eax
movl -0x20(%rbp), %ecx
addl -0x2c(%rbp), %ecx
cmpl %ecx, %eax
jbe 0x1e1c7
movq -0x8(%rbp), %rax
movl 0x88(%rax), %eax
movl %eax, -0x44(%rbp)
jmp 0x1e1d0
movl -0x20(%rbp), %eax
addl -0x2c(%rbp), %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x88(%rax)
movl -0x2c(%rbp), %edx
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movl %edx, %edx
addq %rdx, %rcx
movq %rcx, (%rax)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1e103
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: wbs_get_byte
static uint8_t
wbs_get_byte(wasm_bytestream_t *wbs)
{
  if(wbs->ptr >= wbs->end)
    return 0xff;

  uint8_t r = *wbs->ptr;
  wbs->ptr += 1;
  return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jb 0x1e22f
movb $-0x1, -0x1(%rbp)
jmp 0x1e24f
movq -0x10(%rbp), %rax
movq (%rax), %rax
movb (%rax), %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movb -0x11(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
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_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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1e210
movb %al, -0x19(%rbp)
movzbl -0x19(%rbp), %eax
movl %eax, -0x20(%rbp)
subl $0x40, %eax
je 0x1e297
jmp 0x1e28a
movl -0x20(%rbp), %eax
addl $-0x7c, %eax
subl $0x4, %eax
jb 0x1e2a0
jmp 0x1e2b3
movl $0x0, -0x4(%rbp)
jmp 0x1e2ec
movzbl -0x19(%rbp), %ecx
movl $0x7f, %eax
subl %ecx, %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x1e2ec
movq -0x10(%rbp), %rdi
movzbl -0x19(%rbp), %r8d
movq -0x18(%rbp), %rax
movq (%rax), %r9
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
subq %rax, %r9
subq $0x1, %r9
leaq 0x20503(%rip), %rsi     # 0x3e7dc
movl $0xc1, %edx
leaq 0x20568(%rip), %rcx     # 0x3e84d
movb $0x0, %al
callq 0x18220
movl -0x4(%rbp), %eax
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: import_function
static void
import_function(ir_unit_t *iu, const char *module, const char *name, int type)
{
  uint32_t vmir_type = VECTOR_ITEM(&iu->iu_wasm_type_map, type);

  ir_function_t *f = calloc(1, sizeof(ir_function_t));

  TAILQ_INIT(&f->if_bbs);
  f->if_type = vmir_type;
  f->if_gfid = VECTOR_LEN(&iu->iu_functions);
  f->if_name = strdup(name);
  VECTOR_PUSH_BACK(&iu->iu_functions, f);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x580(%rax), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x20(%rbp)
movl $0x1, %edi
movl $0x90, %esi
callq 0x32c0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq $0x0, 0x48(%rax)
movq -0x28(%rbp), %rcx
addq $0x48, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x50(%rax)
movl -0x20(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x2e0(%rax), %rax
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x34(%rax)
movq -0x18(%rbp), %rdi
callq 0x34a0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x2e0(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq -0x8(%rbp), %rcx
cmpq 0x2e8(%rcx), %rax
jbe 0x1e3fc
movq -0x30(%rbp), %rcx
addq $0x1, %rcx
shlq %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x2e8(%rax)
movq -0x8(%rbp), %rax
movq 0x2e8(%rax), %rax
shlq $0x3, %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x2d8(%rax), %rdi
movq -0x38(%rbp), %rsi
callq 0x3390
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x2d8(%rax)
movq -0x30(%rbp), %rcx
addq $0x1, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x2e0(%rax)
movq -0x28(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x2d8(%rax), %rax
movq -0x30(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x28(%rbp), %rax
cmpq $0x0, 0x70(%rax)
jne 0x1e465
movq -0x28(%rbp), %rdi
callq 0x1e640
cmpl $0x0, %eax
jne 0x1e463
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movq 0x20(%rcx), %rdi
movq -0x8(%rbp), %rcx
movq 0x48(%rcx), %rsi
callq *%rax
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x70(%rax)
jmp 0x1e465
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_wasm_parser.c
// Function: import_table
static void
import_table(ir_unit_t *iu, const char *module, const char *name,
              wasm_bytestream_t *wbs)
{
  const uint8_t elem_type = wbs_get_byte(wbs);
  if(elem_type != 0x70)
    parser_error(iu, "Table %s::%s is not of type 'anyfunc'",
                 module, name);

  const uint32_t flags = wbs_get_vu32(wbs);
  if(flags)
    parser_error(iu, "Resizable table %s::%s not supported",
                 module, name);

  const uint32_t initial = wbs_get_vu32(wbs);
  parser_error(iu, "Imported tables not yet supported: %s.%s size:%u",
               module, name, initial);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1e210
movb %al, -0x21(%rbp)
movzbl -0x21(%rbp), %eax
cmpl $0x70, %eax
je 0x1e4c3
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %r8
movq -0x18(%rbp), %r9
leaq 0x2032c(%rip), %rsi     # 0x3e7dc
movl $0x110, %edx            # imm = 0x110
leaq 0x20616(%rip), %rcx     # 0x3ead2
movb $0x0, %al
callq 0x18220
movq -0x20(%rbp), %rdi
callq 0x1d450
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
je 0x1e4fb
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %r8
movq -0x18(%rbp), %r9
leaq 0x202f4(%rip), %rsi     # 0x3e7dc
movl $0x115, %edx            # imm = 0x115
leaq 0x20604(%rip), %rcx     # 0x3eaf8
movb $0x0, %al
callq 0x18220
movq -0x20(%rbp), %rdi
callq 0x1d450
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %r8
movq -0x18(%rbp), %r9
movl -0x2c(%rbp), %eax
leaq 0x202bf(%rip), %rsi     # 0x3e7dc
movl $0x119, %edx            # imm = 0x119
leaq 0x205f4(%rip), %rcx     # 0x3eb1d
movl %eax, (%rsp)
movb $0x0, %al
callq 0x18220
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_wasm_parser.c
// Function: import_memory
static void
import_memory(ir_unit_t *iu, const char *module, const char *name,
              wasm_bytestream_t *wbs)
{
  const uint32_t flags = wbs_get_vu32(wbs);
  if(flags)
    parser_error(iu, "Resizable memory %s::%s not supported",
                 module, name);

  const uint32_t initial = wbs_get_vu32(wbs);
  parser_error(iu, "Importing memory not yet supported: %s.%s initial_size:%u",
               module, name, initial);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1d450
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x1e590
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %r8
movq -0x18(%rbp), %r9
leaq 0x2025f(%rip), %rsi     # 0x3e7dc
movl $0x124, %edx            # imm = 0x124
leaq 0x205c5(%rip), %rcx     # 0x3eb4e
movb $0x0, %al
callq 0x18220
movq -0x20(%rbp), %rdi
callq 0x1d450
movl %eax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %r8
movq -0x18(%rbp), %r9
movl -0x28(%rbp), %eax
leaq 0x2022a(%rip), %rsi     # 0x3e7dc
movl $0x128, %edx            # imm = 0x128
leaq 0x205b6(%rip), %rcx     # 0x3eb74
movl %eax, (%rsp)
movb $0x0, %al
callq 0x18220
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, 0x38(%rax)
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
cmpq $0x3a, %rax
jae 0x1e6c9
movslq -0x14(%rbp), %rcx
leaq 0x2b38d(%rip), %rax     # 0x49a00
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
callq 0x32d0
cmpl $0x0, %eax
jne 0x1e6bc
movq -0x20(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x38(%rax)
movq -0x20(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x3c(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x1e6d0
jmp 0x1e6be
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1e65e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_type.c
// Function: type_make_pointer
static int
type_make_pointer(ir_unit_t *iu, int type, int may_create)
{
  for(int i = 0; i < VECTOR_LEN(&iu->iu_types); i++) {
    ir_type_t *it = &VECTOR_ITEM(&iu->iu_types, i);
    if(it->it_code == IR_TYPE_POINTER && it->it_pointer.pointee == type)
      return i;
  }
  if(!may_create)
    return -1;

  iu->iu_types_created = 1;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x170(%rcx), %rax
jae 0x1e751
movq -0x10(%rbp), %rax
movq 0x168(%rax), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0xb, (%rax)
jne 0x1e744
movq -0x28(%rbp), %rax
movl 0x8(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x1e744
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1e832
jmp 0x1e746
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1e6f9
cmpl $0x0, -0x18(%rbp)
jne 0x1e763
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1e832
movq -0x10(%rbp), %rax
movl $0x1, 0x368(%rax)
movq -0x10(%rbp), %rax
movq 0x170(%rax), %rax
movl %eax, -0x54(%rbp)
movl $0xb, -0x50(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq 0x170(%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq -0x10(%rbp), %rcx
cmpq 0x178(%rcx), %rax
jbe 0x1e7f8
movq -0x60(%rbp), %rcx
addq $0x1, %rcx
shlq %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x178(%rax)
movq -0x10(%rbp), %rax
imulq $0x28, 0x178(%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rax
movq 0x168(%rax), %rdi
movq -0x68(%rbp), %rsi
callq 0x3390
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x168(%rax)
movq -0x60(%rbp), %rcx
addq $0x1, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x170(%rax)
movq -0x10(%rbp), %rax
movq 0x168(%rax), %rdi
imulq $0x28, -0x60(%rbp), %rax
addq %rax, %rdi
leaq -0x50(%rbp), %rsi
movl $0x28, %edx
callq 0x3330
movl -0x54(%rbp), %eax
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_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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x1e872
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x1eae0
movl %eax, -0x14(%rbp)
movl $0x1, %edi
movl $0x30, %esi
callq 0x32c0
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rdi
callq 0x1eb20
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movq 0x180(%rax), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl $0x2, (%rax)
movl -0x10(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x24(%rax)
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rax
movl 0x88(%rax), %ecx
addl -0x14(%rbp), %ecx
subl $0x1, %ecx
movl -0x14(%rbp), %eax
subl $0x1, %eax
xorl $-0x1, %eax
andl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x88(%rax)
movq -0x8(%rbp), %rax
movl 0x88(%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x1ecd0
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x2c(%rax)
movl -0x18(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x14(%rax)
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x1ecd0
movl %eax, %ecx
movq -0x8(%rbp), %rax
addl 0x88(%rax), %ecx
movl %ecx, 0x88(%rax)
movl -0x2c(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1ef90
movq -0x8(%rbp), %rax
movl 0x198(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x19c(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x1e9fb
movq -0x10(%rbp), %rdi
callq 0x1e210
movb %al, -0x11(%rbp)
movzbl -0x11(%rbp), %eax
cmpl $0xb, %eax
jne 0x1e9b5
jmp 0x1e9fb
movzbl -0x11(%rbp), %eax
addl $-0x41, %eax
subl $0x3, %eax
ja 0x1e9d6
jmp 0x1e9c3
movq -0x8(%rbp), %rdi
movzbl -0x11(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0x1efb0
jmp 0x1e9f9
movq -0x8(%rbp), %rdi
movzbl -0x11(%rbp), %r8d
leaq 0x1fdf6(%rip), %rsi     # 0x3e7dc
movl $0x506, %edx            # imm = 0x506
leaq 0x20379(%rip), %rcx     # 0x3ed6b
movb $0x0, %al
callq 0x18220
jmp 0x1e98d
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: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x5d0(%rax)
jne 0x1ea48
movq -0x10(%rbp), %rdi
leaq 0x1fda7(%rip), %rsi     # 0x3e7dc
movl $0x1c5, %edx            # imm = 0x1C5
leaq 0x2038e(%rip), %rcx     # 0x3edcf
movb $0x0, %al
callq 0x18220
movq -0x10(%rbp), %rax
movq 0x5c8(%rax), %rax
movq -0x10(%rbp), %rdx
movq 0x5d0(%rdx), %rcx
movq %rcx, %rsi
addq $-0x1, %rsi
movq %rsi, 0x5d0(%rdx)
movq -0x8(%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_value.c
// Function: value_str_id
static const char *
value_str_id(ir_unit_t *iu, int id)
{
  int len = value_print_id(NULL, iu, id);
  char *dst = tmpstr(iu, len);
  const char *ret = dst;
  value_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 0x1f490
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 0x1f490
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_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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movslq 0x198(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x188(%rcx), %rax
jne 0x1ebf9
movl $0x1, %edi
movl $0x48, %esi
callq 0x32c0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x188(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq -0x8(%rbp), %rcx
cmpq 0x190(%rcx), %rax
jbe 0x1ebca
movq -0x18(%rbp), %rcx
addq $0x1, %rcx
shlq %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x190(%rax)
movq -0x8(%rbp), %rax
movq 0x190(%rax), %rax
shlq $0x3, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x180(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x3390
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x180(%rax)
movq -0x18(%rbp), %rcx
addq $0x1, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x188(%rax)
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x180(%rax), %rax
movq -0x18(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x1eca2
movq -0x8(%rbp), %rax
movslq 0x198(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x188(%rcx), %rax
jae 0x1ec13
jmp 0x1ec32
leaq 0x200e1(%rip), %rdi     # 0x3ecfb
leaq 0x1fb43(%rip), %rsi     # 0x3e764
movl $0xfe, %edx
leaq 0x200fd(%rip), %rcx     # 0x3ed2a
callq 0x31c0
movq -0x8(%rbp), %rax
movq 0x180(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x198(%rcx), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x1ec82
movl $0x1, %edi
movl $0x48, %esi
callq 0x32c0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x180(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x198(%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x1eca0
movq -0x8(%rbp), %rax
movq 0x180(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x198(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
jmp 0x1eca2
movq -0x8(%rbp), %rax
movl 0x198(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x8(%rbp), %rcx
movl 0x198(%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x198(%rcx)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x20(%rbp)
subq $0xb, %rax
ja 0x1edd6
movq -0x20(%rbp), %rax
leaq 0x1e101(%rip), %rcx     # 0x3ce40
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x0, -0x4(%rbp)
jmp 0x1ee0e
movl $0x1, -0x4(%rbp)
jmp 0x1ee0e
movl $0x2, -0x4(%rbp)
jmp 0x1ee0e
movl $0x4, -0x4(%rbp)
jmp 0x1ee0e
movl $0x8, -0x4(%rbp)
jmp 0x1ee0e
movq -0x18(%rbp), %rax
cmpl $0x20, 0x8(%rax)
jg 0x1ed97
movl $0x4, -0x4(%rbp)
jmp 0x1ee0e
movq -0x18(%rbp), %rax
cmpl $0x40, 0x8(%rax)
jg 0x1edaa
movl $0x8, -0x4(%rbp)
jmp 0x1ee0e
jmp 0x1edd8
movl $0x4, -0x4(%rbp)
jmp 0x1ee0e
movq -0x18(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x1ee0e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0xc(%rax), %esi
callq 0x1eae0
movl %eax, -0x4(%rbp)
jmp 0x1ee0e
jmp 0x1edd8
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4760
movq -0x28(%rbp), %rdi
movq %rax, %r8
leaq 0x1feb5(%rip), %rsi     # 0x3ecb0
movl $0x1e1, %edx            # imm = 0x1E1
leaq 0x1feb9(%rip), %rcx     # 0x3ecc0
movb $0x0, %al
callq 0x18220
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x20(%rbp)
subq $0xb, %rax
ja 0x1ef4e
movq -0x20(%rbp), %rax
leaq 0x1dfc1(%rip), %rcx     # 0x3ce70
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x0, -0x4(%rbp)
jmp 0x1ef86
movl $0x1, -0x4(%rbp)
jmp 0x1ef86
movl $0x2, -0x4(%rbp)
jmp 0x1ef86
movl $0x4, -0x4(%rbp)
jmp 0x1ef86
movl $0x8, -0x4(%rbp)
jmp 0x1ef86
movq -0x18(%rbp), %rax
cmpl $0x20, 0x8(%rax)
jg 0x1ef07
movl $0x4, -0x4(%rbp)
jmp 0x1ef86
movq -0x18(%rbp), %rax
cmpl $0x40, 0x8(%rax)
jg 0x1ef1a
movl $0x8, -0x4(%rbp)
jmp 0x1ef86
jmp 0x1ef50
movl $0x4, -0x4(%rbp)
jmp 0x1ef86
movq -0x18(%rbp), %rax
movl 0x1c(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x1ef86
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0xc(%rax), %esi
callq 0x1ecd0
movq -0x18(%rbp), %rcx
imull 0x8(%rcx), %eax
movl %eax, -0x4(%rbp)
jmp 0x1ef86
jmp 0x1ef50
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4760
movq -0x28(%rbp), %rdi
movq %rax, %r8
leaq 0x1fd3d(%rip), %rsi     # 0x3ecb0
movl $0x17d, %edx            # imm = 0x17D
leaq 0x1fdc9(%rip), %rcx     # 0x3ed48
movb $0x0, %al
callq 0x18220
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl -0xc(%rbp), %eax
addl $-0x41, %eax
movl %eax, %ecx
movq %rcx, -0x48(%rbp)
subl $0x3, %eax
ja 0x1f0b0
movq -0x48(%rbp), %rax
leaq 0x1debd(%rip), %rcx     # 0x3cea0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1f170
movq -0x50(%rbp), %rdi
movl %eax, %esi
movl $0x5, %edx
callq 0x1f0f0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x1f0d2
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1f270
movq -0x58(%rbp), %rdi
movq %rax, %rsi
movl $0x6, %edx
callq 0x1f1f0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x1f0d2
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1cf10
movq -0x60(%rbp), %rdi
movl %eax, %esi
movl $0x8, %edx
callq 0x1f0f0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x1f0d2
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1f300
movq -0x68(%rbp), %rdi
movq %rax, %rsi
movl $0x9, %edx
callq 0x1f1f0
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x1f0d2
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %r8d
leaq 0x1f71d(%rip), %rsi     # 0x3e7dc
movl $0x356, %edx            # imm = 0x356
leaq 0x1fcca(%rip), %rcx     # 0x3ed95
movb $0x0, %al
callq 0x18220
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1f360
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)