mono_branch_optimize_exception_target (struct MonoCompile * cfg, struct MonoBasicBlock * bb, const char * exname)
{
  unsigned int D.22546;
  unsigned int D.22547;
  struct MonoInst * D.22550;
  unsigned int D.22553;
  unsigned int D.22555;
  struct MonoImage * D.22556;
  struct MonoExceptionClause * D.22557;
  long unsigned int D.22558;
  long unsigned int D.22559;
  unsigned int D.22560;
  unsigned int D.22561;
  unsigned int D.22564;
  unsigned int D.22565;
  unsigned int D.22569;
  struct MonoClass * D.22571;
  int D.22573;
  struct MonoBasicBlock * * D.22575;
  unsigned int D.22576;
  long unsigned int D.22577;
  long unsigned int D.22578;
  struct MonoBasicBlock * * D.22579;
  unsigned int D.22582;
  unsigned int D.22583;
  struct MonoBasicBlock * D.22585;
  unsigned int D.22586;
  unsigned int D.22587;
  unsigned int D.22592;
  unsigned int D.22593;
  struct MonoMemPool * D.22596;
  int D.22597;
  int D.22598;
  const unsigned char * D.22599;
  void * D.22600;
  struct MonoBasicBlock * * D.22601;
  unsigned int D.22602;
  struct MonoMethod * D.22605;
  const char * D.22606;
  struct MonoClass * D.22607;
  const char * D.22608;
  const char * D.22609;
  int D.22610;
  <unnamed-unsigned:15> D.22611;
  int D.22612;
  struct MonoMethodHeader * header;
  struct MonoExceptionClause * clause;
  struct MonoClass * exclass;
  int i;

  header = cfg->header;
  D.22546 = cfg->opt;
  D.22547 = D.22546 & 1048576;
  if (D.22547 == 0) goto <D.22548>; else goto <D.22549>;
  <D.22548>:
  D.22550 = 0B;
  return D.22550;
  <D.22549>:
  D.22553 = bb->region;
  if (D.22553 == 4294967295) goto <D.22551>; else goto <D.22554>;
  <D.22554>:
  D.22553 = bb->region;
  D.22555 = D.22553 & 240;
  if (D.22555 != 0) goto <D.22551>; else goto <D.22552>;
  <D.22551>:
  D.22550 = 0B;
  return D.22550;
  <D.22552>:
  D.22556 = mono_get_corlib ();
  exclass = mono_class_from_name (D.22556, "System", exname);
  i = 0;
  goto <D.22238>;
  <D.22237>:
  D.22557 = header->clauses;
  D.22558 = (long unsigned int) i;
  D.22559 = D.22558 * 32;
  clause = D.22557 + D.22559;
  D.22560 = clause->try_offset;
  D.22561 = bb->real_offset;
  if (D.22560 <= D.22561) goto <D.22562>; else goto <D.22563>;
  <D.22562>:
  D.22561 = bb->real_offset;
  D.22560 = clause->try_offset;
  D.22564 = clause->try_len;
  D.22565 = D.22560 + D.22564;
  if (D.22561 < D.22565) goto <D.22566>; else goto <D.22567>;
  <D.22566>:
  D.22569 = clause->flags;
  if (D.22569 == 0) goto <D.22570>; else goto <D.22568>;
  <D.22570>:
  D.22571 = clause->data.catch_class;
  if (D.22571 != 0B) goto <D.22572>; else goto <D.22568>;
  <D.22572>:
  D.22571 = clause->data.catch_class;
  D.22573 = mono_class_is_assignable_from (D.22571, exclass);
  if (D.22573 != 0) goto <D.22574>; else goto <D.22568>;
  <D.22574>:
  {
    struct MonoBasicBlock * tbb;

    D.22575 = cfg->cil_offset_to_bb;
    D.22576 = clause->handler_offset;
    D.22577 = (long unsigned int) D.22576;
    D.22578 = D.22577 * 8;
    D.22579 = D.22575 + D.22578;
    tbb = *D.22579;
    if (tbb != 0B) goto <D.22581>; else goto <D.22580>;
    <D.22581>:
    D.22582 = BIT_FIELD_REF <*tbb, 32, 704>;
    D.22583 = D.22582 & 12;
    if (D.22583 == 4) goto <D.22584>; else goto <D.22580>;
    <D.22584>:
    {
      struct MonoBasicBlock * targetbb;
      gboolean unsafe;

      targetbb = tbb;
      unsafe = 0;
      goto <D.22235>;
      <D.22234>:
      D.22585 = tbb->next_bb;
      D.22586 = D.22585->flags;
      D.22587 = D.22586 & 8;
      if (D.22587 != 0) goto <D.22588>; else goto <D.22589>;
      <D.22588>:
      unsafe = 1;
      goto <D.22233>;
      <D.22589>:
      tbb = tbb->next_bb;
      <D.22235>:
      if (unsafe == 0) goto <D.22590>; else goto <D.22233>;
      <D.22590>:
      D.22585 = tbb->next_bb;
      if (D.22585 != 0B) goto <D.22591>; else goto <D.22233>;
      <D.22591>:
      D.22592 = tbb->region;
      D.22585 = tbb->next_bb;
      D.22593 = D.22585->region;
      if (D.22592 == D.22593) goto <D.22234>; else goto <D.22233>;
      <D.22233>:
      if (unsafe == 0) goto <D.22594>; else goto <D.22595>;
      <D.22594>:
      {
        struct MonoInst * jump;

        D.22596 = cfg->mempool;
        jump = mono_mempool_alloc0 (D.22596, 80);
        jump->opcode = 446;
        jump->dreg = -1;
        jump->sreg3 = -1;
        D.22597 = jump->sreg3;
        jump->sreg2 = D.22597;
        D.22598 = jump->sreg2;
        jump->sreg1 = D.22598;
        D.22599 = cfg->ip;
        jump->cil_code = D.22599;
        D.22596 = cfg->mempool;
        D.22600 = mono_mempool_alloc0 (D.22596, 80);
        jump->data.op[1].src = D.22600;
        D.22601 = jump->data.op[1].many_blocks;
        *D.22601 = targetbb;
        D.22602 = cfg->verbose_level;
        if (D.22602 > 2) goto <D.22603>; else goto <D.22604>;
        <D.22603>:
        D.22605 = cfg->method;
        D.22606 = D.22605->name;
        D.22605 = cfg->method;
        D.22607 = D.22605->klass;
        D.22608 = D.22607->name;
        D.22571 = clause->data.catch_class;
        D.22609 = D.22571->name;
        D.22610 = targetbb->block_num;
        monoeg_g_print ("found exception to optimize - returning branch to BB%d (%s) (instead of throw) for method %s:%s\n", D.22610, D.22609, D.22608, D.22606);
        <D.22604>:
        D.22550 = jump;
        return D.22550;
      }
      <D.22595>:
      D.22550 = 0B;
      return D.22550;
    }
    <D.22580>:
    D.22550 = 0B;
    return D.22550;
  }
  <D.22568>:
  D.22550 = 0B;
  return D.22550;
  <D.22567>:
  <D.22563>:
  i = i + 1;
  <D.22238>:
  D.22611 = header->num_clauses;
  D.22612 = (int) D.22611;
  if (D.22612 > i) goto <D.22237>; else goto <D.22239>;
  <D.22239>:
  D.22550 = 0B;
  return D.22550;
}


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.22616;
  struct MonoInst * D.22619;
  struct MonoBasicBlock * * D.22622;
  struct MonoBasicBlock * D.22623;
  short int D.22624;
  struct MonoInst * D.22625;
  struct MonoInst * D.22628;
  struct MonoInst * D.22630;
  <unnamed-unsigned:1> D.22634;
  unsigned char D.22635;
  <unnamed-unsigned:1> D.22636;
  unsigned char D.22637;
  unsigned char D.22638;
  <unnamed-unsigned:1> D.22639;
  unsigned int D.22641;
  struct MonoInst * D.22642;
  <unnamed-unsigned:1> D.22650;
  unsigned char D.22651;
  unsigned char D.22652;
  <unnamed-unsigned:1> D.22653;
  struct MonoInst * D.22656;
  struct MonoBasicBlock * * D.22657;
  long unsigned int D.22658;
  long unsigned int D.22659;
  struct MonoBasicBlock * * D.22660;
  struct MonoBasicBlock * D.22661;
  short int D.22662;
  int D.22663;
  struct MonoInst * D.22667;
  struct MonoBasicBlock * * D.22668;
  struct MonoBasicBlock * D.22669;
  struct MonoBasicBlock * * D.22670;
  int D.22671;
  struct MonoBasicBlock * D.22672;
  struct MonoBasicBlock * D.22673;
  struct MonoInst * next;

  next = ins->next;
  if (next != 0B) goto <D.22614>; else goto <D.22615>;
  <D.22614>:
  D.22616 = next->opcode;
  if (D.22616 == 316) goto <D.22617>; else goto <D.22618>;
  <D.22617>:
  D.22619 = next->next;
  ins->next = D.22619;
  next = next->next;
  <D.22618>:
  <D.22615>:
  if (first_bb == last_bb) goto <D.22620>; else goto <D.22621>;
  <D.22620>:
  goto <D.22260>;
  <D.22259>:
  D.22622 = first_bb->out_bb;
  D.22623 = *D.22622;
  mono_unlink_bblock (cfg, first_bb, D.22623);
  <D.22260>:
  D.22624 = first_bb->out_count;
  if (D.22624 != 0) goto <D.22259>; else goto <D.22261>;
  <D.22261>:
  D.22625 = *prev;
  if (D.22625 != 0B) goto <D.22626>; else goto <D.22627>;
  <D.22626>:
  D.22625 = *prev;
  D.22628 = first_bb->code;
  D.22625->next = D.22628;
  D.22628 = first_bb->code;
  D.22625 = *prev;
  D.22628->prev = D.22625;
  goto <D.22629>;
  <D.22627>:
  D.22628 = first_bb->code;
  bb->code = D.22628;
  <D.22629>:
  D.22630 = last_bb->last_ins;
  D.22630->next = next;
  if (next != 0B) goto <D.22631>; else goto <D.22632>;
  <D.22631>:
  D.22630 = last_bb->last_ins;
  next->prev = D.22630;
  goto <D.22633>;
  <D.22632>:
  D.22630 = last_bb->last_ins;
  bb->last_ins = D.22630;
  <D.22633>:
  D.22630 = last_bb->last_ins;
  *prev = D.22630;
  D.22634 = bb->has_array_access;
  D.22635 = (unsigned char) D.22634;
  D.22636 = first_bb->has_array_access;
  D.22637 = (unsigned char) D.22636;
  D.22638 = D.22635 | D.22637;
  D.22639 = (<unnamed-unsigned:1>) D.22638;
  bb->has_array_access = D.22639;
  goto <D.22640>;
  <D.22621>:
  {
    int i;
    int count;
    struct MonoBasicBlock * * tmp_bblocks;
    struct MonoBasicBlock * tmp;
    struct MonoInst * last;

    tmp = first_bb;
    goto <D.22268>;
    <D.22267>:
    D.22641 = bb->region;
    tmp->region = D.22641;
    tmp = tmp->next_bb;
    <D.22268>:
    if (tmp != 0B) goto <D.22267>; else goto <D.22269>;
    <D.22269>:
    D.22642 = ins->next;
    if (D.22642 != 0B) goto <D.22643>; else goto <D.22644>;
    <D.22643>:
    D.22642 = ins->next;
    D.22642->prev = 0B;
    <D.22644>:
    ins->next = 0B;
    bb->last_ins = ins;
    D.22630 = last_bb->last_ins;
    if (D.22630 != 0B) goto <D.22645>; else goto <D.22646>;
    <D.22645>:
    D.22630 = last_bb->last_ins;
    D.22630->next = next;
    if (next != 0B) goto <D.22647>; else goto <D.22648>;
    <D.22647>:
    D.22630 = last_bb->last_ins;
    next->prev = D.22630;
    <D.22648>:
    goto <D.22649>;
    <D.22646>:
    last_bb->code = next;
    <D.22649>:
    D.22650 = last_bb->has_array_access;
    D.22651 = (unsigned char) D.22650;
    D.22634 = bb->has_array_access;
    D.22635 = (unsigned char) D.22634;
    D.22652 = D.22651 | D.22635;
    D.22653 = (<unnamed-unsigned:1>) D.22652;
    last_bb->has_array_access = D.22653;
    if (next != 0B) goto <D.22654>; else goto <D.22655>;
    <D.22654>:
    last = next;
    goto <D.22271>;
    <D.22270>:
    last = last->next;
    <D.22271>:
    D.22656 = last->next;
    if (D.22656 != 0B) goto <D.22270>; else goto <D.22272>;
    <D.22272>:
    last_bb->last_ins = last;
    <D.22655>:
    i = 0;
    goto <D.22274>;
    <D.22273>:
    D.22657 = bb->out_bb;
    D.22658 = (long unsigned int) i;
    D.22659 = D.22658 * 8;
    D.22660 = D.22657 + D.22659;
    D.22661 = *D.22660;
    mono_link_bblock (cfg, last_bb, D.22661);
    i = i + 1;
    <D.22274>:
    D.22662 = bb->out_count;
    D.22663 = (int) D.22662;
    if (D.22663 > i) goto <D.22273>; else goto <D.22275>;
    <D.22275>:
    D.22625 = *prev;
    if (D.22625 != 0B) goto <D.22664>; else goto <D.22665>;
    <D.22664>:
    D.22625 = *prev;
    D.22628 = first_bb->code;
    D.22625->next = D.22628;
    D.22628 = first_bb->code;
    D.22625 = *prev;
    D.22628->prev = D.22625;
    goto <D.22666>;
    <D.22665>:
    D.22628 = first_bb->code;
    bb->code = D.22628;
    <D.22666>:
    D.22667 = first_bb->last_ins;
    bb->last_ins = D.22667;
    D.22634 = bb->has_array_access;
    D.22635 = (unsigned char) D.22634;
    D.22636 = first_bb->has_array_access;
    D.22637 = (unsigned char) D.22636;
    D.22638 = D.22635 | D.22637;
    D.22639 = (<unnamed-unsigned:1>) D.22638;
    bb->has_array_access = D.22639;
    tmp_bblocks = bb->out_bb;
    D.22662 = bb->out_count;
    count = (int) D.22662;
    i = 0;
    goto <D.22277>;
    <D.22276>:
    D.22658 = (long unsigned int) i;
    D.22659 = D.22658 * 8;
    D.22668 = tmp_bblocks + D.22659;
    D.22669 = *D.22668;
    mono_unlink_bblock (cfg, bb, D.22669);
    i = i + 1;
    <D.22277>:
    if (i < count) goto <D.22276>; else goto <D.22278>;
    <D.22278>:
    i = 0;
    goto <D.22281>;
    <D.22280>:
    {
      struct MonoBasicBlock * out_bb;

      D.22622 = first_bb->out_bb;
      D.22658 = (long unsigned int) i;
      D.22659 = D.22658 * 8;
      D.22670 = D.22622 + D.22659;
      out_bb = *D.22670;
      mono_link_bblock (cfg, bb, out_bb);
    }
    i = i + 1;
    <D.22281>:
    D.22624 = first_bb->out_count;
    D.22671 = (int) D.22624;
    if (D.22671 > i) goto <D.22280>; else goto <D.22282>;
    <D.22282>:
    i = 0;
    goto <D.22285>;
    <D.22284>:
    {
      struct MonoBasicBlock * out_bb;

      D.22657 = bb->out_bb;
      D.22658 = (long unsigned int) i;
      D.22659 = D.22658 * 8;
      D.22660 = D.22657 + D.22659;
      out_bb = *D.22660;
      mono_unlink_bblock (cfg, first_bb, out_bb);
    }
    i = i + 1;
    <D.22285>:
    D.22662 = bb->out_count;
    D.22663 = (int) D.22662;
    if (D.22663 > i) goto <D.22284>; else goto <D.22286>;
    <D.22286>:
    D.22672 = bb->next_bb;
    last_bb->next_bb = D.22672;
    D.22673 = first_bb->next_bb;
    bb->next_bb = D.22673;
    *prev = 0B;
  }
  <D.22640>:
}


