__attribute__((visibility ("hidden")))
mono_liveness_handle_exception_clauses (struct MonoCompile * cfg)
{
  struct MonoMemPool * D.22588;
  <unnamed-unsigned:15> D.22589;
  unsigned int D.22590;
  unsigned int D.22591;
  long unsigned int D.22592;
  long unsigned int D.22593;
  gboolean * D.22594;
  int D.22595;
  struct MonoExceptionClause * D.22596;
  long unsigned int D.22597;
  unsigned int D.22598;
  long unsigned int D.22601;
  long unsigned int D.22602;
  unsigned int D.22603;
  unsigned int D.22606;
  unsigned int D.22607;
  unsigned int D.22610;
  unsigned int D.22611;
  long unsigned int D.22614;
  gboolean * D.22615;
  unsigned int D.22616;
  unsigned int D.22618;
  unsigned int D.22621;
  unsigned int D.22624;
  unsigned int D.22625;
  long unsigned int D.22626;
  long unsigned int D.22627;
  gboolean * D.22628;
  int D.22629;
  unsigned int D.22632;
  int D.22635;
  struct GSList * visited.0;
  struct MonoBasicBlock * bb;
  struct GSList * visited;
  struct MonoMethodHeader * header;
  struct MonoExceptionClause * clause;
  struct MonoExceptionClause * clause2;
  int i;
  int j;
  gboolean * outer_try;

  try
    {
      visited = 0B;
      header = cfg->header;
      D.22588 = cfg->mempool;
      D.22589 = header->num_clauses;
      D.22590 = (unsigned int) D.22589;
      D.22591 = D.22590 * 4;
      outer_try = mono_mempool_alloc0 (D.22588, D.22591);
      i = 0;
      goto <D.22202>;
      <D.22201>:
      D.22592 = (long unsigned int) i;
      D.22593 = D.22592 * 4;
      D.22594 = outer_try + D.22593;
      *D.22594 = 1;
      i = i + 1;
      <D.22202>:
      D.22589 = header->num_clauses;
      D.22595 = (int) D.22589;
      if (D.22595 > i) goto <D.22201>; else goto <D.22203>;
      <D.22203>:
      D.22589 = header->num_clauses;
      D.22595 = (int) D.22589;
      i = D.22595 + -1;
      goto <D.22208>;
      <D.22207>:
      D.22596 = header->clauses;
      D.22592 = (long unsigned int) i;
      D.22597 = D.22592 * 32;
      clause = D.22596 + D.22597;
      D.22598 = clause->flags;
      if (D.22598 != 0) goto <D.22599>; else goto <D.22600>;
      <D.22599>:
      D.22592 = (long unsigned int) i;
      D.22593 = D.22592 * 4;
      D.22594 = outer_try + D.22593;
      *D.22594 = 1;
      j = i + -1;
      goto <D.22206>;
      <D.22205>:
      D.22596 = header->clauses;
      D.22601 = (long unsigned int) j;
      D.22602 = D.22601 * 32;
      clause2 = D.22596 + D.22602;
      D.22603 = clause2->flags;
      if (D.22603 == 0) goto <D.22604>; else goto <D.22605>;
      <D.22604>:
      D.22606 = clause->handler_offset;
      D.22607 = clause2->try_offset;
      if (D.22606 <= D.22607) goto <D.22608>; else goto <D.22609>;
      <D.22608>:
      D.22607 = clause2->try_offset;
      D.22606 = clause->handler_offset;
      D.22610 = clause->handler_len;
      D.22611 = D.22606 + D.22610;
      if (D.22607 < D.22611) goto <D.22612>; else goto <D.22613>;
      <D.22612>:
      D.22601 = (long unsigned int) j;
      D.22614 = D.22601 * 4;
      D.22615 = outer_try + D.22614;
      *D.22615 = 0;
      goto <D.22204>;
      <D.22613>:
      <D.22609>:
      <D.22605>:
      D.22607 = clause2->try_offset;
      D.22616 = clause->try_offset;
      if (D.22607 < D.22616) goto <D.22204>; else goto <D.22617>;
      <D.22617>:
      j = j + -1;
      <D.22206>:
      if (j >= 0) goto <D.22205>; else goto <D.22204>;
      <D.22204>:
      <D.22600>:
      i = i + -1;
      <D.22208>:
      if (i >= 0) goto <D.22207>; else goto <D.22209>;
      <D.22209>:
      bb = cfg->bb_entry;
      goto <D.22212>;
      <D.22211>:
      D.22618 = bb->region;
      if (D.22618 == 4294967295) goto <D.22619>; else goto <D.22620>;
      <D.22619>:
      // predicted unlikely by continue predictor.
      goto <D.22210>;
      <D.22620>:
      D.22618 = bb->region;
      D.22621 = D.22618 & 240;
      if (D.22621 == 0) goto <D.22622>; else goto <D.22623>;
      <D.22622>:
      D.22618 = bb->region;
      D.22624 = D.22618 >> 8;
      D.22625 = D.22624 + 4294967295;
      D.22626 = (long unsigned int) D.22625;
      D.22627 = D.22626 * 4;
      D.22628 = outer_try + D.22627;
      D.22629 = *D.22628;
      if (D.22629 != 0) goto <D.22630>; else goto <D.22631>;
      <D.22630>:
      // predicted unlikely by continue predictor.
      goto <D.22210>;
      <D.22631>:
      <D.22623>:
      D.22632 = cfg->verbose_level;
      if (D.22632 > 2) goto <D.22633>; else goto <D.22634>;
      <D.22633>:
      D.22635 = bb->block_num;
      printf ("pessimize variables in bb %d.\n", D.22635);
      <D.22634>:
      visit_bb (cfg, bb, &visited);
      <D.22210>:
      bb = bb->next_bb;
      <D.22212>:
      if (bb != 0B) goto <D.22211>; else goto <D.22213>;
      <D.22213>:
      visited.0 = visited;
      monoeg_g_slist_free (visited.0);
    }
  finally
    {
      visited = {CLOBBER};
    }
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__))
printf (const char * restrict __fmt)
{
  int D.22637;

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


visit_bb (struct MonoCompile * cfg, struct MonoBasicBlock * bb, struct GSList * * visited)
{
  struct GSList * D.22639;
  struct GSList * D.22640;
  short unsigned int D.22643;
  int D.22644;
  int D.22645;
  int D.22646;
  char D.22649;
  int iftmp.1;
  int D.22655;
  _Bool D.22658;
  long int D.22659;
  long int D.22660;
  unsigned int D.22665;
  unsigned int D.22666;
  struct MonoInst * * D.22669;
  long unsigned int D.22670;
  long unsigned int D.22671;
  struct MonoInst * * D.22672;
  struct MonoInst * D.22673;
  struct MonoInst * iftmp.2;
  long int D.22680;
  struct MonoMethodVar * D.22681;
  long unsigned int D.22682;
  long unsigned int D.22683;
  struct MonoInst * * D.22684;
  unsigned int D.22685;
  long unsigned int D.22686;
  long unsigned int D.22687;
  struct MonoInst * * D.22688;
  struct MonoInst * D.22689;
  unsigned char D.22690;
  unsigned char D.22691;
  struct MonoInst * iftmp.3;
  int D.22695;
  int D.22696;
  unsigned int D.22697;
  sizetype D.22700;
  sizetype D.22701;
  sizetype D.22702;
  struct MonoInst * * D.22703;
  struct MonoInst * iftmp.4;
  unsigned char D.22709;
  unsigned char D.22710;
  struct MonoInst * iftmp.5;
  int D.22712;
  unsigned int D.22713;
  sizetype D.22716;
  sizetype D.22717;
  struct MonoInst * * D.22718;
  struct MonoInst * iftmp.6;
  unsigned char D.22724;
  unsigned char D.22725;
  int D.22726;
  int D.22727;
  int D.22728;
  signed char D.22729;
  _Bool D.22730;
  long int D.22731;
  long int D.22732;
  unsigned int sreg.7;
  long unsigned int D.22738;
  long unsigned int D.22739;
  struct MonoInst * * D.22740;
  struct MonoInst * D.22741;
  struct MonoInst * iftmp.8;
  long int D.22748;
  long unsigned int D.22749;
  long unsigned int D.22750;
  unsigned int D.22751;
  long unsigned int D.22752;
  long unsigned int D.22753;
  struct MonoInst * * D.22754;
  struct MonoInst * D.22755;
  unsigned char D.22756;
  unsigned char D.22757;
  struct MonoInst * iftmp.9;
  int D.22761;
  int D.22762;
  unsigned int D.22763;
  sizetype D.22766;
  sizetype D.22767;
  sizetype D.22768;
  struct MonoInst * * D.22769;
  struct MonoInst * iftmp.10;
  unsigned char D.22775;
  unsigned char D.22776;
  struct MonoInst * iftmp.11;
  int D.22778;
  unsigned int D.22779;
  sizetype D.22782;
  sizetype D.22783;
  struct MonoInst * * D.22784;
  struct MonoInst * iftmp.12;
  unsigned char D.22790;
  unsigned char D.22791;
  struct GSList * D.22792;
  struct MonoBasicBlock * * D.22793;
  long unsigned int D.22794;
  long unsigned int D.22795;
  struct MonoBasicBlock * * D.22796;
  struct MonoBasicBlock * D.22797;
  short int D.22798;
  int D.22799;
  int i;
  struct MonoInst * ins;

  D.22639 = *visited;
  D.22640 = monoeg_g_slist_find (D.22639, bb);
  if (D.22640 != 0B) goto <D.22641>; else goto <D.22642>;
  <D.22641>:
  return;
  <D.22642>:
  ins = bb->code;
  goto <D.22185>;
  <D.22184>:
  {
    const char * spec;
    int regtype;
    int srcindex;
    int sreg;
    int num_sregs;
    int sregs[3];

    try
      {
        D.22643 = ins->opcode;
        D.22644 = (int) D.22643;
        D.22645 = D.22644 + -313;
        D.22646 = D.22645 * 4;
        spec = &ins_info[D.22646];
        D.22643 = ins->opcode;
        if (D.22643 == 316) goto <D.22647>; else goto <D.22648>;
        <D.22647>:
        // predicted unlikely by continue predictor.
        goto <D.22174>;
        <D.22648>:
        D.22649 = *spec;
        regtype = (int) D.22649;
        D.22655 = ins->dreg;
        if (D.22655 != -1) goto <D.22651>; else goto <D.22656>;
        <D.22656>:
        if (regtype != 32) goto <D.22651>; else goto <D.22652>;
        <D.22651>:
        D.22655 = ins->dreg;
        if (D.22655 == -1) goto <D.22653>; else goto <D.22657>;
        <D.22657>:
        if (regtype == 32) goto <D.22653>; else goto <D.22652>;
        <D.22653>:
        iftmp.1 = 1;
        goto <D.22654>;
        <D.22652>:
        iftmp.1 = 0;
        <D.22654>:
        D.22658 = iftmp.1 != 0;
        D.22659 = (long int) D.22658;
        D.22660 = __builtin_expect (D.22659, 0);
        if (D.22660 != 0) goto <D.22661>; else goto <D.22662>;
        <D.22661>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "liveness.c", 94, "((ins->dreg == -1) && (regtype == \' \')) || ((ins->dreg != -1) && (regtype != \' \'))");
        <D.22662>:
        D.22655 = ins->dreg;
        if (D.22655 != -1) goto <D.22663>; else goto <D.22664>;
        <D.22663>:
        D.22655 = ins->dreg;
        D.22665 = (unsigned int) D.22655;
        D.22666 = cfg->vreg_to_inst_len;
        if (D.22665 < D.22666) goto <D.22667>; else goto <D.22668>;
        <D.22667>:
        D.22669 = cfg->vreg_to_inst;
        D.22655 = ins->dreg;
        D.22670 = (long unsigned int) D.22655;
        D.22671 = D.22670 * 8;
        D.22672 = D.22669 + D.22671;
        D.22673 = *D.22672;
        if (D.22673 != 0B) goto <D.22674>; else goto <D.22675>;
        <D.22674>:
        {
          struct MonoInst * var;
          int idx;
          struct MonoMethodVar * vi;

          D.22655 = ins->dreg;
          D.22665 = (unsigned int) D.22655;
          D.22666 = cfg->vreg_to_inst_len;
          if (D.22665 < D.22666) goto <D.22677>; else goto <D.22678>;
          <D.22677>:
          D.22669 = cfg->vreg_to_inst;
          D.22655 = ins->dreg;
          D.22670 = (long unsigned int) D.22655;
          D.22671 = D.22670 * 8;
          D.22672 = D.22669 + D.22671;
          iftmp.2 = *D.22672;
          goto <D.22679>;
          <D.22678>:
          iftmp.2 = 0B;
          <D.22679>:
          var = iftmp.2;
          D.22680 = var->data.op[0].const_val;
          idx = (int) D.22680;
          D.22681 = cfg->vars;
          D.22682 = (long unsigned int) idx;
          D.22683 = D.22682 * 80;
          vi = D.22681 + D.22683;
          D.22684 = cfg->varinfo;
          D.22685 = vi->idx;
          D.22686 = (long unsigned int) D.22685;
          D.22687 = D.22686 * 8;
          D.22688 = D.22684 + D.22687;
          D.22689 = *D.22688;
          D.22684 = cfg->varinfo;
          D.22685 = vi->idx;
          D.22686 = (long unsigned int) D.22685;
          D.22687 = D.22686 * 8;
          D.22688 = D.22684 + D.22687;
          D.22689 = *D.22688;
          D.22690 = D.22689->flags;
          D.22691 = D.22690 | 4;
          D.22689->flags = D.22691;
          if (0 != 0) goto <D.22692>; else goto <D.22693>;
          <D.22692>:
          D.22695 = var->dreg;
          D.22696 = D.22695 + 1;
          D.22697 = (unsigned int) D.22696;
          D.22666 = cfg->vreg_to_inst_len;
          if (D.22697 < D.22666) goto <D.22698>; else goto <D.22699>;
          <D.22698>:
          D.22669 = cfg->vreg_to_inst;
          D.22695 = var->dreg;
          D.22700 = (sizetype) D.22695;
          D.22701 = D.22700 + 1;
          D.22702 = D.22701 * 8;
          D.22703 = D.22669 + D.22702;
          iftmp.3 = *D.22703;
          goto <D.22704>;
          <D.22699>:
          iftmp.3 = 0B;
          <D.22704>:
          D.22695 = var->dreg;
          D.22696 = D.22695 + 1;
          D.22697 = (unsigned int) D.22696;
          D.22666 = cfg->vreg_to_inst_len;
          if (D.22697 < D.22666) goto <D.22706>; else goto <D.22707>;
          <D.22706>:
          D.22669 = cfg->vreg_to_inst;
          D.22695 = var->dreg;
          D.22700 = (sizetype) D.22695;
          D.22701 = D.22700 + 1;
          D.22702 = D.22701 * 8;
          D.22703 = D.22669 + D.22702;
          iftmp.4 = *D.22703;
          goto <D.22708>;
          <D.22707>:
          iftmp.4 = 0B;
          <D.22708>:
          D.22709 = iftmp.4->flags;
          D.22710 = D.22709 | 4;
          iftmp.3->flags = D.22710;
          D.22695 = var->dreg;
          D.22712 = D.22695 + 2;
          D.22713 = (unsigned int) D.22712;
          D.22666 = cfg->vreg_to_inst_len;
          if (D.22713 < D.22666) goto <D.22714>; else goto <D.22715>;
          <D.22714>:
          D.22669 = cfg->vreg_to_inst;
          D.22695 = var->dreg;
          D.22700 = (sizetype) D.22695;
          D.22716 = D.22700 + 2;
          D.22717 = D.22716 * 8;
          D.22718 = D.22669 + D.22717;
          iftmp.5 = *D.22718;
          goto <D.22719>;
          <D.22715>:
          iftmp.5 = 0B;
          <D.22719>:
          D.22695 = var->dreg;
          D.22712 = D.22695 + 2;
          D.22713 = (unsigned int) D.22712;
          D.22666 = cfg->vreg_to_inst_len;
          if (D.22713 < D.22666) goto <D.22721>; else goto <D.22722>;
          <D.22721>:
          D.22669 = cfg->vreg_to_inst;
          D.22695 = var->dreg;
          D.22700 = (sizetype) D.22695;
          D.22716 = D.22700 + 2;
          D.22717 = D.22716 * 8;
          D.22718 = D.22669 + D.22717;
          iftmp.6 = *D.22718;
          goto <D.22723>;
          <D.22722>:
          iftmp.6 = 0B;
          <D.22723>:
          D.22724 = iftmp.6->flags;
          D.22725 = D.22724 | 4;
          iftmp.5->flags = D.22725;
          <D.22693>:
        }
        <D.22675>:
        <D.22668>:
        <D.22664>:
        D.22726 = ins->sreg1;
        sregs[0] = D.22726;
        D.22727 = ins->sreg2;
        sregs[1] = D.22727;
        D.22728 = ins->sreg3;
        sregs[2] = D.22728;
        D.22643 = ins->opcode;
        D.22644 = (int) D.22643;
        D.22645 = D.22644 + -313;
        D.22729 = ins_sreg_counts[D.22645];
        num_sregs = (int) D.22729;
        srcindex = 0;
        goto <D.22182>;
        <D.22181>:
        sreg = sregs[srcindex];
        D.22730 = sreg == -1;
        D.22731 = (long int) D.22730;
        D.22732 = __builtin_expect (D.22731, 0);
        if (D.22732 != 0) goto <D.22733>; else goto <D.22734>;
        <D.22733>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "liveness.c", 114, "sreg != -1");
        <D.22734>:
        D.22666 = cfg->vreg_to_inst_len;
        sreg.7 = (unsigned int) sreg;
        if (D.22666 > sreg.7) goto <D.22736>; else goto <D.22737>;
        <D.22736>:
        D.22669 = cfg->vreg_to_inst;
        D.22738 = (long unsigned int) sreg;
        D.22739 = D.22738 * 8;
        D.22740 = D.22669 + D.22739;
        D.22741 = *D.22740;
        if (D.22741 != 0B) goto <D.22742>; else goto <D.22743>;
        <D.22742>:
        {
          struct MonoInst * var;
          int idx;
          struct MonoMethodVar * vi;

          D.22666 = cfg->vreg_to_inst_len;
          sreg.7 = (unsigned int) sreg;
          if (D.22666 > sreg.7) goto <D.22745>; else goto <D.22746>;
          <D.22745>:
          D.22669 = cfg->vreg_to_inst;
          D.22738 = (long unsigned int) sreg;
          D.22739 = D.22738 * 8;
          D.22740 = D.22669 + D.22739;
          iftmp.8 = *D.22740;
          goto <D.22747>;
          <D.22746>:
          iftmp.8 = 0B;
          <D.22747>:
          var = iftmp.8;
          D.22748 = var->data.op[0].const_val;
          idx = (int) D.22748;
          D.22681 = cfg->vars;
          D.22749 = (long unsigned int) idx;
          D.22750 = D.22749 * 80;
          vi = D.22681 + D.22750;
          D.22684 = cfg->varinfo;
          D.22751 = vi->idx;
          D.22752 = (long unsigned int) D.22751;
          D.22753 = D.22752 * 8;
          D.22754 = D.22684 + D.22753;
          D.22755 = *D.22754;
          D.22684 = cfg->varinfo;
          D.22751 = vi->idx;
          D.22752 = (long unsigned int) D.22751;
          D.22753 = D.22752 * 8;
          D.22754 = D.22684 + D.22753;
          D.22755 = *D.22754;
          D.22756 = D.22755->flags;
          D.22757 = D.22756 | 4;
          D.22755->flags = D.22757;
          if (0 != 0) goto <D.22758>; else goto <D.22759>;
          <D.22758>:
          D.22761 = var->dreg;
          D.22762 = D.22761 + 1;
          D.22763 = (unsigned int) D.22762;
          D.22666 = cfg->vreg_to_inst_len;
          if (D.22763 < D.22666) goto <D.22764>; else goto <D.22765>;
          <D.22764>:
          D.22669 = cfg->vreg_to_inst;
          D.22761 = var->dreg;
          D.22766 = (sizetype) D.22761;
          D.22767 = D.22766 + 1;
          D.22768 = D.22767 * 8;
          D.22769 = D.22669 + D.22768;
          iftmp.9 = *D.22769;
          goto <D.22770>;
          <D.22765>:
          iftmp.9 = 0B;
          <D.22770>:
          D.22761 = var->dreg;
          D.22762 = D.22761 + 1;
          D.22763 = (unsigned int) D.22762;
          D.22666 = cfg->vreg_to_inst_len;
          if (D.22763 < D.22666) goto <D.22772>; else goto <D.22773>;
          <D.22772>:
          D.22669 = cfg->vreg_to_inst;
          D.22761 = var->dreg;
          D.22766 = (sizetype) D.22761;
          D.22767 = D.22766 + 1;
          D.22768 = D.22767 * 8;
          D.22769 = D.22669 + D.22768;
          iftmp.10 = *D.22769;
          goto <D.22774>;
          <D.22773>:
          iftmp.10 = 0B;
          <D.22774>:
          D.22775 = iftmp.10->flags;
          D.22776 = D.22775 | 4;
          iftmp.9->flags = D.22776;
          D.22761 = var->dreg;
          D.22778 = D.22761 + 2;
          D.22779 = (unsigned int) D.22778;
          D.22666 = cfg->vreg_to_inst_len;
          if (D.22779 < D.22666) goto <D.22780>; else goto <D.22781>;
          <D.22780>:
          D.22669 = cfg->vreg_to_inst;
          D.22761 = var->dreg;
          D.22766 = (sizetype) D.22761;
          D.22782 = D.22766 + 2;
          D.22783 = D.22782 * 8;
          D.22784 = D.22669 + D.22783;
          iftmp.11 = *D.22784;
          goto <D.22785>;
          <D.22781>:
          iftmp.11 = 0B;
          <D.22785>:
          D.22761 = var->dreg;
          D.22778 = D.22761 + 2;
          D.22779 = (unsigned int) D.22778;
          D.22666 = cfg->vreg_to_inst_len;
          if (D.22779 < D.22666) goto <D.22787>; else goto <D.22788>;
          <D.22787>:
          D.22669 = cfg->vreg_to_inst;
          D.22761 = var->dreg;
          D.22766 = (sizetype) D.22761;
          D.22782 = D.22766 + 2;
          D.22783 = D.22782 * 8;
          D.22784 = D.22669 + D.22783;
          iftmp.12 = *D.22784;
          goto <D.22789>;
          <D.22788>:
          iftmp.12 = 0B;
          <D.22789>:
          D.22790 = iftmp.12->flags;
          D.22791 = D.22790 | 4;
          iftmp.11->flags = D.22791;
          <D.22759>:
        }
        <D.22743>:
        <D.22737>:
        srcindex = srcindex + 1;
        <D.22182>:
        if (srcindex < num_sregs) goto <D.22181>; else goto <D.22183>;
        <D.22183>:
      }
    finally
      {
        sregs = {CLOBBER};
      }
  }
  <D.22174>:
  ins = ins->next;
  <D.22185>:
  if (ins != 0B) goto <D.22184>; else goto <D.22186>;
  <D.22186>:
  D.22639 = *visited;
  D.22792 = monoeg_g_slist_append (D.22639, bb);
  *visited = D.22792;
  i = 0;
  goto <D.22188>;
  <D.22187>:
  D.22793 = bb->out_bb;
  D.22794 = (long unsigned int) i;
  D.22795 = D.22794 * 8;
  D.22796 = D.22793 + D.22795;
  D.22797 = *D.22796;
  visit_bb (cfg, D.22797, visited);
  i = i + 1;
  <D.22188>:
  D.22798 = bb->out_count;
  D.22799 = (int) D.22798;
  if (D.22799 > i) goto <D.22187>; else goto <D.22189>;
  <D.22189>:
}


