mono_compile_iterated_dfrontier (struct MonoCompile * m, struct MonoBitSet * set)
{
  unsigned int D.24451;
  unsigned int D.24452;
  struct MonoMemPool * D.24453;
  unsigned int bitsize.0;
  void * D.24455;
  unsigned int D.24456;
  unsigned int D.24457;
  struct MonoBitSet * D.24458;
  struct MonoBitSet * result;
  int bitsize;
  int count1;
  int count2;

  D.24451 = m->num_bblocks;
  D.24452 = mono_bitset_alloc_size (D.24451, 0);
  bitsize = (int) D.24452;
  D.24453 = m->mempool;
  bitsize.0 = (unsigned int) bitsize;
  D.24455 = mono_mempool_alloc0 (D.24453, bitsize.0);
  D.24451 = m->num_bblocks;
  result = mono_bitset_mem_new (D.24455, D.24451, 0);
  df_set (m, result, set);
  D.24456 = mono_bitset_count (result);
  count2 = (int) D.24456;
  <D.24380>:
  count1 = count2;
  df_set (m, result, result);
  D.24457 = mono_bitset_count (result);
  count2 = (int) D.24457;
  if (count2 > count1) goto <D.24380>; else goto <D.24381>;
  <D.24381>:
  D.24458 = result;
  return D.24458;
}


df_set (struct MonoCompile * m, struct MonoBitSet * dest, struct MonoBitSet * set)
{
  struct MonoBasicBlock * * D.24460;
  unsigned int i.1;
  unsigned int D.24462;
  struct MonoBasicBlock * * D.24463;
  struct MonoBasicBlock * D.24464;
  unsigned int D.24465;
  unsigned int D.24466;
  unsigned int D.24467;
  unsigned int D.24468;
  unsigned int D.24469;
  unsigned int i.2;
  unsigned int D.24471;
  int i;

  i = mono_bitset_find_start (set);
  goto <D.24370>;
  <D.24369>:
  {
    struct MonoBitSet * tmp_src;
    struct MonoBitSet * tmp_dest;
    int i;
    int size;

    D.24460 = m->bblocks;
    i.1 = (unsigned int) i;
    D.24462 = i.1 * 4;
    D.24463 = D.24460 + D.24462;
    D.24464 = *D.24463;
    tmp_src = D.24464->dfrontier;
    tmp_dest = dest;
    D.24465 = tmp_dest->size;
    D.24466 = D.24465 / 32;
    size = (int) D.24466;
    i = 0;
    goto <D.24367>;
    <D.24366>:
    D.24467 = tmp_dest->data[i];
    D.24468 = tmp_src->data[i];
    D.24469 = D.24467 | D.24468;
    tmp_dest->data[i] = D.24469;
    i = i + 1;
    <D.24367>:
    if (i < size) goto <D.24366>; else goto <D.24368>;
    <D.24368>:
  }
  i = mono_bitset_find_first (set, i);
  <D.24370>:
  i.2 = (unsigned int) i;
  D.24471 = m->num_bblocks;
  if (i.2 < D.24471) goto <D.24472>; else goto <D.24371>;
  <D.24472>:
  if (i >= 0) goto <D.24369>; else goto <D.24371>;
  <D.24371>:
}


mono_compile_dominator_info (struct MonoCompile * cfg, int dom_flags)
{
  int D.24473;
  unsigned int D.24476;
  unsigned int D.24477;
  int D.24480;
  unsigned int D.24483;

  D.24473 = dom_flags & 1;
  if (D.24473 != 0) goto <D.24474>; else goto <D.24475>;
  <D.24474>:
  D.24476 = cfg->comp_done;
  D.24477 = D.24476 & 1;
  if (D.24477 == 0) goto <D.24478>; else goto <D.24479>;
  <D.24478>:
  compute_dominators (cfg);
  <D.24479>:
  <D.24475>:
  D.24480 = dom_flags & 4;
  if (D.24480 != 0) goto <D.24481>; else goto <D.24482>;
  <D.24481>:
  D.24476 = cfg->comp_done;
  D.24483 = D.24476 & 4;
  if (D.24483 == 0) goto <D.24484>; else goto <D.24485>;
  <D.24484>:
  compute_dominance_frontier (cfg);
  <D.24485>:
  <D.24482>:
}