mono_if_conversion (struct MonoCompile * cfg)
{
  unsigned int D.22674;
  unsigned int D.22675;
  short int D.22680;
  unsigned char D.22682;
  unsigned char D.22683;
  struct MonoBasicBlock * * D.22684;
  short int D.22685;
  short int D.22688;
  short int D.22691;
  short int D.22694;
  struct MonoBasicBlock * * D.22697;
  struct MonoBasicBlock * D.22698;
  struct MonoBasicBlock * * D.22699;
  struct MonoBasicBlock * D.22700;
  struct MonoInst * D.22703;
  short unsigned int D.22706;
  _Bool D.22707;
  _Bool D.22708;
  _Bool D.22709;
  struct MonoInst * D.22715;
  short unsigned int D.22716;
  short unsigned int D.22717;
  _Bool D.22718;
  short unsigned int D.22719;
  _Bool D.22720;
  _Bool D.22721;
  short unsigned int D.22724;
  short unsigned int D.22725;
  struct MonoBasicBlock * * D.22728;
  short unsigned int D.22730;
  short unsigned int D.22732;
  _Bool D.22735;
  _Bool D.22736;
  _Bool D.22737;
  int D.22739;
  int D.22740;
  short unsigned int D.22742;
  _Bool D.22743;
  _Bool D.22744;
  _Bool D.22745;
  short unsigned int D.22748;
  _Bool D.22749;
  _Bool D.22750;
  _Bool D.22751;
  short unsigned int D.22759;
  _Bool D.22760;
  _Bool D.22761;
  _Bool D.22762;
  short unsigned int D.22768;
  _Bool D.22769;
  _Bool D.22770;
  _Bool D.22771;
  short unsigned int D.22796;
  _Bool D.22797;
  _Bool D.22798;
  _Bool D.22799;
  short unsigned int D.22805;
  _Bool D.22806;
  _Bool D.22807;
  _Bool D.22808;
  int D.22835;
  int D.22837;
  short unsigned int D.22838;
  int D.22839;
  int D.22840;
  int D.22843;
  int D.22844;
  int D.22845;
  char D.22846;
  unsigned int D.22849;
  int D.22852;
  struct MonoInst * D.22853;
  struct MonoInst * D.22854;
  int D.22857;
  _Bool D.22858;
  unsigned int D.22860;
  unsigned int D.22863;
  struct MonoInst * D.22864;
  struct MonoInst * D.22867;
  struct MonoInst * D.22870;
  struct MonoInst * D.22873;
  struct MonoInst * D.22876;
  struct MonoInst * D.22879;
  struct MonoInst * D.22882;
  struct MonoInst * D.22885;
  struct MonoMemPool * D.22888;
  int D.22889;
  int D.22890;
  const unsigned char * D.22891;
  <unnamed type> D.22892;
  <unnamed type> D.22893;
  int D.22894;
  short unsigned int D.22895;
  <unnamed type> D.22896;
  int D.22897;
  short unsigned int D.22898;
  int D.22901;
  int D.22902;
  struct MonoBasicBlock * * D.22903;
  struct MonoBasicBlock * D.22904;
  struct MonoBasicBlock * D.22905;
  struct MonoBasicBlock * * D.22906;
  struct MonoBasicBlock * D.22907;
  struct MonoBasicBlock * D.22908;
  short int D.22909;
  struct MonoBasicBlock * D.22912;
  unsigned int D.22915;
  unsigned int D.22916;
  signed int D.22922;
  unsigned int D.22923;
  unsigned int D.22924;
  signed int D.22926;
  unsigned int D.22927;
  unsigned int D.22928;
  short unsigned int D.22936;
  _Bool D.22937;
  _Bool D.22938;
  _Bool D.22939;
  short unsigned int D.22944;
  _Bool D.22945;
  _Bool D.22946;
  _Bool D.22947;
  short unsigned int D.22950;
  short unsigned int D.22959;
  _Bool D.22960;
  _Bool D.22961;
  _Bool D.22962;
  short unsigned int D.23015;
  short unsigned int D.23021;
  short unsigned int D.23022;
  _Bool D.23023;
  short unsigned int D.23024;
  _Bool D.23025;
  _Bool D.23026;
  short unsigned int D.23029;
  short unsigned int D.23030;
  short unsigned int D.23033;
  int D.23034;
  int D.23035;
  int D.23038;
  int D.23039;
  int D.23040;
  char D.23041;
  int D.23046;
  unsigned int D.23049;
  struct MonoInst * D.23054;
  unsigned int D.23055;
  struct MonoInst * D.23056;
  struct MonoInst * D.23059;
  struct MonoInst * D.23062;
  struct MonoInst * D.23065;
  int D.23068;
  int D.23069;
  struct MonoBasicBlock * * D.23070;
  struct MonoBasicBlock * * D.23071;
  struct MonoBasicBlock * D.23072;
  <unnamed type> D.23075;
  int D.23076;
  short unsigned int D.23077;
  int D.23078;
  short unsigned int D.23079;
  struct MonoBasicBlock * D.23080;
  struct MonoInst * D.23083;
  struct MonoInst * D.23086;
  int D.23093;
  int D.23094;
  short unsigned int D.23104;
  short unsigned int D.23105;
  _Bool D.23106;
  short unsigned int D.23107;
  _Bool D.23108;
  _Bool D.23109;
  short unsigned int D.23111;
  int D.23117;
  int D.23118;
  short int D.23127;
  struct MonoBasicBlock * * D.23129;
  struct MonoBasicBlock * D.23130;
  struct MonoBasicBlock * * D.23132;
  struct MonoBasicBlock * D.23133;
  signed int D.23135;
  unsigned int D.23136;
  unsigned int D.23137;
  short unsigned int D.23141;
  _Bool D.23142;
  _Bool D.23143;
  _Bool D.23144;
  struct MonoBasicBlock * * D.23146;
  struct MonoBasicBlock * * D.23147;
  struct MonoBasicBlock * D.23148;
  short unsigned int D.23153;
  _Bool D.23154;
  _Bool D.23155;
  _Bool D.23156;
  struct MonoBasicBlock * * D.23158;
  struct MonoBasicBlock * D.23159;
  struct MonoBasicBlock * D.23160;
  short unsigned int D.23164;
  _Bool D.23165;
  _Bool D.23166;
  _Bool D.23167;
  struct MonoBasicBlock * * D.23169;
  struct MonoBasicBlock * D.23170;
  short unsigned int D.23175;
  short unsigned int D.23176;
  long int D.23178;
  short unsigned int D.23183;
  short unsigned int D.23184;
  int D.23186;
  int D.23187;
  struct MonoInst * D.23189;
  long int D.23191;
  short unsigned int D.23196;
  _Bool D.23197;
  _Bool D.23198;
  _Bool D.23199;
  int D.23201;
  short unsigned int D.23204;
  int D.23206;
  int D.23208;
  struct MonoInst * D.23210;
  struct MonoInst * D.23214;
  struct MonoInst * D.23215;
  struct MonoInst * D.23220;
  int D.23225;
  int D.23226;
  short unsigned int D.23227;
  int D.23228;
  int D.23229;
  short unsigned int D.23230;
  unsigned int D.23233;
  unsigned int D.23236;
  struct MonoBasicBlock * bb;
  gboolean changed;
  void restart = <<< error >>>;

  changed = 0;
  D.22674 = cfg->opt;
  D.22675 = D.22674 & 256;
  if (D.22675 == 0) goto <D.22676>; else goto <D.22677>;
  <D.22676>:
  return;
  <D.22677>:
  bb = cfg->bb_entry;
  goto <D.22346>;
  <D.22345>:
  {
    struct MonoBasicBlock * bb1;
    struct MonoBasicBlock * bb2;

    restart:
    D.22680 = bb->out_count;
    if (D.22680 != 2) goto <D.22678>; else goto <D.22681>;
    <D.22681>:
    D.22682 = BIT_FIELD_REF <*bb, 8, 1488>;
    D.22683 = D.22682 & 8;
    if (D.22683 != 0) goto <D.22678>; else goto <D.22679>;
    <D.22678>:
    // predicted unlikely by continue predictor.
    goto <D.22295>;
    <D.22679>:
    D.22684 = bb->out_bb;
    bb1 = *D.22684;
    D.22684 = bb->out_bb;
    bb2 = MEM[(struct MonoBasicBlock * *)D.22684 + 8B];
    D.22685 = bb1->in_count;
    if (D.22685 == 1) goto <D.22686>; else goto <D.22687>;
    <D.22686>:
    D.22688 = bb2->in_count;
    if (D.22688 == 1) goto <D.22689>; else goto <D.22690>;
    <D.22689>:
    D.22691 = bb1->out_count;
    if (D.22691 == 1) goto <D.22692>; else goto <D.22693>;
    <D.22692>:
    D.22694 = bb2->out_count;
    if (D.22694 == 1) goto <D.22695>; else goto <D.22696>;
    <D.22695>:
    D.22697 = bb1->out_bb;
    D.22698 = *D.22697;
    D.22699 = bb2->out_bb;
    D.22700 = *D.22699;
    if (D.22698 == D.22700) goto <D.22701>; else goto <D.22702>;
    <D.22701>:
    {
      struct MonoInst * compare;
      struct MonoInst * branch;
      struct MonoInst * ins1;
      struct MonoInst * ins2;
      struct MonoInst * cmov;
      struct MonoInst * move;
      struct MonoInst * tmp;
      struct MonoBasicBlock * true_bb;
      struct MonoBasicBlock * false_bb;
      gboolean simple;
      gboolean ret;
      int dreg;
      int tmp_reg;
      CompType comp_type;

      D.22703 = bb->last_ins;
      if (D.22703 != 0B) goto <D.22704>; else goto <D.22705>;
      <D.22704>:
      D.22703 = bb->last_ins;
      D.22706 = D.22703->opcode;
      D.22707 = D.22706 == 763;
      D.22708 = D.22706 == 446;
      D.22709 = D.22707 | D.22708;
      if (D.22709 != 0) goto <D.22710>; else goto <D.22711>;
      <D.22710>:
      // predicted unlikely by continue predictor.
      goto <D.22295>;
      <D.22711>:
      <D.22705>:
      D.22703 = bb->last_ins;
      if (D.22703 == 0B) goto <D.22712>; else goto <D.22714>;
      <D.22714>:
      D.22703 = bb->last_ins;
      D.22715 = D.22703->prev;
      if (D.22715 == 0B) goto <D.22712>; else goto <D.22713>;
      <D.22712>:
      // predicted unlikely by continue predictor.
      goto <D.22295>;
      <D.22713>:
      branch = bb->last_ins;
      compare = branch->prev;
      D.22716 = branch->opcode;
      D.22717 = D.22716 + 64981;
      D.22718 = D.22717 > 9;
      D.22719 = D.22716 + 64874;
      D.22720 = D.22719 > 9;
      D.22721 = D.22718 & D.22720;
      if (D.22721 != 0) goto <D.22722>; else goto <D.22723>;
      <D.22722>:
      D.22724 = branch->opcode;
      D.22725 = D.22724 + 64884;
      if (D.22725 > 9) goto <D.22726>; else goto <D.22727>;
      <D.22726>:
      // predicted unlikely by continue predictor.
      goto <D.22295>;
      <D.22727>:
      <D.22723>:
      D.22728 = branch->data.op[1].many_blocks;
      true_bb = *D.22728;
      D.22728 = branch->data.op[1].many_blocks;
      false_bb = MEM[(struct MonoBasicBlock * *)D.22728 + 8B];
      ins1 = true_bb->code;
      goto <D.22311>;
      <D.22310>:
      ins1 = ins1->next;
      <D.22311>:
      if (ins1 != 0B) goto <D.22729>; else goto <D.22312>;
      <D.22729>:
      D.22730 = ins1->opcode;
      if (D.22730 == 316) goto <D.22310>; else goto <D.22312>;
      <D.22312>:
      ins2 = false_bb->code;
      goto <D.22314>;
      <D.22313>:
      ins2 = ins2->next;
      <D.22314>:
      if (ins2 != 0B) goto <D.22731>; else goto <D.22315>;
      <D.22731>:
      D.22732 = ins2->opcode;
      if (D.22732 == 316) goto <D.22313>; else goto <D.22315>;
      <D.22315>:
      D.22735 = ins1 == 0B;
      D.22736 = ins2 == 0B;
      D.22737 = D.22735 | D.22736;
      if (D.22737 != 0) goto <D.22733>; else goto <D.22738>;
      <D.22738>:
      D.22739 = ins1->dreg;
      D.22740 = ins2->dreg;
      if (D.22739 != D.22740) goto <D.22733>; else goto <D.22741>;
      <D.22741>:
      D.22739 = ins1->dreg;
      if (D.22739 == -1) goto <D.22733>; else goto <D.22734>;
      <D.22733>:
      // predicted unlikely by continue predictor.
      goto <D.22295>;
      <D.22734>:
      simple = 1;
      tmp = ins1->next;
      goto <D.22317>;
      <D.22316>:
      D.22742 = tmp->opcode;
      D.22743 = D.22742 != 316;
      D.22744 = D.22742 != 446;
      D.22745 = D.22743 & D.22744;
      if (D.22745 != 0) goto <D.22746>; else goto <D.22747>;
      <D.22746>:
      simple = 0;
      <D.22747>:
      tmp = tmp->next;
      <D.22317>:
      if (tmp != 0B) goto <D.22316>; else goto <D.22318>;
      <D.22318>:
      tmp = ins2->next;
      goto <D.22320>;
      <D.22319>:
      D.22748 = tmp->opcode;
      D.22749 = D.22748 != 316;
      D.22750 = D.22748 != 446;
      D.22751 = D.22749 & D.22750;
      if (D.22751 != 0) goto <D.22752>; else goto <D.22753>;
      <D.22752>:
      simple = 0;
      <D.22753>:
      tmp = tmp->next;
      <D.22320>:
      if (tmp != 0B) goto <D.22319>; else goto <D.22321>;
      <D.22321>:
      if (simple == 0) goto <D.22754>; else goto <D.22755>;
      <D.22754>:
      // predicted unlikely by continue predictor.
      goto <D.22295>;
      <D.22755>:
      D.22759 = ins1->opcode;
      D.22760 = D.22759 != 428;
      D.22761 = D.22759 != 430;
      D.22762 = D.22760 & D.22761;
      if (D.22762 != 0) goto <D.22763>; else goto <D.22756>;
      <D.22763>:
      D.22730 = ins1->opcode;
      if (D.22730 != 431) goto <D.22764>; else goto <D.22756>;
      <D.22764>:
      D.22730 = ins1->opcode;
      if (D.22730 != 962) goto <D.22765>; else goto <D.22756>;
      <D.22765>:
      D.22730 = ins1->opcode;
      if (D.22730 != 362) goto <D.22766>; else goto <D.22756>;
      <D.22766>:
      D.22730 = ins1->opcode;
      if (D.22730 != 363) goto <D.22767>; else goto <D.22756>;
      <D.22767>:
      D.22768 = ins1->opcode;
      D.22769 = D.22768 != 432;
      D.22770 = D.22768 != 963;
      D.22771 = D.22769 & D.22770;
      if (D.22771 != 0) goto <D.22772>; else goto <D.22756>;
      <D.22772>:
      D.22730 = ins1->opcode;
      if (D.22730 != 433) goto <D.22773>; else goto <D.22756>;
      <D.22773>:
      D.22730 = ins1->opcode;
      if (D.22730 != 365) goto <D.22774>; else goto <D.22756>;
      <D.22774>:
      D.22730 = ins1->opcode;
      if (D.22730 != 542) goto <D.22775>; else goto <D.22756>;
      <D.22775>:
      D.22730 = ins1->opcode;
      if (D.22730 != 630) goto <D.22776>; else goto <D.22756>;
      <D.22776>:
      D.22730 = ins1->opcode;
      if (D.22730 != 629) goto <D.22777>; else goto <D.22756>;
      <D.22777>:
      D.22730 = ins1->opcode;
      if (D.22730 != 496) goto <D.22778>; else goto <D.22756>;
      <D.22778>:
      D.22730 = ins1->opcode;
      if (D.22730 != 570) goto <D.22779>; else goto <D.22756>;
      <D.22779>:
      D.22730 = ins1->opcode;
      if (D.22730 != 979) goto <D.22780>; else goto <D.22756>;
      <D.22780>:
      D.22730 = ins1->opcode;
      if (D.22730 != 639) goto <D.22781>; else goto <D.22756>;
      <D.22781>:
      D.22730 = ins1->opcode;
      if (D.22730 != 640) goto <D.22782>; else goto <D.22756>;
      <D.22782>:
      D.22730 = ins1->opcode;
      if (D.22730 != 641) goto <D.22783>; else goto <D.22756>;
      <D.22783>:
      D.22730 = ins1->opcode;
      if (D.22730 != 636) goto <D.22784>; else goto <D.22756>;
      <D.22784>:
      D.22730 = ins1->opcode;
      if (D.22730 != 595) goto <D.22785>; else goto <D.22756>;
      <D.22785>:
      D.22730 = ins1->opcode;
      if (D.22730 != 584) goto <D.22786>; else goto <D.22756>;
      <D.22786>:
      D.22730 = ins1->opcode;
      if (D.22730 != 766) goto <D.22787>; else goto <D.22756>;
      <D.22787>:
      D.22730 = ins1->opcode;
      if (D.22730 != 507) goto <D.22788>; else goto <D.22756>;
      <D.22788>:
      D.22730 = ins1->opcode;
      if (D.22730 != 594) goto <D.22789>; else goto <D.22756>;
      <D.22789>:
      D.22730 = ins1->opcode;
      if (D.22730 != 585) goto <D.22790>; else goto <D.22756>;
      <D.22790>:
      D.22730 = ins1->opcode;
      if (D.22730 != 499) goto <D.22791>; else goto <D.22756>;
      <D.22791>:
      D.22730 = ins1->opcode;
      if (D.22730 != 314) goto <D.22792>; else goto <D.22756>;
      <D.22792>:
      D.22730 = ins1->opcode;
      if (D.22730 != 319) goto <D.22793>; else goto <D.22756>;
      <D.22793>:
      D.22730 = ins1->opcode;
      if (D.22730 != 316) goto <D.22794>; else goto <D.22756>;
      <D.22794>:
      D.22730 = ins1->opcode;
      if (D.22730 != 769) goto <D.22795>; else goto <D.22756>;
      <D.22795>:
      D.22730 = ins1->opcode;
      if (D.22730 != 803) goto <D.22757>; else goto <D.22756>;
      <D.22756>:
      D.22796 = ins2->opcode;
      D.22797 = D.22796 != 428;
      D.22798 = D.22796 != 430;
      D.22799 = D.22797 & D.22798;
      if (D.22799 != 0) goto <D.22800>; else goto <D.22758>;
      <D.22800>:
      D.22732 = ins2->opcode;
      if (D.22732 != 431) goto <D.22801>; else goto <D.22758>;
      <D.22801>:
      D.22732 = ins2->opcode;
      if (D.22732 != 962) goto <D.22802>; else goto <D.22758>;
      <D.22802>:
      D.22732 = ins2->opcode;
      if (D.22732 != 362) goto <D.22803>; else goto <D.22758>;
      <D.22803>:
      D.22732 = ins2->opcode;
      if (D.22732 != 363) goto <D.22804>; else goto <D.22758>;
      <D.22804>:
      D.22805 = ins2->opcode;
      D.22806 = D.22805 != 432;
      D.22807 = D.22805 != 963;
      D.22808 = D.22806 & D.22807;
      if (D.22808 != 0) goto <D.22809>; else goto <D.22758>;
      <D.22809>:
      D.22732 = ins2->opcode;
      if (D.22732 != 433) goto <D.22810>; else goto <D.22758>;
      <D.22810>:
      D.22732 = ins2->opcode;
      if (D.22732 != 365) goto <D.22811>; else goto <D.22758>;
      <D.22811>:
      D.22732 = ins2->opcode;
      if (D.22732 != 542) goto <D.22812>; else goto <D.22758>;
      <D.22812>:
      D.22732 = ins2->opcode;
      if (D.22732 != 630) goto <D.22813>; else goto <D.22758>;
      <D.22813>:
      D.22732 = ins2->opcode;
      if (D.22732 != 629) goto <D.22814>; else goto <D.22758>;
      <D.22814>:
      D.22732 = ins2->opcode;
      if (D.22732 != 496) goto <D.22815>; else goto <D.22758>;
      <D.22815>:
      D.22732 = ins2->opcode;
      if (D.22732 != 570) goto <D.22816>; else goto <D.22758>;
      <D.22816>:
      D.22732 = ins2->opcode;
      if (D.22732 != 979) goto <D.22817>; else goto <D.22758>;
      <D.22817>:
      D.22732 = ins2->opcode;
      if (D.22732 != 639) goto <D.22818>; else goto <D.22758>;
      <D.22818>:
      D.22732 = ins2->opcode;
      if (D.22732 != 640) goto <D.22819>; else goto <D.22758>;
      <D.22819>:
      D.22732 = ins2->opcode;
      if (D.22732 != 641) goto <D.22820>; else goto <D.22758>;
      <D.22820>:
      D.22732 = ins2->opcode;
      if (D.22732 != 636) goto <D.22821>; else goto <D.22758>;
      <D.22821>:
      D.22732 = ins2->opcode;
      if (D.22732 != 595) goto <D.22822>; else goto <D.22758>;
      <D.22822>:
      D.22732 = ins2->opcode;
      if (D.22732 != 584) goto <D.22823>; else goto <D.22758>;
      <D.22823>:
      D.22732 = ins2->opcode;
      if (D.22732 != 766) goto <D.22824>; else goto <D.22758>;
      <D.22824>:
      D.22732 = ins2->opcode;
      if (D.22732 != 507) goto <D.22825>; else goto <D.22758>;
      <D.22825>:
      D.22732 = ins2->opcode;
      if (D.22732 != 594) goto <D.22826>; else goto <D.22758>;
      <D.22826>:
      D.22732 = ins2->opcode;
      if (D.22732 != 585) goto <D.22827>; else goto <D.22758>;
      <D.22827>:
      D.22732 = ins2->opcode;
      if (D.22732 != 499) goto <D.22828>; else goto <D.22758>;
      <D.22828>:
      D.22732 = ins2->opcode;
      if (D.22732 != 314) goto <D.22829>; else goto <D.22758>;
      <D.22829>:
      D.22732 = ins2->opcode;
      if (D.22732 != 319) goto <D.22830>; else goto <D.22758>;
      <D.22830>:
      D.22732 = ins2->opcode;
      if (D.22732 != 316) goto <D.22831>; else goto <D.22758>;
      <D.22831>:
      D.22732 = ins2->opcode;
      if (D.22732 != 769) goto <D.22832>; else goto <D.22758>;
      <D.22832>:
      D.22732 = ins2->opcode;
      if (D.22732 != 803) goto <D.22757>; else goto <D.22758>;
      <D.22757>:
      // predicted unlikely by continue predictor.
      goto <D.22295>;
      <D.22758>:
      D.22835 = compare->sreg1;
      D.22739 = ins1->dreg;
      if (D.22835 == D.22739) goto <D.22833>; else goto <D.22836>;
      <D.22836>:
      D.22837 = compare->sreg2;
      D.22739 = ins1->dreg;
      if (D.22837 == D.22739) goto <D.22833>; else goto <D.22834>;
      <D.22833>:
      // predicted unlikely by continue predictor.
      goto <D.22295>;
      <D.22834>:
      D.22838 = compare->opcode;
      D.22839 = (int) D.22838;
      D.22724 = branch->opcode;
      D.22840 = (int) D.22724;
      comp_type = mono_opcode_to_type (D.22840, D.22839);
      if (comp_type > 1) goto <D.22841>; else goto <D.22842>;
      <D.22841>:
      // predicted unlikely by continue predictor.
      goto <D.22295>;
      <D.22842>:
      D.22730 = ins1->opcode;
      D.22843 = (int) D.22730;
      D.22844 = D.22843 + -313;
      D.22845 = D.22844 * 4;
      D.22846 = ins_info[D.22845];
      if (D.22846 != 105) goto <D.22847>; else goto <D.22848>;
      <D.22847>:
      // predicted unlikely by continue predictor.
      goto <D.22295>;
      <D.22848>:
      D.22849 = cfg->verbose_level;
      if (D.22849 > 2) goto <D.22850>; else goto <D.22851>;
      <D.22850>:
      D.22852 = bb->block_num;
      printf ("\tBranch -> CMove optimization in BB%d on\n", D.22852);
      printf ("\t\t");
      mono_print_ins (compare);
      printf ("\t\t");
      D.22853 = compare->next;
      mono_print_ins (D.22853);
      printf ("\t\t");
      mono_print_ins (ins1);
      printf ("\t\t");
      mono_print_ins (ins2);
      <D.22851>:
      changed = 1;
      D.22854 = cfg->ret;
      if (D.22854 != 0B) goto <D.22855>; else goto <D.22856>;
      <D.22855>:
      D.22739 = ins1->dreg;
      D.22854 = cfg->ret;
      D.22857 = D.22854->dreg;
      D.22858 = D.22739 == D.22857;
      ret = (gboolean) D.22858;
      goto <D.22859>;
      <D.22856>:
      ret = 0;
      <D.22859>:
      D.22860 = mono_alloc_dreg (cfg, 1);
      tmp_reg = (int) D.22860;
      dreg = ins1->dreg;
      ins1->dreg = tmp_reg;
      if (ret != 0) goto <D.22861>; else goto <D.22862>;
      <D.22861>:
      D.22863 = mono_alloc_dreg (cfg, 1);
      dreg = (int) D.22863;
      ins2->dreg = dreg;
      <D.22862>:
      D.22864 = ins1->prev;
      if (D.22864 != 0B) goto <D.22865>; else goto <D.22866>;
      <D.22865>:
      D.22864 = ins1->prev;
      D.22867 = ins1->next;
      D.22864->next = D.22867;
      <D.22866>:
      D.22867 = ins1->next;
      if (D.22867 != 0B) goto <D.22868>; else goto <D.22869>;
      <D.22868>:
      D.22867 = ins1->next;
      D.22864 = ins1->prev;
      D.22867->prev = D.22864;
      <D.22869>:
      D.22870 = true_bb->code;
      if (D.22870 == ins1) goto <D.22871>; else goto <D.22872>;
      <D.22871>:
      D.22867 = ins1->next;
      true_bb->code = D.22867;
      <D.22872>:
      D.22873 = true_bb->last_ins;
      if (D.22873 == ins1) goto <D.22874>; else goto <D.22875>;
      <D.22874>:
      D.22864 = ins1->prev;
      true_bb->last_ins = D.22864;
      <D.22875>:
      D.22876 = ins2->prev;
      if (D.22876 != 0B) goto <D.22877>; else goto <D.22878>;
      <D.22877>:
      D.22876 = ins2->prev;
      D.22879 = ins2->next;
      D.22876->next = D.22879;
      <D.22878>:
      D.22879 = ins2->next;
      if (D.22879 != 0B) goto <D.22880>; else goto <D.22881>;
      <D.22880>:
      D.22879 = ins2->next;
      D.22876 = ins2->prev;
      D.22879->prev = D.22876;
      <D.22881>:
      D.22882 = false_bb->code;
      if (D.22882 == ins2) goto <D.22883>; else goto <D.22884>;
      <D.22883>:
      D.22879 = ins2->next;
      false_bb->code = D.22879;
      <D.22884>:
      D.22885 = false_bb->last_ins;
      if (D.22885 == ins2) goto <D.22886>; else goto <D.22887>;
      <D.22886>:
      D.22876 = ins2->prev;
      false_bb->last_ins = D.22876;
      <D.22887>:
      mono_bblock_insert_before_ins (bb, compare, ins2);
      mono_bblock_insert_before_ins (bb, ins2, ins1);
      D.22888 = cfg->mempool;
      cmov = mono_mempool_alloc0 (D.22888, 80);
      cmov->opcode = 316;
      cmov->dreg = -1;
      cmov->sreg3 = -1;
      D.22889 = cmov->sreg3;
      cmov->sreg2 = D.22889;
      D.22890 = cmov->sreg2;
      cmov->sreg1 = D.22890;
      D.22891 = cfg->ip;
      cmov->cil_code = D.22891;
      cmov->dreg = dreg;
      cmov->sreg1 = dreg;
      cmov->sreg2 = tmp_reg;
      D.22838 = compare->opcode;
      D.22839 = (int) D.22838;
      D.22724 = branch->opcode;
      D.22840 = (int) D.22724;
      D.22892 = mono_opcode_to_type (D.22840, D.22839);
      switch (D.22892) <default: <D.22325>, case 0: <D.22324>, case 1: <D.22322>>
      <D.22322>:
      D.22724 = branch->opcode;
      D.22840 = (int) D.22724;
      D.22893 = mono_opcode_to_cond (D.22840);
      D.22894 = int_cmov_opcodes[D.22893];
      D.22895 = (short unsigned int) D.22894;
      cmov->opcode = D.22895;
      goto <D.22323>;
      <D.22324>:
      D.22724 = branch->opcode;
      D.22840 = (int) D.22724;
      D.22896 = mono_opcode_to_cond (D.22840);
      D.22897 = long_cmov_opcodes[D.22896];
      D.22898 = (short unsigned int) D.22897;
      cmov->opcode = D.22898;
      goto <D.22323>;
      <D.22325>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "branch-opts.c", 432);
      <D.22323>:
      mono_bblock_insert_after_ins (bb, compare, cmov);
      if (ret != 0) goto <D.22899>; else goto <D.22900>;
      <D.22899>:
      D.22888 = cfg->mempool;
      move = mono_mempool_alloc0 (D.22888, 80);
      move->opcode = 428;
      move->dreg = -1;
      move->sreg3 = -1;
      D.22901 = move->sreg3;
      move->sreg2 = D.22901;
      D.22902 = move->sreg2;
      move->sreg1 = D.22902;
      D.22891 = cfg->ip;
      move->cil_code = D.22891;
      D.22854 = cfg->ret;
      D.22857 = D.22854->dreg;
      move->dreg = D.22857;
      move->sreg1 = dreg;
      mono_bblock_insert_after_ins (bb, cmov, move);
      <D.22900>:
      branch->opcode = 446;
      D.22903 = true_bb->out_bb;
      D.22904 = *D.22903;
      branch->data.op[0].target_block = D.22904;
      D.22905 = branch->data.op[0].target_block;
      mono_link_bblock (cfg, bb, D.22905);
      mono_unlink_bblock (cfg, bb, true_bb);
      mono_unlink_bblock (cfg, bb, false_bb);
      D.22903 = true_bb->out_bb;
      D.22904 = *D.22903;
      mono_unlink_bblock (cfg, true_bb, D.22904);
      D.22906 = false_bb->out_bb;
      D.22907 = *D.22906;
      mono_unlink_bblock (cfg, false_bb, D.22907);
      mono_remove_bblock (cfg, true_bb);
      mono_remove_bblock (cfg, false_bb);
      D.22684 = bb->out_bb;
      D.22908 = *D.22684;
      D.22909 = D.22908->in_count;
      if (D.22909 == 1) goto <D.22910>; else goto <D.22911>;
      <D.22910>:
      D.22684 = bb->out_bb;
      D.22908 = *D.22684;
      D.22912 = cfg->bb_exit;
      if (D.22908 != D.22912) goto <D.22913>; else goto <D.22914>;
      <D.22913>:
      D.22915 = bb->region;
      D.22684 = bb->out_bb;
      D.22908 = *D.22684;
      D.22916 = D.22908->region;
      if (D.22915 == D.22916) goto <D.22917>; else goto <D.22918>;
      <D.22917>:
      D.22684 = bb->out_bb;
      D.22908 = *D.22684;
      mono_merge_basic_blocks (cfg, bb, D.22908);
      goto restart;
      <D.22918>:
      <D.22914>:
      <D.22911>:
    }
    <D.22702>:
    <D.22696>:
    <D.22693>:
    <D.22690>:
    <D.22687>:
    D.22922 = BIT_FIELD_REF <*bb2, 32, 256>;
    D.22923 = (unsigned int) D.22922;
    D.22924 = D.22923;
    if (D.22924 == 65537) goto <D.22925>; else goto <D.22919>;
    <D.22925>:
    D.22699 = bb2->out_bb;
    D.22700 = *D.22699;
    if (D.22700 == bb1) goto <D.22920>; else goto <D.22919>;
    <D.22919>:
    D.22926 = BIT_FIELD_REF <*bb1, 32, 256>;
    D.22927 = (unsigned int) D.22926;
    D.22928 = D.22927;
    if (D.22928 == 65537) goto <D.22929>; else goto <D.22921>;
    <D.22929>:
    D.22697 = bb1->out_bb;
    D.22698 = *D.22697;
    if (D.22698 == bb2) goto <D.22920>; else goto <D.22921>;
    <D.22920>:
    {
      struct MonoInst * compare;
      struct MonoInst * branch;
      struct MonoInst * ins1;
      struct MonoInst * cmov;
      struct MonoInst * tmp;
      gboolean simple;
      int dreg;
      int tmp_reg;
      CompType comp_type;
      CompRelation cond;
      struct MonoBasicBlock * next_bb;
      struct MonoBasicBlock * code_bb;

      D.22922 = BIT_FIELD_REF <*bb2, 32, 256>;
      D.22923 = (unsigned int) D.22922;
      D.22924 = D.22923;
      if (D.22924 == 65537) goto <D.22932>; else goto <D.22930>;
      <D.22932>:
      D.22699 = bb2->out_bb;
      D.22700 = *D.22699;
      if (D.22700 == bb1) goto <D.22933>; else goto <D.22930>;
      <D.22933>:
      code_bb = bb2;
      next_bb = bb1;
      goto <D.22931>;
      <D.22930>:
      code_bb = bb1;
      next_bb = bb2;
      <D.22931>:
      ins1 = code_bb->code;
      if (ins1 == 0B) goto <D.22934>; else goto <D.22935>;
      <D.22934>:
      // predicted unlikely by continue predictor.
      goto <D.22295>;
      <D.22935>:
      simple = 1;
      tmp = ins1->next;
      goto <D.22339>;
      <D.22338>:
      D.22936 = tmp->opcode;
      D.22937 = D.22936 != 316;
      D.22938 = D.22936 != 446;
      D.22939 = D.22937 & D.22938;
      if (D.22939 != 0) goto <D.22940>; else goto <D.22941>;
      <D.22940>:
      simple = 0;
      <D.22941>:
      tmp = tmp->next;
      <D.22339>:
      if (tmp != 0B) goto <D.22338>; else goto <D.22340>;
      <D.22340>:
      if (simple == 0) goto <D.22942>; else goto <D.22943>;
      <D.22942>:
      // predicted unlikely by continue predictor.
      goto <D.22295>;
      <D.22943>:
      D.22944 = ins1->opcode;
      D.22945 = D.22944 != 428;
      D.22946 = D.22944 != 430;
      D.22947 = D.22945 & D.22946;
      if (D.22947 != 0) goto <D.22948>; else goto <D.22949>;
      <D.22948>:
      D.22950 = ins1->opcode;
      if (D.22950 != 431) goto <D.22951>; else goto <D.22952>;
      <D.22951>:
      D.22950 = ins1->opcode;
      if (D.22950 != 962) goto <D.22953>; else goto <D.22954>;
      <D.22953>:
      D.22950 = ins1->opcode;
      if (D.22950 != 362) goto <D.22955>; else goto <D.22956>;
      <D.22955>:
      D.22950 = ins1->opcode;
      if (D.22950 != 363) goto <D.22957>; else goto <D.22958>;
      <D.22957>:
      D.22959 = ins1->opcode;
      D.22960 = D.22959 != 432;
      D.22961 = D.22959 != 963;
      D.22962 = D.22960 & D.22961;
      if (D.22962 != 0) goto <D.22963>; else goto <D.22964>;
      <D.22963>:
      D.22950 = ins1->opcode;
      if (D.22950 != 433) goto <D.22965>; else goto <D.22966>;
      <D.22965>:
      D.22950 = ins1->opcode;
      if (D.22950 != 365) goto <D.22967>; else goto <D.22968>;
      <D.22967>:
      D.22950 = ins1->opcode;
      if (D.22950 != 542) goto <D.22969>; else goto <D.22970>;
      <D.22969>:
      D.22950 = ins1->opcode;
      if (D.22950 != 630) goto <D.22971>; else goto <D.22972>;
      <D.22971>:
      D.22950 = ins1->opcode;
      if (D.22950 != 629) goto <D.22973>; else goto <D.22974>;
      <D.22973>:
      D.22950 = ins1->opcode;
      if (D.22950 != 496) goto <D.22975>; else goto <D.22976>;
      <D.22975>:
      D.22950 = ins1->opcode;
      if (D.22950 != 570) goto <D.22977>; else goto <D.22978>;
      <D.22977>:
      D.22950 = ins1->opcode;
      if (D.22950 != 979) goto <D.22979>; else goto <D.22980>;
      <D.22979>:
      D.22950 = ins1->opcode;
      if (D.22950 != 639) goto <D.22981>; else goto <D.22982>;
      <D.22981>:
      D.22950 = ins1->opcode;
      if (D.22950 != 640) goto <D.22983>; else goto <D.22984>;
      <D.22983>:
      D.22950 = ins1->opcode;
      if (D.22950 != 641) goto <D.22985>; else goto <D.22986>;
      <D.22985>:
      D.22950 = ins1->opcode;
      if (D.22950 != 636) goto <D.22987>; else goto <D.22988>;
      <D.22987>:
      D.22950 = ins1->opcode;
      if (D.22950 != 595) goto <D.22989>; else goto <D.22990>;
      <D.22989>:
      D.22950 = ins1->opcode;
      if (D.22950 != 584) goto <D.22991>; else goto <D.22992>;
      <D.22991>:
      D.22950 = ins1->opcode;
      if (D.22950 != 766) goto <D.22993>; else goto <D.22994>;
      <D.22993>:
      D.22950 = ins1->opcode;
      if (D.22950 != 507) goto <D.22995>; else goto <D.22996>;
      <D.22995>:
      D.22950 = ins1->opcode;
      if (D.22950 != 594) goto <D.22997>; else goto <D.22998>;
      <D.22997>:
      D.22950 = ins1->opcode;
      if (D.22950 != 585) goto <D.22999>; else goto <D.23000>;
      <D.22999>:
      D.22950 = ins1->opcode;
      if (D.22950 != 499) goto <D.23001>; else goto <D.23002>;
      <D.23001>:
      D.22950 = ins1->opcode;
      if (D.22950 != 314) goto <D.23003>; else goto <D.23004>;
      <D.23003>:
      D.22950 = ins1->opcode;
      if (D.22950 != 319) goto <D.23005>; else goto <D.23006>;
      <D.23005>:
      D.22950 = ins1->opcode;
      if (D.22950 != 316) goto <D.23007>; else goto <D.23008>;
      <D.23007>:
      D.22950 = ins1->opcode;
      if (D.22950 != 769) goto <D.23009>; else goto <D.23010>;
      <D.23009>:
      D.22950 = ins1->opcode;
      if (D.22950 != 803) goto <D.23011>; else goto <D.23012>;
      <D.23011>:
      // predicted unlikely by continue predictor.
      goto <D.22295>;
      <D.23012>:
      <D.23010>:
      <D.23008>:
      <D.23006>:
      <D.23004>:
      <D.23002>:
      <D.23000>:
      <D.22998>:
      <D.22996>:
      <D.22994>:
      <D.22992>:
      <D.22990>:
      <D.22988>:
      <D.22986>:
      <D.22984>:
      <D.22982>:
      <D.22980>:
      <D.22978>:
      <D.22976>:
      <D.22974>:
      <D.22972>:
      <D.22970>:
      <D.22968>:
      <D.22966>:
      <D.22964>:
      <D.22958>:
      <D.22956>:
      <D.22954>:
      <D.22952>:
      <D.22949>:
      D.22703 = bb->last_ins;
      if (D.22703 != 0B) goto <D.23013>; else goto <D.23014>;
      <D.23013>:
      D.22703 = bb->last_ins;
      D.23015 = D.22703->opcode;
      if (D.23015 == 763) goto <D.23016>; else goto <D.23017>;
      <D.23016>:
      // predicted unlikely by continue predictor.
      goto <D.22295>;
      <D.23017>:
      <D.23014>:
      D.22703 = bb->last_ins;
      if (D.22703 == 0B) goto <D.23018>; else goto <D.23020>;
      <D.23020>:
      D.22703 = bb->last_ins;
      D.22715 = D.22703->prev;
      if (D.22715 == 0B) goto <D.23018>; else goto <D.23019>;
      <D.23018>:
      // predicted unlikely by continue predictor.
      goto <D.22295>;
      <D.23019>:
      branch = bb->last_ins;
      compare = branch->prev;
      D.23021 = branch->opcode;
      D.23022 = D.23021 + 64981;
      D.23023 = D.23022 > 9;
      D.23024 = D.23021 + 64874;
      D.23025 = D.23024 > 9;
      D.23026 = D.23023 & D.23025;
      if (D.23026 != 0) goto <D.23027>; else goto <D.23028>;
      <D.23027>:
      D.23029 = branch->opcode;
      D.23030 = D.23029 + 64884;
      if (D.23030 > 9) goto <D.23031>; else goto <D.23032>;
      <D.23031>:
      // predicted unlikely by continue predictor.
      goto <D.22295>;
      <D.23032>:
      <D.23028>:
      D.23033 = compare->opcode;
      D.23034 = (int) D.23033;
      D.23029 = branch->opcode;
      D.23035 = (int) D.23029;
      comp_type = mono_opcode_to_type (D.23035, D.23034);
      if (comp_type > 1) goto <D.23036>; else goto <D.23037>;
      <D.23036>:
      // predicted unlikely by continue predictor.
      goto <D.22295>;
      <D.23037>:
      D.22950 = ins1->opcode;
      D.23038 = (int) D.22950;
      D.23039 = D.23038 + -313;
      D.23040 = D.23039 * 4;
      D.23041 = ins_info[D.23040];
      if (D.23041 != 105) goto <D.23042>; else goto <D.23043>;
      <D.23042>:
      // predicted unlikely by continue predictor.
      goto <D.22295>;
      <D.23043>:
      D.22854 = cfg->ret;
      if (D.22854 != 0B) goto <D.23044>; else goto <D.23045>;
      <D.23044>:
      D.23046 = ins1->dreg;
      D.22854 = cfg->ret;
      D.22857 = D.22854->dreg;
      if (D.23046 == D.22857) goto <D.23047>; else goto <D.23048>;
      <D.23047>:
      // predicted unlikely by continue predictor.
      goto <D.22295>;
      <D.23048>:
      <D.23045>:
      D.22674 = cfg->opt;
      D.23049 = D.22674 & 64;
      if (D.23049 == 0) goto <D.23050>; else goto <D.23051>;
      <D.23050>:
      // predicted unlikely by continue predictor.
      goto <D.22295>;
      <D.23051>:
      D.22849 = cfg->verbose_level;
      if (D.22849 > 2) goto <D.23052>; else goto <D.23053>;
      <D.23052>:
      D.22852 = bb->block_num;
      printf ("\tBranch -> CMove optimization (2) in BB%d on\n", D.22852);
      printf ("\t\t");
      mono_print_ins (compare);
      printf ("\t\t");
      D.23054 = compare->next;
      mono_print_ins (D.23054);
      printf ("\t\t");
      mono_print_ins (ins1);
      <D.23053>:
      changed = 1;
      D.23055 = mono_alloc_dreg (cfg, 1);
      tmp_reg = (int) D.23055;
      dreg = ins1->dreg;
      ins1->dreg = tmp_reg;
      D.23056 = ins1->prev;
      if (D.23056 != 0B) goto <D.23057>; else goto <D.23058>;
      <D.23057>:
      D.23056 = ins1->prev;
      D.23059 = ins1->next;
      D.23056->next = D.23059;
      <D.23058>:
      D.23059 = ins1->next;
      if (D.23059 != 0B) goto <D.23060>; else goto <D.23061>;
      <D.23060>:
      D.23059 = ins1->next;
      D.23056 = ins1->prev;
      D.23059->prev = D.23056;
      <D.23061>:
      D.23062 = code_bb->code;
      if (D.23062 == ins1) goto <D.23063>; else goto <D.23064>;
      <D.23063>:
      D.23059 = ins1->next;
      code_bb->code = D.23059;
      <D.23064>:
      D.23065 = code_bb->last_ins;
      if (D.23065 == ins1) goto <D.23066>; else goto <D.23067>;
      <D.23066>:
      D.23056 = ins1->prev;
      code_bb->last_ins = D.23056;
      <D.23067>:
      mono_bblock_insert_before_ins (bb, compare, ins1);
      D.22888 = cfg->mempool;
      cmov = mono_mempool_alloc0 (D.22888, 80);
      cmov->opcode = 316;
      cmov->dreg = -1;
      cmov->sreg3 = -1;
      D.23068 = cmov->sreg3;
      cmov->sreg2 = D.23068;
      D.23069 = cmov->sreg2;
      cmov->sreg1 = D.23069;
      D.22891 = cfg->ip;
      cmov->cil_code = D.22891;
      cmov->dreg = dreg;
      cmov->sreg1 = dreg;
      cmov->sreg2 = tmp_reg;
      D.23029 = branch->opcode;
      D.23035 = (int) D.23029;
      cond = mono_opcode_to_cond (D.23035);
      D.23070 = branch->data.op[1].many_blocks;
      D.23071 = D.23070 + 8;
      D.23072 = *D.23071;
      if (D.23072 == code_bb) goto <D.23073>; else goto <D.23074>;
      <D.23073>:
      cond = mono_negate_cond (cond);
      <D.23074>:
      D.23033 = compare->opcode;
      D.23034 = (int) D.23033;
      D.23029 = branch->opcode;
      D.23035 = (int) D.23029;
      D.23075 = mono_opcode_to_type (D.23035, D.23034);
      switch (D.23075) <default: <D.22344>, case 0: <D.22343>, case 1: <D.22341>>
      <D.22341>:
      D.23076 = int_cmov_opcodes[cond];
      D.23077 = (short unsigned int) D.23076;
      cmov->opcode = D.23077;
      goto <D.22342>;
      <D.22343>:
      D.23078 = long_cmov_opcodes[cond];
      D.23079 = (short unsigned int) D.23078;
      cmov->opcode = D.23079;
      goto <D.22342>;
      <D.22344>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "branch-opts.c", 584);
      <D.22342>:
      mono_bblock_insert_after_ins (bb, compare, cmov);
      branch->opcode = 446;
      branch->data.op[0].target_block = next_bb;
      D.23080 = branch->data.op[0].target_block;
      mono_link_bblock (cfg, bb, D.23080);
      D.23062 = code_bb->code;
      if (D.23062 != 0B) goto <D.23081>; else goto <D.23082>;
      <D.23081>:
      branch = code_bb->code;
      D.23083 = branch->prev;
      if (D.23083 != 0B) goto <D.23084>; else goto <D.23085>;
      <D.23084>:
      D.23083 = branch->prev;
      D.23086 = branch->next;
      D.23083->next = D.23086;
      <D.23085>:
      D.23086 = branch->next;
      if (D.23086 != 0B) goto <D.23087>; else goto <D.23088>;
      <D.23087>:
      D.23086 = branch->next;
      D.23083 = branch->prev;
      D.23086->prev = D.23083;
      <D.23088>:
      D.23062 = code_bb->code;
      if (D.23062 == branch) goto <D.23089>; else goto <D.23090>;
      <D.23089>:
      D.23086 = branch->next;
      code_bb->code = D.23086;
      <D.23090>:
      D.23065 = code_bb->last_ins;
      if (D.23065 == branch) goto <D.23091>; else goto <D.23092>;
      <D.23091>:
      D.23083 = branch->prev;
      code_bb->last_ins = D.23083;
      <D.23092>:
      branch->opcode = 316;
      branch->dreg = -1;
      branch->sreg3 = -1;
      D.23093 = branch->sreg3;
      branch->sreg2 = D.23093;
      D.23094 = branch->sreg2;
      branch->sreg1 = D.23094;
      <D.23082>:
      mono_unlink_bblock (cfg, bb, code_bb);
      mono_unlink_bblock (cfg, code_bb, next_bb);
      D.22684 = bb->out_bb;
      D.22908 = *D.22684;
      D.22909 = D.22908->in_count;
      if (D.22909 == 1) goto <D.23095>; else goto <D.23096>;
      <D.23095>:
      D.22684 = bb->out_bb;
      D.22908 = *D.22684;
      D.22912 = cfg->bb_exit;
      if (D.22908 != D.22912) goto <D.23097>; else goto <D.23098>;
      <D.23097>:
      D.22915 = bb->region;
      D.22684 = bb->out_bb;
      D.22908 = *D.22684;
      D.22916 = D.22908->region;
      if (D.22915 == D.22916) goto <D.23099>; else goto <D.23100>;
      <D.23099>:
      D.22684 = bb->out_bb;
      D.22908 = *D.22684;
      mono_merge_basic_blocks (cfg, bb, D.22908);
      D.22703 = bb->last_ins;
      if (D.22703 == 0B) goto <D.23101>; else goto <D.23103>;
      <D.23103>:
      D.22703 = bb->last_ins;
      D.23104 = D.22703->opcode;
      D.23105 = D.23104 + 64981;
      D.23106 = D.23105 > 9;
      D.23107 = D.23104 + 64874;
      D.23108 = D.23107 > 9;
      D.23109 = D.23106 & D.23108;
      if (D.23109 != 0) goto <D.23110>; else goto <D.23102>;
      <D.23110>:
      D.22703 = bb->last_ins;
      D.23015 = D.22703->opcode;
      D.23111 = D.23015 + 64884;
      if (D.23111 > 9) goto <D.23112>; else goto <D.23102>;
      <D.23112>:
      D.22703 = bb->last_ins;
      D.23015 = D.22703->opcode;
      if (D.23015 != 446) goto <D.23113>; else goto <D.23102>;
      <D.23113>:
      D.22703 = bb->last_ins;
      D.23015 = D.22703->opcode;
      if (D.23015 != 763) goto <D.23114>; else goto <D.23102>;
      <D.23114>:
      D.22703 = bb->last_ins;
      D.23015 = D.22703->opcode;
      if (D.23015 != 370) goto <D.23101>; else goto <D.23102>;
      <D.23101>:
      D.22680 = bb->out_count;
      if (D.22680 != 0) goto <D.23115>; else goto <D.23116>;
      <D.23115>:
      D.22888 = cfg->mempool;
      ins1 = mono_mempool_alloc0 (D.22888, 80);
      ins1->opcode = 446;
      ins1->dreg = -1;
      ins1->sreg3 = -1;
      D.23117 = ins1->sreg3;
      ins1->sreg2 = D.23117;
      D.23118 = ins1->sreg2;
      ins1->sreg1 = D.23118;
      D.22891 = cfg->ip;
      ins1->cil_code = D.22891;
      D.22684 = bb->out_bb;
      D.22908 = *D.22684;
      ins1->data.op[0].target_block = D.22908;
      D.22703 = bb->last_ins;
      if (D.22703 != 0B) goto <D.23119>; else goto <D.23120>;
      <D.23119>:
      D.22703 = bb->last_ins;
      D.22703->next = ins1;
      D.22703 = bb->last_ins;
      ins1->prev = D.22703;
      bb->last_ins = ins1;
      goto <D.23121>;
      <D.23120>:
      bb->last_ins = ins1;
      D.22703 = bb->last_ins;
      bb->code = D.22703;
      <D.23121>:
      <D.23116>:
      <D.23102>:
      goto restart;
      <D.23100>:
      <D.23098>:
      <D.23096>:
    }
    <D.22921>:
  }
  <D.22295>:
  bb = bb->next_bb;
  <D.22346>:
  if (bb != 0B) goto <D.22345>; else goto <D.22347>;
  <D.22347>:
  bb = cfg->bb_entry;
  goto <D.22359>;
  <D.22358>:
  {
    struct MonoBasicBlock * bb1;
    struct MonoBasicBlock * bb2;
    struct MonoBasicBlock * true_bb;
    struct MonoBasicBlock * false_bb;
    struct MonoBasicBlock * next_bb;
    struct MonoInst * branch1;
    struct MonoInst * branch2;
    struct MonoInst * compare1;
    struct MonoInst * ins;

    D.22680 = bb->out_count;
    if (D.22680 != 2) goto <D.23122>; else goto <D.23124>;
    <D.23124>:
    D.22682 = BIT_FIELD_REF <*bb, 8, 1488>;
    D.22683 = D.22682 & 8;
    if (D.22683 != 0) goto <D.23122>; else goto <D.23123>;
    <D.23122>:
    // predicted unlikely by continue predictor.
    goto <D.22357>;
    <D.23123>:
    D.22684 = bb->out_bb;
    bb1 = *D.22684;
    D.22684 = bb->out_bb;
    bb2 = MEM[(struct MonoBasicBlock * *)D.22684 + 8B];
    D.23127 = bb1->in_count;
    if (D.23127 != 2) goto <D.23125>; else goto <D.23128>;
    <D.23128>:
    D.23129 = bb1->in_bb;
    D.23130 = *D.23129;
    if (D.23130 != bb) goto <D.23125>; else goto <D.23131>;
    <D.23131>:
    D.23129 = bb1->in_bb;
    D.23132 = D.23129 + 8;
    D.23133 = *D.23132;
    if (D.23133 != bb2) goto <D.23125>; else goto <D.23134>;
    <D.23134>:
    D.23135 = BIT_FIELD_REF <*bb2, 32, 256>;
    D.23136 = (unsigned int) D.23135;
    D.23137 = D.23136;
    if (D.23137 != 65538) goto <D.23125>; else goto <D.23126>;
    <D.23125>:
    // predicted unlikely by continue predictor.
    goto <D.22357>;
    <D.23126>:
    next_bb = bb2;
    branch1 = bb->last_ins;
    if (branch1 == 0B) goto <D.23138>; else goto <D.23140>;
    <D.23140>:
    D.23141 = branch1->opcode;
    D.23142 = D.23141 != 656;
    D.23143 = D.23141 != 559;
    D.23144 = D.23142 & D.23143;
    if (D.23144 != 0) goto <D.23138>; else goto <D.23145>;
    <D.23145>:
    D.23146 = branch1->data.op[1].many_blocks;
    D.23147 = D.23146 + 8;
    D.23148 = *D.23147;
    if (D.23148 != next_bb) goto <D.23138>; else goto <D.23139>;
    <D.23138>:
    // predicted unlikely by continue predictor.
    goto <D.22357>;
    <D.23139>:
    D.23146 = branch1->data.op[1].many_blocks;
    true_bb = *D.23146;
    branch2 = next_bb->last_ins;
    if (branch2 == 0B) goto <D.23149>; else goto <D.23150>;
    <D.23149>:
    // predicted unlikely by continue predictor.
    goto <D.22357>;
    <D.23150>:
    D.23153 = branch2->opcode;
    D.23154 = D.23153 == 654;
    D.23155 = D.23153 == 557;
    D.23156 = D.23154 | D.23155;
    if (D.23156 != 0) goto <D.23157>; else goto <D.23151>;
    <D.23157>:
    D.23158 = branch2->data.op[1].many_blocks;
    D.23159 = *D.23158;
    D.23146 = branch1->data.op[1].many_blocks;
    D.23160 = *D.23146;
    if (D.23159 == D.23160) goto <D.23161>; else goto <D.23151>;
    <D.23161>:
    D.23158 = branch2->data.op[1].many_blocks;
    false_bb = MEM[(struct MonoBasicBlock * *)D.23158 + 8B];
    goto <D.23152>;
    <D.23151>:
    D.23164 = branch2->opcode;
    D.23165 = D.23164 == 655;
    D.23166 = D.23164 == 558;
    D.23167 = D.23165 | D.23166;
    if (D.23167 != 0) goto <D.23168>; else goto <D.23162>;
    <D.23168>:
    D.23158 = branch2->data.op[1].many_blocks;
    D.23169 = D.23158 + 8;
    D.23170 = *D.23169;
    D.23146 = branch1->data.op[1].many_blocks;
    D.23160 = *D.23146;
    if (D.23170 == D.23160) goto <D.23171>; else goto <D.23162>;
    <D.23171>:
    D.23158 = branch2->data.op[1].many_blocks;
    false_bb = *D.23158;
    goto <D.23163>;
    <D.23162>:
    // predicted unlikely by continue predictor.
    goto <D.22357>;
    <D.23163>:
    <D.23152>:
    D.22703 = bb->last_ins;
    compare1 = D.22703->prev;
    if (compare1 == 0B) goto <D.23172>; else goto <D.23174>;
    <D.23174>:
    D.23175 = compare1->opcode;
    D.23176 = D.23175 + 65209;
    if (D.23176 > 1) goto <D.23172>; else goto <D.23177>;
    <D.23177>:
    D.23178 = compare1->data.op[1].const_val;
    if (D.23178 != 0) goto <D.23172>; else goto <D.23173>;
    <D.23172>:
    // predicted unlikely by continue predictor.
    goto <D.22357>;
    <D.23173>:
    ins = next_bb->code;
    if (ins == 0B) goto <D.23179>; else goto <D.23180>;
    <D.23179>:
    // predicted unlikely by continue predictor.
    goto <D.22357>;
    <D.23180>:
    D.23183 = ins->opcode;
    D.23184 = D.23183 + 65209;
    if (D.23184 <= 1) goto <D.23185>; else goto <D.23181>;
    <D.23185>:
    D.23186 = ins->sreg1;
    D.23187 = compare1->sreg1;
    if (D.23186 == D.23187) goto <D.23188>; else goto <D.23181>;
    <D.23188>:
    D.23189 = ins->next;
    if (D.23189 == branch2) goto <D.23190>; else goto <D.23181>;
    <D.23190>:
    D.23191 = ins->data.op[1].const_val;
    if (D.23191 < 0) goto <D.23192>; else goto <D.23193>;
    <D.23192>:
    // predicted unlikely by continue predictor.
    goto <D.22357>;
    <D.23193>:
    goto <D.23182>;
    <D.23181>:
    D.23196 = ins->opcode;
    D.23197 = D.23196 == 787;
    D.23198 = D.23196 == 785;
    D.23199 = D.23197 | D.23198;
    if (D.23199 != 0) goto <D.23200>; else goto <D.23194>;
    <D.23200>:
    D.23201 = ins->dreg;
    D.23187 = compare1->sreg1;
    if (D.23201 != D.23187) goto <D.23202>; else goto <D.23194>;
    <D.23202>:
    D.23189 = ins->next;
    if (D.23189 != 0B) goto <D.23203>; else goto <D.23194>;
    <D.23203>:
    D.23189 = ins->next;
    D.23204 = D.23189->opcode;
    if (D.23204 == 326) goto <D.23205>; else goto <D.23194>;
    <D.23205>:
    D.23189 = ins->next;
    D.23206 = D.23189->sreg1;
    D.23187 = compare1->sreg1;
    if (D.23206 == D.23187) goto <D.23207>; else goto <D.23194>;
    <D.23207>:
    D.23189 = ins->next;
    D.23208 = D.23189->sreg2;
    D.23201 = ins->dreg;
    if (D.23208 == D.23201) goto <D.23209>; else goto <D.23194>;
    <D.23209>:
    D.23189 = ins->next;
    D.23210 = D.23189->next;
    if (D.23210 == branch2) goto <D.23211>; else goto <D.23194>;
    <D.23211>:
    goto <D.23195>;
    <D.23194>:
    // predicted unlikely by continue predictor.
    goto <D.22357>;
    <D.23195>:
    <D.23182>:
    D.22849 = cfg->verbose_level;
    if (D.22849 > 2) goto <D.23212>; else goto <D.23213>;
    <D.23212>:
    D.22852 = bb->block_num;
    printf ("\tSigned->unsigned compare optimization in BB%d on\n", D.22852);
    printf ("\t\t");
    mono_print_ins (compare1);
    printf ("\t\t");
    D.23214 = compare1->next;
    mono_print_ins (D.23214);
    printf ("\t\t");
    mono_print_ins (ins);
    <D.23213>:
    D.23215 = compare1->prev;
    if (D.23215 != 0B) goto <D.23216>; else goto <D.23217>;
    <D.23216>:
    D.23215 = compare1->prev;
    D.23214 = compare1->next;
    D.23215->next = D.23214;
    <D.23217>:
    D.23214 = compare1->next;
    if (D.23214 != 0B) goto <D.23218>; else goto <D.23219>;
    <D.23218>:
    D.23214 = compare1->next;
    D.23215 = compare1->prev;
    D.23214->prev = D.23215;
    <D.23219>:
    D.23220 = bb->code;
    if (D.23220 == compare1) goto <D.23221>; else goto <D.23222>;
    <D.23221>:
    D.23214 = compare1->next;
    bb->code = D.23214;
    <D.23222>:
    D.22703 = bb->last_ins;
    if (D.22703 == compare1) goto <D.23223>; else goto <D.23224>;
    <D.23223>:
    D.23215 = compare1->prev;
    bb->last_ins = D.23215;
    <D.23224>:
    compare1->opcode = 316;
    compare1->dreg = -1;
    compare1->sreg3 = -1;
    D.23225 = compare1->sreg3;
    compare1->sreg2 = D.23225;
    D.23226 = compare1->sreg2;
    compare1->sreg1 = D.23226;
    branch1->opcode = 446;
    D.23146 = branch1->data.op[1].many_blocks;
    D.23160 = *D.23146;
    mono_unlink_bblock (cfg, bb, D.23160);
    D.23146 = branch1->data.op[1].many_blocks;
    D.23147 = D.23146 + 8;
    D.23148 = *D.23147;
    mono_unlink_bblock (cfg, bb, D.23148);
    branch1->data.op[0].target_block = next_bb;
    mono_link_bblock (cfg, bb, next_bb);
    D.23227 = branch2->opcode;
    D.23228 = (int) D.23227;
    D.23229 = br_to_br_un (D.23228);
    D.23230 = (short unsigned int) D.23229;
    branch2->opcode = D.23230;
    mono_merge_basic_blocks (cfg, bb, next_bb);
  }
  <D.22357>:
  bb = bb->next_bb;
  <D.22359>:
  if (bb != 0B) goto <D.22358>; else goto <D.22360>;
  <D.22360>:
  if (changed != 0) goto <D.23231>; else goto <D.23232>;
  <D.23231>:
  D.22674 = cfg->opt;
  D.23233 = D.22674 & 2;
  if (D.23233 != 0) goto <D.23234>; else goto <D.23235>;
  <D.23234>:
  mono_optimize_branches (cfg);
  <D.23235>:
  mono_handle_global_vregs (cfg);
  D.22674 = cfg->opt;
  D.23236 = D.22674 & 48;
  if (D.23236 != 0) goto <D.23237>; else goto <D.23238>;
  <D.23237>:
  mono_local_cprop (cfg);
  <D.23238>:
  D.22674 = cfg->opt;
  D.23049 = D.22674 & 64;
  if (D.23049 != 0) goto <D.23239>; else goto <D.23240>;
  <D.23239>:
  mono_local_deadce (cfg);
  <D.23240>:
  <D.23232>:
}


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

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