__attribute__((visibility ("hidden")))
mono_analyze_liveness (struct MonoCompile * cfg)
{
  unsigned int D.22803;
  unsigned int D.22804;
  unsigned int D.22807;
  unsigned int D.22808;
  _Bool D.22809;
  long int D.22810;
  long int D.22811;
  unsigned int D.22814;
  unsigned int max_vars.13;
  unsigned int D.22818;
  struct MonoMethodVar * D.22819;
  long unsigned int D.22820;
  long unsigned int D.22821;
  struct MonoMethodVar * D.22822;
  struct MonoBasicBlock * * D.22823;
  long unsigned int D.22824;
  struct MonoBasicBlock * * D.22825;
  struct MonoMemPool * D.22826;
  unsigned int bitsize.14;
  struct MonoBitSet * D.22828;
  struct MonoBitSet * D.22829;
  int D.22832;
  struct MonoBasicBlock * * D.22833;
  long unsigned int D.22834;
  long unsigned int D.22835;
  struct MonoBasicBlock * * D.22836;
  struct MonoBasicBlock * D.22837;
  int D.22838;
  short int D.22839;
  int D.22840;
  struct MonoBitSet * D.22843;
  struct MonoBitSet * D.22844;
  unsigned int D.22845;
  unsigned int i.15;
  unsigned int D.22847;
  long unsigned int D.22848;
  long unsigned int D.22849;
  long unsigned int D.22850;
  unsigned int l_end.16;
  long unsigned int D.22852;
  long unsigned int D.22853;
  struct MonoBasicBlock * * D.22854;
  int D.22855;
  long unsigned int D.22856;
  long unsigned int D.22857;
  gboolean * D.22858;
  struct MonoBitSet * D.22859;
  long unsigned int D.22862;
  long unsigned int D.22863;
  struct MonoBasicBlock * * D.22864;
  int D.22865;
  long unsigned int D.22866;
  long unsigned int D.22867;
  gboolean * D.22868;
  int D.22871;
  struct MonoBasicBlock * * D.22872;
  struct MonoBasicBlock * * D.22873;
  struct MonoBasicBlock * D.22874;
  int D.22875;
  short int D.22876;
  int D.22877;
  struct MonoBasicBlock * * D.22878;
  struct MonoBasicBlock * * D.22879;
  struct MonoBasicBlock * D.22880;
  int D.22881;
  short int D.22882;
  int D.22883;
  struct MonoBitSet * D.22886;
  gsize[0:] * D.22890;
  struct MonoBitSet * D.22891;
  gsize[0:] * D.22892;
  long unsigned int D.22893;
  long unsigned int D.22894;
  struct MonoBitSet * D.22895;
  struct MonoBitSet * D.22898;
  gsize[0:] * D.22899;
  struct MonoBitSet * D.22900;
  gsize[0:] * D.22901;
  long unsigned int D.22902;
  long unsigned int D.22903;
  long unsigned int D.22904;
  long unsigned int D.22905;
  long unsigned int D.22906;
  long unsigned int D.22907;
  long unsigned int D.22908;
  long unsigned int D.22909;
  long unsigned int D.22910;
  long unsigned int D.22911;
  long unsigned int D.22912;
  long unsigned int D.22913;
  long unsigned int D.22914;
  struct MonoInst * D.22917;
  short unsigned int D.22919;
  long unsigned int D.22921;
  long unsigned int D.22922;
  long unsigned int D.22923;
  long unsigned int D.22924;
  long unsigned int D.22925;
  int D.22928;
  struct MonoBitSet * D.22931;
  gsize[0:] * D.22932;
  long unsigned int D.22933;
  long unsigned int D.22934;
  long unsigned int D.22935;
  long unsigned int D.22936;
  long unsigned int D.22937;
  long unsigned int D.22938;
  long unsigned int D.22939;
  long unsigned int D.22940;
  long unsigned int D.22941;
  long unsigned int D.22942;
  long unsigned int D.22943;
  long unsigned int D.22944;
  long unsigned int D.22945;
  struct MonoBitSet * D.22946;
  int D.22949;
  long unsigned int D.22950;
  long unsigned int D.22951;
  gboolean * D.22952;
  int D.22953;
  int D.22958;
  unsigned int l_end.17;
  long unsigned int D.22960;
  long unsigned int D.22961;
  struct MonoBasicBlock * * D.22962;
  _Bool D.22963;
  long int D.22964;
  long int D.22965;
  struct MonoBitSet * D.22970;
  struct MonoBitSet * D.22973;
  gsize[0:] * D.22974;
  struct MonoBitSet * D.22975;
  gsize[0:] * D.22976;
  long unsigned int D.22977;
  long unsigned int D.22978;
  long unsigned int D.22979;
  long unsigned int D.22980;
  long unsigned int D.22981;
  long unsigned int D.22982;
  long unsigned int D.22983;
  long unsigned int D.22984;
  long unsigned int D.22985;
  long unsigned int D.22986;
  long unsigned int D.22987;
  long unsigned int D.22988;
  long unsigned int D.22989;
  int D.22990;
  int D.22991;
  struct MonoBitSet * D.22992;
  long unsigned int D.22995;
  long unsigned int D.22996;
  long unsigned int D.22997;
  struct MonoBitSet * D.22998;
  unsigned int j.18;
  unsigned int D.23000;
  long unsigned int D.23001;
  long unsigned int D.23004;
  long unsigned int D.23005;
  struct MonoMethodVar * D.23006;
  int abs_pos.19;
  long unsigned int D.23008;
  unsigned int D.23011;
  int D.23012;
  unsigned int j.20;
  struct MonoInst * * D.23015;
  unsigned int D.23016;
  long unsigned int D.23017;
  long unsigned int D.23018;
  struct MonoInst * * D.23019;
  struct MonoInst * D.23020;
  short unsigned int D.23021;
  unsigned int D.23024;
  unsigned char D.23027;
  int D.23028;
  int D.23029;
  long unsigned int D.23034;
  long unsigned int D.23035;
  struct MonoGenericSharingContext * D.23038;
  struct MonoMethod * D.23040;
  struct MonoMethodSignature * D.23041;
  long unsigned int D.23042;
  long unsigned int D.23043;
  struct MonoInst * * D.23045;
  struct MonoInst * D.23046;
  unsigned char D.23047;
  unsigned int D.23050;
  int D.23051;
  struct MonoBitSet * D.23052;
  struct MonoBitSet * D.23053;
  unsigned int D.23054;
  unsigned int D.23055;
  long unsigned int D.23056;
  long unsigned int D.23059;
  struct MonoBitSet * old_live_out_set;
  int i;
  int j;
  int max_vars;
  int out_iter;
  gboolean * in_worklist;
  struct MonoBasicBlock * * worklist;
  guint32 l_end;
  int bitsize;

  D.22803 = cfg->num_varinfo;
  max_vars = (int) D.22803;
  D.22804 = cfg->verbose_level;
  if (D.22804 > 1) goto <D.22805>; else goto <D.22806>;
  <D.22805>:
  printf ("\nLIVENESS:\n");
  <D.22806>:
  D.22807 = cfg->comp_done;
  D.22808 = D.22807 & 16;
  D.22809 = D.22808 != 0;
  D.22810 = (long int) D.22809;
  D.22811 = __builtin_expect (D.22810, 0);
  if (D.22811 != 0) goto <D.22812>; else goto <D.22813>;
  <D.22812>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "liveness.c", 316, "!(cfg->comp_done & MONO_COMP_LIVENESS)");
  <D.22813>:
  D.22807 = cfg->comp_done;
  D.22814 = D.22807 | 16;
  cfg->comp_done = D.22814;
  if (max_vars == 0) goto <D.22815>; else goto <D.22816>;
  <D.22815>:
  return;
  <D.22816>:
  max_vars.13 = (unsigned int) max_vars;
  D.22818 = mono_bitset_alloc_size (max_vars.13, 0);
  bitsize = (int) D.22818;
  i = 0;
  goto <D.22260>;
  <D.22259>:
  D.22819 = cfg->vars;
  D.22820 = (long unsigned int) i;
  D.22821 = D.22820 * 80;
  D.22822 = D.22819 + D.22821;
  D.22822->range.first_use.abs_pos = 4294967295;
  D.22819 = cfg->vars;
  D.22820 = (long unsigned int) i;
  D.22821 = D.22820 * 80;
  D.22822 = D.22819 + D.22821;
  D.22822->range.last_use.abs_pos = 0;
  D.22819 = cfg->vars;
  D.22820 = (long unsigned int) i;
  D.22821 = D.22820 * 80;
  D.22822 = D.22819 + D.22821;
  D.22822->spill_costs = 0;
  i = i + 1;
  <D.22260>:
  if (i < max_vars) goto <D.22259>; else goto <D.22261>;
  <D.22261>:
  i = 0;
  goto <D.22267>;
  <D.22266>:
  {
    struct MonoBasicBlock * bb;

    D.22823 = cfg->bblocks;
    D.22820 = (long unsigned int) i;
    D.22824 = D.22820 * 8;
    D.22825 = D.22823 + D.22824;
    bb = *D.22825;
    D.22826 = cfg->mempool;
    bitsize.14 = (unsigned int) bitsize;
    max_vars.13 = (unsigned int) max_vars;
    D.22828 = mono_bitset_mp_new (D.22826, bitsize.14, max_vars.13);
    bb->gen_set = D.22828;
    D.22826 = cfg->mempool;
    bitsize.14 = (unsigned int) bitsize;
    max_vars.13 = (unsigned int) max_vars;
    D.22829 = mono_bitset_mp_new (D.22826, bitsize.14, max_vars.13);
    bb->kill_set = D.22829;
    D.22804 = cfg->verbose_level;
    if (D.22804 > 1) goto <D.22830>; else goto <D.22831>;
    <D.22830>:
    D.22832 = bb->block_num;
    printf ("BLOCK BB%d (", D.22832);
    j = 0;
    goto <D.22264>;
    <D.22263>:
    D.22833 = bb->out_bb;
    D.22834 = (long unsigned int) j;
    D.22835 = D.22834 * 8;
    D.22836 = D.22833 + D.22835;
    D.22837 = *D.22836;
    D.22838 = D.22837->block_num;
    printf ("BB%d, ", D.22838);
    j = j + 1;
    <D.22264>:
    D.22839 = bb->out_count;
    D.22840 = (int) D.22839;
    if (D.22840 > j) goto <D.22263>; else goto <D.22265>;
    <D.22265>:
    printf ("):\n");
    <D.22831>:
    analyze_liveness_bb (cfg, bb);
    D.22804 = cfg->verbose_level;
    if (D.22804 > 1) goto <D.22841>; else goto <D.22842>;
    <D.22841>:
    D.22832 = bb->block_num;
    printf ("GEN  BB%d: ", D.22832);
    D.22843 = bb->gen_set;
    mono_bitset_print (D.22843);
    D.22832 = bb->block_num;
    printf ("KILL BB%d: ", D.22832);
    D.22844 = bb->kill_set;
    mono_bitset_print (D.22844);
    <D.22842>:
  }
  i = i + 1;
  <D.22267>:
  D.22845 = cfg->num_bblocks;
  i.15 = (unsigned int) i;
  if (D.22845 > i.15) goto <D.22266>; else goto <D.22268>;
  <D.22268>:
  max_vars.13 = (unsigned int) max_vars;
  old_live_out_set = mono_bitset_new (max_vars.13, 0);
  D.22845 = cfg->num_bblocks;
  D.22847 = D.22845 + 1;
  D.22848 = (long unsigned int) D.22847;
  D.22849 = D.22848 * 4;
  in_worklist = monoeg_malloc0 (D.22849);
  D.22845 = cfg->num_bblocks;
  D.22847 = D.22845 + 1;
  D.22848 = (long unsigned int) D.22847;
  D.22850 = D.22848 * 8;
  worklist = monoeg_malloc (D.22850);
  l_end = 0;
  i = 0;
  goto <D.22271>;
  <D.22270>:
  {
    struct MonoBasicBlock * bb;

    D.22823 = cfg->bblocks;
    D.22820 = (long unsigned int) i;
    D.22824 = D.22820 * 8;
    D.22825 = D.22823 + D.22824;
    bb = *D.22825;
    l_end.16 = l_end;
    l_end = l_end.16 + 1;
    D.22852 = (long unsigned int) l_end.16;
    D.22853 = D.22852 * 8;
    D.22854 = worklist + D.22853;
    *D.22854 = bb;
    D.22855 = bb->dfn;
    D.22856 = (long unsigned int) D.22855;
    D.22857 = D.22856 * 4;
    D.22858 = in_worklist + D.22857;
    *D.22858 = 1;
    bb->live_in_set = 0B;
    D.22826 = cfg->mempool;
    bitsize.14 = (unsigned int) bitsize;
    max_vars.13 = (unsigned int) max_vars;
    D.22859 = mono_bitset_mp_new (D.22826, bitsize.14, max_vars.13);
    bb->live_out_set = D.22859;
  }
  i = i + 1;
  <D.22271>:
  D.22845 = cfg->num_bblocks;
  i.15 = (unsigned int) i;
  if (D.22845 > i.15) goto <D.22270>; else goto <D.22272>;
  <D.22272>:
  out_iter = 0;
  D.22804 = cfg->verbose_level;
  if (D.22804 > 1) goto <D.22860>; else goto <D.22861>;
  <D.22860>:
  printf ("\nITERATION:\n");
  <D.22861>:
  goto <D.22282>;
  <D.22325>:
  {
    struct MonoBasicBlock * bb;
    struct MonoBasicBlock * out_bb;
    gboolean changed;

    l_end = l_end + 4294967295;
    D.22862 = (long unsigned int) l_end;
    D.22863 = D.22862 * 8;
    D.22864 = worklist + D.22863;
    bb = *D.22864;
    D.22865 = bb->dfn;
    D.22866 = (long unsigned int) D.22865;
    D.22867 = D.22866 * 4;
    D.22868 = in_worklist + D.22867;
    *D.22868 = 0;
    D.22804 = cfg->verbose_level;
    if (D.22804 > 1) goto <D.22869>; else goto <D.22870>;
    <D.22869>:
    D.22871 = bb->block_num;
    D.22865 = bb->dfn;
    printf ("P: BB%d(%d): IN: ", D.22871, D.22865);
    j = 0;
    goto <D.22277>;
    <D.22276>:
    D.22872 = bb->in_bb;
    D.22834 = (long unsigned int) j;
    D.22835 = D.22834 * 8;
    D.22873 = D.22872 + D.22835;
    D.22874 = *D.22873;
    D.22875 = D.22874->block_num;
    printf ("BB%d ", D.22875);
    j = j + 1;
    <D.22277>:
    D.22876 = bb->in_count;
    D.22877 = (int) D.22876;
    if (D.22877 > j) goto <D.22276>; else goto <D.22278>;
    <D.22278>:
    printf ("OUT:");
    j = 0;
    goto <D.22280>;
    <D.22279>:
    D.22878 = bb->out_bb;
    D.22834 = (long unsigned int) j;
    D.22835 = D.22834 * 8;
    D.22879 = D.22878 + D.22835;
    D.22880 = *D.22879;
    D.22881 = D.22880->block_num;
    printf ("BB%d ", D.22881);
    j = j + 1;
    <D.22280>:
    D.22882 = bb->out_count;
    D.22883 = (int) D.22882;
    if (D.22883 > j) goto <D.22279>; else goto <D.22281>;
    <D.22281>:
    printf ("\n");
    <D.22870>:
    D.22882 = bb->out_count;
    if (D.22882 == 0) goto <D.22884>; else goto <D.22885>;
    <D.22884>:
    // predicted unlikely by continue predictor.
    goto <D.22282>;
    <D.22885>:
    out_iter = out_iter + 1;
    D.22886 = bb->live_in_set;
    if (D.22886 == 0B) goto <D.22887>; else goto <D.22888>;
    <D.22887>:
    changed = 1;
    goto <D.22889>;
    <D.22888>:
    changed = 0;
    D.22890 = &old_live_out_set->data;
    D.22891 = bb->live_out_set;
    D.22892 = &D.22891->data;
    D.22893 = old_live_out_set->size;
    D.22894 = D.22893 / 8;
    memcpy (D.22890, D.22892, D.22894);
    <D.22889>:
    j = 0;
    goto <D.22305>;
    <D.22304>:
    D.22878 = bb->out_bb;
    D.22834 = (long unsigned int) j;
    D.22835 = D.22834 * 8;
    D.22879 = D.22878 + D.22835;
    out_bb = *D.22879;
    D.22895 = out_bb->live_in_set;
    if (D.22895 == 0B) goto <D.22896>; else goto <D.22897>;
    <D.22896>:
    D.22826 = cfg->mempool;
    bitsize.14 = (unsigned int) bitsize;
    max_vars.13 = (unsigned int) max_vars;
    D.22898 = mono_bitset_mp_new_noinit (D.22826, bitsize.14, max_vars.13);
    out_bb->live_in_set = D.22898;
    D.22895 = out_bb->live_in_set;
    D.22899 = &D.22895->data;
    D.22900 = out_bb->live_out_set;
    D.22901 = &D.22900->data;
    D.22895 = out_bb->live_in_set;
    D.22902 = D.22895->size;
    D.22903 = D.22902 / 8;
    memcpy (D.22899, D.22901, D.22903);
    {
      struct MonoBitSet * tmp_src;
      struct MonoBitSet * tmp_dest;
      int i;
      int size;

      tmp_src = out_bb->kill_set;
      tmp_dest = out_bb->live_in_set;
      D.22904 = tmp_dest->size;
      D.22905 = D.22904 / 64;
      size = (int) D.22905;
      i = 0;
      goto <D.22288>;
      <D.22287>:
      D.22906 = tmp_dest->data[i];
      D.22907 = tmp_src->data[i];
      D.22908 = ~D.22907;
      D.22909 = D.22906 & D.22908;
      tmp_dest->data[i] = D.22909;
      i = i + 1;
      <D.22288>:
      if (i < size) goto <D.22287>; else goto <D.22289>;
      <D.22289>:
    }
    {
      struct MonoBitSet * tmp_src;
      struct MonoBitSet * tmp_dest;
      int i;
      int size;

      tmp_src = out_bb->gen_set;
      tmp_dest = out_bb->live_in_set;
      D.22910 = tmp_dest->size;
      D.22911 = D.22910 / 64;
      size = (int) D.22911;
      i = 0;
      goto <D.22295>;
      <D.22294>:
      D.22912 = tmp_dest->data[i];
      D.22913 = tmp_src->data[i];
      D.22914 = D.22912 | D.22913;
      tmp_dest->data[i] = D.22914;
      i = i + 1;
      <D.22295>:
      if (i < size) goto <D.22294>; else goto <D.22296>;
      <D.22296>:
    }
    <D.22897>:
    D.22917 = bb->last_ins;
    if (D.22917 != 0B) goto <D.22918>; else goto <D.22915>;
    <D.22918>:
    D.22917 = bb->last_ins;
    D.22919 = D.22917->opcode;
    if (D.22919 == 798) goto <D.22920>; else goto <D.22915>;
    <D.22920>:
    goto <D.22916>;
    <D.22915>:
    {
      struct MonoBitSet * tmp_src;
      struct MonoBitSet * tmp_dest;
      int i;
      int size;

      tmp_src = out_bb->live_in_set;
      tmp_dest = bb->live_out_set;
      D.22921 = tmp_dest->size;
      D.22922 = D.22921 / 64;
      size = (int) D.22922;
      i = 0;
      goto <D.22302>;
      <D.22301>:
      D.22923 = tmp_dest->data[i];
      D.22924 = tmp_src->data[i];
      D.22925 = D.22923 | D.22924;
      tmp_dest->data[i] = D.22925;
      i = i + 1;
      <D.22302>:
      if (i < size) goto <D.22301>; else goto <D.22303>;
      <D.22303>:
    }
    <D.22916>:
    j = j + 1;
    <D.22305>:
    D.22882 = bb->out_count;
    D.22883 = (int) D.22882;
    if (D.22883 > j) goto <D.22304>; else goto <D.22306>;
    <D.22306>:
    if (changed != 0) goto <D.22926>; else goto <D.22927>;
    <D.22927>:
    D.22891 = bb->live_out_set;
    D.22928 = mono_bitset_equal (old_live_out_set, D.22891);
    if (D.22928 == 0) goto <D.22926>; else goto <D.22324>;
    <D.22926>:
    D.22886 = bb->live_in_set;
    if (D.22886 == 0B) goto <D.22929>; else goto <D.22930>;
    <D.22929>:
    D.22826 = cfg->mempool;
    bitsize.14 = (unsigned int) bitsize;
    max_vars.13 = (unsigned int) max_vars;
    D.22931 = mono_bitset_mp_new_noinit (D.22826, bitsize.14, max_vars.13);
    bb->live_in_set = D.22931;
    <D.22930>:
    D.22886 = bb->live_in_set;
    D.22932 = &D.22886->data;
    D.22891 = bb->live_out_set;
    D.22892 = &D.22891->data;
    D.22886 = bb->live_in_set;
    D.22933 = D.22886->size;
    D.22934 = D.22933 / 8;
    memcpy (D.22932, D.22892, D.22934);
    {
      struct MonoBitSet * tmp_src;
      struct MonoBitSet * tmp_dest;
      int i;
      int size;

      tmp_src = bb->kill_set;
      tmp_dest = bb->live_in_set;
      D.22935 = tmp_dest->size;
      D.22936 = D.22935 / 64;
      size = (int) D.22936;
      i = 0;
      goto <D.22312>;
      <D.22311>:
      D.22937 = tmp_dest->data[i];
      D.22938 = tmp_src->data[i];
      D.22939 = ~D.22938;
      D.22940 = D.22937 & D.22939;
      tmp_dest->data[i] = D.22940;
      i = i + 1;
      <D.22312>:
      if (i < size) goto <D.22311>; else goto <D.22313>;
      <D.22313>:
    }
    {
      struct MonoBitSet * tmp_src;
      struct MonoBitSet * tmp_dest;
      int i;
      int size;

      tmp_src = bb->gen_set;
      tmp_dest = bb->live_in_set;
      D.22941 = tmp_dest->size;
      D.22942 = D.22941 / 64;
      size = (int) D.22942;
      i = 0;
      goto <D.22319>;
      <D.22318>:
      D.22943 = tmp_dest->data[i];
      D.22944 = tmp_src->data[i];
      D.22945 = D.22943 | D.22944;
      tmp_dest->data[i] = D.22945;
      i = i + 1;
      <D.22319>:
      if (i < size) goto <D.22318>; else goto <D.22320>;
      <D.22320>:
    }
    j = 0;
    goto <D.22323>;
    <D.22322>:
    {
      struct MonoBasicBlock * in_bb;

      D.22872 = bb->in_bb;
      D.22834 = (long unsigned int) j;
      D.22835 = D.22834 * 8;
      D.22873 = D.22872 + D.22835;
      in_bb = *D.22873;
      D.22946 = in_bb->gen_set;
      if (D.22946 != 0B) goto <D.22947>; else goto <D.22948>;
      <D.22947>:
      D.22949 = in_bb->dfn;
      D.22950 = (long unsigned int) D.22949;
      D.22951 = D.22950 * 4;
      D.22952 = in_worklist + D.22951;
      D.22953 = *D.22952;
      if (D.22953 == 0) goto <D.22954>; else goto <D.22955>;
      <D.22954>:
      D.22804 = cfg->verbose_level;
      if (D.22804 > 1) goto <D.22956>; else goto <D.22957>;
      <D.22956>:
      D.22958 = in_bb->block_num;
      printf ("\tADD: %d\n", D.22958);
      <D.22957>:
      l_end.17 = l_end;
      l_end = l_end.17 + 1;
      D.22960 = (long unsigned int) l_end.17;
      D.22961 = D.22960 * 8;
      D.22962 = worklist + D.22961;
      *D.22962 = in_bb;
      D.22949 = in_bb->dfn;
      D.22950 = (long unsigned int) D.22949;
      D.22951 = D.22950 * 4;
      D.22952 = in_worklist + D.22951;
      *D.22952 = 1;
      <D.22955>:
      <D.22948>:
    }
    j = j + 1;
    <D.22323>:
    D.22876 = bb->in_count;
    D.22877 = (int) D.22876;
    if (D.22877 > j) goto <D.22322>; else goto <D.22324>;
    <D.22324>:
    D.22804 = cfg->verbose_level;
    D.22963 = D.22804 > 1;
    D.22964 = (long int) D.22963;
    D.22965 = __builtin_expect (D.22964, 0);
    if (D.22965 != 0) goto <D.22966>; else goto <D.22967>;
    <D.22966>:
    D.22871 = bb->block_num;
    printf ("\tLIVE IN  BB%d: ", D.22871);
    D.22886 = bb->live_in_set;
    mono_bitset_print (D.22886);
    <D.22967>:
  }
  <D.22282>:
  if (l_end != 0) goto <D.22325>; else goto <D.22326>;
  <D.22326>:
  D.22804 = cfg->verbose_level;
  if (D.22804 > 1) goto <D.22968>; else goto <D.22969>;
  <D.22968>:
  D.22845 = cfg->num_bblocks;
  printf ("IT: %d %d.\n", D.22845, out_iter);
  <D.22969>:
  mono_bitset_free (old_live_out_set);
  monoeg_g_free (worklist);
  monoeg_g_free (in_worklist);
  i = 0;
  goto <D.22343>;
  <D.22342>:
  {
    struct MonoBasicBlock * bb;

    D.22823 = cfg->bblocks;
    D.22820 = (long unsigned int) i;
    D.22824 = D.22820 * 8;
    D.22825 = D.22823 + D.22824;
    bb = *D.22825;
    D.22970 = bb->live_in_set;
    if (D.22970 == 0B) goto <D.22971>; else goto <D.22972>;
    <D.22971>:
    D.22826 = cfg->mempool;
    bitsize.14 = (unsigned int) bitsize;
    max_vars.13 = (unsigned int) max_vars;
    D.22973 = mono_bitset_mp_new (D.22826, bitsize.14, max_vars.13);
    bb->live_in_set = D.22973;
    D.22970 = bb->live_in_set;
    D.22974 = &D.22970->data;
    D.22975 = bb->live_out_set;
    D.22976 = &D.22975->data;
    D.22970 = bb->live_in_set;
    D.22977 = D.22970->size;
    D.22978 = D.22977 / 8;
    memcpy (D.22974, D.22976, D.22978);
    {
      struct MonoBitSet * tmp_src;
      struct MonoBitSet * tmp_dest;
      int i;
      int size;

      tmp_src = bb->kill_set;
      tmp_dest = bb->live_in_set;
      D.22979 = tmp_dest->size;
      D.22980 = D.22979 / 64;
      size = (int) D.22980;
      i = 0;
      goto <D.22333>;
      <D.22332>:
      D.22981 = tmp_dest->data[i];
      D.22982 = tmp_src->data[i];
      D.22983 = ~D.22982;
      D.22984 = D.22981 & D.22983;
      tmp_dest->data[i] = D.22984;
      i = i + 1;
      <D.22333>:
      if (i < size) goto <D.22332>; else goto <D.22334>;
      <D.22334>:
    }
    {
      struct MonoBitSet * tmp_src;
      struct MonoBitSet * tmp_dest;
      int i;
      int size;

      tmp_src = bb->gen_set;
      tmp_dest = bb->live_in_set;
      D.22985 = tmp_dest->size;
      D.22986 = D.22985 / 64;
      size = (int) D.22986;
      i = 0;
      goto <D.22340>;
      <D.22339>:
      D.22987 = tmp_dest->data[i];
      D.22988 = tmp_src->data[i];
      D.22989 = D.22987 | D.22988;
      tmp_dest->data[i] = D.22989;
      i = i + 1;
      <D.22340>:
      if (i < size) goto <D.22339>; else goto <D.22341>;
      <D.22341>:
    }
    <D.22972>:
  }
  i = i + 1;
  <D.22343>:
  D.22845 = cfg->num_bblocks;
  i.15 = (unsigned int) i;
  if (D.22845 > i.15) goto <D.22342>; else goto <D.22344>;
  <D.22344>:
  i = 0;
  goto <D.22360>;
  <D.22359>:
  {
    struct MonoBasicBlock * bb;
    guint32 max;
    guint32 abs_pos;
    struct MonoMethodVar * vars;

    D.22823 = cfg->bblocks;
    D.22820 = (long unsigned int) i;
    D.22824 = D.22820 * 8;
    D.22825 = D.22823 + D.22824;
    bb = *D.22825;
    D.22990 = bb->dfn;
    D.22991 = D.22990 << 16;
    abs_pos = (guint32) D.22991;
    vars = cfg->vars;
    D.22992 = bb->live_out_set;
    if (D.22992 == 0B) goto <D.22993>; else goto <D.22994>;
    <D.22993>:
    // predicted unlikely by continue predictor.
    goto <D.22349>;
    <D.22994>:
    D.22995 = (long unsigned int) max_vars;
    D.22996 = D.22995 + 63;
    D.22997 = D.22996 / 64;
    max = (guint32) D.22997;
    j = 0;
    goto <D.22357>;
    <D.22356>:
    {
      gsize bits_in;
      gsize bits_out;
      int k;

      D.22998 = bb->live_in_set;
      bits_in = D.22998->data[j];
      D.22992 = bb->live_out_set;
      bits_out = D.22992->data[j];
      j.18 = (unsigned int) j;
      D.23000 = j.18 * 64;
      k = (int) D.23000;
      goto <D.22354>;
      <D.22353>:
      D.23001 = bits_in & 1;
      if (D.23001 != 0) goto <D.23002>; else goto <D.23003>;
      <D.23002>:
      D.23004 = (long unsigned int) k;
      D.23005 = D.23004 * 80;
      D.23006 = vars + D.23005;
      abs_pos.19 = (int) abs_pos;
      update_live_range (D.23006, abs_pos.19);
      <D.23003>:
      D.23008 = bits_out & 1;
      if (D.23008 != 0) goto <D.23009>; else goto <D.23010>;
      <D.23009>:
      D.23004 = (long unsigned int) k;
      D.23005 = D.23004 * 80;
      D.23006 = vars + D.23005;
      D.23011 = abs_pos + 65535;
      D.23012 = (int) D.23011;
      update_live_range (D.23006, D.23012);
      <D.23010>:
      bits_in = bits_in >> 1;
      bits_out = bits_out >> 1;
      k = k + 1;
      <D.22354>:
      if (bits_in != 0) goto <D.22353>; else goto <D.23013>;
      <D.23013>:
      if (bits_out != 0) goto <D.22353>; else goto <D.22355>;
      <D.22355>:
    }
    j = j + 1;
    <D.22357>:
    j.20 = (unsigned int) j;
    if (j.20 < max) goto <D.22356>; else goto <D.22358>;
    <D.22358>:
  }
  <D.22349>:
  i = i + 1;
  <D.22360>:
  D.22845 = cfg->num_bblocks;
  i.15 = (unsigned int) i;
  if (D.22845 > i.15) goto <D.22359>; else goto <D.22361>;
  <D.22361>:
  i = 0;
  goto <D.22364>;
  <D.22363>:
  {
    struct MonoMethodVar * vi;

    D.22819 = cfg->vars;
    D.22820 = (long unsigned int) i;
    D.22821 = D.22820 * 80;
    vi = D.22819 + D.22821;
    D.23015 = cfg->varinfo;
    D.23016 = vi->idx;
    D.23017 = (long unsigned int) D.23016;
    D.23018 = D.23017 * 8;
    D.23019 = D.23015 + D.23018;
    D.23020 = *D.23019;
    D.23021 = D.23020->opcode;
    if (D.23021 == 330) goto <D.23022>; else goto <D.23023>;
    <D.23022>:
    D.23024 = vi->range.last_use.abs_pos;
    if (D.23024 == 0) goto <D.23025>; else goto <D.23026>;
    <D.23025>:
    D.23015 = cfg->varinfo;
    D.23016 = vi->idx;
    D.23017 = (long unsigned int) D.23016;
    D.23018 = D.23017 * 8;
    D.23019 = D.23015 + D.23018;
    D.23020 = *D.23019;
    D.23027 = D.23020->flags;
    D.23028 = (int) D.23027;
    D.23029 = D.23028 & 20;
    if (D.23029 == 0) goto <D.23030>; else goto <D.23031>;
    <D.23030>:
    D.23034 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.23035 = D.23034 & 256;
    if (D.23035 == 0) goto <D.23036>; else goto <D.23037>;
    <D.23036>:
    D.23038 = cfg->generic_sharing_context;
    if (D.23038 == 0B) goto <D.23032>; else goto <D.23039>;
    <D.23039>:
    D.23040 = cfg->method;
    D.23041 = mono_method_signature (D.23040);
    D.23042 = BIT_FIELD_REF <*D.23041, 64, 64>;
    D.23043 = D.23042 & 512;
    if (D.23043 == 0) goto <D.23032>; else goto <D.23044>;
    <D.23044>:
    D.23015 = cfg->varinfo;
    D.23016 = vi->idx;
    D.23017 = (long unsigned int) D.23016;
    D.23018 = D.23017 * 8;
    D.23019 = D.23015 + D.23018;
    D.23020 = *D.23019;
    D.23045 = cfg->args;
    D.23046 = *D.23045;
    if (D.23020 != D.23046) goto <D.23032>; else goto <D.23033>;
    <D.23032>:
    D.23015 = cfg->varinfo;
    D.23016 = vi->idx;
    D.23017 = (long unsigned int) D.23016;
    D.23018 = D.23017 * 8;
    D.23019 = D.23015 + D.23018;
    D.23020 = *D.23019;
    D.23015 = cfg->varinfo;
    D.23016 = vi->idx;
    D.23017 = (long unsigned int) D.23016;
    D.23018 = D.23017 * 8;
    D.23019 = D.23015 + D.23018;
    D.23020 = *D.23019;
    D.23027 = D.23020->flags;
    D.23047 = D.23027 | 2;
    D.23020->flags = D.23047;
    <D.23033>:
    <D.23037>:
    <D.23031>:
    <D.23026>:
    vi->range.first_use.abs_pos = 0;
    <D.23023>:
  }
  i = i + 1;
  <D.22364>:
  if (i < max_vars) goto <D.22363>; else goto <D.22365>;
  <D.22365>:
  D.22804 = cfg->verbose_level;
  if (D.22804 > 1) goto <D.23048>; else goto <D.23049>;
  <D.23048>:
  D.22845 = cfg->num_bblocks;
  D.23050 = D.22845 + 4294967295;
  i = (int) D.23050;
  goto <D.22368>;
  <D.22367>:
  {
    struct MonoBasicBlock * bb;

    D.22823 = cfg->bblocks;
    D.22820 = (long unsigned int) i;
    D.22824 = D.22820 * 8;
    D.22825 = D.22823 + D.22824;
    bb = *D.22825;
    D.23051 = bb->block_num;
    printf ("LIVE IN  BB%d: ", D.23051);
    D.23052 = bb->live_in_set;
    mono_bitset_print (D.23052);
    D.23051 = bb->block_num;
    printf ("LIVE OUT BB%d: ", D.23051);
    D.23053 = bb->live_out_set;
    mono_bitset_print (D.23053);
  }
  i = i + -1;
  <D.22368>:
  if (i >= 0) goto <D.22367>; else goto <D.22369>;
  <D.22369>:
  i = 0;
  goto <D.22372>;
  <D.22371>:
  {
    struct MonoMethodVar * vi;

    D.22819 = cfg->vars;
    D.22820 = (long unsigned int) i;
    D.22821 = D.22820 * 80;
    vi = D.22819 + D.22821;
    D.23054 = vi->range.first_use.abs_pos;
    D.23055 = vi->range.last_use.abs_pos;
    printf ("V%d: [0x%x - 0x%x]\n", i, D.23054, D.23055);
  }
  i = i + 1;
  <D.22372>:
  if (i < max_vars) goto <D.22371>; else goto <D.22373>;
  <D.22373>:
  <D.23049>:
  D.23034 = BIT_FIELD_REF <*cfg, 64, 5568>;
  D.23056 = D.23034 & 4096;
  if (D.23056 == 0) goto <D.23057>; else goto <D.23058>;
  <D.23057>:
  optimize_initlocals (cfg);
  <D.23058>:
  D.23034 = BIT_FIELD_REF <*cfg, 64, 5568>;
  D.23059 = D.23034 & 33554432;
  if (D.23059 != 0) goto <D.23060>; else goto <D.23061>;
  <D.23060>:
  mono_analyze_liveness2 (cfg);
  <D.23061>:
}