compute_dominators (struct MonoCompile * cfg)
{
  unsigned int D.24486;
  unsigned int D.24487;
  _Bool D.24488;
  long int D.24489;
  long int D.24490;
  unsigned int D.24493;
  unsigned int D.24494;
  struct MonoBasicBlock * * D.24495;
  unsigned int D.24496;
  int D.24497;
  unsigned int D.24498;
  unsigned int D.24499;
  struct MonoBasicBlock * * D.24500;
  unsigned int bindex.3;
  unsigned int D.24502;
  struct MonoBasicBlock * * D.24503;
  struct MonoBasicBlock * * D.24504;
  unsigned int i.4;
  unsigned int D.24506;
  struct MonoBasicBlock * * D.24507;
  int D.24510;
  unsigned int D.24511;
  unsigned int D.24512;
  struct MonoBasicBlock * * D.24513;
  struct MonoBasicBlock * D.24514;
  short int D.24517;
  int D.24518;
  struct MonoBasicBlock * D.24519;
  _Bool D.24522;
  long int D.24523;
  long int D.24524;
  int D.24529;
  unsigned int D.24531;
  unsigned int D.24532;
  struct MonoBasicBlock * * D.24533;
  struct MonoBasicBlock * D.24534;
  int D.24537;
  int D.24538;
  unsigned int D.24541;
  unsigned int D.24542;
  struct MonoBasicBlock * * D.24543;
  unsigned int D.24545;
  unsigned int D.24546;
  struct MonoBasicBlock * * D.24547;
  int D.24548;
  unsigned int D.24549;
  unsigned int D.24550;
  struct MonoBasicBlock * * D.24551;
  struct MonoBasicBlock * D.24552;
  unsigned int bindex.5;
  struct MonoBasicBlock * * D.24559;
  struct MonoMemPool * D.24560;
  unsigned int bitsize.6;
  sizetype bitsize.7;
  int D.24563;
  unsigned int D.24564;
  unsigned int D.24565;
  unsigned int D.24566;
  int D.24567;
  unsigned int D.24568;
  unsigned int D.24569;
  unsigned int D.24572;
  struct MonoBasicBlock * * D.24573;
  int D.24574;
  unsigned int D.24575;
  unsigned int D.24576;
  unsigned int D.24577;
  int D.24578;
  unsigned int D.24579;
  unsigned int D.24580;
  unsigned int D.24581;
  struct MonoBasicBlock * * D.24582;
  struct MonoBasicBlock * D.24583;
  struct MonoBasicBlock * D.24584;
  struct GSList * D.24587;
  struct GSList * D.24588;
  unsigned int D.24589;
  unsigned int D.24590;
  unsigned int i.8;
  unsigned int D.24592;
  int bindex;
  int i;
  int bitsize;
  struct MonoBasicBlock * entry;
  struct MonoBasicBlock * * doms;
  gboolean changed;

  D.24486 = cfg->comp_done;
  D.24487 = D.24486 & 1;
  D.24488 = D.24487 != 0;
  D.24489 = (long int) D.24488;
  D.24490 = __builtin_expect (D.24489, 0);
  if (D.24490 != 0) goto <D.24491>; else goto <D.24492>;
  <D.24491>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "dominators.c", 42, "!(cfg->comp_done & MONO_COMP_DOM)");
  <D.24492>:
  D.24493 = cfg->num_bblocks;
  D.24494 = mono_bitset_alloc_size (D.24493, 0);
  bitsize = (int) D.24494;
  D.24495 = cfg->bblocks;
  entry = *D.24495;
  D.24493 = cfg->num_bblocks;
  D.24496 = D.24493 * 4;
  doms = monoeg_malloc0 (D.24496);
  D.24497 = entry->dfn;
  D.24498 = (unsigned int) D.24497;
  D.24499 = D.24498 * 4;
  D.24500 = doms + D.24499;
  *D.24500 = entry;
  changed = 1;
  goto <D.24319>;
  <D.24318>:
  changed = 0;
  bindex = 0;
  goto <D.24316>;
  <D.24315>:
  {
    struct MonoBasicBlock * bb;
    struct MonoBasicBlock * idom;

    D.24495 = cfg->bblocks;
    bindex.3 = (unsigned int) bindex;
    D.24502 = bindex.3 * 4;
    D.24503 = D.24495 + D.24502;
    bb = *D.24503;
    idom = 0B;
    i = 0;
    goto <D.24305>;
    <D.24304>:
    {
      struct MonoBasicBlock * in_bb;

      D.24504 = bb->in_bb;
      i.4 = (unsigned int) i;
      D.24506 = i.4 * 4;
      D.24507 = D.24504 + D.24506;
      in_bb = *D.24507;
      if (in_bb != bb) goto <D.24508>; else goto <D.24509>;
      <D.24508>:
      D.24510 = in_bb->dfn;
      D.24511 = (unsigned int) D.24510;
      D.24512 = D.24511 * 4;
      D.24513 = doms + D.24512;
      D.24514 = *D.24513;
      if (D.24514 != 0B) goto <D.24515>; else goto <D.24516>;
      <D.24515>:
      idom = in_bb;
      goto <D.24303>;
      <D.24516>:
      <D.24509>:
    }
    i = i + 1;
    <D.24305>:
    D.24517 = bb->in_count;
    D.24518 = (int) D.24517;
    if (D.24518 > i) goto <D.24304>; else goto <D.24303>;
    <D.24303>:
    D.24495 = cfg->bblocks;
    D.24519 = *D.24495;
    if (D.24519 != bb) goto <D.24520>; else goto <D.24521>;
    <D.24520>:
    D.24522 = idom == 0B;
    D.24523 = (long int) D.24522;
    D.24524 = __builtin_expect (D.24523, 0);
    if (D.24524 != 0) goto <D.24525>; else goto <D.24526>;
    <D.24525>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "dominators.c", 79, "idom");
    <D.24526>:
    <D.24521>:
    goto <D.24313>;
    <D.24312>:
    {
      struct MonoBasicBlock * in_bb;

      D.24504 = bb->in_bb;
      i.4 = (unsigned int) i;
      D.24506 = i.4 * 4;
      D.24507 = D.24504 + D.24506;
      in_bb = *D.24507;
      D.24529 = in_bb->dfn;
      if (D.24529 != 0) goto <D.24527>; else goto <D.24530>;
      <D.24530>:
      if (in_bb == entry) goto <D.24527>; else goto <D.24528>;
      <D.24527>:
      D.24529 = in_bb->dfn;
      D.24531 = (unsigned int) D.24529;
      D.24532 = D.24531 * 4;
      D.24533 = doms + D.24532;
      D.24534 = *D.24533;
      if (D.24534 != 0B) goto <D.24535>; else goto <D.24536>;
      <D.24535>:
      {
        struct MonoBasicBlock * f1;
        struct MonoBasicBlock * f2;

        f1 = idom;
        f2 = in_bb;
        goto <D.24310>;
        <D.24309>:
        D.24537 = f1->dfn;
        D.24538 = f2->dfn;
        if (D.24537 < D.24538) goto <D.24539>; else goto <D.24540>;
        <D.24539>:
        D.24538 = f2->dfn;
        D.24541 = (unsigned int) D.24538;
        D.24542 = D.24541 * 4;
        D.24543 = doms + D.24542;
        f2 = *D.24543;
        goto <D.24544>;
        <D.24540>:
        D.24537 = f1->dfn;
        D.24545 = (unsigned int) D.24537;
        D.24546 = D.24545 * 4;
        D.24547 = doms + D.24546;
        f1 = *D.24547;
        <D.24544>:
        <D.24310>:
        if (f1 != f2) goto <D.24309>; else goto <D.24311>;
        <D.24311>:
        idom = f1;
      }
      <D.24536>:
      <D.24528>:
      i = i + 1;
    }
    <D.24313>:
    D.24517 = bb->in_count;
    D.24518 = (int) D.24517;
    if (D.24518 > i) goto <D.24312>; else goto <D.24314>;
    <D.24314>:
    D.24548 = bb->dfn;
    D.24549 = (unsigned int) D.24548;
    D.24550 = D.24549 * 4;
    D.24551 = doms + D.24550;
    D.24552 = *D.24551;
    if (D.24552 != idom) goto <D.24553>; else goto <D.24554>;
    <D.24553>:
    D.24495 = cfg->bblocks;
    D.24519 = *D.24495;
    if (D.24519 == bb) goto <D.24555>; else goto <D.24556>;
    <D.24555>:
    D.24548 = bb->dfn;
    D.24549 = (unsigned int) D.24548;
    D.24550 = D.24549 * 4;
    D.24551 = doms + D.24550;
    *D.24551 = bb;
    goto <D.24557>;
    <D.24556>:
    D.24548 = bb->dfn;
    D.24549 = (unsigned int) D.24548;
    D.24550 = D.24549 * 4;
    D.24551 = doms + D.24550;
    *D.24551 = idom;
    changed = 1;
    <D.24557>:
    <D.24554>:
  }
  bindex = bindex + 1;
  <D.24316>:
  bindex.5 = (unsigned int) bindex;
  D.24493 = cfg->num_bblocks;
  if (bindex.5 < D.24493) goto <D.24315>; else goto <D.24317>;
  <D.24317>:
  <D.24319>:
  if (changed != 0) goto <D.24318>; else goto <D.24320>;
  <D.24320>:
  i = 0;
  goto <D.24329>;
  <D.24328>:
  {
    struct MonoBasicBlock * bb;
    struct MonoBasicBlock * cbb;
    struct MonoBitSet * dominators;
    char * mem;

    D.24495 = cfg->bblocks;
    i.4 = (unsigned int) i;
    D.24506 = i.4 * 4;
    D.24559 = D.24495 + D.24506;
    bb = *D.24559;
    D.24560 = cfg->mempool;
    bitsize.6 = (unsigned int) bitsize;
    mem = mono_mempool_alloc0 (D.24560, bitsize.6);
    D.24493 = cfg->num_bblocks;
    dominators = mono_bitset_mem_new (mem, D.24493, 0);
    bb->dominators = dominators;
    bitsize.7 = (sizetype) bitsize;
    mem = mem + bitsize.7;
    D.24563 = bb->dfn;
    D.24564 = (unsigned int) D.24563;
    D.24565 = D.24564 / 32;
    D.24566 = dominators->data[D.24565];
    D.24563 = bb->dfn;
    D.24567 = D.24563 & 31;
    D.24568 = 1 << D.24567;
    D.24569 = D.24566 | D.24568;
    dominators->data[D.24565] = D.24569;
    D.24563 = bb->dfn;
    if (D.24563 != 0) goto <D.24570>; else goto <D.24571>;
    <D.24570>:
    D.24563 = bb->dfn;
    D.24564 = (unsigned int) D.24563;
    D.24572 = D.24564 * 4;
    D.24573 = doms + D.24572;
    cbb = *D.24573;
    goto <D.24326>;
    <D.24325>:
    D.24574 = cbb->dfn;
    D.24575 = (unsigned int) D.24574;
    D.24576 = D.24575 / 32;
    D.24577 = dominators->data[D.24576];
    D.24574 = cbb->dfn;
    D.24578 = D.24574 & 31;
    D.24579 = 1 << D.24578;
    D.24580 = D.24577 | D.24579;
    dominators->data[D.24576] = D.24580;
    D.24574 = cbb->dfn;
    D.24575 = (unsigned int) D.24574;
    D.24581 = D.24575 * 4;
    D.24582 = doms + D.24581;
    cbb = *D.24582;
    <D.24326>:
    D.24574 = cbb->dfn;
    if (D.24574 != 0) goto <D.24325>; else goto <D.24327>;
    <D.24327>:
    D.24563 = bb->dfn;
    D.24564 = (unsigned int) D.24563;
    D.24572 = D.24564 * 4;
    D.24573 = doms + D.24572;
    D.24583 = *D.24573;
    bb->idom = D.24583;
    D.24584 = bb->idom;
    if (D.24584 != 0B) goto <D.24585>; else goto <D.24586>;
    <D.24585>:
    D.24584 = bb->idom;
    D.24560 = cfg->mempool;
    D.24584 = bb->idom;
    D.24587 = D.24584->dominated;
    D.24588 = g_slist_prepend_mempool (D.24560, D.24587, bb);
    D.24584->dominated = D.24588;
    <D.24586>:
    <D.24571>:
    D.24589 = dominators->data[0];
    D.24590 = D.24589 | 1;
    dominators->data[0] = D.24590;
  }
  i = i + 1;
  <D.24329>:
  i.8 = (unsigned int) i;
  D.24493 = cfg->num_bblocks;
  if (i.8 < D.24493) goto <D.24328>; else goto <D.24330>;
  <D.24330>:
  monoeg_g_free (doms);
  D.24486 = cfg->comp_done;
  D.24592 = D.24486 | 3;
  cfg->comp_done = D.24592;
}


