LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_bitcode_instr.c
// Function: parse_insertval
static void
parse_insertval(ir_unit_t *iu, unsigned int argc, const int64_t *argv)
{
  ir_bb_t *ib = iu->iu_current_bb;

  ir_valuetype_t src = instr_get_vtp(iu, &argc, &argv);
  ir_valuetype_t replacement = instr_get_vtp(iu, &argc, &argv);

  int num_indices = argc;

  ir_instr_insertval_t *i =
    instr_add(ib, sizeof(ir_instr_insertval_t) +
              sizeof(int) * num_indices, IR_IC_INSERTVAL);

  i->src = src;
  i->replacement = replacement;
  i->num_indicies = num_indices;

  for(int j = 0; j < num_indices; j++) {
    i->indicies[j] = instr_get_uint(iu, &argc, &argv);
  }

  value_alloc_instr_ret(iu, i->src.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 -0x8(%rbp), %rdi
leaq -0xc(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x37a40
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
leaq -0xc(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x37a40
movq %rax, -0x30(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x34(%rbp), %rsi
shlq $0x2, %rsi
addq $0x70, %rsi
movl $0x11, %edx
callq 0x20c10
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x58(%rax)
movq -0x40(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0x60(%rax)
movl -0x34(%rbp), %ecx
movq -0x40(%rbp), %rax
movl %ecx, 0x68(%rax)
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x34(%rbp), %eax
jge 0x3799b
movq -0x8(%rbp), %rdi
leaq -0xc(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x37cf0
movl %eax, %edx
movq -0x40(%rbp), %rax
movslq -0x44(%rbp), %rcx
movl %edx, 0x6c(%rax,%rcx,4)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x37969
movq -0x8(%rbp), %rdi
movq -0x40(%rbp), %rax
movl 0x5c(%rax), %esi
movq -0x40(%rbp), %rdx
callq 0x22410
addq $0x50, %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_resume
static void
parse_resume(ir_unit_t *iu, unsigned int argc, const int64_t *argv)
{
  ir_bb_t *ib = iu->iu_current_bb;

  ir_instr_resume_t *i =
    instr_add(ib, sizeof(ir_instr_resume_t) + MAX_RESUME_VALUES * sizeof(ir_valuetype_t), IR_IC_RESUME);

  i->values[0] = instr_get_vtp(iu, &argc, &argv);
  i->num_values = 1;
}

// 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 $0xa0, %esi
movl $0x13, %edx
callq 0x20c10
movq %rax, -0x28(%rbp)
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, 0x5c(%rax)
movq -0x28(%rbp), %rax
movl $0x1, 0x58(%rax)
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: instr_get_value
static ir_valuetype_t
instr_get_value(ir_unit_t *iu, unsigned int *argcp, const int64_t **argvp,
                int type)
{
  const int64_t *argv = *argvp;
  int argc = *argcp;

  if(argc < 1)
    parser_error(iu, "Missing value code");

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

  int val = iu->iu_next_value - argv[0];
  ir_valuetype_t r = {.type = type, .value = val};
  return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x34(%rbp)
cmpl $0x1, -0x34(%rbp)
jge 0x37c9f
movq -0x10(%rbp), %rdi
leaq 0x9033(%rip), %rsi      # 0x40cbf
movl $0x3c, %edx
leaq 0x90c4(%rip), %rcx      # 0x40d5c
movb $0x0, %al
callq 0x18220
movq -0x30(%rbp), %rcx
addq $0x8, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl -0x34(%rbp), %ecx
subl $0x1, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movslq 0x198(%rax), %rax
movq -0x30(%rbp), %rcx
subq (%rcx), %rax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movq -0x8(%rbp), %rax
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: instr_get_uint
static unsigned int
instr_get_uint(ir_unit_t *iu, unsigned int *argcp, const int64_t **argvp)
{
  const int64_t *argv = *argvp;
  int argc = *argcp;

  if(argc < 1)
    parser_error(iu, "Missing argument");

  *argvp = argv + 1;
  *argcp = argc - 1;
  return argv[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), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
cmpl $0x1, -0x24(%rbp)
jge 0x37d3c
movq -0x8(%rbp), %rdi
leaq 0x8f96(%rip), %rsi      # 0x40cbf
movl $0x69, %edx
leaq 0x903a(%rip), %rcx      # 0x40d6f
movb $0x0, %al
callq 0x18220
movq -0x20(%rbp), %rcx
addq $0x8, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl -0x24(%rbp), %ecx
subl $0x1, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rax
addq $0x30, %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: instr_get_value_signed
static ir_valuetype_t
instr_get_value_signed(ir_unit_t *iu,
                       unsigned int *argcp, const int64_t **argvp,
                       int type)
{
  const int64_t *argv = *argvp;
  int argc = *argcp;

  if(argc < 1)
    parser_error(iu, "Missing value code");

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

  int val = iu->iu_next_value - read_sign_rotated(argv);

  ir_valuetype_t r = {.type = type, .value = val};
  return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x34(%rbp)
cmpl $0x1, -0x34(%rbp)
jge 0x37dbf
movq -0x10(%rbp), %rdi
leaq 0x8f13(%rip), %rsi      # 0x40cbf
movl $0x53, %edx
leaq 0x8fa4(%rip), %rcx      # 0x40d5c
movb $0x0, %al
callq 0x18220
movq -0x30(%rbp), %rcx
addq $0x8, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl -0x34(%rbp), %ecx
subl $0x1, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movslq 0x198(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
callq 0x35f90
movq %rax, %rcx
movq -0x40(%rbp), %rax
subq %rcx, %rax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movq -0x8(%rbp), %rax
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: switch_sort64
static int
switch_sort64(const void *A, const void *B)
{
  const ir_instr_path_t *a = (const ir_instr_path_t *)A;
  const ir_instr_path_t *b = (const ir_instr_path_t *)B;
  if(a->v64 > b->v64)
    return 1;
  if(a->v64 < b->v64)
    return -1;
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
cmpq (%rcx), %rax
jbe 0x37e85
movl $0x1, -0x4(%rbp)
jmp 0x37ea5
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x37e9e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x37ea5
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_type.c
// Function: type_struct_layout
static void
type_struct_layout(ir_unit_t *iu, ir_type_t *it)
{
  int offset = 0;
  int ba = 1; // Biggest alignment
  const int packed = it->it_struct.packed;

  for(int i = 0; i < it->it_struct.num_elements; i++) {
    ir_type_t *ty = type_get(iu, it->it_struct.elements[i].type);

    if(ty->it_code == IR_TYPE_STRUCT && !ty->it_struct.computed)
      type_struct_layout(iu, ty);

    int s = type_sizeof_ptr(iu, ty);

    if(!packed) {
      int a = type_alignment_ptr(iu, ty);
      offset = VMIR_ALIGN(offset, a);
      ba = VMIR_MAX(ba, a);
    }
    it->it_struct.elements[i].offset = offset;
    offset += s;
  }
  it->it_struct.size = packed ? offset : VMIR_ALIGN(offset, ba);
  it->it_struct.alignment = ba;
  it->it_struct.computed = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x1, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsbl 0x24(%rax), %eax
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jge 0x3892f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x20(%rbp), %rcx
movl (%rax,%rcx,8), %esi
callq 0x1ee20
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x388ac
movq -0x28(%rbp), %rax
cmpb $0x0, 0x25(%rax)
jne 0x388ac
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x38830
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x1ee80
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x38905
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x1ed10
movl %eax, -0x30(%rbp)
movl -0x14(%rbp), %eax
addl -0x30(%rbp), %eax
subl $0x1, %eax
movl -0x30(%rbp), %ecx
subl $0x1, %ecx
xorl $-0x1, %ecx
andl %ecx, %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x30(%rbp), %eax
jle 0x388f9
movl -0x18(%rbp), %eax
movl %eax, -0x34(%rbp)
jmp 0x388ff
movl -0x30(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %edx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x20(%rbp), %rcx
movl %edx, 0x4(%rax,%rcx,8)
movl -0x2c(%rbp), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x38860
cmpl $0x0, -0x1c(%rbp)
je 0x3893d
movl -0x14(%rbp), %eax
movl %eax, -0x38(%rbp)
jmp 0x38954
movl -0x14(%rbp), %eax
addl -0x18(%rbp), %eax
subl $0x1, %eax
movl -0x18(%rbp), %ecx
subl $0x1, %ecx
xorl $-0x1, %ecx
andl %ecx, %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x1c(%rax)
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x10(%rbp), %rax
movb $0x1, 0x25(%rax)
addq $0x40, %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_vbr64
static uint64_t
read_vbr64(bcbitstream_t *bs, int width)
{
  assert(width > 0);

  uint64_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 |= (uint64_t)(x & mask) << stride;
    if(cont & x) {
      stride += width - 1;
      assert(stride < 64);
    } else {
      break;
    }
  }
  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0x38997
jmp 0x389b6
leaq 0x7f7f(%rip), %rdi      # 0x4091d
leaq 0x7f82(%rip), %rsi      # 0x40927
movl $0x6b, %edx
leaq 0x8854(%rip), %rcx      # 0x41205
callq 0x31c0
movq $0x0, -0x18(%rbp)
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x17a80
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
andl -0x20(%rbp), %eax
movl %eax, %eax
movl -0x24(%rbp), %ecx
shlq %cl, %rax
orq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
andl -0x28(%rbp), %eax
cmpl $0x0, %eax
je 0x38a43
movl -0xc(%rbp), %eax
subl $0x1, %eax
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
cmpl $0x40, -0x24(%rbp)
jge 0x38a22
jmp 0x38a41
leaq 0x8806(%rip), %rdi      # 0x4122f
leaq 0x7ef7(%rip), %rsi      # 0x40927
movl $0x77, %edx
leaq 0x87c9(%rip), %rcx      # 0x41205
callq 0x31c0
jmp 0x38a45
jmp 0x38a47
jmp 0x389de
movq -0x18(%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_bitcode_parser.c
// Function: load_array
static void
load_array(bcbitstream_t *bs, ir_unit_t *iu, const ir_abbrev_operand_t *type)
{
  const int arraysize = read_vbr(bs, 6);
  for(int i = 0; i < arraysize; i++) {

    int64_t a;

    switch(type->iao_type) {
    case IAOT_FIXED_WIDTH:
      a = read_bits(bs, type->iao_data);
      break;
    case IAOT_VBR:
      a = read_vbr(bs, type->iao_data);
      break;
    case IAOT_CHAR6:
      a = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
        "0123456789._"[read_bits(bs, 6)];
      break;
    default:
      parser_error(iu, "Bad array type %d\n", type->iao_type);
    }
    VECTOR_PUSH_BACK(&iu->iu_argv, a);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x6, %esi
callq 0x33b80
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x38be0
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
subl $0x1, %eax
je 0x38abc
jmp 0x38aa8
movl -0x3c(%rbp), %eax
subl $0x2, %eax
je 0x38ad4
jmp 0x38ab2
movl -0x3c(%rbp), %eax
subl $0x4, %eax
je 0x38aec
jmp 0x38b10
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x17a80
movl %eax, %eax
movq %rax, -0x28(%rbp)
jmp 0x38b35
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x33b80
movl %eax, %eax
movq %rax, -0x28(%rbp)
jmp 0x38b35
movq -0x8(%rbp), %rdi
movl $0x6, %esi
callq 0x17a80
movl %eax, %eax
movl %eax, %ecx
leaq 0x87f2(%rip), %rax      # 0x412f7
movsbq (%rax,%rcx), %rax
movq %rax, -0x28(%rbp)
jmp 0x38b35
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %r8d
leaq 0x7d42(%rip), %rsi      # 0x40864
movl $0x447, %edx            # imm = 0x447
leaq 0x880a(%rip), %rcx      # 0x41338
movb $0x0, %al
callq 0x18220
jmp 0x38b37
movq -0x10(%rbp), %rax
movq 0x458(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq -0x10(%rbp), %rcx
cmpq 0x460(%rcx), %rax
jbe 0x38ba6
movq -0x30(%rbp), %rcx
addq $0x1, %rcx
shlq %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x460(%rax)
movq -0x10(%rbp), %rax
movq 0x460(%rax), %rax
shlq $0x3, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x450(%rax), %rdi
movq -0x38(%rbp), %rsi
callq 0x3390
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x450(%rax)
movq -0x30(%rbp), %rcx
addq $0x1, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x458(%rax)
movq -0x28(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x450(%rax), %rax
movq -0x30(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x38bd2
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x38a8c
addq $0x40, %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: load_blob
static void
load_blob(bcbitstream_t *bs, ir_unit_t *iu)
{
  const int blobsize = read_vbr(bs, 6);
  align_bits32(bs);
  for(int i = 0; i < blobsize; i++) {
    int64_t a;
    a = read_bits(bs, 8);
    VECTOR_PUSH_BACK(&iu->iu_argv, a);
  }
  int tailpad = VMIR_ALIGN(blobsize, 4) - blobsize;
  read_bits(bs, tailpad * 8);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x6, %esi
callq 0x33b80
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x33b50
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x38cea
movq -0x8(%rbp), %rdi
movl $0x8, %esi
callq 0x17a80
movl %eax, %eax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x458(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq -0x10(%rbp), %rcx
cmpq 0x460(%rcx), %rax
jbe 0x38cb0
movq -0x28(%rbp), %rcx
addq $0x1, %rcx
shlq %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x460(%rax)
movq -0x10(%rbp), %rax
movq 0x460(%rax), %rax
shlq $0x3, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x450(%rax), %rdi
movq -0x30(%rbp), %rsi
callq 0x3390
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x450(%rax)
movq -0x28(%rbp), %rcx
addq $0x1, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x458(%rax)
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x450(%rax), %rax
movq -0x28(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x38cdc
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x38c21
movl -0x14(%rbp), %eax
addl $0x4, %eax
subl $0x1, %eax
andl $-0x4, %eax
subl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x8(%rbp), %rdi
movl -0x34(%rbp), %esi
shll $0x3, %esi
callq 0x17a80
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_sysio_open
static vmir_errcode_t
vmir_sysio_open(void *opaque, const char *path, vmir_openflags_t flags,
                intptr_t *fh)
{
  int fs = O_CLOEXEC;
  fs |= flags & VMIR_FS_OPEN_CREATE ? O_CREAT  : 0;
  fs |= flags & VMIR_FS_OPEN_TRUNC  ? O_TRUNC  : 0;
  fs |= flags & VMIR_FS_OPEN_APPEND ? O_APPEND : 0;

  if((flags & (VMIR_FS_OPEN_READ | VMIR_FS_OPEN_WRITE)) ==
     (VMIR_FS_OPEN_READ | VMIR_FS_OPEN_WRITE))
    fs |= O_RDWR;
  else if(flags & VMIR_FS_OPEN_READ)
    fs |= O_RDONLY;
  else if(flags & VMIR_FS_OPEN_WRITE)
    fs |= O_WRONLY;
  else
    return VMIR_ERR_INVALID_ARGS;

  int fd = open(path, fs, 0644);
  if(fd == -1) {
    return VMIR_ERR_FS_ERROR;
  }
  *fh = fd;
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl $0x80000, -0x2c(%rbp)   # imm = 0x80000
movl -0x1c(%rbp), %edx
andl $0x4, %edx
xorl %eax, %eax
movl $0x40, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
orl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x1c(%rbp), %edx
andl $0x8, %edx
xorl %eax, %eax
movl $0x200, %ecx            # imm = 0x200
cmpl $0x0, %edx
cmovnel %ecx, %eax
orl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x1c(%rbp), %edx
andl $0x10, %edx
xorl %eax, %eax
movl $0x400, %ecx            # imm = 0x400
cmpl $0x0, %edx
cmovnel %ecx, %eax
orl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x1c(%rbp), %eax
andl $0x3, %eax
cmpl $0x3, %eax
jne 0x3924f
movl -0x2c(%rbp), %eax
orl $0x2, %eax
movl %eax, -0x2c(%rbp)
jmp 0x39288
movl -0x1c(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x39265
movl -0x2c(%rbp), %eax
orl $0x0, %eax
movl %eax, -0x2c(%rbp)
jmp 0x39286
movl -0x1c(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x3927b
movl -0x2c(%rbp), %eax
orl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x39284
movl $0xfffffffd, -0x4(%rbp) # imm = 0xFFFFFFFD
jmp 0x392bf
jmp 0x39286
jmp 0x39288
movq -0x18(%rbp), %rdi
movl -0x2c(%rbp), %esi
movl $0x1a4, %edx            # imm = 0x1A4
movb $0x0, %al
callq 0x33e0
movl %eax, -0x30(%rbp)
cmpl $-0x1, -0x30(%rbp)
jne 0x392ad
movl $0xfffffffc, -0x4(%rbp) # imm = 0xFFFFFFFC
jmp 0x392bf
movslq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
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.c
// Function: find_globalvar
static const ir_globalvar_t *
find_globalvar(ir_unit_t *iu, const char *name)
{
  for(int i = 0; i < iu->iu_next_value; i++) {
    ir_value_t *iv = value_get(iu, i);
    if(iv->iv_class != IR_VC_GLOBALVAR)
      continue;
    ir_globalvar_t *ig = iv->iv_gvar;
    if(ig->ig_name != NULL && !strcmp(ig->ig_name, name))
      return ig;
  }
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x198(%rcx), %eax
jge 0x39435
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x20ee0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x2, (%rax)
je 0x393f1
jmp 0x3942a
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x39428
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x32d0
cmpl $0x0, %eax
jne 0x39428
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3943d
jmp 0x3942a
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x393c7
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/tlsf/tlsf.c
// Function: tlsf_walk_heap
void tlsf_walk_heap(tlsf_pool pool, tlsf_walker walker, void* user)
{
	tlsf_walker heap_walker = walker ? walker : default_walker;
	block_header_t* block =
		offset_to_block(pool, sizeof(pool_t) - block_header_overhead);

	while (block && !block_is_last(block))
	{
		heap_walker(
			block_to_ptr(block),
			block_size(block),
			!block_is_free(block),
			user);
		block = block_next(block);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x39915
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x39922
leaq 0x3b4(%rip), %rax       # 0x39cd0
movq %rax, -0x30(%rbp)
jmp 0x39922
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1980, %esi           # imm = 0x1980
callq 0x39d40
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x28(%rbp)
movb %al, -0x31(%rbp)
je 0x3995c
movq -0x28(%rbp), %rdi
callq 0x39d60
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x39965
jmp 0x399c5
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rdi
callq 0x39d90
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rdi
callq 0x39c30
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rdi
callq 0x39b80
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movl %eax, %ecx
movq -0x40(%rbp), %rax
cmpl $0x0, %ecx
setne %cl
xorb $-0x1, %cl
andb $0x1, %cl
movzbl %cl, %edx
movq -0x18(%rbp), %rcx
callq *%rax
movq -0x28(%rbp), %rdi
callq 0x39bc0
movq %rax, -0x28(%rbp)
jmp 0x3993c
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/tlsf/tlsf.c
// Function: block_next
static block_header_t* block_next(const block_header_t* block)
{
	block_header_t* next = offset_to_block(block_to_ptr(block),
		block_size(block) - block_header_overhead);
	tlsf_assert(!block_is_last(block));
	return next;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x39d90
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x39c30
movq -0x18(%rbp), %rdi
movq %rax, %rsi
subq $0x8, %rsi
callq 0x39d40
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x39d60
cmpl $0x0, %eax
jne 0x39c06
jmp 0x39c25
leaq 0x7d87(%rip), %rdi      # 0x41994
leaq 0x78f7(%rip), %rsi      # 0x4150b
movl $0xf8, %edx
leaq 0x7d8a(%rip), %rcx      # 0x419aa
callq 0x31c0
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/tlsf/tlsf.c
// Function: mapping_insert
static void mapping_insert(size_t size, int* fli, int* sli)
{
	int fl, sl;
	if (size < SMALL_BLOCK_SIZE)
	{
		/* Store small blocks in first list. */
		fl = 0;
		sl = tlsf_cast(int, size) / (SMALL_BLOCK_SIZE / SL_INDEX_COUNT);
	}
	else
	{
		fl = tlsf_fls_sizet(size);
		sl = tlsf_cast(int, size >> (fl - SL_INDEX_COUNT_LOG2)) ^ (1 << SL_INDEX_COUNT_LOG2);
		fl -= (FL_INDEX_SHIFT - 1);
	}
	*fli = fl;
	*sli = sl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x100, -0x8(%rbp)      # imm = 0x100
jae 0x39c86
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl $0x8, %ecx
cltd
idivl %ecx
movl %eax, -0x20(%rbp)
jmp 0x39cb0
movq -0x8(%rbp), %rdi
callq 0x3aaa0
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
subl $0x5, %ecx
movl %ecx, %ecx
shrq %cl, %rax
xorl $0x20, %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
subl $0x7, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x20(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/tlsf/tlsf.c
// Function: tlsf_block_size
size_t tlsf_block_size(void* ptr)
{
	size_t size = 0;
	if (ptr)
	{
		const block_header_t* block = block_from_ptr(ptr);
		size = block_size(block);
	}
	return size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x39de5
movq -0x8(%rbp), %rdi
callq 0x39df0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x39c30
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/tlsf/tlsf.c
// Function: pool_construct
static void pool_construct(pool_t* pool)
{
	int i, j;

	pool->block_null.next_free = &pool->block_null;
	pool->block_null.prev_free = &pool->block_null;

	pool->fl_bitmap = 0;
	for (i = 0; i < FL_INDEX_COUNT; ++i)
	{
		pool->sl_bitmap[i] = 0;
		for (j = 0; j < SL_INDEX_COUNT; ++j)
		{
			pool->blocks[i][j] = &pool->block_null;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x20(%rax)
movl $0x0, -0xc(%rbp)
cmpl $0x19, -0xc(%rbp)
jge 0x3a02e
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl $0x0, 0x24(%rax,%rcx,4)
movl $0x0, -0x10(%rbp)
cmpl $0x20, -0x10(%rbp)
jge 0x3a021
movq -0x8(%rbp), %rdx
movq -0x8(%rbp), %rax
addq $0x88, %rax
movslq -0xc(%rbp), %rcx
shlq $0x8, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x39fef
jmp 0x3a023
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x39fd2
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/tlsf/tlsf.c
// Function: tlsf_malloc
void* tlsf_malloc(tlsf_pool tlsf, size_t size)
{
	pool_t* pool = tlsf_cast(pool_t*, tlsf);
	const size_t adjust = adjust_request_size(size, ALIGN_SIZE);
	block_header_t* block = block_locate_free(pool, adjust);
	return block_prepare_used(pool, block, adjust);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x8, %esi
callq 0x3a1e0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3a250
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x3a300
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/tlsf/tlsf.c
// Function: adjust_request_size
static size_t adjust_request_size(size_t size, size_t align)
{
	size_t adjust = 0;
	if (size && size < block_size_max)
	{
		const size_t aligned = align_up(size, align);
		adjust = tlsf_max(aligned, block_size_min);
	}
	return adjust;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3a244
movabsq $0x100000000, %rax      # imm = 0x100000000
cmpq %rax, -0x8(%rbp)
jae 0x3a244
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3aca0
movq %rax, -0x20(%rbp)
cmpq $0x18, -0x20(%rbp)
jbe 0x3a231
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x3a23c
movl $0x18, %eax
movq %rax, -0x28(%rbp)
jmp 0x3a23c
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/tlsf/tlsf.c
// Function: block_locate_free
static block_header_t* block_locate_free(pool_t* pool, size_t size)
{
	int fl = 0, sl = 0;
	block_header_t* block = 0;

	if (size)
	{
		mapping_search(size, &fl, &sl);
		block = search_suitable_block(pool, &fl, &sl);
	}

	if (block)
	{
		tlsf_assert(block_size(block) >= size);
		remove_free_block(pool, block, fl, sl);
	}

	return block;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3a2a3
movq -0x10(%rbp), %rdi
leaq -0x14(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x3ad20
movq -0x8(%rbp), %rdi
leaq -0x14(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x3ad80
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x3a2ed
movq -0x20(%rbp), %rdi
callq 0x39c30
cmpq -0x10(%rbp), %rax
jb 0x3a2bb
jmp 0x3a2da
leaq 0x7926(%rip), %rdi      # 0x41be8
leaq 0x7242(%rip), %rsi      # 0x4150b
movl $0x238, %edx            # imm = 0x238
leaq 0x792d(%rip), %rcx      # 0x41c02
callq 0x31c0
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
callq 0x3ae90
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/tlsf/tlsf.c
// Function: block_prepare_used
static void* block_prepare_used(pool_t* pool, block_header_t* block, size_t size)
{
	void* p = 0;
	if (block)
	{
		block_trim_free(pool, block, size);
		block_mark_as_used(block);
		p = block_to_ptr(block);
	}
	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3a34a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3b000
movq -0x10(%rbp), %rdi
callq 0x3a9b0
movq -0x10(%rbp), %rdi
callq 0x39d90
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/tlsf/tlsf.c
// Function: align_ptr
static void* align_ptr(const void* ptr, size_t align)
{
	const tlsfptr_t aligned =
		(tlsf_cast(tlsfptr_t, ptr) + (align - 1)) & ~(align - 1);
	tlsf_assert(0 == (align & (align - 1)) && "must align to a power of two");
	return tlsf_cast(void*, aligned);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
subq $0x1, %rcx
addq %rcx, %rax
movq -0x10(%rbp), %rcx
subq $0x1, %rcx
xorq $-0x1, %rcx
andq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x10(%rbp), %rax
subq $0x1, %rax
andq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
jne 0x3a552
movb $0x1, %al
testb $0x1, %al
jne 0x3a550
jmp 0x3a552
jmp 0x3a571
leaq 0x74b7(%rip), %rdi      # 0x41a10
leaq 0x6fab(%rip), %rsi      # 0x4150b
movl $0x123, %edx            # imm = 0x123
leaq 0x7a30(%rip), %rcx      # 0x41f9c
callq 0x31c0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/tlsf/tlsf.c
// Function: block_trim_free_leading
static block_header_t* block_trim_free_leading(pool_t* pool, block_header_t* block, size_t size)
{
	block_header_t* remaining_block = block;
	if (block_can_split(block, size))
	{
		/* We want the 2nd block. */
		remaining_block = block_split(block, size - block_header_overhead);
		block_set_prev_free(remaining_block);

		block_link_next(block);
		block_insert(pool, block);
	}

	return remaining_block;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3b0a0
cmpl $0x0, %eax
je 0x3a5e2
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
subq $0x8, %rsi
callq 0x3b0e0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3a150
movq -0x10(%rbp), %rdi
callq 0x3a100
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3a0b0
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/tlsf/tlsf.c
// Function: tlsf_free
void tlsf_free(tlsf_pool tlsf, void* ptr)
{
	/* Don't attempt to free a NULL pointer. */
	if (ptr)
	{
		pool_t* pool = tlsf_cast(pool_t*, tlsf);
		block_header_t* block = block_from_ptr(ptr);
		block_mark_as_free(block);
		block = block_merge_prev(pool, block);
		block = block_merge_next(pool, block);
		block_insert(pool, block);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3a654
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x39df0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3a660
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3a6a0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3a760
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3a0b0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/tlsf/tlsf.c
// Function: block_merge_prev
static block_header_t* block_merge_prev(pool_t* pool, block_header_t* block)
{
	if (block_is_prev_free(block))
	{
		block_header_t* prev = block_prev(block);
		tlsf_assert(prev && "prev physical block can't be null");
		tlsf_assert(block_is_free(prev) && "prev block is not free though marked as such");
		block_remove(pool, prev);
		block = block_absorb(prev, block);
	}

	return block;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x39ba0
cmpl $0x0, %eax
je 0x3a754
movq -0x10(%rbp), %rdi
callq 0x3b220
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x3a6e0
movb $0x1, %al
testb $0x1, %al
jne 0x3a6de
jmp 0x3a6e0
jmp 0x3a6ff
leaq 0x78fd(%rip), %rdi      # 0x41fe4
leaq 0x6e1d(%rip), %rsi      # 0x4150b
movl $0x1e6, %edx            # imm = 0x1E6
leaq 0x7916(%rip), %rcx      # 0x42010
callq 0x31c0
movq -0x18(%rbp), %rdi
callq 0x39b80
cmpl $0x0, %eax
je 0x3a717
movb $0x1, %al
testb $0x1, %al
jne 0x3a715
jmp 0x3a717
jmp 0x3a736
leaq 0x795c(%rip), %rdi      # 0x4207a
leaq 0x6de6(%rip), %rsi      # 0x4150b
movl $0x1e7, %edx            # imm = 0x1E7
leaq 0x78df(%rip), %rcx      # 0x42010
callq 0x31c0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3b240
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3b290
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/tlsf/tlsf.c
// Function: block_merge_next
static block_header_t* block_merge_next(pool_t* pool, block_header_t* block)
{
	block_header_t* next = block_next(block);
	tlsf_assert(next && "next physical block can't be null");

	if (block_is_free(next))
	{
		tlsf_assert(!block_is_last(block) && "previous block can't be last!");
		block_remove(pool, next);
		block = block_absorb(block, next);
	}

	return block;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x39bc0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x3a78e
movb $0x1, %al
testb $0x1, %al
jne 0x3a78c
jmp 0x3a78e
jmp 0x3a7ad
leaq 0x79e4(%rip), %rdi      # 0x42179
leaq 0x6d6f(%rip), %rsi      # 0x4150b
movl $0x1f3, %edx            # imm = 0x1F3
leaq 0x79fd(%rip), %rcx      # 0x421a5
callq 0x31c0
movq -0x18(%rbp), %rdi
callq 0x39b80
cmpl $0x0, %eax
je 0x3a810
movq -0x10(%rbp), %rdi
callq 0x39d60
cmpl $0x0, %eax
jne 0x3a7d3
movb $0x1, %al
testb $0x1, %al
jne 0x3a7d1
jmp 0x3a7d3
jmp 0x3a7f2
leaq 0x7a08(%rip), %rdi      # 0x421e2
leaq 0x6d2a(%rip), %rsi      # 0x4150b
movl $0x1f7, %edx            # imm = 0x1F7
leaq 0x79b8(%rip), %rcx      # 0x421a5
callq 0x31c0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3b240
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3b290
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/tlsf/tlsf.c
// Function: block_trim_used
static void block_trim_used(pool_t* pool, block_header_t* block, size_t size)
{
	tlsf_assert(!block_is_free(block) && "block must be used");
	if (block_can_split(block, size))
	{
		/* If the next block is free, we must coalesce. */
		block_header_t* remaining_block = block_split(block, size);
		block_set_prev_used(remaining_block);

		remaining_block = block_merge_next(pool, remaining_block);
		block_insert(pool, remaining_block);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x39b80
cmpl $0x0, %eax
jne 0x3aa1c
movb $0x1, %al
testb $0x1, %al
jne 0x3aa1a
jmp 0x3aa1c
jmp 0x3aa3b
leaq 0x780b(%rip), %rdi      # 0x4222e
leaq 0x6ae1(%rip), %rsi      # 0x4150b
movl $0x20f, %edx            # imm = 0x20F
leaq 0x7826(%rip), %rcx      # 0x4225c
callq 0x31c0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3b0a0
cmpl $0x0, %eax
je 0x3aa85
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3b0e0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3a090
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3a760
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3a0b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/tlsf/tlsfbits.h
// Function: tlsf_fls_sizet
tlsf_decl int tlsf_fls_sizet(size_t size)
{
	int high = (int)(size >> 32);
	int bits = 0;
	if (high)
	{
		bits = 32 + tlsf_fls(high);
	}
	else
	{
		bits = tlsf_fls((int)size & 0xffffffff);

	}
	return bits;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x20, %rax
movl %eax, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x3aad4
movl -0xc(%rbp), %edi
callq 0x3aaf0
addl $0x20, %eax
movl %eax, -0x10(%rbp)
jmp 0x3aae5
movq -0x8(%rbp), %rax
movl %eax, %edi
andl $-0x1, %edi
callq 0x3aaf0
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/tlsf/tlsf.c
// Function: insert_free_block
static void insert_free_block(pool_t* pool, block_header_t* block, int fl, int sl)
{
	block_header_t* current = pool->blocks[fl][sl];
	tlsf_assert(current && "free list cannot have a null entry");
	tlsf_assert(block && "cannot insert a null entry into the free list");
	block->next_free = current;
	block->prev_free = &pool->block_null;
	current->prev_free = block;

	tlsf_assert(block_to_ptr(block) == align_ptr(block_to_ptr(block), ALIGN_SIZE)
		&& "block not aligned properly");
	/*
	** Insert the new block at the head of the list, and mark the first-
	** and second-level bitmaps appropriately.
	*/
	pool->blocks[fl][sl] = block;
	pool->fl_bitmap |= (1 << fl);
	pool->sl_bitmap[fl] |= (1 << sl);
}

// 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 -0x8(%rbp), %rax
addq $0x88, %rax
movslq -0x14(%rbp), %rcx
shlq $0x8, %rcx
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x3ab78
movb $0x1, %al
testb $0x1, %al
jne 0x3ab76
jmp 0x3ab78
jmp 0x3ab97
leaq 0x6f13(%rip), %rdi      # 0x41a92
leaq 0x6985(%rip), %rsi      # 0x4150b
movl $0x19a, %edx            # imm = 0x19A
leaq 0x6f30(%rip), %rcx      # 0x41ac2
callq 0x31c0
cmpq $0x0, -0x10(%rbp)
je 0x3aba8
movb $0x1, %al
testb $0x1, %al
jne 0x3aba6
jmp 0x3aba8
jmp 0x3abc7
leaq 0x6f7e(%rip), %rdi      # 0x41b2d
leaq 0x6955(%rip), %rsi      # 0x4150b
movl $0x19b, %edx            # imm = 0x19B
leaq 0x6f00(%rip), %rcx      # 0x41ac2
callq 0x31c0
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rdi
callq 0x39d90
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x39d90
movq %rax, %rdi
movl $0x8, %esi
callq 0x3a500
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jne 0x3ac24
movb $0x1, %al
testb $0x1, %al
jne 0x3ac22
jmp 0x3ac24
jmp 0x3ac43
leaq 0x6f3b(%rip), %rdi      # 0x41b66
leaq 0x68d9(%rip), %rsi      # 0x4150b
movl $0x1a1, %edx            # imm = 0x1A1
leaq 0x6e84(%rip), %rcx      # 0x41ac2
callq 0x31c0
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
addq $0x88, %rax
movslq -0x14(%rbp), %rcx
shlq $0x8, %rcx
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
orl 0x20(%rax), %ecx
movl %ecx, 0x20(%rax)
movl -0x18(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
orl 0x24(%rax,%rcx,4), %edx
movl %edx, 0x24(%rax,%rcx,4)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/tlsf/tlsf.c
// Function: mapping_search
static void mapping_search(size_t size, int* fli, int* sli)
{
	if (size >= (1 << SL_INDEX_COUNT_LOG2))
	{
		const size_t round = (1 << (tlsf_fls_sizet(size) - SL_INDEX_COUNT_LOG2)) - 1;
		size += round;
	}
	mapping_insert(size, fli, sli);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x20, -0x8(%rbp)
jb 0x3ad65
movq -0x8(%rbp), %rdi
callq 0x3aaa0
movl %eax, %ecx
subl $0x5, %ecx
movl $0x1, %eax
shll %cl, %eax
subl $0x1, %eax
cltq
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x39c50
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/tlsf/tlsf.c
// Function: search_suitable_block
static block_header_t* search_suitable_block(pool_t* pool, int* fli, int* sli)
{
	int fl = *fli;
	int sl = *sli;

	/*
	** First, search for a block in the list associated with the given
	** fl/sl index.
	*/
	unsigned int sl_map = pool->sl_bitmap[fl] & (~0 << sl);
	if (!sl_map)
	{
		/* No block exists. Search in the next largest first-level list. */
		const unsigned int fl_map = pool->fl_bitmap & (~0 << (fl + 1));
		if (!fl_map)
		{
			/* No free blocks available, memory has been exhausted. */
			return 0;
		}

		fl = tlsf_ffs(fl_map);
		*fli = fl;
		sl_map = pool->sl_bitmap[fl];
	}
	tlsf_assert(sl_map && "internal error - second level bitmap is null");
	sl = tlsf_ffs(sl_map);
	*sli = sl;

	/* Return the first block in the free list. */
	return pool->blocks[fl][sl];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl 0x24(%rax,%rcx,4), %eax
movl -0x28(%rbp), %ecx
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0x3ae1a
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
movl -0x24(%rbp), %ecx
addl $0x1, %ecx
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x30(%rbp)
jne 0x3adf7
movq $0x0, -0x8(%rbp)
jmp 0x3ae7e
movl -0x30(%rbp), %edi
callq 0x3afe0
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl 0x24(%rax,%rcx,4), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x3ae2a
movb $0x1, %al
testb $0x1, %al
jne 0x3ae28
jmp 0x3ae2a
jmp 0x3ae49
leaq 0x6e32(%rip), %rdi      # 0x41c63
leaq 0x66d3(%rip), %rsi      # 0x4150b
movl $0x171, %edx            # imm = 0x171
leaq 0x6e58(%rip), %rcx      # 0x41c9c
callq 0x31c0
movl -0x2c(%rbp), %edi
callq 0x3afe0
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
addq $0x88, %rax
movslq -0x24(%rbp), %rcx
shlq $0x8, %rcx
addq %rcx, %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/tlsf/tlsf.c
// Function: remove_free_block
static void remove_free_block(pool_t* pool, block_header_t* block, int fl, int sl)
{
	block_header_t* prev = block->prev_free;
	block_header_t* next = block->next_free;
	tlsf_assert(prev && "prev_free field can not be null");
	tlsf_assert(next && "next_free field can not be null");
	next->prev_free = prev;
	prev->next_free = next;

	/* If this block is the head of the free list, set new head. */
	if (pool->blocks[fl][sl] == block)
	{
		pool->blocks[fl][sl] = next;

		/* If the new head is null, clear the bitmap. */
		if (next == &pool->block_null)
		{
			pool->sl_bitmap[fl] &= ~(1 << sl);

			/* If the second bitmap is now empty, clear the fl bitmap. */
			if (!pool->sl_bitmap[fl])
			{
				pool->fl_bitmap &= ~(1 << fl);
			}
		}
	}
}

// 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), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x3aecf
movb $0x1, %al
testb $0x1, %al
jne 0x3aecd
jmp 0x3aecf
jmp 0x3aeee
leaq 0x6e24(%rip), %rdi      # 0x41cfa
leaq 0x662e(%rip), %rsi      # 0x4150b
movl $0x17e, %edx            # imm = 0x17E
leaq 0x6e3b(%rip), %rcx      # 0x41d24
callq 0x31c0
cmpq $0x0, -0x28(%rbp)
je 0x3aeff
movb $0x1, %al
testb $0x1, %al
jne 0x3aefd
jmp 0x3aeff
jmp 0x3af1e
leaq 0x6e7b(%rip), %rdi      # 0x41d81
leaq 0x65fe(%rip), %rsi      # 0x4150b
movl $0x17f, %edx            # imm = 0x17F
leaq 0x6e0b(%rip), %rcx      # 0x41d24
callq 0x31c0
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
addq $0x88, %rax
movslq -0x14(%rbp), %rcx
shlq $0x8, %rcx
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x10(%rbp), %rax
jne 0x3afd0
movq -0x28(%rbp), %rdx
movq -0x8(%rbp), %rax
addq $0x88, %rax
movslq -0x14(%rbp), %rcx
shlq $0x8, %rcx
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x28(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x3afce
movl -0x18(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
xorl $-0x1, %edx
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
andl 0x24(%rax,%rcx,4), %edx
movl %edx, 0x24(%rax,%rcx,4)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpl $0x0, 0x24(%rax,%rcx,4)
jne 0x3afcc
movl -0x14(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, %ecx
xorl $-0x1, %ecx
movq -0x8(%rbp), %rax
andl 0x20(%rax), %ecx
movl %ecx, 0x20(%rax)
jmp 0x3afce
jmp 0x3afd0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/tlsf/tlsf.c
// Function: block_trim_free
static void block_trim_free(pool_t* pool, block_header_t* block, size_t size)
{
	tlsf_assert(block_is_free(block) && "block must be free");
	if (block_can_split(block, size))
	{
		block_header_t* remaining_block = block_split(block, size);
		block_link_next(block);
		block_set_prev_free(remaining_block);
		block_insert(pool, remaining_block);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x39b80
cmpl $0x0, %eax
je 0x3b02c
movb $0x1, %al
testb $0x1, %al
jne 0x3b02a
jmp 0x3b02c
jmp 0x3b04b
leaq 0x6d8b(%rip), %rdi      # 0x41dbe
leaq 0x64d1(%rip), %rsi      # 0x4150b
movl $0x202, %edx            # imm = 0x202
leaq 0x6da5(%rip), %rcx      # 0x41deb
callq 0x31c0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3b0a0
cmpl $0x0, %eax
je 0x3b08d
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3b0e0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3a100
movq -0x20(%rbp), %rdi
callq 0x3a150
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3a0b0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)