analyze_liveness_bb (struct MonoCompile * cfg, struct MonoBasicBlock * bb)
{
  int D.23063;
  int D.23064;
  short unsigned int D.23065;
  int D.23066;
  int D.23067;
  int D.23068;
  unsigned int D.23069;
  long int D.23076;
  struct MonoMethodVar * D.23077;
  long unsigned int D.23078;
  long unsigned int D.23079;
  int D.23082;
  struct MonoMethodVar * D.23083;
  unsigned int inst_num.21;
  unsigned int D.23085;
  int D.23086;
  struct MonoBitSet * D.23087;
  long unsigned int D.23088;
  long unsigned int D.23089;
  unsigned int idx.22;
  unsigned int D.23091;
  long unsigned int D.23092;
  long unsigned int D.23093;
  struct MonoBitSet * D.23096;
  long unsigned int D.23097;
  long unsigned int D.23098;
  long unsigned int D.23099;
  long unsigned int D.23100;
  int D.23101;
  signed char D.23102;
  int D.23103;
  int D.23104;
  int D.23105;
  int D.23106;
  int D.23107;
  int D.23108;
  int D.23109;
  signed char D.23110;
  int D.23111;
  sizetype D.23112;
  const char * D.23113;
  char D.23114;
  unsigned int D.23117;
  unsigned int sreg.23;
  struct MonoInst * * D.23121;
  long unsigned int D.23122;
  long unsigned int D.23123;
  struct MonoInst * * D.23124;
  struct MonoInst * D.23125;
  struct MonoInst * iftmp.24;
  long int D.23132;
  long unsigned int D.23133;
  long unsigned int D.23134;
  struct MonoMethodVar * D.23137;
  long unsigned int D.23138;
  long unsigned int D.23139;
  unsigned int idx.25;
  unsigned int D.23141;
  long unsigned int D.23142;
  long unsigned int D.23143;
  long unsigned int D.23146;
  long unsigned int D.23147;
  long unsigned int D.23148;
  long unsigned int D.23149;
  int D.23150;
  int D.23151;
  char D.23152;
  int D.23155;
  unsigned int D.23156;
  long unsigned int D.23159;
  long unsigned int D.23160;
  struct MonoInst * * D.23161;
  struct MonoInst * D.23162;
  struct MonoInst * iftmp.26;
  long int D.23169;
  long unsigned int D.23170;
  long unsigned int D.23171;
  short unsigned int D.23172;
  struct MonoMethodVar * D.23175;
  long unsigned int D.23176;
  long unsigned int D.23177;
  unsigned int idx.27;
  unsigned int D.23179;
  long unsigned int D.23180;
  long unsigned int D.23181;
  long unsigned int D.23184;
  long unsigned int D.23185;
  long unsigned int D.23186;
  long unsigned int D.23187;
  int D.23188;
  int D.23189;
  unsigned int D.23193;
  int D.23194;
  long unsigned int D.23195;
  long unsigned int D.23196;
  long unsigned int D.23197;
  struct MonoInst * ins;
  int sreg;
  int inst_num;
  struct MonoMethodVar * vars;
  guint32 abs_pos;

  vars = cfg->vars;
  D.23063 = bb->dfn;
  D.23064 = D.23063 << 16;
  abs_pos = (guint32) D.23064;
  inst_num = 2;
  ins = bb->code;
  goto <D.22245>;
  <D.22244>:
  {
    const char * spec;
    int num_sregs;
    int i;
    int sregs[3];

    try
      {
        D.23065 = ins->opcode;
        D.23066 = (int) D.23065;
        D.23067 = D.23066 + -313;
        D.23068 = D.23067 * 4;
        spec = &ins_info[D.23068];
        D.23069 = cfg->verbose_level;
        if (D.23069 > 1) goto <D.23070>; else goto <D.23071>;
        <D.23070>:
        printf ("\t");
        mono_print_ins (ins);
        <D.23071>:
        D.23065 = ins->opcode;
        if (D.23065 == 316) goto <D.23072>; else goto <D.23073>;
        <D.23072>:
        // predicted unlikely by continue predictor.
        goto <D.22231>;
        <D.23073>:
        D.23065 = ins->opcode;
        if (D.23065 == 314) goto <D.23074>; else goto <D.23075>;
        <D.23074>:
        {
          struct MonoInst * var;
          int idx;
          struct MonoMethodVar * vi;

          var = ins->data.op[0].p;
          D.23076 = var->data.op[0].const_val;
          idx = (int) D.23076;
          D.23077 = cfg->vars;
          D.23078 = (long unsigned int) idx;
          D.23079 = D.23078 * 80;
          vi = D.23077 + D.23079;
          D.23069 = cfg->verbose_level;
          if (D.23069 > 1) goto <D.23080>; else goto <D.23081>;
          <D.23080>:
          D.23082 = var->dreg;
          printf ("\tGEN: R%d(%d)\n", D.23082, idx);
          <D.23081>:
          D.23078 = (long unsigned int) idx;
          D.23079 = D.23078 * 80;
          D.23083 = vars + D.23079;
          inst_num.21 = (unsigned int) inst_num;
          D.23085 = abs_pos + inst_num.21;
          D.23086 = (int) D.23085;
          update_live_range (D.23083, D.23086);
          D.23087 = bb->kill_set;
          D.23078 = (long unsigned int) idx;
          D.23088 = D.23078 / 64;
          D.23089 = D.23087->data[D.23088];
          idx.22 = (unsigned int) idx;
          D.23091 = idx.22 & 63;
          D.23092 = D.23089 >> D.23091;
          D.23093 = D.23092 & 1;
          if (D.23093 == 0) goto <D.23094>; else goto <D.23095>;
          <D.23094>:
          D.23096 = bb->gen_set;
          D.23078 = (long unsigned int) idx;
          D.23097 = D.23078 / 64;
          D.23096 = bb->gen_set;
          D.23098 = D.23096->data[D.23097];
          idx.22 = (unsigned int) idx;
          D.23091 = idx.22 & 63;
          D.23099 = 1 << D.23091;
          D.23100 = D.23098 | D.23099;
          D.23096->data[D.23097] = D.23100;
          <D.23095>:
          D.23101 = vi->spill_costs;
          D.23102 = bb->nesting;
          D.23103 = (int) D.23102;
          D.23104 = D.23103 << 1;
          D.23105 = 1 << D.23104;
          D.23106 = D.23101 + D.23105;
          vi->spill_costs = D.23106;
        }
        <D.23075>:
        D.23107 = ins->sreg1;
        sregs[0] = D.23107;
        D.23108 = ins->sreg2;
        sregs[1] = D.23108;
        D.23109 = ins->sreg3;
        sregs[2] = D.23109;
        D.23065 = ins->opcode;
        D.23066 = (int) D.23065;
        D.23067 = D.23066 + -313;
        D.23110 = ins_sreg_counts[D.23067];
        num_sregs = (int) D.23110;
        i = 0;
        goto <D.22239>;
        <D.22238>:
        sreg = sregs[i];
        D.23111 = i + 1;
        D.23112 = (sizetype) D.23111;
        D.23113 = spec + D.23112;
        D.23114 = *D.23113;
        if (D.23114 != 32) goto <D.23115>; else goto <D.23116>;
        <D.23115>:
        D.23117 = cfg->vreg_to_inst_len;
        sreg.23 = (unsigned int) sreg;
        if (D.23117 > sreg.23) goto <D.23119>; else goto <D.23120>;
        <D.23119>:
        D.23121 = cfg->vreg_to_inst;
        D.23122 = (long unsigned int) sreg;
        D.23123 = D.23122 * 8;
        D.23124 = D.23121 + D.23123;
        D.23125 = *D.23124;
        if (D.23125 != 0B) goto <D.23126>; else goto <D.23127>;
        <D.23126>:
        {
          struct MonoInst * var;
          int idx;
          struct MonoMethodVar * vi;

          D.23117 = cfg->vreg_to_inst_len;
          sreg.23 = (unsigned int) sreg;
          if (D.23117 > sreg.23) goto <D.23129>; else goto <D.23130>;
          <D.23129>:
          D.23121 = cfg->vreg_to_inst;
          D.23122 = (long unsigned int) sreg;
          D.23123 = D.23122 * 8;
          D.23124 = D.23121 + D.23123;
          iftmp.24 = *D.23124;
          goto <D.23131>;
          <D.23130>:
          iftmp.24 = 0B;
          <D.23131>:
          var = iftmp.24;
          D.23132 = var->data.op[0].const_val;
          idx = (int) D.23132;
          D.23077 = cfg->vars;
          D.23133 = (long unsigned int) idx;
          D.23134 = D.23133 * 80;
          vi = D.23077 + D.23134;
          D.23069 = cfg->verbose_level;
          if (D.23069 > 1) goto <D.23135>; else goto <D.23136>;
          <D.23135>:
          printf ("\tGEN: R%d(%d)\n", sreg, idx);
          <D.23136>:
          D.23133 = (long unsigned int) idx;
          D.23134 = D.23133 * 80;
          D.23137 = vars + D.23134;
          inst_num.21 = (unsigned int) inst_num;
          D.23085 = abs_pos + inst_num.21;
          D.23086 = (int) D.23085;
          update_live_range (D.23137, D.23086);
          D.23087 = bb->kill_set;
          D.23133 = (long unsigned int) idx;
          D.23138 = D.23133 / 64;
          D.23139 = D.23087->data[D.23138];
          idx.25 = (unsigned int) idx;
          D.23141 = idx.25 & 63;
          D.23142 = D.23139 >> D.23141;
          D.23143 = D.23142 & 1;
          if (D.23143 == 0) goto <D.23144>; else goto <D.23145>;
          <D.23144>:
          D.23096 = bb->gen_set;
          D.23133 = (long unsigned int) idx;
          D.23146 = D.23133 / 64;
          D.23096 = bb->gen_set;
          D.23147 = D.23096->data[D.23146];
          idx.25 = (unsigned int) idx;
          D.23141 = idx.25 & 63;
          D.23148 = 1 << D.23141;
          D.23149 = D.23147 | D.23148;
          D.23096->data[D.23146] = D.23149;
          <D.23145>:
          D.23150 = vi->spill_costs;
          D.23102 = bb->nesting;
          D.23103 = (int) D.23102;
          D.23104 = D.23103 << 1;
          D.23105 = 1 << D.23104;
          D.23151 = D.23150 + D.23105;
          vi->spill_costs = D.23151;
        }
        <D.23127>:
        <D.23120>:
        <D.23116>:
        i = i + 1;
        <D.22239>:
        if (i < num_sregs) goto <D.22238>; else goto <D.22240>;
        <D.22240>:
        D.23152 = *spec;
        if (D.23152 != 32) goto <D.23153>; else goto <D.23154>;
        <D.23153>:
        D.23155 = ins->dreg;
        D.23156 = (unsigned int) D.23155;
        D.23117 = cfg->vreg_to_inst_len;
        if (D.23156 < D.23117) goto <D.23157>; else goto <D.23158>;
        <D.23157>:
        D.23121 = cfg->vreg_to_inst;
        D.23155 = ins->dreg;
        D.23159 = (long unsigned int) D.23155;
        D.23160 = D.23159 * 8;
        D.23161 = D.23121 + D.23160;
        D.23162 = *D.23161;
        if (D.23162 != 0B) goto <D.23163>; else goto <D.23164>;
        <D.23163>:
        {
          struct MonoInst * var;
          int idx;
          struct MonoMethodVar * vi;

          D.23155 = ins->dreg;
          D.23156 = (unsigned int) D.23155;
          D.23117 = cfg->vreg_to_inst_len;
          if (D.23156 < D.23117) goto <D.23166>; else goto <D.23167>;
          <D.23166>:
          D.23121 = cfg->vreg_to_inst;
          D.23155 = ins->dreg;
          D.23159 = (long unsigned int) D.23155;
          D.23160 = D.23159 * 8;
          D.23161 = D.23121 + D.23160;
          iftmp.26 = *D.23161;
          goto <D.23168>;
          <D.23167>:
          iftmp.26 = 0B;
          <D.23168>:
          var = iftmp.26;
          D.23169 = var->data.op[0].const_val;
          idx = (int) D.23169;
          D.23077 = cfg->vars;
          D.23170 = (long unsigned int) idx;
          D.23171 = D.23170 * 80;
          vi = D.23077 + D.23171;
          D.23065 = ins->opcode;
          D.23172 = D.23065 + 65162;
          if (D.23172 <= 13) goto <D.23173>; else goto <D.23174>;
          <D.23173>:
          D.23170 = (long unsigned int) idx;
          D.23171 = D.23170 * 80;
          D.23175 = vars + D.23171;
          inst_num.21 = (unsigned int) inst_num;
          D.23085 = abs_pos + inst_num.21;
          D.23086 = (int) D.23085;
          update_live_range (D.23175, D.23086);
          D.23087 = bb->kill_set;
          D.23170 = (long unsigned int) idx;
          D.23176 = D.23170 / 64;
          D.23177 = D.23087->data[D.23176];
          idx.27 = (unsigned int) idx;
          D.23179 = idx.27 & 63;
          D.23180 = D.23177 >> D.23179;
          D.23181 = D.23180 & 1;
          if (D.23181 == 0) goto <D.23182>; else goto <D.23183>;
          <D.23182>:
          D.23096 = bb->gen_set;
          D.23170 = (long unsigned int) idx;
          D.23184 = D.23170 / 64;
          D.23096 = bb->gen_set;
          D.23185 = D.23096->data[D.23184];
          idx.27 = (unsigned int) idx;
          D.23179 = idx.27 & 63;
          D.23186 = 1 << D.23179;
          D.23187 = D.23185 | D.23186;
          D.23096->data[D.23184] = D.23187;
          <D.23183>:
          D.23188 = vi->spill_costs;
          D.23102 = bb->nesting;
          D.23103 = (int) D.23102;
          D.23104 = D.23103 << 1;
          D.23105 = 1 << D.23104;
          D.23189 = D.23188 + D.23105;
          vi->spill_costs = D.23189;
          goto <D.23190>;
          <D.23174>:
          D.23069 = cfg->verbose_level;
          if (D.23069 > 1) goto <D.23191>; else goto <D.23192>;
          <D.23191>:
          D.23155 = ins->dreg;
          printf ("\tKILL: R%d(%d)\n", D.23155, idx);
          <D.23192>:
          D.23170 = (long unsigned int) idx;
          D.23171 = D.23170 * 80;
          D.23175 = vars + D.23171;
          inst_num.21 = (unsigned int) inst_num;
          D.23085 = abs_pos + inst_num.21;
          D.23193 = D.23085 + 1;
          D.23194 = (int) D.23193;
          update_live_range (D.23175, D.23194);
          D.23087 = bb->kill_set;
          D.23170 = (long unsigned int) idx;
          D.23195 = D.23170 / 64;
          D.23087 = bb->kill_set;
          D.23196 = D.23087->data[D.23195];
          idx.27 = (unsigned int) idx;
          D.23179 = idx.27 & 63;
          D.23186 = 1 << D.23179;
          D.23197 = D.23196 | D.23186;
          D.23087->data[D.23195] = D.23197;
          D.23188 = vi->spill_costs;
          D.23102 = bb->nesting;
          D.23103 = (int) D.23102;
          D.23104 = D.23103 << 1;
          D.23105 = 1 << D.23104;
          D.23189 = D.23188 + D.23105;
          vi->spill_costs = D.23189;
          <D.23190>:
        }
        <D.23164>:
        <D.23158>:
        <D.23154>:
      }
    finally
      {
        sregs = {CLOBBER};
      }
  }
  <D.22231>:
  ins = ins->next;
  inst_num = inst_num + 2;
  <D.22245>:
  if (ins != 0B) goto <D.22244>; else goto <D.22246>;
  <D.22246>:
}


mono_bitset_mp_new_noinit (struct MonoMemPool * mp, guint32 size, guint32 max_size)
{
  struct MonoBitSet * D.23200;
  guint8 * mem;

  mem = mono_mempool_alloc (mp, size);
  D.23200 = mono_bitset_mem_new (mem, max_size, 1);
  return D.23200;
}


mono_bitset_mp_new (struct MonoMemPool * mp, guint32 size, guint32 max_size)
{
  struct MonoBitSet * D.23202;
  guint8 * mem;

  mem = mono_mempool_alloc0 (mp, size);
  D.23202 = mono_bitset_mem_new (mem, max_size, 1);
  return D.23202;
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.23204;
  long unsigned int D.23205;

  D.23205 = __builtin_object_size (__dest, 0);
  D.23204 = __builtin___memcpy_chk (__dest, __src, __len, D.23205);
  return D.23204;
}


update_live_range (struct MonoMethodVar * var, int abs_pos)
{
  unsigned int D.23207;
  unsigned int abs_pos.28;
  unsigned int D.23211;

  D.23207 = var->range.first_use.abs_pos;
  abs_pos.28 = (unsigned int) abs_pos;
  if (D.23207 > abs_pos.28) goto <D.23209>; else goto <D.23210>;
  <D.23209>:
  abs_pos.28 = (unsigned int) abs_pos;
  var->range.first_use.abs_pos = abs_pos.28;
  <D.23210>:
  D.23211 = var->range.last_use.abs_pos;
  abs_pos.28 = (unsigned int) abs_pos;
  if (D.23211 < abs_pos.28) goto <D.23212>; else goto <D.23213>;
  <D.23212>:
  abs_pos.28 = (unsigned int) abs_pos;
  var->range.last_use.abs_pos = abs_pos.28;
  <D.23213>:
}