br_to_br_un (int opcode)
{
  int D.23244;

  switch (opcode) <default: <D.22249>, case 557: <D.22247>, case 558: <D.22248>, case 654: <D.22245>, case 655: <D.22246>>
  <D.22245>:
  D.23244 = 659;
  return D.23244;
  <D.22246>:
  D.23244 = 660;
  return D.23244;
  <D.22247>:
  D.23244 = 562;
  return D.23244;
  <D.22248>:
  D.23244 = 563;
  return D.23244;
  <D.22249>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "branch-opts.c", 155);
  D.23244 = -1;
  return D.23244;
}


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

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


mono_merge_basic_blocks (struct MonoCompile * cfg, struct MonoBasicBlock * bb, struct MonoBasicBlock * bbn)
{
  <unnamed-unsigned:1> D.23247;
  unsigned char D.23248;
  <unnamed-unsigned:1> D.23249;
  unsigned char D.23250;
  unsigned char D.23251;
  <unnamed-unsigned:1> D.23252;
  <unnamed-unsigned:1> D.23253;
  unsigned char D.23254;
  <unnamed-unsigned:1> D.23255;
  unsigned char D.23256;
  unsigned char D.23257;
  <unnamed-unsigned:1> D.23258;
  struct MonoBasicBlock * * D.23259;
  long unsigned int D.23260;
  long unsigned int D.23261;
  struct MonoBasicBlock * * D.23262;
  struct MonoBasicBlock * D.23263;
  short int D.23264;
  int D.23265;
  struct MonoBasicBlock * D.23266;
  unsigned char D.23267;
  unsigned char D.23268;
  short unsigned int D.23271;
  struct MonoBasicBlock * D.23274;
  _Bool D.23275;
  long int D.23276;
  long int D.23277;
  int D.23280;
  int D.23281;
  unsigned char D.23282;
  struct MonoInst * D.23290;
  struct MonoInst * D.23293;
  struct MonoJumpInfoBBTable * iftmp.0;
  struct MonoJumpInfoBBTable * iftmp.1;
  struct MonoJumpInfoBBTable * iftmp.2;
  struct MonoJumpInfoBBTable * iftmp.3;
  struct MonoBasicBlock * * D.23312;
  long unsigned int D.23313;
  long unsigned int D.23314;
  struct MonoBasicBlock * * D.23315;
  struct MonoBasicBlock * D.23316;
  _Bool D.23319;
  long int D.23320;
  long int D.23321;
  int D.23324;
  struct MonoInst * D.23328;
  short unsigned int D.23330;
  short unsigned int D.23331;
  _Bool D.23332;
  short unsigned int D.23333;
  _Bool D.23334;
  _Bool D.23335;
  short unsigned int D.23337;
  short unsigned int D.23338;
  struct MonoBasicBlock * * D.23339;
  struct MonoBasicBlock * * D.23340;
  struct MonoBasicBlock * D.23341;
  _Bool D.23342;
  long int D.23343;
  long int D.23344;
  short unsigned int D.23351;
  short unsigned int D.23352;
  _Bool D.23353;
  short unsigned int D.23354;
  _Bool D.23355;
  _Bool D.23356;
  int D.23361;
  int D.23362;
  <unnamed-unsigned:1> D.23363;
  unsigned char D.23364;
  <unnamed-unsigned:1> D.23365;
  unsigned char D.23366;
  unsigned char D.23367;
  <unnamed-unsigned:1> D.23368;
  <unnamed-unsigned:1> D.23369;
  unsigned char D.23370;
  <unnamed-unsigned:1> D.23371;
  unsigned char D.23372;
  unsigned char D.23373;
  <unnamed-unsigned:1> D.23374;
  struct MonoInst * D.23377;
  struct MonoInst * D.23380;
  struct MonoBasicBlock * D.23383;
  struct MonoBasicBlock * D.23386;
  struct MonoBasicBlock * D.23388;
  short int D.23393;
  struct MonoBasicBlock * * D.23396;
  struct MonoBasicBlock * D.23397;
  short unsigned int D.23400;
  short unsigned int D.23401;
  _Bool D.23402;
  short unsigned int D.23403;
  _Bool D.23404;
  _Bool D.23405;
  struct MonoMemPool * D.23416;
  const unsigned char * D.23417;
  struct MonoInst * inst;
  struct MonoBasicBlock * prev_bb;
  int i;

  D.23247 = bb->has_array_access;
  D.23248 = (unsigned char) D.23247;
  D.23249 = bbn->has_array_access;
  D.23250 = (unsigned char) D.23249;
  D.23251 = D.23248 | D.23250;
  D.23252 = (<unnamed-unsigned:1>) D.23251;
  bb->has_array_access = D.23252;
  D.23253 = bb->extended;
  D.23254 = (unsigned char) D.23253;
  D.23255 = bbn->extended;
  D.23256 = (unsigned char) D.23255;
  D.23257 = D.23254 | D.23256;
  D.23258 = (<unnamed-unsigned:1>) D.23257;
  bb->extended = D.23258;
  mono_unlink_bblock (cfg, bb, bbn);
  i = 0;
  goto <D.22440>;
  <D.22439>:
  D.23259 = bbn->out_bb;
  D.23260 = (long unsigned int) i;
  D.23261 = D.23260 * 8;
  D.23262 = D.23259 + D.23261;
  D.23263 = *D.23262;
  mono_link_bblock (cfg, bb, D.23263);
  i = i + 1;
  <D.22440>:
  D.23264 = bbn->out_count;
  D.23265 = (int) D.23264;
  if (D.23265 > i) goto <D.22439>; else goto <D.22441>;
  <D.22441>:
  goto <D.22443>;
  <D.22442>:
  D.23259 = bbn->out_bb;
  D.23266 = *D.23259;
  mono_unlink_bblock (cfg, bbn, D.23266);
  <D.22443>:
  D.23264 = bbn->out_count;
  if (D.23264 != 0) goto <D.22442>; else goto <D.22444>;
  <D.22444>:
  D.23267 = BIT_FIELD_REF <*bb, 8, 1488>;
  D.23268 = D.23267 & 32;
  if (D.23268 != 0) goto <D.23269>; else goto <D.23270>;
  <D.23269>:
  inst = bb->code;
  goto <D.22446>;
  <D.22445>:
  D.23271 = inst->opcode;
  if (D.23271 == 739) goto <D.23272>; else goto <D.23273>;
  <D.23272>:
  D.23274 = inst->data.op[0].target_block;
  D.23275 = D.23274 != bbn;
  D.23276 = (long int) D.23275;
  D.23277 = __builtin_expect (D.23276, 0);
  if (D.23277 != 0) goto <D.23278>; else goto <D.23279>;
  <D.23278>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "branch-opts.c", 984, "inst->inst_target_bb == bbn");
  <D.23279>:
  inst->opcode = 316;
  inst->dreg = -1;
  inst->sreg3 = -1;
  D.23280 = inst->sreg3;
  inst->sreg2 = D.23280;
  D.23281 = inst->sreg2;
  inst->sreg1 = D.23281;
  <D.23273>:
  inst = inst->next;
  <D.22446>:
  if (inst != 0B) goto <D.22445>; else goto <D.22447>;
  <D.22447>:
  <D.23270>:
  D.23267 = BIT_FIELD_REF <*bb, 8, 1488>;
  D.23282 = D.23267 & 16;
  if (D.23282 != 0) goto <D.23283>; else goto <D.23284>;
  <D.23283>:
  inst = bb->code;
  goto <D.22454>;
  <D.22453>:
  D.23271 = inst->opcode;
  if (D.23271 == 735) goto <D.23285>; else goto <D.23288>;
  <D.23288>:
  D.23271 = inst->opcode;
  if (D.23271 == 736) goto <D.23289>; else goto <D.23286>;
  <D.23289>:
  D.23290 = inst->data.op[1].src;
  if (D.23290 == 8B) goto <D.23285>; else goto <D.23286>;
  <D.23286>:
  D.23271 = inst->opcode;
  if (D.23271 == 370) goto <D.23285>; else goto <D.23291>;
  <D.23291>:
  D.23271 = inst->opcode;
  if (D.23271 == 738) goto <D.23292>; else goto <D.23287>;
  <D.23292>:
  D.23290 = inst->data.op[1].src;
  D.23293 = D.23290->data.op[1].src;
  if (D.23293 == 8B) goto <D.23285>; else goto <D.23287>;
  <D.23285>:
  {
    int i;
    struct MonoJumpInfoBBTable * table;

    D.23271 = inst->opcode;
    if (D.23271 == 735) goto <D.23295>; else goto <D.23296>;
    <D.23295>:
    iftmp.0 = inst->data.op[0].p;
    goto <D.23297>;
    <D.23296>:
    D.23271 = inst->opcode;
    if (D.23271 == 736) goto <D.23301>; else goto <D.23299>;
    <D.23301>:
    D.23290 = inst->data.op[1].src;
    if (D.23290 == 8B) goto <D.23302>; else goto <D.23299>;
    <D.23302>:
    iftmp.1 = inst->data.op[0].p;
    goto <D.23300>;
    <D.23299>:
    D.23271 = inst->opcode;
    if (D.23271 == 370) goto <D.23304>; else goto <D.23305>;
    <D.23304>:
    iftmp.2 = inst->data.op[0].p;
    goto <D.23306>;
    <D.23305>:
    D.23271 = inst->opcode;
    if (D.23271 == 738) goto <D.23310>; else goto <D.23308>;
    <D.23310>:
    D.23290 = inst->data.op[1].src;
    D.23293 = D.23290->data.op[1].src;
    if (D.23293 == 8B) goto <D.23311>; else goto <D.23308>;
    <D.23311>:
    D.23290 = inst->data.op[1].src;
    iftmp.3 = D.23290->data.op[0].p;
    goto <D.23309>;
    <D.23308>:
    iftmp.3 = 0B;
    <D.23309>:
    iftmp.2 = iftmp.3;
    <D.23306>:
    iftmp.1 = iftmp.2;
    <D.23300>:
    iftmp.0 = iftmp.1;
    <D.23297>:
    table = iftmp.0;
    i = 0;
    goto <D.22451>;
    <D.22450>:
    D.23312 = table->table;
    D.23313 = (long unsigned int) i;
    D.23314 = D.23313 * 8;
    D.23315 = D.23312 + D.23314;
    D.23316 = *D.23315;
    if (D.23316 != 0B) goto <D.23317>; else goto <D.23318>;
    <D.23317>:
    D.23312 = table->table;
    D.23313 = (long unsigned int) i;
    D.23314 = D.23313 * 8;
    D.23315 = D.23312 + D.23314;
    D.23316 = *D.23315;
    D.23319 = D.23316 != bbn;
    D.23320 = (long int) D.23319;
    D.23321 = __builtin_expect (D.23320, 0);
    if (D.23321 != 0) goto <D.23322>; else goto <D.23323>;
    <D.23322>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "branch-opts.c", 997, "table->table [i] == bbn");
    <D.23323>:
    <D.23318>:
    D.23312 = table->table;
    D.23313 = (long unsigned int) i;
    D.23314 = D.23313 * 8;
    D.23315 = D.23312 + D.23314;
    *D.23315 = 0B;
    i = i + 1;
    <D.22451>:
    D.23324 = table->table_size;
    if (D.23324 > i) goto <D.22450>; else goto <D.22452>;
    <D.22452>:
  }
  <D.23287>:
  inst = inst->next;
  <D.22454>:
  if (inst != 0B) goto <D.22453>; else goto <D.22455>;
  <D.22455>:
  <D.23284>:
  D.23328 = bb->last_ins;
  if (D.23328 != 0B) goto <D.23329>; else goto <D.23325>;
  <D.23329>:
  D.23328 = bb->last_ins;
  D.23330 = D.23328->opcode;
  D.23331 = D.23330 + 64981;
  D.23332 = D.23331 <= 9;
  D.23333 = D.23330 + 64874;
  D.23334 = D.23333 <= 9;
  D.23335 = D.23332 | D.23334;
  if (D.23335 != 0) goto <D.23326>; else goto <D.23336>;
  <D.23336>:
  D.23328 = bb->last_ins;
  D.23337 = D.23328->opcode;
  D.23338 = D.23337 + 64884;
  if (D.23338 <= 9) goto <D.23326>; else goto <D.23325>;
  <D.23326>:
  D.23328 = bb->last_ins;
  D.23339 = D.23328->data.op[1].many_blocks;
  D.23340 = D.23339 + 8;
  D.23341 = *D.23340;
  D.23342 = D.23341 != bbn;
  D.23343 = (long int) D.23342;
  D.23344 = __builtin_expect (D.23343, 0);
  if (D.23344 != 0) goto <D.23345>; else goto <D.23346>;
  <D.23345>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "branch-opts.c", 1005, "bb->last_ins->inst_false_bb == bbn");
  <D.23346>:
  D.23328 = bb->last_ins;
  D.23339 = D.23328->data.op[1].many_blocks;
  D.23340 = D.23339 + 8;
  *D.23340 = 0B;
  bb->extended = 1;
  goto <D.23327>;
  <D.23325>:
  D.23328 = bb->last_ins;
  if (D.23328 != 0B) goto <D.23349>; else goto <D.23350>;
  <D.23349>:
  D.23328 = bb->last_ins;
  D.23351 = D.23328->opcode;
  D.23352 = D.23351 + 64981;
  D.23353 = D.23352 <= 9;
  D.23354 = D.23351 + 64874;
  D.23355 = D.23354 <= 9;
  D.23356 = D.23353 | D.23355;
  if (D.23356 != 0) goto <D.23347>; else goto <D.23357>;
  <D.23357>:
  D.23328 = bb->last_ins;
  D.23337 = D.23328->opcode;
  D.23338 = D.23337 + 64884;
  if (D.23338 <= 9) goto <D.23347>; else goto <D.23358>;
  <D.23358>:
  D.23328 = bb->last_ins;
  D.23337 = D.23328->opcode;
  if (D.23337 == 446) goto <D.23347>; else goto <D.23359>;
  <D.23359>:
  D.23328 = bb->last_ins;
  D.23337 = D.23328->opcode;
  if (D.23337 == 763) goto <D.23347>; else goto <D.23360>;
  <D.23360>:
  D.23328 = bb->last_ins;
  D.23337 = D.23328->opcode;
  if (D.23337 == 370) goto <D.23347>; else goto <D.23348>;
  <D.23347>:
  D.23328 = bb->last_ins;
  D.23328->opcode = 316;
  D.23328 = bb->last_ins;
  D.23328->dreg = -1;
  D.23328 = bb->last_ins;
  D.23328 = bb->last_ins;
  D.23328 = bb->last_ins;
  D.23328->sreg3 = -1;
  D.23361 = D.23328->sreg3;
  D.23328->sreg2 = D.23361;
  D.23362 = D.23328->sreg2;
  D.23328->sreg1 = D.23362;
  <D.23348>:
  <D.23350>:
  <D.23327>:
  D.23363 = bb->has_call_handler;
  D.23364 = (unsigned char) D.23363;
  D.23365 = bbn->has_call_handler;
  D.23366 = (unsigned char) D.23365;
  D.23367 = D.23364 | D.23366;
  D.23368 = (<unnamed-unsigned:1>) D.23367;
  bb->has_call_handler = D.23368;
  D.23369 = bb->has_jump_table;
  D.23370 = (unsigned char) D.23369;
  D.23371 = bbn->has_jump_table;
  D.23372 = (unsigned char) D.23371;
  D.23373 = D.23370 | D.23372;
  D.23374 = (<unnamed-unsigned:1>) D.23373;
  bb->has_jump_table = D.23374;
  D.23328 = bb->last_ins;
  if (D.23328 != 0B) goto <D.23375>; else goto <D.23376>;
  <D.23375>:
  D.23377 = bbn->code;
  if (D.23377 != 0B) goto <D.23378>; else goto <D.23379>;
  <D.23378>:
  D.23328 = bb->last_ins;
  D.23377 = bbn->code;
  D.23328->next = D.23377;
  D.23377 = bbn->code;
  D.23328 = bb->last_ins;
  D.23377->prev = D.23328;
  D.23380 = bbn->last_ins;
  bb->last_ins = D.23380;
  <D.23379>:
  goto <D.23381>;
  <D.23376>:
  D.23377 = bbn->code;
  bb->code = D.23377;
  D.23380 = bbn->last_ins;
  bb->last_ins = D.23380;
  <D.23381>:
  prev_bb = cfg->bb_entry;
  goto <D.22457>;
  <D.22456>:
  prev_bb = prev_bb->next_bb;
  <D.22457>:
  if (prev_bb != 0B) goto <D.23382>; else goto <D.22458>;
  <D.23382>:
  D.23383 = prev_bb->next_bb;
  if (D.23383 != bbn) goto <D.22456>; else goto <D.22458>;
  <D.22458>:
  if (prev_bb != 0B) goto <D.23384>; else goto <D.23385>;
  <D.23384>:
  D.23386 = bbn->next_bb;
  prev_bb->next_bb = D.23386;
  goto <D.23387>;
  <D.23385>:
  D.23388 = bb->next_bb;
  if (D.23388 == bbn) goto <D.23389>; else goto <D.23390>;
  <D.23389>:
  D.23386 = bbn->next_bb;
  bb->next_bb = D.23386;
  <D.23390>:
  <D.23387>:
  mono_nullify_basic_block (bbn);
  D.23328 = bb->last_ins;
  if (D.23328 != 0B) goto <D.23391>; else goto <D.23392>;
  <D.23391>:
  D.23393 = bb->out_count;
  if (D.23393 == 1) goto <D.23394>; else goto <D.23395>;
  <D.23394>:
  D.23396 = bb->out_bb;
  D.23397 = *D.23396;
  D.23388 = bb->next_bb;
  if (D.23397 != D.23388) goto <D.23398>; else goto <D.23399>;
  <D.23398>:
  D.23328 = bb->last_ins;
  D.23400 = D.23328->opcode;
  D.23401 = D.23400 + 64981;
  D.23402 = D.23401 > 9;
  D.23403 = D.23400 + 64874;
  D.23404 = D.23403 > 9;
  D.23405 = D.23402 & D.23404;
  if (D.23405 != 0) goto <D.23406>; else goto <D.23407>;
  <D.23406>:
  D.23328 = bb->last_ins;
  D.23337 = D.23328->opcode;
  D.23338 = D.23337 + 64884;
  if (D.23338 > 9) goto <D.23408>; else goto <D.23409>;
  <D.23408>:
  D.23328 = bb->last_ins;
  D.23337 = D.23328->opcode;
  if (D.23337 != 446) goto <D.23410>; else goto <D.23411>;
  <D.23410>:
  D.23328 = bb->last_ins;
  D.23337 = D.23328->opcode;
  if (D.23337 != 763) goto <D.23412>; else goto <D.23413>;
  <D.23412>:
  D.23328 = bb->last_ins;
  D.23337 = D.23328->opcode;
  if (D.23337 != 370) goto <D.23414>; else goto <D.23415>;
  <D.23414>:
  D.23416 = cfg->mempool;
  inst = mono_mempool_alloc0 (D.23416, 80);
  inst->opcode = 446;
  inst->dreg = -1;
  inst->sreg3 = -1;
  D.23280 = inst->sreg3;
  inst->sreg2 = D.23280;
  D.23281 = inst->sreg2;
  inst->sreg1 = D.23281;
  D.23417 = cfg->ip;
  inst->cil_code = D.23417;
  D.23396 = bb->out_bb;
  D.23397 = *D.23396;
  inst->data.op[0].target_block = D.23397;
  D.23328 = bb->last_ins;
  if (D.23328 != 0B) goto <D.23418>; else goto <D.23419>;
  <D.23418>:
  D.23328 = bb->last_ins;
  D.23328->next = inst;
  D.23328 = bb->last_ins;
  inst->prev = D.23328;
  bb->last_ins = inst;
  goto <D.23420>;
  <D.23419>:
  bb->last_ins = inst;
  D.23328 = bb->last_ins;
  bb->code = D.23328;
  <D.23420>:
  <D.23415>:
  <D.23413>:
  <D.23411>:
  <D.23409>:
  <D.23407>:
  <D.23399>:
  <D.23395>:
  <D.23392>:
}