g_slist_prepend_mempool (struct MonoMemPool * mp, struct GSList * list, void * data)
{
  struct GSList * D.24593;
  struct GSList * new_list;

  new_list = mono_mempool_alloc (mp, 8);
  new_list->data = data;
  new_list->next = list;
  D.24593 = new_list;
  return D.24593;
}


compute_dominance_frontier (struct MonoCompile * cfg)
{
  unsigned int D.24595;
  unsigned int D.24596;
  _Bool D.24597;
  long int D.24598;
  long int D.24599;
  struct MonoBasicBlock * * D.24602;
  unsigned int i.9;
  unsigned int D.24604;
  struct MonoBasicBlock * * D.24605;
  struct MonoBasicBlock * D.24606;
  unsigned int D.24607;
  unsigned int D.24608;
  unsigned int i.10;
  unsigned int D.24610;
  unsigned int D.24611;
  struct MonoMemPool * D.24612;
  unsigned int bitsize.11;
  unsigned int D.24614;
  struct MonoBitSet * D.24615;
  sizetype bitsize.12;
  short int D.24617;
  struct MonoBasicBlock * * D.24620;
  unsigned int j.13;
  unsigned int D.24622;
  struct MonoBasicBlock * * D.24623;
  int D.24625;
  struct MonoBasicBlock * D.24627;
  struct MonoBitSet * D.24628;
  int D.24629;
  unsigned int D.24630;
  unsigned int D.24631;
  unsigned int D.24632;
  int D.24633;
  unsigned int D.24634;
  unsigned int D.24635;
  struct MonoBasicBlock * D.24636;
  int D.24637;
  unsigned int D.24638;
  char * mem;
  int i;
  int j;
  int bitsize;

  D.24595 = cfg->comp_done;
  D.24596 = D.24595 & 4;
  D.24597 = D.24596 != 0;
  D.24598 = (long int) D.24597;
  D.24599 = __builtin_expect (D.24598, 0);
  if (D.24599 != 0) goto <D.24600>; else goto <D.24601>;
  <D.24600>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "dominators.c", 197, "!(cfg->comp_done & MONO_COMP_DFRONTIER)");
  <D.24601>:
  i = 0;
  goto <D.24339>;
  <D.24338>:
  D.24602 = cfg->bblocks;
  i.9 = (unsigned int) i;
  D.24604 = i.9 * 4;
  D.24605 = D.24602 + D.24604;
  D.24606 = *D.24605;
  D.24602 = cfg->bblocks;
  i.9 = (unsigned int) i;
  D.24604 = i.9 * 4;
  D.24605 = D.24602 + D.24604;
  D.24606 = *D.24605;
  D.24607 = D.24606->flags;
  D.24608 = D.24607 & 4294967294;
  D.24606->flags = D.24608;
  i = i + 1;
  <D.24339>:
  i.10 = (unsigned int) i;
  D.24610 = cfg->num_bblocks;
  if (i.10 < D.24610) goto <D.24338>; else goto <D.24340>;
  <D.24340>:
  D.24610 = cfg->num_bblocks;
  D.24611 = mono_bitset_alloc_size (D.24610, 0);
  bitsize = (int) D.24611;
  D.24612 = cfg->mempool;
  D.24610 = cfg->num_bblocks;
  bitsize.11 = (unsigned int) bitsize;
  D.24614 = D.24610 * bitsize.11;
  mem = mono_mempool_alloc0 (D.24612, D.24614);
  i = 0;
  goto <D.24343>;
  <D.24342>:
  {
    struct MonoBasicBlock * bb;

    D.24602 = cfg->bblocks;
    i.9 = (unsigned int) i;
    D.24604 = i.9 * 4;
    D.24605 = D.24602 + D.24604;
    bb = *D.24605;
    D.24610 = cfg->num_bblocks;
    D.24615 = mono_bitset_mem_new (mem, D.24610, 0);
    bb->dfrontier = D.24615;
    bitsize.12 = (sizetype) bitsize;
    mem = mem + bitsize.12;
  }
  i = i + 1;
  <D.24343>:
  i.10 = (unsigned int) i;
  D.24610 = cfg->num_bblocks;
  if (i.10 < D.24610) goto <D.24342>; else goto <D.24344>;
  <D.24344>:
  i = 0;
  goto <D.24354>;
  <D.24353>:
  {
    struct MonoBasicBlock * bb;

    D.24602 = cfg->bblocks;
    i.9 = (unsigned int) i;
    D.24604 = i.9 * 4;
    D.24605 = D.24602 + D.24604;
    bb = *D.24605;
    D.24617 = bb->in_count;
    if (D.24617 > 1) goto <D.24618>; else goto <D.24619>;
    <D.24618>:
    j = 0;
    goto <D.24351>;
    <D.24350>:
    {
      struct MonoBasicBlock * p;

      D.24620 = bb->in_bb;
      j.13 = (unsigned int) j;
      D.24622 = j.13 * 4;
      D.24623 = D.24620 + D.24622;
      p = *D.24623;
      D.24625 = p->dfn;
      if (D.24625 != 0) goto <D.24624>; else goto <D.24626>;
      <D.24626>:
      D.24602 = cfg->bblocks;
      D.24627 = *D.24602;
      if (D.24627 == p) goto <D.24624>; else goto <D.24349>;
      <D.24624>:
      goto <D.24348>;
      <D.24347>:
      D.24628 = p->dfrontier;
      D.24629 = bb->dfn;
      D.24630 = (unsigned int) D.24629;
      D.24631 = D.24630 / 32;
      D.24628 = p->dfrontier;
      D.24632 = D.24628->data[D.24631];
      D.24629 = bb->dfn;
      D.24633 = D.24629 & 31;
      D.24634 = 1 << D.24633;
      D.24635 = D.24632 | D.24634;
      D.24628->data[D.24631] = D.24635;
      p = p->idom;
      <D.24348>:
      D.24636 = bb->idom;
      if (D.24636 != p) goto <D.24347>; else goto <D.24349>;
      <D.24349>:
    }
    j = j + 1;
    <D.24351>:
    D.24617 = bb->in_count;
    D.24637 = (int) D.24617;
    if (D.24637 > j) goto <D.24350>; else goto <D.24352>;
    <D.24352>:
    <D.24619>:
  }
  i = i + 1;
  <D.24354>:
  i.10 = (unsigned int) i;
  D.24610 = cfg->num_bblocks;
  if (i.10 < D.24610) goto <D.24353>; else goto <D.24355>;
  <D.24355>:
  D.24595 = cfg->comp_done;
  D.24638 = D.24595 | 4;
  cfg->comp_done = D.24638;
}


