LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_libc.c
// Function: vmir_heap_free
static void
vmir_heap_free(ir_unit_t *iu, void *ptr)
{
  if(ptr == NULL)
    return;
  heap_t *h = iu->iu_heap;
  heap_block_t *hb = ptr;
  hb--;
  assert(hb->hb_magic == HEAP_MAGIC_ALLOC);
  hb->hb_magic = HEAP_MAGIC_FREE;

  vmir_heap_merge_next(h, hb);
  heap_block_t *prev = TAILQ_PREV(hb, heap_block_queue, hb_link);
  if(prev != NULL) {
    assert(prev < hb);
    vmir_heap_merge_next(h, prev);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x16f6c
jmp 0x17025
movq -0x8(%rbp), %rax
movq 0x90(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $-0x18, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0xa110ced, (%rax)      # imm = 0xA110CED
jne 0x16f9d
jmp 0x16fbc
leaq 0x27586(%rip), %rdi     # 0x3e52a
leaq 0x275a0(%rip), %rsi     # 0x3e54b
movl $0xe4, %edx
leaq 0x27716(%rip), %rcx     # 0x3e6cd
callq 0x31c0
movq -0x20(%rbp), %rax
movl $0xf4eef4ee, (%rax)     # imm = 0xF4EEF4EE
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1c8f0
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x17025
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x16ff9
jmp 0x17018
leaq 0x276f6(%rip), %rdi     # 0x3e6f6
leaq 0x27544(%rip), %rsi     # 0x3e54b
movl $0xea, %edx
leaq 0x276ba(%rip), %rcx     # 0x3e6cd
callq 0x31c0
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x1c8f0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir.c
// Function: vmir_destroy
void
vmir_destroy(ir_unit_t *iu)
{
  libc_terminate(iu);

  for(int i = 0; i < VECTOR_LEN(&iu->iu_functions); i++) {
    function_destroy(VECTOR_ITEM(&iu->iu_functions, i));
  }

  free(iu->iu_vm_funcs);
  free(iu->iu_function_table);
  VECTOR_CLEAR(&iu->iu_functions);

  for(int i = 0; i < VECTOR_LEN(&iu->iu_types); i++) {
    ir_type_t *it = &VECTOR_ITEM(&iu->iu_types, i);
    type_clean(it);
  }

  VECTOR_CLEAR(&iu->iu_types);

  free(iu->iu_triple);
  free(iu->iu_debugged_function);

  VECTOR_CLEAR(&iu->iu_vfds);
  free(iu);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x171a0
movl $0x0, -0xc(%rbp)
movslq -0xc(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x2e0(%rcx), %rax
jae 0x17080
movq -0x8(%rbp), %rax
movq 0x2d8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x171e0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1704c
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
movq $0x0, 0x2e8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x2e0(%rax)
movq -0x8(%rbp), %rax
movq 0x2d8(%rax), %rdi
callq 0x3030
movl $0x0, -0x10(%rbp)
movslq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x170(%rcx), %rax
jae 0x1710e
movq -0x8(%rbp), %rax
movq 0x168(%rax), %rax
movslq -0x10(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x17230
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x170cf
jmp 0x17110
movq -0x8(%rbp), %rax
movq $0x0, 0x178(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x170(%rax)
movq -0x8(%rbp), %rax
movq 0x168(%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
movq 0x128(%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
movq 0x108(%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
movq $0x0, 0xe0(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0xd8(%rax)
movq -0x8(%rbp), %rax
movq 0xd0(%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rdi
callq 0x3030
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_function.c
// Function: function_destroy
static void
function_destroy(ir_function_t *f)
{
  function_remove_bb(f);
  free(f->if_name);
  free(f->if_vm_text);
  free(f->if_instr_backrefs);
  free(f);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1c9b0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rdi
callq 0x3030
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_type.c
// Function: type_clean
static void
type_clean(ir_type_t *it)
{
  switch(it->it_code) {
  default:
    break;
  case IR_TYPE_STRUCT:
    free(it->it_struct.name);
    free(it->it_struct.elements);
    break;
  case IR_TYPE_FUNCTION:
    free(it->it_function.parameters);
    break;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xc(%rbp)
testl %eax, %eax
je 0x17257
jmp 0x1724b
movl -0xc(%rbp), %eax
subl $0xc, %eax
je 0x17273
jmp 0x17255
jmp 0x17280
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3030
jmp 0x17280
movq -0x8(%rbp), %rax
movq 0x8(%rax), %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.c
// Function: vmir_create
ir_unit_t *
vmir_create(void *membase, uint32_t memsize,
            uint32_t rsize, uint32_t asize,
            void *opaque)
{
  ir_unit_t *iu = calloc(1, sizeof(ir_unit_t));
  iu->iu_log_level = VMIR_LOG_INFO;
  iu->iu_external_function_resolver = vmir_default_external_function_resolver;

  iu->iu_opaque = opaque;
  iu->iu_mem = membase;
  iu->iu_memsize = memsize;
  iu->iu_rsize = rsize;
  iu->iu_asize = asize;
  iu->iu_text_alloc_memsize = 1024 * 1024;
  iu->iu_text_alloc = malloc(iu->iu_text_alloc_memsize);

  iu->iu_mem_low = iu->iu_mem;
  iu->iu_mem_high = iu->iu_mem + memsize;

  return iu;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq %r8, -0x20(%rbp)
movl $0x1, %edi
movl $0x638, %esi            # imm = 0x638
callq 0x32c0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl $0x2, 0x630(%rax)
movq -0x28(%rbp), %rax
leaq -0x5a5(%rip), %rcx      # 0x16d30
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x8(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movl -0xc(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0xa4(%rax)
movl -0x10(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x9c(%rax)
movl -0x14(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0xa0(%rax)
movq -0x28(%rbp), %rax
movq $0x100000, 0x448(%rax) # imm = 0x100000
movq -0x28(%rbp), %rax
movq 0x448(%rax), %rdi
callq 0x3360
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x438(%rax)
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rcx
movl -0xc(%rbp), %eax
addq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_bitstream.c
// Function: read_bits
static uint32_t
read_bits(bcbitstream_t *bs, int num)
{
  int r = 0;
  int off = 0;
  // printf("bs->bytes_offset=%d\n", bs->bytes_offset);

  while(num > 0) {
    if(bs->bytes_offset >= bs->bytes_length)
      return 0;

    if(bs->remain == 0) {
      bs->tmp = bs->rdata[bs->bytes_offset];
      bs->bytes_offset++;
      bs->remain = 8;
    }

    int pick = VMIR_MIN(num, bs->remain);
    r |= (bs->tmp & ((1 << pick) - 1)) << off;
    bs->tmp = bs->tmp >> pick;
    off += pick;
    num -= pick;
    bs->remain -= pick;
  }
  return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0x17b80
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jl 0x17abf
movl $0x0, -0x4(%rbp)
jmp 0x17b86
movq -0x10(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x17afa
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0xc(%rcx), %rcx
movb (%rax,%rcx), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x14(%rax)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rax
movl $0x8, 0x10(%rax)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x17b0e
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x17b18
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x14(%rax), %eax
movl -0x20(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
subl $0x1, %ecx
andl %ecx, %eax
movl -0x1c(%rbp), %ecx
shll %cl, %eax
orl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x14(%rax), %eax
movl -0x20(%rbp), %ecx
sarl %cl, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x14(%rax)
movl -0x20(%rbp), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x20(%rbp), %ecx
movl -0x14(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x14(%rbp)
movl -0x20(%rbp), %edx
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x10(%rax)
jmp 0x17a99
movl -0x18(%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_bitcode_parser.c
// Function: ir_parse_blocks
static void
ir_parse_blocks(ir_unit_t *iu, int abbrev_id_width,
                rec_handler_t *rh, const ir_blockinfo_t *ibi,
                bcbitstream_t *bs)
{
  assert(bs->remain == 0);
  while(1) {
    uint32_t id = read_bits(bs, abbrev_id_width);
    if(id == 0)
      break;
    switch(id) {
    case 1:  ir_enter_subblock(iu, bs, abbrev_id_width); break;
    case 2:  ir_define_abbrev(iu, bs);                break;
    case 3:  ir_unabbrev_record(iu, rh, bs);          break;
    default: ir_dispatch_abbrev(iu, id, rh, ibi, bs); break;
    }
  }

  align_bits32(bs);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x17dc7
jmp 0x17de6
leaq 0x28a86(%rip), %rdi     # 0x40854
leaq 0x28a8f(%rip), %rsi     # 0x40864
movl $0x4aa, %edx            # imm = 0x4AA
leaq 0x28a9d(%rip), %rcx     # 0x4087e
callq 0x31c0
jmp 0x17de8
movq -0x28(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x17a80
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0x17dff
jmp 0x17e71
movl -0x2c(%rbp), %eax
movl %eax, -0x30(%rbp)
subl $0x1, %eax
je 0x17e20
jmp 0x17e0c
movl -0x30(%rbp), %eax
subl $0x2, %eax
je 0x17e32
jmp 0x17e16
movl -0x30(%rbp), %eax
subl $0x3, %eax
je 0x17e41
jmp 0x17e54
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl -0xc(%rbp), %edx
callq 0x331a0
jmp 0x17e6c
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x334f0
jmp 0x17e6c
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x33740
jmp 0x17e6c
movq -0x8(%rbp), %rdi
movl -0x2c(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x337f0
jmp 0x17de8
movq -0x28(%rbp), %rdi
callq 0x33b50
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_libc.c
// Function: vmir_heap_init
static void
vmir_heap_init(ir_unit_t *iu)
{
  int size = iu->iu_memsize - iu->iu_heap_start;
  heap_t *h = iu->iu_mem + iu->iu_heap_start;
  iu->iu_heap = h;
  TAILQ_INIT(&h->h_blocks);

  heap_block_t *hb = (void *)(h + 1);

  hb->hb_size = size - sizeof(heap_t);
  hb->hb_magic = HEAP_MAGIC_FREE;
  TAILQ_INSERT_TAIL(&h->h_blocks, hb, hb_link);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0xa4(%rax), %eax
movq -0x8(%rbp), %rcx
subl 0x8c(%rcx), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x8c(%rcx), %ecx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x90(%rax)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
movslq -0xc(%rbp), %rax
subq $0x10, %rax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x20(%rbp), %rax
movl $0xf4eef4ee, (%rax)     # imm = 0xF4EEF4EE
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
addq $0x8, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir.c
// Function: initialize_globals
static void
initialize_globals(ir_unit_t *iu, void *mem)
{
  for(int i = 0; i < VECTOR_LEN(&iu->iu_initializers); i++) {
    ir_initializer_t *ii = &VECTOR_ITEM(&iu->iu_initializers, i);
    const ir_value_t *gv = value_get(iu, ii->ii_globalvar);
    const ir_value_t *c  = value_get(iu, ii->ii_constant);
    const ir_globalvar_t *ig = gv->iv_gvar;
#if 0
    printf("Initializing global @ 0x%08x + 0x%08x '%s' with '%s'\n",
           ig->ig_addr, ig->ig_size,
           value_str_id(iu, ii->ii_globalvar),
           value_str_id(iu, ii->ii_constant));
#endif
    initialize_global(iu, mem + ig->ig_addr, ig->ig_type, c);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x2f8(%rcx), %rax
jae 0x17ff5
movq -0x8(%rbp), %rax
movq 0x2f0(%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movl (%rax), %esi
callq 0x20ee0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x20ee0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x38(%rbp), %rax
movl 0x28(%rax), %eax
addq %rax, %rsi
movq -0x38(%rbp), %rax
movl 0x10(%rax), %edx
movq -0x30(%rbp), %rcx
callq 0x38d20
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x17f67
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir.c
// Function: parser_error0
static void __attribute__((noreturn))
parser_error0(ir_unit_t *iu, const char *file, int line,
              const char *fmt, ...)
{
  va_list ap;
  va_start(ap, fmt);
  vsnprintf(iu->iu_err_buf, sizeof(iu->iu_err_buf), fmt, ap);
  va_end(ap);
  iu->iu_err_file = file;
  iu->iu_err_line = line;

  vmir_log(iu, VMIR_LOG_ERROR, "Parser error: %s:%d : %s",
           file, line, iu->iu_err_buf);

  if(iu->iu_failed) {
    printf("Double failure\n");
  } else {
    iu->iu_failed = 1;
  }

  longjmp(iu->iu_parser_jmp, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x1825b
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x40(%rbp), %rax
leaq -0xf0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x20, (%rax)
movq -0x8(%rbp), %rdi
addq $0x468, %rdi            # imm = 0x468
movq -0x20(%rbp), %rdx
leaq -0x40(%rbp), %rcx
movl $0x100, %esi            # imm = 0x100
callq 0x3100
leaq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x568(%rax)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x570(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl -0x14(%rbp), %r8d
movq -0x8(%rbp), %r9
addq $0x468, %r9             # imm = 0x468
movl $0x1, %esi
leaq 0x2918b(%rip), %rdx     # 0x41487
movb $0x0, %al
callq 0x4650
movq -0x8(%rbp), %rax
cmpl $0x0, 0x574(%rax)
je 0x18320
leaq 0x29189(%rip), %rdi     # 0x414a0
movb $0x0, %al
callq 0x3170
jmp 0x1832e
movq -0x8(%rbp), %rax
movl $0x1, 0x574(%rax)
movq -0x8(%rbp), %rdi
addq $0x370, %rdi            # imm = 0x370
movl $0x1, %esi
callq 0x33b0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir.c
// Function: run_global_ctors
static void
run_global_ctors(ir_unit_t *iu)
{
  const ir_globalvar_t *ig = find_globalvar(iu, "llvm.global_ctors");

  if(ig == NULL)
    return;
  const int ctor_size = 12;
  int num_ctors = ig->ig_size / ctor_size;

  for(int i = 0; i < num_ctors; i++) {
    uint32_t fn = mem_rd32(iu->iu_mem + ig->ig_addr + ctor_size * i + 4, iu);
    if(fn < VECTOR_LEN(&iu->iu_functions)) {
      ir_function_t *f = VECTOR_ITEM(&iu->iu_functions, fn);
      vmir_vm_function_call(iu, f, NULL);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x29149(%rip), %rsi     # 0x414b0
callq 0x393b0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1837c
jmp 0x18416
movl $0xc, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x2c(%rax), %eax
movl $0xc, %ecx
xorl %edx, %edx
divl %ecx
movl %eax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x18416
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x28(%rax), %eax
addq %rax, %rdi
imull $0xc, -0x1c(%rbp), %eax
cltq
addq %rax, %rdi
addq $0x4, %rdi
movq -0x8(%rbp), %rsi
callq 0x192a0
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpq 0x2e0(%rcx), %rax
jae 0x18409
movq -0x8(%rbp), %rax
movq 0x2d8(%rax), %rax
movl -0x20(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movb $0x0, %al
callq 0x3f20
jmp 0x1840b
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1839d
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir.c
// Function: vmir_instrumentation_dump
void
vmir_instrumentation_dump(ir_unit_t *iu)
{
  VECTOR_SORT(&iu->iu_instrumentation, instrumentation_cmp);
  for(int i = 0; i < VECTOR_LEN(&iu->iu_instrumentation); i++) {
    const ir_instrumentation_t *ii = &VECTOR_ITEM(&iu->iu_instrumentation, i);
    printf("%10"PRId64" %10"PRId64" %s.%d\n",
           ii->ii_count,
           ii->ii_count * ii->ii_instructions,
           ii->ii_func->if_name, ii->ii_bb);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x110(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x118(%rax), %rsi
movl $0x18, %edx
leaq 0x92(%rip), %rcx        # 0x184e0
callq 0x30d0
movl $0x0, -0xc(%rbp)
movslq -0xc(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x118(%rcx), %rax
jae 0x184cd
movq -0x8(%rbp), %rax
movq 0x110(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x18(%rbp), %rax
movslq 0xc(%rax), %rax
imulq %rax, %rdx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x20(%rax), %rcx
movq -0x18(%rbp), %rax
movl 0x8(%rax), %r8d
leaq 0x25d19(%rip), %rdi     # 0x3e1d4
movb $0x0, %al
callq 0x3170
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1845a
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir.c
// Function: instrumentation_cmp
static int
instrumentation_cmp(const ir_instrumentation_t *a,
                    const ir_instrumentation_t *b)
{
  if(a->ii_count * a->ii_instructions < b->ii_count * b->ii_instructions)
    return -1;
  if(a->ii_count * a->ii_instructions > b->ii_count * b->ii_instructions)
    return 1;
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0xc(%rcx), %rcx
imulq %rcx, %rax
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq -0x18(%rbp), %rdx
movslq 0xc(%rdx), %rdx
imulq %rdx, %rcx
cmpq %rcx, %rax
jge 0x18522
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1855f
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0xc(%rcx), %rcx
imulq %rcx, %rax
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq -0x18(%rbp), %rdx
movslq 0xc(%rdx), %rdx
imulq %rdx, %rcx
cmpq %rcx, %rax
jle 0x18558
movl $0x1, -0x4(%rbp)
jmp 0x1855f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir.c
// Function: vmir_mem_copy
uint32_t
vmir_mem_copy(ir_unit_t *iu, const void *data, size_t len)
{
  void *hostaddr;
  uint32_t addr = vmir_mem_alloc(iu, len, &hostaddr);
  if(hostaddr != NULL)
    memcpy(hostaddr, data, len);

  return addr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %esi
leaq -0x20(%rbp), %rdx
callq 0x47c0
movl %eax, -0x24(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x185b2
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3330
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir.c
// Function: vmir_argv_copy
static uint32_t
vmir_argv_copy(ir_unit_t *iu, int argc, char **argv)
{
  void *vm_argv_host;
  uint32_t vm_argv = vmir_mem_alloc(iu, (argc + 1) * sizeof(uint32_t),
                                    &vm_argv_host);

  for(int i = 0; i < argc; i++) {
    uint32_t str = vmir_mem_strdup(iu, argv[i]);
    mem_wr32(vm_argv_host + i * sizeof(uint32_t), str, iu);
  }
  return vm_argv;
}

// 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
movl -0xc(%rbp), %eax
addl $0x1, %eax
cltq
shlq $0x2, %rax
movl %eax, %esi
leaq -0x20(%rbp), %rdx
callq 0x47c0
movl %eax, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x1881e
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x185c0
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x28(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdi
movl -0x2c(%rbp), %esi
movq -0x8(%rbp), %rdx
callq 0x192c0
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x187d8
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir.c
// Function: tmpstr
static char * __attribute__((warn_unused_result))
tmpstr(ir_unit_t *iu, int len)
{
  int idx = (iu->iu_tmp_str_ptr++) & (IU_MAX_TMP_STR - 1);
  free(iu->iu_tmp_str[idx]);
  iu->iu_tmp_str[idx] = malloc(len + 1);
  iu->iu_tmp_str[idx][len] = 0;
  return iu->iu_tmp_str[idx];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movl 0x2d0(%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x2d0(%rcx)
andl $0x1f, %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movq 0x1d0(%rax,%rcx,8), %rdi
callq 0x3030
movl -0xc(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x3360
movq %rax, %rdx
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movq %rdx, 0x1d0(%rax,%rcx,8)
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movq 0x1d0(%rax,%rcx,8), %rax
movslq -0xc(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movq 0x1d0(%rax,%rcx,8), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir.c
// Function: addstr
static int __attribute__((warn_unused_result))
addstr(char **dst, const char *str)
{
  int len = strlen(str);
  if(dst != NULL) {
    memcpy(*dst, str, len);
    *dst += len;
  }
  return len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3150
movl %eax, -0x14(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x18eda
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x3330
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 $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_type.c
// Function: type_print_id
static int
type_print_id(char **dstp, const ir_unit_t *iu, int id)
{
  char tmpbuf[128];

  if(id < VECTOR_LEN(&iu->iu_types))
    return type_print(dstp, iu, &VECTOR_ITEM(&iu->iu_types, id));

  snprintf(tmpbuf, sizeof(tmpbuf), "[TypeId-%d]", id);
  return addstr(dstp, tmpbuf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x170(%rcx), %rax
jae 0x18f3f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x168(%rax), %rdx
movslq -0x1c(%rbp), %rax
imulq $0x28, %rax, %rax
addq %rax, %rdx
callq 0x18930
movl %eax, -0x4(%rbp)
jmp 0x18f6f
leaq -0xa0(%rbp), %rdi
movl -0x1c(%rbp), %ecx
movl $0x80, %esi
leaq 0x25355(%rip), %rdx     # 0x3e2aa
movb $0x0, %al
callq 0x3180
movq -0x10(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x18e90
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_vm.c
// Function: vm_strchr
static uint32_t __attribute__((noinline))
vm_strchr(uint32_t a, int b, void *mem)
{
  void *s = mem + a;
  void *r = strchr(s, b);
  int ret = r ? r - mem : 0;
  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl -0x4(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl -0x8(%rbp), %esi
callq 0x3160
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x19368
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x30(%rbp)
jmp 0x19370
xorl %eax, %eax
movq %rax, -0x30(%rbp)
jmp 0x19370
movq -0x30(%rbp), %rax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_vm.c
// Function: vm_strrchr
static uint32_t __attribute__((noinline))
vm_strrchr(uint32_t a, int b, void *mem)
{
  void *s = mem + a;
  void *r = strrchr(s, b);
  int ret = r ? r - mem : 0;
  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl -0x4(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl -0x8(%rbp), %esi
callq 0x3190
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x193c8
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x30(%rbp)
jmp 0x193d0
xorl %eax, %eax
movq %rax, -0x30(%rbp)
jmp 0x193d0
movq -0x30(%rbp), %rax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_vm.c
// Function: vm_vaarg32
static uint32_t __attribute__((noinline))
vm_vaarg32(void *rf, void **ptr)
{
  void *p = *ptr;
  p -= sizeof(uint32_t);
  uint32_t r = *(uint32_t *)p;
  *ptr = p;
  return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $-0x4, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl -0x1c(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_vm.c
// Function: vm_vaarg64
static uint64_t __attribute__((noinline))
vm_vaarg64(void *rf, void **ptr)
{
  void *p = *ptr;
  p -= sizeof(uint64_t);
  uint64_t r = *(uint64_t *)p;
  *ptr = p;
  return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $-0x8, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_vm.c
// Function: vmir_traceback
static void
vmir_traceback(struct ir_unit *iu, const char *info)
{
  const vm_frame_t *f;

  vmir_log(iu, VMIR_LOG_INFO, "--- Traceback (%s) ---", info);
  for(f = iu->iu_current_frame; f != NULL; f = f->prev) {
    vmir_log(iu, VMIR_LOG_INFO, "%s()", f->func->if_name);
  }
  vmir_log(iu, VMIR_LOG_INFO, "--- Traceback end ---");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl $0x2, %esi
leaq 0x24df8(%rip), %rdx     # 0x3e2dc
movb $0x0, %al
callq 0x4650
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1952f
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x20(%rax), %rcx
movl $0x2, %esi
leaq 0x24bc8(%rip), %rdx     # 0x3e0e2
movb $0x0, %al
callq 0x4650
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x194f7
movq -0x8(%rbp), %rdi
movl $0x2, %esi
leaq 0x24db4(%rip), %rdx     # 0x3e2f3
movb $0x0, %al
callq 0x4650
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_libc.c
// Function: vmir_atoi
static int
vmir_atoi(void *ret, const void *rf, ir_unit_t *iu)
{
  const char *str = vmir_vm_ptr(&rf, iu);
  int r = atoi(str);
  vmir_vm_ret32(ret, r);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x10(%rbp), %rdi
callq 0x3db0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3450
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x3ee0
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_libc.c
// Function: vmir_toupper
static int
vmir_toupper(void *ret, const void *rf, ir_unit_t *iu)
{
  uint32_t c = vmir_vm_arg32(&rf);
  if(c >= 'a' && c <= 'z')
    c -= 32;
  vmir_vm_ret32(ret, c);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x3cf0
movl %eax, -0x1c(%rbp)
cmpl $0x61, -0x1c(%rbp)
jb 0x19685
cmpl $0x7a, -0x1c(%rbp)
ja 0x19685
movl -0x1c(%rbp), %eax
subl $0x20, %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x3ee0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_libc.c
// Function: vmir_tolower
static int
vmir_tolower(void *ret, const void *rf, ir_unit_t *iu)
{
  uint32_t c = vmir_vm_arg32(&rf);
  if(c >= 'A' && c <= 'Z')
    c += 32;
  vmir_vm_ret32(ret, c);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x3cf0
movl %eax, -0x1c(%rbp)
cmpl $0x41, -0x1c(%rbp)
jb 0x196d5
cmpl $0x5a, -0x1c(%rbp)
ja 0x196d5
movl -0x1c(%rbp), %eax
addl $0x20, %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x3ee0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_libc.c
// Function: vmir_isprint
static int
vmir_isprint(void *ret, const void *rf, ir_unit_t *iu)
{
  uint32_t c = vmir_vm_arg32(&rf);
  c &= 0x7f;
  c = (c >= ' ' && c < 127);
  vmir_vm_ret32(ret, c);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x3cf0
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
andl $0x7f, %eax
movl %eax, -0x1c(%rbp)
xorl %eax, %eax
cmpl $0x20, -0x1c(%rbp)
movb %al, -0x1d(%rbp)
jb 0x1972e
cmpl $0x7f, -0x1c(%rbp)
setb %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x3ee0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_libc.c
// Function: vmir_malloc
static int
vmir_malloc(void *ret, const void *rf, ir_unit_t *iu)
{
  uint32_t size = vmir_vm_arg32(&rf);
  MEMTRACE("malloc(%d) = ...\n", size);
  void *p = vmir_heap_malloc(iu, size);
  vmir_vm_retptr(ret, p, iu);
  MEMTRACE("malloc(%d) = 0x%x\n", size, *(uint32_t *)ret);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x3cf0
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x16e00
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3e90
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_libc.c
// Function: vmir_free
static int
vmir_free(void *ret, const void *rf, ir_unit_t *iu)
{
  uint32_t ptr = vmir_vm_arg32(&rf);
  if(ptr == 0)
    return 0;
  MEMTRACE("free(0x%x)\n", ptr);
  vmir_heap_free(iu, iu->iu_mem + ptr);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x3cf0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x1982f
movl $0x0, -0x4(%rbp)
jmp 0x1984d
movq -0x20(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rsi
movl -0x24(%rbp), %eax
addq %rax, %rsi
callq 0x16f50
movl $0x0, -0x4(%rbp)
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_libc.c
// Function: vmir_realloc
static int
vmir_realloc(void *ret, const void *rf, ir_unit_t *iu)
{
  uint32_t ptr = vmir_vm_arg32(&rf);
  uint32_t size = vmir_vm_arg32(&rf);

  MEMTRACE("realloc(0x%x, %d) = ...\n", ptr, size);
  void *p = vmir_heap_realloc(iu, ptr ? iu->iu_mem + ptr : NULL, size);
  vmir_vm_retptr(ret, p, iu);
  MEMTRACE("realloc(0x%x, %d) = 0x%x\n", ptr, size, *(uint32_t *)ret);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x3cf0
movl %eax, -0x1c(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x3cf0
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x198ae
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x1c(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
jmp 0x198b6
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0x198b6
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl -0x20(%rbp), %edx
callq 0x1af20
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3e90
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_libc.c
// Function: vmir_calloc
static int
vmir_calloc(void *ret, const void *rf, ir_unit_t *iu)
{
  uint32_t nmemb = vmir_vm_arg32(&rf);
  uint32_t size = vmir_vm_arg32(&rf);
  MEMTRACE("calloc(%d, %d) = ...\n", nmemb, size);
  void *p = vmir_heap_malloc(iu, size * nmemb);
  if(p != NULL)
    memset(p, 0, size * nmemb);
  vmir_vm_retptr(ret, p, iu);
  MEMTRACE("calloc(%d, %d) = 0x%x\n", nmemb, size, *(uint32_t *)ret);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x3cf0
movl %eax, -0x1c(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x3cf0
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movl -0x20(%rbp), %esi
imull -0x1c(%rbp), %esi
callq 0x16e00
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x1994d
movq -0x28(%rbp), %rdi
movl -0x20(%rbp), %eax
imull -0x1c(%rbp), %eax
movl %eax, %eax
movl %eax, %edx
xorl %esi, %esi
callq 0x31f0
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3e90
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_libc.c
// Function: vmir_open
static int
vmir_open(void *ret, const void *rf, ir_unit_t *iu)
{
  const char *path = vmir_vm_ptr(&rf, iu);
  uint32_t flags = vmir_vm_arg32(&rf);

  uint32_t vmir_flags = 0;
  if(flags & 0100) // O_CREAT
    vmir_flags |= VMIR_FS_OPEN_CREATE;

  if(flags & 2)
    vmir_flags |= VMIR_FS_OPEN_RW;
  else if(flags & 1)
    vmir_flags |= VMIR_FS_OPEN_WRITE;
  else
    vmir_flags |= VMIR_FS_OPEN_READ;

  int fd = vfd_open(iu, path, vmir_flags);
  vmir_vm_ret32(ret, fd);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x10(%rbp), %rdi
callq 0x3db0
movq %rax, -0x20(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x3cf0
movl %eax, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x24(%rbp), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x199bc
movl -0x28(%rbp), %eax
orl $0x4, %eax
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x199d2
movl -0x28(%rbp), %eax
orl $0x3, %eax
movl %eax, -0x28(%rbp)
jmp 0x199f3
movl -0x24(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x199e8
movl -0x28(%rbp), %eax
orl $0x2, %eax
movl %eax, -0x28(%rbp)
jmp 0x199f1
movl -0x28(%rbp), %eax
orl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x199f3
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x28(%rbp), %edx
callq 0x1b020
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0x3ee0
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_libc.c
// Function: vmir_read
static int
vmir_read(void *ret, const void *rf, ir_unit_t *iu)
{
  uint32_t fd = vmir_vm_arg32(&rf);
  void *buf = vmir_vm_ptr(&rf, iu);
  uint32_t nbyte = vmir_vm_arg32(&rf);
  vmir_vm_ret32(ret, vfd_read(iu, fd, buf, nbyte));
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x3cf0
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x10(%rbp), %rdi
callq 0x3db0
movq %rax, -0x28(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x3cf0
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x28(%rbp), %rdx
movl -0x2c(%rbp), %eax
movl %eax, %ecx
callq 0x1b090
movq -0x38(%rbp), %rdi
movl %eax, %esi
callq 0x3ee0
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_libc.c
// Function: vmir_lseek
static int
vmir_lseek(void *ret, const void *rf, ir_unit_t *iu)
{
  uint32_t fd = vmir_vm_arg32(&rf);
  int64_t offset = vmir_vm_arg64(&rf);
  uint32_t whence = vmir_vm_arg32(&rf);
  vmir_vm_ret64(ret, vfd_seek(iu, fd, offset, whence));
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x3cf0
movl %eax, -0x1c(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x3d20
movq %rax, -0x28(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x3cf0
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x28(%rbp), %rdx
movl -0x2c(%rbp), %ecx
callq 0x1b190
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x3f00
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_libc.c
// Function: vmir_close
static int
vmir_close(void *ret, const void *rf, ir_unit_t *iu)
{
  uint32_t fd = vmir_vm_arg32(&rf);
  vmir_fd_close(iu, fd);
  vmir_vm_ret32(ret, 0);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x3cf0
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x16c30
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x3ee0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_libc.c
// Function: vmir_fopen
static int
vmir_fopen(void *ret, const void *rf, ir_unit_t *iu)
{
  const char *path = vmir_vm_ptr(&rf, iu);
  const char *mode = vmir_vm_ptr(&rf, iu);
  vFILE_t *vfile = vFILE_open(iu, path, mode, 0);
  vmir_vm_retptr(ret, vfile, iu);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x10(%rbp), %rdi
callq 0x3db0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x10(%rbp), %rdi
callq 0x3db0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
xorl %ecx, %ecx
callq 0x1b210
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3e90
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_libc.c
// Function: vmir_fdopen
static int
vmir_fdopen(void *ret, const void *rf, ir_unit_t *iu)
{
  uint32_t fd = vmir_vm_arg32(&rf);
  const char *mode = vmir_vm_ptr(&rf, iu);
  vFILE_t *vfile = vFILE_open_fd(iu, fd, 0, mode);
  vmir_vm_retptr(ret, vfile, iu);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x3cf0
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x10(%rbp), %rdi
callq 0x3db0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x28(%rbp), %rcx
xorl %edx, %edx
callq 0x1b2e0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3e90
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_libc.c
// Function: vmir_fseek
static int
vmir_fseek(void *ret, const void *rf, ir_unit_t *iu)
{
  vFILE_t *vfile = vmir_vm_ptr_nullchk(&rf, iu);
  if(vfile == NULL) {
    vmir_vm_ret32(ret, -1);
    return 0;
  }
  uint32_t offset = vmir_vm_arg32(&rf);
  uint32_t whence = vmir_vm_arg32(&rf);
  int r = fseek(vfile->fp, offset, whence);
  vmir_vm_ret32(ret, r);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0x3de0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x19cc3
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x3ee0
movl $0x0, -0x4(%rbp)
jmp 0x19d05
leaq -0x18(%rbp), %rdi
callq 0x3cf0
movl %eax, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x3cf0
movl %eax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movl -0x2c(%rbp), %eax
movl %eax, %esi
movl -0x30(%rbp), %edx
callq 0x3380
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rdi
movl -0x34(%rbp), %esi
callq 0x3ee0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_libc.c
// Function: vmir_fseeko
static int
vmir_fseeko(void *ret, const void *rf, ir_unit_t *iu)
{
  vFILE_t *vfile = vmir_vm_ptr_nullchk(&rf, iu);
  if(vfile == NULL) {
    vmir_vm_ret64(ret, -1);
    return 0;
  }
  uint64_t offset = vmir_vm_arg64(&rf);
  uint32_t whence = vmir_vm_arg32(&rf);
  int64_t r = fseeko(vfile->fp, offset, whence);
  vmir_vm_ret64(ret, r);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0x3de0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x19d55
movq -0x10(%rbp), %rdi
movq $-0x1, %rsi
callq 0x3f00
movl $0x0, -0x4(%rbp)
jmp 0x19d9b
leaq -0x18(%rbp), %rdi
callq 0x3d20
movq %rax, -0x30(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x3cf0
movl %eax, -0x34(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x30(%rbp), %rsi
movl -0x34(%rbp), %edx
callq 0x33f0
cltq
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x3f00
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_libc.c
// Function: vmir_fread
static int
vmir_fread(void *ret, const void *rf, ir_unit_t *iu)
{
  void *buf = vmir_vm_ptr(&rf, iu);
  uint32_t size = vmir_vm_arg32(&rf);
  uint32_t nmemb = vmir_vm_arg32(&rf);
  vFILE_t *vfile = vmir_vm_ptr_nullchk(&rf, iu);
  if(vfile == NULL) {
    vmir_vm_ret32(ret, -1);
    return 0;
  }
  int r = fread(buf, size, nmemb, vfile->fp);
  vmir_vm_ret32(ret, r);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0x3db0
movq %rax, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x3cf0
movl %eax, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x3cf0
movl %eax, -0x30(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0x3de0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x19e1c
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x3ee0
movl $0x0, -0x4(%rbp)
jmp 0x19e4c
movq -0x28(%rbp), %rdi
movl -0x2c(%rbp), %eax
movl %eax, %esi
movl -0x30(%rbp), %eax
movl %eax, %edx
movq -0x38(%rbp), %rax
movq (%rax), %rcx
callq 0x30f0
movl %eax, -0x3c(%rbp)
movq -0x10(%rbp), %rdi
movl -0x3c(%rbp), %esi
callq 0x3ee0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_libc.c
// Function: vmir_fwrite
static int
vmir_fwrite(void *ret, const void *rf, ir_unit_t *iu)
{
  void *buf = vmir_vm_ptr(&rf, iu);
  uint32_t size = vmir_vm_arg32(&rf);
  uint32_t nmemb = vmir_vm_arg32(&rf);
  vFILE_t *vfile = vmir_vm_ptr_nullchk(&rf, iu);
  if(vfile == NULL) {
    vmir_vm_ret32(ret, -1);
    return 0;
  }
  int r = fwrite(buf, size, nmemb, vfile->fp);
  vmir_vm_ret32(ret, r);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0x3db0
movq %rax, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x3cf0
movl %eax, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x3cf0
movl %eax, -0x30(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0x3de0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x19ecc
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x3ee0
movl $0x0, -0x4(%rbp)
jmp 0x19efc
movq -0x28(%rbp), %rdi
movl -0x2c(%rbp), %eax
movl %eax, %esi
movl -0x30(%rbp), %eax
movl %eax, %edx
movq -0x38(%rbp), %rax
movq (%rax), %rcx
callq 0x3480
movl %eax, -0x3c(%rbp)
movq -0x10(%rbp), %rdi
movl -0x3c(%rbp), %esi
callq 0x3ee0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)