mono_remove_bblock (struct MonoCompile * cfg, struct MonoBasicBlock * bb)
{
  struct MonoBasicBlock * D.23422;
  _Bool D.23423;
  long int D.23424;
  long int D.23425;
  struct MonoBasicBlock * D.23428;
  struct MonoBasicBlock * tmp_bb;

  tmp_bb = cfg->bb_entry;
  goto <D.22478>;
  <D.22477>:
  tmp_bb = tmp_bb->next_bb;
  <D.22478>:
  if (tmp_bb != 0B) goto <D.23421>; else goto <D.22479>;
  <D.23421>:
  D.23422 = tmp_bb->next_bb;
  if (D.23422 != bb) goto <D.22477>; else goto <D.22479>;
  <D.22479>:
  D.23423 = tmp_bb == 0B;
  D.23424 = (long int) D.23423;
  D.23425 = __builtin_expect (D.23424, 0);
  if (D.23425 != 0) goto <D.23426>; else goto <D.23427>;
  <D.23426>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "branch-opts.c", 1092, "tmp_bb");
  <D.23427>:
  D.23428 = bb->next_bb;
  tmp_bb->next_bb = D.23428;
}


mono_remove_critical_edges (struct MonoCompile * cfg)
{
  unsigned int D.23429;
  int D.23432;
  struct MonoBasicBlock * * D.23433;
  long unsigned int D.23434;
  long unsigned int D.23435;
  struct MonoBasicBlock * * D.23436;
  struct MonoBasicBlock * D.23437;
  int D.23438;
  short int D.23439;
  int D.23440;
  struct MonoBasicBlock * * D.23441;
  struct MonoBasicBlock * * D.23442;
  struct MonoBasicBlock * D.23443;
  int D.23444;
  short int D.23445;
  int D.23446;
  struct MonoInst * D.23447;
  long unsigned int D.23452;
  long unsigned int D.23453;
  struct MonoBasicBlock * * D.23454;
  short int D.23457;
  struct MonoInst * D.23460;
  short unsigned int D.23462;
  struct MonoMemPool * D.23463;
  unsigned int D.23464;
  unsigned int D.23465;
  unsigned int D.23466;
  int D.23467;
  unsigned int D.23468;
  int D.23469;
  struct MonoBasicBlock * D.23472;
  struct MonoBasicBlock * * D.23475;
  long unsigned int D.23476;
  long unsigned int D.23477;
  struct MonoBasicBlock * * D.23478;
  struct MonoBasicBlock * D.23479;
  int D.23482;
  int D.23483;
  const unsigned char * D.23484;
  struct MonoInst * D.23485;
  unsigned char * D.23489;
  short int D.23490;
  int D.23491;
  unsigned int D.23493;
  unsigned int D.23494;
  int D.23495;
  int D.23496;
  int D.23497;
  struct MonoInst * D.23498;
  unsigned char * D.23502;
  int D.23505;
  void * D.23506;
  struct MonoBasicBlock * * D.23507;
  void * D.23508;
  struct MonoBasicBlock * * D.23509;
  int D.23512;
  int D.23513;
  long unsigned int D.23516;
  long unsigned int D.23517;
  struct MonoBasicBlock * * D.23518;
  struct MonoBasicBlock * D.23519;
  int D.23520;
  struct MonoBasicBlock * * D.23521;
  struct MonoBasicBlock * D.23522;
  int D.23523;
  struct MonoBasicBlock * bb;
  struct MonoBasicBlock * previous_bb;

  D.23429 = cfg->verbose_level;
  if (D.23429 > 3) goto <D.23430>; else goto <D.23431>;
  <D.23430>:
  bb = cfg->bb_entry;
  goto <D.22493>;
  <D.22492>:
  {
    int i;

    D.23432 = bb->block_num;
    printf ("remove_critical_edges, BEFORE BB%d (in:", D.23432);
    i = 0;
    goto <D.22487>;
    <D.22486>:
    D.23433 = bb->in_bb;
    D.23434 = (long unsigned int) i;
    D.23435 = D.23434 * 8;
    D.23436 = D.23433 + D.23435;
    D.23437 = *D.23436;
    D.23438 = D.23437->block_num;
    printf (" %d", D.23438);
    i = i + 1;
    <D.22487>:
    D.23439 = bb->in_count;
    D.23440 = (int) D.23439;
    if (D.23440 > i) goto <D.22486>; else goto <D.22488>;
    <D.22488>:
    printf (") (out:");
    i = 0;
    goto <D.22490>;
    <D.22489>:
    D.23441 = bb->out_bb;
    D.23434 = (long unsigned int) i;
    D.23435 = D.23434 * 8;
    D.23442 = D.23441 + D.23435;
    D.23443 = *D.23442;
    D.23444 = D.23443->block_num;
    printf (" %d", D.23444);
    i = i + 1;
    <D.22490>:
    D.23445 = bb->out_count;
    D.23446 = (int) D.23445;
    if (D.23446 > i) goto <D.22489>; else goto <D.22491>;
    <D.22491>:
    printf (")");
    D.23447 = bb->last_ins;
    if (D.23447 != 0B) goto <D.23448>; else goto <D.23449>;
    <D.23448>:
    printf (" ");
    D.23447 = bb->last_ins;
    mono_print_ins (D.23447);
    <D.23449>:
    printf ("\n");
  }
  bb = bb->next_bb;
  <D.22493>:
  if (bb != 0B) goto <D.22492>; else goto <D.22494>;
  <D.22494>:
  <D.23431>:
  previous_bb = cfg->bb_entry;
  bb = previous_bb->next_bb;
  goto <D.22509>;
  <D.22508>:
  D.23439 = bb->in_count;
  if (D.23439 > 1) goto <D.23450>; else goto <D.23451>;
  <D.23450>:
  {
    int in_bb_index;

    in_bb_index = 0;
    goto <D.22506>;
    <D.22505>:
    {
      struct MonoBasicBlock * in_bb;

      D.23433 = bb->in_bb;
      D.23452 = (long unsigned int) in_bb_index;
      D.23453 = D.23452 * 8;
      D.23454 = D.23433 + D.23453;
      in_bb = *D.23454;
      D.23457 = in_bb->out_count;
      if (D.23457 > 1) goto <D.23455>; else goto <D.23458>;
      <D.23458>:
      D.23457 = in_bb->out_count;
      if (D.23457 == 1) goto <D.23459>; else goto <D.23456>;
      <D.23459>:
      D.23460 = in_bb->last_ins;
      if (D.23460 != 0B) goto <D.23461>; else goto <D.23456>;
      <D.23461>:
      D.23460 = in_bb->last_ins;
      D.23462 = D.23460->opcode;
      if (D.23462 == 763) goto <D.23455>; else goto <D.23456>;
      <D.23455>:
      {
        struct MonoBasicBlock * new_bb;

        D.23463 = cfg->mempool;
        new_bb = mono_mempool_alloc0 (D.23463, 296);
        D.23464 = cfg->num_bblocks;
        D.23465 = D.23464;
        D.23466 = D.23465 + 1;
        cfg->num_bblocks = D.23466;
        D.23467 = (int) D.23465;
        new_bb->block_num = D.23467;
        D.23468 = bb->region;
        new_bb->region = D.23468;
        D.23469 = mono_bb_is_fall_through (cfg, previous_bb);
        if (D.23469 != 0) goto <D.23470>; else goto <D.23471>;
        <D.23470>:
        D.23472 = cfg->bb_entry;
        if (D.23472 != previous_bb) goto <D.23473>; else goto <D.23474>;
        <D.23473>:
        {
          int i;

          i = 0;
          goto <D.22502>;
          <D.22501>:
          D.23475 = previous_bb->out_bb;
          D.23476 = (long unsigned int) i;
          D.23477 = D.23476 * 8;
          D.23478 = D.23475 + D.23477;
          D.23479 = *D.23478;
          if (D.23479 == bb) goto <D.23480>; else goto <D.23481>;
          <D.23480>:
          {
            struct MonoInst * jump;

            D.23463 = cfg->mempool;
            jump = mono_mempool_alloc0 (D.23463, 80);
            jump->opcode = 446;
            jump->dreg = -1;
            jump->sreg3 = -1;
            D.23482 = jump->sreg3;
            jump->sreg2 = D.23482;
            D.23483 = jump->sreg2;
            jump->sreg1 = D.23483;
            D.23484 = cfg->ip;
            jump->cil_code = D.23484;
            D.23485 = previous_bb->last_ins;
            if (D.23485 != 0B) goto <D.23486>; else goto <D.23487>;
            <D.23486>:
            D.23485 = previous_bb->last_ins;
            D.23485->next = jump;
            D.23485 = previous_bb->last_ins;
            jump->prev = D.23485;
            previous_bb->last_ins = jump;
            goto <D.23488>;
            <D.23487>:
            previous_bb->last_ins = jump;
            D.23485 = previous_bb->last_ins;
            previous_bb->code = D.23485;
            <D.23488>:
            D.23489 = previous_bb->cil_code;
            jump->cil_code = D.23489;
            jump->data.op[0].target_block = bb;
            goto <D.22500>;
          }
          <D.23481>:
          i = i + 1;
          <D.22502>:
          D.23490 = previous_bb->out_count;
          D.23491 = (int) D.23490;
          if (D.23491 > i) goto <D.22501>; else goto <D.22500>;
          <D.22500>:
        }
        goto <D.23492>;
        <D.23474>:
        {
          struct MonoInst * jump;
          struct MonoBasicBlock * new_bb_after_entry;

          D.23463 = cfg->mempool;
          new_bb_after_entry = mono_mempool_alloc0 (D.23463, 296);
          D.23464 = cfg->num_bblocks;
          D.23493 = D.23464;
          D.23494 = D.23493 + 1;
          cfg->num_bblocks = D.23494;
          D.23495 = (int) D.23493;
          new_bb_after_entry->block_num = D.23495;
          D.23468 = bb->region;
          new_bb_after_entry->region = D.23468;
          D.23463 = cfg->mempool;
          jump = mono_mempool_alloc0 (D.23463, 80);
          jump->opcode = 446;
          jump->dreg = -1;
          jump->sreg3 = -1;
          D.23496 = jump->sreg3;
          jump->sreg2 = D.23496;
          D.23497 = jump->sreg2;
          jump->sreg1 = D.23497;
          D.23484 = cfg->ip;
          jump->cil_code = D.23484;
          D.23498 = new_bb_after_entry->last_ins;
          if (D.23498 != 0B) goto <D.23499>; else goto <D.23500>;
          <D.23499>:
          D.23498 = new_bb_after_entry->last_ins;
          D.23498->next = jump;
          D.23498 = new_bb_after_entry->last_ins;
          jump->prev = D.23498;
          new_bb_after_entry->last_ins = jump;
          goto <D.23501>;
          <D.23500>:
          new_bb_after_entry->last_ins = jump;
          D.23498 = new_bb_after_entry->last_ins;
          new_bb_after_entry->code = D.23498;
          <D.23501>:
          D.23502 = bb->cil_code;
          jump->cil_code = D.23502;
          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.23429 = cfg->verbose_level;
          if (D.23429 > 2) goto <D.23503>; else goto <D.23504>;
          <D.23503>:
          D.23432 = bb->block_num;
          D.23505 = new_bb_after_entry->block_num;
          printf ("remove_critical_edges, added helper BB%d jumping to BB%d\n", D.23505, D.23432);
          <D.23504>:
        }
        <D.23492>:
        <D.23471>:
        previous_bb->next_bb = new_bb;
        new_bb->next_bb = bb;
        previous_bb = new_bb;
        D.23463 = cfg->mempool;
        D.23506 = mono_mempool_alloc (D.23463, 8);
        new_bb->in_bb = D.23506;
        D.23507 = new_bb->in_bb;
        *D.23507 = in_bb;
        new_bb->in_count = 1;
        D.23463 = cfg->mempool;
        D.23508 = mono_mempool_alloc (D.23463, 8);
        new_bb->out_bb = D.23508;
        D.23509 = new_bb->out_bb;
        *D.23509 = 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.23429 = cfg->verbose_level;
        if (D.23429 > 2) goto <D.23510>; else goto <D.23511>;
        <D.23510>:
        D.23512 = new_bb->block_num;
        D.23432 = bb->block_num;
        D.23513 = in_bb->block_num;
        printf ("remove_critical_edges, removed critical edge from BB%d to BB%d (added BB%d)\n", D.23513, D.23432, D.23512);
        <D.23511>:
      }
      <D.23456>:
    }
    in_bb_index = in_bb_index + 1;
    <D.22506>:
    D.23439 = bb->in_count;
    D.23440 = (int) D.23439;
    if (D.23440 > in_bb_index) goto <D.22505>; else goto <D.22507>;
    <D.22507>:
  }
  <D.23451>:
  previous_bb = previous_bb->next_bb;
  bb = bb->next_bb;
  <D.22509>:
  if (bb != 0B) goto <D.22508>; else goto <D.22510>;
  <D.22510>:
  D.23429 = cfg->verbose_level;
  if (D.23429 > 3) goto <D.23514>; else goto <D.23515>;
  <D.23514>:
  bb = cfg->bb_entry;
  goto <D.22519>;
  <D.22518>:
  {
    int i;

    D.23432 = bb->block_num;
    printf ("remove_critical_edges, AFTER BB%d (in:", D.23432);
    i = 0;
    goto <D.22513>;
    <D.22512>:
    D.23433 = bb->in_bb;
    D.23516 = (long unsigned int) i;
    D.23517 = D.23516 * 8;
    D.23518 = D.23433 + D.23517;
    D.23519 = *D.23518;
    D.23520 = D.23519->block_num;
    printf (" %d", D.23520);
    i = i + 1;
    <D.22513>:
    D.23439 = bb->in_count;
    D.23440 = (int) D.23439;
    if (D.23440 > i) goto <D.22512>; else goto <D.22514>;
    <D.22514>:
    printf (") (out:");
    i = 0;
    goto <D.22516>;
    <D.22515>:
    D.23441 = bb->out_bb;
    D.23516 = (long unsigned int) i;
    D.23517 = D.23516 * 8;
    D.23521 = D.23441 + D.23517;
    D.23522 = *D.23521;
    D.23523 = D.23522->block_num;
    printf (" %d", D.23523);
    i = i + 1;
    <D.22516>:
    D.23445 = bb->out_count;
    D.23446 = (int) D.23445;
    if (D.23446 > i) goto <D.22515>; else goto <D.22517>;
    <D.22517>:
    printf (")");
    D.23447 = bb->last_ins;
    if (D.23447 != 0B) goto <D.23524>; else goto <D.23525>;
    <D.23524>:
    printf (" ");
    D.23447 = bb->last_ins;
    mono_print_ins (D.23447);
    <D.23525>:
    printf ("\n");
  }
  bb = bb->next_bb;
  <D.22519>:
  if (bb != 0B) goto <D.22518>; else goto <D.22520>;
  <D.22520>:
  <D.23515>:
}


