LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_type.c
// Function: type_bitwidth
static unsigned int
type_bitwidth(ir_unit_t *iu, const ir_type_t *it)
{
  switch(it->it_code) {
  case IR_TYPE_VOID:
    return 0;
  case IR_TYPE_INT1:
    return 1;
  case IR_TYPE_INT8:
    return 8;
  case IR_TYPE_INT16:
    return 16;
  case IR_TYPE_INT32:
    return 32;
  case IR_TYPE_INT64:
    return 64;
  case IR_TYPE_INTx:
    return it->it_bits;

  default:
    parser_error(iu, "Unable to compute bitwidth 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
decl %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x6, %eax
ja 0x32fa9
movq -0x20(%rbp), %rax
leaq 0xad12(%rip), %rcx      # 0x3dc70
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x0, -0x4(%rbp)
jmp 0x32fdf
movl $0x1, -0x4(%rbp)
jmp 0x32fdf
movl $0x8, -0x4(%rbp)
jmp 0x32fdf
movl $0x10, -0x4(%rbp)
jmp 0x32fdf
movl $0x20, -0x4(%rbp)
jmp 0x32fdf
movl $0x40, -0x4(%rbp)
jmp 0x32fdf
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x32fdf
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 0xbce4(%rip), %rsi      # 0x3ecb0
movl $0x1b5, %edx            # imm = 0x1B5
leaq 0xd543(%rip), %rcx      # 0x4051b
movb $0x0, %al
callq 0x18220
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_vm.c
// Function: emit_data
static void *
emit_data(ir_unit_t *iu, int size)
{
  if(iu->iu_text_ptr + size >= iu->iu_text_alloc + iu->iu_text_alloc_memsize)
    parser_error(iu, "Function too big");
  void *r = iu->iu_text_ptr;
  iu->iu_text_ptr += size;
  return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x440(%rax), %rax
movslq -0xc(%rbp), %rcx
addq %rcx, %rax
movq -0x8(%rbp), %rcx
movq 0x438(%rcx), %rcx
movq -0x8(%rbp), %rdx
addq 0x448(%rdx), %rcx
cmpq %rcx, %rax
jb 0x3304a
movq -0x8(%rbp), %rdi
leaq 0xcee8(%rip), %rsi      # 0x3ff1f
movl $0x963, %edx            # imm = 0x963
leaq 0xcf1e(%rip), %rcx      # 0x3ff61
movb $0x0, %al
callq 0x18220
movq -0x8(%rbp), %rax
movq 0x440(%rax), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %edx
movq -0x8(%rbp), %rax
movq 0x440(%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, 0x440(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_type.c
// Function: type_code_mask
static uint32_t
type_code_mask(ir_type_code_t code)
{
  switch(code) {
  case IR_TYPE_INT1:
    return 0xff;
  case IR_TYPE_INT8:
    return 0xff;
  case IR_TYPE_INT16:
    return 0xffff;
  default:
    return 0xffffffff;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
subl $0x2, %eax
je 0x330a8
jmp 0x33094
movl -0xc(%rbp), %eax
subl $0x3, %eax
je 0x330b1
jmp 0x3309e
movl -0xc(%rbp), %eax
subl $0x4, %eax
je 0x330ba
jmp 0x330c3
movl $0xff, -0x4(%rbp)
jmp 0x330ca
movl $0xff, -0x4(%rbp)
jmp 0x330ca
movl $0xffff, -0x4(%rbp)     # imm = 0xFFFF
jmp 0x330ca
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_vm.c
// Function: bb_to_offset_delta
static int16_t
bb_to_offset_delta(ir_unit_t *iu, ir_function_t *f, int bbi, int off)
{
  ir_bb_t *bb = bb_find(f, bbi);
  if(bb == NULL) {
    vmir_log(iu, VMIR_LOG_FAIL, "%s() basic block %d not found during fixup",
             f->if_name, bbi);
    abort();
  }
  // The 2 is here because we need to compensate that the instruction
  // stream is past the opcode when the branch is executed
  int o = bb->ib_text_offset - (off + 2);

  assert(o >= INT16_MIN);
  assert(o <= INT16_MAX);
  return o;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x268e0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x33122
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movl -0x14(%rbp), %r8d
xorl %esi, %esi
leaq 0xd6b2(%rip), %rdx      # 0x407c8
movb $0x0, %al
callq 0x4650
callq 0x3050
movq -0x20(%rbp), %rax
movl 0x20(%rax), %eax
movl -0x18(%rbp), %ecx
addl $0x2, %ecx
subl %ecx, %eax
movl %eax, -0x24(%rbp)
cmpl $0xffff8000, -0x24(%rbp) # imm = 0xFFFF8000
jl 0x3313f
jmp 0x3315e
leaq 0xd6ad(%rip), %rdi      # 0x407f3
leaq 0xcdd2(%rip), %rsi      # 0x3ff1f
movl $0x1258, %edx           # imm = 0x1258
leaq 0xd6a9(%rip), %rcx      # 0x40802
callq 0x31c0
cmpl $0x7fff, -0x24(%rbp)    # imm = 0x7FFF
jg 0x33169
jmp 0x33188
leaq 0xd6d5(%rip), %rdi      # 0x40845
leaq 0xcda8(%rip), %rsi      # 0x3ff1f
movl $0x1259, %edx           # imm = 0x1259
leaq 0xd67f(%rip), %rcx      # 0x40802
callq 0x31c0
movl -0x24(%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_bitcode_parser.c
// Function: ir_unabbrev_record
static void
ir_unabbrev_record(ir_unit_t *iu, rec_handler_t *rh, bcbitstream_t *bs)
{
  int i;
  const uint32_t code = read_vbr(bs, 6);
  const uint32_t numops = read_vbr(bs, 6);

  int64_t *argv = malloc(numops * sizeof(int64_t));
  for(i = 0; i < numops; i++) {
    argv[i] = read_vbr64(bs, 6);
  }

  rh(iu, code, numops, argv);
  free(argv);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl $0x6, %esi
callq 0x33b80
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movl $0x6, %esi
callq 0x33b80
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, %edi
shlq $0x3, %rdi
callq 0x3360
movq %rax, -0x30(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jae 0x337bf
movq -0x18(%rbp), %rdi
movl $0x6, %esi
callq 0x38980
movq %rax, %rdx
movq -0x30(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3378f
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdi
movl -0x20(%rbp), %esi
movl -0x24(%rbp), %edx
movq -0x30(%rbp), %rcx
callq *%rax
movq -0x30(%rbp), %rdi
callq 0x3030
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_vbr
static uint32_t
read_vbr(bcbitstream_t *bs, int width)
{
  assert(width > 0);

  uint32_t ret = 0;
  const uint32_t cont = (1 << (width - 1));
  const uint32_t mask = cont - 1;
  int stride = 0;

  while(1) {
    uint32_t x = read_bits(bs, width);
    ret |= (x & mask) << stride;
    if(cont & x) {
      stride += width - 1;
      assert(stride < 32);
    } else {
      break;
    }
  }
  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0x33b97
jmp 0x33bb6
leaq 0xcd7f(%rip), %rdi      # 0x4091d
leaq 0xcd82(%rip), %rsi      # 0x40927
movl $0x50, %edx
leaq 0xcd8b(%rip), %rcx      # 0x4093c
callq 0x31c0
movl $0x0, -0x10(%rbp)
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x17a80
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
andl -0x18(%rbp), %eax
movl -0x1c(%rbp), %ecx
shll %cl, %eax
orl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
andl -0x20(%rbp), %eax
cmpl $0x0, %eax
je 0x33c3d
movl -0xc(%rbp), %eax
subl $0x1, %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x20, -0x1c(%rbp)
jge 0x33c1c
jmp 0x33c3b
leaq 0xcd41(%rip), %rdi      # 0x40964
leaq 0xccfd(%rip), %rsi      # 0x40927
movl $0x5c, %edx
leaq 0xcd06(%rip), %rcx      # 0x4093c
callq 0x31c0
jmp 0x33c3f
jmp 0x33c41
jmp 0x33bdd
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_bitcode_parser.c
// Function: blockinfo_find
static ir_blockinfo_t *
blockinfo_find(ir_unit_t *iu, int id)
{
  ir_blockinfo_t *ib;
  LIST_FOREACH(ib, &iu->iu_blockinfos, ib_link) {
    if(ib->ib_id == id)
      return ib;
  }
  ib = calloc(1, sizeof(ir_blockinfo_t));
  ib->ib_id = id;
  LIST_INSERT_HEAD(&iu->iu_blockinfos, ib, ib_link);
  TAILQ_INIT(&ib->ib_abbrevs);
  return ib;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x138(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x33c9d
movq -0x20(%rbp), %rax
movl 0x10(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x33c8e
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x33d2d
jmp 0x33c90
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x33c6e
movl $0x1, %edi
movl $0x28, %esi
callq 0x32c0
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x138(%rax), %rax
movq -0x20(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
je 0x33ce5
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x138(%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x138(%rax)
movq -0x10(%rbp), %rcx
addq $0x138, %rcx            # imm = 0x138
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x33d09
movq -0x20(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x20(%rbp), %rcx
addq $0x18, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_bitcode_parser.c
// Function: blockinfo_rec_handler
static void
blockinfo_rec_handler(ir_unit_t *iu, int op,
                      unsigned int argc, const int64_t *argv)
{
  ir_block_t *ib = LIST_FIRST(&iu->iu_blocks);
  switch(op) {

  case 1: // SETBID
    if(argc != 1)
      parser_error(iu, "Bad number of args (%d) for SETBID", argc);

    ib->ib_blockinfo = blockinfo_find(iu, argv[0]);
    break;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x140(%rax), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
subl $0x1, %eax
jne 0x33db4
jmp 0x33d6f
cmpl $0x1, -0x10(%rbp)
je 0x33d97
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %r8d
leaq 0xcae0(%rip), %rsi      # 0x40864
movl $0x60, %edx
leaq 0xcbe0(%rip), %rcx      # 0x40970
movb $0x0, %al
callq 0x18220
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl %eax, %esi
callq 0x33c50
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_bitcode_parser.c
// Function: module_rec_handler
static void
module_rec_handler(ir_unit_t *iu, int op,
                   unsigned int argc, const int64_t *argv)
{
  switch(op) {
  case MODULE_CODE_VERSION:
    iu->iu_version = argv[0];
    break;

  case MODULE_CODE_TRIPLE:
    free(iu->iu_triple);
    iu->iu_triple = read_str_from_argv(argc, argv);
    break;

  case MODULE_CODE_DATALAYOUT:
    break;

  case MODULE_CODE_GLOBALVAR:
    return module_globalvar(iu, argc, argv);

  case MODULE_CODE_FUNCTION:
    return module_function(iu, argc, argv);

  case MODULE_CODE_ALIAS:
    return module_alias(iu, argc, argv);

  case MODULE_CODE_VSTOFFSET:
    return module_vstoffset(iu, argc, argv);

  case MODULE_CODE_COMDAT:
  case MODULE_CODE_METADATA_VALUES_UNUSED:
  case MODULE_CODE_SOURCE_FILENAME:
    break;

  default:
    printargs(argv, argc);
    parser_error(iu, "Unknown module code %d", op);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl -0xc(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0xf, %eax
ja 0x33e8e
movq -0x20(%rbp), %rax
leaq 0x9f2f(%rip), %rcx      # 0x3dd24
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x130(%rax)
jmp 0x33ebc
movq -0x8(%rbp), %rax
movq 0x128(%rax), %rdi
callq 0x3030
movl -0x10(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x35860
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x128(%rax)
jmp 0x33ebc
jmp 0x33ebc
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x358d0
jmp 0x33ebc
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x35ab0
jmp 0x33ebc
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x35cc0
jmp 0x33ebc
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x35d40
jmp 0x33ebc
jmp 0x33ebc
movq -0x18(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x35d90
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %r8d
leaq 0xc9bb(%rip), %rsi      # 0x40864
movl $0x103, %edx            # imm = 0x103
leaq 0xcade(%rip), %rcx      # 0x40993
movb $0x0, %al
callq 0x18220
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_bitcode_parser.c
// Function: value_symtab_rec_handler
static void
value_symtab_rec_handler(ir_unit_t *iu, int op,
                         unsigned int argc, const int64_t *argv)
{
  unsigned int vid;
  char *str;
  switch(op) {
  case 1: // VST_CODE_ENTRY
    if(argc < 2)
      parser_error(iu, "Bad args to VST_CODE_ENTRY");

    vid = argv[0];
    str = read_str_from_argv(argc - 1, argv + 1);
    set_value_name(iu, vid, str);
    break;

  case 2: // VST_CODE_BBENTRY
    break;

  case 3: // VST_CODE_FNENTRY
    if(argc < 3)
      break;
    // cogbee
      // parser_error(iu, "Bad args to VST_CODE_FNENTRY");

    vid = argv[0];
    str = read_str_from_argv(argc - 2, argv + 2);
    set_value_name(iu, vid, str);
    break;

  default:
    parser_error(iu, "Unknown op %d in symtab\n", op);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x2c(%rbp)
subl $0x1, %eax
je 0x34fda
jmp 0x34fc3
movl -0x2c(%rbp), %eax
subl $0x2, %eax
je 0x35031
jmp 0x34fcd
movl -0x2c(%rbp), %eax
subl $0x3, %eax
je 0x35033
jmp 0x3506e
cmpl $0x2, -0x10(%rbp)
jae 0x34ffe
movq -0x8(%rbp), %rdi
leaq 0xb879(%rip), %rsi      # 0x40864
movl $0x1d6, %edx            # imm = 0x1D6
leaq 0xbf5a(%rip), %rcx      # 0x40f51
movb $0x0, %al
callq 0x18220
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl %eax, -0x1c(%rbp)
movl -0x10(%rbp), %edi
subl $0x1, %edi
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
callq 0x35860
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x28(%rbp), %rdx
callq 0x37eb0
jmp 0x35090
jmp 0x35090
cmpl $0x3, -0x10(%rbp)
jae 0x3503b
jmp 0x35090
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl %eax, -0x1c(%rbp)
movl -0x10(%rbp), %edi
subl $0x2, %edi
movq -0x18(%rbp), %rsi
addq $0x10, %rsi
callq 0x35860
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x28(%rbp), %rdx
callq 0x37eb0
jmp 0x35090
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %r8d
leaq 0xb7e7(%rip), %rsi      # 0x40864
movl $0x1ec, %edx            # imm = 0x1EC
leaq 0xbee3(%rip), %rcx      # 0x40f6c
movb $0x0, %al
callq 0x18220
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_bitcode_parser.c
// Function: strtab_rec_handler
static void strtab_rec_handler(ir_unit_t *iu, int op, 
                  unsigned int argc, const int64_t *argv) {

  // Set Function name.
  for(int i = 0; i < VECTOR_LEN(&iu->iu_functions); i++) {
    ir_function_t *f = VECTOR_ITEM(&iu->iu_functions, i);
    int str_offset = f->str_offset;
    int str_size = f->str_size;
    f->if_name = read_str_from_argv(str_size, argv + str_offset);
    // printf("f->f_name=%s\n", f->if_name);

    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);
      }
    }
  }

  // Set global variable name.
  for(int i = 0; i < VECTOR_LEN(&iu->iu_values); i++) {
    ir_value_t *iv = VECTOR_ITEM(&iu->iu_values, i);
    if(iv == NULL)
      continue;
    if (iv->iv_class == IR_VC_GLOBALVAR) {
      iv->iv_gvar->ig_name = read_str_from_argv(iv->iv_gvar->str_size, argv + iv->iv_gvar->str_offset);
      // printf("iv->iv_gvar->ig_name=%s\n", iv->iv_gvar->ig_name);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x2e0(%rcx), %rax
jae 0x3565e
movq -0x8(%rbp), %rax
movq 0x2d8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %edi
movq -0x18(%rbp), %rsi
movslq -0x2c(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
callq 0x35860
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x28(%rbp), %rax
cmpq $0x0, 0x70(%rax)
jne 0x3564e
movq -0x28(%rbp), %rdi
callq 0x1e640
cmpl $0x0, %eax
jne 0x3564c
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 0x3564e
jmp 0x35650
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x355ad
movl $0x0, -0x34(%rbp)
movslq -0x34(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x188(%rcx), %rax
jae 0x356e2
movq -0x8(%rbp), %rax
movq 0x180(%rax), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x35696
jmp 0x356d7
movq -0x40(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x356d5
movq -0x40(%rbp), %rax
movq 0x30(%rax), %rax
movl 0x18(%rax), %edi
movq -0x18(%rbp), %rsi
movq -0x40(%rbp), %rax
movq 0x30(%rax), %rax
movslq 0x14(%rax), %rax
shlq $0x3, %rax
addq %rax, %rsi
callq 0x35860
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq 0x30(%rax), %rax
movq %rcx, 0x20(%rax)
jmp 0x356d7
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x35665
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_value.c
// Function: eval_constexprs
static void
eval_constexprs(ir_unit_t *iu)
{
  for(int i = 0; i < iu->iu_next_value; i++) {
    ir_value_t *iv = VECTOR_ITEM(&iu->iu_values, i);
    if(iv->iv_class == IR_VC_CE)
      eval_constexpr(iu, iv, iv->iv_ce);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x198(%rcx), %eax
jge 0x35774
movq -0x8(%rbp), %rax
movq 0x180(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x8, (%rax)
jne 0x35767
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdx
callq 0x37f00
jmp 0x35769
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x35723
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_type.c
// Function: types_finalize
static void
types_finalize(ir_unit_t *iu)
{
  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_STRUCT && !it->it_struct.computed) {
      type_struct_layout(iu, it);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movslq -0xc(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x170(%rcx), %rax
jae 0x357eb
movq -0x8(%rbp), %rax
movq 0x168(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x357de
movq -0x18(%rbp), %rax
cmpb $0x0, 0x25(%rax)
jne 0x357de
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x38830
jmp 0x357e0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x35793
addq $0x20, %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_str_from_argv
static char *
read_str_from_argv(unsigned int argc, const int64_t *argv)
{
  char *r = malloc(argc + 1);
  r[argc] = 0;
  for(int i = 0; i < argc; i++)
    r[i] = argv[i];
  return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x3360
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl -0x4(%rbp), %ecx
movb $0x0, (%rax,%rcx)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jae 0x358c0
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movb %al, %dl
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x35894
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_bitcode_parser.c
// Function: module_alias
static void
module_alias(ir_unit_t *iu, unsigned int argc, const int64_t *argv)
{
  if(argc < 4)
    parser_error(iu, "Bad number of args");

  ir_value_t *iv = value_append_and_get(iu);
  iv->iv_class = IR_VC_ALIAS;
  iv->iv_type = argv[2];
  iv->iv_reg = argv[3];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
cmpl $0x4, -0xc(%rbp)
jae 0x35cf7
movq -0x8(%rbp), %rdi
leaq 0xab80(%rip), %rsi      # 0x40864
movl $0xc7, %edx
leaq 0xad01(%rip), %rcx      # 0x409f1
movb $0x0, %al
callq 0x18220
movq -0x8(%rbp), %rdi
callq 0x223d0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0xa, (%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x24(%rax)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x30(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_bitstream.c
// Function: printargs
static void
printargs(const int64_t *argv, unsigned int argc)
{
  int i, x;
  int64_t v;
  for(x = 0; x < 2; x++) {
    for(i = 0; i < argc; i++) {
      v = argv[i];
      if(x == 0) {
        printf("%c", (v >= ' ' && v <= 0x7f) ? (char)v : '.');
      } else {
        printf("<0x%" PRIx64 ">", v);
      }
    }
    printf("\n");
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x2, -0x14(%rbp)
jge 0x35e47
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x35e2b
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x35e0c
cmpq $0x20, -0x20(%rbp)
jl 0x35def
cmpq $0x7f, -0x20(%rbp)
jg 0x35def
movq -0x20(%rbp), %rax
movsbl %al, %eax
movl %eax, -0x24(%rbp)
jmp 0x35df9
movl $0x2e, %eax
movl %eax, -0x24(%rbp)
jmp 0x35df9
movl -0x24(%rbp), %esi
leaq 0xac01(%rip), %rdi      # 0x40a04
movb $0x0, %al
callq 0x3170
jmp 0x35e1e
movq -0x20(%rbp), %rsi
leaq 0xabf0(%rip), %rdi      # 0x40a07
movb $0x0, %al
callq 0x3170
jmp 0x35e20
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x35db7
leaq 0xbbbf(%rip), %rdi      # 0x419f1
movb $0x0, %al
callq 0x3170
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x35da6
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_support.c
// Function: vmir_llvm_alignment
static int
vmir_llvm_alignment(int align, int default_alignment)
{
  if(align == 0)
    return default_alignment;
  if(align > 9)
    return 256;
  return (1 << align) >> 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x35e68
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x35e86
cmpl $0x9, -0x8(%rbp)
jle 0x35e77
movl $0x100, -0x4(%rbp)      # imm = 0x100
jmp 0x35e86
movl -0x8(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
sarl %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_bitstream.c
// Function: read_zstr_from_argv
static char *
read_zstr_from_argv(unsigned int *argcp, const int64_t **argvp)
{
  int len = 0;
  const int64_t *argv = *argvp;
  int argc = *argcp;
  for(len = 0; len < argc; len++) {
    if(argv[len] == 0)
      break;
  }
  if(len == argc)
    return NULL;
  len++;
  char *s = malloc(len);

  *argvp = argv + len;
  *argcp = argc - len;


  for(len = 0; len < argc; len++) {
    s[len] = argv[len];
    if(argv[len] == 0)
      break;
  }
  return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x35ee8
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x35edb
jmp 0x35ee8
jmp 0x35edd
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x35ec2
movl -0x1c(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jne 0x35efd
movq $0x0, -0x8(%rbp)
jmp 0x35f83
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movslq -0x1c(%rbp), %rdi
callq 0x3360
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rcx
movslq -0x1c(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl -0x2c(%rbp), %ecx
subl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x35f7b
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movb %al, %dl
movq -0x38(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x35f6e
jmp 0x35f7b
jmp 0x35f70
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x35f3c
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_bitstream.c
// Function: read_sign_rotated
static int64_t
read_sign_rotated(const int64_t *argv)
{
  uint64_t u64 = *argv;
  if((u64 & 1) == 0)
    return u64 >> 1;
  if(u64 != 1)
    return -(u64 >> 1);
  return 1ULL << 63;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x35fbe
movq -0x18(%rbp), %rax
shrq %rax
movq %rax, -0x8(%rbp)
jmp 0x35fe5
cmpq $0x1, -0x18(%rbp)
je 0x35fd7
movq -0x18(%rbp), %rcx
shrq %rcx
xorl %eax, %eax
subq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x35fe5
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_bitcode_instr.c
// Function: parse_ret
static void
parse_ret(ir_unit_t *iu, unsigned int argc, const int64_t *argv)
{
  ir_bb_t *ib = iu->iu_current_bb;

  ir_instr_unary_t *i = instr_add(ib, sizeof(ir_instr_unary_t), IR_IC_RET);

  if(argc == 0) {
    i->value.value = -1;
  } else {
    i->value = instr_get_vtp(iu, &argc, &argv);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x1c8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl $0x68, %esi
movl $0x1, %edx
callq 0x20c10
movq %rax, -0x28(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x3609c
movq -0x28(%rbp), %rax
movl $0xffffffff, 0x58(%rax) # imm = 0xFFFFFFFF
jmp 0x360c8
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
leaq -0xc(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x37a40
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq %rcx, 0x58(%rax)
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_bitcode_instr.c
// Function: parse_binop
static void
parse_binop(ir_unit_t *iu, unsigned int argc, const int64_t *argv)
{
  ir_bb_t *ib = iu->iu_current_bb;

  ir_instr_binary_t *i = instr_add(ib, sizeof(ir_instr_binary_t), IR_IC_BINOP);
  i->lhs_value = instr_get_vtp(iu, &argc, &argv);
  i->rhs_value = instr_get_value(iu, &argc, &argv, i->lhs_value.type);
  i->op        = instr_get_uint(iu, &argc, &argv);

  value_alloc_instr_ret(iu, i->lhs_value.type, &i->super);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x1c8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl $0x70, %esi
movl $0x2, %edx
callq 0x20c10
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
leaq -0xc(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x37a40
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq %rcx, 0x5c(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movl 0x60(%rax), %ecx
leaq -0xc(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x37c50
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x38(%rbp)
movq -0x38(%rbp), %rcx
movq %rcx, 0x64(%rax)
movq -0x8(%rbp), %rdi
leaq -0xc(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x37cf0
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x58(%rax)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movl 0x60(%rax), %esi
movq -0x28(%rbp), %rdx
callq 0x22410
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_bitcode_instr.c
// Function: parse_cast
static void
parse_cast(ir_unit_t *iu, unsigned int argc, const int64_t *argv)
{
  ir_bb_t *ib = iu->iu_current_bb;

  ir_instr_unary_t *i = instr_add(ib, sizeof(ir_instr_unary_t), IR_IC_CAST);
  i->value = instr_get_vtp(iu, &argc, &argv);
  int type = instr_get_uint(iu, &argc, &argv);
  i->op    = instr_get_uint(iu, &argc, &argv);
  value_alloc_instr_ret(iu, type, &i->super);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x1c8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl $0x68, %esi
movl $0x3, %edx
callq 0x20c10
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
leaq -0xc(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x37a40
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq %rcx, 0x58(%rax)
movq -0x8(%rbp), %rdi
leaq -0xc(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x37cf0
movl %eax, -0x34(%rbp)
movq -0x8(%rbp), %rdi
leaq -0xc(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x37cf0
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x60(%rax)
movq -0x8(%rbp), %rdi
movl -0x34(%rbp), %esi
movq -0x28(%rbp), %rdx
callq 0x22410
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_bitcode_instr.c
// Function: parse_load
static void
parse_load(ir_unit_t *iu, unsigned int argc, const int64_t *argv)
{
  ir_bb_t *ib = iu->iu_current_bb;

  ir_instr_load_t *i = instr_add(ib, sizeof(ir_instr_load_t), IR_IC_LOAD);
  i->immediate_offset = 0;
  i->ptr = instr_get_vtp(iu, &argc, &argv);
  i->value_offset.value = -1;
  i->value_offset_multiply = 0;
  i->cast = -1;
  if(argc == 3) {
    // Explicit type
    value_alloc_instr_ret(iu, argv[0], &i->super);
  } else {
    value_alloc_instr_ret(iu, type_get_pointee(iu, i->ptr.type), &i->super);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x1c8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl $0x78, %esi
movl $0x4, %edx
callq 0x20c10
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl $0x0, 0x60(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
leaq -0xc(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x37a40
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq %rcx, 0x58(%rax)
movq -0x28(%rbp), %rax
movl $0xffffffff, 0x64(%rax) # imm = 0xFFFFFFFF
movq -0x28(%rbp), %rax
movl $0x0, 0x6c(%rax)
movq -0x28(%rbp), %rax
movb $-0x1, 0x74(%rax)
cmpl $0x3, -0xc(%rbp)
jne 0x362fc
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl %eax, %esi
movq -0x28(%rbp), %rdx
callq 0x22410
jmp 0x36323
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movl 0x5c(%rax), %esi
callq 0x291c0
movq -0x40(%rbp), %rdi
movl %eax, %esi
movq -0x28(%rbp), %rdx
callq 0x22410
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_bitcode_instr.c
// Function: parse_store
static void
parse_store(ir_unit_t *iu, unsigned int argc, const int64_t *argv,
            int old)
{
  ir_bb_t *ib = iu->iu_current_bb;

  ir_instr_store_t *i = instr_add(ib, sizeof(ir_instr_store_t), IR_IC_STORE);
  i->immediate_offset = 0;
  i->ptr   = instr_get_vtp(iu, &argc, &argv);
  if(old)
    i->value = instr_get_value(iu, &argc, &argv,
                               type_get_pointee(iu, i->ptr.type));
  else
    i->value = instr_get_vtp(iu, &argc, &argv);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x1c8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movl $0x70, %esi
movl $0x5, %edx
callq 0x20c10
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl $0x0, 0x68(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
leaq -0xc(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x37a40
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, -0x38(%rbp)
movq -0x38(%rbp), %rcx
movq %rcx, 0x58(%rax)
cmpl $0x0, -0x1c(%rbp)
je 0x363f1
movq -0x30(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rax
movl 0x5c(%rax), %esi
callq 0x291c0
movq -0x60(%rbp), %rdi
movl %eax, %ecx
leaq -0xc(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x37c50
movq %rax, %rcx
movq -0x58(%rbp), %rax
movq %rcx, -0x40(%rbp)
movq -0x40(%rbp), %rcx
movq %rcx, 0x60(%rax)
jmp 0x3641d
movq -0x30(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x8(%rbp), %rdi
leaq -0xc(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x37a40
movq %rax, %rcx
movq -0x68(%rbp), %rax
movq %rcx, -0x48(%rbp)
movq -0x48(%rbp), %rcx
movq %rcx, 0x60(%rax)
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_bitcode_instr.c
// Function: parse_cmp2
static void
parse_cmp2(ir_unit_t *iu, unsigned int argc, const int64_t *argv)
{
  ir_bb_t *ib = iu->iu_current_bb;

  ir_instr_binary_t *i = instr_add(ib, sizeof(ir_instr_binary_t), IR_IC_CMP2);
  i->lhs_value = instr_get_vtp(iu, &argc, &argv);
  i->rhs_value = instr_get_value(iu, &argc, &argv, i->lhs_value.type);
  i->op    = instr_get_uint(iu, &argc, &argv);
  value_alloc_instr_ret(iu, type_find_by_code(iu, IR_TYPE_INT1), &i->super);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x1c8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl $0x70, %esi
movl $0x7, %edx
callq 0x20c10
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
leaq -0xc(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x37a40
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq %rcx, 0x5c(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movl 0x60(%rax), %ecx
leaq -0xc(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x37c50
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, -0x38(%rbp)
movq -0x38(%rbp), %rcx
movq %rcx, 0x64(%rax)
movq -0x8(%rbp), %rdi
leaq -0xc(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x37cf0
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x58(%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x1f410
movq -0x40(%rbp), %rdi
movl %eax, %esi
movq -0x28(%rbp), %rdx
callq 0x22410
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_bitcode_instr.c
// Function: parse_br
static void
parse_br(ir_unit_t *iu, unsigned int argc, const int64_t *argv)
{
  ir_bb_t *ib = iu->iu_current_bb;

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

  i->true_branch = instr_get_uint(iu, &argc, &argv);

  if(argc == 0) {
    i->condition.value = -1;
  } else {
    i->false_branch = instr_get_uint(iu, &argc, &argv);
    i->condition = instr_get_value(iu, &argc, &argv,
                                   type_make(iu, IR_TYPE_INT1));
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x1c8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl $0x68, %esi
movl $0x8, %edx
callq 0x20c10
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
leaq -0xc(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x37cf0
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x60(%rax)
cmpl $0x0, -0xc(%rbp)
jne 0x36866
movq -0x28(%rbp), %rax
movl $0xffffffff, 0x58(%rax) # imm = 0xFFFFFFFF
jmp 0x368c4
movq -0x8(%rbp), %rdi
leaq -0xc(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x37cf0
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x64(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x281a0
movq -0x40(%rbp), %rdi
movl %eax, %ecx
leaq -0xc(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x37c50
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq %rcx, 0x58(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_bitcode_instr.c
// Function: parse_alloca
static void
parse_alloca(ir_unit_t *iu, unsigned int argc, const int64_t *argv)
{
  if(argc != 4)
    parser_error(iu, "Invalid number of args to alloca");

  int flags = argv[3];

  ir_bb_t *ib = iu->iu_current_bb;

  ir_instr_alloca_t *i =
    instr_add(ib, sizeof(ir_instr_alloca_t), IR_IC_ALLOCA);

  unsigned int rtype  = argv[0];

  if(flags & (1 << 6)) { // ExplicitType
    i->size = type_sizeof(iu, rtype);
    rtype = type_make_pointer(iu, rtype, 1);
  } else {
    unsigned int pointee = type_get_pointee(iu, rtype);
    i->size = type_sizeof(iu, pointee);
  }

  value_alloc_instr_ret(iu, rtype, &i->super);

  i->alignment = vmir_llvm_alignment(flags & 0x1f, 4);
  i->num_items_value.value = argv[2];
  i->num_items_value.type = argv[1];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
cmpl $0x4, -0xc(%rbp)
je 0x37357
movq -0x8(%rbp), %rdi
leaq 0x997b(%rip), %rsi      # 0x40cbf
movl $0x29f, %edx            # imm = 0x29F
leaq 0x9b93(%rip), %rcx      # 0x40ee3
movb $0x0, %al
callq 0x18220
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x1c8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movl $0x68, %esi
movl $0xd, %edx
callq 0x20c10
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl %eax, -0x34(%rbp)
movl -0x1c(%rbp), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x373c8
movq -0x8(%rbp), %rdi
movl -0x34(%rbp), %esi
callq 0x1ecd0
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x58(%rax)
movq -0x8(%rbp), %rdi
movl -0x34(%rbp), %esi
movl $0x1, %edx
callq 0x1e6e0
movl %eax, -0x34(%rbp)
jmp 0x373ec
movq -0x8(%rbp), %rdi
movl -0x34(%rbp), %esi
callq 0x291c0
movl %eax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movl -0x38(%rbp), %esi
callq 0x1ecd0
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x58(%rax)
movq -0x8(%rbp), %rdi
movl -0x34(%rbp), %esi
movq -0x30(%rbp), %rdx
callq 0x22410
movl -0x1c(%rbp), %edi
andl $0x1f, %edi
movl $0x4, %esi
callq 0x35e50
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x64(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x5c(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x60(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_bitcode_instr.c
// Function: parse_vselect
static void
parse_vselect(ir_unit_t *iu, unsigned int argc, const int64_t *argv)
{
  ir_bb_t *ib = iu->iu_current_bb;

  ir_instr_select_t *i = instr_add(ib, sizeof(ir_instr_select_t), IR_IC_SELECT);
  i->true_value  = instr_get_vtp(iu, &argc, &argv);
  i->false_value = instr_get_value(iu, &argc, &argv, i->true_value.type);
  i->pred        = instr_get_vtp(iu, &argc, &argv);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x1c8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl $0x70, %esi
movl $0xe, %edx
callq 0x20c10
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rdi
leaq -0xc(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x37a40
movq %rax, %rcx
movq -0x58(%rbp), %rax
movq %rcx, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq %rcx, 0x58(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movl 0x5c(%rax), %ecx
leaq -0xc(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x37c50
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, -0x38(%rbp)
movq -0x38(%rbp), %rcx
movq %rcx, 0x60(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
leaq -0xc(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x37a40
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, -0x40(%rbp)
movq -0x40(%rbp), %rcx
movq %rcx, 0x68(%rax)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movl 0x5c(%rax), %esi
movq -0x28(%rbp), %rdx
callq 0x22410
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_bitcode_instr.c
// Function: parse_vaarg
static void
parse_vaarg(ir_unit_t *iu, unsigned int argc, const int64_t *argv)
{
  ir_bb_t *ib = iu->iu_current_bb;

  ir_instr_unary_t *i = instr_add(ib, sizeof(ir_instr_unary_t), IR_IC_VAARG);
  int type = argv[0];
  argc--;
  argv++;
  i->value = instr_get_value(iu, &argc, &argv, type);
  int rtype = instr_get_uint(iu,  &argc, &argv);
  value_alloc_instr_ret(iu, rtype, &i->super);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x1c8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl $0x68, %esi
movl $0xf, %edx
callq 0x20c10
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl %eax, -0x2c(%rbp)
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movl -0x2c(%rbp), %ecx
leaq -0xc(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x37c50
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x34(%rbp)
movq -0x34(%rbp), %rcx
movq %rcx, 0x58(%rax)
movq -0x8(%rbp), %rdi
leaq -0xc(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x37cf0
movl %eax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movl -0x38(%rbp), %esi
movq -0x28(%rbp), %rdx
callq 0x22410
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_bitcode_instr.c
// Function: parse_landingpad
static void
parse_landingpad(ir_unit_t *iu, unsigned int argc, const int64_t *argv,
                 int old)
{
  ir_bb_t *ib = iu->iu_current_bb;

  unsigned int type = instr_get_uint(iu, &argc, &argv);

  if(old) {
    instr_get_vtp(iu, &argc, &argv);
  }
  unsigned int is_clean_up = instr_get_uint(iu, &argc, &argv);
  unsigned int num_clauses = instr_get_uint(iu, &argc, &argv);

  ir_instr_landingpad_t *i =
    instr_add(ib, sizeof(ir_instr_landingpad_t) +
              sizeof(ir_instr_landingpad_clause_t) * num_clauses,
              IR_IC_LANDINGPAD);

  i->type = type;
  //  i->personality = personality;
  i->is_clean_up = is_clean_up;
  i->num_clauses = num_clauses;

  for(int j = 0; j < num_clauses; j++) {
    i->clauses[j].clause = instr_get_uint(iu, &argc, &argv);
    i->clauses[j].is_catch = instr_get_uint(iu, &argc, &argv);
  }

  value_alloc_instr_ret(iu, i->type, &i->super);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x1c8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
leaq -0xc(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x37cf0
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x377f4
movq -0x8(%rbp), %rdi
leaq -0xc(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x37a40
movq %rax, -0x34(%rbp)
movq -0x8(%rbp), %rdi
leaq -0xc(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x37cf0
movl %eax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
leaq -0xc(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x37cf0
movl %eax, -0x3c(%rbp)
movq -0x28(%rbp), %rdi
movl -0x3c(%rbp), %eax
movl %eax, %esi
shlq $0x3, %rsi
addq $0x68, %rsi
movl $0x12, %edx
callq 0x20c10
movq %rax, -0x48(%rbp)
movl -0x2c(%rbp), %ecx
movq -0x48(%rbp), %rax
movl %ecx, 0x58(%rax)
movl -0x38(%rbp), %ecx
movq -0x48(%rbp), %rax
movl %ecx, 0x60(%rax)
movl -0x3c(%rbp), %ecx
movq -0x48(%rbp), %rax
movl %ecx, 0x64(%rax)
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
cmpl -0x3c(%rbp), %eax
jae 0x378b1
movq -0x8(%rbp), %rdi
leaq -0xc(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x37cf0
movl %eax, %edx
movq -0x48(%rbp), %rax
movslq -0x4c(%rbp), %rcx
movl %edx, 0x6c(%rax,%rcx,8)
movq -0x8(%rbp), %rdi
leaq -0xc(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x37cf0
movl %eax, %edx
movq -0x48(%rbp), %rax
movslq -0x4c(%rbp), %rcx
movl %edx, 0x68(%rax,%rcx,8)
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x37860
movq -0x8(%rbp), %rdi
movq -0x48(%rbp), %rax
movl 0x58(%rax), %esi
movq -0x48(%rbp), %rdx
callq 0x22410
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)