mono_branch_optimize_exception_target (struct MonoCompile * cfg, struct MonoBasicBlock * bb, const char * exname)
{
  unsigned int D.24551;
  unsigned int D.24552;
  struct MonoInst * D.24555;
  unsigned int D.24558;
  unsigned int D.24560;
  struct MonoImage * D.24561;
  struct MonoExceptionClause * D.24562;
  unsigned int i.0;
  unsigned int D.24564;
  unsigned int D.24565;
  unsigned int D.24566;
  unsigned int D.24569;
  unsigned int D.24570;
  unsigned int D.24574;
  struct MonoClass * D.24576;
  int D.24578;
  struct MonoBasicBlock * * D.24580;
  unsigned int D.24581;
  unsigned int D.24582;
  struct MonoBasicBlock * * D.24583;
  unsigned int D.24586;
  unsigned int D.24587;
  struct MonoBasicBlock * D.24589;
  unsigned int D.24590;
  unsigned int D.24591;
  unsigned int D.24596;
  unsigned int D.24597;
  struct MonoMemPool * D.24600;
  int D.24601;
  int D.24602;
  const unsigned char * D.24603;
  void * D.24604;
  struct MonoBasicBlock * * D.24605;
  unsigned int D.24606;
  int D.24609;
  const char * D.24610;
  struct MonoMethod * D.24611;
  struct MonoClass * D.24612;
  const char * D.24613;
  const char * D.24614;
  <unnamed-unsigned:15> D.24615;
  int D.24616;
  struct MonoMethodHeader * header;
  struct MonoExceptionClause * clause;
  struct MonoClass * exclass;
  int i;

  header = cfg->header;
  D.24551 = cfg->opt;
  D.24552 = D.24551 & 1048576;
  if (D.24552 == 0) goto <D.24553>; else goto <D.24554>;
  <D.24553>:
  D.24555 = 0B;
  return D.24555;
  <D.24554>:
  D.24558 = bb->region;
  if (D.24558 == 4294967295) goto <D.24556>; else goto <D.24559>;
  <D.24559>:
  D.24558 = bb->region;
  D.24560 = D.24558 & 240;
  if (D.24560 != 0) goto <D.24556>; else goto <D.24557>;
  <D.24556>:
  D.24555 = 0B;
  return D.24555;
  <D.24557>:
  D.24561 = mono_get_corlib ();
  exclass = mono_class_from_name (D.24561, "System", exname);
  i = 0;
  goto <D.24312>;
  <D.24311>:
  D.24562 = header->clauses;
  i.0 = (unsigned int) i;
  D.24564 = i.0 * 24;
  clause = D.24562 + D.24564;
  D.24565 = clause->try_offset;
  D.24566 = bb->real_offset;
  if (D.24565 <= D.24566) goto <D.24567>; else goto <D.24568>;
  <D.24567>:
  D.24566 = bb->real_offset;
  D.24565 = clause->try_offset;
  D.24569 = clause->try_len;
  D.24570 = D.24565 + D.24569;
  if (D.24566 < D.24570) goto <D.24571>; else goto <D.24572>;
  <D.24571>:
  D.24574 = clause->flags;
  if (D.24574 == 0) goto <D.24575>; else goto <D.24573>;
  <D.24575>:
  D.24576 = clause->data.catch_class;
  if (D.24576 != 0B) goto <D.24577>; else goto <D.24573>;
  <D.24577>:
  D.24576 = clause->data.catch_class;
  D.24578 = mono_class_is_assignable_from (D.24576, exclass);
  if (D.24578 != 0) goto <D.24579>; else goto <D.24573>;
  <D.24579>:
  {
    struct MonoBasicBlock * tbb;

    D.24580 = cfg->cil_offset_to_bb;
    D.24581 = clause->handler_offset;
    D.24582 = D.24581 * 4;
    D.24583 = D.24580 + D.24582;
    tbb = *D.24583;
    if (tbb != 0B) goto <D.24585>; else goto <D.24584>;
    <D.24585>:
    D.24586 = BIT_FIELD_REF <*tbb, 32, 480>;
    D.24587 = D.24586 & 12;
    if (D.24587 == 4) goto <D.24588>; else goto <D.24584>;
    <D.24588>:
    {
      struct MonoBasicBlock * targetbb;
      gboolean unsafe;

      targetbb = tbb;
      unsafe = 0;
      goto <D.24309>;
      <D.24308>:
      D.24589 = tbb->next_bb;
      D.24590 = D.24589->flags;
      D.24591 = D.24590 & 8;
      if (D.24591 != 0) goto <D.24592>; else goto <D.24593>;
      <D.24592>:
      unsafe = 1;
      goto <D.24307>;
      <D.24593>:
      tbb = tbb->next_bb;
      <D.24309>:
      if (unsafe == 0) goto <D.24594>; else goto <D.24307>;
      <D.24594>:
      D.24589 = tbb->next_bb;
      if (D.24589 != 0B) goto <D.24595>; else goto <D.24307>;
      <D.24595>:
      D.24596 = tbb->region;
      D.24589 = tbb->next_bb;
      D.24597 = D.24589->region;
      if (D.24596 == D.24597) goto <D.24308>; else goto <D.24307>;
      <D.24307>:
      if (unsafe == 0) goto <D.24598>; else goto <D.24599>;
      <D.24598>:
      {
        struct MonoInst * jump;

        D.24600 = cfg->mempool;
        jump = mono_mempool_alloc0 (D.24600, 56);
        jump->opcode = 442;
        jump->dreg = -1;
        jump->sreg3 = -1;
        D.24601 = jump->sreg3;
        jump->sreg2 = D.24601;
        D.24602 = jump->sreg2;
        jump->sreg1 = D.24602;
        D.24603 = cfg->ip;
        jump->cil_code = D.24603;
        D.24600 = cfg->mempool;
        D.24604 = mono_mempool_alloc0 (D.24600, 56);
        jump->data.op[1].src = D.24604;
        D.24605 = jump->data.op[1].many_blocks;
        *D.24605 = targetbb;
        D.24606 = cfg->verbose_level;
        if (D.24606 > 2) goto <D.24607>; else goto <D.24608>;
        <D.24607>:
        D.24609 = targetbb->block_num;
        D.24576 = clause->data.catch_class;
        D.24610 = D.24576->name;
        D.24611 = cfg->method;
        D.24612 = D.24611->klass;
        D.24613 = D.24612->name;
        D.24611 = cfg->method;
        D.24614 = D.24611->name;
        monoeg_g_print ("found exception to optimize - returning branch to BB%d (%s) (instead of throw) for method %s:%s\n", D.24609, D.24610, D.24613, D.24614);
        <D.24608>:
        D.24555 = jump;
        return D.24555;
      }
      <D.24599>:
      D.24555 = 0B;
      return D.24555;
    }
    <D.24584>:
    D.24555 = 0B;
    return D.24555;
  }
  <D.24573>:
  D.24555 = 0B;
  return D.24555;
  <D.24572>:
  <D.24568>:
  i = i + 1;
  <D.24312>:
  D.24615 = header->num_clauses;
  D.24616 = (int) D.24615;
  if (D.24616 > i) goto <D.24311>; else goto <D.24313>;
  <D.24313>:
  D.24555 = 0B;
  return D.24555;
}


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.24620;
  struct MonoInst * D.24623;
  struct MonoBasicBlock * * D.24626;
  struct MonoBasicBlock * D.24627;
  short int D.24628;
  struct MonoInst * D.24629;
  struct MonoInst * D.24632;
  struct MonoInst * D.24634;
  <unnamed-unsigned:1> D.24638;
  unsigned char D.24639;
  <unnamed-unsigned:1> D.24640;
  unsigned char D.24641;
  unsigned char D.24642;
  <unnamed-unsigned:1> D.24643;
  unsigned int D.24645;
  struct MonoInst * D.24646;
  <unnamed-unsigned:1> D.24654;
  unsigned char D.24655;
  unsigned char D.24656;
  <unnamed-unsigned:1> D.24657;
  struct MonoInst * D.24660;
  struct MonoBasicBlock * * D.24661;
  unsigned int i.1;
  unsigned int D.24663;
  struct MonoBasicBlock * * D.24664;
  struct MonoBasicBlock * D.24665;
  short int D.24666;
  int D.24667;
  struct MonoInst * D.24671;
  struct MonoBasicBlock * * D.24672;
  struct MonoBasicBlock * D.24673;
  struct MonoBasicBlock * * D.24674;
  int D.24675;
  struct MonoBasicBlock * D.24676;
  struct MonoBasicBlock * D.24677;
  struct MonoInst * next;

  next = ins->next;
  if (next != 0B) goto <D.24618>; else goto <D.24619>;
  <D.24618>:
  D.24620 = next->opcode;
  if (D.24620 == 316) goto <D.24621>; else goto <D.24622>;
  <D.24621>:
  D.24623 = next->next;
  ins->next = D.24623;
  next = next->next;
  <D.24622>:
  <D.24619>:
  if (first_bb == last_bb) goto <D.24624>; else goto <D.24625>;
  <D.24624>:
  goto <D.24334>;
  <D.24333>:
  D.24626 = first_bb->out_bb;
  D.24627 = *D.24626;
  mono_unlink_bblock (cfg, first_bb, D.24627);
  <D.24334>:
  D.24628 = first_bb->out_count;
  if (D.24628 != 0) goto <D.24333>; else goto <D.24335>;
  <D.24335>:
  D.24629 = *prev;
  if (D.24629 != 0B) goto <D.24630>; else goto <D.24631>;
  <D.24630>:
  D.24629 = *prev;
  D.24632 = first_bb->code;
  D.24629->next = D.24632;
  D.24632 = first_bb->code;
  D.24629 = *prev;
  D.24632->prev = D.24629;
  goto <D.24633>;
  <D.24631>:
  D.24632 = first_bb->code;
  bb->code = D.24632;
  <D.24633>:
  D.24634 = last_bb->last_ins;
  D.24634->next = next;
  if (next != 0B) goto <D.24635>; else goto <D.24636>;
  <D.24635>:
  D.24634 = last_bb->last_ins;
  next->prev = D.24634;
  goto <D.24637>;
  <D.24636>:
  D.24634 = last_bb->last_ins;
  bb->last_ins = D.24634;
  <D.24637>:
  D.24634 = last_bb->last_ins;
  *prev = D.24634;
  D.24638 = bb->has_array_access;
  D.24639 = (unsigned char) D.24638;
  D.24640 = first_bb->has_array_access;
  D.24641 = (unsigned char) D.24640;
  D.24642 = D.24639 | D.24641;
  D.24643 = (<unnamed-unsigned:1>) D.24642;
  bb->has_array_access = D.24643;
  goto <D.24644>;
  <D.24625>:
  {
    int i;
    int count;
    struct MonoBasicBlock * * tmp_bblocks;
    struct MonoBasicBlock * tmp;
    struct MonoInst * last;

    tmp = first_bb;
    goto <D.24342>;
    <D.24341>:
    D.24645 = bb->region;
    tmp->region = D.24645;
    tmp = tmp->next_bb;
    <D.24342>:
    if (tmp != 0B) goto <D.24341>; else goto <D.24343>;
    <D.24343>:
    D.24646 = ins->next;
    if (D.24646 != 0B) goto <D.24647>; else goto <D.24648>;
    <D.24647>:
    D.24646 = ins->next;
    D.24646->prev = 0B;
    <D.24648>:
    ins->next = 0B;
    bb->last_ins = ins;
    D.24634 = last_bb->last_ins;
    if (D.24634 != 0B) goto <D.24649>; else goto <D.24650>;
    <D.24649>:
    D.24634 = last_bb->last_ins;
    D.24634->next = next;
    if (next != 0B) goto <D.24651>; else goto <D.24652>;
    <D.24651>:
    D.24634 = last_bb->last_ins;
    next->prev = D.24634;
    <D.24652>:
    goto <D.24653>;
    <D.24650>:
    last_bb->code = next;
    <D.24653>:
    D.24654 = last_bb->has_array_access;
    D.24655 = (unsigned char) D.24654;
    D.24638 = bb->has_array_access;
    D.24639 = (unsigned char) D.24638;
    D.24656 = D.24655 | D.24639;
    D.24657 = (<unnamed-unsigned:1>) D.24656;
    last_bb->has_array_access = D.24657;
    if (next != 0B) goto <D.24658>; else goto <D.24659>;
    <D.24658>:
    last = next;
    goto <D.24345>;
    <D.24344>:
    last = last->next;
    <D.24345>:
    D.24660 = last->next;
    if (D.24660 != 0B) goto <D.24344>; else goto <D.24346>;
    <D.24346>:
    last_bb->last_ins = last;
    <D.24659>:
    i = 0;
    goto <D.24348>;
    <D.24347>:
    D.24661 = bb->out_bb;
    i.1 = (unsigned int) i;
    D.24663 = i.1 * 4;
    D.24664 = D.24661 + D.24663;
    D.24665 = *D.24664;
    mono_link_bblock (cfg, last_bb, D.24665);
    i = i + 1;
    <D.24348>:
    D.24666 = bb->out_count;
    D.24667 = (int) D.24666;
    if (D.24667 > i) goto <D.24347>; else goto <D.24349>;
    <D.24349>:
    D.24629 = *prev;
    if (D.24629 != 0B) goto <D.24668>; else goto <D.24669>;
    <D.24668>:
    D.24629 = *prev;
    D.24632 = first_bb->code;
    D.24629->next = D.24632;
    D.24632 = first_bb->code;
    D.24629 = *prev;
    D.24632->prev = D.24629;
    goto <D.24670>;
    <D.24669>:
    D.24632 = first_bb->code;
    bb->code = D.24632;
    <D.24670>:
    D.24671 = first_bb->last_ins;
    bb->last_ins = D.24671;
    D.24638 = bb->has_array_access;
    D.24639 = (unsigned char) D.24638;
    D.24640 = first_bb->has_array_access;
    D.24641 = (unsigned char) D.24640;
    D.24642 = D.24639 | D.24641;
    D.24643 = (<unnamed-unsigned:1>) D.24642;
    bb->has_array_access = D.24643;
    tmp_bblocks = bb->out_bb;
    D.24666 = bb->out_count;
    count = (int) D.24666;
    i = 0;
    goto <D.24351>;
    <D.24350>:
    i.1 = (unsigned int) i;
    D.24663 = i.1 * 4;
    D.24672 = tmp_bblocks + D.24663;
    D.24673 = *D.24672;
    mono_unlink_bblock (cfg, bb, D.24673);
    i = i + 1;
    <D.24351>:
    if (i < count) goto <D.24350>; else goto <D.24352>;
    <D.24352>:
    i = 0;
    goto <D.24355>;
    <D.24354>:
    {
      struct MonoBasicBlock * out_bb;

      D.24626 = first_bb->out_bb;
      i.1 = (unsigned int) i;
      D.24663 = i.1 * 4;
      D.24674 = D.24626 + D.24663;
      out_bb = *D.24674;
      mono_link_bblock (cfg, bb, out_bb);
    }
    i = i + 1;
    <D.24355>:
    D.24628 = first_bb->out_count;
    D.24675 = (int) D.24628;
    if (D.24675 > i) goto <D.24354>; else goto <D.24356>;
    <D.24356>:
    i = 0;
    goto <D.24359>;
    <D.24358>:
    {
      struct MonoBasicBlock * out_bb;

      D.24661 = bb->out_bb;
      i.1 = (unsigned int) i;
      D.24663 = i.1 * 4;
      D.24664 = D.24661 + D.24663;
      out_bb = *D.24664;
      mono_unlink_bblock (cfg, first_bb, out_bb);
    }
    i = i + 1;
    <D.24359>:
    D.24666 = bb->out_count;
    D.24667 = (int) D.24666;
    if (D.24667 > i) goto <D.24358>; else goto <D.24360>;
    <D.24360>:
    D.24676 = bb->next_bb;
    last_bb->next_bb = D.24676;
    D.24677 = first_bb->next_bb;
    bb->next_bb = D.24677;
    *prev = 0B;
  }
  <D.24644>:
}