mono_bb_is_fall_through (struct MonoCompile * cfg, struct MonoBasicBlock * bb)
{
  gboolean D.23526;
  int iftmp.4;
  struct MonoBasicBlock * D.23531;
  unsigned int D.23533;
  unsigned int D.23534;
  struct MonoInst * D.23536;
  short unsigned int D.23538;
  short unsigned int D.23539;
  _Bool D.23540;
  short unsigned int D.23541;
  _Bool D.23542;
  _Bool D.23543;
  short unsigned int D.23545;
  short unsigned int D.23546;

  D.23531 = bb->next_bb;
  if (D.23531 != 0B) goto <D.23532>; else goto <D.23528>;
  <D.23532>:
  D.23531 = bb->next_bb;
  D.23533 = D.23531->region;
  D.23534 = bb->region;
  if (D.23533 == D.23534) goto <D.23535>; else goto <D.23528>;
  <D.23535>:
  D.23536 = bb->last_ins;
  if (D.23536 == 0B) goto <D.23529>; else goto <D.23537>;
  <D.23537>:
  D.23536 = bb->last_ins;
  D.23538 = D.23536->opcode;
  D.23539 = D.23538 + 64981;
  D.23540 = D.23539 > 9;
  D.23541 = D.23538 + 64874;
  D.23542 = D.23541 > 9;
  D.23543 = D.23540 & D.23542;
  if (D.23543 != 0) goto <D.23544>; else goto <D.23528>;
  <D.23544>:
  D.23536 = bb->last_ins;
  D.23545 = D.23536->opcode;
  D.23546 = D.23545 + 64884;
  if (D.23546 > 9) goto <D.23547>; else goto <D.23528>;
  <D.23547>:
  D.23536 = bb->last_ins;
  D.23545 = D.23536->opcode;
  if (D.23545 != 446) goto <D.23548>; else goto <D.23528>;
  <D.23548>:
  D.23536 = bb->last_ins;
  D.23545 = D.23536->opcode;
  if (D.23545 != 763) goto <D.23549>; else goto <D.23528>;
  <D.23549>:
  D.23536 = bb->last_ins;
  D.23545 = D.23536->opcode;
  if (D.23545 != 370) goto <D.23529>; else goto <D.23528>;
  <D.23529>:
  iftmp.4 = 1;
  goto <D.23530>;
  <D.23528>:
  iftmp.4 = 0;
  <D.23530>:
  D.23526 = iftmp.4;
  return D.23526;
}


replace_out_block (struct MonoBasicBlock * bb, struct MonoBasicBlock * orig, struct MonoBasicBlock * repl)
{
  struct MonoBasicBlock * * D.23551;
  long unsigned int D.23552;
  long unsigned int D.23553;
  struct MonoBasicBlock * * D.23554;
  short int D.23559;
  long unsigned int D.23562;
  long unsigned int D.23563;
  sizetype D.23564;
  struct MonoBasicBlock * * D.23565;
  struct MonoBasicBlock * D.23566;
  short int D.23567;
  unsigned short D.23568;
  unsigned short D.23569;
  short int D.23570;
  int D.23572;
  int i;

  i = 0;
  goto <D.22372>;
  <D.22371>:
  {
    struct MonoBasicBlock * ob;

    D.23551 = bb->out_bb;
    D.23552 = (long unsigned int) i;
    D.23553 = D.23552 * 8;
    D.23554 = D.23551 + D.23553;
    ob = *D.23554;
    if (ob == orig) goto <D.23555>; else goto <D.23556>;
    <D.23555>:
    if (repl == 0B) goto <D.23557>; else goto <D.23558>;
    <D.23557>:
    D.23559 = bb->out_count;
    if (D.23559 > 1) goto <D.23560>; else goto <D.23561>;
    <D.23560>:
    D.23551 = bb->out_bb;
    D.23552 = (long unsigned int) i;
    D.23553 = D.23552 * 8;
    D.23554 = D.23551 + D.23553;
    D.23551 = bb->out_bb;
    D.23559 = bb->out_count;
    D.23562 = (long unsigned int) D.23559;
    D.23563 = D.23562 * 8;
    D.23564 = D.23563 + 18446744073709551608;
    D.23565 = D.23551 + D.23564;
    D.23566 = *D.23565;
    *D.23554 = D.23566;
    <D.23561>:
    D.23559 = bb->out_count;
    D.23567 = D.23559;
    D.23568 = (unsigned short) D.23567;
    D.23569 = D.23568 + 65535;
    D.23570 = (short int) D.23569;
    bb->out_count = D.23570;
    goto <D.23571>;
    <D.23558>:
    D.23551 = bb->out_bb;
    D.23552 = (long unsigned int) i;
    D.23553 = D.23552 * 8;
    D.23554 = D.23551 + D.23553;
    *D.23554 = repl;
    <D.23571>:
    <D.23556>:
  }
  i = i + 1;
  <D.22372>:
  D.23559 = bb->out_count;
  D.23572 = (int) D.23559;
  if (D.23572 > i) goto <D.22371>; else goto <D.22373>;
  <D.22373>:
}


replace_out_block_in_code (struct MonoBasicBlock * bb, struct MonoBasicBlock * orig, struct MonoBasicBlock * repl)
{
  short unsigned int D.23573;
  int D.23574;
  struct MonoBasicBlock * D.23575;
  struct MonoClass * D.23580;
  long int D.23581;
  struct MonoBasicBlock * * D.23582;
  long unsigned int D.23583;
  long unsigned int D.23584;
  struct MonoBasicBlock * * D.23585;
  struct MonoBasicBlock * D.23586;
  short unsigned int D.23592;
  short unsigned int D.23593;
  _Bool D.23594;
  short unsigned int D.23595;
  _Bool D.23596;
  _Bool D.23597;
  short unsigned int D.23599;
  struct MonoBasicBlock * D.23600;
  struct MonoBasicBlock * * D.23603;
  struct MonoBasicBlock * D.23604;
  struct MonoInst * D.23612;
  struct MonoInst * D.23615;
  struct MonoJumpInfoBBTable * iftmp.5;
  struct MonoJumpInfoBBTable * iftmp.6;
  struct MonoJumpInfoBBTable * iftmp.7;
  struct MonoJumpInfoBBTable * iftmp.8;
  struct MonoBasicBlock * * D.23634;
  long unsigned int D.23635;
  long unsigned int D.23636;
  struct MonoBasicBlock * * D.23637;
  struct MonoBasicBlock * D.23638;
  int D.23641;
  struct MonoInst * ins;

  ins = bb->code;
  goto <D.22406>;
  <D.22405>:
  D.23573 = ins->opcode;
  D.23574 = (int) D.23573;
  switch (D.23574) <default: <D.22399>, case 370: <D.22393>, case 446: <D.22390>, case 739: <D.22392>>
  <D.22390>:
  D.23575 = ins->data.op[0].target_block;
  if (D.23575 == orig) goto <D.23576>; else goto <D.23577>;
  <D.23576>:
  ins->data.op[0].target_block = repl;
  <D.23577>:
  goto <D.22391>;
  <D.22392>:
  D.23575 = ins->data.op[0].target_block;
  if (D.23575 == orig) goto <D.23578>; else goto <D.23579>;
  <D.23578>:
  ins->data.op[0].target_block = repl;
  <D.23579>:
  goto <D.22391>;
  <D.22393>:
  {
    int i;
    int n;

    D.23580 = ins->klass;
    D.23581 = (long int) D.23580;
    n = (int) D.23581;
    i = 0;
    goto <D.22397>;
    <D.22396>:
    D.23582 = ins->data.op[1].many_blocks;
    D.23583 = (long unsigned int) i;
    D.23584 = D.23583 * 8;
    D.23585 = D.23582 + D.23584;
    D.23586 = *D.23585;
    if (D.23586 == orig) goto <D.23587>; else goto <D.23588>;
    <D.23587>:
    D.23582 = ins->data.op[1].many_blocks;
    D.23583 = (long unsigned int) i;
    D.23584 = D.23583 * 8;
    D.23585 = D.23582 + D.23584;
    *D.23585 = repl;
    <D.23588>:
    i = i + 1;
    <D.22397>:
    if (i < n) goto <D.22396>; else goto <D.22398>;
    <D.22398>:
    goto <D.22391>;
  }
  <D.22399>:
  D.23592 = ins->opcode;
  D.23593 = D.23592 + 64981;
  D.23594 = D.23593 <= 9;
  D.23595 = D.23592 + 64874;
  D.23596 = D.23595 <= 9;
  D.23597 = D.23594 | D.23596;
  if (D.23597 != 0) goto <D.23589>; else goto <D.23598>;
  <D.23598>:
  D.23573 = ins->opcode;
  D.23599 = D.23573 + 64884;
  if (D.23599 <= 9) goto <D.23589>; else goto <D.23590>;
  <D.23589>:
  D.23582 = ins->data.op[1].many_blocks;
  D.23600 = *D.23582;
  if (D.23600 == orig) goto <D.23601>; else goto <D.23602>;
  <D.23601>:
  D.23582 = ins->data.op[1].many_blocks;
  *D.23582 = repl;
  <D.23602>:
  D.23582 = ins->data.op[1].many_blocks;
  D.23603 = D.23582 + 8;
  D.23604 = *D.23603;
  if (D.23604 == orig) goto <D.23605>; else goto <D.23606>;
  <D.23605>:
  D.23582 = ins->data.op[1].many_blocks;
  D.23603 = D.23582 + 8;
  *D.23603 = repl;
  <D.23606>:
  goto <D.23591>;
  <D.23590>:
  D.23573 = ins->opcode;
  if (D.23573 == 735) goto <D.23607>; else goto <D.23610>;
  <D.23610>:
  D.23573 = ins->opcode;
  if (D.23573 == 736) goto <D.23611>; else goto <D.23608>;
  <D.23611>:
  D.23612 = ins->data.op[1].src;
  if (D.23612 == 8B) goto <D.23607>; else goto <D.23608>;
  <D.23608>:
  D.23573 = ins->opcode;
  if (D.23573 == 370) goto <D.23607>; else goto <D.23613>;
  <D.23613>:
  D.23573 = ins->opcode;
  if (D.23573 == 738) goto <D.23614>; else goto <D.23609>;
  <D.23614>:
  D.23612 = ins->data.op[1].src;
  D.23615 = D.23612->data.op[1].src;
  if (D.23615 == 8B) goto <D.23607>; else goto <D.23609>;
  <D.23607>:
  {
    int i;
    struct MonoJumpInfoBBTable * table;

    D.23573 = ins->opcode;
    if (D.23573 == 735) goto <D.23617>; else goto <D.23618>;
    <D.23617>:
    iftmp.5 = ins->data.op[0].p;
    goto <D.23619>;
    <D.23618>:
    D.23573 = ins->opcode;
    if (D.23573 == 736) goto <D.23623>; else goto <D.23621>;
    <D.23623>:
    D.23612 = ins->data.op[1].src;
    if (D.23612 == 8B) goto <D.23624>; else goto <D.23621>;
    <D.23624>:
    iftmp.6 = ins->data.op[0].p;
    goto <D.23622>;
    <D.23621>:
    D.23573 = ins->opcode;
    if (D.23573 == 370) goto <D.23626>; else goto <D.23627>;
    <D.23626>:
    iftmp.7 = ins->data.op[0].p;
    goto <D.23628>;
    <D.23627>:
    D.23573 = ins->opcode;
    if (D.23573 == 738) goto <D.23632>; else goto <D.23630>;
    <D.23632>:
    D.23612 = ins->data.op[1].src;
    D.23615 = D.23612->data.op[1].src;
    if (D.23615 == 8B) goto <D.23633>; else goto <D.23630>;
    <D.23633>:
    D.23612 = ins->data.op[1].src;
    iftmp.8 = D.23612->data.op[0].p;
    goto <D.23631>;
    <D.23630>:
    iftmp.8 = 0B;
    <D.23631>:
    iftmp.7 = iftmp.8;
    <D.23628>:
    iftmp.6 = iftmp.7;
    <D.23622>:
    iftmp.5 = iftmp.6;
    <D.23619>:
    table = iftmp.5;
    i = 0;
    goto <D.22403>;
    <D.22402>:
    D.23634 = table->table;
    D.23635 = (long unsigned int) i;
    D.23636 = D.23635 * 8;
    D.23637 = D.23634 + D.23636;
    D.23638 = *D.23637;
    if (D.23638 == orig) goto <D.23639>; else goto <D.23640>;
    <D.23639>:
    D.23634 = table->table;
    D.23635 = (long unsigned int) i;
    D.23636 = D.23635 * 8;
    D.23637 = D.23634 + D.23636;
    *D.23637 = repl;
    <D.23640>:
    i = i + 1;
    <D.22403>:
    D.23641 = table->table_size;
    if (D.23641 > i) goto <D.22402>; else goto <D.22404>;
    <D.22404>:
  }
  <D.23609>:
  <D.23591>:
  goto <D.22391>;
  <D.22391>:
  ins = ins->next;
  <D.22406>:
  if (ins != 0B) goto <D.22405>; else goto <D.22407>;
  <D.22407>:
}


replace_in_block (struct MonoBasicBlock * bb, struct MonoBasicBlock * orig, struct MonoBasicBlock * repl)
{
  struct MonoBasicBlock * * D.23642;
  long unsigned int D.23643;
  long unsigned int D.23644;
  struct MonoBasicBlock * * D.23645;
  short int D.23650;
  long unsigned int D.23653;
  long unsigned int D.23654;
  sizetype D.23655;
  struct MonoBasicBlock * * D.23656;
  struct MonoBasicBlock * D.23657;
  short int D.23658;
  unsigned short D.23659;
  unsigned short D.23660;
  short int D.23661;
  int D.23663;
  int i;

  i = 0;
  goto <D.22382>;
  <D.22381>:
  {
    struct MonoBasicBlock * ib;

    D.23642 = bb->in_bb;
    D.23643 = (long unsigned int) i;
    D.23644 = D.23643 * 8;
    D.23645 = D.23642 + D.23644;
    ib = *D.23645;
    if (ib == orig) goto <D.23646>; else goto <D.23647>;
    <D.23646>:
    if (repl == 0B) goto <D.23648>; else goto <D.23649>;
    <D.23648>:
    D.23650 = bb->in_count;
    if (D.23650 > 1) goto <D.23651>; else goto <D.23652>;
    <D.23651>:
    D.23642 = bb->in_bb;
    D.23643 = (long unsigned int) i;
    D.23644 = D.23643 * 8;
    D.23645 = D.23642 + D.23644;
    D.23642 = bb->in_bb;
    D.23650 = bb->in_count;
    D.23653 = (long unsigned int) D.23650;
    D.23654 = D.23653 * 8;
    D.23655 = D.23654 + 18446744073709551608;
    D.23656 = D.23642 + D.23655;
    D.23657 = *D.23656;
    *D.23645 = D.23657;
    <D.23652>:
    D.23650 = bb->in_count;
    D.23658 = D.23650;
    D.23659 = (unsigned short) D.23658;
    D.23660 = D.23659 + 65535;
    D.23661 = (short int) D.23660;
    bb->in_count = D.23661;
    goto <D.23662>;
    <D.23649>:
    D.23642 = bb->in_bb;
    D.23643 = (long unsigned int) i;
    D.23644 = D.23643 * 8;
    D.23645 = D.23642 + D.23644;
    *D.23645 = repl;
    <D.23662>:
    <D.23647>:
  }
  i = i + 1;
  <D.22382>:
  D.23650 = bb->in_count;
  D.23663 = (int) D.23650;
  if (D.23663 > i) goto <D.22381>; else goto <D.22383>;
  <D.22383>:
}


mono_optimize_branches (struct MonoCompile * cfg)
{
  unsigned int D.23664;
  struct MonoBasicBlock * D.23668;
  unsigned int D.23669;
  unsigned char D.23672;
  unsigned char D.23673;
  int D.23676;
  short int D.23681;
  struct MonoBasicBlock * D.23684;
  unsigned int D.23687;
  unsigned int D.23690;
  int D.23693;
  struct MonoBasicBlock * D.23694;
  struct MonoBasicBlock * * D.23695;
  long unsigned int D.23696;
  long unsigned int D.23697;
  struct MonoBasicBlock * * D.23698;
  struct MonoBasicBlock * D.23699;
  short int D.23700;
  int D.23701;
  short int D.23702;
  struct MonoBasicBlock * * D.23705;
  struct MonoInst * D.23708;
  short unsigned int D.23711;
  short unsigned int D.23714;
  short unsigned int D.23715;
  _Bool D.23716;
  short unsigned int D.23717;
  _Bool D.23718;
  _Bool D.23719;
  short unsigned int D.23721;
  struct MonoBasicBlock * * D.23722;
  struct MonoBasicBlock * D.23723;
  int D.23726;
  int D.23727;
  struct MonoBasicBlock * D.23730;
  unsigned char D.23737;
  unsigned char D.23738;
  unsigned char D.23745;
  struct MonoInst * D.23770;
  short unsigned int D.23773;
  struct MonoBasicBlock * D.23776;
  unsigned int D.23779;
  int D.23784;
  short unsigned int D.23794;
  short unsigned int D.23795;
  _Bool D.23796;
  short unsigned int D.23797;
  _Bool D.23798;
  _Bool D.23799;
  short unsigned int D.23801;
  struct MonoInst * D.23804;
  struct MonoInst * D.23806;
  unsigned char D.23807;
  unsigned char D.23808;
  int D.23809;
  int D.23810;
  int D.23814;
  int D.23837;
  struct MonoBasicBlock * * D.23838;
  struct MonoBasicBlock * D.23839;
  unsigned char D.23858;
  unsigned char D.23859;
  int D.23868;
  struct MonoBasicBlock * * D.23871;
  struct MonoBasicBlock * D.23872;
  _Bool D.23873;
  long int D.23874;
  long int D.23875;
  short unsigned int D.23886;
  short unsigned int D.23887;
  _Bool D.23888;
  short unsigned int D.23889;
  _Bool D.23890;
  _Bool D.23891;
  unsigned char D.23898;
  unsigned char D.23899;
  unsigned int D.23902;
  unsigned char D.23905;
  unsigned char D.23906;
  unsigned int D.23909;
  unsigned int D.23910;
  short unsigned int D.23911;
  _Bool D.23914;
  _Bool D.23915;
  _Bool D.23916;
  int i;
  int changed;
  struct MonoBasicBlock * bb;
  struct MonoBasicBlock * bbn;
  guint32 niterations;

  changed = 0;
  D.23664 = cfg->num_bblocks;
  if (D.23664 > 1000) goto <D.23665>; else goto <D.23666>;
  <D.23665>:
  D.23664 = cfg->num_bblocks;
  niterations = D.23664 * 2;
  goto <D.23667>;
  <D.23666>:
  niterations = 1000;
  <D.23667>:
  <D.22543>:
  {
    struct MonoBasicBlock * previous_bb;

    changed = 0;
    niterations = niterations + 4294967295;
    previous_bb = cfg->bb_entry;
    D.23668 = cfg->bb_entry;
    bb = D.23668->next_bb;
    goto <D.22541>;
    <D.22540>:
    D.23669 = bb->region;
    if (D.23669 != 4294967295) goto <D.23670>; else goto <D.23671>;
    <D.23670>:
    // predicted unlikely by continue predictor.
    goto <D.22530>;
    <D.23671>:
    D.23672 = BIT_FIELD_REF <*bb, 8, 1488>;
    D.23673 = D.23672 & 2;
    if (D.23673 == 0) goto <D.23674>; else goto <D.23675>;
    <D.23674>:
    D.23676 = remove_block_if_useless (cfg, bb, previous_bb);
    if (D.23676 != 0) goto <D.23677>; else goto <D.23678>;
    <D.23677>:
    changed = 1;
    // predicted unlikely by continue predictor.
    goto <D.22530>;
    <D.23678>:
    <D.23675>:
    bbn = bb->next_bb;
    if (bbn != 0B) goto <D.23679>; else goto <D.23680>;
    <D.23679>:
    D.23681 = bbn->in_count;
    if (D.23681 == 0) goto <D.23682>; else goto <D.23683>;
    <D.23682>:
    D.23684 = cfg->bb_exit;
    if (D.23684 != bbn) goto <D.23685>; else goto <D.23686>;
    <D.23685>:
    D.23669 = bb->region;
    D.23687 = bbn->region;
    if (D.23669 == D.23687) goto <D.23688>; else goto <D.23689>;
    <D.23688>:
    D.23690 = cfg->verbose_level;
    if (D.23690 > 2) goto <D.23691>; else goto <D.23692>;
    <D.23691>:
    D.23693 = bbn->block_num;
    monoeg_g_print ("nullify block triggered %d\n", D.23693);
    <D.23692>:
    D.23694 = bbn->next_bb;
    bb->next_bb = D.23694;
    i = 0;
    goto <D.22532>;
    <D.22531>:
    D.23695 = bbn->out_bb;
    D.23696 = (long unsigned int) i;
    D.23697 = D.23696 * 8;
    D.23698 = D.23695 + D.23697;
    D.23699 = *D.23698;
    replace_in_block (D.23699, bbn, 0B);
    i = i + 1;
    <D.22532>:
    D.23700 = bbn->out_count;
    D.23701 = (int) D.23700;
    if (D.23701 > i) goto <D.22531>; else goto <D.22533>;
    <D.22533>:
    mono_nullify_basic_block (bbn);
    changed = 1;
    <D.23689>:
    <D.23686>:
    <D.23683>:
    <D.23680>:
    D.23702 = bb->out_count;
    if (D.23702 == 1) goto <D.23703>; else goto <D.23704>;
    <D.23703>:
    D.23705 = bb->out_bb;
    bbn = *D.23705;
    D.23708 = bb->last_ins;
    if (D.23708 != 0B) goto <D.23709>; else goto <D.23710>;
    <D.23709>:
    D.23708 = bb->last_ins;
    D.23711 = D.23708->opcode;
    if (D.23711 != 446) goto <D.23712>; else goto <D.23713>;
    <D.23712>:
    D.23708 = bb->last_ins;
    D.23714 = D.23708->opcode;
    D.23715 = D.23714 + 64981;
    D.23716 = D.23715 <= 9;
    D.23717 = D.23714 + 64874;
    D.23718 = D.23717 <= 9;
    D.23719 = D.23716 | D.23718;
    if (D.23719 != 0) goto <D.23706>; else goto <D.23720>;
    <D.23720>:
    D.23708 = bb->last_ins;
    D.23711 = D.23708->opcode;
    D.23721 = D.23711 + 64884;
    if (D.23721 <= 9) goto <D.23706>; else goto <D.23707>;
    <D.23706>:
    D.23708 = bb->last_ins;
    D.23708->opcode = 446;
    D.23708 = bb->last_ins;
    D.23708 = bb->last_ins;
    D.23722 = D.23708->data.op[1].many_blocks;
    D.23723 = *D.23722;
    D.23708->data.op[0].target_block = D.23723;
    changed = 1;
    D.23690 = cfg->verbose_level;
    if (D.23690 > 2) goto <D.23724>; else goto <D.23725>;
    <D.23724>:
    D.23702 = bb->out_count;
    D.23726 = (int) D.23702;
    D.23727 = bb->block_num;
    monoeg_g_print ("cond branch removal triggered in %d %d\n", D.23727, D.23726);
    <D.23725>:
    <D.23707>:
    <D.23713>:
    <D.23710>:
    D.23669 = bb->region;
    D.23687 = bbn->region;
    if (D.23669 == D.23687) goto <D.23728>; else goto <D.23729>;
    <D.23728>:
    D.23730 = bb->next_bb;
    if (D.23730 == bbn) goto <D.23731>; else goto <D.23732>;
    <D.23731>:
    D.23708 = bb->last_ins;
    if (D.23708 != 0B) goto <D.23733>; else goto <D.23734>;
    <D.23733>:
    D.23708 = bb->last_ins;
    D.23711 = D.23708->opcode;
    if (D.23711 == 446) goto <D.23735>; else goto <D.23736>;
    <D.23735>:
    D.23737 = BIT_FIELD_REF <*bbn, 8, 1488>;
    D.23738 = D.23737 & 1;
    if (D.23738 == 0) goto <D.23739>; else goto <D.23740>;
    <D.23739>:
    D.23708 = bb->last_ins;
    D.23708->opcode = 316;
    changed = 1;
    D.23690 = cfg->verbose_level;
    if (D.23690 > 2) goto <D.23741>; else goto <D.23742>;
    <D.23741>:
    D.23693 = bbn->block_num;
    D.23727 = bb->block_num;
    monoeg_g_print ("br removal triggered %d -> %d\n", D.23727, D.23693);
    <D.23742>:
    <D.23740>:
    <D.23736>:
    <D.23734>:
    D.23681 = bbn->in_count;
    if (D.23681 == 1) goto <D.23743>; else goto <D.23744>;
    <D.23743>:
    D.23672 = BIT_FIELD_REF <*bb, 8, 1488>;
    D.23745 = D.23672 & 8;
    if (D.23745 == 0) goto <D.23746>; else goto <D.23747>;
    <D.23746>:
    D.23684 = cfg->bb_exit;
    if (D.23684 != bbn) goto <D.23748>; else goto <D.23749>;
    <D.23748>:
    D.23690 = cfg->verbose_level;
    if (D.23690 > 2) goto <D.23750>; else goto <D.23751>;
    <D.23750>:
    D.23693 = bbn->block_num;
    D.23727 = bb->block_num;
    monoeg_g_print ("block merge triggered %d -> %d\n", D.23727, D.23693);
    <D.23751>:
    mono_merge_basic_blocks (cfg, bb, bbn);
    changed = 1;
    // predicted unlikely by continue predictor.
    goto <D.22530>;
    <D.23749>:
    <D.23747>:
    <D.23744>:
    <D.23732>:
    <D.23729>:
    <D.23704>:
    bbn = bb->next_bb;
    if (bbn != 0B) goto <D.23752>; else goto <D.23753>;
    <D.23752>:
    D.23681 = bbn->in_count;
    if (D.23681 == 0) goto <D.23754>; else goto <D.23755>;
    <D.23754>:
    D.23684 = cfg->bb_exit;
    if (D.23684 != bbn) goto <D.23756>; else goto <D.23757>;
    <D.23756>:
    D.23669 = bb->region;
    D.23687 = bbn->region;
    if (D.23669 == D.23687) goto <D.23758>; else goto <D.23759>;
    <D.23758>:
    D.23690 = cfg->verbose_level;
    if (D.23690 > 2) goto <D.23760>; else goto <D.23761>;
    <D.23760>:
    D.23693 = bbn->block_num;
    monoeg_g_print ("nullify block triggered %d\n", D.23693);
    <D.23761>:
    D.23694 = bbn->next_bb;
    bb->next_bb = D.23694;
    i = 0;
    goto <D.22535>;
    <D.22534>:
    D.23695 = bbn->out_bb;
    D.23696 = (long unsigned int) i;
    D.23697 = D.23696 * 8;
    D.23698 = D.23695 + D.23697;
    D.23699 = *D.23698;
    replace_in_block (D.23699, bbn, 0B);
    i = i + 1;
    <D.22535>:
    D.23700 = bbn->out_count;
    D.23701 = (int) D.23700;
    if (D.23701 > i) goto <D.22534>; else goto <D.22536>;
    <D.22536>:
    mono_nullify_basic_block (bbn);
    changed = 1;
    // predicted unlikely by continue predictor.
    goto <D.22530>;
    <D.23759>:
    <D.23757>:
    <D.23755>:
    <D.23753>:
    D.23702 = bb->out_count;
    if (D.23702 == 1) goto <D.23762>; else goto <D.23763>;
    <D.23762>:
    D.23705 = bb->out_bb;
    bbn = *D.23705;
    D.23708 = bb->last_ins;
    if (D.23708 != 0B) goto <D.23764>; else goto <D.23765>;
    <D.23764>:
    D.23708 = bb->last_ins;
    D.23711 = D.23708->opcode;
    if (D.23711 == 446) goto <D.23766>; else goto <D.23767>;
    <D.23766>:
    D.23708 = bb->last_ins;
    bbn = D.23708->data.op[0].target_block;
    D.23669 = bb->region;
    D.23687 = bbn->region;
    if (D.23669 == D.23687) goto <D.23768>; else goto <D.23769>;
    <D.23768>:
    D.23770 = bbn->code;
    if (D.23770 != 0B) goto <D.23771>; else goto <D.23772>;
    <D.23771>:
    D.23770 = bbn->code;
    D.23773 = D.23770->opcode;
    if (D.23773 == 446) goto <D.23774>; else goto <D.23775>;
    <D.23774>:
    D.23770 = bbn->code;
    D.23776 = D.23770->data.op[0].target_block;
    if (D.23776 != bbn) goto <D.23777>; else goto <D.23778>;
    <D.23777>:
    D.23770 = bbn->code;
    D.23776 = D.23770->data.op[0].target_block;
    D.23779 = D.23776->region;
    D.23669 = bb->region;
    if (D.23779 == D.23669) goto <D.23780>; else goto <D.23781>;
    <D.23780>:
    D.23690 = cfg->verbose_level;
    if (D.23690 > 2) goto <D.23782>; else goto <D.23783>;
    <D.23782>:
    D.23770 = bbn->code;
    D.23776 = D.23770->data.op[0].target_block;
    D.23784 = D.23776->block_num;
    D.23693 = bbn->block_num;
    D.23727 = bb->block_num;
    monoeg_g_print ("branch to branch triggered %d -> %d -> %d\n", D.23727, D.23693, D.23784);
    <D.23783>:
    replace_in_block (bbn, bb, 0B);
    D.23770 = bbn->code;
    D.23776 = D.23770->data.op[0].target_block;
    replace_out_block (bb, bbn, D.23776);
    D.23770 = bbn->code;
    D.23776 = D.23770->data.op[0].target_block;
    mono_link_bblock (cfg, bb, D.23776);
    D.23708 = bb->last_ins;
    D.23770 = bbn->code;
    D.23776 = D.23770->data.op[0].target_block;
    D.23708->data.op[0].target_block = D.23776;
    changed = 1;
    // predicted unlikely by continue predictor.
    goto <D.22530>;
    <D.23781>:
    <D.23778>:
    <D.23775>:
    <D.23772>:
    <D.23769>:
    <D.23767>:
    <D.23765>:
    goto <D.23785>;
    <D.23763>:
    D.23702 = bb->out_count;
    if (D.23702 == 2) goto <D.23786>; else goto <D.23787>;
    <D.23786>:
    D.23708 = bb->last_ins;
    if (D.23708 != 0B) goto <D.23792>; else goto <D.23793>;
    <D.23792>:
    D.23708 = bb->last_ins;
    D.23794 = D.23708->opcode;
    D.23795 = D.23794 + 64981;
    D.23796 = D.23795 <= 9;
    D.23797 = D.23794 + 64874;
    D.23798 = D.23797 <= 9;
    D.23799 = D.23796 | D.23798;
    if (D.23799 != 0) goto <D.23790>; else goto <D.23800>;
    <D.23800>:
    D.23708 = bb->last_ins;
    D.23711 = D.23708->opcode;
    D.23721 = D.23711 + 64884;
    if (D.23721 <= 9) goto <D.23790>; else goto <D.23791>;
    <D.23790>:
    D.23708 = bb->last_ins;
    D.23711 = D.23708->opcode;
    D.23801 = D.23711 + 64874;
    if (D.23801 > 9) goto <D.23802>; else goto <D.23803>;
    <D.23802>:
    D.23708 = bb->last_ins;
    D.23804 = D.23708->data.op[0].src;
    if (D.23804 == 0B) goto <D.23788>; else goto <D.23805>;
    <D.23805>:
    D.23708 = bb->last_ins;
    D.23804 = D.23708->data.op[0].src;
    D.23806 = D.23804->data.op[0].src;
    D.23807 = D.23806->type;
    if (D.23807 != 4) goto <D.23788>; else goto <D.23789>;
    <D.23788>:
    {
      int branch_result;
      struct MonoBasicBlock * taken_branch_target;
      struct MonoBasicBlock * untaken_branch_target;

      taken_branch_target = 0B;
      untaken_branch_target = 0B;
      D.23708 = bb->last_ins;
      D.23808 = D.23708->flags;
      D.23809 = (int) D.23808;
      D.23810 = D.23809 & 8;
      if (D.23810 != 0) goto <D.23811>; else goto <D.23812>;
      <D.23811>:
      branch_result = 1;
      goto <D.23813>;
      <D.23812>:
      D.23708 = bb->last_ins;
      D.23808 = D.23708->flags;
      D.23809 = (int) D.23808;
      D.23814 = D.23809 & 16;
      if (D.23814 != 0) goto <D.23815>; else goto <D.23816>;
      <D.23815>:
      branch_result = 0;
      goto <D.23817>;
      <D.23816>:
      branch_result = 2;
      <D.23817>:
      <D.23813>:
      if (branch_result == 1) goto <D.23818>; else goto <D.23819>;
      <D.23818>:
      D.23708 = bb->last_ins;
      D.23722 = D.23708->data.op[1].many_blocks;
      taken_branch_target = *D.23722;
      D.23708 = bb->last_ins;
      D.23722 = D.23708->data.op[1].many_blocks;
      untaken_branch_target = MEM[(struct MonoBasicBlock * *)D.23722 + 8B];
      goto <D.23820>;
      <D.23819>:
      if (branch_result == 0) goto <D.23821>; else goto <D.23822>;
      <D.23821>:
      D.23708 = bb->last_ins;
      D.23722 = D.23708->data.op[1].many_blocks;
      taken_branch_target = MEM[(struct MonoBasicBlock * *)D.23722 + 8B];
      D.23708 = bb->last_ins;
      D.23722 = D.23708->data.op[1].many_blocks;
      untaken_branch_target = *D.23722;
      <D.23822>:
      <D.23820>:
      if (taken_branch_target != 0B) goto <D.23823>; else goto <D.23824>;
      <D.23823>:
      D.23708 = bb->last_ins;
      D.23708->opcode = 446;
      D.23708 = bb->last_ins;
      D.23708->data.op[0].target_block = taken_branch_target;
      D.23672 = BIT_FIELD_REF <*bb, 8, 1488>;
      D.23745 = D.23672 & 8;
      if (D.23745 == 0) goto <D.23825>; else goto <D.23826>;
      <D.23825>:
      mono_unlink_bblock (cfg, bb, untaken_branch_target);
      <D.23826>:
      changed = 1;
      // predicted unlikely by continue predictor.
      goto <D.22530>;
      <D.23824>:
      D.23708 = bb->last_ins;
      D.23722 = D.23708->data.op[1].many_blocks;
      bbn = *D.23722;
      D.23669 = bb->region;
      D.23687 = bbn->region;
      if (D.23669 == D.23687) goto <D.23827>; else goto <D.23828>;
      <D.23827>:
      D.23770 = bbn->code;
      if (D.23770 != 0B) goto <D.23829>; else goto <D.23830>;
      <D.23829>:
      D.23770 = bbn->code;
      D.23773 = D.23770->opcode;
      if (D.23773 == 446) goto <D.23831>; else goto <D.23832>;
      <D.23831>:
      D.23770 = bbn->code;
      D.23776 = D.23770->data.op[0].target_block;
      D.23779 = D.23776->region;
      D.23669 = bb->region;
      if (D.23779 == D.23669) goto <D.23833>; else goto <D.23834>;
      <D.23833>:
      D.23690 = cfg->verbose_level;
      if (D.23690 > 2) goto <D.23835>; else goto <D.23836>;
      <D.23835>:
      D.23770 = bbn->code;
      D.23773 = D.23770->opcode;
      D.23837 = (int) D.23773;
      D.23770 = bbn->code;
      D.23776 = D.23770->data.op[0].target_block;
      D.23784 = D.23776->block_num;
      D.23693 = bbn->block_num;
      D.23727 = bb->block_num;
      monoeg_g_print ("cbranch1 to branch triggered %d -> (%d) %d (0x%02x)\n", D.23727, D.23693, D.23784, D.23837);
      <D.23836>:
      D.23708 = bb->last_ins;
      D.23722 = D.23708->data.op[1].many_blocks;
      D.23723 = *D.23722;
      mono_unlink_bblock (cfg, bb, D.23723);
      D.23708 = bb->last_ins;
      D.23722 = D.23708->data.op[1].many_blocks;
      D.23838 = D.23722 + 8;
      D.23839 = *D.23838;
      mono_unlink_bblock (cfg, bb, D.23839);
      D.23708 = bb->last_ins;
      D.23722 = D.23708->data.op[1].many_blocks;
      D.23770 = bbn->code;
      D.23776 = D.23770->data.op[0].target_block;
      *D.23722 = D.23776;
      D.23708 = bb->last_ins;
      D.23722 = D.23708->data.op[1].many_blocks;
      D.23723 = *D.23722;
      mono_link_bblock (cfg, bb, D.23723);
      D.23708 = bb->last_ins;
      D.23722 = D.23708->data.op[1].many_blocks;
      D.23838 = D.23722 + 8;
      D.23839 = *D.23838;
      mono_link_bblock (cfg, bb, D.23839);
      changed = 1;
      // predicted unlikely by continue predictor.
      goto <D.22530>;
      <D.23834>:
      <D.23832>:
      <D.23830>:
      <D.23828>:
      D.23708 = bb->last_ins;
      D.23722 = D.23708->data.op[1].many_blocks;
      bbn = MEM[(struct MonoBasicBlock * *)D.23722 + 8B];
      if (bbn != 0B) goto <D.23840>; else goto <D.23841>;
      <D.23840>:
      D.23669 = bb->region;
      D.23687 = bbn->region;
      if (D.23669 == D.23687) goto <D.23842>; else goto <D.23843>;
      <D.23842>:
      D.23770 = bbn->code;
      if (D.23770 != 0B) goto <D.23844>; else goto <D.23845>;
      <D.23844>:
      D.23770 = bbn->code;
      D.23773 = D.23770->opcode;
      if (D.23773 == 446) goto <D.23846>; else goto <D.23847>;
      <D.23846>:
      D.23770 = bbn->code;
      D.23776 = D.23770->data.op[0].target_block;
      D.23779 = D.23776->region;
      D.23669 = bb->region;
      if (D.23779 == D.23669) goto <D.23848>; else goto <D.23849>;
      <D.23848>:
      D.23690 = cfg->verbose_level;
      if (D.23690 > 2) goto <D.23850>; else goto <D.23851>;
      <D.23850>:
      D.23770 = bbn->code;
      D.23773 = D.23770->opcode;
      D.23837 = (int) D.23773;
      D.23770 = bbn->code;
      D.23776 = D.23770->data.op[0].target_block;
      D.23784 = D.23776->block_num;
      D.23693 = bbn->block_num;
      D.23727 = bb->block_num;
      monoeg_g_print ("cbranch2 to branch triggered %d -> (%d) %d (0x%02x)\n", D.23727, D.23693, D.23784, D.23837);
      <D.23851>:
      D.23708 = bb->last_ins;
      D.23722 = D.23708->data.op[1].many_blocks;
      D.23723 = *D.23722;
      mono_unlink_bblock (cfg, bb, D.23723);
      D.23708 = bb->last_ins;
      D.23722 = D.23708->data.op[1].many_blocks;
      D.23838 = D.23722 + 8;
      D.23839 = *D.23838;
      mono_unlink_bblock (cfg, bb, D.23839);
      D.23708 = bb->last_ins;
      D.23722 = D.23708->data.op[1].many_blocks;
      D.23838 = D.23722 + 8;
      D.23770 = bbn->code;
      D.23776 = D.23770->data.op[0].target_block;
      *D.23838 = D.23776;
      D.23708 = bb->last_ins;
      D.23722 = D.23708->data.op[1].many_blocks;
      D.23723 = *D.23722;
      mono_link_bblock (cfg, bb, D.23723);
      D.23708 = bb->last_ins;
      D.23722 = D.23708->data.op[1].many_blocks;
      D.23838 = D.23722 + 8;
      D.23839 = *D.23838;
      mono_link_bblock (cfg, bb, D.23839);
      changed = 1;
      // predicted unlikely by continue predictor.
      goto <D.22530>;
      <D.23849>:
      <D.23847>:
      <D.23845>:
      <D.23843>:
      <D.23841>:
      D.23708 = bb->last_ins;
      D.23722 = D.23708->data.op[1].many_blocks;
      bbn = MEM[(struct MonoBasicBlock * *)D.23722 + 8B];
      if (bbn != 0B) goto <D.23852>; else goto <D.23853>;
      <D.23852>:
      D.23669 = bb->region;
      D.23687 = bbn->region;
      if (D.23669 == D.23687) goto <D.23854>; else goto <D.23855>;
      <D.23854>:
      D.23681 = bbn->in_count;
      if (D.23681 == 1) goto <D.23856>; else goto <D.23857>;
      <D.23856>:
      D.23858 = BIT_FIELD_REF <*cfg, 8, 5600>;
      D.23859 = D.23858 & 8;
      if (D.23859 != 0) goto <D.23860>; else goto <D.23861>;
      <D.23860>:
      D.23684 = cfg->bb_exit;
      if (D.23684 != bbn) goto <D.23862>; else goto <D.23863>;
      <D.23862>:
      D.23672 = BIT_FIELD_REF <*bb, 8, 1488>;
      D.23745 = D.23672 & 8;
      if (D.23745 == 0) goto <D.23864>; else goto <D.23865>;
      <D.23864>:
      D.23737 = BIT_FIELD_REF <*bbn, 8, 1488>;
      D.23738 = D.23737 & 1;
      if (D.23738 == 0) goto <D.23866>; else goto <D.23867>;
      <D.23866>:
      D.23868 = mono_bblocks_linked (bbn, bb);
      if (D.23868 == 0) goto <D.23869>; else goto <D.23870>;
      <D.23869>:
      D.23871 = bbn->in_bb;
      D.23872 = *D.23871;
      D.23873 = D.23872 != bb;
      D.23874 = (long int) D.23873;
      D.23875 = __builtin_expect (D.23874, 0);
      if (D.23875 != 0) goto <D.23876>; else goto <D.23877>;
      <D.23876>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "branch-opts.c", 1432, "bbn->in_bb [0] == bb");
      <D.23877>:
      D.23690 = cfg->verbose_level;
      if (D.23690 > 2) goto <D.23878>; else goto <D.23879>;
      <D.23878>:
      D.23693 = bbn->block_num;
      D.23727 = bb->block_num;
      monoeg_g_print ("merge false branch target triggered BB%d -> BB%d\n", D.23727, D.23693);
      <D.23879>:
      mono_merge_basic_blocks (cfg, bb, bbn);
      changed = 1;
      // predicted unlikely by continue predictor.
      goto <D.22530>;
      <D.23870>:
      <D.23867>:
      <D.23865>:
      <D.23863>:
      <D.23861>:
      <D.23857>:
      <D.23855>:
      <D.23853>:
    }
    <D.23789>:
    <D.23803>:
    <D.23791>:
    <D.23793>:
    D.23708 = bb->last_ins;
    if (D.23708 != 0B) goto <D.23884>; else goto <D.23885>;
    <D.23884>:
    D.23708 = bb->last_ins;
    D.23886 = D.23708->opcode;
    D.23887 = D.23886 + 64981;
    D.23888 = D.23887 <= 9;
    D.23889 = D.23886 + 64874;
    D.23890 = D.23889 <= 9;
    D.23891 = D.23888 | D.23890;
    if (D.23891 != 0) goto <D.23882>; else goto <D.23892>;
    <D.23892>:
    D.23708 = bb->last_ins;
    D.23711 = D.23708->opcode;
    D.23721 = D.23711 + 64884;
    if (D.23721 <= 9) goto <D.23882>; else goto <D.23883>;
    <D.23882>:
    D.23708 = bb->last_ins;
    D.23711 = D.23708->opcode;
    D.23801 = D.23711 + 64874;
    if (D.23801 > 9) goto <D.23893>; else goto <D.23894>;
    <D.23893>:
    D.23708 = bb->last_ins;
    D.23804 = D.23708->data.op[0].src;
    if (D.23804 == 0B) goto <D.23880>; else goto <D.23895>;
    <D.23895>:
    D.23708 = bb->last_ins;
    D.23804 = D.23708->data.op[0].src;
    D.23806 = D.23804->data.op[0].src;
    D.23807 = D.23806->type;
    if (D.23807 != 4) goto <D.23880>; else goto <D.23881>;
    <D.23880>:
    D.23708 = bb->last_ins;
    D.23722 = D.23708->data.op[1].many_blocks;
    D.23838 = D.23722 + 8;
    D.23839 = *D.23838;
    if (D.23839 != 0B) goto <D.23896>; else goto <D.23897>;
    <D.23896>:
    D.23708 = bb->last_ins;
    D.23722 = D.23708->data.op[1].many_blocks;
    D.23838 = D.23722 + 8;
    D.23839 = *D.23838;
    D.23898 = BIT_FIELD_REF <*D.23839, 8, 1488>;
    D.23899 = D.23898 & 1;
    if (D.23899 != 0) goto <D.23900>; else goto <D.23901>;
    <D.23900>:
    D.23669 = bb->region;
    D.23708 = bb->last_ins;
    D.23722 = D.23708->data.op[1].many_blocks;
    D.23838 = D.23722 + 8;
    D.23839 = *D.23838;
    D.23902 = D.23839->region;
    if (D.23669 == D.23902) goto <D.23903>; else goto <D.23904>;
    <D.23903>:
    D.23905 = BIT_FIELD_REF <*cfg, 8, 5624>;
    D.23906 = D.23905 & 1;
    if (D.23906 == 0) goto <D.23907>; else goto <D.23908>;
    <D.23907>:
    D.23708 = bb->last_ins;
    D.23708 = bb->last_ins;
    D.23711 = D.23708->opcode;
    D.23909 = (unsigned int) D.23711;
    D.23910 = mono_reverse_branch_op (D.23909);
    D.23911 = (short unsigned int) D.23910;
    D.23708->opcode = D.23911;
    D.23708 = bb->last_ins;
    D.23722 = D.23708->data.op[1].many_blocks;
    bbn = MEM[(struct MonoBasicBlock * *)D.23722 + 8B];
    D.23708 = bb->last_ins;
    D.23722 = D.23708->data.op[1].many_blocks;
    D.23838 = D.23722 + 8;
    D.23708 = bb->last_ins;
    D.23722 = D.23708->data.op[1].many_blocks;
    D.23723 = *D.23722;
    *D.23838 = D.23723;
    D.23708 = bb->last_ins;
    D.23722 = D.23708->data.op[1].many_blocks;
    *D.23722 = bbn;
    D.23708 = bb->last_ins;
    D.23722 = D.23708->data.op[1].many_blocks;
    D.23723 = *D.23722;
    move_basic_block_to_end (cfg, D.23723);
    D.23690 = cfg->verbose_level;
    if (D.23690 > 2) goto <D.23912>; else goto <D.23913>;
    <D.23912>:
    D.23727 = bb->block_num;
    monoeg_g_print ("cbranch to throw block triggered %d.\n", D.23727);
    <D.23913>:
    <D.23908>:
    <D.23904>:
    <D.23901>:
    <D.23897>:
    <D.23881>:
    <D.23894>:
    <D.23883>:
    <D.23885>:
    <D.23787>:
    <D.23785>:
    <D.22530>:
    previous_bb = bb;
    bb = bb->next_bb;
    <D.22541>:
    if (bb != 0B) goto <D.22540>; else goto <D.22542>;
    <D.22542>:
  }
  D.23914 = changed != 0;
  D.23915 = niterations != 0;
  D.23916 = D.23914 & D.23915;
  if (D.23916 != 0) goto <D.22543>; else goto <D.22544>;
  <D.22544>:
}