__attribute__((__unused__))
mono_bitset_print (struct MonoBitSet * set)
{
  unsigned int i.29;
  int D.23215;
  unsigned int D.23220;
  int i;
  gboolean first;

  first = 1;
  printf ("{");
  i = 0;
  goto <D.22159>;
  <D.22158>:
  i.29 = (unsigned int) i;
  D.23215 = mono_bitset_test (set, i.29);
  if (D.23215 != 0) goto <D.23216>; else goto <D.23217>;
  <D.23216>:
  if (first == 0) goto <D.23218>; else goto <D.23219>;
  <D.23218>:
  printf (", ");
  <D.23219>:
  printf ("%d", i);
  first = 0;
  <D.23217>:
  i = i + 1;
  <D.22159>:
  D.23220 = mono_bitset_size (set);
  i.29 = (unsigned int) i;
  if (D.23220 > i.29) goto <D.22158>; else goto <D.22160>;
  <D.22160>:
  printf ("}\n");
}


optimize_initlocals (struct MonoCompile * cfg)
{
  unsigned int D.23221;
  unsigned int D.23222;
  struct MonoBasicBlock * D.23223;
  int D.23224;
  int D.23225;
  int D.23226;
  short unsigned int D.23227;
  int D.23228;
  int D.23229;
  signed char D.23230;
  int D.23231;
  long unsigned int D.23232;
  long unsigned int D.23233;
  long unsigned int D.23234;
  unsigned int D.23235;
  unsigned int D.23236;
  long unsigned int D.23237;
  long unsigned int D.23238;
  short unsigned int D.23239;
  int D.23242;
  long unsigned int D.23243;
  long unsigned int D.23244;
  long unsigned int D.23245;
  unsigned int D.23246;
  unsigned int D.23247;
  long unsigned int D.23248;
  long unsigned int D.23249;
  int D.23250;
  char D.23251;
  struct MonoInst * iftmp.30;
  unsigned int D.23257;
  unsigned int D.23258;
  struct MonoInst * * D.23261;
  long unsigned int D.23262;
  struct MonoInst * * D.23263;
  long unsigned int D.23267;
  long unsigned int D.23268;
  long unsigned int D.23269;
  long unsigned int D.23270;
  struct MonoBitSet * D.23273;
  long int D.23274;
  long unsigned int D.23275;
  long unsigned int D.23276;
  long unsigned int D.23277;
  unsigned int D.23278;
  unsigned int D.23279;
  long unsigned int D.23280;
  long unsigned int D.23281;
  struct MonoInst * D.23284;
  unsigned char D.23287;
  int D.23288;
  int D.23289;
  long unsigned int D.23292;
  long unsigned int D.23293;
  unsigned char D.23296;
  short unsigned int D.23301;
  struct MonoMethodVar * D.23303;
  long unsigned int D.23304;
  struct MonoMethodVar * D.23305;
  int D.23306;
  int D.23307;
  struct MonoBitSet * used;
  struct MonoInst * ins;
  struct MonoBasicBlock * initlocals_bb;

  D.23221 = cfg->next_vreg;
  D.23222 = D.23221 + 1;
  used = mono_bitset_new (D.23222, 0);
  mono_bitset_clear_all (used);
  D.23223 = cfg->bb_entry;
  initlocals_bb = D.23223->next_bb;
  ins = initlocals_bb->code;
  goto <D.22387>;
  <D.22386>:
  {
    int num_sregs;
    int i;
    int sregs[3];

    try
      {
        D.23224 = ins->sreg1;
        sregs[0] = D.23224;
        D.23225 = ins->sreg2;
        sregs[1] = D.23225;
        D.23226 = ins->sreg3;
        sregs[2] = D.23226;
        D.23227 = ins->opcode;
        D.23228 = (int) D.23227;
        D.23229 = D.23228 + -313;
        D.23230 = ins_sreg_counts[D.23229];
        num_sregs = (int) D.23230;
        i = 0;
        goto <D.22384>;
        <D.22383>:
        D.23231 = sregs[i];
        D.23232 = (long unsigned int) D.23231;
        D.23233 = D.23232 / 64;
        D.23234 = used->data[D.23233];
        D.23231 = sregs[i];
        D.23235 = (unsigned int) D.23231;
        D.23236 = D.23235 & 63;
        D.23237 = 1 << D.23236;
        D.23238 = D.23234 | D.23237;
        used->data[D.23233] = D.23238;
        i = i + 1;
        <D.22384>:
        if (i < num_sregs) goto <D.22383>; else goto <D.22385>;
        <D.22385>:
        D.23227 = ins->opcode;
        D.23239 = D.23227 + 65162;
        if (D.23239 <= 13) goto <D.23240>; else goto <D.23241>;
        <D.23240>:
        D.23242 = ins->dreg;
        D.23243 = (long unsigned int) D.23242;
        D.23244 = D.23243 / 64;
        D.23245 = used->data[D.23244];
        D.23242 = ins->dreg;
        D.23246 = (unsigned int) D.23242;
        D.23247 = D.23246 & 63;
        D.23248 = 1 << D.23247;
        D.23249 = D.23245 | D.23248;
        used->data[D.23244] = D.23249;
        <D.23241>:
      }
    finally
      {
        sregs = {CLOBBER};
      }
  }
  ins = ins->next;
  <D.22387>:
  if (ins != 0B) goto <D.22386>; else goto <D.22388>;
  <D.22388>:
  ins = initlocals_bb->code;
  goto <D.22393>;
  <D.22392>:
  {
    const char * spec;

    D.23227 = ins->opcode;
    D.23228 = (int) D.23227;
    D.23229 = D.23228 + -313;
    D.23250 = D.23229 * 4;
    spec = &ins_info[D.23250];
    D.23251 = *spec;
    if (D.23251 != 32) goto <D.23252>; else goto <D.23253>;
    <D.23252>:
    D.23227 = ins->opcode;
    D.23239 = D.23227 + 65162;
    if (D.23239 > 13) goto <D.23254>; else goto <D.23255>;
    <D.23254>:
    {
      struct MonoInst * var;

      D.23242 = ins->dreg;
      D.23257 = (unsigned int) D.23242;
      D.23258 = cfg->vreg_to_inst_len;
      if (D.23257 < D.23258) goto <D.23259>; else goto <D.23260>;
      <D.23259>:
      D.23261 = cfg->vreg_to_inst;
      D.23242 = ins->dreg;
      D.23243 = (long unsigned int) D.23242;
      D.23262 = D.23243 * 8;
      D.23263 = D.23261 + D.23262;
      iftmp.30 = *D.23263;
      goto <D.23264>;
      <D.23260>:
      iftmp.30 = 0B;
      <D.23264>:
      var = iftmp.30;
      if (var != 0B) goto <D.23265>; else goto <D.23266>;
      <D.23265>:
      D.23242 = ins->dreg;
      D.23243 = (long unsigned int) D.23242;
      D.23267 = D.23243 / 64;
      D.23268 = used->data[D.23267];
      D.23242 = ins->dreg;
      D.23246 = (unsigned int) D.23242;
      D.23247 = D.23246 & 63;
      D.23269 = D.23268 >> D.23247;
      D.23270 = D.23269 & 1;
      if (D.23270 == 0) goto <D.23271>; else goto <D.23272>;
      <D.23271>:
      D.23273 = initlocals_bb->live_out_set;
      D.23274 = var->data.op[0].const_val;
      D.23275 = (long unsigned int) D.23274;
      D.23276 = D.23275 / 64;
      D.23277 = D.23273->data[D.23276];
      D.23274 = var->data.op[0].const_val;
      D.23278 = (unsigned int) D.23274;
      D.23279 = D.23278 & 63;
      D.23280 = D.23277 >> D.23279;
      D.23281 = D.23280 & 1;
      if (D.23281 == 0) goto <D.23282>; else goto <D.23283>;
      <D.23282>:
      D.23284 = cfg->ret;
      if (D.23284 != var) goto <D.23285>; else goto <D.23286>;
      <D.23285>:
      D.23287 = var->flags;
      D.23288 = (int) D.23287;
      D.23289 = D.23288 & 20;
      if (D.23289 == 0) goto <D.23290>; else goto <D.23291>;
      <D.23290>:
      D.23292 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.23293 = D.23292 & 2048;
      if (D.23293 != 0) goto <D.23294>; else goto <D.23295>;
      <D.23294>:
      D.23296 = var->type;
      if (D.23296 == 6) goto <D.23297>; else goto <D.23298>;
      <D.23297>:
      // predicted unlikely by continue predictor.
      goto <D.22391>;
      <D.23298>:
      <D.23295>:
      D.23227 = ins->opcode;
      D.23301 = D.23227 + 65174;
      if (D.23301 <= 1) goto <D.23299>; else goto <D.23302>;
      <D.23302>:
      D.23227 = ins->opcode;
      if (D.23227 == 365) goto <D.23299>; else goto <D.23300>;
      <D.23299>:
      ins->opcode = 316;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.23226 = ins->sreg3;
      ins->sreg2 = D.23226;
      D.23225 = ins->sreg2;
      ins->sreg1 = D.23225;
      D.23303 = cfg->vars;
      D.23274 = var->data.op[0].const_val;
      D.23275 = (long unsigned int) D.23274;
      D.23304 = D.23275 * 80;
      D.23305 = D.23303 + D.23304;
      D.23303 = cfg->vars;
      D.23274 = var->data.op[0].const_val;
      D.23275 = (long unsigned int) D.23274;
      D.23304 = D.23275 * 80;
      D.23305 = D.23303 + D.23304;
      D.23306 = D.23305->spill_costs;
      D.23307 = D.23306 + -1;
      D.23305->spill_costs = D.23307;
      <D.23300>:
      <D.23291>:
      <D.23286>:
      <D.23283>:
      <D.23272>:
      <D.23266>:
    }
    <D.23255>:
    <D.23253>:
  }
  <D.22391>:
  ins = ins->next;
  <D.22393>:
  if (ins != 0B) goto <D.22392>; else goto <D.22394>;
  <D.22394>:
  monoeg_g_free (used);
}