mono_if_conversion (struct MonoCompile * cfg)
{

}


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

  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.24678 = bb->last_ins;
  bb->code = D.24678;
  bb->cil_code = 0B;
}


mono_merge_basic_blocks (struct MonoCompile * cfg, struct MonoBasicBlock * bb, struct MonoBasicBlock * bbn)
{
  <unnamed-unsigned:1> D.24679;
  unsigned char D.24680;
  <unnamed-unsigned:1> D.24681;
  unsigned char D.24682;
  unsigned char D.24683;
  <unnamed-unsigned:1> D.24684;
  <unnamed-unsigned:1> D.24685;
  unsigned char D.24686;
  <unnamed-unsigned:1> D.24687;
  unsigned char D.24688;
  unsigned char D.24689;
  <unnamed-unsigned:1> D.24690;
  struct MonoBasicBlock * * D.24691;
  unsigned int i.2;
  unsigned int D.24693;
  struct MonoBasicBlock * * D.24694;
  struct MonoBasicBlock * D.24695;
  short int D.24696;
  int D.24697;
  struct MonoBasicBlock * D.24698;
  unsigned char D.24699;
  unsigned char D.24700;
  short unsigned int D.24703;
  struct MonoBasicBlock * D.24706;
  _Bool D.24707;
  long int D.24708;
  long int D.24709;
  int D.24712;
  int D.24713;
  unsigned char D.24714;
  struct MonoInst * D.24722;
  struct MonoInst * D.24725;
  struct MonoJumpInfoBBTable * iftmp.3;
  struct MonoJumpInfoBBTable * iftmp.4;
  struct MonoJumpInfoBBTable * iftmp.5;
  struct MonoJumpInfoBBTable * iftmp.6;
  struct MonoBasicBlock * * D.24744;
  unsigned int i.7;
  unsigned int D.24746;
  struct MonoBasicBlock * * D.24747;
  struct MonoBasicBlock * D.24748;
  _Bool D.24751;
  long int D.24752;
  long int D.24753;
  int D.24756;
  struct MonoInst * D.24760;
  short unsigned int D.24762;
  short unsigned int D.24763;
  _Bool D.24764;
  short unsigned int D.24765;
  _Bool D.24766;
  _Bool D.24767;
  short unsigned int D.24769;
  short unsigned int D.24770;
  struct MonoBasicBlock * * D.24771;
  struct MonoBasicBlock * * D.24772;
  struct MonoBasicBlock * D.24773;
  _Bool D.24774;
  long int D.24775;
  long int D.24776;
  short unsigned int D.24783;
  short unsigned int D.24784;
  _Bool D.24785;
  short unsigned int D.24786;
  _Bool D.24787;
  _Bool D.24788;
  int D.24793;
  int D.24794;
  <unnamed-unsigned:1> D.24795;
  unsigned char D.24796;
  <unnamed-unsigned:1> D.24797;
  unsigned char D.24798;
  unsigned char D.24799;
  <unnamed-unsigned:1> D.24800;
  <unnamed-unsigned:1> D.24801;
  unsigned char D.24802;
  <unnamed-unsigned:1> D.24803;
  unsigned char D.24804;
  unsigned char D.24805;
  <unnamed-unsigned:1> D.24806;
  struct MonoInst * D.24809;
  struct MonoInst * D.24812;
  struct MonoBasicBlock * D.24815;
  struct MonoBasicBlock * D.24818;
  struct MonoBasicBlock * D.24820;
  short int D.24825;
  struct MonoBasicBlock * * D.24828;
  struct MonoBasicBlock * D.24829;
  short unsigned int D.24832;
  short unsigned int D.24833;
  _Bool D.24834;
  short unsigned int D.24835;
  _Bool D.24836;
  _Bool D.24837;
  struct MonoMemPool * D.24848;
  const unsigned char * D.24849;
  struct MonoInst * inst;
  struct MonoBasicBlock * prev_bb;
  int i;

  D.24679 = bb->has_array_access;
  D.24680 = (unsigned char) D.24679;
  D.24681 = bbn->has_array_access;
  D.24682 = (unsigned char) D.24681;
  D.24683 = D.24680 | D.24682;
  D.24684 = (<unnamed-unsigned:1>) D.24683;
  bb->has_array_access = D.24684;
  D.24685 = bb->extended;
  D.24686 = (unsigned char) D.24685;
  D.24687 = bbn->extended;
  D.24688 = (unsigned char) D.24687;
  D.24689 = D.24686 | D.24688;
  D.24690 = (<unnamed-unsigned:1>) D.24689;
  bb->extended = D.24690;
  mono_unlink_bblock (cfg, bb, bbn);
  i = 0;
  goto <D.24443>;
  <D.24442>:
  D.24691 = bbn->out_bb;
  i.2 = (unsigned int) i;
  D.24693 = i.2 * 4;
  D.24694 = D.24691 + D.24693;
  D.24695 = *D.24694;
  mono_link_bblock (cfg, bb, D.24695);
  i = i + 1;
  <D.24443>:
  D.24696 = bbn->out_count;
  D.24697 = (int) D.24696;
  if (D.24697 > i) goto <D.24442>; else goto <D.24444>;
  <D.24444>:
  goto <D.24446>;
  <D.24445>:
  D.24691 = bbn->out_bb;
  D.24698 = *D.24691;
  mono_unlink_bblock (cfg, bbn, D.24698);
  <D.24446>:
  D.24696 = bbn->out_count;
  if (D.24696 != 0) goto <D.24445>; else goto <D.24447>;
  <D.24447>:
  D.24699 = BIT_FIELD_REF <*bb, 8, 912>;
  D.24700 = D.24699 & 32;
  if (D.24700 != 0) goto <D.24701>; else goto <D.24702>;
  <D.24701>:
  inst = bb->code;
  goto <D.24449>;
  <D.24448>:
  D.24703 = inst->opcode;
  if (D.24703 == 735) goto <D.24704>; else goto <D.24705>;
  <D.24704>:
  D.24706 = inst->data.op[0].target_block;
  D.24707 = D.24706 != bbn;
  D.24708 = (long int) D.24707;
  D.24709 = __builtin_expect (D.24708, 0);
  if (D.24709 != 0) goto <D.24710>; else goto <D.24711>;
  <D.24710>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "branch-opts.c", 984, "inst->inst_target_bb == bbn");
  <D.24711>:
  inst->opcode = 316;
  inst->dreg = -1;
  inst->sreg3 = -1;
  D.24712 = inst->sreg3;
  inst->sreg2 = D.24712;
  D.24713 = inst->sreg2;
  inst->sreg1 = D.24713;
  <D.24705>:
  inst = inst->next;
  <D.24449>:
  if (inst != 0B) goto <D.24448>; else goto <D.24450>;
  <D.24450>:
  <D.24702>:
  D.24699 = BIT_FIELD_REF <*bb, 8, 912>;
  D.24714 = D.24699 & 16;
  if (D.24714 != 0) goto <D.24715>; else goto <D.24716>;
  <D.24715>:
  inst = bb->code;
  goto <D.24457>;
  <D.24456>:
  D.24703 = inst->opcode;
  if (D.24703 == 731) goto <D.24717>; else goto <D.24720>;
  <D.24720>:
  D.24703 = inst->opcode;
  if (D.24703 == 732) goto <D.24721>; else goto <D.24718>;
  <D.24721>:
  D.24722 = inst->data.op[1].src;
  if (D.24722 == 8B) goto <D.24717>; else goto <D.24718>;
  <D.24718>:
  D.24703 = inst->opcode;
  if (D.24703 == 370) goto <D.24717>; else goto <D.24723>;
  <D.24723>:
  D.24703 = inst->opcode;
  if (D.24703 == 734) goto <D.24724>; else goto <D.24719>;
  <D.24724>:
  D.24722 = inst->data.op[1].src;
  D.24725 = D.24722->data.op[1].src;
  if (D.24725 == 8B) goto <D.24717>; else goto <D.24719>;
  <D.24717>:
  {
    int i;
    struct MonoJumpInfoBBTable * table;

    D.24703 = inst->opcode;
    if (D.24703 == 731) goto <D.24727>; else goto <D.24728>;
    <D.24727>:
    iftmp.3 = inst->data.op[0].p;
    goto <D.24729>;
    <D.24728>:
    D.24703 = inst->opcode;
    if (D.24703 == 732) goto <D.24733>; else goto <D.24731>;
    <D.24733>:
    D.24722 = inst->data.op[1].src;
    if (D.24722 == 8B) goto <D.24734>; else goto <D.24731>;
    <D.24734>:
    iftmp.4 = inst->data.op[0].p;
    goto <D.24732>;
    <D.24731>:
    D.24703 = inst->opcode;
    if (D.24703 == 370) goto <D.24736>; else goto <D.24737>;
    <D.24736>:
    iftmp.5 = inst->data.op[0].p;
    goto <D.24738>;
    <D.24737>:
    D.24703 = inst->opcode;
    if (D.24703 == 734) goto <D.24742>; else goto <D.24740>;
    <D.24742>:
    D.24722 = inst->data.op[1].src;
    D.24725 = D.24722->data.op[1].src;
    if (D.24725 == 8B) goto <D.24743>; else goto <D.24740>;
    <D.24743>:
    D.24722 = inst->data.op[1].src;
    iftmp.6 = D.24722->data.op[0].p;
    goto <D.24741>;
    <D.24740>:
    iftmp.6 = 0B;
    <D.24741>:
    iftmp.5 = iftmp.6;
    <D.24738>:
    iftmp.4 = iftmp.5;
    <D.24732>:
    iftmp.3 = iftmp.4;
    <D.24729>:
    table = iftmp.3;
    i = 0;
    goto <D.24454>;
    <D.24453>:
    D.24744 = table->table;
    i.7 = (unsigned int) i;
    D.24746 = i.7 * 4;
    D.24747 = D.24744 + D.24746;
    D.24748 = *D.24747;
    if (D.24748 != 0B) goto <D.24749>; else goto <D.24750>;
    <D.24749>:
    D.24744 = table->table;
    i.7 = (unsigned int) i;
    D.24746 = i.7 * 4;
    D.24747 = D.24744 + D.24746;
    D.24748 = *D.24747;
    D.24751 = D.24748 != bbn;
    D.24752 = (long int) D.24751;
    D.24753 = __builtin_expect (D.24752, 0);
    if (D.24753 != 0) goto <D.24754>; else goto <D.24755>;
    <D.24754>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "branch-opts.c", 997, "table->table [i] == bbn");
    <D.24755>:
    <D.24750>:
    D.24744 = table->table;
    i.7 = (unsigned int) i;
    D.24746 = i.7 * 4;
    D.24747 = D.24744 + D.24746;
    *D.24747 = 0B;
    i = i + 1;
    <D.24454>:
    D.24756 = table->table_size;
    if (D.24756 > i) goto <D.24453>; else goto <D.24455>;
    <D.24455>:
  }
  <D.24719>:
  inst = inst->next;
  <D.24457>:
  if (inst != 0B) goto <D.24456>; else goto <D.24458>;
  <D.24458>:
  <D.24716>:
  D.24760 = bb->last_ins;
  if (D.24760 != 0B) goto <D.24761>; else goto <D.24757>;
  <D.24761>:
  D.24760 = bb->last_ins;
  D.24762 = D.24760->opcode;
  D.24763 = D.24762 + 64985;
  D.24764 = D.24763 <= 9;
  D.24765 = D.24762 + 64878;
  D.24766 = D.24765 <= 9;
  D.24767 = D.24764 | D.24766;
  if (D.24767 != 0) goto <D.24758>; else goto <D.24768>;
  <D.24768>:
  D.24760 = bb->last_ins;
  D.24769 = D.24760->opcode;
  D.24770 = D.24769 + 64888;
  if (D.24770 <= 9) goto <D.24758>; else goto <D.24757>;
  <D.24758>:
  D.24760 = bb->last_ins;
  D.24771 = D.24760->data.op[1].many_blocks;
  D.24772 = D.24771 + 4;
  D.24773 = *D.24772;
  D.24774 = D.24773 != bbn;
  D.24775 = (long int) D.24774;
  D.24776 = __builtin_expect (D.24775, 0);
  if (D.24776 != 0) goto <D.24777>; else goto <D.24778>;
  <D.24777>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "branch-opts.c", 1005, "bb->last_ins->inst_false_bb == bbn");
  <D.24778>:
  D.24760 = bb->last_ins;
  D.24771 = D.24760->data.op[1].many_blocks;
  D.24772 = D.24771 + 4;
  *D.24772 = 0B;
  bb->extended = 1;
  goto <D.24759>;
  <D.24757>:
  D.24760 = bb->last_ins;
  if (D.24760 != 0B) goto <D.24781>; else goto <D.24782>;
  <D.24781>:
  D.24760 = bb->last_ins;
  D.24783 = D.24760->opcode;
  D.24784 = D.24783 + 64985;
  D.24785 = D.24784 <= 9;
  D.24786 = D.24783 + 64878;
  D.24787 = D.24786 <= 9;
  D.24788 = D.24785 | D.24787;
  if (D.24788 != 0) goto <D.24779>; else goto <D.24789>;
  <D.24789>:
  D.24760 = bb->last_ins;
  D.24769 = D.24760->opcode;
  D.24770 = D.24769 + 64888;
  if (D.24770 <= 9) goto <D.24779>; else goto <D.24790>;
  <D.24790>:
  D.24760 = bb->last_ins;
  D.24769 = D.24760->opcode;
  if (D.24769 == 442) goto <D.24779>; else goto <D.24791>;
  <D.24791>:
  D.24760 = bb->last_ins;
  D.24769 = D.24760->opcode;
  if (D.24769 == 759) goto <D.24779>; else goto <D.24792>;
  <D.24792>:
  D.24760 = bb->last_ins;
  D.24769 = D.24760->opcode;
  if (D.24769 == 370) goto <D.24779>; else goto <D.24780>;
  <D.24779>:
  D.24760 = bb->last_ins;
  D.24760->opcode = 316;
  D.24760 = bb->last_ins;
  D.24760->dreg = -1;
  D.24760 = bb->last_ins;
  D.24760 = bb->last_ins;
  D.24760 = bb->last_ins;
  D.24760->sreg3 = -1;
  D.24793 = D.24760->sreg3;
  D.24760->sreg2 = D.24793;
  D.24794 = D.24760->sreg2;
  D.24760->sreg1 = D.24794;
  <D.24780>:
  <D.24782>:
  <D.24759>:
  D.24795 = bb->has_call_handler;
  D.24796 = (unsigned char) D.24795;
  D.24797 = bbn->has_call_handler;
  D.24798 = (unsigned char) D.24797;
  D.24799 = D.24796 | D.24798;
  D.24800 = (<unnamed-unsigned:1>) D.24799;
  bb->has_call_handler = D.24800;
  D.24801 = bb->has_jump_table;
  D.24802 = (unsigned char) D.24801;
  D.24803 = bbn->has_jump_table;
  D.24804 = (unsigned char) D.24803;
  D.24805 = D.24802 | D.24804;
  D.24806 = (<unnamed-unsigned:1>) D.24805;
  bb->has_jump_table = D.24806;
  D.24760 = bb->last_ins;
  if (D.24760 != 0B) goto <D.24807>; else goto <D.24808>;
  <D.24807>:
  D.24809 = bbn->code;
  if (D.24809 != 0B) goto <D.24810>; else goto <D.24811>;
  <D.24810>:
  D.24760 = bb->last_ins;
  D.24809 = bbn->code;
  D.24760->next = D.24809;
  D.24809 = bbn->code;
  D.24760 = bb->last_ins;
  D.24809->prev = D.24760;
  D.24812 = bbn->last_ins;
  bb->last_ins = D.24812;
  <D.24811>:
  goto <D.24813>;
  <D.24808>:
  D.24809 = bbn->code;
  bb->code = D.24809;
  D.24812 = bbn->last_ins;
  bb->last_ins = D.24812;
  <D.24813>:
  prev_bb = cfg->bb_entry;
  goto <D.24460>;
  <D.24459>:
  prev_bb = prev_bb->next_bb;
  <D.24460>:
  if (prev_bb != 0B) goto <D.24814>; else goto <D.24461>;
  <D.24814>:
  D.24815 = prev_bb->next_bb;
  if (D.24815 != bbn) goto <D.24459>; else goto <D.24461>;
  <D.24461>:
  if (prev_bb != 0B) goto <D.24816>; else goto <D.24817>;
  <D.24816>:
  D.24818 = bbn->next_bb;
  prev_bb->next_bb = D.24818;
  goto <D.24819>;
  <D.24817>:
  D.24820 = bb->next_bb;
  if (D.24820 == bbn) goto <D.24821>; else goto <D.24822>;
  <D.24821>:
  D.24818 = bbn->next_bb;
  bb->next_bb = D.24818;
  <D.24822>:
  <D.24819>:
  mono_nullify_basic_block (bbn);
  D.24760 = bb->last_ins;
  if (D.24760 != 0B) goto <D.24823>; else goto <D.24824>;
  <D.24823>:
  D.24825 = bb->out_count;
  if (D.24825 == 1) goto <D.24826>; else goto <D.24827>;
  <D.24826>:
  D.24828 = bb->out_bb;
  D.24829 = *D.24828;
  D.24820 = bb->next_bb;
  if (D.24829 != D.24820) goto <D.24830>; else goto <D.24831>;
  <D.24830>:
  D.24760 = bb->last_ins;
  D.24832 = D.24760->opcode;
  D.24833 = D.24832 + 64985;
  D.24834 = D.24833 > 9;
  D.24835 = D.24832 + 64878;
  D.24836 = D.24835 > 9;
  D.24837 = D.24834 & D.24836;
  if (D.24837 != 0) goto <D.24838>; else goto <D.24839>;
  <D.24838>:
  D.24760 = bb->last_ins;
  D.24769 = D.24760->opcode;
  D.24770 = D.24769 + 64888;
  if (D.24770 > 9) goto <D.24840>; else goto <D.24841>;
  <D.24840>:
  D.24760 = bb->last_ins;
  D.24769 = D.24760->opcode;
  if (D.24769 != 442) goto <D.24842>; else goto <D.24843>;
  <D.24842>:
  D.24760 = bb->last_ins;
  D.24769 = D.24760->opcode;
  if (D.24769 != 759) goto <D.24844>; else goto <D.24845>;
  <D.24844>:
  D.24760 = bb->last_ins;
  D.24769 = D.24760->opcode;
  if (D.24769 != 370) goto <D.24846>; else goto <D.24847>;
  <D.24846>:
  D.24848 = cfg->mempool;
  inst = mono_mempool_alloc0 (D.24848, 56);
  inst->opcode = 442;
  inst->dreg = -1;
  inst->sreg3 = -1;
  D.24712 = inst->sreg3;
  inst->sreg2 = D.24712;
  D.24713 = inst->sreg2;
  inst->sreg1 = D.24713;
  D.24849 = cfg->ip;
  inst->cil_code = D.24849;
  D.24828 = bb->out_bb;
  D.24829 = *D.24828;
  inst->data.op[0].target_block = D.24829;
  D.24760 = bb->last_ins;
  if (D.24760 != 0B) goto <D.24850>; else goto <D.24851>;
  <D.24850>:
  D.24760 = bb->last_ins;
  D.24760->next = inst;
  D.24760 = bb->last_ins;
  inst->prev = D.24760;
  bb->last_ins = inst;
  goto <D.24852>;
  <D.24851>:
  bb->last_ins = inst;
  D.24760 = bb->last_ins;
  bb->code = D.24760;
  <D.24852>:
  <D.24847>:
  <D.24845>:
  <D.24843>:
  <D.24841>:
  <D.24839>:
  <D.24831>:
  <D.24827>:
  <D.24824>:
}


mono_remove_bblock (struct MonoCompile * cfg, struct MonoBasicBlock * bb)
{
  struct MonoBasicBlock * D.24854;
  _Bool D.24855;
  long int D.24856;
  long int D.24857;
  struct MonoBasicBlock * D.24860;
  struct MonoBasicBlock * tmp_bb;

  tmp_bb = cfg->bb_entry;
  goto <D.24481>;
  <D.24480>:
  tmp_bb = tmp_bb->next_bb;
  <D.24481>:
  if (tmp_bb != 0B) goto <D.24853>; else goto <D.24482>;
  <D.24853>:
  D.24854 = tmp_bb->next_bb;
  if (D.24854 != bb) goto <D.24480>; else goto <D.24482>;
  <D.24482>:
  D.24855 = tmp_bb == 0B;
  D.24856 = (long int) D.24855;
  D.24857 = __builtin_expect (D.24856, 0);
  if (D.24857 != 0) goto <D.24858>; else goto <D.24859>;
  <D.24858>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "branch-opts.c", 1092, "tmp_bb");
  <D.24859>:
  D.24860 = bb->next_bb;
  tmp_bb->next_bb = D.24860;
}


mono_remove_critical_edges (struct MonoCompile * cfg)
{
  unsigned int D.24861;
  int D.24864;
  struct MonoBasicBlock * * D.24865;
  unsigned int i.8;
  unsigned int D.24867;
  struct MonoBasicBlock * * D.24868;
  struct MonoBasicBlock * D.24869;
  int D.24870;
  short int D.24871;
  int D.24872;
  struct MonoBasicBlock * * D.24873;
  struct MonoBasicBlock * * D.24874;
  struct MonoBasicBlock * D.24875;
  int D.24876;
  short int D.24877;
  int D.24878;
  struct MonoInst * D.24879;
  unsigned int in_bb_index.9;
  unsigned int D.24885;
  struct MonoBasicBlock * * D.24886;
  short int D.24889;
  struct MonoInst * D.24892;
  short unsigned int D.24894;
  struct MonoMemPool * D.24895;
  unsigned int D.24896;
  unsigned int D.24897;
  unsigned int D.24898;
  int D.24899;
  unsigned int D.24900;
  int D.24901;
  struct MonoBasicBlock * D.24904;
  struct MonoBasicBlock * * D.24907;
  unsigned int i.10;
  unsigned int D.24909;
  struct MonoBasicBlock * * D.24910;
  struct MonoBasicBlock * D.24911;
  int D.24914;
  int D.24915;
  const unsigned char * D.24916;
  struct MonoInst * D.24917;
  unsigned char * D.24921;
  short int D.24922;
  int D.24923;
  unsigned int D.24925;
  unsigned int D.24926;
  int D.24927;
  int D.24928;
  int D.24929;
  struct MonoInst * D.24930;
  unsigned char * D.24934;
  int D.24937;
  void * D.24938;
  struct MonoBasicBlock * * D.24939;
  void * D.24940;
  struct MonoBasicBlock * * D.24941;
  int D.24944;
  int D.24945;
  unsigned int i.11;
  unsigned int D.24949;
  struct MonoBasicBlock * * D.24950;
  struct MonoBasicBlock * D.24951;
  int D.24952;
  struct MonoBasicBlock * * D.24953;
  struct MonoBasicBlock * D.24954;
  int D.24955;
  struct MonoBasicBlock * bb;
  struct MonoBasicBlock * previous_bb;

  D.24861 = cfg->verbose_level;
  if (D.24861 > 3) goto <D.24862>; else goto <D.24863>;
  <D.24862>:
  bb = cfg->bb_entry;
  goto <D.24496>;
  <D.24495>:
  {
    int i;

    D.24864 = bb->block_num;
    printf ("remove_critical_edges, BEFORE BB%d (in:", D.24864);
    i = 0;
    goto <D.24490>;
    <D.24489>:
    D.24865 = bb->in_bb;
    i.8 = (unsigned int) i;
    D.24867 = i.8 * 4;
    D.24868 = D.24865 + D.24867;
    D.24869 = *D.24868;
    D.24870 = D.24869->block_num;
    printf (" %d", D.24870);
    i = i + 1;
    <D.24490>:
    D.24871 = bb->in_count;
    D.24872 = (int) D.24871;
    if (D.24872 > i) goto <D.24489>; else goto <D.24491>;
    <D.24491>:
    printf (") (out:");
    i = 0;
    goto <D.24493>;
    <D.24492>:
    D.24873 = bb->out_bb;
    i.8 = (unsigned int) i;
    D.24867 = i.8 * 4;
    D.24874 = D.24873 + D.24867;
    D.24875 = *D.24874;
    D.24876 = D.24875->block_num;
    printf (" %d", D.24876);
    i = i + 1;
    <D.24493>:
    D.24877 = bb->out_count;
    D.24878 = (int) D.24877;
    if (D.24878 > i) goto <D.24492>; else goto <D.24494>;
    <D.24494>:
    printf (")");
    D.24879 = bb->last_ins;
    if (D.24879 != 0B) goto <D.24880>; else goto <D.24881>;
    <D.24880>:
    printf (" ");
    D.24879 = bb->last_ins;
    mono_print_ins (D.24879);
    <D.24881>:
    printf ("\n");
  }
  bb = bb->next_bb;
  <D.24496>:
  if (bb != 0B) goto <D.24495>; else goto <D.24497>;
  <D.24497>:
  <D.24863>:
  previous_bb = cfg->bb_entry;
  bb = previous_bb->next_bb;
  goto <D.24512>;
  <D.24511>:
  D.24871 = bb->in_count;
  if (D.24871 > 1) goto <D.24882>; else goto <D.24883>;
  <D.24882>:
  {
    int in_bb_index;

    in_bb_index = 0;
    goto <D.24509>;
    <D.24508>:
    {
      struct MonoBasicBlock * in_bb;

      D.24865 = bb->in_bb;
      in_bb_index.9 = (unsigned int) in_bb_index;
      D.24885 = in_bb_index.9 * 4;
      D.24886 = D.24865 + D.24885;
      in_bb = *D.24886;
      D.24889 = in_bb->out_count;
      if (D.24889 > 1) goto <D.24887>; else goto <D.24890>;
      <D.24890>:
      D.24889 = in_bb->out_count;
      if (D.24889 == 1) goto <D.24891>; else goto <D.24888>;
      <D.24891>:
      D.24892 = in_bb->last_ins;
      if (D.24892 != 0B) goto <D.24893>; else goto <D.24888>;
      <D.24893>:
      D.24892 = in_bb->last_ins;
      D.24894 = D.24892->opcode;
      if (D.24894 == 759) goto <D.24887>; else goto <D.24888>;
      <D.24887>:
      {
        struct MonoBasicBlock * new_bb;

        D.24895 = cfg->mempool;
        new_bb = mono_mempool_alloc0 (D.24895, 172);
        D.24896 = cfg->num_bblocks;
        D.24897 = D.24896;
        D.24898 = D.24897 + 1;
        cfg->num_bblocks = D.24898;
        D.24899 = (int) D.24897;
        new_bb->block_num = D.24899;
        D.24900 = bb->region;
        new_bb->region = D.24900;
        D.24901 = mono_bb_is_fall_through (cfg, previous_bb);
        if (D.24901 != 0) goto <D.24902>; else goto <D.24903>;
        <D.24902>:
        D.24904 = cfg->bb_entry;
        if (D.24904 != previous_bb) goto <D.24905>; else goto <D.24906>;
        <D.24905>:
        {
          int i;

          i = 0;
          goto <D.24505>;
          <D.24504>:
          D.24907 = previous_bb->out_bb;
          i.10 = (unsigned int) i;
          D.24909 = i.10 * 4;
          D.24910 = D.24907 + D.24909;
          D.24911 = *D.24910;
          if (D.24911 == bb) goto <D.24912>; else goto <D.24913>;
          <D.24912>:
          {
            struct MonoInst * jump;

            D.24895 = cfg->mempool;
            jump = mono_mempool_alloc0 (D.24895, 56);
            jump->opcode = 442;
            jump->dreg = -1;
            jump->sreg3 = -1;
            D.24914 = jump->sreg3;
            jump->sreg2 = D.24914;
            D.24915 = jump->sreg2;
            jump->sreg1 = D.24915;
            D.24916 = cfg->ip;
            jump->cil_code = D.24916;
            D.24917 = previous_bb->last_ins;
            if (D.24917 != 0B) goto <D.24918>; else goto <D.24919>;
            <D.24918>:
            D.24917 = previous_bb->last_ins;
            D.24917->next = jump;
            D.24917 = previous_bb->last_ins;
            jump->prev = D.24917;
            previous_bb->last_ins = jump;
            goto <D.24920>;
            <D.24919>:
            previous_bb->last_ins = jump;
            D.24917 = previous_bb->last_ins;
            previous_bb->code = D.24917;
            <D.24920>:
            D.24921 = previous_bb->cil_code;
            jump->cil_code = D.24921;
            jump->data.op[0].target_block = bb;
            goto <D.24503>;
          }
          <D.24913>:
          i = i + 1;
          <D.24505>:
          D.24922 = previous_bb->out_count;
          D.24923 = (int) D.24922;
          if (D.24923 > i) goto <D.24504>; else goto <D.24503>;
          <D.24503>:
        }
        goto <D.24924>;
        <D.24906>:
        {
          struct MonoInst * jump;
          struct MonoBasicBlock * new_bb_after_entry;

          D.24895 = cfg->mempool;
          new_bb_after_entry = mono_mempool_alloc0 (D.24895, 172);
          D.24896 = cfg->num_bblocks;
          D.24925 = D.24896;
          D.24926 = D.24925 + 1;
          cfg->num_bblocks = D.24926;
          D.24927 = (int) D.24925;
          new_bb_after_entry->block_num = D.24927;
          D.24900 = bb->region;
          new_bb_after_entry->region = D.24900;
          D.24895 = cfg->mempool;
          jump = mono_mempool_alloc0 (D.24895, 56);
          jump->opcode = 442;
          jump->dreg = -1;
          jump->sreg3 = -1;
          D.24928 = jump->sreg3;
          jump->sreg2 = D.24928;
          D.24929 = jump->sreg2;
          jump->sreg1 = D.24929;
          D.24916 = cfg->ip;
          jump->cil_code = D.24916;
          D.24930 = new_bb_after_entry->last_ins;
          if (D.24930 != 0B) goto <D.24931>; else goto <D.24932>;
          <D.24931>:
          D.24930 = new_bb_after_entry->last_ins;
          D.24930->next = jump;
          D.24930 = new_bb_after_entry->last_ins;
          jump->prev = D.24930;
          new_bb_after_entry->last_ins = jump;
          goto <D.24933>;
          <D.24932>:
          new_bb_after_entry->last_ins = jump;
          D.24930 = new_bb_after_entry->last_ins;
          new_bb_after_entry->code = D.24930;
          <D.24933>:
          D.24934 = bb->cil_code;
          jump->cil_code = D.24934;
          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.24861 = cfg->verbose_level;
          if (D.24861 > 2) goto <D.24935>; else goto <D.24936>;
          <D.24935>:
          D.24937 = new_bb_after_entry->block_num;
          D.24864 = bb->block_num;
          printf ("remove_critical_edges, added helper BB%d jumping to BB%d\n", D.24937, D.24864);
          <D.24936>:
        }
        <D.24924>:
        <D.24903>:
        previous_bb->next_bb = new_bb;
        new_bb->next_bb = bb;
        previous_bb = new_bb;
        D.24895 = cfg->mempool;
        D.24938 = mono_mempool_alloc (D.24895, 4);
        new_bb->in_bb = D.24938;
        D.24939 = new_bb->in_bb;
        *D.24939 = in_bb;
        new_bb->in_count = 1;
        D.24895 = cfg->mempool;
        D.24940 = mono_mempool_alloc (D.24895, 4);
        new_bb->out_bb = D.24940;
        D.24941 = new_bb->out_bb;
        *D.24941 = 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.24861 = cfg->verbose_level;
        if (D.24861 > 2) goto <D.24942>; else goto <D.24943>;
        <D.24942>:
        D.24944 = in_bb->block_num;
        D.24864 = bb->block_num;
        D.24945 = new_bb->block_num;
        printf ("remove_critical_edges, removed critical edge from BB%d to BB%d (added BB%d)\n", D.24944, D.24864, D.24945);
        <D.24943>:
      }
      <D.24888>:
    }
    in_bb_index = in_bb_index + 1;
    <D.24509>:
    D.24871 = bb->in_count;
    D.24872 = (int) D.24871;
    if (D.24872 > in_bb_index) goto <D.24508>; else goto <D.24510>;
    <D.24510>:
  }
  <D.24883>:
  previous_bb = previous_bb->next_bb;
  bb = bb->next_bb;
  <D.24512>:
  if (bb != 0B) goto <D.24511>; else goto <D.24513>;
  <D.24513>:
  D.24861 = cfg->verbose_level;
  if (D.24861 > 3) goto <D.24946>; else goto <D.24947>;
  <D.24946>:
  bb = cfg->bb_entry;
  goto <D.24522>;
  <D.24521>:
  {
    int i;

    D.24864 = bb->block_num;
    printf ("remove_critical_edges, AFTER BB%d (in:", D.24864);
    i = 0;
    goto <D.24516>;
    <D.24515>:
    D.24865 = bb->in_bb;
    i.11 = (unsigned int) i;
    D.24949 = i.11 * 4;
    D.24950 = D.24865 + D.24949;
    D.24951 = *D.24950;
    D.24952 = D.24951->block_num;
    printf (" %d", D.24952);
    i = i + 1;
    <D.24516>:
    D.24871 = bb->in_count;
    D.24872 = (int) D.24871;
    if (D.24872 > i) goto <D.24515>; else goto <D.24517>;
    <D.24517>:
    printf (") (out:");
    i = 0;
    goto <D.24519>;
    <D.24518>:
    D.24873 = bb->out_bb;
    i.11 = (unsigned int) i;
    D.24949 = i.11 * 4;
    D.24953 = D.24873 + D.24949;
    D.24954 = *D.24953;
    D.24955 = D.24954->block_num;
    printf (" %d", D.24955);
    i = i + 1;
    <D.24519>:
    D.24877 = bb->out_count;
    D.24878 = (int) D.24877;
    if (D.24878 > i) goto <D.24518>; else goto <D.24520>;
    <D.24520>:
    printf (")");
    D.24879 = bb->last_ins;
    if (D.24879 != 0B) goto <D.24956>; else goto <D.24957>;
    <D.24956>:
    printf (" ");
    D.24879 = bb->last_ins;
    mono_print_ins (D.24879);
    <D.24957>:
    printf ("\n");
  }
  bb = bb->next_bb;
  <D.24522>:
  if (bb != 0B) goto <D.24521>; else goto <D.24523>;
  <D.24523>:
  <D.24947>:
}


mono_bb_is_fall_through (struct MonoCompile * cfg, struct MonoBasicBlock * bb)
{
  gboolean D.24958;
  int iftmp.12;
  struct MonoBasicBlock * D.24963;
  unsigned int D.24965;
  unsigned int D.24966;
  struct MonoInst * D.24968;
  short unsigned int D.24970;
  short unsigned int D.24971;
  _Bool D.24972;
  short unsigned int D.24973;
  _Bool D.24974;
  _Bool D.24975;
  short unsigned int D.24977;
  short unsigned int D.24978;

  D.24963 = bb->next_bb;
  if (D.24963 != 0B) goto <D.24964>; else goto <D.24960>;
  <D.24964>:
  D.24963 = bb->next_bb;
  D.24965 = D.24963->region;
  D.24966 = bb->region;
  if (D.24965 == D.24966) goto <D.24967>; else goto <D.24960>;
  <D.24967>:
  D.24968 = bb->last_ins;
  if (D.24968 == 0B) goto <D.24961>; else goto <D.24969>;
  <D.24969>:
  D.24968 = bb->last_ins;
  D.24970 = D.24968->opcode;
  D.24971 = D.24970 + 64985;
  D.24972 = D.24971 > 9;
  D.24973 = D.24970 + 64878;
  D.24974 = D.24973 > 9;
  D.24975 = D.24972 & D.24974;
  if (D.24975 != 0) goto <D.24976>; else goto <D.24960>;
  <D.24976>:
  D.24968 = bb->last_ins;
  D.24977 = D.24968->opcode;
  D.24978 = D.24977 + 64888;
  if (D.24978 > 9) goto <D.24979>; else goto <D.24960>;
  <D.24979>:
  D.24968 = bb->last_ins;
  D.24977 = D.24968->opcode;
  if (D.24977 != 442) goto <D.24980>; else goto <D.24960>;
  <D.24980>:
  D.24968 = bb->last_ins;
  D.24977 = D.24968->opcode;
  if (D.24977 != 759) goto <D.24981>; else goto <D.24960>;
  <D.24981>:
  D.24968 = bb->last_ins;
  D.24977 = D.24968->opcode;
  if (D.24977 != 370) goto <D.24961>; else goto <D.24960>;
  <D.24961>:
  iftmp.12 = 1;
  goto <D.24962>;
  <D.24960>:
  iftmp.12 = 0;
  <D.24962>:
  D.24958 = iftmp.12;
  return D.24958;
}


replace_out_block (struct MonoBasicBlock * bb, struct MonoBasicBlock * orig, struct MonoBasicBlock * repl)
{
  struct MonoBasicBlock * * D.24983;
  unsigned int i.13;
  unsigned int D.24985;
  struct MonoBasicBlock * * D.24986;
  short int D.24991;
  sizetype D.24994;
  sizetype D.24995;
  sizetype D.24996;
  struct MonoBasicBlock * * D.24997;
  struct MonoBasicBlock * D.24998;
  short int D.24999;
  unsigned short D.25000;
  unsigned short D.25001;
  short int D.25002;
  int D.25004;
  int i;

  i = 0;
  goto <D.24375>;
  <D.24374>:
  {
    struct MonoBasicBlock * ob;

    D.24983 = bb->out_bb;
    i.13 = (unsigned int) i;
    D.24985 = i.13 * 4;
    D.24986 = D.24983 + D.24985;
    ob = *D.24986;
    if (ob == orig) goto <D.24987>; else goto <D.24988>;
    <D.24987>:
    if (repl == 0B) goto <D.24989>; else goto <D.24990>;
    <D.24989>:
    D.24991 = bb->out_count;
    if (D.24991 > 1) goto <D.24992>; else goto <D.24993>;
    <D.24992>:
    D.24983 = bb->out_bb;
    i.13 = (unsigned int) i;
    D.24985 = i.13 * 4;
    D.24986 = D.24983 + D.24985;
    D.24983 = bb->out_bb;
    D.24991 = bb->out_count;
    D.24994 = (sizetype) D.24991;
    D.24995 = D.24994 + 1073741823;
    D.24996 = D.24995 * 4;
    D.24997 = D.24983 + D.24996;
    D.24998 = *D.24997;
    *D.24986 = D.24998;
    <D.24993>:
    D.24991 = bb->out_count;
    D.24999 = D.24991;
    D.25000 = (unsigned short) D.24999;
    D.25001 = D.25000 + 65535;
    D.25002 = (short int) D.25001;
    bb->out_count = D.25002;
    goto <D.25003>;
    <D.24990>:
    D.24983 = bb->out_bb;
    i.13 = (unsigned int) i;
    D.24985 = i.13 * 4;
    D.24986 = D.24983 + D.24985;
    *D.24986 = repl;
    <D.25003>:
    <D.24988>:
  }
  i = i + 1;
  <D.24375>:
  D.24991 = bb->out_count;
  D.25004 = (int) D.24991;
  if (D.25004 > i) goto <D.24374>; else goto <D.24376>;
  <D.24376>:
}


replace_out_block_in_code (struct MonoBasicBlock * bb, struct MonoBasicBlock * orig, struct MonoBasicBlock * repl)
{
  short unsigned int D.25005;
  int D.25006;
  struct MonoBasicBlock * D.25007;
  struct MonoClass * D.25012;
  struct MonoBasicBlock * * D.25013;
  unsigned int i.14;
  unsigned int D.25015;
  struct MonoBasicBlock * * D.25016;
  struct MonoBasicBlock * D.25017;
  short unsigned int D.25023;
  short unsigned int D.25024;
  _Bool D.25025;
  short unsigned int D.25026;
  _Bool D.25027;
  _Bool D.25028;
  short unsigned int D.25030;
  struct MonoBasicBlock * D.25031;
  struct MonoBasicBlock * * D.25034;
  struct MonoBasicBlock * D.25035;
  struct MonoInst * D.25043;
  struct MonoInst * D.25046;
  struct MonoJumpInfoBBTable * iftmp.15;
  struct MonoJumpInfoBBTable * iftmp.16;
  struct MonoJumpInfoBBTable * iftmp.17;
  struct MonoJumpInfoBBTable * iftmp.18;
  struct MonoBasicBlock * * D.25065;
  unsigned int i.19;
  unsigned int D.25067;
  struct MonoBasicBlock * * D.25068;
  struct MonoBasicBlock * D.25069;
  int D.25072;
  struct MonoInst * ins;

  ins = bb->code;
  goto <D.24409>;
  <D.24408>:
  D.25005 = ins->opcode;
  D.25006 = (int) D.25005;
  switch (D.25006) <default: <D.24402>, case 370: <D.24396>, case 442: <D.24393>, case 735: <D.24395>>
  <D.24393>:
  D.25007 = ins->data.op[0].target_block;
  if (D.25007 == orig) goto <D.25008>; else goto <D.25009>;
  <D.25008>:
  ins->data.op[0].target_block = repl;
  <D.25009>:
  goto <D.24394>;
  <D.24395>:
  D.25007 = ins->data.op[0].target_block;
  if (D.25007 == orig) goto <D.25010>; else goto <D.25011>;
  <D.25010>:
  ins->data.op[0].target_block = repl;
  <D.25011>:
  goto <D.24394>;
  <D.24396>:
  {
    int i;
    int n;

    D.25012 = ins->klass;
    n = (int) D.25012;
    i = 0;
    goto <D.24400>;
    <D.24399>:
    D.25013 = ins->data.op[1].many_blocks;
    i.14 = (unsigned int) i;
    D.25015 = i.14 * 4;
    D.25016 = D.25013 + D.25015;
    D.25017 = *D.25016;
    if (D.25017 == orig) goto <D.25018>; else goto <D.25019>;
    <D.25018>:
    D.25013 = ins->data.op[1].many_blocks;
    i.14 = (unsigned int) i;
    D.25015 = i.14 * 4;
    D.25016 = D.25013 + D.25015;
    *D.25016 = repl;
    <D.25019>:
    i = i + 1;
    <D.24400>:
    if (i < n) goto <D.24399>; else goto <D.24401>;
    <D.24401>:
    goto <D.24394>;
  }
  <D.24402>:
  D.25023 = ins->opcode;
  D.25024 = D.25023 + 64985;
  D.25025 = D.25024 <= 9;
  D.25026 = D.25023 + 64878;
  D.25027 = D.25026 <= 9;
  D.25028 = D.25025 | D.25027;
  if (D.25028 != 0) goto <D.25020>; else goto <D.25029>;
  <D.25029>:
  D.25005 = ins->opcode;
  D.25030 = D.25005 + 64888;
  if (D.25030 <= 9) goto <D.25020>; else goto <D.25021>;
  <D.25020>:
  D.25013 = ins->data.op[1].many_blocks;
  D.25031 = *D.25013;
  if (D.25031 == orig) goto <D.25032>; else goto <D.25033>;
  <D.25032>:
  D.25013 = ins->data.op[1].many_blocks;
  *D.25013 = repl;
  <D.25033>:
  D.25013 = ins->data.op[1].many_blocks;
  D.25034 = D.25013 + 4;
  D.25035 = *D.25034;
  if (D.25035 == orig) goto <D.25036>; else goto <D.25037>;
  <D.25036>:
  D.25013 = ins->data.op[1].many_blocks;
  D.25034 = D.25013 + 4;
  *D.25034 = repl;
  <D.25037>:
  goto <D.25022>;
  <D.25021>:
  D.25005 = ins->opcode;
  if (D.25005 == 731) goto <D.25038>; else goto <D.25041>;
  <D.25041>:
  D.25005 = ins->opcode;
  if (D.25005 == 732) goto <D.25042>; else goto <D.25039>;
  <D.25042>:
  D.25043 = ins->data.op[1].src;
  if (D.25043 == 8B) goto <D.25038>; else goto <D.25039>;
  <D.25039>:
  D.25005 = ins->opcode;
  if (D.25005 == 370) goto <D.25038>; else goto <D.25044>;
  <D.25044>:
  D.25005 = ins->opcode;
  if (D.25005 == 734) goto <D.25045>; else goto <D.25040>;
  <D.25045>:
  D.25043 = ins->data.op[1].src;
  D.25046 = D.25043->data.op[1].src;
  if (D.25046 == 8B) goto <D.25038>; else goto <D.25040>;
  <D.25038>:
  {
    int i;
    struct MonoJumpInfoBBTable * table;

    D.25005 = ins->opcode;
    if (D.25005 == 731) goto <D.25048>; else goto <D.25049>;
    <D.25048>:
    iftmp.15 = ins->data.op[0].p;
    goto <D.25050>;
    <D.25049>:
    D.25005 = ins->opcode;
    if (D.25005 == 732) goto <D.25054>; else goto <D.25052>;
    <D.25054>:
    D.25043 = ins->data.op[1].src;
    if (D.25043 == 8B) goto <D.25055>; else goto <D.25052>;
    <D.25055>:
    iftmp.16 = ins->data.op[0].p;
    goto <D.25053>;
    <D.25052>:
    D.25005 = ins->opcode;
    if (D.25005 == 370) goto <D.25057>; else goto <D.25058>;
    <D.25057>:
    iftmp.17 = ins->data.op[0].p;
    goto <D.25059>;
    <D.25058>:
    D.25005 = ins->opcode;
    if (D.25005 == 734) goto <D.25063>; else goto <D.25061>;
    <D.25063>:
    D.25043 = ins->data.op[1].src;
    D.25046 = D.25043->data.op[1].src;
    if (D.25046 == 8B) goto <D.25064>; else goto <D.25061>;
    <D.25064>:
    D.25043 = ins->data.op[1].src;
    iftmp.18 = D.25043->data.op[0].p;
    goto <D.25062>;
    <D.25061>:
    iftmp.18 = 0B;
    <D.25062>:
    iftmp.17 = iftmp.18;
    <D.25059>:
    iftmp.16 = iftmp.17;
    <D.25053>:
    iftmp.15 = iftmp.16;
    <D.25050>:
    table = iftmp.15;
    i = 0;
    goto <D.24406>;
    <D.24405>:
    D.25065 = table->table;
    i.19 = (unsigned int) i;
    D.25067 = i.19 * 4;
    D.25068 = D.25065 + D.25067;
    D.25069 = *D.25068;
    if (D.25069 == orig) goto <D.25070>; else goto <D.25071>;
    <D.25070>:
    D.25065 = table->table;
    i.19 = (unsigned int) i;
    D.25067 = i.19 * 4;
    D.25068 = D.25065 + D.25067;
    *D.25068 = repl;
    <D.25071>:
    i = i + 1;
    <D.24406>:
    D.25072 = table->table_size;
    if (D.25072 > i) goto <D.24405>; else goto <D.24407>;
    <D.24407>:
  }
  <D.25040>:
  <D.25022>:
  goto <D.24394>;
  <D.24394>:
  ins = ins->next;
  <D.24409>:
  if (ins != 0B) goto <D.24408>; else goto <D.24410>;
  <D.24410>:
}


replace_in_block (struct MonoBasicBlock * bb, struct MonoBasicBlock * orig, struct MonoBasicBlock * repl)
{
  struct MonoBasicBlock * * D.25073;
  unsigned int i.20;
  unsigned int D.25075;
  struct MonoBasicBlock * * D.25076;
  short int D.25081;
  sizetype D.25084;
  sizetype D.25085;
  sizetype D.25086;
  struct MonoBasicBlock * * D.25087;
  struct MonoBasicBlock * D.25088;
  short int D.25089;
  unsigned short D.25090;
  unsigned short D.25091;
  short int D.25092;
  int D.25094;
  int i;

  i = 0;
  goto <D.24385>;
  <D.24384>:
  {
    struct MonoBasicBlock * ib;

    D.25073 = bb->in_bb;
    i.20 = (unsigned int) i;
    D.25075 = i.20 * 4;
    D.25076 = D.25073 + D.25075;
    ib = *D.25076;
    if (ib == orig) goto <D.25077>; else goto <D.25078>;
    <D.25077>:
    if (repl == 0B) goto <D.25079>; else goto <D.25080>;
    <D.25079>:
    D.25081 = bb->in_count;
    if (D.25081 > 1) goto <D.25082>; else goto <D.25083>;
    <D.25082>:
    D.25073 = bb->in_bb;
    i.20 = (unsigned int) i;
    D.25075 = i.20 * 4;
    D.25076 = D.25073 + D.25075;
    D.25073 = bb->in_bb;
    D.25081 = bb->in_count;
    D.25084 = (sizetype) D.25081;
    D.25085 = D.25084 + 1073741823;
    D.25086 = D.25085 * 4;
    D.25087 = D.25073 + D.25086;
    D.25088 = *D.25087;
    *D.25076 = D.25088;
    <D.25083>:
    D.25081 = bb->in_count;
    D.25089 = D.25081;
    D.25090 = (unsigned short) D.25089;
    D.25091 = D.25090 + 65535;
    D.25092 = (short int) D.25091;
    bb->in_count = D.25092;
    goto <D.25093>;
    <D.25080>:
    D.25073 = bb->in_bb;
    i.20 = (unsigned int) i;
    D.25075 = i.20 * 4;
    D.25076 = D.25073 + D.25075;
    *D.25076 = repl;
    <D.25093>:
    <D.25078>:
  }
  i = i + 1;
  <D.24385>:
  D.25081 = bb->in_count;
  D.25094 = (int) D.25081;
  if (D.25094 > i) goto <D.24384>; else goto <D.24386>;
  <D.24386>:
}


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

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


mono_optimize_branches (struct MonoCompile * cfg)
{
  unsigned int D.25097;
  struct MonoBasicBlock * D.25101;
  unsigned int D.25102;
  unsigned char D.25105;
  unsigned char D.25106;
  int D.25109;
  short int D.25114;
  struct MonoBasicBlock * D.25117;
  unsigned int D.25120;
  unsigned int D.25123;
  int D.25126;
  struct MonoBasicBlock * D.25127;
  struct MonoBasicBlock * * D.25128;
  unsigned int i.21;
  unsigned int D.25130;
  struct MonoBasicBlock * * D.25131;
  struct MonoBasicBlock * D.25132;
  short int D.25133;
  int D.25134;
  short int D.25135;
  struct MonoBasicBlock * * D.25138;
  struct MonoInst * D.25141;
  short unsigned int D.25144;
  short unsigned int D.25147;
  short unsigned int D.25148;
  _Bool D.25149;
  short unsigned int D.25150;
  _Bool D.25151;
  _Bool D.25152;
  short unsigned int D.25154;
  struct MonoBasicBlock * * D.25155;
  struct MonoBasicBlock * D.25156;
  int D.25159;
  int D.25160;
  struct MonoBasicBlock * D.25163;
  unsigned char D.25170;
  unsigned char D.25171;
  unsigned char D.25178;
  struct MonoInst * D.25203;
  short unsigned int D.25206;
  struct MonoBasicBlock * D.25209;
  unsigned int D.25212;
  int D.25217;
  short unsigned int D.25227;
  short unsigned int D.25228;
  _Bool D.25229;
  short unsigned int D.25230;
  _Bool D.25231;
  _Bool D.25232;
  short unsigned int D.25234;
  struct MonoInst * D.25237;
  struct MonoInst * D.25239;
  unsigned char D.25240;
  unsigned char D.25241;
  int D.25242;
  int D.25243;
  int D.25247;
  int D.25270;
  struct MonoBasicBlock * * D.25271;
  struct MonoBasicBlock * D.25272;
  unsigned char D.25291;
  unsigned char D.25292;
  int D.25301;
  struct MonoBasicBlock * * D.25304;
  struct MonoBasicBlock * D.25305;
  _Bool D.25306;
  long int D.25307;
  long int D.25308;
  short unsigned int D.25319;
  short unsigned int D.25320;
  _Bool D.25321;
  short unsigned int D.25322;
  _Bool D.25323;
  _Bool D.25324;
  unsigned char D.25331;
  unsigned char D.25332;
  unsigned int D.25335;
  unsigned char D.25338;
  unsigned char D.25339;
  unsigned int D.25342;
  unsigned int D.25343;
  short unsigned int D.25344;
  _Bool D.25347;
  _Bool D.25348;
  _Bool D.25349;
  int i;
  int changed;
  struct MonoBasicBlock * bb;
  struct MonoBasicBlock * bbn;
  guint32 niterations;

  changed = 0;
  D.25097 = cfg->num_bblocks;
  if (D.25097 > 1000) goto <D.25098>; else goto <D.25099>;
  <D.25098>:
  D.25097 = cfg->num_bblocks;
  niterations = D.25097 * 2;
  goto <D.25100>;
  <D.25099>:
  niterations = 1000;
  <D.25100>:
  <D.24546>:
  {
    struct MonoBasicBlock * previous_bb;

    changed = 0;
    niterations = niterations + 4294967295;
    previous_bb = cfg->bb_entry;
    D.25101 = cfg->bb_entry;
    bb = D.25101->next_bb;
    goto <D.24544>;
    <D.24543>:
    D.25102 = bb->region;
    if (D.25102 != 4294967295) goto <D.25103>; else goto <D.25104>;
    <D.25103>:
    // predicted unlikely by continue predictor.
    goto <D.24533>;
    <D.25104>:
    D.25105 = BIT_FIELD_REF <*bb, 8, 912>;
    D.25106 = D.25105 & 2;
    if (D.25106 == 0) goto <D.25107>; else goto <D.25108>;
    <D.25107>:
    D.25109 = remove_block_if_useless (cfg, bb, previous_bb);
    if (D.25109 != 0) goto <D.25110>; else goto <D.25111>;
    <D.25110>:
    changed = 1;
    // predicted unlikely by continue predictor.
    goto <D.24533>;
    <D.25111>:
    <D.25108>:
    bbn = bb->next_bb;
    if (bbn != 0B) goto <D.25112>; else goto <D.25113>;
    <D.25112>:
    D.25114 = bbn->in_count;
    if (D.25114 == 0) goto <D.25115>; else goto <D.25116>;
    <D.25115>:
    D.25117 = cfg->bb_exit;
    if (D.25117 != bbn) goto <D.25118>; else goto <D.25119>;
    <D.25118>:
    D.25102 = bb->region;
    D.25120 = bbn->region;
    if (D.25102 == D.25120) goto <D.25121>; else goto <D.25122>;
    <D.25121>:
    D.25123 = cfg->verbose_level;
    if (D.25123 > 2) goto <D.25124>; else goto <D.25125>;
    <D.25124>:
    D.25126 = bbn->block_num;
    monoeg_g_print ("nullify block triggered %d\n", D.25126);
    <D.25125>:
    D.25127 = bbn->next_bb;
    bb->next_bb = D.25127;
    i = 0;
    goto <D.24535>;
    <D.24534>:
    D.25128 = bbn->out_bb;
    i.21 = (unsigned int) i;
    D.25130 = i.21 * 4;
    D.25131 = D.25128 + D.25130;
    D.25132 = *D.25131;
    replace_in_block (D.25132, bbn, 0B);
    i = i + 1;
    <D.24535>:
    D.25133 = bbn->out_count;
    D.25134 = (int) D.25133;
    if (D.25134 > i) goto <D.24534>; else goto <D.24536>;
    <D.24536>:
    mono_nullify_basic_block (bbn);
    changed = 1;
    <D.25122>:
    <D.25119>:
    <D.25116>:
    <D.25113>:
    D.25135 = bb->out_count;
    if (D.25135 == 1) goto <D.25136>; else goto <D.25137>;
    <D.25136>:
    D.25138 = bb->out_bb;
    bbn = *D.25138;
    D.25141 = bb->last_ins;
    if (D.25141 != 0B) goto <D.25142>; else goto <D.25143>;
    <D.25142>:
    D.25141 = bb->last_ins;
    D.25144 = D.25141->opcode;
    if (D.25144 != 442) goto <D.25145>; else goto <D.25146>;
    <D.25145>:
    D.25141 = bb->last_ins;
    D.25147 = D.25141->opcode;
    D.25148 = D.25147 + 64985;
    D.25149 = D.25148 <= 9;
    D.25150 = D.25147 + 64878;
    D.25151 = D.25150 <= 9;
    D.25152 = D.25149 | D.25151;
    if (D.25152 != 0) goto <D.25139>; else goto <D.25153>;
    <D.25153>:
    D.25141 = bb->last_ins;
    D.25144 = D.25141->opcode;
    D.25154 = D.25144 + 64888;
    if (D.25154 <= 9) goto <D.25139>; else goto <D.25140>;
    <D.25139>:
    D.25141 = bb->last_ins;
    D.25141->opcode = 442;
    D.25141 = bb->last_ins;
    D.25141 = bb->last_ins;
    D.25155 = D.25141->data.op[1].many_blocks;
    D.25156 = *D.25155;
    D.25141->data.op[0].target_block = D.25156;
    changed = 1;
    D.25123 = cfg->verbose_level;
    if (D.25123 > 2) goto <D.25157>; else goto <D.25158>;
    <D.25157>:
    D.25159 = bb->block_num;
    D.25135 = bb->out_count;
    D.25160 = (int) D.25135;
    monoeg_g_print ("cond branch removal triggered in %d %d\n", D.25159, D.25160);
    <D.25158>:
    <D.25140>:
    <D.25146>:
    <D.25143>:
    D.25102 = bb->region;
    D.25120 = bbn->region;
    if (D.25102 == D.25120) goto <D.25161>; else goto <D.25162>;
    <D.25161>:
    D.25163 = bb->next_bb;
    if (D.25163 == bbn) goto <D.25164>; else goto <D.25165>;
    <D.25164>:
    D.25141 = bb->last_ins;
    if (D.25141 != 0B) goto <D.25166>; else goto <D.25167>;
    <D.25166>:
    D.25141 = bb->last_ins;
    D.25144 = D.25141->opcode;
    if (D.25144 == 442) goto <D.25168>; else goto <D.25169>;
    <D.25168>:
    D.25170 = BIT_FIELD_REF <*bbn, 8, 912>;
    D.25171 = D.25170 & 1;
    if (D.25171 == 0) goto <D.25172>; else goto <D.25173>;
    <D.25172>:
    D.25141 = bb->last_ins;
    D.25141->opcode = 316;
    changed = 1;
    D.25123 = cfg->verbose_level;
    if (D.25123 > 2) goto <D.25174>; else goto <D.25175>;
    <D.25174>:
    D.25159 = bb->block_num;
    D.25126 = bbn->block_num;
    monoeg_g_print ("br removal triggered %d -> %d\n", D.25159, D.25126);
    <D.25175>:
    <D.25173>:
    <D.25169>:
    <D.25167>:
    D.25114 = bbn->in_count;
    if (D.25114 == 1) goto <D.25176>; else goto <D.25177>;
    <D.25176>:
    D.25105 = BIT_FIELD_REF <*bb, 8, 912>;
    D.25178 = D.25105 & 8;
    if (D.25178 == 0) goto <D.25179>; else goto <D.25180>;
    <D.25179>:
    D.25117 = cfg->bb_exit;
    if (D.25117 != bbn) goto <D.25181>; else goto <D.25182>;
    <D.25181>:
    D.25123 = cfg->verbose_level;
    if (D.25123 > 2) goto <D.25183>; else goto <D.25184>;
    <D.25183>:
    D.25159 = bb->block_num;
    D.25126 = bbn->block_num;
    monoeg_g_print ("block merge triggered %d -> %d\n", D.25159, D.25126);
    <D.25184>:
    mono_merge_basic_blocks (cfg, bb, bbn);
    changed = 1;
    // predicted unlikely by continue predictor.
    goto <D.24533>;
    <D.25182>:
    <D.25180>:
    <D.25177>:
    <D.25165>:
    <D.25162>:
    <D.25137>:
    bbn = bb->next_bb;
    if (bbn != 0B) goto <D.25185>; else goto <D.25186>;
    <D.25185>:
    D.25114 = bbn->in_count;
    if (D.25114 == 0) goto <D.25187>; else goto <D.25188>;
    <D.25187>:
    D.25117 = cfg->bb_exit;
    if (D.25117 != bbn) goto <D.25189>; else goto <D.25190>;
    <D.25189>:
    D.25102 = bb->region;
    D.25120 = bbn->region;
    if (D.25102 == D.25120) goto <D.25191>; else goto <D.25192>;
    <D.25191>:
    D.25123 = cfg->verbose_level;
    if (D.25123 > 2) goto <D.25193>; else goto <D.25194>;
    <D.25193>:
    D.25126 = bbn->block_num;
    monoeg_g_print ("nullify block triggered %d\n", D.25126);
    <D.25194>:
    D.25127 = bbn->next_bb;
    bb->next_bb = D.25127;
    i = 0;
    goto <D.24538>;
    <D.24537>:
    D.25128 = bbn->out_bb;
    i.21 = (unsigned int) i;
    D.25130 = i.21 * 4;
    D.25131 = D.25128 + D.25130;
    D.25132 = *D.25131;
    replace_in_block (D.25132, bbn, 0B);
    i = i + 1;
    <D.24538>:
    D.25133 = bbn->out_count;
    D.25134 = (int) D.25133;
    if (D.25134 > i) goto <D.24537>; else goto <D.24539>;
    <D.24539>:
    mono_nullify_basic_block (bbn);
    changed = 1;
    // predicted unlikely by continue predictor.
    goto <D.24533>;
    <D.25192>:
    <D.25190>:
    <D.25188>:
    <D.25186>:
    D.25135 = bb->out_count;
    if (D.25135 == 1) goto <D.25195>; else goto <D.25196>;
    <D.25195>:
    D.25138 = bb->out_bb;
    bbn = *D.25138;
    D.25141 = bb->last_ins;
    if (D.25141 != 0B) goto <D.25197>; else goto <D.25198>;
    <D.25197>:
    D.25141 = bb->last_ins;
    D.25144 = D.25141->opcode;
    if (D.25144 == 442) goto <D.25199>; else goto <D.25200>;
    <D.25199>:
    D.25141 = bb->last_ins;
    bbn = D.25141->data.op[0].target_block;
    D.25102 = bb->region;
    D.25120 = bbn->region;
    if (D.25102 == D.25120) goto <D.25201>; else goto <D.25202>;
    <D.25201>:
    D.25203 = bbn->code;
    if (D.25203 != 0B) goto <D.25204>; else goto <D.25205>;
    <D.25204>:
    D.25203 = bbn->code;
    D.25206 = D.25203->opcode;
    if (D.25206 == 442) goto <D.25207>; else goto <D.25208>;
    <D.25207>:
    D.25203 = bbn->code;
    D.25209 = D.25203->data.op[0].target_block;
    if (D.25209 != bbn) goto <D.25210>; else goto <D.25211>;
    <D.25210>:
    D.25203 = bbn->code;
    D.25209 = D.25203->data.op[0].target_block;
    D.25212 = D.25209->region;
    D.25102 = bb->region;
    if (D.25212 == D.25102) goto <D.25213>; else goto <D.25214>;
    <D.25213>:
    D.25123 = cfg->verbose_level;
    if (D.25123 > 2) goto <D.25215>; else goto <D.25216>;
    <D.25215>:
    D.25159 = bb->block_num;
    D.25126 = bbn->block_num;
    D.25203 = bbn->code;
    D.25209 = D.25203->data.op[0].target_block;
    D.25217 = D.25209->block_num;
    monoeg_g_print ("branch to branch triggered %d -> %d -> %d\n", D.25159, D.25126, D.25217);
    <D.25216>:
    replace_in_block (bbn, bb, 0B);
    D.25203 = bbn->code;
    D.25209 = D.25203->data.op[0].target_block;
    replace_out_block (bb, bbn, D.25209);
    D.25203 = bbn->code;
    D.25209 = D.25203->data.op[0].target_block;
    mono_link_bblock (cfg, bb, D.25209);
    D.25141 = bb->last_ins;
    D.25203 = bbn->code;
    D.25209 = D.25203->data.op[0].target_block;
    D.25141->data.op[0].target_block = D.25209;
    changed = 1;
    // predicted unlikely by continue predictor.
    goto <D.24533>;
    <D.25214>:
    <D.25211>:
    <D.25208>:
    <D.25205>:
    <D.25202>:
    <D.25200>:
    <D.25198>:
    goto <D.25218>;
    <D.25196>:
    D.25135 = bb->out_count;
    if (D.25135 == 2) goto <D.25219>; else goto <D.25220>;
    <D.25219>:
    D.25141 = bb->last_ins;
    if (D.25141 != 0B) goto <D.25225>; else goto <D.25226>;
    <D.25225>:
    D.25141 = bb->last_ins;
    D.25227 = D.25141->opcode;
    D.25228 = D.25227 + 64985;
    D.25229 = D.25228 <= 9;
    D.25230 = D.25227 + 64878;
    D.25231 = D.25230 <= 9;
    D.25232 = D.25229 | D.25231;
    if (D.25232 != 0) goto <D.25223>; else goto <D.25233>;
    <D.25233>:
    D.25141 = bb->last_ins;
    D.25144 = D.25141->opcode;
    D.25154 = D.25144 + 64888;
    if (D.25154 <= 9) goto <D.25223>; else goto <D.25224>;
    <D.25223>:
    D.25141 = bb->last_ins;
    D.25144 = D.25141->opcode;
    D.25234 = D.25144 + 64878;
    if (D.25234 > 9) goto <D.25235>; else goto <D.25236>;
    <D.25235>:
    D.25141 = bb->last_ins;
    D.25237 = D.25141->data.op[0].src;
    if (D.25237 == 0B) goto <D.25221>; else goto <D.25238>;
    <D.25238>:
    D.25141 = bb->last_ins;
    D.25237 = D.25141->data.op[0].src;
    D.25239 = D.25237->data.op[0].src;
    D.25240 = D.25239->type;
    if (D.25240 != 4) goto <D.25221>; else goto <D.25222>;
    <D.25221>:
    {
      int branch_result;
      struct MonoBasicBlock * taken_branch_target;
      struct MonoBasicBlock * untaken_branch_target;

      taken_branch_target = 0B;
      untaken_branch_target = 0B;
      D.25141 = bb->last_ins;
      D.25241 = D.25141->flags;
      D.25242 = (int) D.25241;
      D.25243 = D.25242 & 8;
      if (D.25243 != 0) goto <D.25244>; else goto <D.25245>;
      <D.25244>:
      branch_result = 1;
      goto <D.25246>;
      <D.25245>:
      D.25141 = bb->last_ins;
      D.25241 = D.25141->flags;
      D.25242 = (int) D.25241;
      D.25247 = D.25242 & 16;
      if (D.25247 != 0) goto <D.25248>; else goto <D.25249>;
      <D.25248>:
      branch_result = 0;
      goto <D.25250>;
      <D.25249>:
      branch_result = 2;
      <D.25250>:
      <D.25246>:
      if (branch_result == 1) goto <D.25251>; else goto <D.25252>;
      <D.25251>:
      D.25141 = bb->last_ins;
      D.25155 = D.25141->data.op[1].many_blocks;
      taken_branch_target = *D.25155;
      D.25141 = bb->last_ins;
      D.25155 = D.25141->data.op[1].many_blocks;
      untaken_branch_target = MEM[(struct MonoBasicBlock * *)D.25155 + 4B];
      goto <D.25253>;
      <D.25252>:
      if (branch_result == 0) goto <D.25254>; else goto <D.25255>;
      <D.25254>:
      D.25141 = bb->last_ins;
      D.25155 = D.25141->data.op[1].many_blocks;
      taken_branch_target = MEM[(struct MonoBasicBlock * *)D.25155 + 4B];
      D.25141 = bb->last_ins;
      D.25155 = D.25141->data.op[1].many_blocks;
      untaken_branch_target = *D.25155;
      <D.25255>:
      <D.25253>:
      if (taken_branch_target != 0B) goto <D.25256>; else goto <D.25257>;
      <D.25256>:
      D.25141 = bb->last_ins;
      D.25141->opcode = 442;
      D.25141 = bb->last_ins;
      D.25141->data.op[0].target_block = taken_branch_target;
      D.25105 = BIT_FIELD_REF <*bb, 8, 912>;
      D.25178 = D.25105 & 8;
      if (D.25178 == 0) goto <D.25258>; else goto <D.25259>;
      <D.25258>:
      mono_unlink_bblock (cfg, bb, untaken_branch_target);
      <D.25259>:
      changed = 1;
      // predicted unlikely by continue predictor.
      goto <D.24533>;
      <D.25257>:
      D.25141 = bb->last_ins;
      D.25155 = D.25141->data.op[1].many_blocks;
      bbn = *D.25155;
      D.25102 = bb->region;
      D.25120 = bbn->region;
      if (D.25102 == D.25120) goto <D.25260>; else goto <D.25261>;
      <D.25260>:
      D.25203 = bbn->code;
      if (D.25203 != 0B) goto <D.25262>; else goto <D.25263>;
      <D.25262>:
      D.25203 = bbn->code;
      D.25206 = D.25203->opcode;
      if (D.25206 == 442) goto <D.25264>; else goto <D.25265>;
      <D.25264>:
      D.25203 = bbn->code;
      D.25209 = D.25203->data.op[0].target_block;
      D.25212 = D.25209->region;
      D.25102 = bb->region;
      if (D.25212 == D.25102) goto <D.25266>; else goto <D.25267>;
      <D.25266>:
      D.25123 = cfg->verbose_level;
      if (D.25123 > 2) goto <D.25268>; else goto <D.25269>;
      <D.25268>:
      D.25159 = bb->block_num;
      D.25126 = bbn->block_num;
      D.25203 = bbn->code;
      D.25209 = D.25203->data.op[0].target_block;
      D.25217 = D.25209->block_num;
      D.25203 = bbn->code;
      D.25206 = D.25203->opcode;
      D.25270 = (int) D.25206;
      monoeg_g_print ("cbranch1 to branch triggered %d -> (%d) %d (0x%02x)\n", D.25159, D.25126, D.25217, D.25270);
      <D.25269>:
      D.25141 = bb->last_ins;
      D.25155 = D.25141->data.op[1].many_blocks;
      D.25156 = *D.25155;
      mono_unlink_bblock (cfg, bb, D.25156);
      D.25141 = bb->last_ins;
      D.25155 = D.25141->data.op[1].many_blocks;
      D.25271 = D.25155 + 4;
      D.25272 = *D.25271;
      mono_unlink_bblock (cfg, bb, D.25272);
      D.25141 = bb->last_ins;
      D.25155 = D.25141->data.op[1].many_blocks;
      D.25203 = bbn->code;
      D.25209 = D.25203->data.op[0].target_block;
      *D.25155 = D.25209;
      D.25141 = bb->last_ins;
      D.25155 = D.25141->data.op[1].many_blocks;
      D.25156 = *D.25155;
      mono_link_bblock (cfg, bb, D.25156);
      D.25141 = bb->last_ins;
      D.25155 = D.25141->data.op[1].many_blocks;
      D.25271 = D.25155 + 4;
      D.25272 = *D.25271;
      mono_link_bblock (cfg, bb, D.25272);
      changed = 1;
      // predicted unlikely by continue predictor.
      goto <D.24533>;
      <D.25267>:
      <D.25265>:
      <D.25263>:
      <D.25261>:
      D.25141 = bb->last_ins;
      D.25155 = D.25141->data.op[1].many_blocks;
      bbn = MEM[(struct MonoBasicBlock * *)D.25155 + 4B];
      if (bbn != 0B) goto <D.25273>; else goto <D.25274>;
      <D.25273>:
      D.25102 = bb->region;
      D.25120 = bbn->region;
      if (D.25102 == D.25120) goto <D.25275>; else goto <D.25276>;
      <D.25275>:
      D.25203 = bbn->code;
      if (D.25203 != 0B) goto <D.25277>; else goto <D.25278>;
      <D.25277>:
      D.25203 = bbn->code;
      D.25206 = D.25203->opcode;
      if (D.25206 == 442) goto <D.25279>; else goto <D.25280>;
      <D.25279>:
      D.25203 = bbn->code;
      D.25209 = D.25203->data.op[0].target_block;
      D.25212 = D.25209->region;
      D.25102 = bb->region;
      if (D.25212 == D.25102) goto <D.25281>; else goto <D.25282>;
      <D.25281>:
      D.25123 = cfg->verbose_level;
      if (D.25123 > 2) goto <D.25283>; else goto <D.25284>;
      <D.25283>:
      D.25159 = bb->block_num;
      D.25126 = bbn->block_num;
      D.25203 = bbn->code;
      D.25209 = D.25203->data.op[0].target_block;
      D.25217 = D.25209->block_num;
      D.25203 = bbn->code;
      D.25206 = D.25203->opcode;
      D.25270 = (int) D.25206;
      monoeg_g_print ("cbranch2 to branch triggered %d -> (%d) %d (0x%02x)\n", D.25159, D.25126, D.25217, D.25270);
      <D.25284>:
      D.25141 = bb->last_ins;
      D.25155 = D.25141->data.op[1].many_blocks;
      D.25156 = *D.25155;
      mono_unlink_bblock (cfg, bb, D.25156);
      D.25141 = bb->last_ins;
      D.25155 = D.25141->data.op[1].many_blocks;
      D.25271 = D.25155 + 4;
      D.25272 = *D.25271;
      mono_unlink_bblock (cfg, bb, D.25272);
      D.25141 = bb->last_ins;
      D.25155 = D.25141->data.op[1].many_blocks;
      D.25271 = D.25155 + 4;
      D.25203 = bbn->code;
      D.25209 = D.25203->data.op[0].target_block;
      *D.25271 = D.25209;
      D.25141 = bb->last_ins;
      D.25155 = D.25141->data.op[1].many_blocks;
      D.25156 = *D.25155;
      mono_link_bblock (cfg, bb, D.25156);
      D.25141 = bb->last_ins;
      D.25155 = D.25141->data.op[1].many_blocks;
      D.25271 = D.25155 + 4;
      D.25272 = *D.25271;
      mono_link_bblock (cfg, bb, D.25272);
      changed = 1;
      // predicted unlikely by continue predictor.
      goto <D.24533>;
      <D.25282>:
      <D.25280>:
      <D.25278>:
      <D.25276>:
      <D.25274>:
      D.25141 = bb->last_ins;
      D.25155 = D.25141->data.op[1].many_blocks;
      bbn = MEM[(struct MonoBasicBlock * *)D.25155 + 4B];
      if (bbn != 0B) goto <D.25285>; else goto <D.25286>;
      <D.25285>:
      D.25102 = bb->region;
      D.25120 = bbn->region;
      if (D.25102 == D.25120) goto <D.25287>; else goto <D.25288>;
      <D.25287>:
      D.25114 = bbn->in_count;
      if (D.25114 == 1) goto <D.25289>; else goto <D.25290>;
      <D.25289>:
      D.25291 = BIT_FIELD_REF <*cfg, 8, 3392>;
      D.25292 = D.25291 & 8;
      if (D.25292 != 0) goto <D.25293>; else goto <D.25294>;
      <D.25293>:
      D.25117 = cfg->bb_exit;
      if (D.25117 != bbn) goto <D.25295>; else goto <D.25296>;
      <D.25295>:
      D.25105 = BIT_FIELD_REF <*bb, 8, 912>;
      D.25178 = D.25105 & 8;
      if (D.25178 == 0) goto <D.25297>; else goto <D.25298>;
      <D.25297>:
      D.25170 = BIT_FIELD_REF <*bbn, 8, 912>;
      D.25171 = D.25170 & 1;
      if (D.25171 == 0) goto <D.25299>; else goto <D.25300>;
      <D.25299>:
      D.25301 = mono_bblocks_linked (bbn, bb);
      if (D.25301 == 0) goto <D.25302>; else goto <D.25303>;
      <D.25302>:
      D.25304 = bbn->in_bb;
      D.25305 = *D.25304;
      D.25306 = D.25305 != bb;
      D.25307 = (long int) D.25306;
      D.25308 = __builtin_expect (D.25307, 0);
      if (D.25308 != 0) goto <D.25309>; else goto <D.25310>;
      <D.25309>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "branch-opts.c", 1432, "bbn->in_bb [0] == bb");
      <D.25310>:
      D.25123 = cfg->verbose_level;
      if (D.25123 > 2) goto <D.25311>; else goto <D.25312>;
      <D.25311>:
      D.25159 = bb->block_num;
      D.25126 = bbn->block_num;
      monoeg_g_print ("merge false branch target triggered BB%d -> BB%d\n", D.25159, D.25126);
      <D.25312>:
      mono_merge_basic_blocks (cfg, bb, bbn);
      changed = 1;
      // predicted unlikely by continue predictor.
      goto <D.24533>;
      <D.25303>:
      <D.25300>:
      <D.25298>:
      <D.25296>:
      <D.25294>:
      <D.25290>:
      <D.25288>:
      <D.25286>:
    }
    <D.25222>:
    <D.25236>:
    <D.25224>:
    <D.25226>:
    D.25141 = bb->last_ins;
    if (D.25141 != 0B) goto <D.25317>; else goto <D.25318>;
    <D.25317>:
    D.25141 = bb->last_ins;
    D.25319 = D.25141->opcode;
    D.25320 = D.25319 + 64985;
    D.25321 = D.25320 <= 9;
    D.25322 = D.25319 + 64878;
    D.25323 = D.25322 <= 9;
    D.25324 = D.25321 | D.25323;
    if (D.25324 != 0) goto <D.25315>; else goto <D.25325>;
    <D.25325>:
    D.25141 = bb->last_ins;
    D.25144 = D.25141->opcode;
    D.25154 = D.25144 + 64888;
    if (D.25154 <= 9) goto <D.25315>; else goto <D.25316>;
    <D.25315>:
    D.25141 = bb->last_ins;
    D.25144 = D.25141->opcode;
    D.25234 = D.25144 + 64878;
    if (D.25234 > 9) goto <D.25326>; else goto <D.25327>;
    <D.25326>:
    D.25141 = bb->last_ins;
    D.25237 = D.25141->data.op[0].src;
    if (D.25237 == 0B) goto <D.25313>; else goto <D.25328>;
    <D.25328>:
    D.25141 = bb->last_ins;
    D.25237 = D.25141->data.op[0].src;
    D.25239 = D.25237->data.op[0].src;
    D.25240 = D.25239->type;
    if (D.25240 != 4) goto <D.25313>; else goto <D.25314>;
    <D.25313>:
    D.25141 = bb->last_ins;
    D.25155 = D.25141->data.op[1].many_blocks;
    D.25271 = D.25155 + 4;
    D.25272 = *D.25271;
    if (D.25272 != 0B) goto <D.25329>; else goto <D.25330>;
    <D.25329>:
    D.25141 = bb->last_ins;
    D.25155 = D.25141->data.op[1].many_blocks;
    D.25271 = D.25155 + 4;
    D.25272 = *D.25271;
    D.25331 = BIT_FIELD_REF <*D.25272, 8, 912>;
    D.25332 = D.25331 & 1;
    if (D.25332 != 0) goto <D.25333>; else goto <D.25334>;
    <D.25333>:
    D.25102 = bb->region;
    D.25141 = bb->last_ins;
    D.25155 = D.25141->data.op[1].many_blocks;
    D.25271 = D.25155 + 4;
    D.25272 = *D.25271;
    D.25335 = D.25272->region;
    if (D.25102 == D.25335) goto <D.25336>; else goto <D.25337>;
    <D.25336>:
    D.25338 = BIT_FIELD_REF <*cfg, 8, 3416>;
    D.25339 = D.25338 & 1;
    if (D.25339 == 0) goto <D.25340>; else goto <D.25341>;
    <D.25340>:
    D.25141 = bb->last_ins;
    D.25141 = bb->last_ins;
    D.25144 = D.25141->opcode;
    D.25342 = (unsigned int) D.25144;
    D.25343 = mono_reverse_branch_op (D.25342);
    D.25344 = (short unsigned int) D.25343;
    D.25141->opcode = D.25344;
    D.25141 = bb->last_ins;
    D.25155 = D.25141->data.op[1].many_blocks;
    bbn = MEM[(struct MonoBasicBlock * *)D.25155 + 4B];
    D.25141 = bb->last_ins;
    D.25155 = D.25141->data.op[1].many_blocks;
    D.25271 = D.25155 + 4;
    D.25141 = bb->last_ins;
    D.25155 = D.25141->data.op[1].many_blocks;
    D.25156 = *D.25155;
    *D.25271 = D.25156;
    D.25141 = bb->last_ins;
    D.25155 = D.25141->data.op[1].many_blocks;
    *D.25155 = bbn;
    D.25141 = bb->last_ins;
    D.25155 = D.25141->data.op[1].many_blocks;
    D.25156 = *D.25155;
    move_basic_block_to_end (cfg, D.25156);
    D.25123 = cfg->verbose_level;
    if (D.25123 > 2) goto <D.25345>; else goto <D.25346>;
    <D.25345>:
    D.25159 = bb->block_num;
    monoeg_g_print ("cbranch to throw block triggered %d.\n", D.25159);
    <D.25346>:
    <D.25341>:
    <D.25337>:
    <D.25334>:
    <D.25330>:
    <D.25314>:
    <D.25327>:
    <D.25316>:
    <D.25318>:
    <D.25220>:
    <D.25218>:
    <D.24533>:
    previous_bb = bb;
    bb = bb->next_bb;
    <D.24544>:
    if (bb != 0B) goto <D.24543>; else goto <D.24545>;
    <D.24545>:
  }
  D.25347 = changed != 0;
  D.25348 = niterations != 0;
  D.25349 = D.25347 & D.25348;
  if (D.25349 != 0) goto <D.24546>; else goto <D.24547>;
  <D.24547>:
}


remove_block_if_useless (struct MonoCompile * cfg, struct MonoBasicBlock * bb, struct MonoBasicBlock * previous_bb)
{
  unsigned int D.25350;
  gboolean D.25353;
  short unsigned int D.25354;
  int D.25355;
  short int D.25360;
  struct MonoBasicBlock * * D.25362;
  struct MonoBasicBlock * D.25363;
  struct MonoBasicBlock * D.25364;
  struct MonoInst * D.25366;
  short unsigned int D.25369;
  struct MonoBasicBlock * D.25372;
  unsigned int D.25377;
  unsigned int D.25378;
  _Bool D.25381;
  _Bool D.25382;
  _Bool D.25383;
  unsigned int D.25386;
  int D.25389;
  struct MonoBasicBlock * * D.25390;
  short int D.25391;
  int D.25394;
  struct MonoBasicBlock * * D.25397;
  unsigned int i.22;
  unsigned int D.25399;
  struct MonoBasicBlock * * D.25400;
  struct MonoBasicBlock * D.25401;
  struct MonoMemPool * D.25404;
  int D.25405;
  int D.25406;
  const unsigned char * D.25407;
  unsigned char * D.25411;
  short int D.25412;
  int D.25413;
  struct MonoBasicBlock * target_bb;
  struct MonoInst * inst;

  target_bb = 0B;
  D.25350 = bb->region;
  if (D.25350 != 4294967295) goto <D.25351>; else goto <D.25352>;
  <D.25351>:
  bb->not_useless = 1;
  D.25353 = 0;
  return D.25353;
  <D.25352>:
  inst = bb->code;
  goto <D.24423>;
  <D.24422>:
  D.25354 = inst->opcode;
  D.25355 = (int) D.25354;
  switch (D.25355) <default: <D.24421>, case 316: <D.24418>, case 442: <D.24420>>
  <D.24418>:
  goto <D.24419>;
  <D.24420>:
  target_bb = inst->data.op[0].target_block;
  goto <D.24419>;
  <D.24421>:
  bb->not_useless = 1;
  D.25353 = 0;
  return D.25353;
  <D.24419>:
  inst = inst->next;
  <D.24423>:
  if (inst != 0B) goto <D.24422>; else goto <D.24424>;
  <D.24424>:
  if (target_bb == 0B) goto <D.25356>; else goto <D.25357>;
  <D.25356>:
  D.25360 = bb->out_count;
  if (D.25360 == 1) goto <D.25361>; else goto <D.25358>;
  <D.25361>:
  D.25362 = bb->out_bb;
  D.25363 = *D.25362;
  D.25364 = bb->next_bb;
  if (D.25363 == D.25364) goto <D.25365>; else goto <D.25358>;
  <D.25365>:
  target_bb = bb->next_bb;
  goto <D.25359>;
  <D.25358>:
  D.25353 = 0;
  return D.25353;
  <D.25359>:
  <D.25357>:
  D.25366 = previous_bb->last_ins;
  if (D.25366 != 0B) goto <D.25367>; else goto <D.25368>;
  <D.25367>:
  D.25366 = previous_bb->last_ins;
  D.25369 = D.25366->opcode;
  if (D.25369 == 370) goto <D.25370>; else goto <D.25371>;
  <D.25370>:
  D.25353 = 0;
  return D.25353;
  <D.25371>:
  <D.25368>:
  D.25372 = cfg->bb_entry;
  if (D.25372 == previous_bb) goto <D.25373>; else goto <D.25374>;
  <D.25373>:
  D.25364 = bb->next_bb;
  if (D.25364 != target_bb) goto <D.25375>; else goto <D.25376>;
  <D.25375>:
  D.25353 = 0;
  return D.25353;
  <D.25376>:
  <D.25374>:
  D.25377 = previous_bb->region;
  D.25378 = D.25377 & 240;
  if (D.25378 == 0) goto <D.25379>; else goto <D.25380>;
  <D.25379>:
  D.25353 = 0;
  return D.25353;
  <D.25380>:
  D.25381 = target_bb != 0B;
  D.25382 = target_bb != bb;
  D.25383 = D.25381 & D.25382;
  if (D.25383 != 0) goto <D.25384>; else goto <D.25385>;
  <D.25384>:
  {
    int i;

    D.25386 = cfg->verbose_level;
    if (D.25386 > 1) goto <D.25387>; else goto <D.25388>;
    <D.25387>:
    D.25389 = bb->block_num;
    printf ("remove_block_if_useless, removed BB%d\n", D.25389);
    <D.25388>:
    goto <D.24428>;
    <D.24427>:
    {
      struct MonoBasicBlock * in_bb;

      D.25390 = bb->in_bb;
      in_bb = *D.25390;
      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.24428>:
    D.25391 = bb->in_count;
    if (D.25391 != 0) goto <D.24427>; else goto <D.24429>;
    <D.24429>:
    mono_unlink_bblock (cfg, bb, target_bb);
    D.25372 = cfg->bb_entry;
    if (D.25372 != previous_bb) goto <D.25392>; else goto <D.25393>;
    <D.25392>:
    D.25394 = mono_bb_is_fall_through (cfg, previous_bb);
    if (D.25394 != 0) goto <D.25395>; else goto <D.25396>;
    <D.25395>:
    i = 0;
    goto <D.24433>;
    <D.24432>:
    D.25397 = previous_bb->out_bb;
    i.22 = (unsigned int) i;
    D.25399 = i.22 * 4;
    D.25400 = D.25397 + D.25399;
    D.25401 = *D.25400;
    if (D.25401 == target_bb) goto <D.25402>; else goto <D.25403>;
    <D.25402>:
    {
      struct MonoInst * jump;

      D.25404 = cfg->mempool;
      jump = mono_mempool_alloc0 (D.25404, 56);
      jump->opcode = 442;
      jump->dreg = -1;
      jump->sreg3 = -1;
      D.25405 = jump->sreg3;
      jump->sreg2 = D.25405;
      D.25406 = jump->sreg2;
      jump->sreg1 = D.25406;
      D.25407 = cfg->ip;
      jump->cil_code = D.25407;
      D.25366 = previous_bb->last_ins;
      if (D.25366 != 0B) goto <D.25408>; else goto <D.25409>;
      <D.25408>:
      D.25366 = previous_bb->last_ins;
      D.25366->next = jump;
      D.25366 = previous_bb->last_ins;
      jump->prev = D.25366;
      previous_bb->last_ins = jump;
      goto <D.25410>;
      <D.25409>:
      previous_bb->last_ins = jump;
      D.25366 = previous_bb->last_ins;
      previous_bb->code = D.25366;
      <D.25410>:
      D.25411 = previous_bb->cil_code;
      jump->cil_code = D.25411;
      jump->data.op[0].target_block = target_bb;
      goto <D.24431>;
    }
    <D.25403>:
    i = i + 1;
    <D.24433>:
    D.25412 = previous_bb->out_count;
    D.25413 = (int) D.25412;
    if (D.25413 > i) goto <D.24432>; else goto <D.24431>;
    <D.24431>:
    <D.25396>:
    <D.25393>:
    D.25364 = bb->next_bb;
    previous_bb->next_bb = D.25364;
    mono_nullify_basic_block (bb);
    D.25353 = 1;
    return D.25353;
  }
  <D.25385>:
  D.25353 = 0;
  return D.25353;
}


move_basic_block_to_end (struct MonoCompile * cfg, struct MonoBasicBlock * bb)
{
  struct MonoBasicBlock * D.25416;
  struct MonoBasicBlock * D.25420;
  struct MonoInst * D.25425;
  short unsigned int D.25427;
  _Bool D.25428;
  _Bool D.25429;
  _Bool D.25430;
  short unsigned int D.25432;
  short unsigned int D.25434;
  short unsigned int D.25435;
  _Bool D.25436;
  short unsigned int D.25437;
  _Bool D.25438;
  _Bool D.25439;
  short unsigned int D.25441;
  struct MonoMemPool * D.25442;
  int D.25443;
  int D.25444;
  const unsigned char * D.25445;
  struct MonoBasicBlock * bbn;
  struct MonoBasicBlock * next;

  next = bb->next_bb;
  bbn = cfg->bb_entry;
  goto <D.24469>;
  <D.24468>:
  bbn = bbn->next_bb;
  <D.24469>:
  D.25416 = bbn->next_bb;
  if (D.25416 != 0B) goto <D.25417>; else goto <D.24470>;
  <D.25417>:
  D.25416 = bbn->next_bb;
  if (D.25416 != bb) goto <D.24468>; else goto <D.24470>;
  <D.24470>:
  D.25416 = bbn->next_bb;
  if (D.25416 != 0B) goto <D.25418>; else goto <D.25419>;
  <D.25418>:
  D.25420 = bb->next_bb;
  bbn->next_bb = D.25420;
  <D.25419>:
  bbn = cfg->bb_entry;
  goto <D.24472>;
  <D.24471>:
  bbn = bbn->next_bb;
  <D.24472>:
  D.25416 = bbn->next_bb;
  if (D.25416 != 0B) goto <D.24471>; else goto <D.24473>;
  <D.24473>:
  bbn->next_bb = bb;
  bb->next_bb = 0B;
  if (next != 0B) goto <D.25423>; else goto <D.25424>;
  <D.25423>:
  D.25425 = bb->last_ins;
  if (D.25425 == 0B) goto <D.25421>; else goto <D.25426>;
  <D.25426>:
  D.25425 = bb->last_ins;
  D.25427 = D.25425->opcode;
  D.25428 = D.25427 != 798;
  D.25429 = D.25427 != 442;
  D.25430 = D.25428 & D.25429;
  if (D.25430 != 0) goto <D.25431>; else goto <D.25422>;
  <D.25431>:
  D.25425 = bb->last_ins;
  D.25432 = D.25425->opcode;
  if (D.25432 != 759) goto <D.25433>; else goto <D.25422>;
  <D.25433>:
  D.25425 = bb->last_ins;
  D.25434 = D.25425->opcode;
  D.25435 = D.25434 + 64985;
  D.25436 = D.25435 > 9;
  D.25437 = D.25434 + 64878;
  D.25438 = D.25437 > 9;
  D.25439 = D.25436 & D.25438;
  if (D.25439 != 0) goto <D.25440>; else goto <D.25422>;
  <D.25440>:
  D.25425 = bb->last_ins;
  D.25432 = D.25425->opcode;
  D.25441 = D.25432 + 64888;
  if (D.25441 > 9) goto <D.25421>; else goto <D.25422>;
  <D.25421>:
  {
    struct MonoInst * ins;

    D.25442 = cfg->mempool;
    ins = mono_mempool_alloc0 (D.25442, 56);
    ins->opcode = 442;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.25443 = ins->sreg3;
    ins->sreg2 = D.25443;
    D.25444 = ins->sreg2;
    ins->sreg1 = D.25444;
    D.25445 = cfg->ip;
    ins->cil_code = D.25445;
    D.25425 = bb->last_ins;
    if (D.25425 != 0B) goto <D.25446>; else goto <D.25447>;
    <D.25446>:
    D.25425 = bb->last_ins;
    D.25425->next = ins;
    D.25425 = bb->last_ins;
    ins->prev = D.25425;
    bb->last_ins = ins;
    goto <D.25448>;
    <D.25447>:
    bb->last_ins = ins;
    D.25425 = bb->last_ins;
    bb->code = D.25425;
    <D.25448>:
    mono_link_bblock (cfg, bb, next);
    ins->data.op[0].target_block = next;
  }
  <D.25422>:
  <D.25424>:
}