remove_block_if_useless (struct MonoCompile * cfg, struct MonoBasicBlock * bb, struct MonoBasicBlock * previous_bb)
{
  unsigned int D.23917;
  gboolean D.23920;
  short unsigned int D.23921;
  int D.23922;
  short int D.23927;
  struct MonoBasicBlock * * D.23929;
  struct MonoBasicBlock * D.23930;
  struct MonoBasicBlock * D.23931;
  struct MonoInst * D.23933;
  short unsigned int D.23936;
  struct MonoBasicBlock * D.23939;
  unsigned int D.23944;
  unsigned int D.23945;
  _Bool D.23948;
  _Bool D.23949;
  _Bool D.23950;
  unsigned int D.23953;
  int D.23956;
  struct MonoBasicBlock * * D.23957;
  short int D.23958;
  int D.23961;
  struct MonoBasicBlock * * D.23964;
  long unsigned int D.23965;
  long unsigned int D.23966;
  struct MonoBasicBlock * * D.23967;
  struct MonoBasicBlock * D.23968;
  struct MonoMemPool * D.23971;
  int D.23972;
  int D.23973;
  const unsigned char * D.23974;
  unsigned char * D.23978;
  short int D.23979;
  int D.23980;
  struct MonoBasicBlock * target_bb;
  struct MonoInst * inst;

  target_bb = 0B;
  D.23917 = bb->region;
  if (D.23917 != 4294967295) goto <D.23918>; else goto <D.23919>;
  <D.23918>:
  bb->not_useless = 1;
  D.23920 = 0;
  return D.23920;
  <D.23919>:
  inst = bb->code;
  goto <D.22420>;
  <D.22419>:
  D.23921 = inst->opcode;
  D.23922 = (int) D.23921;
  switch (D.23922) <default: <D.22418>, case 316: <D.22415>, case 446: <D.22417>>
  <D.22415>:
  goto <D.22416>;
  <D.22417>:
  target_bb = inst->data.op[0].target_block;
  goto <D.22416>;
  <D.22418>:
  bb->not_useless = 1;
  D.23920 = 0;
  return D.23920;
  <D.22416>:
  inst = inst->next;
  <D.22420>:
  if (inst != 0B) goto <D.22419>; else goto <D.22421>;
  <D.22421>:
  if (target_bb == 0B) goto <D.23923>; else goto <D.23924>;
  <D.23923>:
  D.23927 = bb->out_count;
  if (D.23927 == 1) goto <D.23928>; else goto <D.23925>;
  <D.23928>:
  D.23929 = bb->out_bb;
  D.23930 = *D.23929;
  D.23931 = bb->next_bb;
  if (D.23930 == D.23931) goto <D.23932>; else goto <D.23925>;
  <D.23932>:
  target_bb = bb->next_bb;
  goto <D.23926>;
  <D.23925>:
  D.23920 = 0;
  return D.23920;
  <D.23926>:
  <D.23924>:
  D.23933 = previous_bb->last_ins;
  if (D.23933 != 0B) goto <D.23934>; else goto <D.23935>;
  <D.23934>:
  D.23933 = previous_bb->last_ins;
  D.23936 = D.23933->opcode;
  if (D.23936 == 370) goto <D.23937>; else goto <D.23938>;
  <D.23937>:
  D.23920 = 0;
  return D.23920;
  <D.23938>:
  <D.23935>:
  D.23939 = cfg->bb_entry;
  if (D.23939 == previous_bb) goto <D.23940>; else goto <D.23941>;
  <D.23940>:
  D.23931 = bb->next_bb;
  if (D.23931 != target_bb) goto <D.23942>; else goto <D.23943>;
  <D.23942>:
  D.23920 = 0;
  return D.23920;
  <D.23943>:
  <D.23941>:
  D.23944 = previous_bb->region;
  D.23945 = D.23944 & 240;
  if (D.23945 == 0) goto <D.23946>; else goto <D.23947>;
  <D.23946>:
  D.23920 = 0;
  return D.23920;
  <D.23947>:
  D.23948 = target_bb != 0B;
  D.23949 = target_bb != bb;
  D.23950 = D.23948 & D.23949;
  if (D.23950 != 0) goto <D.23951>; else goto <D.23952>;
  <D.23951>:
  {
    int i;

    D.23953 = cfg->verbose_level;
    if (D.23953 > 1) goto <D.23954>; else goto <D.23955>;
    <D.23954>:
    D.23956 = bb->block_num;
    printf ("remove_block_if_useless, removed BB%d\n", D.23956);
    <D.23955>:
    goto <D.22425>;
    <D.22424>:
    {
      struct MonoBasicBlock * in_bb;

      D.23957 = bb->in_bb;
      in_bb = *D.23957;
      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.22425>:
    D.23958 = bb->in_count;
    if (D.23958 != 0) goto <D.22424>; else goto <D.22426>;
    <D.22426>:
    mono_unlink_bblock (cfg, bb, target_bb);
    D.23939 = cfg->bb_entry;
    if (D.23939 != previous_bb) goto <D.23959>; else goto <D.23960>;
    <D.23959>:
    D.23961 = mono_bb_is_fall_through (cfg, previous_bb);
    if (D.23961 != 0) goto <D.23962>; else goto <D.23963>;
    <D.23962>:
    i = 0;
    goto <D.22430>;
    <D.22429>:
    D.23964 = previous_bb->out_bb;
    D.23965 = (long unsigned int) i;
    D.23966 = D.23965 * 8;
    D.23967 = D.23964 + D.23966;
    D.23968 = *D.23967;
    if (D.23968 == target_bb) goto <D.23969>; else goto <D.23970>;
    <D.23969>:
    {
      struct MonoInst * jump;

      D.23971 = cfg->mempool;
      jump = mono_mempool_alloc0 (D.23971, 80);
      jump->opcode = 446;
      jump->dreg = -1;
      jump->sreg3 = -1;
      D.23972 = jump->sreg3;
      jump->sreg2 = D.23972;
      D.23973 = jump->sreg2;
      jump->sreg1 = D.23973;
      D.23974 = cfg->ip;
      jump->cil_code = D.23974;
      D.23933 = previous_bb->last_ins;
      if (D.23933 != 0B) goto <D.23975>; else goto <D.23976>;
      <D.23975>:
      D.23933 = previous_bb->last_ins;
      D.23933->next = jump;
      D.23933 = previous_bb->last_ins;
      jump->prev = D.23933;
      previous_bb->last_ins = jump;
      goto <D.23977>;
      <D.23976>:
      previous_bb->last_ins = jump;
      D.23933 = previous_bb->last_ins;
      previous_bb->code = D.23933;
      <D.23977>:
      D.23978 = previous_bb->cil_code;
      jump->cil_code = D.23978;
      jump->data.op[0].target_block = target_bb;
      goto <D.22428>;
    }
    <D.23970>:
    i = i + 1;
    <D.22430>:
    D.23979 = previous_bb->out_count;
    D.23980 = (int) D.23979;
    if (D.23980 > i) goto <D.22429>; else goto <D.22428>;
    <D.22428>:
    <D.23963>:
    <D.23960>:
    D.23931 = bb->next_bb;
    previous_bb->next_bb = D.23931;
    mono_nullify_basic_block (bb);
    D.23920 = 1;
    return D.23920;
  }
  <D.23952>:
  D.23920 = 0;
  return D.23920;
}


move_basic_block_to_end (struct MonoCompile * cfg, struct MonoBasicBlock * bb)
{
  struct MonoBasicBlock * D.23983;
  struct MonoBasicBlock * D.23987;
  struct MonoInst * D.23992;
  short unsigned int D.23994;
  _Bool D.23995;
  _Bool D.23996;
  _Bool D.23997;
  short unsigned int D.23999;
  short unsigned int D.24001;
  short unsigned int D.24002;
  _Bool D.24003;
  short unsigned int D.24004;
  _Bool D.24005;
  _Bool D.24006;
  short unsigned int D.24008;
  struct MonoMemPool * D.24009;
  int D.24010;
  int D.24011;
  const unsigned char * D.24012;
  struct MonoBasicBlock * bbn;
  struct MonoBasicBlock * next;

  next = bb->next_bb;
  bbn = cfg->bb_entry;
  goto <D.22466>;
  <D.22465>:
  bbn = bbn->next_bb;
  <D.22466>:
  D.23983 = bbn->next_bb;
  if (D.23983 != 0B) goto <D.23984>; else goto <D.22467>;
  <D.23984>:
  D.23983 = bbn->next_bb;
  if (D.23983 != bb) goto <D.22465>; else goto <D.22467>;
  <D.22467>:
  D.23983 = bbn->next_bb;
  if (D.23983 != 0B) goto <D.23985>; else goto <D.23986>;
  <D.23985>:
  D.23987 = bb->next_bb;
  bbn->next_bb = D.23987;
  <D.23986>:
  bbn = cfg->bb_entry;
  goto <D.22469>;
  <D.22468>:
  bbn = bbn->next_bb;
  <D.22469>:
  D.23983 = bbn->next_bb;
  if (D.23983 != 0B) goto <D.22468>; else goto <D.22470>;
  <D.22470>:
  bbn->next_bb = bb;
  bb->next_bb = 0B;
  if (next != 0B) goto <D.23990>; else goto <D.23991>;
  <D.23990>:
  D.23992 = bb->last_ins;
  if (D.23992 == 0B) goto <D.23988>; else goto <D.23993>;
  <D.23993>:
  D.23992 = bb->last_ins;
  D.23994 = D.23992->opcode;
  D.23995 = D.23994 != 802;
  D.23996 = D.23994 != 446;
  D.23997 = D.23995 & D.23996;
  if (D.23997 != 0) goto <D.23998>; else goto <D.23989>;
  <D.23998>:
  D.23992 = bb->last_ins;
  D.23999 = D.23992->opcode;
  if (D.23999 != 763) goto <D.24000>; else goto <D.23989>;
  <D.24000>:
  D.23992 = bb->last_ins;
  D.24001 = D.23992->opcode;
  D.24002 = D.24001 + 64981;
  D.24003 = D.24002 > 9;
  D.24004 = D.24001 + 64874;
  D.24005 = D.24004 > 9;
  D.24006 = D.24003 & D.24005;
  if (D.24006 != 0) goto <D.24007>; else goto <D.23989>;
  <D.24007>:
  D.23992 = bb->last_ins;
  D.23999 = D.23992->opcode;
  D.24008 = D.23999 + 64884;
  if (D.24008 > 9) goto <D.23988>; else goto <D.23989>;
  <D.23988>:
  {
    struct MonoInst * ins;

    D.24009 = cfg->mempool;
    ins = mono_mempool_alloc0 (D.24009, 80);
    ins->opcode = 446;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.24010 = ins->sreg3;
    ins->sreg2 = D.24010;
    D.24011 = ins->sreg2;
    ins->sreg1 = D.24011;
    D.24012 = cfg->ip;
    ins->cil_code = D.24012;
    D.23992 = bb->last_ins;
    if (D.23992 != 0B) goto <D.24013>; else goto <D.24014>;
    <D.24013>:
    D.23992 = bb->last_ins;
    D.23992->next = ins;
    D.23992 = bb->last_ins;
    ins->prev = D.23992;
    bb->last_ins = ins;
    goto <D.24015>;
    <D.24014>:
    bb->last_ins = ins;
    D.23992 = bb->last_ins;
    bb->code = D.23992;
    <D.24015>:
    mono_link_bblock (cfg, bb, next);
    ins->data.op[0].target_block = next;
  }
  <D.23989>:
  <D.23991>:
}