LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_transform.c
// Function: combine_instructions
static void
combine_instructions(ir_unit_t *iu, ir_function_t *f)
{
  ir_bb_t *bb;
  TAILQ_FOREACH(bb, &f->if_bbs, ib_link) {
    ir_instr_t *ii, *iin;
    ii = TAILQ_LAST(&bb->ib_instrs, ir_instr_queue);
    if(ii->ii_class == IR_IC_BR)
      combine_branch_with_compare(iu, (ir_instr_br_t *)ii);

    for(ii = TAILQ_FIRST(&bb->ib_instrs); ii != NULL; ii = iin) {
      iin = TAILQ_NEXT(ii, ii_link);
      if(ii->ii_class == IR_IC_BINOP)
        combine_binop(iu, (ir_instr_binary_t *)ii);
      else if(ii->ii_class == IR_IC_CAST)
        combine_binop_cast(iu, (ir_instr_unary_t *)ii);
      else if(ii->ii_class == IR_IC_SELECT)
        combine_select_with_compare(iu, (ir_instr_select_t *)ii);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x24dca
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x8, 0x28(%rax)
jne 0x24d41
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x27120
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x24db8
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x2, 0x28(%rax)
jne 0x24d78
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x272c0
jmp 0x24dac
movq -0x20(%rbp), %rax
cmpl $0x3, 0x28(%rax)
jne 0x24d91
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x272f0
jmp 0x24daa
movq -0x20(%rbp), %rax
cmpl $0xe, 0x28(%rax)
jne 0x24da8
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x273c0
jmp 0x24daa
jmp 0x24dac
jmp 0x24dae
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x24d4d
jmp 0x24dba
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x24d0c
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_transform.c
// Function: prepare_calls
static int
prepare_calls(ir_unit_t *iu, ir_function_t *f)
{
  ir_bb_t *bb;
  int call_arg_base = iu->iu_next_value;
  int num_call_args = 0;
  int callargtype = type_make(iu, IR_TYPE_INT32);
  TAILQ_FOREACH(bb, &f->if_bbs, ib_link) {
    ir_instr_t *ii;
    TAILQ_FOREACH(ii, &bb->ib_instrs, ii_link) {
    if(ii->ii_class == IR_IC_CALL || ii->ii_class == IR_IC_INVOKE) {
      prepare_call(iu, f, (ir_instr_call_t *)ii,
                   call_arg_base, &num_call_args,
                   callargtype);
      }
    }
  }
  return num_call_args;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x198(%rax), %eax
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl $0x5, %esi
callq 0x281a0
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x24ec9
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x24eba
movq -0x30(%rbp), %rax
cmpl $0xa, 0x28(%rax)
je 0x24e8f
movq -0x30(%rbp), %rax
cmpl $0xb, 0x28(%rax)
jne 0x24eab
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x24(%rbp), %r9d
leaq -0x20(%rbp), %r8
callq 0x282e0
jmp 0x24ead
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x24e74
jmp 0x24ebc
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x24e61
movl -0x20(%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_transform.c
// Function: legalize_temporary_values
static void
legalize_temporary_values(ir_unit_t *iu, ir_function_t *f)
{
  SLIST_HEAD(, ir_value) vals;
  SLIST_INIT(&vals);
  ir_value_t *iv;

  for(int i = iu->iu_first_func_value; i < iu->iu_next_value; i++) {
    iv = value_get(iu, i);
    if(iv->iv_class != IR_VC_TEMPORARY)
      continue;
    ir_type_t *ty = type_get(iu, iv->iv_type);

    if(ty->it_code == IR_TYPE_STRUCT) {
      const int num_values = ty->it_struct.num_elements;
      ir_valuetype_t *values = malloc(sizeof(ir_valuetype_t) * num_values);
      for(int j = 0; j < num_values; j++) {
        values[j] = value_alloc_temporary(iu, ty->it_struct.elements[j].type);
      }
      iv->iv_data = values;
      iv->iv_num_values = num_values;
      SLIST_INSERT_HEAD(&vals, iv, iv_tmp_link);
    }
  }

  SLIST_FOREACH(iv, &vals, iv_tmp_link) {
    legalize_aggregate(iu, iv);
  }

  SLIST_FOREACH(iv, &vals, iv_tmp_link) {
    // The old temporary aggregate value should no longer be used for anything
    iv->iv_class = IR_VC_DEAD;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x19c(%rax), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x198(%rcx), %eax
jge 0x25007
movq -0x8(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x20ee0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x4, (%rax)
je 0x24f36
jmp 0x24ff9
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movl 0x24(%rax), %esi
callq 0x1ee20
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x24ff7
movq -0x30(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x34(%rbp)
movslq -0x34(%rbp), %rdi
shlq $0x3, %rdi
callq 0x3360
movq %rax, -0x40(%rbp)
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x34(%rbp), %eax
jge 0x24fcb
movq -0x40(%rbp), %rax
movq %rax, -0x58(%rbp)
movslq -0x44(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x44(%rbp), %rcx
movl (%rax,%rcx,8), %esi
callq 0x20c80
movq -0x60(%rbp), %rcx
movq %rax, %rdx
movq -0x58(%rbp), %rax
movq %rdx, -0x4c(%rbp)
movq -0x4c(%rbp), %rdx
movq %rdx, (%rax,%rcx,8)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x24f79
movq -0x40(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movl -0x34(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x24ff7
jmp 0x24ff9
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x24f05
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x25031
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x287b0
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x2500f
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x25058
movq -0x20(%rbp), %rax
movl $0xc, (%rax)
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x25039
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_transform.c
// Function: legalize_instructions
static void
legalize_instructions(ir_unit_t *iu, ir_function_t *f)
{
  ir_bb_t *bb;
  TAILQ_FOREACH(bb, &f->if_bbs, ib_link) {
    ir_instr_t *ii;
    TAILQ_FOREACH(ii, &bb->ib_instrs, ii_link) {
      if(ii->ii_class == IR_IC_LOAD) {
        if(ii->ii_ret.value < -1) {
          ii = split_aggregated_load(iu, (ir_instr_load_t *)ii);
        }
      }
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x250db
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x250cc
movq -0x20(%rbp), %rax
cmpl $0x4, 0x28(%rax)
jne 0x250bd
movq -0x20(%rbp), %rax
cmpl $-0x1, 0x2c(%rax)
jge 0x250bb
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x29040
movq %rax, -0x20(%rbp)
jmp 0x250bd
jmp 0x250bf
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x2508f
jmp 0x250ce
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x2507c
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_transform.c
// Function: liveness_analysis
static void
liveness_analysis(ir_unit_t *iu, ir_function_t *f)
{
  /* First function value is the value index for the first argument
   * or first temporary in case of functions with no arguments
   */
  const int ffv = iu->iu_first_func_value;
  int temp_values = iu->iu_next_value - ffv;

  // words needed for the value sets
  int setwords = (temp_values + 31) / 32;

  ir_bb_t *ib;
  ir_instr_t *ii;

  TAILQ_FOREACH(ib, &f->if_bbs, ib_link) {
    TAILQ_FOREACH(ii, &ib->ib_instrs, ii_link) {
      ii->ii_liveness = calloc(1, sizeof(uint32_t) * setwords * 3);
      liveness_set_gen(ii, iu, ii->ii_liveness + setwords);
      liveness_set_succ(f, ii);
    }
  }

  liveness_update(f, setwords, ffv);
  coalesce(iu, setwords, temp_values, ffv, f);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x19c(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl 0x198(%rax), %eax
subl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
addl $0x1f, %eax
movl $0x20, %ecx
cltd
idivl %ecx
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x25455
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x25443
movslq -0x1c(%rbp), %rax
shlq $0x2, %rax
imulq $0x3, %rax, %rsi
movl $0x1, %edi
callq 0x32c0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x30(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x30(%rbp), %rax
movq 0x38(%rax), %rdx
movslq -0x1c(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdx
callq 0x29460
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x26e80
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x253e1
jmp 0x25445
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x253ca
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x29830
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl -0x18(%rbp), %edx
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %r8
callq 0x29bf0
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_transform.c
// Function: finalize_call_args
static void
finalize_call_args(ir_unit_t *iu, ir_function_t *f,
                   int call_arg_base, int num_call_args)
{
  int call_arg_size = num_call_args * 4;
  f->if_regframe_size += call_arg_size;

  for(int i = 0; i < num_call_args; i++) {
    ir_value_t *iv = value_get(iu, call_arg_base + i);
    iv->iv_class = IR_VC_REGFRAME;
    iv->iv_reg = f->if_regframe_size - (i + 1) * 4;
  }
}

// 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)
movl -0x18(%rbp), %eax
shll $0x2, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
addl 0x2c(%rax), %ecx
movl %ecx, 0x2c(%rax)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x254fc
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
addl -0x20(%rbp), %esi
callq 0x20ee0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl $0x5, (%rax)
movq -0x10(%rbp), %rax
movl 0x2c(%rax), %ecx
movl -0x20(%rbp), %eax
addl $0x1, %eax
shll $0x2, %eax
subl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x30(%rax)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x254b3
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_transform.c
// Function: merge_lea_into_store
static void
merge_lea_into_store(ir_unit_t *iu, ir_instr_store_t *ii)
{
  ir_value_t *ptr = value_get(iu, ii->ptr.value);
  ir_instr_t *a = value_get_assigning_instr(iu, ptr);
  ir_instr_lea_t *lea = instr_isa(a, IR_IC_LEA);
  if(lea == NULL || lea->value_offset.value != -1)
    return;

  assert(ii->immediate_offset == 0);
  int off = lea->immediate_offset;
  if(off < INT16_MIN || off > INT16_MAX) {
    return;
  }

  ii->immediate_offset = lea->immediate_offset;
  ii->ptr.value = lea->baseptr.value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x58(%rax), %esi
callq 0x20ee0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x26540
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl $0x14, %esi
callq 0x265a0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x25928
movq -0x28(%rbp), %rax
cmpl $-0x1, 0x64(%rax)
je 0x2592a
jmp 0x2598f
movq -0x10(%rbp), %rax
cmpl $0x0, 0x68(%rax)
jne 0x25936
jmp 0x25955
leaq 0x19bbe(%rip), %rdi     # 0x3f4fb
leaq 0x19aa9(%rip), %rsi     # 0x3f3ed
movl $0xcc, %edx
leaq 0x19bc5(%rip), %rcx     # 0x3f515
callq 0x31c0
movq -0x28(%rbp), %rax
movl 0x60(%rax), %eax
movl %eax, -0x2c(%rbp)
cmpl $0xffff8000, -0x2c(%rbp) # imm = 0xFFFF8000
jl 0x25971
cmpl $0x7fff, -0x2c(%rbp)    # imm = 0x7FFF
jle 0x25973
jmp 0x2598f
movq -0x28(%rbp), %rax
movl 0x60(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x68(%rax)
movq -0x28(%rbp), %rax
movl 0x58(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x58(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_transform.c
// Function: merge_lea_into_load
static void
merge_lea_into_load(ir_unit_t *iu, ir_instr_load_t *ii)
{
  ir_value_t *ptr = value_get(iu, ii->ptr.value);
  ir_instr_t *a = value_get_assigning_instr(iu, ptr);
  ir_instr_lea_t *lea = instr_isa(a, IR_IC_LEA);
  if(lea == NULL)
    return;

  assert(ii->immediate_offset == 0);
  int off = lea->immediate_offset;
  if(off < INT16_MIN || off > INT16_MAX) {
    iu->iu_stats.lea_load_combined_failed++;
    return;
  }

  ii->immediate_offset += lea->immediate_offset;
  assert(ii->value_offset.value < 0);
  ii->value_offset = lea->value_offset;
  ii->value_offset_multiply = lea->value_offset_multiply;
  ii->ptr.value = lea->baseptr.value;

  iu->iu_stats.lea_load_combined++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x58(%rax), %esi
callq 0x20ee0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x26540
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl $0x14, %esi
callq 0x265a0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x25bf3
jmp 0x25cca
movq -0x10(%rbp), %rax
cmpl $0x0, 0x60(%rax)
jne 0x25bff
jmp 0x25c1e
leaq 0x198f5(%rip), %rdi     # 0x3f4fb
leaq 0x197e0(%rip), %rsi     # 0x3f3ed
movl $0xe3, %edx
leaq 0x19937(%rip), %rcx     # 0x3f550
callq 0x31c0
movq -0x28(%rbp), %rax
movl 0x60(%rax), %eax
movl %eax, -0x2c(%rbp)
cmpl $0xffff8000, -0x2c(%rbp) # imm = 0xFFFF8000
jl 0x25c3a
cmpl $0x7fff, -0x2c(%rbp)    # imm = 0x7FFF
jle 0x25c4f
movq -0x8(%rbp), %rax
movl 0x624(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x624(%rax)
jmp 0x25cca
movq -0x28(%rbp), %rax
movl 0x60(%rax), %ecx
movq -0x10(%rbp), %rax
addl 0x60(%rax), %ecx
movl %ecx, 0x60(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x64(%rax)
jge 0x25c6c
jmp 0x25c8b
leaq 0x19916(%rip), %rdi     # 0x3f589
leaq 0x19773(%rip), %rsi     # 0x3f3ed
movl $0xeb, %edx
leaq 0x198ca(%rip), %rcx     # 0x3f550
callq 0x31c0
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movq 0x64(%rcx), %rcx
movq %rcx, 0x64(%rax)
movq -0x28(%rbp), %rax
movl 0x6c(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x6c(%rax)
movq -0x28(%rbp), %rax
movl 0x58(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x58(%rax)
movq -0x8(%rbp), %rax
movl 0x620(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x620(%rax)
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_transform.c
// Function: replace_single_path_phi
static ir_instr_t *
replace_single_path_phi(ir_unit_t *iu, ir_instr_phi_t *ii)
{
  if(ii->num_nodes != 1)
    return &ii->super;

  ir_instr_move_t *move =
    instr_add_before(sizeof(ir_instr_move_t), IR_IC_MOVE, &ii->super);

  move->super.ii_ret = ii->super.ii_ret;
  value_bind_return_value(iu, &move->super);

  move->value = ii->nodes[0].value;

  instr_destroy(&ii->super);
  return &move->super;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x1, 0x58(%rax)
je 0x25cf4
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x25d49
movq -0x18(%rbp), %rdx
movl $0x60, %edi
movl $0x15, %esi
callq 0x26380
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x2c(%rcx), %rcx
movq %rcx, 0x2c(%rax)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x20cf0
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x60(%rcx), %rcx
movq %rcx, 0x58(%rax)
movq -0x18(%rbp), %rdi
callq 0x1cad0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_transform.c
// Function: binop_prep_args
static void
binop_prep_args(ir_unit_t *iu, ir_instr_binary_t *ii)
{
  switch(ii->op) {
  case BINOP_ADD:
  case BINOP_MUL:
  case BINOP_AND:
  case BINOP_OR:
  case BINOP_XOR:
    if(is_reg(iu, ii->rhs_value) && !is_reg(iu, ii->lhs_value)) {
      ir_valuetype_t tmp = ii->lhs_value;
      ii->lhs_value = ii->rhs_value;
      ii->rhs_value = tmp;
    }
    break;
  }

  registerify(iu, &ii->super, &ii->lhs_value);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x58(%rax), %eax
movl %eax, -0x1c(%rbp)
testl %eax, %eax
je 0x25fe7
jmp 0x25fd0
movl -0x1c(%rbp), %eax
subl $0x2, %eax
je 0x25fe7
jmp 0x25fda
movl -0x1c(%rbp), %eax
addl $-0xa, %eax
subl $0x2, %eax
ja 0x2603d
jmp 0x25fe7
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x64(%rax), %rsi
callq 0x26670
cmpl $0x0, %eax
je 0x2603b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x5c(%rax), %rsi
callq 0x26670
cmpl $0x0, %eax
jne 0x2603b
movq -0x10(%rbp), %rax
movq 0x5c(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x64(%rcx), %rcx
movq %rcx, 0x5c(%rax)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x64(%rax)
jmp 0x2603d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rdx
addq $0x5c, %rdx
callq 0x26400
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_transform.c
// Function: registerify_cmp
static void
registerify_cmp(ir_unit_t *iu, ir_instr_binary_t *ii)
{
  const ir_value_t *lhs = value_get(iu, ii->lhs_value.value);
  if(lhs->iv_class != IR_VC_CONSTANT)
    return;
  const ir_value_t *rhs = value_get(iu, ii->rhs_value.value);
  if(rhs->iv_class == IR_VC_CONSTANT) {
    registerify(iu, &ii->super, &ii->lhs_value);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x5c(%rax), %esi
callq 0x20ee0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x3, (%rax)
je 0x2608f
jmp 0x260c1
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x64(%rax), %esi
callq 0x20ee0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x3, (%rax)
jne 0x260c1
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rdx
addq $0x5c, %rdx
callq 0x26400
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_transform.c
// Function: binop_transform_cast
static void
binop_transform_cast(ir_unit_t *iu, ir_instr_unary_t *ii)
{
  ir_type_t *srcty = type_get(iu, ii->value.type);
  ir_type_t *dstty = type_get(iu, ii->super.ii_ret.type);

  switch(ii->op) {
  default:
    return;

  case CAST_BITCAST:
    if(srcty->it_code == IR_TYPE_POINTER && dstty->it_code == IR_TYPE_POINTER)
      break;
    return;

  case CAST_INTTOPTR:
    if(srcty->it_code == IR_TYPE_INT32)
      break;
    return;

  case CAST_PTRTOINT:
    if(dstty->it_code == IR_TYPE_INT32)
      break;
    return;

  case CAST_TRUNC:
    if(legalize_type(dstty) == legalize_type(srcty))
      break;

    return;
  }

  ii->super.ii_class = IR_IC_MOVE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x5c(%rax), %esi
callq 0x1ee20
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x30(%rax), %esi
callq 0x1ee20
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x60(%rax), %eax
movq %rax, -0x28(%rbp)
subq $0xb, %rax
ja 0x2612d
movq -0x28(%rbp), %rax
leaq 0x175a4(%rip), %rcx     # 0x3d6c8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x2618c
movq -0x18(%rbp), %rax
cmpl $0xb, (%rax)
jne 0x26143
movq -0x20(%rbp), %rax
cmpl $0xb, (%rax)
jne 0x26143
jmp 0x26181
jmp 0x2618c
movq -0x18(%rbp), %rax
cmpl $0x5, (%rax)
jne 0x26150
jmp 0x26181
jmp 0x2618c
movq -0x20(%rbp), %rax
cmpl $0x5, (%rax)
jne 0x2615d
jmp 0x26181
jmp 0x2618c
movq -0x20(%rbp), %rdi
callq 0x45d0
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x45d0
movl %eax, %ecx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
jne 0x2617f
jmp 0x26181
jmp 0x2618c
movq -0x10(%rbp), %rax
movl $0x15, 0x28(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_value.c
// Function: value_get_const32
static uint32_t __attribute__((unused))
value_get_const32(ir_unit_t *iu, const ir_value_t *iv)
{
  ir_type_t *it = type_get(iu, iv->iv_type);

  switch(iv->iv_class) {

  case IR_VC_GLOBALVAR:
    return iv->iv_gvar->ig_addr;

  case IR_VC_CONSTANT:
    switch(it->it_code) {
    case IR_TYPE_INT1:
      return !!iv->iv_u32;
    case IR_TYPE_INT8:
    case IR_TYPE_INT16:
    case IR_TYPE_INT32:
    case IR_TYPE_POINTER:
    case IR_TYPE_FLOAT:
      return iv->iv_u32;
    case IR_TYPE_INTx:
    case IR_TYPE_INT64:
  case IR_TYPE_DOUBLE:
      return iv->iv_u64;
    default:
      break;
    }
    break;
  default:
    break;
  }

  parser_error(iu, "Unable to value_get_const for value %s",
               value_str(iu, iv));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x24(%rax), %esi
callq 0x1ee20
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
subl $0x2, %eax
je 0x261e1
jmp 0x261d4
movl -0x24(%rbp), %eax
subl $0x3, %eax
je 0x261f4
jmp 0x26272
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movl 0x28(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x262aa
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x28(%rbp)
subl $0x2, %eax
je 0x2623c
jmp 0x26204
movl -0x28(%rbp), %eax
addl $-0x3, %eax
subl $0x3, %eax
jb 0x26255
jmp 0x26211
movl -0x28(%rbp), %eax
addl $-0x6, %eax
subl $0x2, %eax
jb 0x26261
jmp 0x2621e
movl -0x28(%rbp), %eax
subl $0x8, %eax
je 0x26255
jmp 0x26228
movl -0x28(%rbp), %eax
subl $0x9, %eax
je 0x26261
jmp 0x26232
movl -0x28(%rbp), %eax
subl $0xb, %eax
je 0x26255
jmp 0x2626e
movq -0x18(%rbp), %rax
cmpl $0x0, 0x30(%rax)
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x262aa
movq -0x18(%rbp), %rax
movl 0x30(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x262aa
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movl %eax, -0x4(%rbp)
jmp 0x262aa
jmp 0x26270
jmp 0x26274
jmp 0x26274
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x264e0
movq -0x30(%rbp), %rdi
movq %rax, %r8
leaq 0x184cd(%rip), %rsi     # 0x3e764
movl $0x1d5, %edx            # imm = 0x1D5
leaq 0x19206(%rip), %rcx     # 0x3f4a9
movb $0x0, %al
callq 0x18220
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_transform.c
// Function: emit_interim_lea
static ir_valuetype_t
emit_interim_lea(ir_unit_t *iu, ir_valuetype_t baseptr,
                 ir_valuetype_t value_offset, int value_offset_multiply,
                 ir_instr_gep_t *gep, int type)
{
  type = type_make_pointer(iu, type, 1);
  ir_instr_lea_t *lea =
    instr_add_before(sizeof(ir_instr_lea_t), IR_IC_LEA, &gep->super);

  value_alloc_instr_ret(iu, type, &lea->super);

  lea->baseptr = baseptr;

  registerify(iu, &lea->super, &lea->baseptr);

  lea->immediate_offset = 0;
  lea->value_offset = value_offset;
  lea->value_offset_multiply = value_offset_multiply;
  return lea->super.ii_ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rdi, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movl %r9d, -0x34(%rbp)
movq -0x20(%rbp), %rdi
movl -0x34(%rbp), %esi
movl $0x1, %edx
callq 0x1e6e0
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rdx
movl $0x70, %edi
movl $0x14, %esi
callq 0x26380
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
movl -0x34(%rbp), %esi
movq -0x40(%rbp), %rdx
callq 0x22410
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x58(%rax)
movq -0x20(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x40(%rbp), %rdx
addq $0x58, %rdx
callq 0x26400
movq -0x40(%rbp), %rax
movl $0x0, 0x60(%rax)
movq -0x40(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x64(%rax)
movl -0x24(%rbp), %ecx
movq -0x40(%rbp), %rax
movl %ecx, 0x6c(%rax)
movq -0x40(%rbp), %rax
movq 0x2c(%rax), %rax
movq %rax, -0x8(%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_instr.c
// Function: instr_add_before
static void *
instr_add_before(size_t size, instr_class_t ic, ir_instr_t *before)
{
  ir_bb_t *ib = before->ii_bb;
  ir_instr_t *ii = instr_create(size, ic);
  ii->ii_bb = ib;
  TAILQ_INSERT_BEFORE(before, ii, ii_link);
  return ii;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x20da0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_transform.c
// Function: registerify
static void
registerify(ir_unit_t *iu, ir_instr_t *ii, ir_valuetype_t *vtp)
{
  ir_value_t *v = value_get(iu, vtp->value);
  ir_instr_move_t *move;

  switch(v->iv_class) {
  case IR_VC_TEMPORARY:
  case IR_VC_REGFRAME:
    return;

  case IR_VC_GLOBALVAR:
  case IR_VC_CONSTANT:
    move = instr_add_before(sizeof(ir_instr_move_t), IR_IC_MOVE, ii);
    value_alloc_instr_ret(iu, v->iv_type, &move->super);
    move->value = *vtp;
    *vtp = move->super.ii_ret;
    break;

  default:
    parser_error(iu, "Unable convert %s (class %d) into register",
                 type_str_index(iu, v->iv_type),
                 v->iv_class);
  }
}

// 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
movq -0x18(%rbp), %rax
movl (%rax), %esi
callq 0x20ee0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
addl $-0x2, %eax
subl $0x2, %eax
jb 0x2644c
jmp 0x2643a
movl -0x2c(%rbp), %eax
addl $-0x4, %eax
subl $0x1, %eax
ja 0x26497
jmp 0x26447
jmp 0x264d7
movq -0x10(%rbp), %rdx
movl $0x60, %edi
movl $0x15, %esi
callq 0x26380
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movl 0x24(%rax), %esi
movq -0x28(%rbp), %rdx
callq 0x22410
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, 0x58(%rax)
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movq 0x2c(%rcx), %rcx
movq %rcx, (%rax)
jmp 0x264d7
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movl 0x24(%rax), %esi
callq 0x22560
movq -0x38(%rbp), %rdi
movq %rax, %r8
movq -0x20(%rbp), %rax
movl (%rax), %r9d
leaq 0x18f29(%rip), %rsi     # 0x3f3ed
movl $0x35, %edx
leaq 0x19000(%rip), %rcx     # 0x3f4d0
movb $0x0, %al
callq 0x18220
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_value.c
// Function: value_str
static const char *
value_str(ir_unit_t *iu, const ir_value_t *iv)
{
  int len = value_print(NULL, iu, iv, NULL);
  char *dst = tmpstr(iu, len);
  const char *ret = dst;
  value_print(&dst, iu, iv, NULL);
  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdi
callq 0x1f520
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x18e00
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %ecx
callq 0x1f520
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_value.c
// Function: value_get_assigning_instr
static ir_instr_t *
value_get_assigning_instr(ir_unit_t *iu, ir_value_t *iv)
{
  ir_value_instr_t *ivi;
  LIST_FOREACH(ivi, &iv->iv_instructions, ivi_value_link)
    if(ivi->ivi_relation == IVI_OUTPUT)
      return ivi->ivi_instr;
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x26586
movq -0x20(%rbp), %rax
cmpl $0x1, 0x30(%rax)
jne 0x26577
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x2658e
jmp 0x26579
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x26558
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_instr.c
// Function: instr_add_after
static void *
instr_add_after(size_t size, instr_class_t ic, ir_instr_t *after)
{
  ir_bb_t *ib = after->ii_bb;
  ir_instr_t *ii = instr_create(size, ic);
  ii->ii_bb = ib;
  TAILQ_INSERT_AFTER(&ib->ib_instrs,  after, ii, ii_link);
  return ii;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x20da0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
je 0x26640
movq -0x28(%rbp), %rcx
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
jmp 0x2664c
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_transform.c
// Function: instr_verify_output
static void
instr_verify_output(ir_unit_t *iu, ir_instr_t *ii)
{
  ir_value_instr_t *ivi = LIST_FIRST(&ii->ii_values);

  if(ii->ii_ret.value != -1) {
    for(; ivi != NULL; ivi = LIST_NEXT(ivi, ivi_instr_link)) {
      if(ivi->ivi_relation == IVI_OUTPUT) {
        break;
      }
    }
    if(ivi == NULL) {
      parser_error(iu, "Instruction output mismatch for %s",
                   instr_str(iu, ii, 1));
    } else {
      ivi = LIST_NEXT(ivi, ivi_instr_link);
    }
  }
  for(; ivi != NULL; ivi = LIST_NEXT(ivi, ivi_instr_link)) {
    if(ivi->ivi_relation == IVI_OUTPUT) {
      parser_error(iu, "Instruction output mismatch for %s",
                   instr_str(iu, ii, 1));
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x2c(%rax)
je 0x2675b
jmp 0x266e8
cmpq $0x0, -0x18(%rbp)
je 0x2670b
movq -0x18(%rbp), %rax
cmpl $0x1, 0x30(%rax)
jne 0x266fb
jmp 0x2670b
jmp 0x266fd
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x266e8
cmpq $0x0, -0x18(%rbp)
jne 0x2674d
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0x225c0
movq -0x20(%rbp), %rdi
movq %rax, %r8
leaq 0x18cb3(%rip), %rsi     # 0x3f3ed
movl $0x204, %edx            # imm = 0x204
leaq 0x18ec5(%rip), %rcx     # 0x3f60b
movb $0x0, %al
callq 0x18220
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x2675b
jmp 0x2675d
cmpq $0x0, -0x18(%rbp)
je 0x267b9
movq -0x18(%rbp), %rax
cmpl $0x1, 0x30(%rax)
jne 0x267a9
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0x225c0
movq -0x28(%rbp), %rdi
movq %rax, %r8
leaq 0x18c57(%rip), %rsi     # 0x3f3ed
movl $0x20c, %edx            # imm = 0x20C
leaq 0x18e69(%rip), %rcx     # 0x3f60b
movb $0x0, %al
callq 0x18220
jmp 0x267ab
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x2675d
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_transform.c
// Function: instr_bind_input
static void
instr_bind_input(ir_unit_t *iu, ir_valuetype_t vt, ir_instr_t *ii)
{
  if(vt.value == -1)
    return;
  ir_value_t *iv = value_get(iu, vt.value);
  if(iv->iv_class != IR_VC_TEMPORARY)
    return;
  value_bind_instr(iv, ii, IVI_INPUT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpl $-0x1, -0x8(%rbp)
jne 0x267dc
jmp 0x26806
movq -0x10(%rbp), %rdi
movl -0x8(%rbp), %esi
callq 0x20ee0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x4, (%rax)
je 0x267f7
jmp 0x26806
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x20e00
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_transform.c
// Function: cfg_add_edge
static void
cfg_add_edge(ir_function_t *f, ir_bb_t *from, int bb, int mark)
{
  ir_bb_t *to = bb_find(f, bb);
  if(mark) {
    if(to->ib_mark)
      return;
    to->ib_mark = 1;
  }
  cfg_create_edge(f, from, to);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x268e0
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x26850
movq -0x20(%rbp), %rax
cmpb $0x0, 0x2c(%rax)
je 0x26848
jmp 0x26861
movq -0x20(%rbp), %rax
movb $0x1, 0x2c(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x26940
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_transform.c
// Function: unmark_outgoing_blocks
static void
unmark_outgoing_blocks(ir_bb_t *bb)
{
  ir_bb_edge_t *c;
  LIST_FOREACH(c, &bb->ib_outgoing_edges, ibe_from_link) {
    assert(c->ibe_to->ib_mark == 1);
    c->ibe_to->ib_mark = 0;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x268da
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movzbl 0x2c(%rax), %eax
cmpl $0x1, %eax
jne 0x268a2
jmp 0x268c1
leaq 0x18d85(%rip), %rdi     # 0x3f62e
leaq 0x18b3d(%rip), %rsi     # 0x3f3ed
movl $0x44e, %edx            # imm = 0x44E
leaq 0x18d8a(%rip), %rcx     # 0x3f646
callq 0x31c0
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movb $0x0, 0x2c(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x26888
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_function.c
// Function: bb_find
static ir_bb_t *
bb_find(ir_function_t *f,  int id)
{
  ir_bb_t *ib;
  TAILQ_FOREACH(ib, &f->if_bbs, ib_link) {
    if(ib->ib_id == id)
      return ib;
  }
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x26923
movq -0x20(%rbp), %rax
movl 0x28(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x26914
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2692b
jmp 0x26916
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x268f7
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_function.c
// Function: cfg_create_edge
static void
cfg_create_edge(ir_function_t *f, ir_bb_t *from, ir_bb_t *to)
{
  ir_bb_edge_t *ibe = malloc(sizeof(ir_bb_edge_t));
  LIST_INSERT_HEAD(&f->if_edges,             ibe, ibe_function_link);
  ibe->ibe_from = from;
  LIST_INSERT_HEAD(&from->ib_outgoing_edges, ibe, ibe_from_link);
  ibe->ibe_to   = to;
  LIST_INSERT_HEAD(&to->ib_incoming_edges,   ibe, ibe_to_link);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x40, %edi
callq 0x3360
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x20(%rbp), %rcx
movq %rax, 0x20(%rcx)
cmpq $0x0, %rax
je 0x2698c
movq -0x20(%rbp), %rcx
addq $0x20, %rcx
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq %rcx, 0x28(%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x8(%rbp), %rcx
addq $0x58, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x20(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
je 0x269d9
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rcx
addq $0x38, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x20(%rbp), %rcx
movq %rax, 0x10(%rcx)
cmpq $0x0, %rax
je 0x26a2b
movq -0x20(%rbp), %rcx
addq $0x10, %rcx
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x18(%rbp), %rcx
addq $0x30, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_transform.c
// Function: combine_binop_cast
static void
combine_binop_cast(ir_unit_t *iu, ir_instr_unary_t *ii)
{
  ir_instr_t *u;

  if(ii->op != CAST_ZEXT && ii->op != CAST_SEXT)
    return;
  ir_value_t *v = value_get(iu, ii->super.ii_ret.value);
  ir_type_t *ty = type_get(iu, v->iv_type);
  if(ty->it_code != IR_TYPE_INT32)
    return;

  u = combine_get_upstream_instruction(iu, ii->value, &ii->super);
  if(u != NULL && u->ii_class == IR_IC_LOAD) {
    ir_instr_load_t *load = (ir_instr_load_t *)u;
    ir_value_t *ptr = value_get(iu, load->ptr.value);
    if(ptr->iv_class != IR_VC_TEMPORARY &&
       ptr->iv_class != IR_VC_REGFRAME)
      return;
    combine_binop_load_cast(iu, ii, load);
    return;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1, 0x60(%rax)
je 0x27319
movq -0x10(%rbp), %rax
cmpl $0x2, 0x60(%rax)
je 0x27319
jmp 0x273b7
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x2c(%rax), %esi
callq 0x20ee0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movl 0x24(%rax), %esi
callq 0x1ee20
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x5, (%rax)
je 0x2734c
jmp 0x273b7
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rdx
movq 0x58(%rax), %rsi
callq 0x275d0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x273b7
movq -0x18(%rbp), %rax
cmpl $0x4, 0x28(%rax)
jne 0x273b7
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rax
movl 0x58(%rax), %esi
callq 0x20ee0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpl $0x4, (%rax)
je 0x273a6
movq -0x38(%rbp), %rax
cmpl $0x5, (%rax)
je 0x273a6
jmp 0x273b7
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x27980
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_transform.c
// Function: combine_get_upstream_instruction
static ir_instr_t *
combine_get_upstream_instruction(ir_unit_t *iu, ir_valuetype_t vt,
                                 ir_instr_t *target)
{
  ir_value_t *iv = value_get(iu, vt.value);
  if(iv->iv_class != IR_VC_TEMPORARY)
    return NULL;

  ir_instr_t *upstream = NULL;
  ir_value_instr_t *ivi;
  LIST_FOREACH(ivi, &iv->iv_instructions, ivi_value_link) {
    switch(ivi->ivi_relation) {
    case IVI_OUTPUT:
      if(upstream != NULL)
        return NULL; /* Multiple instructions write to this value
                      * Happens only when in non SSA form
                      */
      upstream = ivi->ivi_instr;
      break;
    case IVI_INPUT:
      if(ivi->ivi_instr != target)
        return NULL; // Other instruction is using the value
      break;
    }
  }

  return upstream;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x20ee0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x4, (%rax)
je 0x2760a
movq $0x0, -0x8(%rbp)
jmp 0x2768f
movq $0x0, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x27687
movq -0x38(%rbp), %rax
movl 0x30(%rax), %eax
movl %eax, -0x3c(%rbp)
testl %eax, %eax
je 0x2765e
jmp 0x27635
movl -0x3c(%rbp), %eax
subl $0x1, %eax
jne 0x27678
jmp 0x2763f
cmpq $0x0, -0x30(%rbp)
je 0x27650
movq $0x0, -0x8(%rbp)
jmp 0x2768f
movq -0x38(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x27678
movq -0x38(%rbp), %rax
movq 0x28(%rax), %rax
cmpq -0x20(%rbp), %rax
je 0x27676
movq $0x0, -0x8(%rbp)
jmp 0x2768f
jmp 0x27678
jmp 0x2767a
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x2761e
movq -0x30(%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_transform.c
// Function: combine_binop_add
static void
combine_binop_add(ir_unit_t *iu, ir_instr_binary_t *ii)
{
  ir_instr_t *lhs, *rhs;

  lhs = combine_get_upstream_instruction(iu, ii->lhs_value, &ii->super);
  if(lhs != NULL && lhs->ii_class == IR_IC_BINOP &&
     ((ir_instr_binary_t *)lhs)->op == BINOP_MUL) {
    combine_binop_add_mul(iu, ii, (ir_instr_binary_t *)lhs, 0);
    return;
  }

  rhs = combine_get_upstream_instruction(iu, ii->rhs_value, &ii->super);
  if(rhs != NULL && rhs->ii_class == IR_IC_BINOP &&
     ((ir_instr_binary_t *)rhs)->op == BINOP_MUL) {
    combine_binop_add_mul(iu, ii, (ir_instr_binary_t *)rhs, 1);
    return;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rdx
movq 0x5c(%rax), %rsi
callq 0x275d0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x276f9
movq -0x18(%rbp), %rax
cmpl $0x2, 0x28(%rax)
jne 0x276f9
movq -0x18(%rbp), %rax
cmpl $0x2, 0x58(%rax)
jne 0x276f9
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
xorl %ecx, %ecx
callq 0x27750
jmp 0x27743
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rdx
movq 0x64(%rax), %rsi
callq 0x275d0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x27743
movq -0x20(%rbp), %rax
cmpl $0x2, 0x28(%rax)
jne 0x27743
movq -0x20(%rbp), %rax
cmpl $0x2, 0x58(%rax)
jne 0x27743
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl $0x1, %ecx
callq 0x27750
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_transform.c
// Function: combine_binop_load_cast
static void
combine_binop_load_cast(ir_unit_t *iu, ir_instr_unary_t *cast,
                        ir_instr_load_t *load)
{
  ir_value_t *kill = value_get(iu, load->super.ii_ret.value);
  load->cast = cast->op;
  load->load_type = kill->iv_type;
  load->super.ii_ret = cast->super.ii_ret;

  instr_bind_clear(&load->super);
  instr_bind_input(iu, load->ptr, &load->super);
  if(load->value_offset.value >= 0)
    instr_bind_input(iu, load->value_offset, &load->super);
  value_bind_return_value(iu, &load->super);

  kill->iv_class = IR_VC_DEAD;
  instr_destroy(&cast->super);
  iu->iu_stats.load_cast_combine++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x2c(%rax), %esi
callq 0x20ee0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x60(%rax), %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x74(%rax)
movq -0x20(%rbp), %rax
movl 0x24(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x70(%rax)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x2c(%rcx), %rcx
movq %rcx, 0x2c(%rax)
movq -0x18(%rbp), %rdi
callq 0x1cc20
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq -0x18(%rbp), %rdx
movq 0x58(%rax), %rsi
callq 0x267c0
movq -0x18(%rbp), %rax
cmpl $0x0, 0x64(%rax)
jl 0x27a13
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq -0x18(%rbp), %rdx
movq 0x64(%rax), %rsi
callq 0x267c0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x20cf0
movq -0x20(%rbp), %rax
movl $0xc, (%rax)
movq -0x10(%rbp), %rdi
callq 0x1cad0
movq -0x8(%rbp), %rax
movl 0x618(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x618(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_transform.c
// Function: exit_ssa_bb
static void
exit_ssa_bb(ir_unit_t *iu, ir_function_t *f, ir_bb_t *bb)
{
  ir_bb_edge_t *ibe;
  ir_instr_t *ii;

  LIST_FOREACH(ibe, &bb->ib_incoming_edges, ibe_to_link)
    exit_ssa_edge(iu, f, bb, ibe);

  // Delete PHI instructions
  while((ii = TAILQ_FIRST(&bb->ib_instrs)) != NULL &&
        ii->ii_class == IR_IC_PHI)
    instr_destroy(ii);
}

// 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 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x27a9a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x27ae0
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x27a70
jmp 0x27a9c
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movq %rcx, -0x28(%rbp)
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x29(%rbp)
je 0x27ac1
movq -0x28(%rbp), %rax
cmpl $0x9, 0x28(%rax)
sete %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x27aca
jmp 0x27ad5
movq -0x28(%rbp), %rdi
callq 0x1cad0
jmp 0x27a9c
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_transform.c
// Function: phi_lift_node_find
static phi_lift_node_t *
phi_lift_node_find(struct phi_lift_node_list *nodes, int value)
{
  phi_lift_node_t *pln;
  LIST_FOREACH(pln, nodes, pln_link)
    if(pln->pln_vt.value == value)
      return pln;
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x280a2
movq -0x20(%rbp), %rax
movl 0x20(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x28093
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x280aa
jmp 0x28095
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x28076
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq