mono_branch_optimize_exception_target (struct MonoCompile * cfg, struct MonoBasicBlock * bb, const char * exname)
{
  unsigned int D.22565;
  unsigned int D.22566;
  struct MonoInst * D.22569;
  unsigned int D.22572;
  unsigned int D.22574;
  struct MonoImage * D.22575;
  struct MonoExceptionClause * D.22576;
  long unsigned int D.22577;
  long unsigned int D.22578;
  unsigned int D.22579;
  unsigned int D.22580;
  unsigned int D.22583;
  unsigned int D.22584;
  unsigned int D.22588;
  struct MonoClass * D.22590;
  int D.22592;
  struct MonoBasicBlock * * D.22594;
  unsigned int D.22595;
  long unsigned int D.22596;
  long unsigned int D.22597;
  struct MonoBasicBlock * * D.22598;
  long unsigned int D.22601;
  long unsigned int D.22602;
  struct MonoBasicBlock * D.22604;
  unsigned int D.22605;
  unsigned int D.22606;
  unsigned int D.22611;
  unsigned int D.22612;
  struct MonoMemPool * D.22615;
  int D.22616;
  int D.22617;
  const unsigned char * D.22618;
  void * D.22619;
  struct MonoBasicBlock * * D.22620;
  unsigned int D.22621;
  int D.22624;
  const char * D.22625;
  struct MonoMethod * D.22626;
  struct MonoClass * D.22627;
  const char * D.22628;
  const char * D.22629;
  <unnamed-unsigned:15> D.22630;
  int D.22631;
  struct MonoMethodHeader * header;
  struct MonoExceptionClause * clause;
  struct MonoClass * exclass;
  int i;

  header = cfg->header;
  D.22565 = cfg->opt;
  D.22566 = D.22565 & 1048576;
  if (D.22566 == 0) goto <D.22567>; else goto <D.22568>;
  <D.22567>:
  D.22569 = 0B;
  return D.22569;
  <D.22568>:
  D.22572 = bb->region;
  if (D.22572 == 4294967295) goto <D.22570>; else goto <D.22573>;
  <D.22573>:
  D.22572 = bb->region;
  D.22574 = D.22572 & 240;
  if (D.22574 != 0) goto <D.22570>; else goto <D.22571>;
  <D.22570>:
  D.22569 = 0B;
  return D.22569;
  <D.22571>:
  D.22575 = mono_get_corlib ();
  exclass = mono_class_from_name (D.22575, "System", exname);
  i = 0;
  goto <D.22328>;
  <D.22327>:
  D.22576 = header->clauses;
  D.22577 = (long unsigned int) i;
  D.22578 = D.22577 * 32;
  clause = D.22576 + D.22578;
  D.22579 = clause->try_offset;
  D.22580 = bb->real_offset;
  if (D.22579 <= D.22580) goto <D.22581>; else goto <D.22582>;
  <D.22581>:
  D.22580 = bb->real_offset;
  D.22579 = clause->try_offset;
  D.22583 = clause->try_len;
  D.22584 = D.22579 + D.22583;
  if (D.22580 < D.22584) goto <D.22585>; else goto <D.22586>;
  <D.22585>:
  D.22588 = clause->flags;
  if (D.22588 == 0) goto <D.22589>; else goto <D.22587>;
  <D.22589>:
  D.22590 = clause->data.catch_class;
  if (D.22590 != 0B) goto <D.22591>; else goto <D.22587>;
  <D.22591>:
  D.22590 = clause->data.catch_class;
  D.22592 = mono_class_is_assignable_from (D.22590, exclass);
  if (D.22592 != 0) goto <D.22593>; else goto <D.22587>;
  <D.22593>:
  {
    struct MonoBasicBlock * tbb;

    D.22594 = cfg->cil_offset_to_bb;
    D.22595 = clause->handler_offset;
    D.22596 = (long unsigned int) D.22595;
    D.22597 = D.22596 * 8;
    D.22598 = D.22594 + D.22597;
    tbb = *D.22598;
    if (tbb != 0B) goto <D.22600>; else goto <D.22599>;
    <D.22600>:
    D.22601 = BIT_FIELD_REF <*tbb, 64, 704>;
    D.22602 = D.22601 & 12;
    if (D.22602 == 4) goto <D.22603>; else goto <D.22599>;
    <D.22603>:
    {
      struct MonoBasicBlock * targetbb;
      gboolean unsafe;

      targetbb = tbb;
      unsafe = 0;
      goto <D.22325>;
      <D.22324>:
      D.22604 = tbb->next_bb;
      D.22605 = D.22604->flags;
      D.22606 = D.22605 & 8;
      if (D.22606 != 0) goto <D.22607>; else goto <D.22608>;
      <D.22607>:
      unsafe = 1;
      goto <D.22323>;
      <D.22608>:
      tbb = tbb->next_bb;
      <D.22325>:
      if (unsafe == 0) goto <D.22609>; else goto <D.22323>;
      <D.22609>:
      D.22604 = tbb->next_bb;
      if (D.22604 != 0B) goto <D.22610>; else goto <D.22323>;
      <D.22610>:
      D.22611 = tbb->region;
      D.22604 = tbb->next_bb;
      D.22612 = D.22604->region;
      if (D.22611 == D.22612) goto <D.22324>; else goto <D.22323>;
      <D.22323>:
      if (unsafe == 0) goto <D.22613>; else goto <D.22614>;
      <D.22613>:
      {
        struct MonoInst * jump;

        D.22615 = cfg->mempool;
        jump = mono_mempool_alloc0 (D.22615, 80);
        jump->opcode = 442;
        jump->dreg = -1;
        jump->sreg3 = -1;
        D.22616 = jump->sreg3;
        jump->sreg2 = D.22616;
        D.22617 = jump->sreg2;
        jump->sreg1 = D.22617;
        D.22618 = cfg->ip;
        jump->cil_code = D.22618;
        D.22615 = cfg->mempool;
        D.22619 = mono_mempool_alloc0 (D.22615, 80);
        jump->data.op[1].src = D.22619;
        D.22620 = jump->data.op[1].many_blocks;
        *D.22620 = targetbb;
        D.22621 = cfg->verbose_level;
        if (D.22621 > 2) goto <D.22622>; else goto <D.22623>;
        <D.22622>:
        D.22624 = targetbb->block_num;
        D.22590 = clause->data.catch_class;
        D.22625 = D.22590->name;
        D.22626 = cfg->method;
        D.22627 = D.22626->klass;
        D.22628 = D.22627->name;
        D.22626 = cfg->method;
        D.22629 = D.22626->name;
        monoeg_g_print ("found exception to optimize - returning branch to BB%d (%s) (instead of throw) for method %s:%s\n", D.22624, D.22625, D.22628, D.22629);
        <D.22623>:
        D.22569 = jump;
        return D.22569;
      }
      <D.22614>:
      D.22569 = 0B;
      return D.22569;
    }
    <D.22599>:
    D.22569 = 0B;
    return D.22569;
  }
  <D.22587>:
  D.22569 = 0B;
  return D.22569;
  <D.22586>:
  <D.22582>:
  i = i + 1;
  <D.22328>:
  D.22630 = header->num_clauses;
  D.22631 = (int) D.22630;
  if (D.22631 > i) goto <D.22327>; else goto <D.22329>;
  <D.22329>:
  D.22569 = 0B;
  return D.22569;
}


mono_replace_ins (struct MonoCompile * cfg, struct MonoBasicBlock * bb, struct MonoInst * ins, struct MonoInst * * prev, struct MonoBasicBlock * first_bb, struct MonoBasicBlock * last_bb)
{
  short unsigned int D.22635;
  struct MonoInst * D.22638;
  struct MonoBasicBlock * * D.22641;
  struct MonoBasicBlock * D.22642;
  short int D.22643;
  struct MonoInst * D.22644;
  struct MonoInst * D.22647;
  struct MonoInst * D.22649;
  <unnamed-unsigned:1> D.22653;
  unsigned char D.22654;
  <unnamed-unsigned:1> D.22655;
  unsigned char D.22656;
  unsigned char D.22657;
  <unnamed-unsigned:1> D.22658;
  unsigned int D.22660;
  struct MonoInst * D.22661;
  <unnamed-unsigned:1> D.22669;
  unsigned char D.22670;
  unsigned char D.22671;
  <unnamed-unsigned:1> D.22672;
  struct MonoInst * D.22675;
  struct MonoBasicBlock * * D.22676;
  long unsigned int D.22677;
  long unsigned int D.22678;
  struct MonoBasicBlock * * D.22679;
  struct MonoBasicBlock * D.22680;
  short int D.22681;
  int D.22682;
  struct MonoInst * D.22686;
  struct MonoBasicBlock * * D.22687;
  struct MonoBasicBlock * D.22688;
  struct MonoBasicBlock * * D.22689;
  int D.22690;
  struct MonoBasicBlock * D.22691;
  struct MonoBasicBlock * D.22692;
  struct MonoInst * next;

  next = ins->next;
  if (next != 0B) goto <D.22633>; else goto <D.22634>;
  <D.22633>:
  D.22635 = next->opcode;
  if (D.22635 == 316) goto <D.22636>; else goto <D.22637>;
  <D.22636>:
  D.22638 = next->next;
  ins->next = D.22638;
  next = next->next;
  <D.22637>:
  <D.22634>:
  if (first_bb == last_bb) goto <D.22639>; else goto <D.22640>;
  <D.22639>:
  goto <D.22350>;
  <D.22349>:
  D.22641 = first_bb->out_bb;
  D.22642 = *D.22641;
  mono_unlink_bblock (cfg, first_bb, D.22642);
  <D.22350>:
  D.22643 = first_bb->out_count;
  if (D.22643 != 0) goto <D.22349>; else goto <D.22351>;
  <D.22351>:
  D.22644 = *prev;
  if (D.22644 != 0B) goto <D.22645>; else goto <D.22646>;
  <D.22645>:
  D.22644 = *prev;
  D.22647 = first_bb->code;
  D.22644->next = D.22647;
  D.22647 = first_bb->code;
  D.22644 = *prev;
  D.22647->prev = D.22644;
  goto <D.22648>;
  <D.22646>:
  D.22647 = first_bb->code;
  bb->code = D.22647;
  <D.22648>:
  D.22649 = last_bb->last_ins;
  D.22649->next = next;
  if (next != 0B) goto <D.22650>; else goto <D.22651>;
  <D.22650>:
  D.22649 = last_bb->last_ins;
  next->prev = D.22649;
  goto <D.22652>;
  <D.22651>:
  D.22649 = last_bb->last_ins;
  bb->last_ins = D.22649;
  <D.22652>:
  D.22649 = last_bb->last_ins;
  *prev = D.22649;
  D.22653 = bb->has_array_access;
  D.22654 = (unsigned char) D.22653;
  D.22655 = first_bb->has_array_access;
  D.22656 = (unsigned char) D.22655;
  D.22657 = D.22654 | D.22656;
  D.22658 = (<unnamed-unsigned:1>) D.22657;
  bb->has_array_access = D.22658;
  goto <D.22659>;
  <D.22640>:
  {
    int i;
    int count;
    struct MonoBasicBlock * * tmp_bblocks;
    struct MonoBasicBlock * tmp;
    struct MonoInst * last;

    tmp = first_bb;
    goto <D.22358>;
    <D.22357>:
    D.22660 = bb->region;
    tmp->region = D.22660;
    tmp = tmp->next_bb;
    <D.22358>:
    if (tmp != 0B) goto <D.22357>; else goto <D.22359>;
    <D.22359>:
    D.22661 = ins->next;
    if (D.22661 != 0B) goto <D.22662>; else goto <D.22663>;
    <D.22662>:
    D.22661 = ins->next;
    D.22661->prev = 0B;
    <D.22663>:
    ins->next = 0B;
    bb->last_ins = ins;
    D.22649 = last_bb->last_ins;
    if (D.22649 != 0B) goto <D.22664>; else goto <D.22665>;
    <D.22664>:
    D.22649 = last_bb->last_ins;
    D.22649->next = next;
    if (next != 0B) goto <D.22666>; else goto <D.22667>;
    <D.22666>:
    D.22649 = last_bb->last_ins;
    next->prev = D.22649;
    <D.22667>:
    goto <D.22668>;
    <D.22665>:
    last_bb->code = next;
    <D.22668>:
    D.22669 = last_bb->has_array_access;
    D.22670 = (unsigned char) D.22669;
    D.22653 = bb->has_array_access;
    D.22654 = (unsigned char) D.22653;
    D.22671 = D.22670 | D.22654;
    D.22672 = (<unnamed-unsigned:1>) D.22671;
    last_bb->has_array_access = D.22672;
    if (next != 0B) goto <D.22673>; else goto <D.22674>;
    <D.22673>:
    last = next;
    goto <D.22361>;
    <D.22360>:
    last = last->next;
    <D.22361>:
    D.22675 = last->next;
    if (D.22675 != 0B) goto <D.22360>; else goto <D.22362>;
    <D.22362>:
    last_bb->last_ins = last;
    <D.22674>:
    i = 0;
    goto <D.22364>;
    <D.22363>:
    D.22676 = bb->out_bb;
    D.22677 = (long unsigned int) i;
    D.22678 = D.22677 * 8;
    D.22679 = D.22676 + D.22678;
    D.22680 = *D.22679;
    mono_link_bblock (cfg, last_bb, D.22680);
    i = i + 1;
    <D.22364>:
    D.22681 = bb->out_count;
    D.22682 = (int) D.22681;
    if (D.22682 > i) goto <D.22363>; else goto <D.22365>;
    <D.22365>:
    D.22644 = *prev;
    if (D.22644 != 0B) goto <D.22683>; else goto <D.22684>;
    <D.22683>:
    D.22644 = *prev;
    D.22647 = first_bb->code;
    D.22644->next = D.22647;
    D.22647 = first_bb->code;
    D.22644 = *prev;
    D.22647->prev = D.22644;
    goto <D.22685>;
    <D.22684>:
    D.22647 = first_bb->code;
    bb->code = D.22647;
    <D.22685>:
    D.22686 = first_bb->last_ins;
    bb->last_ins = D.22686;
    D.22653 = bb->has_array_access;
    D.22654 = (unsigned char) D.22653;
    D.22655 = first_bb->has_array_access;
    D.22656 = (unsigned char) D.22655;
    D.22657 = D.22654 | D.22656;
    D.22658 = (<unnamed-unsigned:1>) D.22657;
    bb->has_array_access = D.22658;
    tmp_bblocks = bb->out_bb;
    D.22681 = bb->out_count;
    count = (int) D.22681;
    i = 0;
    goto <D.22367>;
    <D.22366>:
    D.22677 = (long unsigned int) i;
    D.22678 = D.22677 * 8;
    D.22687 = tmp_bblocks + D.22678;
    D.22688 = *D.22687;
    mono_unlink_bblock (cfg, bb, D.22688);
    i = i + 1;
    <D.22367>:
    if (i < count) goto <D.22366>; else goto <D.22368>;
    <D.22368>:
    i = 0;
    goto <D.22371>;
    <D.22370>:
    {
      struct MonoBasicBlock * out_bb;

      D.22641 = first_bb->out_bb;
      D.22677 = (long unsigned int) i;
      D.22678 = D.22677 * 8;
      D.22689 = D.22641 + D.22678;
      out_bb = *D.22689;
      mono_link_bblock (cfg, bb, out_bb);
    }
    i = i + 1;
    <D.22371>:
    D.22643 = first_bb->out_count;
    D.22690 = (int) D.22643;
    if (D.22690 > i) goto <D.22370>; else goto <D.22372>;
    <D.22372>:
    i = 0;
    goto <D.22375>;
    <D.22374>:
    {
      struct MonoBasicBlock * out_bb;

      D.22676 = bb->out_bb;
      D.22677 = (long unsigned int) i;
      D.22678 = D.22677 * 8;
      D.22679 = D.22676 + D.22678;
      out_bb = *D.22679;
      mono_unlink_bblock (cfg, first_bb, out_bb);
    }
    i = i + 1;
    <D.22375>:
    D.22681 = bb->out_count;
    D.22682 = (int) D.22681;
    if (D.22682 > i) goto <D.22374>; else goto <D.22376>;
    <D.22376>:
    D.22691 = bb->next_bb;
    last_bb->next_bb = D.22691;
    D.22692 = first_bb->next_bb;
    bb->next_bb = D.22692;
    *prev = 0B;
  }
  <D.22659>:
}


mono_if_conversion (struct MonoCompile * cfg)
{

}


mono_nullify_basic_block (struct MonoBasicBlock * bb)
{
  struct MonoInst * D.22693;

  bb->in_count = 0;
  bb->out_count = 0;
  bb->in_bb = 0B;
  bb->out_bb = 0B;
  bb->next_bb = 0B;
  bb->last_ins = 0B;
  D.22693 = bb->last_ins;
  bb->code = D.22693;
  bb->cil_code = 0B;
}


mono_merge_basic_blocks (struct MonoCompile * cfg, struct MonoBasicBlock * bb, struct MonoBasicBlock * bbn)
{
  <unnamed-unsigned:1> D.22694;
  unsigned char D.22695;
  <unnamed-unsigned:1> D.22696;
  unsigned char D.22697;
  unsigned char D.22698;
  <unnamed-unsigned:1> D.22699;
  <unnamed-unsigned:1> D.22700;
  unsigned char D.22701;
  <unnamed-unsigned:1> D.22702;
  unsigned char D.22703;
  unsigned char D.22704;
  <unnamed-unsigned:1> D.22705;
  struct MonoBasicBlock * * D.22706;
  long unsigned int D.22707;
  long unsigned int D.22708;
  struct MonoBasicBlock * * D.22709;
  struct MonoBasicBlock * D.22710;
  short int D.22711;
  int D.22712;
  struct MonoBasicBlock * D.22713;
  long unsigned int D.22714;
  long unsigned int D.22715;
  short unsigned int D.22718;
  struct MonoBasicBlock * D.22721;
  _Bool D.22722;
  long int D.22723;
  long int D.22724;
  int D.22727;
  int D.22728;
  long unsigned int D.22729;
  struct MonoInst * D.22737;
  struct MonoInst * D.22740;
  struct MonoJumpInfoBBTable * iftmp.0;
  struct MonoJumpInfoBBTable * iftmp.1;
  struct MonoJumpInfoBBTable * iftmp.2;
  struct MonoJumpInfoBBTable * iftmp.3;
  struct MonoBasicBlock * * D.22759;
  long unsigned int D.22760;
  long unsigned int D.22761;
  struct MonoBasicBlock * * D.22762;
  struct MonoBasicBlock * D.22763;
  _Bool D.22766;
  long int D.22767;
  long int D.22768;
  int D.22771;
  struct MonoInst * D.22775;
  short unsigned int D.22777;
  short unsigned int D.22778;
  short unsigned int D.22780;
  short unsigned int D.22782;
  struct MonoBasicBlock * * D.22783;
  struct MonoBasicBlock * * D.22784;
  struct MonoBasicBlock * D.22785;
  _Bool D.22786;
  long int D.22787;
  long int D.22788;
  int D.22800;
  int D.22801;
  <unnamed-unsigned:1> D.22802;
  unsigned char D.22803;
  <unnamed-unsigned:1> D.22804;
  unsigned char D.22805;
  unsigned char D.22806;
  <unnamed-unsigned:1> D.22807;
  <unnamed-unsigned:1> D.22808;
  unsigned char D.22809;
  <unnamed-unsigned:1> D.22810;
  unsigned char D.22811;
  unsigned char D.22812;
  <unnamed-unsigned:1> D.22813;
  struct MonoInst * D.22816;
  struct MonoInst * D.22819;
  struct MonoBasicBlock * D.22822;
  struct MonoBasicBlock * D.22825;
  struct MonoBasicBlock * D.22827;
  short int D.22832;
  struct MonoBasicBlock * * D.22835;
  struct MonoBasicBlock * D.22836;
  struct MonoMemPool * D.22851;
  const unsigned char * D.22852;
  struct MonoInst * inst;
  struct MonoBasicBlock * prev_bb;
  int i;

  D.22694 = bb->has_array_access;
  D.22695 = (unsigned char) D.22694;
  D.22696 = bbn->has_array_access;
  D.22697 = (unsigned char) D.22696;
  D.22698 = D.22695 | D.22697;
  D.22699 = (<unnamed-unsigned:1>) D.22698;
  bb->has_array_access = D.22699;
  D.22700 = bb->extended;
  D.22701 = (unsigned char) D.22700;
  D.22702 = bbn->extended;
  D.22703 = (unsigned char) D.22702;
  D.22704 = D.22701 | D.22703;
  D.22705 = (<unnamed-unsigned:1>) D.22704;
  bb->extended = D.22705;
  mono_unlink_bblock (cfg, bb, bbn);
  i = 0;
  goto <D.22459>;
  <D.22458>:
  D.22706 = bbn->out_bb;
  D.22707 = (long unsigned int) i;
  D.22708 = D.22707 * 8;
  D.22709 = D.22706 + D.22708;
  D.22710 = *D.22709;
  mono_link_bblock (cfg, bb, D.22710);
  i = i + 1;
  <D.22459>:
  D.22711 = bbn->out_count;
  D.22712 = (int) D.22711;
  if (D.22712 > i) goto <D.22458>; else goto <D.22460>;
  <D.22460>:
  goto <D.22462>;
  <D.22461>:
  D.22706 = bbn->out_bb;
  D.22713 = *D.22706;
  mono_unlink_bblock (cfg, bbn, D.22713);
  <D.22462>:
  D.22711 = bbn->out_count;
  if (D.22711 != 0) goto <D.22461>; else goto <D.22463>;
  <D.22463>:
  D.22714 = BIT_FIELD_REF <*bb, 64, 1472>;
  D.22715 = D.22714 & 2097152;
  if (D.22715 != 0) goto <D.22716>; else goto <D.22717>;
  <D.22716>:
  inst = bb->code;
  goto <D.22465>;
  <D.22464>:
  D.22718 = inst->opcode;
  if (D.22718 == 735) goto <D.22719>; else goto <D.22720>;
  <D.22719>:
  D.22721 = inst->data.op[0].target_block;
  D.22722 = D.22721 != bbn;
  D.22723 = (long int) D.22722;
  D.22724 = __builtin_expect (D.22723, 0);
  if (D.22724 != 0) goto <D.22725>; else goto <D.22726>;
  <D.22725>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "branch-opts.c", 984, "inst->inst_target_bb == bbn");
  <D.22726>:
  inst->opcode = 316;
  inst->dreg = -1;
  inst->sreg3 = -1;
  D.22727 = inst->sreg3;
  inst->sreg2 = D.22727;
  D.22728 = inst->sreg2;
  inst->sreg1 = D.22728;
  <D.22720>:
  inst = inst->next;
  <D.22465>:
  if (inst != 0B) goto <D.22464>; else goto <D.22466>;
  <D.22466>:
  <D.22717>:
  D.22714 = BIT_FIELD_REF <*bb, 64, 1472>;
  D.22729 = D.22714 & 1048576;
  if (D.22729 != 0) goto <D.22730>; else goto <D.22731>;
  <D.22730>:
  inst = bb->code;
  goto <D.22473>;
  <D.22472>:
  D.22718 = inst->opcode;
  if (D.22718 == 731) goto <D.22732>; else goto <D.22735>;
  <D.22735>:
  D.22718 = inst->opcode;
  if (D.22718 == 732) goto <D.22736>; else goto <D.22733>;
  <D.22736>:
  D.22737 = inst->data.op[1].src;
  if (D.22737 == 8B) goto <D.22732>; else goto <D.22733>;
  <D.22733>:
  D.22718 = inst->opcode;
  if (D.22718 == 370) goto <D.22732>; else goto <D.22738>;
  <D.22738>:
  D.22718 = inst->opcode;
  if (D.22718 == 734) goto <D.22739>; else goto <D.22734>;
  <D.22739>:
  D.22737 = inst->data.op[1].src;
  D.22740 = D.22737->data.op[1].src;
  if (D.22740 == 8B) goto <D.22732>; else goto <D.22734>;
  <D.22732>:
  {
    int i;
    struct MonoJumpInfoBBTable * table;

    D.22718 = inst->opcode;
    if (D.22718 == 731) goto <D.22742>; else goto <D.22743>;
    <D.22742>:
    iftmp.0 = inst->data.op[0].p;
    goto <D.22744>;
    <D.22743>:
    D.22718 = inst->opcode;
    if (D.22718 == 732) goto <D.22748>; else goto <D.22746>;
    <D.22748>:
    D.22737 = inst->data.op[1].src;
    if (D.22737 == 8B) goto <D.22749>; else goto <D.22746>;
    <D.22749>:
    iftmp.1 = inst->data.op[0].p;
    goto <D.22747>;
    <D.22746>:
    D.22718 = inst->opcode;
    if (D.22718 == 370) goto <D.22751>; else goto <D.22752>;
    <D.22751>:
    iftmp.2 = inst->data.op[0].p;
    goto <D.22753>;
    <D.22752>:
    D.22718 = inst->opcode;
    if (D.22718 == 734) goto <D.22757>; else goto <D.22755>;
    <D.22757>:
    D.22737 = inst->data.op[1].src;
    D.22740 = D.22737->data.op[1].src;
    if (D.22740 == 8B) goto <D.22758>; else goto <D.22755>;
    <D.22758>:
    D.22737 = inst->data.op[1].src;
    iftmp.3 = D.22737->data.op[0].p;
    goto <D.22756>;
    <D.22755>:
    iftmp.3 = 0B;
    <D.22756>:
    iftmp.2 = iftmp.3;
    <D.22753>:
    iftmp.1 = iftmp.2;
    <D.22747>:
    iftmp.0 = iftmp.1;
    <D.22744>:
    table = iftmp.0;
    i = 0;
    goto <D.22470>;
    <D.22469>:
    D.22759 = table->table;
    D.22760 = (long unsigned int) i;
    D.22761 = D.22760 * 8;
    D.22762 = D.22759 + D.22761;
    D.22763 = *D.22762;
    if (D.22763 != 0B) goto <D.22764>; else goto <D.22765>;
    <D.22764>:
    D.22759 = table->table;
    D.22760 = (long unsigned int) i;
    D.22761 = D.22760 * 8;
    D.22762 = D.22759 + D.22761;
    D.22763 = *D.22762;
    D.22766 = D.22763 != bbn;
    D.22767 = (long int) D.22766;
    D.22768 = __builtin_expect (D.22767, 0);
    if (D.22768 != 0) goto <D.22769>; else goto <D.22770>;
    <D.22769>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "branch-opts.c", 997, "table->table [i] == bbn");
    <D.22770>:
    <D.22765>:
    D.22759 = table->table;
    D.22760 = (long unsigned int) i;
    D.22761 = D.22760 * 8;
    D.22762 = D.22759 + D.22761;
    *D.22762 = 0B;
    i = i + 1;
    <D.22470>:
    D.22771 = table->table_size;
    if (D.22771 > i) goto <D.22469>; else goto <D.22471>;
    <D.22471>:
  }
  <D.22734>:
  inst = inst->next;
  <D.22473>:
  if (inst != 0B) goto <D.22472>; else goto <D.22474>;
  <D.22474>:
  <D.22731>:
  D.22775 = bb->last_ins;
  if (D.22775 != 0B) goto <D.22776>; else goto <D.22772>;
  <D.22776>:
  D.22775 = bb->last_ins;
  D.22777 = D.22775->opcode;
  D.22778 = D.22777 + 64985;
  if (D.22778 <= 9) goto <D.22773>; else goto <D.22779>;
  <D.22779>:
  D.22775 = bb->last_ins;
  D.22777 = D.22775->opcode;
  D.22780 = D.22777 + 64878;
  if (D.22780 <= 9) goto <D.22773>; else goto <D.22781>;
  <D.22781>:
  D.22775 = bb->last_ins;
  D.22777 = D.22775->opcode;
  D.22782 = D.22777 + 64888;
  if (D.22782 <= 9) goto <D.22773>; else goto <D.22772>;
  <D.22773>:
  D.22775 = bb->last_ins;
  D.22783 = D.22775->data.op[1].many_blocks;
  D.22784 = D.22783 + 8;
  D.22785 = *D.22784;
  D.22786 = D.22785 != bbn;
  D.22787 = (long int) D.22786;
  D.22788 = __builtin_expect (D.22787, 0);
  if (D.22788 != 0) goto <D.22789>; else goto <D.22790>;
  <D.22789>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "branch-opts.c", 1005, "bb->last_ins->inst_false_bb == bbn");
  <D.22790>:
  D.22775 = bb->last_ins;
  D.22783 = D.22775->data.op[1].many_blocks;
  D.22784 = D.22783 + 8;
  *D.22784 = 0B;
  bb->extended = 1;
  goto <D.22774>;
  <D.22772>:
  D.22775 = bb->last_ins;
  if (D.22775 != 0B) goto <D.22793>; else goto <D.22794>;
  <D.22793>:
  D.22775 = bb->last_ins;
  D.22777 = D.22775->opcode;
  D.22778 = D.22777 + 64985;
  if (D.22778 <= 9) goto <D.22791>; else goto <D.22795>;
  <D.22795>:
  D.22775 = bb->last_ins;
  D.22777 = D.22775->opcode;
  D.22780 = D.22777 + 64878;
  if (D.22780 <= 9) goto <D.22791>; else goto <D.22796>;
  <D.22796>:
  D.22775 = bb->last_ins;
  D.22777 = D.22775->opcode;
  D.22782 = D.22777 + 64888;
  if (D.22782 <= 9) goto <D.22791>; else goto <D.22797>;
  <D.22797>:
  D.22775 = bb->last_ins;
  D.22777 = D.22775->opcode;
  if (D.22777 == 442) goto <D.22791>; else goto <D.22798>;
  <D.22798>:
  D.22775 = bb->last_ins;
  D.22777 = D.22775->opcode;
  if (D.22777 == 759) goto <D.22791>; else goto <D.22799>;
  <D.22799>:
  D.22775 = bb->last_ins;
  D.22777 = D.22775->opcode;
  if (D.22777 == 370) goto <D.22791>; else goto <D.22792>;
  <D.22791>:
  D.22775 = bb->last_ins;
  D.22775->opcode = 316;
  D.22775 = bb->last_ins;
  D.22775->dreg = -1;
  D.22775 = bb->last_ins;
  D.22775 = bb->last_ins;
  D.22775 = bb->last_ins;
  D.22775->sreg3 = -1;
  D.22800 = D.22775->sreg3;
  D.22775->sreg2 = D.22800;
  D.22801 = D.22775->sreg2;
  D.22775->sreg1 = D.22801;
  <D.22792>:
  <D.22794>:
  <D.22774>:
  D.22802 = bb->has_call_handler;
  D.22803 = (unsigned char) D.22802;
  D.22804 = bbn->has_call_handler;
  D.22805 = (unsigned char) D.22804;
  D.22806 = D.22803 | D.22805;
  D.22807 = (<unnamed-unsigned:1>) D.22806;
  bb->has_call_handler = D.22807;
  D.22808 = bb->has_jump_table;
  D.22809 = (unsigned char) D.22808;
  D.22810 = bbn->has_jump_table;
  D.22811 = (unsigned char) D.22810;
  D.22812 = D.22809 | D.22811;
  D.22813 = (<unnamed-unsigned:1>) D.22812;
  bb->has_jump_table = D.22813;
  D.22775 = bb->last_ins;
  if (D.22775 != 0B) goto <D.22814>; else goto <D.22815>;
  <D.22814>:
  D.22816 = bbn->code;
  if (D.22816 != 0B) goto <D.22817>; else goto <D.22818>;
  <D.22817>:
  D.22775 = bb->last_ins;
  D.22816 = bbn->code;
  D.22775->next = D.22816;
  D.22816 = bbn->code;
  D.22775 = bb->last_ins;
  D.22816->prev = D.22775;
  D.22819 = bbn->last_ins;
  bb->last_ins = D.22819;
  <D.22818>:
  goto <D.22820>;
  <D.22815>:
  D.22816 = bbn->code;
  bb->code = D.22816;
  D.22819 = bbn->last_ins;
  bb->last_ins = D.22819;
  <D.22820>:
  prev_bb = cfg->bb_entry;
  goto <D.22476>;
  <D.22475>:
  prev_bb = prev_bb->next_bb;
  <D.22476>:
  if (prev_bb != 0B) goto <D.22821>; else goto <D.22477>;
  <D.22821>:
  D.22822 = prev_bb->next_bb;
  if (D.22822 != bbn) goto <D.22475>; else goto <D.22477>;
  <D.22477>:
  if (prev_bb != 0B) goto <D.22823>; else goto <D.22824>;
  <D.22823>:
  D.22825 = bbn->next_bb;
  prev_bb->next_bb = D.22825;
  goto <D.22826>;
  <D.22824>:
  D.22827 = bb->next_bb;
  if (D.22827 == bbn) goto <D.22828>; else goto <D.22829>;
  <D.22828>:
  D.22825 = bbn->next_bb;
  bb->next_bb = D.22825;
  <D.22829>:
  <D.22826>:
  mono_nullify_basic_block (bbn);
  D.22775 = bb->last_ins;
  if (D.22775 != 0B) goto <D.22830>; else goto <D.22831>;
  <D.22830>:
  D.22832 = bb->out_count;
  if (D.22832 == 1) goto <D.22833>; else goto <D.22834>;
  <D.22833>:
  D.22835 = bb->out_bb;
  D.22836 = *D.22835;
  D.22827 = bb->next_bb;
  if (D.22836 != D.22827) goto <D.22837>; else goto <D.22838>;
  <D.22837>:
  D.22775 = bb->last_ins;
  D.22777 = D.22775->opcode;
  D.22778 = D.22777 + 64985;
  if (D.22778 > 9) goto <D.22839>; else goto <D.22840>;
  <D.22839>:
  D.22775 = bb->last_ins;
  D.22777 = D.22775->opcode;
  D.22780 = D.22777 + 64878;
  if (D.22780 > 9) goto <D.22841>; else goto <D.22842>;
  <D.22841>:
  D.22775 = bb->last_ins;
  D.22777 = D.22775->opcode;
  D.22782 = D.22777 + 64888;
  if (D.22782 > 9) goto <D.22843>; else goto <D.22844>;
  <D.22843>:
  D.22775 = bb->last_ins;
  D.22777 = D.22775->opcode;
  if (D.22777 != 442) goto <D.22845>; else goto <D.22846>;
  <D.22845>:
  D.22775 = bb->last_ins;
  D.22777 = D.22775->opcode;
  if (D.22777 != 759) goto <D.22847>; else goto <D.22848>;
  <D.22847>:
  D.22775 = bb->last_ins;
  D.22777 = D.22775->opcode;
  if (D.22777 != 370) goto <D.22849>; else goto <D.22850>;
  <D.22849>:
  D.22851 = cfg->mempool;
  inst = mono_mempool_alloc0 (D.22851, 80);
  inst->opcode = 442;
  inst->dreg = -1;
  inst->sreg3 = -1;
  D.22727 = inst->sreg3;
  inst->sreg2 = D.22727;
  D.22728 = inst->sreg2;
  inst->sreg1 = D.22728;
  D.22852 = cfg->ip;
  inst->cil_code = D.22852;
  D.22835 = bb->out_bb;
  D.22836 = *D.22835;
  inst->data.op[0].target_block = D.22836;
  D.22775 = bb->last_ins;
  if (D.22775 != 0B) goto <D.22853>; else goto <D.22854>;
  <D.22853>:
  D.22775 = bb->last_ins;
  D.22775->next = inst;
  D.22775 = bb->last_ins;
  inst->prev = D.22775;
  bb->last_ins = inst;
  goto <D.22855>;
  <D.22854>:
  bb->last_ins = inst;
  D.22775 = bb->last_ins;
  bb->code = D.22775;
  <D.22855>:
  <D.22850>:
  <D.22848>:
  <D.22846>:
  <D.22844>:
  <D.22842>:
  <D.22840>:
  <D.22838>:
  <D.22834>:
  <D.22831>:
}


mono_remove_bblock (struct MonoCompile * cfg, struct MonoBasicBlock * bb)
{
  struct MonoBasicBlock * D.22857;
  _Bool D.22858;
  long int D.22859;
  long int D.22860;
  struct MonoBasicBlock * D.22863;
  struct MonoBasicBlock * tmp_bb;

  tmp_bb = cfg->bb_entry;
  goto <D.22497>;
  <D.22496>:
  tmp_bb = tmp_bb->next_bb;
  <D.22497>:
  if (tmp_bb != 0B) goto <D.22856>; else goto <D.22498>;
  <D.22856>:
  D.22857 = tmp_bb->next_bb;
  if (D.22857 != bb) goto <D.22496>; else goto <D.22498>;
  <D.22498>:
  D.22858 = tmp_bb == 0B;
  D.22859 = (long int) D.22858;
  D.22860 = __builtin_expect (D.22859, 0);
  if (D.22860 != 0) goto <D.22861>; else goto <D.22862>;
  <D.22861>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "branch-opts.c", 1092, "tmp_bb");
  <D.22862>:
  D.22863 = bb->next_bb;
  tmp_bb->next_bb = D.22863;
}


mono_remove_critical_edges (struct MonoCompile * cfg)
{
  unsigned int D.22864;
  int D.22867;
  struct MonoBasicBlock * * D.22868;
  long unsigned int D.22869;
  long unsigned int D.22870;
  struct MonoBasicBlock * * D.22871;
  struct MonoBasicBlock * D.22872;
  int D.22873;
  short int D.22874;
  int D.22875;
  struct MonoBasicBlock * * D.22876;
  struct MonoBasicBlock * * D.22877;
  struct MonoBasicBlock * D.22878;
  int D.22879;
  short int D.22880;
  int D.22881;
  struct MonoInst * D.22882;
  long unsigned int D.22887;
  long unsigned int D.22888;
  struct MonoBasicBlock * * D.22889;
  short int D.22892;
  struct MonoInst * D.22895;
  short unsigned int D.22897;
  struct MonoMemPool * D.22898;
  unsigned int D.22899;
  unsigned int D.22900;
  unsigned int D.22901;
  int D.22902;
  unsigned int D.22903;
  int D.22904;
  struct MonoBasicBlock * D.22907;
  struct MonoBasicBlock * * D.22910;
  long unsigned int D.22911;
  long unsigned int D.22912;
  struct MonoBasicBlock * * D.22913;
  struct MonoBasicBlock * D.22914;
  int D.22917;
  int D.22918;
  const unsigned char * D.22919;
  struct MonoInst * D.22920;
  unsigned char * D.22924;
  short int D.22925;
  int D.22926;
  unsigned int D.22928;
  unsigned int D.22929;
  int D.22930;
  int D.22931;
  int D.22932;
  struct MonoInst * D.22933;
  unsigned char * D.22937;
  int D.22940;
  void * D.22941;
  struct MonoBasicBlock * * D.22942;
  void * D.22943;
  struct MonoBasicBlock * * D.22944;
  int D.22947;
  int D.22948;
  long unsigned int D.22951;
  long unsigned int D.22952;
  struct MonoBasicBlock * * D.22953;
  struct MonoBasicBlock * D.22954;
  int D.22955;
  struct MonoBasicBlock * * D.22956;
  struct MonoBasicBlock * D.22957;
  int D.22958;
  struct MonoBasicBlock * bb;
  struct MonoBasicBlock * previous_bb;

  D.22864 = cfg->verbose_level;
  if (D.22864 > 3) goto <D.22865>; else goto <D.22866>;
  <D.22865>:
  bb = cfg->bb_entry;
  goto <D.22512>;
  <D.22511>:
  {
    int i;

    D.22867 = bb->block_num;
    printf ("remove_critical_edges, BEFORE BB%d (in:", D.22867);
    i = 0;
    goto <D.22506>;
    <D.22505>:
    D.22868 = bb->in_bb;
    D.22869 = (long unsigned int) i;
    D.22870 = D.22869 * 8;
    D.22871 = D.22868 + D.22870;
    D.22872 = *D.22871;
    D.22873 = D.22872->block_num;
    printf (" %d", D.22873);
    i = i + 1;
    <D.22506>:
    D.22874 = bb->in_count;
    D.22875 = (int) D.22874;
    if (D.22875 > i) goto <D.22505>; else goto <D.22507>;
    <D.22507>:
    printf (") (out:");
    i = 0;
    goto <D.22509>;
    <D.22508>:
    D.22876 = bb->out_bb;
    D.22869 = (long unsigned int) i;
    D.22870 = D.22869 * 8;
    D.22877 = D.22876 + D.22870;
    D.22878 = *D.22877;
    D.22879 = D.22878->block_num;
    printf (" %d", D.22879);
    i = i + 1;
    <D.22509>:
    D.22880 = bb->out_count;
    D.22881 = (int) D.22880;
    if (D.22881 > i) goto <D.22508>; else goto <D.22510>;
    <D.22510>:
    printf (")");
    D.22882 = bb->last_ins;
    if (D.22882 != 0B) goto <D.22883>; else goto <D.22884>;
    <D.22883>:
    printf (" ");
    D.22882 = bb->last_ins;
    mono_print_ins (D.22882);
    <D.22884>:
    printf ("\n");
  }
  bb = bb->next_bb;
  <D.22512>:
  if (bb != 0B) goto <D.22511>; else goto <D.22513>;
  <D.22513>:
  <D.22866>:
  previous_bb = cfg->bb_entry;
  bb = previous_bb->next_bb;
  goto <D.22528>;
  <D.22527>:
  D.22874 = bb->in_count;
  if (D.22874 > 1) goto <D.22885>; else goto <D.22886>;
  <D.22885>:
  {
    int in_bb_index;

    in_bb_index = 0;
    goto <D.22525>;
    <D.22524>:
    {
      struct MonoBasicBlock * in_bb;

      D.22868 = bb->in_bb;
      D.22887 = (long unsigned int) in_bb_index;
      D.22888 = D.22887 * 8;
      D.22889 = D.22868 + D.22888;
      in_bb = *D.22889;
      D.22892 = in_bb->out_count;
      if (D.22892 > 1) goto <D.22890>; else goto <D.22893>;
      <D.22893>:
      D.22892 = in_bb->out_count;
      if (D.22892 == 1) goto <D.22894>; else goto <D.22891>;
      <D.22894>:
      D.22895 = in_bb->last_ins;
      if (D.22895 != 0B) goto <D.22896>; else goto <D.22891>;
      <D.22896>:
      D.22895 = in_bb->last_ins;
      D.22897 = D.22895->opcode;
      if (D.22897 == 759) goto <D.22890>; else goto <D.22891>;
      <D.22890>:
      {
        struct MonoBasicBlock * new_bb;

        D.22898 = cfg->mempool;
        new_bb = mono_mempool_alloc0 (D.22898, 296);
        D.22899 = cfg->num_bblocks;
        D.22900 = D.22899;
        D.22901 = D.22900 + 1;
        cfg->num_bblocks = D.22901;
        D.22902 = (int) D.22900;
        new_bb->block_num = D.22902;
        D.22903 = bb->region;
        new_bb->region = D.22903;
        D.22904 = mono_bb_is_fall_through (cfg, previous_bb);
        if (D.22904 != 0) goto <D.22905>; else goto <D.22906>;
        <D.22905>:
        D.22907 = cfg->bb_entry;
        if (D.22907 != previous_bb) goto <D.22908>; else goto <D.22909>;
        <D.22908>:
        {
          int i;

          i = 0;
          goto <D.22521>;
          <D.22520>:
          D.22910 = previous_bb->out_bb;
          D.22911 = (long unsigned int) i;
          D.22912 = D.22911 * 8;
          D.22913 = D.22910 + D.22912;
          D.22914 = *D.22913;
          if (D.22914 == bb) goto <D.22915>; else goto <D.22916>;
          <D.22915>:
          {
            struct MonoInst * jump;

            D.22898 = cfg->mempool;
            jump = mono_mempool_alloc0 (D.22898, 80);
            jump->opcode = 442;
            jump->dreg = -1;
            jump->sreg3 = -1;
            D.22917 = jump->sreg3;
            jump->sreg2 = D.22917;
            D.22918 = jump->sreg2;
            jump->sreg1 = D.22918;
            D.22919 = cfg->ip;
            jump->cil_code = D.22919;
            D.22920 = previous_bb->last_ins;
            if (D.22920 != 0B) goto <D.22921>; else goto <D.22922>;
            <D.22921>:
            D.22920 = previous_bb->last_ins;
            D.22920->next = jump;
            D.22920 = previous_bb->last_ins;
            jump->prev = D.22920;
            previous_bb->last_ins = jump;
            goto <D.22923>;
            <D.22922>:
            previous_bb->last_ins = jump;
            D.22920 = previous_bb->last_ins;
            previous_bb->code = D.22920;
            <D.22923>:
            D.22924 = previous_bb->cil_code;
            jump->cil_code = D.22924;
            jump->data.op[0].target_block = bb;
            goto <D.22519>;
          }
          <D.22916>:
          i = i + 1;
          <D.22521>:
          D.22925 = previous_bb->out_count;
          D.22926 = (int) D.22925;
          if (D.22926 > i) goto <D.22520>; else goto <D.22519>;
          <D.22519>:
        }
        goto <D.22927>;
        <D.22909>:
        {
          struct MonoInst * jump;
          struct MonoBasicBlock * new_bb_after_entry;

          D.22898 = cfg->mempool;
          new_bb_after_entry = mono_mempool_alloc0 (D.22898, 296);
          D.22899 = cfg->num_bblocks;
          D.22928 = D.22899;
          D.22929 = D.22928 + 1;
          cfg->num_bblocks = D.22929;
          D.22930 = (int) D.22928;
          new_bb_after_entry->block_num = D.22930;
          D.22903 = bb->region;
          new_bb_after_entry->region = D.22903;
          D.22898 = cfg->mempool;
          jump = mono_mempool_alloc0 (D.22898, 80);
          jump->opcode = 442;
          jump->dreg = -1;
          jump->sreg3 = -1;
          D.22931 = jump->sreg3;
          jump->sreg2 = D.22931;
          D.22932 = jump->sreg2;
          jump->sreg1 = D.22932;
          D.22919 = cfg->ip;
          jump->cil_code = D.22919;
          D.22933 = new_bb_after_entry->last_ins;
          if (D.22933 != 0B) goto <D.22934>; else goto <D.22935>;
          <D.22934>:
          D.22933 = new_bb_after_entry->last_ins;
          D.22933->next = jump;
          D.22933 = new_bb_after_entry->last_ins;
          jump->prev = D.22933;
          new_bb_after_entry->last_ins = jump;
          goto <D.22936>;
          <D.22935>:
          new_bb_after_entry->last_ins = jump;
          D.22933 = new_bb_after_entry->last_ins;
          new_bb_after_entry->code = D.22933;
          <D.22936>:
          D.22937 = bb->cil_code;
          jump->cil_code = D.22937;
          jump->data.op[0].target_block = bb;
          mono_unlink_bblock (cfg, previous_bb, bb);
          mono_link_bblock (cfg, new_bb_after_entry, bb);
          mono_link_bblock (cfg, previous_bb, new_bb_after_entry);
          previous_bb->next_bb = new_bb_after_entry;
          previous_bb = new_bb_after_entry;
          D.22864 = cfg->verbose_level;
          if (D.22864 > 2) goto <D.22938>; else goto <D.22939>;
          <D.22938>:
          D.22940 = new_bb_after_entry->block_num;
          D.22867 = bb->block_num;
          printf ("remove_critical_edges, added helper BB%d jumping to BB%d\n", D.22940, D.22867);
          <D.22939>:
        }
        <D.22927>:
        <D.22906>:
        previous_bb->next_bb = new_bb;
        new_bb->next_bb = bb;
        previous_bb = new_bb;
        D.22898 = cfg->mempool;
        D.22941 = mono_mempool_alloc (D.22898, 8);
        new_bb->in_bb = D.22941;
        D.22942 = new_bb->in_bb;
        *D.22942 = in_bb;
        new_bb->in_count = 1;
        D.22898 = cfg->mempool;
        D.22943 = mono_mempool_alloc (D.22898, 8);
        new_bb->out_bb = D.22943;
        D.22944 = new_bb->out_bb;
        *D.22944 = bb;
        new_bb->out_count = 1;
        replace_out_block (in_bb, bb, new_bb);
        replace_out_block_in_code (in_bb, bb, new_bb);
        replace_in_block (bb, in_bb, new_bb);
        D.22864 = cfg->verbose_level;
        if (D.22864 > 2) goto <D.22945>; else goto <D.22946>;
        <D.22945>:
        D.22947 = in_bb->block_num;
        D.22867 = bb->block_num;
        D.22948 = new_bb->block_num;
        printf ("remove_critical_edges, removed critical edge from BB%d to BB%d (added BB%d)\n", D.22947, D.22867, D.22948);
        <D.22946>:
      }
      <D.22891>:
    }
    in_bb_index = in_bb_index + 1;
    <D.22525>:
    D.22874 = bb->in_count;
    D.22875 = (int) D.22874;
    if (D.22875 > in_bb_index) goto <D.22524>; else goto <D.22526>;
    <D.22526>:
  }
  <D.22886>:
  previous_bb = previous_bb->next_bb;
  bb = bb->next_bb;
  <D.22528>:
  if (bb != 0B) goto <D.22527>; else goto <D.22529>;
  <D.22529>:
  D.22864 = cfg->verbose_level;
  if (D.22864 > 3) goto <D.22949>; else goto <D.22950>;
  <D.22949>:
  bb = cfg->bb_entry;
  goto <D.22538>;
  <D.22537>:
  {
    int i;

    D.22867 = bb->block_num;
    printf ("remove_critical_edges, AFTER BB%d (in:", D.22867);
    i = 0;
    goto <D.22532>;
    <D.22531>:
    D.22868 = bb->in_bb;
    D.22951 = (long unsigned int) i;
    D.22952 = D.22951 * 8;
    D.22953 = D.22868 + D.22952;
    D.22954 = *D.22953;
    D.22955 = D.22954->block_num;
    printf (" %d", D.22955);
    i = i + 1;
    <D.22532>:
    D.22874 = bb->in_count;
    D.22875 = (int) D.22874;
    if (D.22875 > i) goto <D.22531>; else goto <D.22533>;
    <D.22533>:
    printf (") (out:");
    i = 0;
    goto <D.22535>;
    <D.22534>:
    D.22876 = bb->out_bb;
    D.22951 = (long unsigned int) i;
    D.22952 = D.22951 * 8;
    D.22956 = D.22876 + D.22952;
    D.22957 = *D.22956;
    D.22958 = D.22957->block_num;
    printf (" %d", D.22958);
    i = i + 1;
    <D.22535>:
    D.22880 = bb->out_count;
    D.22881 = (int) D.22880;
    if (D.22881 > i) goto <D.22534>; else goto <D.22536>;
    <D.22536>:
    printf (")");
    D.22882 = bb->last_ins;
    if (D.22882 != 0B) goto <D.22959>; else goto <D.22960>;
    <D.22959>:
    printf (" ");
    D.22882 = bb->last_ins;
    mono_print_ins (D.22882);
    <D.22960>:
    printf ("\n");
  }
  bb = bb->next_bb;
  <D.22538>:
  if (bb != 0B) goto <D.22537>; else goto <D.22539>;
  <D.22539>:
  <D.22950>:
}


mono_bb_is_fall_through (struct MonoCompile * cfg, struct MonoBasicBlock * bb)
{
  gboolean D.22961;
  int iftmp.4;
  struct MonoBasicBlock * D.22966;
  unsigned int D.22968;
  unsigned int D.22969;
  struct MonoInst * D.22971;
  short unsigned int D.22973;
  short unsigned int D.22974;
  short unsigned int D.22976;
  short unsigned int D.22978;

  D.22966 = bb->next_bb;
  if (D.22966 != 0B) goto <D.22967>; else goto <D.22963>;
  <D.22967>:
  D.22966 = bb->next_bb;
  D.22968 = D.22966->region;
  D.22969 = bb->region;
  if (D.22968 == D.22969) goto <D.22970>; else goto <D.22963>;
  <D.22970>:
  D.22971 = bb->last_ins;
  if (D.22971 == 0B) goto <D.22964>; else goto <D.22972>;
  <D.22972>:
  D.22971 = bb->last_ins;
  D.22973 = D.22971->opcode;
  D.22974 = D.22973 + 64985;
  if (D.22974 > 9) goto <D.22975>; else goto <D.22963>;
  <D.22975>:
  D.22971 = bb->last_ins;
  D.22973 = D.22971->opcode;
  D.22976 = D.22973 + 64878;
  if (D.22976 > 9) goto <D.22977>; else goto <D.22963>;
  <D.22977>:
  D.22971 = bb->last_ins;
  D.22973 = D.22971->opcode;
  D.22978 = D.22973 + 64888;
  if (D.22978 > 9) goto <D.22979>; else goto <D.22963>;
  <D.22979>:
  D.22971 = bb->last_ins;
  D.22973 = D.22971->opcode;
  if (D.22973 != 442) goto <D.22980>; else goto <D.22963>;
  <D.22980>:
  D.22971 = bb->last_ins;
  D.22973 = D.22971->opcode;
  if (D.22973 != 759) goto <D.22981>; else goto <D.22963>;
  <D.22981>:
  D.22971 = bb->last_ins;
  D.22973 = D.22971->opcode;
  if (D.22973 != 370) goto <D.22964>; else goto <D.22963>;
  <D.22964>:
  iftmp.4 = 1;
  goto <D.22965>;
  <D.22963>:
  iftmp.4 = 0;
  <D.22965>:
  D.22961 = iftmp.4;
  return D.22961;
}


replace_out_block (struct MonoBasicBlock * bb, struct MonoBasicBlock * orig, struct MonoBasicBlock * repl)
{
  struct MonoBasicBlock * * D.22983;
  long unsigned int D.22984;
  long unsigned int D.22985;
  struct MonoBasicBlock * * D.22986;
  short int D.22991;
  long unsigned int D.22994;
  long unsigned int D.22995;
  sizetype D.22996;
  struct MonoBasicBlock * * D.22997;
  struct MonoBasicBlock * D.22998;
  short int D.22999;
  unsigned short D.23000;
  unsigned short D.23001;
  short int D.23002;
  int D.23004;
  int i;

  i = 0;
  goto <D.22391>;
  <D.22390>:
  {
    struct MonoBasicBlock * ob;

    D.22983 = bb->out_bb;
    D.22984 = (long unsigned int) i;
    D.22985 = D.22984 * 8;
    D.22986 = D.22983 + D.22985;
    ob = *D.22986;
    if (ob == orig) goto <D.22987>; else goto <D.22988>;
    <D.22987>:
    if (repl == 0B) goto <D.22989>; else goto <D.22990>;
    <D.22989>:
    D.22991 = bb->out_count;
    if (D.22991 > 1) goto <D.22992>; else goto <D.22993>;
    <D.22992>:
    D.22983 = bb->out_bb;
    D.22984 = (long unsigned int) i;
    D.22985 = D.22984 * 8;
    D.22986 = D.22983 + D.22985;
    D.22983 = bb->out_bb;
    D.22991 = bb->out_count;
    D.22994 = (long unsigned int) D.22991;
    D.22995 = D.22994 * 8;
    D.22996 = D.22995 + 18446744073709551608;
    D.22997 = D.22983 + D.22996;
    D.22998 = *D.22997;
    *D.22986 = D.22998;
    <D.22993>:
    D.22991 = bb->out_count;
    D.22999 = D.22991;
    D.23000 = (unsigned short) D.22999;
    D.23001 = D.23000 + 65535;
    D.23002 = (short int) D.23001;
    bb->out_count = D.23002;
    goto <D.23003>;
    <D.22990>:
    D.22983 = bb->out_bb;
    D.22984 = (long unsigned int) i;
    D.22985 = D.22984 * 8;
    D.22986 = D.22983 + D.22985;
    *D.22986 = repl;
    <D.23003>:
    <D.22988>:
  }
  i = i + 1;
  <D.22391>:
  D.22991 = bb->out_count;
  D.23004 = (int) D.22991;
  if (D.23004 > i) goto <D.22390>; else goto <D.22392>;
  <D.22392>:
}


replace_out_block_in_code (struct MonoBasicBlock * bb, struct MonoBasicBlock * orig, struct MonoBasicBlock * repl)
{
  short unsigned int D.23005;
  int D.23006;
  struct MonoBasicBlock * D.23007;
  struct MonoClass * D.23012;
  long int D.23013;
  struct MonoBasicBlock * * D.23014;
  long unsigned int D.23015;
  long unsigned int D.23016;
  struct MonoBasicBlock * * D.23017;
  struct MonoBasicBlock * D.23018;
  short unsigned int D.23024;
  short unsigned int D.23026;
  short unsigned int D.23028;
  struct MonoBasicBlock * D.23029;
  struct MonoBasicBlock * * D.23032;
  struct MonoBasicBlock * D.23033;
  struct MonoInst * D.23041;
  struct MonoInst * D.23044;
  struct MonoJumpInfoBBTable * iftmp.5;
  struct MonoJumpInfoBBTable * iftmp.6;
  struct MonoJumpInfoBBTable * iftmp.7;
  struct MonoJumpInfoBBTable * iftmp.8;
  struct MonoBasicBlock * * D.23063;
  long unsigned int D.23064;
  long unsigned int D.23065;
  struct MonoBasicBlock * * D.23066;
  struct MonoBasicBlock * D.23067;
  int D.23070;
  struct MonoInst * ins;

  ins = bb->code;
  goto <D.22425>;
  <D.22424>:
  D.23005 = ins->opcode;
  D.23006 = (int) D.23005;
  switch (D.23006) <default: <D.22418>, case 370: <D.22412>, case 442: <D.22409>, case 735: <D.22411>>
  <D.22409>:
  D.23007 = ins->data.op[0].target_block;
  if (D.23007 == orig) goto <D.23008>; else goto <D.23009>;
  <D.23008>:
  ins->data.op[0].target_block = repl;
  <D.23009>:
  goto <D.22410>;
  <D.22411>:
  D.23007 = ins->data.op[0].target_block;
  if (D.23007 == orig) goto <D.23010>; else goto <D.23011>;
  <D.23010>:
  ins->data.op[0].target_block = repl;
  <D.23011>:
  goto <D.22410>;
  <D.22412>:
  {
    int i;
    int n;

    D.23012 = ins->klass;
    D.23013 = (long int) D.23012;
    n = (int) D.23013;
    i = 0;
    goto <D.22416>;
    <D.22415>:
    D.23014 = ins->data.op[1].many_blocks;
    D.23015 = (long unsigned int) i;
    D.23016 = D.23015 * 8;
    D.23017 = D.23014 + D.23016;
    D.23018 = *D.23017;
    if (D.23018 == orig) goto <D.23019>; else goto <D.23020>;
    <D.23019>:
    D.23014 = ins->data.op[1].many_blocks;
    D.23015 = (long unsigned int) i;
    D.23016 = D.23015 * 8;
    D.23017 = D.23014 + D.23016;
    *D.23017 = repl;
    <D.23020>:
    i = i + 1;
    <D.22416>:
    if (i < n) goto <D.22415>; else goto <D.22417>;
    <D.22417>:
    goto <D.22410>;
  }
  <D.22418>:
  D.23005 = ins->opcode;
  D.23024 = D.23005 + 64985;
  if (D.23024 <= 9) goto <D.23021>; else goto <D.23025>;
  <D.23025>:
  D.23005 = ins->opcode;
  D.23026 = D.23005 + 64878;
  if (D.23026 <= 9) goto <D.23021>; else goto <D.23027>;
  <D.23027>:
  D.23005 = ins->opcode;
  D.23028 = D.23005 + 64888;
  if (D.23028 <= 9) goto <D.23021>; else goto <D.23022>;
  <D.23021>:
  D.23014 = ins->data.op[1].many_blocks;
  D.23029 = *D.23014;
  if (D.23029 == orig) goto <D.23030>; else goto <D.23031>;
  <D.23030>:
  D.23014 = ins->data.op[1].many_blocks;
  *D.23014 = repl;
  <D.23031>:
  D.23014 = ins->data.op[1].many_blocks;
  D.23032 = D.23014 + 8;
  D.23033 = *D.23032;
  if (D.23033 == orig) goto <D.23034>; else goto <D.23035>;
  <D.23034>:
  D.23014 = ins->data.op[1].many_blocks;
  D.23032 = D.23014 + 8;
  *D.23032 = repl;
  <D.23035>:
  goto <D.23023>;
  <D.23022>:
  D.23005 = ins->opcode;
  if (D.23005 == 731) goto <D.23036>; else goto <D.23039>;
  <D.23039>:
  D.23005 = ins->opcode;
  if (D.23005 == 732) goto <D.23040>; else goto <D.23037>;
  <D.23040>:
  D.23041 = ins->data.op[1].src;
  if (D.23041 == 8B) goto <D.23036>; else goto <D.23037>;
  <D.23037>:
  D.23005 = ins->opcode;
  if (D.23005 == 370) goto <D.23036>; else goto <D.23042>;
  <D.23042>:
  D.23005 = ins->opcode;
  if (D.23005 == 734) goto <D.23043>; else goto <D.23038>;
  <D.23043>:
  D.23041 = ins->data.op[1].src;
  D.23044 = D.23041->data.op[1].src;
  if (D.23044 == 8B) goto <D.23036>; else goto <D.23038>;
  <D.23036>:
  {
    int i;
    struct MonoJumpInfoBBTable * table;

    D.23005 = ins->opcode;
    if (D.23005 == 731) goto <D.23046>; else goto <D.23047>;
    <D.23046>:
    iftmp.5 = ins->data.op[0].p;
    goto <D.23048>;
    <D.23047>:
    D.23005 = ins->opcode;
    if (D.23005 == 732) goto <D.23052>; else goto <D.23050>;
    <D.23052>:
    D.23041 = ins->data.op[1].src;
    if (D.23041 == 8B) goto <D.23053>; else goto <D.23050>;
    <D.23053>:
    iftmp.6 = ins->data.op[0].p;
    goto <D.23051>;
    <D.23050>:
    D.23005 = ins->opcode;
    if (D.23005 == 370) goto <D.23055>; else goto <D.23056>;
    <D.23055>:
    iftmp.7 = ins->data.op[0].p;
    goto <D.23057>;
    <D.23056>:
    D.23005 = ins->opcode;
    if (D.23005 == 734) goto <D.23061>; else goto <D.23059>;
    <D.23061>:
    D.23041 = ins->data.op[1].src;
    D.23044 = D.23041->data.op[1].src;
    if (D.23044 == 8B) goto <D.23062>; else goto <D.23059>;
    <D.23062>:
    D.23041 = ins->data.op[1].src;
    iftmp.8 = D.23041->data.op[0].p;
    goto <D.23060>;
    <D.23059>:
    iftmp.8 = 0B;
    <D.23060>:
    iftmp.7 = iftmp.8;
    <D.23057>:
    iftmp.6 = iftmp.7;
    <D.23051>:
    iftmp.5 = iftmp.6;
    <D.23048>:
    table = iftmp.5;
    i = 0;
    goto <D.22422>;
    <D.22421>:
    D.23063 = table->table;
    D.23064 = (long unsigned int) i;
    D.23065 = D.23064 * 8;
    D.23066 = D.23063 + D.23065;
    D.23067 = *D.23066;
    if (D.23067 == orig) goto <D.23068>; else goto <D.23069>;
    <D.23068>:
    D.23063 = table->table;
    D.23064 = (long unsigned int) i;
    D.23065 = D.23064 * 8;
    D.23066 = D.23063 + D.23065;
    *D.23066 = repl;
    <D.23069>:
    i = i + 1;
    <D.22422>:
    D.23070 = table->table_size;
    if (D.23070 > i) goto <D.22421>; else goto <D.22423>;
    <D.22423>:
  }
  <D.23038>:
  <D.23023>:
  goto <D.22410>;
  <D.22410>:
  ins = ins->next;
  <D.22425>:
  if (ins != 0B) goto <D.22424>; else goto <D.22426>;
  <D.22426>:
}


replace_in_block (struct MonoBasicBlock * bb, struct MonoBasicBlock * orig, struct MonoBasicBlock * repl)
{
  struct MonoBasicBlock * * D.23071;
  long unsigned int D.23072;
  long unsigned int D.23073;
  struct MonoBasicBlock * * D.23074;
  short int D.23079;
  long unsigned int D.23082;
  long unsigned int D.23083;
  sizetype D.23084;
  struct MonoBasicBlock * * D.23085;
  struct MonoBasicBlock * D.23086;
  short int D.23087;
  unsigned short D.23088;
  unsigned short D.23089;
  short int D.23090;
  int D.23092;
  int i;

  i = 0;
  goto <D.22401>;
  <D.22400>:
  {
    struct MonoBasicBlock * ib;

    D.23071 = bb->in_bb;
    D.23072 = (long unsigned int) i;
    D.23073 = D.23072 * 8;
    D.23074 = D.23071 + D.23073;
    ib = *D.23074;
    if (ib == orig) goto <D.23075>; else goto <D.23076>;
    <D.23075>:
    if (repl == 0B) goto <D.23077>; else goto <D.23078>;
    <D.23077>:
    D.23079 = bb->in_count;
    if (D.23079 > 1) goto <D.23080>; else goto <D.23081>;
    <D.23080>:
    D.23071 = bb->in_bb;
    D.23072 = (long unsigned int) i;
    D.23073 = D.23072 * 8;
    D.23074 = D.23071 + D.23073;
    D.23071 = bb->in_bb;
    D.23079 = bb->in_count;
    D.23082 = (long unsigned int) D.23079;
    D.23083 = D.23082 * 8;
    D.23084 = D.23083 + 18446744073709551608;
    D.23085 = D.23071 + D.23084;
    D.23086 = *D.23085;
    *D.23074 = D.23086;
    <D.23081>:
    D.23079 = bb->in_count;
    D.23087 = D.23079;
    D.23088 = (unsigned short) D.23087;
    D.23089 = D.23088 + 65535;
    D.23090 = (short int) D.23089;
    bb->in_count = D.23090;
    goto <D.23091>;
    <D.23078>:
    D.23071 = bb->in_bb;
    D.23072 = (long unsigned int) i;
    D.23073 = D.23072 * 8;
    D.23074 = D.23071 + D.23073;
    *D.23074 = repl;
    <D.23091>:
    <D.23076>:
  }
  i = i + 1;
  <D.22401>:
  D.23079 = bb->in_count;
  D.23092 = (int) D.23079;
  if (D.23092 > i) goto <D.22400>; else goto <D.22402>;
  <D.22402>:
}


printf (const char * restrict __fmt)
{
  int D.23093;

  D.23093 = __printf_chk (1, __fmt, __builtin_va_arg_pack ());
  return D.23093;
}


mono_optimize_branches (struct MonoCompile * cfg)
{
  unsigned int D.23095;
  struct MonoBasicBlock * D.23099;
  unsigned int D.23100;
  long unsigned int D.23103;
  long unsigned int D.23104;
  int D.23107;
  short int D.23112;
  struct MonoBasicBlock * D.23115;
  unsigned int D.23118;
  unsigned int D.23121;
  int D.23124;
  struct MonoBasicBlock * D.23125;
  struct MonoBasicBlock * * D.23126;
  long unsigned int D.23127;
  long unsigned int D.23128;
  struct MonoBasicBlock * * D.23129;
  struct MonoBasicBlock * D.23130;
  short int D.23131;
  int D.23132;
  short int D.23133;
  struct MonoBasicBlock * * D.23136;
  struct MonoInst * D.23139;
  short unsigned int D.23142;
  short unsigned int D.23145;
  short unsigned int D.23147;
  short unsigned int D.23149;
  struct MonoBasicBlock * * D.23150;
  struct MonoBasicBlock * D.23151;
  int D.23154;
  int D.23155;
  struct MonoBasicBlock * D.23158;
  long unsigned int D.23165;
  long unsigned int D.23166;
  long unsigned int D.23173;
  struct MonoInst * D.23198;
  short unsigned int D.23201;
  struct MonoBasicBlock * D.23204;
  unsigned int D.23207;
  int D.23212;
  struct MonoInst * D.23226;
  struct MonoInst * D.23228;
  unsigned char D.23229;
  unsigned char D.23230;
  int D.23231;
  int D.23232;
  int D.23236;
  int D.23259;
  struct MonoBasicBlock * * D.23260;
  struct MonoBasicBlock * D.23261;
  long unsigned int D.23280;
  long unsigned int D.23281;
  int D.23290;
  struct MonoBasicBlock * * D.23293;
  struct MonoBasicBlock * D.23294;
  _Bool D.23295;
  long int D.23296;
  long int D.23297;
  long unsigned int D.23315;
  long unsigned int D.23316;
  unsigned int D.23319;
  long unsigned int D.23322;
  unsigned int D.23325;
  unsigned int D.23326;
  short unsigned int D.23327;
  int i;
  int changed;
  struct MonoBasicBlock * bb;
  struct MonoBasicBlock * bbn;
  guint32 niterations;

  changed = 0;
  D.23095 = cfg->num_bblocks;
  if (D.23095 > 1000) goto <D.23096>; else goto <D.23097>;
  <D.23096>:
  D.23095 = cfg->num_bblocks;
  niterations = D.23095 * 2;
  goto <D.23098>;
  <D.23097>:
  niterations = 1000;
  <D.23098>:
  <D.22562>:
  {
    struct MonoBasicBlock * previous_bb;

    changed = 0;
    niterations = niterations + 4294967295;
    previous_bb = cfg->bb_entry;
    D.23099 = cfg->bb_entry;
    bb = D.23099->next_bb;
    goto <D.22560>;
    <D.22559>:
    D.23100 = bb->region;
    if (D.23100 != 4294967295) goto <D.23101>; else goto <D.23102>;
    <D.23101>:
    // predicted unlikely by continue predictor.
    goto <D.22549>;
    <D.23102>:
    D.23103 = BIT_FIELD_REF <*bb, 64, 1472>;
    D.23104 = D.23103 & 131072;
    if (D.23104 == 0) goto <D.23105>; else goto <D.23106>;
    <D.23105>:
    D.23107 = remove_block_if_useless (cfg, bb, previous_bb);
    if (D.23107 != 0) goto <D.23108>; else goto <D.23109>;
    <D.23108>:
    changed = 1;
    // predicted unlikely by continue predictor.
    goto <D.22549>;
    <D.23109>:
    <D.23106>:
    bbn = bb->next_bb;
    if (bbn != 0B) goto <D.23110>; else goto <D.23111>;
    <D.23110>:
    D.23112 = bbn->in_count;
    if (D.23112 == 0) goto <D.23113>; else goto <D.23114>;
    <D.23113>:
    D.23115 = cfg->bb_exit;
    if (D.23115 != bbn) goto <D.23116>; else goto <D.23117>;
    <D.23116>:
    D.23100 = bb->region;
    D.23118 = bbn->region;
    if (D.23100 == D.23118) goto <D.23119>; else goto <D.23120>;
    <D.23119>:
    D.23121 = cfg->verbose_level;
    if (D.23121 > 2) goto <D.23122>; else goto <D.23123>;
    <D.23122>:
    D.23124 = bbn->block_num;
    monoeg_g_print ("nullify block triggered %d\n", D.23124);
    <D.23123>:
    D.23125 = bbn->next_bb;
    bb->next_bb = D.23125;
    i = 0;
    goto <D.22551>;
    <D.22550>:
    D.23126 = bbn->out_bb;
    D.23127 = (long unsigned int) i;
    D.23128 = D.23127 * 8;
    D.23129 = D.23126 + D.23128;
    D.23130 = *D.23129;
    replace_in_block (D.23130, bbn, 0B);
    i = i + 1;
    <D.22551>:
    D.23131 = bbn->out_count;
    D.23132 = (int) D.23131;
    if (D.23132 > i) goto <D.22550>; else goto <D.22552>;
    <D.22552>:
    mono_nullify_basic_block (bbn);
    changed = 1;
    <D.23120>:
    <D.23117>:
    <D.23114>:
    <D.23111>:
    D.23133 = bb->out_count;
    if (D.23133 == 1) goto <D.23134>; else goto <D.23135>;
    <D.23134>:
    D.23136 = bb->out_bb;
    bbn = *D.23136;
    D.23139 = bb->last_ins;
    if (D.23139 != 0B) goto <D.23140>; else goto <D.23141>;
    <D.23140>:
    D.23139 = bb->last_ins;
    D.23142 = D.23139->opcode;
    if (D.23142 != 442) goto <D.23143>; else goto <D.23144>;
    <D.23143>:
    D.23139 = bb->last_ins;
    D.23142 = D.23139->opcode;
    D.23145 = D.23142 + 64985;
    if (D.23145 <= 9) goto <D.23137>; else goto <D.23146>;
    <D.23146>:
    D.23139 = bb->last_ins;
    D.23142 = D.23139->opcode;
    D.23147 = D.23142 + 64878;
    if (D.23147 <= 9) goto <D.23137>; else goto <D.23148>;
    <D.23148>:
    D.23139 = bb->last_ins;
    D.23142 = D.23139->opcode;
    D.23149 = D.23142 + 64888;
    if (D.23149 <= 9) goto <D.23137>; else goto <D.23138>;
    <D.23137>:
    D.23139 = bb->last_ins;
    D.23139->opcode = 442;
    D.23139 = bb->last_ins;
    D.23139 = bb->last_ins;
    D.23150 = D.23139->data.op[1].many_blocks;
    D.23151 = *D.23150;
    D.23139->data.op[0].target_block = D.23151;
    changed = 1;
    D.23121 = cfg->verbose_level;
    if (D.23121 > 2) goto <D.23152>; else goto <D.23153>;
    <D.23152>:
    D.23154 = bb->block_num;
    D.23133 = bb->out_count;
    D.23155 = (int) D.23133;
    monoeg_g_print ("cond branch removal triggered in %d %d\n", D.23154, D.23155);
    <D.23153>:
    <D.23138>:
    <D.23144>:
    <D.23141>:
    D.23100 = bb->region;
    D.23118 = bbn->region;
    if (D.23100 == D.23118) goto <D.23156>; else goto <D.23157>;
    <D.23156>:
    D.23158 = bb->next_bb;
    if (D.23158 == bbn) goto <D.23159>; else goto <D.23160>;
    <D.23159>:
    D.23139 = bb->last_ins;
    if (D.23139 != 0B) goto <D.23161>; else goto <D.23162>;
    <D.23161>:
    D.23139 = bb->last_ins;
    D.23142 = D.23139->opcode;
    if (D.23142 == 442) goto <D.23163>; else goto <D.23164>;
    <D.23163>:
    D.23165 = BIT_FIELD_REF <*bbn, 64, 1472>;
    D.23166 = D.23165 & 65536;
    if (D.23166 == 0) goto <D.23167>; else goto <D.23168>;
    <D.23167>:
    D.23139 = bb->last_ins;
    D.23139->opcode = 316;
    changed = 1;
    D.23121 = cfg->verbose_level;
    if (D.23121 > 2) goto <D.23169>; else goto <D.23170>;
    <D.23169>:
    D.23154 = bb->block_num;
    D.23124 = bbn->block_num;
    monoeg_g_print ("br removal triggered %d -> %d\n", D.23154, D.23124);
    <D.23170>:
    <D.23168>:
    <D.23164>:
    <D.23162>:
    D.23112 = bbn->in_count;
    if (D.23112 == 1) goto <D.23171>; else goto <D.23172>;
    <D.23171>:
    D.23103 = BIT_FIELD_REF <*bb, 64, 1472>;
    D.23173 = D.23103 & 524288;
    if (D.23173 == 0) goto <D.23174>; else goto <D.23175>;
    <D.23174>:
    D.23115 = cfg->bb_exit;
    if (D.23115 != bbn) goto <D.23176>; else goto <D.23177>;
    <D.23176>:
    D.23121 = cfg->verbose_level;
    if (D.23121 > 2) goto <D.23178>; else goto <D.23179>;
    <D.23178>:
    D.23154 = bb->block_num;
    D.23124 = bbn->block_num;
    monoeg_g_print ("block merge triggered %d -> %d\n", D.23154, D.23124);
    <D.23179>:
    mono_merge_basic_blocks (cfg, bb, bbn);
    changed = 1;
    // predicted unlikely by continue predictor.
    goto <D.22549>;
    <D.23177>:
    <D.23175>:
    <D.23172>:
    <D.23160>:
    <D.23157>:
    <D.23135>:
    bbn = bb->next_bb;
    if (bbn != 0B) goto <D.23180>; else goto <D.23181>;
    <D.23180>:
    D.23112 = bbn->in_count;
    if (D.23112 == 0) goto <D.23182>; else goto <D.23183>;
    <D.23182>:
    D.23115 = cfg->bb_exit;
    if (D.23115 != bbn) goto <D.23184>; else goto <D.23185>;
    <D.23184>:
    D.23100 = bb->region;
    D.23118 = bbn->region;
    if (D.23100 == D.23118) goto <D.23186>; else goto <D.23187>;
    <D.23186>:
    D.23121 = cfg->verbose_level;
    if (D.23121 > 2) goto <D.23188>; else goto <D.23189>;
    <D.23188>:
    D.23124 = bbn->block_num;
    monoeg_g_print ("nullify block triggered %d\n", D.23124);
    <D.23189>:
    D.23125 = bbn->next_bb;
    bb->next_bb = D.23125;
    i = 0;
    goto <D.22554>;
    <D.22553>:
    D.23126 = bbn->out_bb;
    D.23127 = (long unsigned int) i;
    D.23128 = D.23127 * 8;
    D.23129 = D.23126 + D.23128;
    D.23130 = *D.23129;
    replace_in_block (D.23130, bbn, 0B);
    i = i + 1;
    <D.22554>:
    D.23131 = bbn->out_count;
    D.23132 = (int) D.23131;
    if (D.23132 > i) goto <D.22553>; else goto <D.22555>;
    <D.22555>:
    mono_nullify_basic_block (bbn);
    changed = 1;
    // predicted unlikely by continue predictor.
    goto <D.22549>;
    <D.23187>:
    <D.23185>:
    <D.23183>:
    <D.23181>:
    D.23133 = bb->out_count;
    if (D.23133 == 1) goto <D.23190>; else goto <D.23191>;
    <D.23190>:
    D.23136 = bb->out_bb;
    bbn = *D.23136;
    D.23139 = bb->last_ins;
    if (D.23139 != 0B) goto <D.23192>; else goto <D.23193>;
    <D.23192>:
    D.23139 = bb->last_ins;
    D.23142 = D.23139->opcode;
    if (D.23142 == 442) goto <D.23194>; else goto <D.23195>;
    <D.23194>:
    D.23139 = bb->last_ins;
    bbn = D.23139->data.op[0].target_block;
    D.23100 = bb->region;
    D.23118 = bbn->region;
    if (D.23100 == D.23118) goto <D.23196>; else goto <D.23197>;
    <D.23196>:
    D.23198 = bbn->code;
    if (D.23198 != 0B) goto <D.23199>; else goto <D.23200>;
    <D.23199>:
    D.23198 = bbn->code;
    D.23201 = D.23198->opcode;
    if (D.23201 == 442) goto <D.23202>; else goto <D.23203>;
    <D.23202>:
    D.23198 = bbn->code;
    D.23204 = D.23198->data.op[0].target_block;
    if (D.23204 != bbn) goto <D.23205>; else goto <D.23206>;
    <D.23205>:
    D.23198 = bbn->code;
    D.23204 = D.23198->data.op[0].target_block;
    D.23207 = D.23204->region;
    D.23100 = bb->region;
    if (D.23207 == D.23100) goto <D.23208>; else goto <D.23209>;
    <D.23208>:
    D.23121 = cfg->verbose_level;
    if (D.23121 > 2) goto <D.23210>; else goto <D.23211>;
    <D.23210>:
    D.23154 = bb->block_num;
    D.23124 = bbn->block_num;
    D.23198 = bbn->code;
    D.23204 = D.23198->data.op[0].target_block;
    D.23212 = D.23204->block_num;
    monoeg_g_print ("branch to branch triggered %d -> %d -> %d\n", D.23154, D.23124, D.23212);
    <D.23211>:
    replace_in_block (bbn, bb, 0B);
    D.23198 = bbn->code;
    D.23204 = D.23198->data.op[0].target_block;
    replace_out_block (bb, bbn, D.23204);
    D.23198 = bbn->code;
    D.23204 = D.23198->data.op[0].target_block;
    mono_link_bblock (cfg, bb, D.23204);
    D.23139 = bb->last_ins;
    D.23198 = bbn->code;
    D.23204 = D.23198->data.op[0].target_block;
    D.23139->data.op[0].target_block = D.23204;
    changed = 1;
    // predicted unlikely by continue predictor.
    goto <D.22549>;
    <D.23209>:
    <D.23206>:
    <D.23203>:
    <D.23200>:
    <D.23197>:
    <D.23195>:
    <D.23193>:
    goto <D.23213>;
    <D.23191>:
    D.23133 = bb->out_count;
    if (D.23133 == 2) goto <D.23214>; else goto <D.23215>;
    <D.23214>:
    D.23139 = bb->last_ins;
    if (D.23139 != 0B) goto <D.23220>; else goto <D.23221>;
    <D.23220>:
    D.23139 = bb->last_ins;
    D.23142 = D.23139->opcode;
    D.23145 = D.23142 + 64985;
    if (D.23145 <= 9) goto <D.23218>; else goto <D.23222>;
    <D.23222>:
    D.23139 = bb->last_ins;
    D.23142 = D.23139->opcode;
    D.23147 = D.23142 + 64878;
    if (D.23147 <= 9) goto <D.23218>; else goto <D.23223>;
    <D.23223>:
    D.23139 = bb->last_ins;
    D.23142 = D.23139->opcode;
    D.23149 = D.23142 + 64888;
    if (D.23149 <= 9) goto <D.23218>; else goto <D.23219>;
    <D.23218>:
    D.23139 = bb->last_ins;
    D.23142 = D.23139->opcode;
    D.23147 = D.23142 + 64878;
    if (D.23147 > 9) goto <D.23224>; else goto <D.23225>;
    <D.23224>:
    D.23139 = bb->last_ins;
    D.23226 = D.23139->data.op[0].src;
    if (D.23226 == 0B) goto <D.23216>; else goto <D.23227>;
    <D.23227>:
    D.23139 = bb->last_ins;
    D.23226 = D.23139->data.op[0].src;
    D.23228 = D.23226->data.op[0].src;
    D.23229 = D.23228->type;
    if (D.23229 != 4) goto <D.23216>; else goto <D.23217>;
    <D.23216>:
    {
      int branch_result;
      struct MonoBasicBlock * taken_branch_target;
      struct MonoBasicBlock * untaken_branch_target;

      taken_branch_target = 0B;
      untaken_branch_target = 0B;
      D.23139 = bb->last_ins;
      D.23230 = D.23139->flags;
      D.23231 = (int) D.23230;
      D.23232 = D.23231 & 8;
      if (D.23232 != 0) goto <D.23233>; else goto <D.23234>;
      <D.23233>:
      branch_result = 1;
      goto <D.23235>;
      <D.23234>:
      D.23139 = bb->last_ins;
      D.23230 = D.23139->flags;
      D.23231 = (int) D.23230;
      D.23236 = D.23231 & 16;
      if (D.23236 != 0) goto <D.23237>; else goto <D.23238>;
      <D.23237>:
      branch_result = 0;
      goto <D.23239>;
      <D.23238>:
      branch_result = 2;
      <D.23239>:
      <D.23235>:
      if (branch_result == 1) goto <D.23240>; else goto <D.23241>;
      <D.23240>:
      D.23139 = bb->last_ins;
      D.23150 = D.23139->data.op[1].many_blocks;
      taken_branch_target = *D.23150;
      D.23139 = bb->last_ins;
      D.23150 = D.23139->data.op[1].many_blocks;
      untaken_branch_target = MEM[(struct MonoBasicBlock * *)D.23150 + 8B];
      goto <D.23242>;
      <D.23241>:
      if (branch_result == 0) goto <D.23243>; else goto <D.23244>;
      <D.23243>:
      D.23139 = bb->last_ins;
      D.23150 = D.23139->data.op[1].many_blocks;
      taken_branch_target = MEM[(struct MonoBasicBlock * *)D.23150 + 8B];
      D.23139 = bb->last_ins;
      D.23150 = D.23139->data.op[1].many_blocks;
      untaken_branch_target = *D.23150;
      <D.23244>:
      <D.23242>:
      if (taken_branch_target != 0B) goto <D.23245>; else goto <D.23246>;
      <D.23245>:
      D.23139 = bb->last_ins;
      D.23139->opcode = 442;
      D.23139 = bb->last_ins;
      D.23139->data.op[0].target_block = taken_branch_target;
      D.23103 = BIT_FIELD_REF <*bb, 64, 1472>;
      D.23173 = D.23103 & 524288;
      if (D.23173 == 0) goto <D.23247>; else goto <D.23248>;
      <D.23247>:
      mono_unlink_bblock (cfg, bb, untaken_branch_target);
      <D.23248>:
      changed = 1;
      // predicted unlikely by continue predictor.
      goto <D.22549>;
      <D.23246>:
      D.23139 = bb->last_ins;
      D.23150 = D.23139->data.op[1].many_blocks;
      bbn = *D.23150;
      D.23100 = bb->region;
      D.23118 = bbn->region;
      if (D.23100 == D.23118) goto <D.23249>; else goto <D.23250>;
      <D.23249>:
      D.23198 = bbn->code;
      if (D.23198 != 0B) goto <D.23251>; else goto <D.23252>;
      <D.23251>:
      D.23198 = bbn->code;
      D.23201 = D.23198->opcode;
      if (D.23201 == 442) goto <D.23253>; else goto <D.23254>;
      <D.23253>:
      D.23198 = bbn->code;
      D.23204 = D.23198->data.op[0].target_block;
      D.23207 = D.23204->region;
      D.23100 = bb->region;
      if (D.23207 == D.23100) goto <D.23255>; else goto <D.23256>;
      <D.23255>:
      D.23121 = cfg->verbose_level;
      if (D.23121 > 2) goto <D.23257>; else goto <D.23258>;
      <D.23257>:
      D.23154 = bb->block_num;
      D.23124 = bbn->block_num;
      D.23198 = bbn->code;
      D.23204 = D.23198->data.op[0].target_block;
      D.23212 = D.23204->block_num;
      D.23198 = bbn->code;
      D.23201 = D.23198->opcode;
      D.23259 = (int) D.23201;
      monoeg_g_print ("cbranch1 to branch triggered %d -> (%d) %d (0x%02x)\n", D.23154, D.23124, D.23212, D.23259);
      <D.23258>:
      D.23139 = bb->last_ins;
      D.23150 = D.23139->data.op[1].many_blocks;
      D.23151 = *D.23150;
      mono_unlink_bblock (cfg, bb, D.23151);
      D.23139 = bb->last_ins;
      D.23150 = D.23139->data.op[1].many_blocks;
      D.23260 = D.23150 + 8;
      D.23261 = *D.23260;
      mono_unlink_bblock (cfg, bb, D.23261);
      D.23139 = bb->last_ins;
      D.23150 = D.23139->data.op[1].many_blocks;
      D.23198 = bbn->code;
      D.23204 = D.23198->data.op[0].target_block;
      *D.23150 = D.23204;
      D.23139 = bb->last_ins;
      D.23150 = D.23139->data.op[1].many_blocks;
      D.23151 = *D.23150;
      mono_link_bblock (cfg, bb, D.23151);
      D.23139 = bb->last_ins;
      D.23150 = D.23139->data.op[1].many_blocks;
      D.23260 = D.23150 + 8;
      D.23261 = *D.23260;
      mono_link_bblock (cfg, bb, D.23261);
      changed = 1;
      // predicted unlikely by continue predictor.
      goto <D.22549>;
      <D.23256>:
      <D.23254>:
      <D.23252>:
      <D.23250>:
      D.23139 = bb->last_ins;
      D.23150 = D.23139->data.op[1].many_blocks;
      bbn = MEM[(struct MonoBasicBlock * *)D.23150 + 8B];
      if (bbn != 0B) goto <D.23262>; else goto <D.23263>;
      <D.23262>:
      D.23100 = bb->region;
      D.23118 = bbn->region;
      if (D.23100 == D.23118) goto <D.23264>; else goto <D.23265>;
      <D.23264>:
      D.23198 = bbn->code;
      if (D.23198 != 0B) goto <D.23266>; else goto <D.23267>;
      <D.23266>:
      D.23198 = bbn->code;
      D.23201 = D.23198->opcode;
      if (D.23201 == 442) goto <D.23268>; else goto <D.23269>;
      <D.23268>:
      D.23198 = bbn->code;
      D.23204 = D.23198->data.op[0].target_block;
      D.23207 = D.23204->region;
      D.23100 = bb->region;
      if (D.23207 == D.23100) goto <D.23270>; else goto <D.23271>;
      <D.23270>:
      D.23121 = cfg->verbose_level;
      if (D.23121 > 2) goto <D.23272>; else goto <D.23273>;
      <D.23272>:
      D.23154 = bb->block_num;
      D.23124 = bbn->block_num;
      D.23198 = bbn->code;
      D.23204 = D.23198->data.op[0].target_block;
      D.23212 = D.23204->block_num;
      D.23198 = bbn->code;
      D.23201 = D.23198->opcode;
      D.23259 = (int) D.23201;
      monoeg_g_print ("cbranch2 to branch triggered %d -> (%d) %d (0x%02x)\n", D.23154, D.23124, D.23212, D.23259);
      <D.23273>:
      D.23139 = bb->last_ins;
      D.23150 = D.23139->data.op[1].many_blocks;
      D.23151 = *D.23150;
      mono_unlink_bblock (cfg, bb, D.23151);
      D.23139 = bb->last_ins;
      D.23150 = D.23139->data.op[1].many_blocks;
      D.23260 = D.23150 + 8;
      D.23261 = *D.23260;
      mono_unlink_bblock (cfg, bb, D.23261);
      D.23139 = bb->last_ins;
      D.23150 = D.23139->data.op[1].many_blocks;
      D.23260 = D.23150 + 8;
      D.23198 = bbn->code;
      D.23204 = D.23198->data.op[0].target_block;
      *D.23260 = D.23204;
      D.23139 = bb->last_ins;
      D.23150 = D.23139->data.op[1].many_blocks;
      D.23151 = *D.23150;
      mono_link_bblock (cfg, bb, D.23151);
      D.23139 = bb->last_ins;
      D.23150 = D.23139->data.op[1].many_blocks;
      D.23260 = D.23150 + 8;
      D.23261 = *D.23260;
      mono_link_bblock (cfg, bb, D.23261);
      changed = 1;
      // predicted unlikely by continue predictor.
      goto <D.22549>;
      <D.23271>:
      <D.23269>:
      <D.23267>:
      <D.23265>:
      <D.23263>:
      D.23139 = bb->last_ins;
      D.23150 = D.23139->data.op[1].many_blocks;
      bbn = MEM[(struct MonoBasicBlock * *)D.23150 + 8B];
      if (bbn != 0B) goto <D.23274>; else goto <D.23275>;
      <D.23274>:
      D.23100 = bb->region;
      D.23118 = bbn->region;
      if (D.23100 == D.23118) goto <D.23276>; else goto <D.23277>;
      <D.23276>:
      D.23112 = bbn->in_count;
      if (D.23112 == 1) goto <D.23278>; else goto <D.23279>;
      <D.23278>:
      D.23280 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.23281 = D.23280 & 34359738368;
      if (D.23281 != 0) goto <D.23282>; else goto <D.23283>;
      <D.23282>:
      D.23115 = cfg->bb_exit;
      if (D.23115 != bbn) goto <D.23284>; else goto <D.23285>;
      <D.23284>:
      D.23103 = BIT_FIELD_REF <*bb, 64, 1472>;
      D.23173 = D.23103 & 524288;
      if (D.23173 == 0) goto <D.23286>; else goto <D.23287>;
      <D.23286>:
      D.23165 = BIT_FIELD_REF <*bbn, 64, 1472>;
      D.23166 = D.23165 & 65536;
      if (D.23166 == 0) goto <D.23288>; else goto <D.23289>;
      <D.23288>:
      D.23290 = mono_bblocks_linked (bbn, bb);
      if (D.23290 == 0) goto <D.23291>; else goto <D.23292>;
      <D.23291>:
      D.23293 = bbn->in_bb;
      D.23294 = *D.23293;
      D.23295 = D.23294 != bb;
      D.23296 = (long int) D.23295;
      D.23297 = __builtin_expect (D.23296, 0);
      if (D.23297 != 0) goto <D.23298>; else goto <D.23299>;
      <D.23298>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "branch-opts.c", 1432, "bbn->in_bb [0] == bb");
      <D.23299>:
      D.23121 = cfg->verbose_level;
      if (D.23121 > 2) goto <D.23300>; else goto <D.23301>;
      <D.23300>:
      D.23154 = bb->block_num;
      D.23124 = bbn->block_num;
      monoeg_g_print ("merge false branch target triggered BB%d -> BB%d\n", D.23154, D.23124);
      <D.23301>:
      mono_merge_basic_blocks (cfg, bb, bbn);
      changed = 1;
      // predicted unlikely by continue predictor.
      goto <D.22549>;
      <D.23292>:
      <D.23289>:
      <D.23287>:
      <D.23285>:
      <D.23283>:
      <D.23279>:
      <D.23277>:
      <D.23275>:
    }
    <D.23217>:
    <D.23225>:
    <D.23219>:
    <D.23221>:
    D.23139 = bb->last_ins;
    if (D.23139 != 0B) goto <D.23306>; else goto <D.23307>;
    <D.23306>:
    D.23139 = bb->last_ins;
    D.23142 = D.23139->opcode;
    D.23145 = D.23142 + 64985;
    if (D.23145 <= 9) goto <D.23304>; else goto <D.23308>;
    <D.23308>:
    D.23139 = bb->last_ins;
    D.23142 = D.23139->opcode;
    D.23147 = D.23142 + 64878;
    if (D.23147 <= 9) goto <D.23304>; else goto <D.23309>;
    <D.23309>:
    D.23139 = bb->last_ins;
    D.23142 = D.23139->opcode;
    D.23149 = D.23142 + 64888;
    if (D.23149 <= 9) goto <D.23304>; else goto <D.23305>;
    <D.23304>:
    D.23139 = bb->last_ins;
    D.23142 = D.23139->opcode;
    D.23147 = D.23142 + 64878;
    if (D.23147 > 9) goto <D.23310>; else goto <D.23311>;
    <D.23310>:
    D.23139 = bb->last_ins;
    D.23226 = D.23139->data.op[0].src;
    if (D.23226 == 0B) goto <D.23302>; else goto <D.23312>;
    <D.23312>:
    D.23139 = bb->last_ins;
    D.23226 = D.23139->data.op[0].src;
    D.23228 = D.23226->data.op[0].src;
    D.23229 = D.23228->type;
    if (D.23229 != 4) goto <D.23302>; else goto <D.23303>;
    <D.23302>:
    D.23139 = bb->last_ins;
    D.23150 = D.23139->data.op[1].many_blocks;
    D.23260 = D.23150 + 8;
    D.23261 = *D.23260;
    if (D.23261 != 0B) goto <D.23313>; else goto <D.23314>;
    <D.23313>:
    D.23139 = bb->last_ins;
    D.23150 = D.23139->data.op[1].many_blocks;
    D.23260 = D.23150 + 8;
    D.23261 = *D.23260;
    D.23315 = BIT_FIELD_REF <*D.23261, 64, 1472>;
    D.23316 = D.23315 & 65536;
    if (D.23316 != 0) goto <D.23317>; else goto <D.23318>;
    <D.23317>:
    D.23100 = bb->region;
    D.23139 = bb->last_ins;
    D.23150 = D.23139->data.op[1].many_blocks;
    D.23260 = D.23150 + 8;
    D.23261 = *D.23260;
    D.23319 = D.23261->region;
    if (D.23100 == D.23319) goto <D.23320>; else goto <D.23321>;
    <D.23320>:
    D.23280 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.23322 = D.23280 & 72057594037927936;
    if (D.23322 == 0) goto <D.23323>; else goto <D.23324>;
    <D.23323>:
    D.23139 = bb->last_ins;
    D.23139 = bb->last_ins;
    D.23142 = D.23139->opcode;
    D.23325 = (unsigned int) D.23142;
    D.23326 = mono_reverse_branch_op (D.23325);
    D.23327 = (short unsigned int) D.23326;
    D.23139->opcode = D.23327;
    D.23139 = bb->last_ins;
    D.23150 = D.23139->data.op[1].many_blocks;
    bbn = MEM[(struct MonoBasicBlock * *)D.23150 + 8B];
    D.23139 = bb->last_ins;
    D.23150 = D.23139->data.op[1].many_blocks;
    D.23260 = D.23150 + 8;
    D.23139 = bb->last_ins;
    D.23150 = D.23139->data.op[1].many_blocks;
    D.23151 = *D.23150;
    *D.23260 = D.23151;
    D.23139 = bb->last_ins;
    D.23150 = D.23139->data.op[1].many_blocks;
    *D.23150 = bbn;
    D.23139 = bb->last_ins;
    D.23150 = D.23139->data.op[1].many_blocks;
    D.23151 = *D.23150;
    move_basic_block_to_end (cfg, D.23151);
    D.23121 = cfg->verbose_level;
    if (D.23121 > 2) goto <D.23328>; else goto <D.23329>;
    <D.23328>:
    D.23154 = bb->block_num;
    monoeg_g_print ("cbranch to throw block triggered %d.\n", D.23154);
    <D.23329>:
    <D.23324>:
    <D.23321>:
    <D.23318>:
    <D.23314>:
    <D.23303>:
    <D.23311>:
    <D.23305>:
    <D.23307>:
    <D.23215>:
    <D.23213>:
    <D.22549>:
    previous_bb = bb;
    bb = bb->next_bb;
    <D.22560>:
    if (bb != 0B) goto <D.22559>; else goto <D.22561>;
    <D.22561>:
  }
  if (changed != 0) goto <D.23330>; else goto <D.22563>;
  <D.23330>:
  if (niterations != 0) goto <D.22562>; else goto <D.22563>;
  <D.22563>:
}


remove_block_if_useless (struct MonoCompile * cfg, struct MonoBasicBlock * bb, struct MonoBasicBlock * previous_bb)
{
  unsigned int D.23331;
  gboolean D.23334;
  short unsigned int D.23335;
  int D.23336;
  short int D.23341;
  struct MonoBasicBlock * * D.23343;
  struct MonoBasicBlock * D.23344;
  struct MonoBasicBlock * D.23345;
  struct MonoInst * D.23347;
  short unsigned int D.23350;
  struct MonoBasicBlock * D.23353;
  unsigned int D.23358;
  unsigned int D.23359;
  unsigned int D.23365;
  int D.23368;
  struct MonoBasicBlock * * D.23369;
  short int D.23370;
  int D.23373;
  struct MonoBasicBlock * * D.23376;
  long unsigned int D.23377;
  long unsigned int D.23378;
  struct MonoBasicBlock * * D.23379;
  struct MonoBasicBlock * D.23380;
  struct MonoMemPool * D.23383;
  int D.23384;
  int D.23385;
  const unsigned char * D.23386;
  unsigned char * D.23390;
  short int D.23391;
  int D.23392;
  struct MonoBasicBlock * target_bb;
  struct MonoInst * inst;

  target_bb = 0B;
  D.23331 = bb->region;
  if (D.23331 != 4294967295) goto <D.23332>; else goto <D.23333>;
  <D.23332>:
  bb->not_useless = 1;
  D.23334 = 0;
  return D.23334;
  <D.23333>:
  inst = bb->code;
  goto <D.22439>;
  <D.22438>:
  D.23335 = inst->opcode;
  D.23336 = (int) D.23335;
  switch (D.23336) <default: <D.22437>, case 316: <D.22434>, case 442: <D.22436>>
  <D.22434>:
  goto <D.22435>;
  <D.22436>:
  target_bb = inst->data.op[0].target_block;
  goto <D.22435>;
  <D.22437>:
  bb->not_useless = 1;
  D.23334 = 0;
  return D.23334;
  <D.22435>:
  inst = inst->next;
  <D.22439>:
  if (inst != 0B) goto <D.22438>; else goto <D.22440>;
  <D.22440>:
  if (target_bb == 0B) goto <D.23337>; else goto <D.23338>;
  <D.23337>:
  D.23341 = bb->out_count;
  if (D.23341 == 1) goto <D.23342>; else goto <D.23339>;
  <D.23342>:
  D.23343 = bb->out_bb;
  D.23344 = *D.23343;
  D.23345 = bb->next_bb;
  if (D.23344 == D.23345) goto <D.23346>; else goto <D.23339>;
  <D.23346>:
  target_bb = bb->next_bb;
  goto <D.23340>;
  <D.23339>:
  D.23334 = 0;
  return D.23334;
  <D.23340>:
  <D.23338>:
  D.23347 = previous_bb->last_ins;
  if (D.23347 != 0B) goto <D.23348>; else goto <D.23349>;
  <D.23348>:
  D.23347 = previous_bb->last_ins;
  D.23350 = D.23347->opcode;
  if (D.23350 == 370) goto <D.23351>; else goto <D.23352>;
  <D.23351>:
  D.23334 = 0;
  return D.23334;
  <D.23352>:
  <D.23349>:
  D.23353 = cfg->bb_entry;
  if (D.23353 == previous_bb) goto <D.23354>; else goto <D.23355>;
  <D.23354>:
  D.23345 = bb->next_bb;
  if (D.23345 != target_bb) goto <D.23356>; else goto <D.23357>;
  <D.23356>:
  D.23334 = 0;
  return D.23334;
  <D.23357>:
  <D.23355>:
  D.23358 = previous_bb->region;
  D.23359 = D.23358 & 240;
  if (D.23359 == 0) goto <D.23360>; else goto <D.23361>;
  <D.23360>:
  D.23334 = 0;
  return D.23334;
  <D.23361>:
  if (target_bb != 0B) goto <D.23363>; else goto <D.23362>;
  <D.23363>:
  if (target_bb != bb) goto <D.23364>; else goto <D.23362>;
  <D.23364>:
  {
    int i;

    D.23365 = cfg->verbose_level;
    if (D.23365 > 1) goto <D.23366>; else goto <D.23367>;
    <D.23366>:
    D.23368 = bb->block_num;
    printf ("remove_block_if_useless, removed BB%d\n", D.23368);
    <D.23367>:
    goto <D.22444>;
    <D.22443>:
    {
      struct MonoBasicBlock * in_bb;

      D.23369 = bb->in_bb;
      in_bb = *D.23369;
      mono_unlink_bblock (cfg, in_bb, bb);
      mono_link_bblock (cfg, in_bb, target_bb);
      replace_out_block_in_code (in_bb, bb, target_bb);
    }
    <D.22444>:
    D.23370 = bb->in_count;
    if (D.23370 != 0) goto <D.22443>; else goto <D.22445>;
    <D.22445>:
    mono_unlink_bblock (cfg, bb, target_bb);
    D.23353 = cfg->bb_entry;
    if (D.23353 != previous_bb) goto <D.23371>; else goto <D.23372>;
    <D.23371>:
    D.23373 = mono_bb_is_fall_through (cfg, previous_bb);
    if (D.23373 != 0) goto <D.23374>; else goto <D.23375>;
    <D.23374>:
    i = 0;
    goto <D.22449>;
    <D.22448>:
    D.23376 = previous_bb->out_bb;
    D.23377 = (long unsigned int) i;
    D.23378 = D.23377 * 8;
    D.23379 = D.23376 + D.23378;
    D.23380 = *D.23379;
    if (D.23380 == target_bb) goto <D.23381>; else goto <D.23382>;
    <D.23381>:
    {
      struct MonoInst * jump;

      D.23383 = cfg->mempool;
      jump = mono_mempool_alloc0 (D.23383, 80);
      jump->opcode = 442;
      jump->dreg = -1;
      jump->sreg3 = -1;
      D.23384 = jump->sreg3;
      jump->sreg2 = D.23384;
      D.23385 = jump->sreg2;
      jump->sreg1 = D.23385;
      D.23386 = cfg->ip;
      jump->cil_code = D.23386;
      D.23347 = previous_bb->last_ins;
      if (D.23347 != 0B) goto <D.23387>; else goto <D.23388>;
      <D.23387>:
      D.23347 = previous_bb->last_ins;
      D.23347->next = jump;
      D.23347 = previous_bb->last_ins;
      jump->prev = D.23347;
      previous_bb->last_ins = jump;
      goto <D.23389>;
      <D.23388>:
      previous_bb->last_ins = jump;
      D.23347 = previous_bb->last_ins;
      previous_bb->code = D.23347;
      <D.23389>:
      D.23390 = previous_bb->cil_code;
      jump->cil_code = D.23390;
      jump->data.op[0].target_block = target_bb;
      goto <D.22447>;
    }
    <D.23382>:
    i = i + 1;
    <D.22449>:
    D.23391 = previous_bb->out_count;
    D.23392 = (int) D.23391;
    if (D.23392 > i) goto <D.22448>; else goto <D.22447>;
    <D.22447>:
    <D.23375>:
    <D.23372>:
    D.23345 = bb->next_bb;
    previous_bb->next_bb = D.23345;
    mono_nullify_basic_block (bb);
    D.23334 = 1;
    return D.23334;
  }
  <D.23362>:
  D.23334 = 0;
  return D.23334;
}


move_basic_block_to_end (struct MonoCompile * cfg, struct MonoBasicBlock * bb)
{
  struct MonoBasicBlock * D.23395;
  struct MonoBasicBlock * D.23399;
  struct MonoInst * D.23404;
  short unsigned int D.23406;
  short unsigned int D.23410;
  short unsigned int D.23412;
  short unsigned int D.23414;
  struct MonoMemPool * D.23415;
  int D.23416;
  int D.23417;
  const unsigned char * D.23418;
  struct MonoBasicBlock * bbn;
  struct MonoBasicBlock * next;

  next = bb->next_bb;
  bbn = cfg->bb_entry;
  goto <D.22485>;
  <D.22484>:
  bbn = bbn->next_bb;
  <D.22485>:
  D.23395 = bbn->next_bb;
  if (D.23395 != 0B) goto <D.23396>; else goto <D.22486>;
  <D.23396>:
  D.23395 = bbn->next_bb;
  if (D.23395 != bb) goto <D.22484>; else goto <D.22486>;
  <D.22486>:
  D.23395 = bbn->next_bb;
  if (D.23395 != 0B) goto <D.23397>; else goto <D.23398>;
  <D.23397>:
  D.23399 = bb->next_bb;
  bbn->next_bb = D.23399;
  <D.23398>:
  bbn = cfg->bb_entry;
  goto <D.22488>;
  <D.22487>:
  bbn = bbn->next_bb;
  <D.22488>:
  D.23395 = bbn->next_bb;
  if (D.23395 != 0B) goto <D.22487>; else goto <D.22489>;
  <D.22489>:
  bbn->next_bb = bb;
  bb->next_bb = 0B;
  if (next != 0B) goto <D.23402>; else goto <D.23403>;
  <D.23402>:
  D.23404 = bb->last_ins;
  if (D.23404 == 0B) goto <D.23400>; else goto <D.23405>;
  <D.23405>:
  D.23404 = bb->last_ins;
  D.23406 = D.23404->opcode;
  if (D.23406 != 798) goto <D.23407>; else goto <D.23401>;
  <D.23407>:
  D.23404 = bb->last_ins;
  D.23406 = D.23404->opcode;
  if (D.23406 != 442) goto <D.23408>; else goto <D.23401>;
  <D.23408>:
  D.23404 = bb->last_ins;
  D.23406 = D.23404->opcode;
  if (D.23406 != 759) goto <D.23409>; else goto <D.23401>;
  <D.23409>:
  D.23404 = bb->last_ins;
  D.23406 = D.23404->opcode;
  D.23410 = D.23406 + 64985;
  if (D.23410 > 9) goto <D.23411>; else goto <D.23401>;
  <D.23411>:
  D.23404 = bb->last_ins;
  D.23406 = D.23404->opcode;
  D.23412 = D.23406 + 64878;
  if (D.23412 > 9) goto <D.23413>; else goto <D.23401>;
  <D.23413>:
  D.23404 = bb->last_ins;
  D.23406 = D.23404->opcode;
  D.23414 = D.23406 + 64888;
  if (D.23414 > 9) goto <D.23400>; else goto <D.23401>;
  <D.23400>:
  {
    struct MonoInst * ins;

    D.23415 = cfg->mempool;
    ins = mono_mempool_alloc0 (D.23415, 80);
    ins->opcode = 442;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.23416 = ins->sreg3;
    ins->sreg2 = D.23416;
    D.23417 = ins->sreg2;
    ins->sreg1 = D.23417;
    D.23418 = cfg->ip;
    ins->cil_code = D.23418;
    D.23404 = bb->last_ins;
    if (D.23404 != 0B) goto <D.23419>; else goto <D.23420>;
    <D.23419>:
    D.23404 = bb->last_ins;
    D.23404->next = ins;
    D.23404 = bb->last_ins;
    ins->prev = D.23404;
    bb->last_ins = ins;
    goto <D.23421>;
    <D.23420>:
    bb->last_ins = ins;
    D.23404 = bb->last_ins;
    bb->code = D.23404;
    <D.23421>:
    mono_link_bblock (cfg, bb, next);
    ins->data.op[0].target_block = next;
  }
  <D.23401>:
  <D.23403>:
}