mono_analyze_liveness2 (struct MonoCompile * cfg)
{
  unsigned int disabled.31;
  const gchar * D.23311;
  _Bool D.23312;
  unsigned int disabled.32;
  unsigned int D.23316;
  struct MonoMethod * D.23319;
  char * D.23320;
  unsigned int D.23321;
  long unsigned int D.23322;
  long unsigned int D.23323;
  struct MonoMemPool * D.23324;
  long unsigned int D.23325;
  unsigned int D.23326;
  unsigned int D.23327;
  struct MonoMethodVar * D.23328;
  long unsigned int D.23329;
  long unsigned int D.23330;
  void * D.23331;
  unsigned int D.23332;
  unsigned int D.23333;
  struct MonoBasicBlock * * D.23334;
  long unsigned int D.23335;
  long unsigned int D.23336;
  struct MonoBasicBlock * * D.23337;
  int D.23338;
  int D.23339;
  unsigned int bnum.33;
  sizetype D.23343;
  sizetype D.23344;
  sizetype D.23345;
  struct MonoBasicBlock * * D.23346;
  struct MonoBasicBlock * D.23347;
  int D.23348;
  int D.23349;
  int D.23353;
  long unsigned int D.23354;
  long unsigned int D.23355;
  struct MonoBitSet * D.23356;
  unsigned int j.34;
  unsigned int D.23358;
  long unsigned int D.23359;
  struct MonoInst * * D.23364;
  long unsigned int D.23365;
  long unsigned int D.23366;
  struct MonoInst * * D.23367;
  struct MonoInst * D.23368;
  int D.23369;
  long unsigned int D.23370;
  gint32 * D.23371;
  struct MonoInst * D.23372;
  long int D.23375;
  long unsigned int D.23376;
  long unsigned int D.23377;
  gint32 * D.23378;
  long unsigned int D.23381;
  unsigned int D.23382;
  unsigned int D.23383;
  long unsigned int D.23384;
  long unsigned int D.23385;
  long unsigned int D.23386;
  struct MonoInst * * D.23387;
  long unsigned int D.23388;
  long unsigned int D.23389;
  struct MonoInst * * D.23390;
  long unsigned int D.23391;
  gint32 * D.23392;
  int D.23393;
  long unsigned int D.23398;
  struct MonoInst * * D.23399;
  struct MonoInst * D.23400;
  int D.23401;
  struct MonoLiveInterval * D.23402;
  long unsigned int D.23403;
  unsigned int D.23404;
  long unsigned int D.23405;
  long unsigned int D.23406;
  struct MonoInst * * D.23407;
  struct MonoInst * D.23408;
  short unsigned int D.23409;
  struct MonoLiveInterval * D.23412;
  int bnum;
  int idx;
  int i;
  int j;
  int nins;
  int max;
  int max_vars;
  int block_from;
  int block_to;
  int pos;
  int reverse_len;
  gint32 * last_use;
  static guint32 disabled = 4294967295;
  struct MonoInst * * reverse;

  disabled.31 = disabled;
  if (disabled.31 == 4294967295) goto <D.23309>; else goto <D.23310>;
  <D.23309>:
  D.23311 = monoeg_g_getenv ("DISABLED");
  D.23312 = D.23311 != 0B;
  disabled.32 = (unsigned int) D.23312;
  disabled = disabled.32;
  <D.23310>:
  disabled.31 = disabled;
  if (disabled.31 != 0) goto <D.23314>; else goto <D.23315>;
  <D.23314>:
  return;
  <D.23315>:
  D.23316 = cfg->verbose_level;
  if (D.23316 > 1) goto <D.23317>; else goto <D.23318>;
  <D.23317>:
  D.23319 = cfg->method;
  D.23320 = mono_method_full_name (D.23319, 1);
  printf ("LIVENESS 2 %s\n", D.23320);
  <D.23318>:
  D.23321 = cfg->num_varinfo;
  max_vars = (int) D.23321;
  D.23322 = (long unsigned int) max_vars;
  D.23323 = D.23322 * 4;
  last_use = monoeg_malloc0 (D.23323);
  reverse_len = 1024;
  D.23324 = cfg->mempool;
  D.23325 = (long unsigned int) reverse_len;
  D.23326 = (unsigned int) D.23325;
  D.23327 = D.23326 * 8;
  reverse = mono_mempool_alloc (D.23324, D.23327);
  idx = 0;
  goto <D.22487>;
  <D.22486>:
  {
    struct MonoMethodVar * vi;

    D.23328 = cfg->vars;
    D.23329 = (long unsigned int) idx;
    D.23330 = D.23329 * 80;
    vi = D.23328 + D.23330;
    D.23324 = cfg->mempool;
    D.23331 = mono_mempool_alloc0 (D.23324, 16);
    vi->interval = D.23331;
  }
  idx = idx + 1;
  <D.22487>:
  if (idx < max_vars) goto <D.22486>; else goto <D.22488>;
  <D.22488>:
  D.23332 = cfg->num_bblocks;
  D.23333 = D.23332 + 4294967295;
  bnum = (int) D.23333;
  goto <D.22513>;
  <D.22512>:
  {
    struct MonoBasicBlock * bb;
    struct MonoInst * ins;

    D.23334 = cfg->bblocks;
    D.23335 = (long unsigned int) bnum;
    D.23336 = D.23335 * 8;
    D.23337 = D.23334 + D.23336;
    bb = *D.23337;
    D.23338 = bb->dfn;
    D.23339 = D.23338 << 16;
    block_from = D.23339 + 1;
    D.23332 = cfg->num_bblocks;
    D.23333 = D.23332 + 4294967295;
    bnum.33 = (unsigned int) bnum;
    if (D.23333 > bnum.33) goto <D.23341>; else goto <D.23342>;
    <D.23341>:
    D.23334 = cfg->bblocks;
    D.23343 = (sizetype) bnum;
    D.23344 = D.23343 + 1;
    D.23345 = D.23344 * 8;
    D.23346 = D.23334 + D.23345;
    D.23347 = *D.23346;
    D.23348 = D.23347->dfn;
    D.23349 = D.23348 << 16;
    block_to = D.23349 + 1;
    goto <D.23350>;
    <D.23342>:
    D.23338 = bb->dfn;
    D.23339 = D.23338 << 16;
    block_to = D.23339 + 65535;
    <D.23350>:
    D.23316 = cfg->verbose_level;
    if (D.23316 > 1) goto <D.23351>; else goto <D.23352>;
    <D.23351>:
    D.23353 = bb->block_num;
    printf ("LIVENESS BLOCK BB%d:\n", D.23353);
    <D.23352>:
    D.23322 = (long unsigned int) max_vars;
    D.23323 = D.23322 * 4;
    memset (last_use, 0, D.23323);
    D.23322 = (long unsigned int) max_vars;
    D.23354 = D.23322 + 63;
    D.23355 = D.23354 / 64;
    max = (int) D.23355;
    j = 0;
    goto <D.22497>;
    <D.22496>:
    {
      gsize bits_out;
      int k;

      D.23356 = bb->live_out_set;
      bits_out = D.23356->data[j];
      j.34 = (unsigned int) j;
      D.23358 = j.34 * 64;
      k = (int) D.23358;
      goto <D.22494>;
      <D.22493>:
      D.23359 = bits_out & 1;
      if (D.23359 != 0) goto <D.23360>; else goto <D.23361>;
      <D.23360>:
      D.23316 = cfg->verbose_level;
      if (D.23316 > 1) goto <D.23362>; else goto <D.23363>;
      <D.23362>:
      D.23364 = cfg->varinfo;
      D.23365 = (long unsigned int) k;
      D.23366 = D.23365 * 8;
      D.23367 = D.23364 + D.23366;
      D.23368 = *D.23367;
      D.23369 = D.23368->dreg;
      printf ("Var R%d live at exit, set last_use to %x\n", D.23369, block_to);
      <D.23363>:
      D.23365 = (long unsigned int) k;
      D.23370 = D.23365 * 4;
      D.23371 = last_use + D.23370;
      *D.23371 = block_to;
      <D.23361>:
      bits_out = bits_out >> 1;
      k = k + 1;
      <D.22494>:
      if (bits_out != 0) goto <D.22493>; else goto <D.22495>;
      <D.22495>:
    }
    j = j + 1;
    <D.22497>:
    if (j < max) goto <D.22496>; else goto <D.22498>;
    <D.22498>:
    D.23372 = cfg->ret;
    if (D.23372 != 0B) goto <D.23373>; else goto <D.23374>;
    <D.23373>:
    D.23372 = cfg->ret;
    D.23375 = D.23372->data.op[0].const_val;
    D.23376 = (long unsigned int) D.23375;
    D.23377 = D.23376 * 4;
    D.23378 = last_use + D.23377;
    *D.23378 = block_to;
    <D.23374>:
    nins = 0;
    pos = block_from;
    ins = bb->code;
    goto <D.22502>;
    <D.22501>:
    if (nins >= reverse_len) goto <D.23379>; else goto <D.23380>;
    <D.23379>:
    {
      int new_reverse_len;
      struct MonoInst * * new_reverse;

      new_reverse_len = reverse_len * 2;
      D.23324 = cfg->mempool;
      D.23381 = (long unsigned int) new_reverse_len;
      D.23382 = (unsigned int) D.23381;
      D.23383 = D.23382 * 8;
      new_reverse = mono_mempool_alloc (D.23324, D.23383);
      D.23325 = (long unsigned int) reverse_len;
      D.23384 = D.23325 * 8;
      memcpy (new_reverse, reverse, D.23384);
      reverse = new_reverse;
      reverse_len = new_reverse_len;
    }
    <D.23380>:
    D.23385 = (long unsigned int) nins;
    D.23386 = D.23385 * 8;
    D.23387 = reverse + D.23386;
    *D.23387 = ins;
    ins = ins->next;
    nins = nins + 1;
    pos = pos + 1;
    <D.22502>:
    if (ins != 0B) goto <D.22501>; else goto <D.22503>;
    <D.22503>:
    i = nins + -1;
    goto <D.22506>;
    <D.22505>:
    {
      struct MonoInst * ins;

      D.23388 = (long unsigned int) i;
      D.23389 = D.23388 * 8;
      D.23390 = reverse + D.23389;
      ins = *D.23390;
      update_liveness2 (cfg, ins, 0, pos, last_use);
      pos = pos + -1;
    }
    i = i + -1;
    <D.22506>:
    if (i >= 0) goto <D.22505>; else goto <D.22507>;
    <D.22507>:
    idx = 0;
    goto <D.22510>;
    <D.22509>:
    {
      struct MonoMethodVar * vi;

      D.23328 = cfg->vars;
      D.23329 = (long unsigned int) idx;
      D.23330 = D.23329 * 80;
      vi = D.23328 + D.23330;
      D.23329 = (long unsigned int) idx;
      D.23391 = D.23329 * 4;
      D.23392 = last_use + D.23391;
      D.23393 = *D.23392;
      if (D.23393 != 0) goto <D.23394>; else goto <D.23395>;
      <D.23394>:
      D.23316 = cfg->verbose_level;
      if (D.23316 > 1) goto <D.23396>; else goto <D.23397>;
      <D.23396>:
      D.23364 = cfg->varinfo;
      D.23329 = (long unsigned int) idx;
      D.23398 = D.23329 * 8;
      D.23399 = D.23364 + D.23398;
      D.23400 = *D.23399;
      D.23401 = D.23400->dreg;
      D.23364 = cfg->varinfo;
      D.23329 = (long unsigned int) idx;
      D.23398 = D.23329 * 8;
      D.23399 = D.23364 + D.23398;
      D.23400 = *D.23399;
      D.23401 = D.23400->dreg;
      D.23329 = (long unsigned int) idx;
      D.23391 = D.23329 * 4;
      D.23392 = last_use + D.23391;
      D.23393 = *D.23392;
      printf ("Var R%d live at enter, add range to R%d: [%x, %x)\n", D.23401, D.23401, block_from, D.23393);
      <D.23397>:
      D.23402 = vi->interval;
      D.23329 = (long unsigned int) idx;
      D.23391 = D.23329 * 4;
      D.23392 = last_use + D.23391;
      D.23393 = *D.23392;
      mono_linterval_add_range (cfg, D.23402, block_from, D.23393);
      <D.23395>:
    }
    idx = idx + 1;
    <D.22510>:
    if (idx < max_vars) goto <D.22509>; else goto <D.22511>;
    <D.22511>:
  }
  bnum = bnum + -1;
  <D.22513>:
  if (bnum >= 0) goto <D.22512>; else goto <D.22514>;
  <D.22514>:
  i = 0;
  goto <D.22517>;
  <D.22516>:
  {
    struct MonoMethodVar * vi;

    D.23328 = cfg->vars;
    D.23388 = (long unsigned int) i;
    D.23403 = D.23388 * 80;
    vi = D.23328 + D.23403;
    D.23364 = cfg->varinfo;
    D.23404 = vi->idx;
    D.23405 = (long unsigned int) D.23404;
    D.23406 = D.23405 * 8;
    D.23407 = D.23364 + D.23406;
    D.23408 = *D.23407;
    D.23409 = D.23408->opcode;
    if (D.23409 == 330) goto <D.23410>; else goto <D.23411>;
    <D.23410>:
    D.23412 = vi->interval;
    mono_linterval_add_range (cfg, D.23412, 0, 1);
    <D.23411>:
  }
  i = i + 1;
  <D.22517>:
  if (i < max_vars) goto <D.22516>; else goto <D.22518>;
  <D.22518>:
  monoeg_g_free (last_use);
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
memset (void * __dest, int __ch, size_t __len)
{
  void * D.23414;
  long unsigned int D.23415;

  D.23415 = __builtin_object_size (__dest, 0);
  D.23414 = __builtin___memset_chk (__dest, __ch, __len, D.23415);
  return D.23414;
}


update_liveness2 (struct MonoCompile * cfg, struct MonoInst * ins, gboolean set_volatile, int inst_num, gint32 * last_use)
{
  short unsigned int D.23417;
  int D.23418;
  int D.23419;
  int D.23420;
  unsigned int D.23421;
  char D.23426;
  int D.23429;
  unsigned int D.23430;
  unsigned int D.23431;
  struct MonoInst * * D.23434;
  long unsigned int D.23435;
  long unsigned int D.23436;
  struct MonoInst * * D.23437;
  struct MonoInst * D.23438;
  struct MonoInst * iftmp.35;
  long int D.23445;
  struct MonoMethodVar * D.23446;
  long unsigned int D.23447;
  long unsigned int D.23448;
  short unsigned int D.23449;
  long unsigned int D.23452;
  gint32 * D.23453;
  int D.23454;
  struct MonoLiveInterval * D.23464;
  struct MonoInst * D.23468;
  unsigned char D.23471;
  int D.23472;
  int D.23473;
  short unsigned int D.23476;
  int D.23478;
  int D.23483;
  int D.23484;
  int D.23487;
  int D.23488;
  signed char D.23489;
  int D.23490;
  sizetype D.23491;
  const char * D.23492;
  char D.23493;
  unsigned int sreg.36;
  long unsigned int D.23499;
  long unsigned int D.23500;
  struct MonoInst * * D.23501;
  struct MonoInst * D.23502;
  struct MonoInst * iftmp.37;
  long int D.23509;
  long unsigned int D.23510;
  long unsigned int D.23511;
  gint32 * D.23512;
  int D.23513;
  const char * spec;
  int sreg;
  int num_sregs;
  int i;
  int sregs[3];

  try
    {
      D.23417 = ins->opcode;
      D.23418 = (int) D.23417;
      D.23419 = D.23418 + -313;
      D.23420 = D.23419 * 4;
      spec = &ins_info[D.23420];
      D.23421 = cfg->verbose_level;
      if (D.23421 > 1) goto <D.23422>; else goto <D.23423>;
      <D.23422>:
      printf ("\t%x: ", inst_num);
      mono_print_ins (ins);
      <D.23423>:
      D.23417 = ins->opcode;
      if (D.23417 == 316) goto <D.23424>; else goto <D.23425>;
      <D.23424>:
      return;
      <D.23425>:
      D.23426 = *spec;
      if (D.23426 != 32) goto <D.23427>; else goto <D.23428>;
      <D.23427>:
      D.23429 = ins->dreg;
      D.23430 = (unsigned int) D.23429;
      D.23431 = cfg->vreg_to_inst_len;
      if (D.23430 < D.23431) goto <D.23432>; else goto <D.23433>;
      <D.23432>:
      D.23434 = cfg->vreg_to_inst;
      D.23429 = ins->dreg;
      D.23435 = (long unsigned int) D.23429;
      D.23436 = D.23435 * 8;
      D.23437 = D.23434 + D.23436;
      D.23438 = *D.23437;
      if (D.23438 != 0B) goto <D.23439>; else goto <D.23440>;
      <D.23439>:
      {
        struct MonoInst * var;
        int idx;
        struct MonoMethodVar * vi;

        D.23429 = ins->dreg;
        D.23430 = (unsigned int) D.23429;
        D.23431 = cfg->vreg_to_inst_len;
        if (D.23430 < D.23431) goto <D.23442>; else goto <D.23443>;
        <D.23442>:
        D.23434 = cfg->vreg_to_inst;
        D.23429 = ins->dreg;
        D.23435 = (long unsigned int) D.23429;
        D.23436 = D.23435 * 8;
        D.23437 = D.23434 + D.23436;
        iftmp.35 = *D.23437;
        goto <D.23444>;
        <D.23443>:
        iftmp.35 = 0B;
        <D.23444>:
        var = iftmp.35;
        D.23445 = var->data.op[0].const_val;
        idx = (int) D.23445;
        D.23446 = cfg->vars;
        D.23447 = (long unsigned int) idx;
        D.23448 = D.23447 * 80;
        vi = D.23446 + D.23448;
        D.23417 = ins->opcode;
        D.23449 = D.23417 + 65162;
        if (D.23449 <= 13) goto <D.23450>; else goto <D.23451>;
        <D.23450>:
        D.23447 = (long unsigned int) idx;
        D.23452 = D.23447 * 4;
        D.23453 = last_use + D.23452;
        D.23454 = *D.23453;
        if (D.23454 == 0) goto <D.23455>; else goto <D.23456>;
        <D.23455>:
        D.23421 = cfg->verbose_level;
        if (D.23421 > 1) goto <D.23457>; else goto <D.23458>;
        <D.23457>:
        D.23429 = ins->dreg;
        printf ("\tlast use of R%d set to %x\n", D.23429, inst_num);
        <D.23458>:
        D.23447 = (long unsigned int) idx;
        D.23452 = D.23447 * 4;
        D.23453 = last_use + D.23452;
        *D.23453 = inst_num;
        <D.23456>:
        goto <D.23459>;
        <D.23451>:
        D.23447 = (long unsigned int) idx;
        D.23452 = D.23447 * 4;
        D.23453 = last_use + D.23452;
        D.23454 = *D.23453;
        if (D.23454 > 0) goto <D.23460>; else goto <D.23461>;
        <D.23460>:
        D.23421 = cfg->verbose_level;
        if (D.23421 > 1) goto <D.23462>; else goto <D.23463>;
        <D.23462>:
        D.23429 = ins->dreg;
        D.23447 = (long unsigned int) idx;
        D.23452 = D.23447 * 4;
        D.23453 = last_use + D.23452;
        D.23454 = *D.23453;
        printf ("\tadd range to R%d: [%x, %x)\n", D.23429, inst_num, D.23454);
        <D.23463>:
        D.23464 = vi->interval;
        D.23447 = (long unsigned int) idx;
        D.23452 = D.23447 * 4;
        D.23453 = last_use + D.23452;
        D.23454 = *D.23453;
        mono_linterval_add_range (cfg, D.23464, inst_num, D.23454);
        D.23447 = (long unsigned int) idx;
        D.23452 = D.23447 * 4;
        D.23453 = last_use + D.23452;
        *D.23453 = 0;
        goto <D.23465>;
        <D.23461>:
        D.23468 = cfg->ret;
        if (D.23468 != var) goto <D.23469>; else goto <D.23470>;
        <D.23469>:
        D.23471 = var->flags;
        D.23472 = (int) D.23471;
        D.23473 = D.23472 & 20;
        if (D.23473 == 0) goto <D.23474>; else goto <D.23475>;
        <D.23474>:
        D.23417 = ins->opcode;
        D.23476 = D.23417 + 65174;
        if (D.23476 <= 1) goto <D.23466>; else goto <D.23477>;
        <D.23477>:
        D.23417 = ins->opcode;
        if (D.23417 == 365) goto <D.23466>; else goto <D.23467>;
        <D.23466>:
        D.23471 = var->flags;
        D.23472 = (int) D.23471;
        D.23478 = D.23472 & 4;
        if (D.23478 == 0) goto <D.23479>; else goto <D.23480>;
        <D.23479>:
        D.23421 = cfg->verbose_level;
        if (D.23421 > 1) goto <D.23481>; else goto <D.23482>;
        <D.23481>:
        D.23429 = ins->dreg;
        printf ("\tdead def of R%d, eliminated\n", D.23429);
        <D.23482>:
        ins->opcode = 316;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.23483 = ins->sreg3;
        ins->sreg2 = D.23483;
        D.23484 = ins->sreg2;
        ins->sreg1 = D.23484;
        return;
        <D.23480>:
        <D.23467>:
        <D.23475>:
        <D.23470>:
        D.23421 = cfg->verbose_level;
        if (D.23421 > 1) goto <D.23485>; else goto <D.23486>;
        <D.23485>:
        D.23429 = ins->dreg;
        D.23429 = ins->dreg;
        D.23487 = inst_num + 1;
        printf ("\tdead def of R%d, add range to R%d: [%x, %x]\n", D.23429, D.23429, inst_num, D.23487);
        <D.23486>:
        D.23464 = vi->interval;
        D.23487 = inst_num + 1;
        mono_linterval_add_range (cfg, D.23464, inst_num, D.23487);
        <D.23465>:
        <D.23459>:
      }
      <D.23440>:
      <D.23433>:
      <D.23428>:
      D.23488 = ins->sreg1;
      sregs[0] = D.23488;
      D.23484 = ins->sreg2;
      sregs[1] = D.23484;
      D.23483 = ins->sreg3;
      sregs[2] = D.23483;
      D.23417 = ins->opcode;
      D.23418 = (int) D.23417;
      D.23419 = D.23418 + -313;
      D.23489 = ins_sreg_counts[D.23419];
      num_sregs = (int) D.23489;
      i = 0;
      goto <D.22466>;
      <D.22465>:
      sreg = sregs[i];
      D.23490 = i + 1;
      D.23491 = (sizetype) D.23490;
      D.23492 = spec + D.23491;
      D.23493 = *D.23492;
      if (D.23493 != 32) goto <D.23494>; else goto <D.23495>;
      <D.23494>:
      D.23431 = cfg->vreg_to_inst_len;
      sreg.36 = (unsigned int) sreg;
      if (D.23431 > sreg.36) goto <D.23497>; else goto <D.23498>;
      <D.23497>:
      D.23434 = cfg->vreg_to_inst;
      D.23499 = (long unsigned int) sreg;
      D.23500 = D.23499 * 8;
      D.23501 = D.23434 + D.23500;
      D.23502 = *D.23501;
      if (D.23502 != 0B) goto <D.23503>; else goto <D.23504>;
      <D.23503>:
      {
        struct MonoInst * var;
        int idx;

        D.23431 = cfg->vreg_to_inst_len;
        sreg.36 = (unsigned int) sreg;
        if (D.23431 > sreg.36) goto <D.23506>; else goto <D.23507>;
        <D.23506>:
        D.23434 = cfg->vreg_to_inst;
        D.23499 = (long unsigned int) sreg;
        D.23500 = D.23499 * 8;
        D.23501 = D.23434 + D.23500;
        iftmp.37 = *D.23501;
        goto <D.23508>;
        <D.23507>:
        iftmp.37 = 0B;
        <D.23508>:
        var = iftmp.37;
        D.23509 = var->data.op[0].const_val;
        idx = (int) D.23509;
        D.23510 = (long unsigned int) idx;
        D.23511 = D.23510 * 4;
        D.23512 = last_use + D.23511;
        D.23513 = *D.23512;
        if (D.23513 == 0) goto <D.23514>; else goto <D.23515>;
        <D.23514>:
        D.23421 = cfg->verbose_level;
        if (D.23421 > 1) goto <D.23516>; else goto <D.23517>;
        <D.23516>:
        printf ("\tlast use of R%d set to %x\n", sreg, inst_num);
        <D.23517>:
        D.23510 = (long unsigned int) idx;
        D.23511 = D.23510 * 4;
        D.23512 = last_use + D.23511;
        *D.23512 = inst_num;
        <D.23515>:
      }
      <D.23504>:
      <D.23498>:
      <D.23495>:
      i = i + 1;
      <D.22466>:
      if (i < num_sregs) goto <D.22465>; else goto <D.22467>;
      <D.22467>:
    }
  finally
    {
      sregs = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
mono_linterval_add_range (struct MonoCompile * cfg, struct MonoLiveInterval * interval, int from, int to)
{
  _Bool D.23521;
  long int D.23522;
  long int D.23523;
  int iftmp.38;
  struct MonoLiveRange2 * D.23529;
  int D.23531;
  _Bool D.23534;
  long int D.23535;
  long int D.23536;
  int D.23540;
  int D.23544;
  struct MonoMemPool * D.23550;
  struct MonoLiveRange2 * prev_range;
  struct MonoLiveRange2 * next_range;
  struct MonoLiveRange2 * new_range;

  D.23521 = to < from;
  D.23522 = (long int) D.23521;
  D.23523 = __builtin_expect (D.23522, 0);
  if (D.23523 != 0) goto <D.23524>; else goto <D.23525>;
  <D.23524>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "liveness.c", 637, "to >= from");
  <D.23525>:
  D.23529 = interval->range;
  if (D.23529 != 0B) goto <D.23530>; else goto <D.23527>;
  <D.23530>:
  D.23529 = interval->range;
  D.23531 = D.23529->from;
  if (D.23531 > from) goto <D.23532>; else goto <D.23527>;
  <D.23532>:
  D.23529 = interval->range;
  D.23531 = D.23529->from;
  if (D.23531 == to) goto <D.23533>; else goto <D.23527>;
  <D.23533>:
  iftmp.38 = 1;
  goto <D.23528>;
  <D.23527>:
  iftmp.38 = 0;
  <D.23528>:
  D.23534 = iftmp.38 != 0;
  D.23535 = (long int) D.23534;
  D.23536 = __builtin_expect (D.23535, 1);
  if (D.23536 != 0) goto <D.23537>; else goto <D.23538>;
  <D.23537>:
  D.23529 = interval->range;
  D.23529->from = from;
  return;
  <D.23538>:
  prev_range = 0B;
  next_range = interval->range;
  goto <D.22405>;
  <D.22404>:
  prev_range = next_range;
  next_range = next_range->next;
  <D.22405>:
  if (next_range != 0B) goto <D.23539>; else goto <D.22406>;
  <D.23539>:
  D.23540 = next_range->from;
  if (D.23540 <= from) goto <D.22404>; else goto <D.22406>;
  <D.22406>:
  if (prev_range != 0B) goto <D.23543>; else goto <D.23541>;
  <D.23543>:
  D.23544 = prev_range->to;
  if (D.23544 == from) goto <D.23545>; else goto <D.23541>;
  <D.23545>:
  prev_range->to = to;
  goto <D.23542>;
  <D.23541>:
  if (next_range != 0B) goto <D.23548>; else goto <D.23546>;
  <D.23548>:
  D.23540 = next_range->from;
  if (D.23540 == to) goto <D.23549>; else goto <D.23546>;
  <D.23549>:
  next_range->from = from;
  goto <D.23547>;
  <D.23546>:
  D.23550 = cfg->mempool;
  new_range = mono_mempool_alloc (D.23550, 16);
  new_range->from = from;
  new_range->to = to;
  new_range->next = 0B;
  if (prev_range != 0B) goto <D.23551>; else goto <D.23552>;
  <D.23551>:
  prev_range->next = new_range;
  goto <D.23553>;
  <D.23552>:
  interval->range = new_range;
  <D.23553>:
  if (next_range != 0B) goto <D.23554>; else goto <D.23555>;
  <D.23554>:
  new_range->next = next_range;
  goto <D.23556>;
  <D.23555>:
  interval->last_range = new_range;
  <D.23556>:
  <D.23547>:
  <D.23542>:
}


__attribute__((visibility ("hidden")))
mono_linterval_print (struct MonoLiveInterval * interval)
{
  int D.23558;
  int D.23559;
  struct MonoLiveRange2 * range;

  range = interval->range;
  goto <D.22412>;
  <D.22411>:
  D.23558 = range->from;
  D.23559 = range->to;
  printf ("[%x-%x] ", D.23558, D.23559);
  range = range->next;
  <D.22412>:
  if (range != 0B) goto <D.22411>; else goto <D.22413>;
  <D.22413>:
}


__attribute__((visibility ("hidden")))
mono_linterval_print_nl (struct MonoLiveInterval * interval)
{
  mono_linterval_print (interval);
  printf ("\n");
}


__attribute__((visibility ("hidden")))
mono_linterval_covers (struct MonoLiveInterval * interval, int pos)
{
  int D.23560;
  int D.23563;
  gboolean D.23566;
  struct MonoLiveRange2 * range;

  range = interval->range;
  goto <D.22423>;
  <D.22422>:
  D.23560 = range->from;
  if (D.23560 <= pos) goto <D.23561>; else goto <D.23562>;
  <D.23561>:
  D.23563 = range->to;
  if (D.23563 >= pos) goto <D.23564>; else goto <D.23565>;
  <D.23564>:
  D.23566 = 1;
  return D.23566;
  <D.23565>:
  <D.23562>:
  D.23560 = range->from;
  if (D.23560 > pos) goto <D.23567>; else goto <D.23568>;
  <D.23567>:
  D.23566 = 0;
  return D.23566;
  <D.23568>:
  range = range->next;
  <D.22423>:
  if (range != 0B) goto <D.22422>; else goto <D.22424>;
  <D.22424>:
  D.23566 = 0;
  return D.23566;
}


__attribute__((visibility ("hidden")))
mono_linterval_get_intersect_pos (struct MonoLiveInterval * i1, struct MonoLiveInterval * i2)
{
  int D.23570;
  int D.23571;
  int D.23574;
  int D.23575;
  gint32 D.23580;
  struct MonoLiveRange2 * r1;
  struct MonoLiveRange2 * r2;

  r1 = i1->range;
  goto <D.22435>;
  <D.22434>:
  r2 = i2->range;
  goto <D.22432>;
  <D.22431>:
  D.23570 = r2->to;
  D.23571 = r1->from;
  if (D.23570 > D.23571) goto <D.23572>; else goto <D.23573>;
  <D.23572>:
  D.23574 = r2->from;
  D.23575 = r1->to;
  if (D.23574 < D.23575) goto <D.23576>; else goto <D.23577>;
  <D.23576>:
  D.23574 = r2->from;
  D.23571 = r1->from;
  if (D.23574 <= D.23571) goto <D.23578>; else goto <D.23579>;
  <D.23578>:
  D.23580 = r1->from;
  return D.23580;
  <D.23579>:
  D.23580 = r2->from;
  return D.23580;
  <D.23577>:
  <D.23573>:
  r2 = r2->next;
  <D.22432>:
  if (r2 != 0B) goto <D.22431>; else goto <D.22433>;
  <D.22433>:
  r1 = r1->next;
  <D.22435>:
  if (r1 != 0B) goto <D.22434>; else goto <D.22436>;
  <D.22436>:
  D.23580 = -1;
  return D.23580;
}


__attribute__((visibility ("hidden")))
mono_linterval_split (struct MonoCompile * cfg, struct MonoLiveInterval * interval, struct MonoLiveInterval * * i1, struct MonoLiveInterval * * i2, int pos)
{
  int iftmp.39;
  struct MonoLiveRange2 * D.23586;
  int D.23587;
  struct MonoLiveRange2 * D.23589;
  int D.23590;
  _Bool D.23591;
  long int D.23592;
  long int D.23593;
  struct MonoMemPool * D.23596;
  void * D.23597;
  void * D.23598;
  int D.23599;
  struct MonoLiveInterval * D.23602;
  int D.23603;
  int D.23609;
  struct MonoLiveInterval * D.23610;
  struct MonoLiveRange2 * r;

  D.23586 = interval->range;
  D.23587 = D.23586->from;
  if (D.23587 >= pos) goto <D.23583>; else goto <D.23588>;
  <D.23588>:
  D.23589 = interval->last_range;
  D.23590 = D.23589->to;
  if (D.23590 < pos) goto <D.23583>; else goto <D.23584>;
  <D.23583>:
  iftmp.39 = 1;
  goto <D.23585>;
  <D.23584>:
  iftmp.39 = 0;
  <D.23585>:
  D.23591 = iftmp.39 != 0;
  D.23592 = (long int) D.23591;
  D.23593 = __builtin_expect (D.23592, 0);
  if (D.23593 != 0) goto <D.23594>; else goto <D.23595>;
  <D.23594>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "liveness.c", 752, "pos > interval->range->from && pos <= interval->last_range->to");
  <D.23595>:
  D.23596 = cfg->mempool;
  D.23597 = mono_mempool_alloc0 (D.23596, 16);
  *i1 = D.23597;
  D.23596 = cfg->mempool;
  D.23598 = mono_mempool_alloc0 (D.23596, 16);
  *i2 = D.23598;
  r = interval->range;
  goto <D.22446>;
  <D.22445>:
  D.23599 = r->to;
  if (D.23599 < pos) goto <D.23600>; else goto <D.23601>;
  <D.23600>:
  D.23602 = *i1;
  D.23603 = r->from;
  D.23599 = r->to;
  mono_linterval_add_range (cfg, D.23602, D.23603, D.23599);
  goto <D.23604>;
  <D.23601>:
  D.23603 = r->from;
  if (D.23603 < pos) goto <D.23607>; else goto <D.23605>;
  <D.23607>:
  D.23599 = r->to;
  if (D.23599 >= pos) goto <D.23608>; else goto <D.23605>;
  <D.23608>:
  D.23602 = *i1;
  D.23603 = r->from;
  D.23609 = pos + -1;
  mono_linterval_add_range (cfg, D.23602, D.23603, D.23609);
  D.23610 = *i2;
  D.23599 = r->to;
  mono_linterval_add_range (cfg, D.23610, pos, D.23599);
  goto <D.23606>;
  <D.23605>:
  D.23610 = *i2;
  D.23603 = r->from;
  D.23599 = r->to;
  mono_linterval_add_range (cfg, D.23610, D.23603, D.23599);
  <D.23606>:
  <D.23604>:
  r = r->next;
  <D.22446>:
  if (r != 0B) goto <D.22445>; else goto <D.22447>;
  <D.22447>:
}


__attribute__((visibility ("hidden")))
mono_analyze_liveness_gc (struct MonoCompile * cfg)
{
  unsigned int D.23611;
  unsigned int D.23614;
  long unsigned int D.23615;
  long unsigned int D.23616;
  unsigned int D.23617;
  long unsigned int D.23618;
  long unsigned int D.23619;
  struct MonoMethodVar * D.23620;
  long unsigned int D.23621;
  long unsigned int D.23622;
  int D.23623;
  long unsigned int D.23624;
  long unsigned int D.23625;
  struct MonoMethodVar * * D.23626;
  struct MonoMemPool * D.23627;
  long unsigned int D.23628;
  unsigned int D.23629;
  unsigned int D.23630;
  int D.23631;
  int D.23632;
  int D.23635;
  struct MonoInst * D.23636;
  long unsigned int D.23639;
  long unsigned int D.23640;
  struct MonoBitSet * D.23641;
  unsigned int j.40;
  unsigned int D.23645;
  long unsigned int D.23646;
  struct MonoInst * * D.23649;
  long unsigned int D.23650;
  long unsigned int D.23651;
  struct MonoInst * * D.23652;
  struct MonoInst * D.23653;
  unsigned char D.23654;
  signed char D.23655;
  long unsigned int D.23660;
  gint32 * D.23661;
  long unsigned int D.23664;
  unsigned int D.23665;
  unsigned int D.23666;
  long unsigned int D.23667;
  long unsigned int D.23668;
  long unsigned int D.23669;
  struct MonoInst * * D.23670;
  long unsigned int D.23671;
  long unsigned int D.23672;
  struct MonoInst * * D.23673;
  struct GSList * callsites.41;
  int idx;
  int i;
  int j;
  int nins;
  int max;
  int max_vars;
  int block_from;
  int block_to;
  int pos;
  int reverse_len;
  gint32 * last_use;
  struct MonoInst * * reverse;
  struct MonoMethodVar * * vreg_to_varinfo;
  struct MonoBasicBlock * bb;
  struct GSList * callsites;

  try
    {
      vreg_to_varinfo = 0B;
      D.23611 = cfg->verbose_level;
      if (D.23611 > 1) goto <D.23612>; else goto <D.23613>;
      <D.23612>:
      printf ("\n------------ GC LIVENESS: ----------\n");
      <D.23613>:
      D.23614 = cfg->num_varinfo;
      max_vars = (int) D.23614;
      D.23615 = (long unsigned int) max_vars;
      D.23616 = D.23615 * 4;
      last_use = monoeg_malloc0 (D.23616);
      D.23617 = cfg->next_vreg;
      D.23618 = (long unsigned int) D.23617;
      D.23619 = D.23618 * 8;
      vreg_to_varinfo = monoeg_malloc0 (D.23619);
      idx = 0;
      goto <D.22561>;
      <D.22560>:
      {
        struct MonoMethodVar * vi;

        D.23620 = cfg->vars;
        D.23621 = (long unsigned int) idx;
        D.23622 = D.23621 * 80;
        vi = D.23620 + D.23622;
        D.23623 = vi->vreg;
        D.23624 = (long unsigned int) D.23623;
        D.23625 = D.23624 * 8;
        D.23626 = vreg_to_varinfo + D.23625;
        *D.23626 = vi;
      }
      idx = idx + 1;
      <D.22561>:
      if (idx < max_vars) goto <D.22560>; else goto <D.22562>;
      <D.22562>:
      reverse_len = 1024;
      D.23627 = cfg->mempool;
      D.23628 = (long unsigned int) reverse_len;
      D.23629 = (unsigned int) D.23628;
      D.23630 = D.23629 * 8;
      reverse = mono_mempool_alloc (D.23627, D.23630);
      bb = cfg->bb_entry;
      goto <D.22585>;
      <D.22584>:
      {
        struct MonoInst * ins;

        block_from = bb->real_native_offset;
        D.23631 = bb->native_offset;
        D.23632 = bb->native_length;
        block_to = D.23631 + D.23632;
        D.23611 = cfg->verbose_level;
        if (D.23611 > 1) goto <D.23633>; else goto <D.23634>;
        <D.23633>:
        D.23635 = bb->block_num;
        printf ("GC LIVENESS BB%d:\n", D.23635);
        <D.23634>:
        D.23636 = bb->code;
        if (D.23636 == 0B) goto <D.23637>; else goto <D.23638>;
        <D.23637>:
        // predicted unlikely by continue predictor.
        goto <D.22564>;
        <D.23638>:
        D.23615 = (long unsigned int) max_vars;
        D.23616 = D.23615 * 4;
        memset (last_use, 0, D.23616);
        D.23615 = (long unsigned int) max_vars;
        D.23639 = D.23615 + 63;
        D.23640 = D.23639 / 64;
        max = (int) D.23640;
        j = 0;
        goto <D.22573>;
        <D.22572>:
        {
          gsize bits_out;
          int k;

          D.23641 = bb->live_out_set;
          if (D.23641 == 0B) goto <D.23642>; else goto <D.23643>;
          <D.23642>:
          // predicted unlikely by continue predictor.
          goto <D.22567>;
          <D.23643>:
          D.23641 = bb->live_out_set;
          bits_out = D.23641->data[j];
          j.40 = (unsigned int) j;
          D.23645 = j.40 * 64;
          k = (int) D.23645;
          goto <D.22570>;
          <D.22569>:
          D.23646 = bits_out & 1;
          if (D.23646 != 0) goto <D.23647>; else goto <D.23648>;
          <D.23647>:
          D.23649 = cfg->varinfo;
          D.23650 = (long unsigned int) k;
          D.23651 = D.23650 * 8;
          D.23652 = D.23649 + D.23651;
          D.23653 = *D.23652;
          D.23654 = D.23653->flags;
          D.23655 = (signed char) D.23654;
          if (D.23655 < 0) goto <D.23656>; else goto <D.23657>;
          <D.23656>:
          {
            int vreg;

            D.23649 = cfg->varinfo;
            D.23650 = (long unsigned int) k;
            D.23651 = D.23650 * 8;
            D.23652 = D.23649 + D.23651;
            D.23653 = *D.23652;
            vreg = get_vreg_from_var (cfg, D.23653);
            D.23611 = cfg->verbose_level;
            if (D.23611 > 1) goto <D.23658>; else goto <D.23659>;
            <D.23658>:
            printf ("Var R%d live at exit, last_use set to %x.\n", vreg, block_to);
            <D.23659>:
            D.23650 = (long unsigned int) k;
            D.23660 = D.23650 * 4;
            D.23661 = last_use + D.23660;
            *D.23661 = block_to;
          }
          <D.23657>:
          <D.23648>:
          bits_out = bits_out >> 1;
          k = k + 1;
          <D.22570>:
          if (bits_out != 0) goto <D.22569>; else goto <D.22571>;
          <D.22571>:
        }
        <D.22567>:
        j = j + 1;
        <D.22573>:
        if (j < max) goto <D.22572>; else goto <D.22574>;
        <D.22574>:
        nins = 0;
        pos = block_from;
        ins = bb->code;
        goto <D.22578>;
        <D.22577>:
        if (nins >= reverse_len) goto <D.23662>; else goto <D.23663>;
        <D.23662>:
        {
          int new_reverse_len;
          struct MonoInst * * new_reverse;

          new_reverse_len = reverse_len * 2;
          D.23627 = cfg->mempool;
          D.23664 = (long unsigned int) new_reverse_len;
          D.23665 = (unsigned int) D.23664;
          D.23666 = D.23665 * 8;
          new_reverse = mono_mempool_alloc (D.23627, D.23666);
          D.23628 = (long unsigned int) reverse_len;
          D.23667 = D.23628 * 8;
          memcpy (new_reverse, reverse, D.23667);
          reverse = new_reverse;
          reverse_len = new_reverse_len;
        }
        <D.23663>:
        D.23668 = (long unsigned int) nins;
        D.23669 = D.23668 * 8;
        D.23670 = reverse + D.23669;
        *D.23670 = ins;
        ins = ins->next;
        nins = nins + 1;
        pos = pos + 1;
        <D.22578>:
        if (ins != 0B) goto <D.22577>; else goto <D.22579>;
        <D.22579>:
        callsites = 0B;
        i = nins + -1;
        goto <D.22582>;
        <D.22581>:
        {
          struct MonoInst * ins;

          D.23671 = (long unsigned int) i;
          D.23672 = D.23671 * 8;
          D.23673 = reverse + D.23672;
          ins = *D.23673;
          update_liveness_gc (cfg, bb, ins, last_use, vreg_to_varinfo, &callsites);
        }
        i = i + -1;
        <D.22582>:
        if (i >= 0) goto <D.22581>; else goto <D.22583>;
        <D.22583>:
        callsites.41 = callsites;
        bb->gc_callsites = callsites.41;
      }
      <D.22564>:
      bb = bb->next_bb;
      <D.22585>:
      if (bb != 0B) goto <D.22584>; else goto <D.22586>;
      <D.22586>:
      monoeg_g_free (last_use);
      monoeg_g_free (vreg_to_varinfo);
    }
  finally
    {
      callsites = {CLOBBER};
    }
}


get_vreg_from_var (struct MonoCompile * cfg, struct MonoInst * var)
{
  short unsigned int D.23675;
  int D.23678;
  struct MonoMethodVar * D.23679;
  long int D.23680;
  long unsigned int D.23681;
  long unsigned int D.23682;
  struct MonoMethodVar * D.23683;

  D.23675 = var->opcode;
  if (D.23675 == 366) goto <D.23676>; else goto <D.23677>;
  <D.23676>:
  D.23679 = cfg->vars;
  D.23680 = var->data.op[0].const_val;
  D.23681 = (long unsigned int) D.23680;
  D.23682 = D.23681 * 80;
  D.23683 = D.23679 + D.23682;
  D.23678 = D.23683->vreg;
  return D.23678;
  <D.23677>:
  D.23678 = var->dreg;
  return D.23678;
}


update_liveness_gc (struct MonoCompile * cfg, struct MonoBasicBlock * bb, struct MonoInst * ins, gint32 * last_use, struct MonoMethodVar * * vreg_to_varinfo, struct GSList * * callsites)
{
  short unsigned int D.23685;
  short unsigned int D.23686;
  long int D.23689;
  long unsigned int D.23690;
  long unsigned int D.23691;
  struct MonoMethodVar * * D.23692;
  unsigned int D.23693;
  unsigned int D.23694;
  long unsigned int D.23699;
  long unsigned int D.23700;
  gint32 * D.23701;
  int D.23702;
  struct GSList * D.23715;
  _Bool D.23716;
  long int D.23717;
  long int D.23718;
  struct MonoMemPool * D.23721;
  struct GSList * D.23722;
  struct GSList * D.23723;
  unsigned char D.23725;
  signed char D.23726;
  int D.23731;
  unsigned int D.23734;
  long unsigned int D.23735;
  long unsigned int D.23736;
  long unsigned int D.23737;
  unsigned int D.23738;
  void * D.23739;
  long unsigned int D.23740;
  long unsigned int D.23741;
  gint32 * D.23742;
  int D.23743;
  struct MonoMethodVar * D.23748;
  long unsigned int D.23749;
  struct MonoMethodVar * D.23750;
  int D.23751;
  guint8 * D.23752;
  int D.23753;
  sizetype D.23754;
  guint8 * D.23755;
  unsigned char D.23756;
  signed char D.23757;
  int D.23758;
  int D.23759;
  signed char D.23760;
  signed char D.23761;
  unsigned char D.23762;
  unsigned int i.42;
  struct GSList * D.23766;

  D.23685 = ins->opcode;
  D.23686 = D.23685 + 64698;
  if (D.23686 <= 1) goto <D.23687>; else goto <D.23688>;
  <D.23687>:
  {
    int vreg;
    struct MonoMethodVar * vi;
    int idx;
    int pc_offset;

    D.23689 = ins->data.op[1].const_val;
    vreg = (int) D.23689;
    D.23690 = (long unsigned int) vreg;
    D.23691 = D.23690 * 8;
    D.23692 = vreg_to_varinfo + D.23691;
    vi = *D.23692;
    D.23693 = vi->idx;
    idx = (int) D.23693;
    pc_offset = ins->backend.pc_offset;
    D.23694 = cfg->verbose_level;
    if (D.23694 > 1) goto <D.23695>; else goto <D.23696>;
    <D.23695>:
    printf ("\t%x: ", pc_offset);
    mono_print_ins (ins);
    <D.23696>:
    D.23685 = ins->opcode;
    if (D.23685 == 838) goto <D.23697>; else goto <D.23698>;
    <D.23697>:
    D.23699 = (long unsigned int) idx;
    D.23700 = D.23699 * 4;
    D.23701 = last_use + D.23700;
    D.23702 = *D.23701;
    if (D.23702 > 0) goto <D.23703>; else goto <D.23704>;
    <D.23703>:
    D.23694 = cfg->verbose_level;
    if (D.23694 > 1) goto <D.23705>; else goto <D.23706>;
    <D.23705>:
    D.23699 = (long unsigned int) idx;
    D.23700 = D.23699 * 4;
    D.23701 = last_use + D.23700;
    D.23702 = *D.23701;
    printf ("\tadd range to R%d: [%x, %x)\n", vreg, pc_offset, D.23702);
    <D.23706>:
    D.23699 = (long unsigned int) idx;
    D.23700 = D.23699 * 4;
    D.23701 = last_use + D.23700;
    *D.23701 = 0;
    <D.23704>:
    goto <D.23707>;
    <D.23698>:
    D.23699 = (long unsigned int) idx;
    D.23700 = D.23699 * 4;
    D.23701 = last_use + D.23700;
    D.23702 = *D.23701;
    if (D.23702 == 0) goto <D.23708>; else goto <D.23709>;
    <D.23708>:
    D.23694 = cfg->verbose_level;
    if (D.23694 > 1) goto <D.23710>; else goto <D.23711>;
    <D.23710>:
    printf ("\tlast use of R%d set to %x\n", vreg, pc_offset);
    <D.23711>:
    D.23699 = (long unsigned int) idx;
    D.23700 = D.23699 * 4;
    D.23701 = last_use + D.23700;
    *D.23701 = pc_offset;
    <D.23709>:
    <D.23707>:
  }
  goto <D.23712>;
  <D.23688>:
  D.23685 = ins->opcode;
  if (D.23685 == 841) goto <D.23713>; else goto <D.23714>;
  <D.23713>:
  {
    struct GCCallSite * last;

    D.23715 = *callsites;
    D.23716 = D.23715 == 0B;
    D.23717 = (long int) D.23716;
    D.23718 = __builtin_expect (D.23717, 0);
    if (D.23718 != 0) goto <D.23719>; else goto <D.23720>;
    <D.23719>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "liveness.c", 1003, "*callsites");
    <D.23720>:
    D.23715 = *callsites;
    last = D.23715->data;
    D.23721 = cfg->mempool;
    D.23722 = last->param_slots;
    D.23723 = g_slist_prepend_mempool (D.23721, D.23722, ins);
    last->param_slots = D.23723;
  }
  goto <D.23724>;
  <D.23714>:
  D.23725 = ins->flags;
  D.23726 = (signed char) D.23725;
  if (D.23726 < 0) goto <D.23727>; else goto <D.23728>;
  <D.23727>:
  {
    struct GCCallSite * callsite;
    int i;

    D.23721 = cfg->mempool;
    callsite = mono_mempool_alloc0 (D.23721, 32);
    D.23694 = cfg->verbose_level;
    if (D.23694 > 1) goto <D.23729>; else goto <D.23730>;
    <D.23729>:
    D.23731 = ins->backend.pc_offset;
    printf ("\t%x: ", D.23731);
    mono_print_ins (ins);
    <D.23730>:
    D.23694 = cfg->verbose_level;
    if (D.23694 > 1) goto <D.23732>; else goto <D.23733>;
    <D.23732>:
    printf ("\t\tlive: ");
    <D.23733>:
    callsite->bb = bb;
    D.23721 = cfg->mempool;
    D.23734 = cfg->num_varinfo;
    D.23735 = (long unsigned int) D.23734;
    D.23736 = D.23735 + 7;
    D.23737 = D.23736 >> 3;
    D.23738 = (unsigned int) D.23737;
    D.23739 = mono_mempool_alloc0 (D.23721, D.23738);
    callsite->liveness = D.23739;
    D.23731 = ins->backend.pc_offset;
    callsite->pc_offset = D.23731;
    i = 0;
    goto <D.22535>;
    <D.22534>:
    D.23740 = (long unsigned int) i;
    D.23741 = D.23740 * 4;
    D.23742 = last_use + D.23741;
    D.23743 = *D.23742;
    if (D.23743 != 0) goto <D.23744>; else goto <D.23745>;
    <D.23744>:
    D.23694 = cfg->verbose_level;
    if (D.23694 > 1) goto <D.23746>; else goto <D.23747>;
    <D.23746>:
    D.23748 = cfg->vars;
    D.23740 = (long unsigned int) i;
    D.23749 = D.23740 * 80;
    D.23750 = D.23748 + D.23749;
    D.23751 = D.23750->vreg;
    printf ("R%d", D.23751);
    <D.23747>:
    D.23752 = callsite->liveness;
    D.23753 = i / 8;
    D.23754 = (sizetype) D.23753;
    D.23755 = D.23752 + D.23754;
    D.23752 = callsite->liveness;
    D.23754 = (sizetype) D.23753;
    D.23755 = D.23752 + D.23754;
    D.23756 = *D.23755;
    D.23757 = (signed char) D.23756;
    D.23758 = i % 8;
    D.23759 = 1 << D.23758;
    D.23760 = (signed char) D.23759;
    D.23761 = D.23757 | D.23760;
    D.23762 = (unsigned char) D.23761;
    *D.23755 = D.23762;
    <D.23745>:
    i = i + 1;
    <D.22535>:
    D.23734 = cfg->num_varinfo;
    i.42 = (unsigned int) i;
    if (D.23734 > i.42) goto <D.22534>; else goto <D.22536>;
    <D.22536>:
    D.23694 = cfg->verbose_level;
    if (D.23694 > 1) goto <D.23764>; else goto <D.23765>;
    <D.23764>:
    printf ("\n");
    <D.23765>:
    D.23721 = cfg->mempool;
    D.23715 = *callsites;
    D.23766 = g_slist_prepend_mempool (D.23721, D.23715, callsite);
    *callsites = D.23766;
  }
  <D.23728>:
  <D.23724>:
  <D.23712>:
}


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

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