mono_compute_natural_loops (struct MonoCompile * cfg)
{
  unsigned int D.24639;
  unsigned int D.24640;
  _Bool D.24641;
  long int D.24642;
  long int D.24643;
  unsigned int D.24646;
  unsigned int D.24647;
  struct MonoBasicBlock * * D.24648;
  unsigned int i.14;
  unsigned int D.24650;
  struct MonoBasicBlock * * D.24651;
  struct MonoBasicBlock * * D.24652;
  unsigned int j.15;
  unsigned int D.24654;
  struct MonoBasicBlock * * D.24655;
  struct MonoBitSet * D.24658;
  int D.24659;
  unsigned int D.24660;
  unsigned int D.24661;
  unsigned int D.24662;
  int D.24663;
  unsigned int D.24664;
  unsigned int D.24665;
  struct GList * D.24668;
  struct GList * D.24671;
  int D.24676;
  unsigned int D.24679;
  unsigned int D.24680;
  unsigned int D.24681;
  int D.24682;
  unsigned int D.24683;
  unsigned int D.24684;
  int D.24688;
  unsigned int D.24690;
  unsigned int D.24691;
  unsigned int D.24692;
  int D.24693;
  unsigned int D.24694;
  unsigned int D.24695;
  struct GList * D.24697;
  struct MonoMemPool * D.24698;
  struct GList * D.24699;
  signed char D.24700;
  signed char D.24701;
  unsigned char D.24702;
  unsigned char D.24703;
  signed char D.24704;
  unsigned int D.24707;
  unsigned int D.24708;
  unsigned int D.24709;
  struct MonoBasicBlock * * D.24710;
  unsigned int k.16;
  unsigned int D.24712;
  struct MonoBasicBlock * * D.24713;
  int D.24719;
  unsigned int D.24721;
  unsigned int D.24722;
  unsigned int D.24723;
  int D.24724;
  unsigned int D.24725;
  unsigned int D.24726;
  struct GList * D.24728;
  short int D.24729;
  int D.24730;
  unsigned int D.24735;
  unsigned int D.24736;
  struct GList * D.24738;
  struct GList * D.24739;
  signed char D.24740;
  signed char D.24741;
  unsigned char D.24742;
  unsigned char D.24743;
  signed char D.24744;
  short int D.24745;
  int D.24746;
  unsigned int i.17;
  unsigned int D.24748;
  unsigned int D.24749;
  int D.24750;
  unsigned int D.24753;
  unsigned int D.24754;
  int * D.24755;
  struct MonoBasicBlock * D.24756;
  struct GList * D.24757;
  int D.24760;
  unsigned int D.24763;
  unsigned int D.24764;
  int * D.24765;
  int D.24766;
  int D.24767;
  unsigned int D.24768;
  unsigned int D.24769;
  int * D.24770;
  int D.24771;
  int i;
  int j;
  int k;
  struct MonoBitSet * in_loop_blocks;
  int * bb_indexes;

  D.24639 = cfg->comp_done;
  D.24640 = D.24639 & 256;
  D.24641 = D.24640 != 0;
  D.24642 = (long int) D.24641;
  D.24643 = __builtin_expect (D.24642, 0);
  if (D.24643 != 0) goto <D.24644>; else goto <D.24645>;
  <D.24644>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "dominators.c", 311, "!(cfg->comp_done & MONO_COMP_LOOPS)");
  <D.24645>:
  D.24646 = cfg->num_bblocks;
  D.24647 = D.24646 + 1;
  in_loop_blocks = mono_bitset_new (D.24647, 0);
  i = 0;
  goto <D.24415>;
  <D.24414>:
  {
    struct MonoBasicBlock * n;

    D.24648 = cfg->bblocks;
    i.14 = (unsigned int) i;
    D.24650 = i.14 * 4;
    D.24651 = D.24648 + D.24650;
    n = *D.24651;
    j = 0;
    goto <D.24412>;
    <D.24411>:
    {
      struct MonoBasicBlock * h;

      D.24652 = n->out_bb;
      j.15 = (unsigned int) j;
      D.24654 = j.15 * 4;
      D.24655 = D.24652 + D.24654;
      h = *D.24655;
      if (n != h) goto <D.24656>; else goto <D.24657>;
      <D.24656>:
      D.24658 = n->dominators;
      D.24659 = h->dfn;
      D.24660 = (unsigned int) D.24659;
      D.24661 = D.24660 / 32;
      D.24662 = D.24658->data[D.24661];
      D.24659 = h->dfn;
      D.24663 = D.24659 & 31;
      D.24664 = 1 << D.24663;
      D.24665 = D.24662 & D.24664;
      if (D.24665 != 0) goto <D.24666>; else goto <D.24667>;
      <D.24666>:
      {
        struct GSList * todo;

        D.24668 = h->loop_blocks;
        if (D.24668 != 0B) goto <D.24669>; else goto <D.24670>;
        <D.24669>:
        D.24668 = h->loop_blocks;
        D.24671 = monoeg_g_list_find (D.24668, n);
        if (D.24671 != 0B) goto <D.24672>; else goto <D.24673>;
        <D.24672>:
        // predicted unlikely by continue predictor.
        goto <D.24397>;
        <D.24673>:
        <D.24670>:
        mono_bitset_clear_all (in_loop_blocks);
        D.24668 = h->loop_blocks;
        if (D.24668 != 0B) goto <D.24674>; else goto <D.24675>;
        <D.24674>:
        {
          struct GList * l;

          l = h->loop_blocks;
          goto <D.24401>;
          <D.24400>:
          {
            struct MonoBasicBlock * b;

            b = l->data;
            D.24676 = b->dfn;
            if (D.24676 != 0) goto <D.24677>; else goto <D.24678>;
            <D.24677>:
            D.24676 = b->dfn;
            D.24679 = (unsigned int) D.24676;
            D.24680 = D.24679 / 32;
            D.24681 = in_loop_blocks->data[D.24680];
            D.24676 = b->dfn;
            D.24682 = D.24676 & 31;
            D.24683 = 1 << D.24682;
            D.24684 = D.24681 | D.24683;
            in_loop_blocks->data[D.24680] = D.24684;
            <D.24678>:
          }
          l = l->next;
          <D.24401>:
          if (l != 0B) goto <D.24400>; else goto <D.24402>;
          <D.24402>:
        }
        <D.24675>:
        todo = monoeg_g_slist_prepend (0B, n);
        goto <D.24404>;
        <D.24409>:
        {
          struct MonoBasicBlock * cb;

          cb = todo->data;
          todo = monoeg_g_slist_delete_link (todo, todo);
          D.24688 = cb->dfn;
          if (D.24688 != 0) goto <D.24689>; else goto <D.24685>;
          <D.24689>:
          D.24688 = cb->dfn;
          D.24690 = (unsigned int) D.24688;
          D.24691 = D.24690 / 32;
          D.24692 = in_loop_blocks->data[D.24691];
          D.24688 = cb->dfn;
          D.24693 = D.24688 & 31;
          D.24694 = 1 << D.24693;
          D.24695 = D.24692 & D.24694;
          if (D.24695 != 0) goto <D.24686>; else goto <D.24685>;
          <D.24685>:
          D.24688 = cb->dfn;
          if (D.24688 == 0) goto <D.24696>; else goto <D.24687>;
          <D.24696>:
          D.24668 = h->loop_blocks;
          D.24697 = monoeg_g_list_find (D.24668, cb);
          if (D.24697 != 0B) goto <D.24686>; else goto <D.24687>;
          <D.24686>:
          // predicted unlikely by continue predictor.
          goto <D.24404>;
          <D.24687>:
          D.24698 = cfg->mempool;
          D.24668 = h->loop_blocks;
          D.24699 = g_list_prepend_mempool (D.24698, D.24668, cb);
          h->loop_blocks = D.24699;
          D.24700 = cb->nesting;
          D.24701 = D.24700;
          D.24702 = (unsigned char) D.24701;
          D.24703 = D.24702 + 1;
          D.24704 = (signed char) D.24703;
          cb->nesting = D.24704;
          D.24688 = cb->dfn;
          if (D.24688 != 0) goto <D.24705>; else goto <D.24706>;
          <D.24705>:
          D.24688 = cb->dfn;
          D.24690 = (unsigned int) D.24688;
          D.24707 = D.24690 / 32;
          D.24708 = in_loop_blocks->data[D.24707];
          D.24688 = cb->dfn;
          D.24693 = D.24688 & 31;
          D.24694 = 1 << D.24693;
          D.24709 = D.24708 | D.24694;
          in_loop_blocks->data[D.24707] = D.24709;
          <D.24706>:
          k = 0;
          goto <D.24407>;
          <D.24406>:
          {
            struct MonoBasicBlock * prev;

            D.24710 = cb->in_bb;
            k.16 = (unsigned int) k;
            D.24712 = k.16 * 4;
            D.24713 = D.24710 + D.24712;
            prev = *D.24713;
            if (prev != h) goto <D.24717>; else goto <D.24718>;
            <D.24717>:
            D.24719 = prev->dfn;
            if (D.24719 == 0) goto <D.24716>; else goto <D.24720>;
            <D.24720>:
            D.24719 = prev->dfn;
            D.24721 = (unsigned int) D.24719;
            D.24722 = D.24721 / 32;
            D.24723 = in_loop_blocks->data[D.24722];
            D.24719 = prev->dfn;
            D.24724 = D.24719 & 31;
            D.24725 = 1 << D.24724;
            D.24726 = D.24723 & D.24725;
            if (D.24726 == 0) goto <D.24716>; else goto <D.24715>;
            <D.24716>:
            D.24719 = prev->dfn;
            if (D.24719 != 0) goto <D.24714>; else goto <D.24727>;
            <D.24727>:
            D.24668 = h->loop_blocks;
            D.24728 = monoeg_g_list_find (D.24668, prev);
            if (D.24728 == 0B) goto <D.24714>; else goto <D.24715>;
            <D.24714>:
            todo = monoeg_g_slist_prepend (todo, prev);
            <D.24715>:
            <D.24718>:
          }
          k = k + 1;
          <D.24407>:
          D.24729 = cb->in_count;
          D.24730 = (int) D.24729;
          if (D.24730 > k) goto <D.24406>; else goto <D.24408>;
          <D.24408>:
        }
        <D.24404>:
        if (todo != 0B) goto <D.24409>; else goto <D.24410>;
        <D.24410>:
        D.24659 = h->dfn;
        if (D.24659 == 0) goto <D.24733>; else goto <D.24734>;
        <D.24734>:
        D.24659 = h->dfn;
        D.24660 = (unsigned int) D.24659;
        D.24661 = D.24660 / 32;
        D.24735 = in_loop_blocks->data[D.24661];
        D.24659 = h->dfn;
        D.24663 = D.24659 & 31;
        D.24664 = 1 << D.24663;
        D.24736 = D.24735 & D.24664;
        if (D.24736 == 0) goto <D.24733>; else goto <D.24732>;
        <D.24733>:
        D.24659 = h->dfn;
        if (D.24659 != 0) goto <D.24731>; else goto <D.24737>;
        <D.24737>:
        D.24668 = h->loop_blocks;
        D.24738 = monoeg_g_list_find (D.24668, h);
        if (D.24738 == 0B) goto <D.24731>; else goto <D.24732>;
        <D.24731>:
        D.24698 = cfg->mempool;
        D.24668 = h->loop_blocks;
        D.24739 = g_list_prepend_mempool (D.24698, D.24668, h);
        h->loop_blocks = D.24739;
        D.24740 = h->nesting;
        D.24741 = D.24740;
        D.24742 = (unsigned char) D.24741;
        D.24743 = D.24742 + 1;
        D.24744 = (signed char) D.24743;
        h->nesting = D.24744;
        <D.24732>:
      }
      <D.24667>:
      <D.24657>:
    }
    <D.24397>:
    j = j + 1;
    <D.24412>:
    D.24745 = n->out_count;
    D.24746 = (int) D.24745;
    if (D.24746 > j) goto <D.24411>; else goto <D.24413>;
    <D.24413>:
  }
  i = i + 1;
  <D.24415>:
  i.17 = (unsigned int) i;
  D.24646 = cfg->num_bblocks;
  if (i.17 < D.24646) goto <D.24414>; else goto <D.24416>;
  <D.24416>:
  mono_bitset_free (in_loop_blocks);
  D.24639 = cfg->comp_done;
  D.24748 = D.24639 | 256;
  cfg->comp_done = D.24748;
  D.24646 = cfg->num_bblocks;
  D.24749 = D.24646 * 4;
  bb_indexes = monoeg_malloc0 (D.24749);
  {
    struct MonoBasicBlock * bb;

    i = 0;
    bb = cfg->bb_entry;
    goto <D.24419>;
    <D.24418>:
    D.24750 = bb->dfn;
    if (D.24750 != 0) goto <D.24751>; else goto <D.24752>;
    <D.24751>:
    D.24750 = bb->dfn;
    D.24753 = (unsigned int) D.24750;
    D.24754 = D.24753 * 4;
    D.24755 = bb_indexes + D.24754;
    *D.24755 = i;
    <D.24752>:
    i = i + 1;
    bb = bb->next_bb;
    <D.24419>:
    if (bb != 0B) goto <D.24418>; else goto <D.24420>;
    <D.24420>:
  }
  i = 0;
  goto <D.24429>;
  <D.24428>:
  D.24648 = cfg->bblocks;
  i.14 = (unsigned int) i;
  D.24650 = i.14 * 4;
  D.24651 = D.24648 + D.24650;
  D.24756 = *D.24651;
  D.24757 = D.24756->loop_blocks;
  if (D.24757 != 0B) goto <D.24758>; else goto <D.24759>;
  <D.24758>:
  {
    struct MonoBasicBlock * h;
    struct MonoBasicBlock * body_start;
    struct GList * l;

    D.24648 = cfg->bblocks;
    i.14 = (unsigned int) i;
    D.24650 = i.14 * 4;
    D.24651 = D.24648 + D.24650;
    h = *D.24651;
    body_start = h;
    l = h->loop_blocks;
    goto <D.24426>;
    <D.24425>:
    {
      struct MonoBasicBlock * cb;

      cb = l->data;
      D.24760 = cb->dfn;
      if (D.24760 != 0) goto <D.24761>; else goto <D.24762>;
      <D.24761>:
      D.24760 = cb->dfn;
      D.24763 = (unsigned int) D.24760;
      D.24764 = D.24763 * 4;
      D.24765 = bb_indexes + D.24764;
      D.24766 = *D.24765;
      D.24767 = body_start->dfn;
      D.24768 = (unsigned int) D.24767;
      D.24769 = D.24768 * 4;
      D.24770 = bb_indexes + D.24769;
      D.24771 = *D.24770;
      if (D.24766 < D.24771) goto <D.24772>; else goto <D.24773>;
      <D.24772>:
      body_start = cb;
      <D.24773>:
      <D.24762>:
    }
    l = l->next;
    <D.24426>:
    if (l != 0B) goto <D.24425>; else goto <D.24427>;
    <D.24427>:
    body_start->loop_body_start = 1;
  }
  <D.24759>:
  i = i + 1;
  <D.24429>:
  i.17 = (unsigned int) i;
  D.24646 = cfg->num_bblocks;
  if (i.17 < D.24646) goto <D.24428>; else goto <D.24430>;
  <D.24430>:
  monoeg_g_free (bb_indexes);
}


g_list_prepend_mempool (struct MonoMemPool * mp, struct GList * list, void * data)
{
  struct GList * iftmp.18;
  struct GList * D.24778;
  struct GList * D.24783;
  struct GList * new_list;

  new_list = mono_mempool_alloc (mp, 12);
  new_list->data = data;
  if (list != 0B) goto <D.24775>; else goto <D.24776>;
  <D.24775>:
  iftmp.18 = list->prev;
  goto <D.24777>;
  <D.24776>:
  iftmp.18 = 0B;
  <D.24777>:
  new_list->prev = iftmp.18;
  new_list->next = list;
  D.24778 = new_list->prev;
  if (D.24778 != 0B) goto <D.24779>; else goto <D.24780>;
  <D.24779>:
  D.24778 = new_list->prev;
  D.24778->next = new_list;
  <D.24780>:
  if (list != 0B) goto <D.24781>; else goto <D.24782>;
  <D.24781>:
  list->prev = new_list;
  <D.24782>:
  D.24783 = new_list;
  return D.24783;
}


mono_free_loop_info (struct MonoCompile * cfg)
{
  unsigned int D.24785;
  unsigned int D.24786;
  unsigned int D.24789;

  D.24785 = cfg->comp_done;
  D.24786 = D.24785 & 2;
  if (D.24786 != 0) goto <D.24787>; else goto <D.24788>;
  <D.24787>:
  clear_idominators (cfg);
  <D.24788>:
  D.24785 = cfg->comp_done;
  D.24789 = D.24785 & 256;
  if (D.24789 != 0) goto <D.24790>; else goto <D.24791>;
  <D.24790>:
  clear_loops (cfg);
  <D.24791>:
}


clear_idominators (struct MonoCompile * cfg)
{
  struct MonoBasicBlock * * D.24792;
  unsigned int D.24793;
  struct MonoBasicBlock * * D.24794;
  struct MonoBasicBlock * D.24795;
  struct GSList * D.24796;
  unsigned int D.24799;
  unsigned int D.24800;
  unsigned int D.24801;
  guint i;

  i = 0;
  goto <D.24436>;
  <D.24435>:
  D.24792 = cfg->bblocks;
  D.24793 = i * 4;
  D.24794 = D.24792 + D.24793;
  D.24795 = *D.24794;
  D.24796 = D.24795->dominated;
  if (D.24796 != 0B) goto <D.24797>; else goto <D.24798>;
  <D.24797>:
  D.24792 = cfg->bblocks;
  D.24793 = i * 4;
  D.24794 = D.24792 + D.24793;
  D.24795 = *D.24794;
  D.24795->dominated = 0B;
  <D.24798>:
  i = i + 1;
  <D.24436>:
  D.24799 = cfg->num_bblocks;
  if (D.24799 > i) goto <D.24435>; else goto <D.24437>;
  <D.24437>:
  D.24800 = cfg->comp_done;
  D.24801 = D.24800 & 4294967293;
  cfg->comp_done = D.24801;
}


clear_loops (struct MonoCompile * cfg)
{
  struct MonoBasicBlock * * D.24802;
  unsigned int D.24803;
  struct MonoBasicBlock * * D.24804;
  struct MonoBasicBlock * D.24805;
  unsigned int D.24806;
  unsigned int D.24807;
  unsigned int D.24808;
  guint i;

  i = 0;
  goto <D.24443>;
  <D.24442>:
  D.24802 = cfg->bblocks;
  D.24803 = i * 4;
  D.24804 = D.24802 + D.24803;
  D.24805 = *D.24804;
  D.24805->nesting = 0;
  D.24802 = cfg->bblocks;
  D.24803 = i * 4;
  D.24804 = D.24802 + D.24803;
  D.24805 = *D.24804;
  D.24805->loop_blocks = 0B;
  i = i + 1;
  <D.24443>:
  D.24806 = cfg->num_bblocks;
  if (D.24806 > i) goto <D.24442>; else goto <D.24444>;
  <D.24444>:
  D.24807 = cfg->comp_done;
  D.24808 = D.24807 & 4294967039;
  cfg->comp_done = D.24808;
}