mono_liveness_handle_exception_clauses (struct MonoCompile * cfg)
{
  <unnamed-unsigned:15> D.22668;
  unsigned int D.22669;
  unsigned int D.22670;
  struct MonoMemPool * D.22671;
  long unsigned int D.22672;
  long unsigned int D.22673;
  gboolean * D.22674;
  int D.22675;
  struct MonoExceptionClause * D.22676;
  long unsigned int D.22677;
  unsigned int D.22678;
  long unsigned int D.22681;
  long unsigned int D.22682;
  unsigned int D.22683;
  unsigned int D.22686;
  unsigned int D.22687;
  unsigned int D.22690;
  unsigned int D.22691;
  long unsigned int D.22694;
  gboolean * D.22695;
  unsigned int D.22696;
  unsigned int D.22698;
  unsigned int D.22701;
  unsigned int D.22704;
  unsigned int D.22705;
  long unsigned int D.22706;
  long unsigned int D.22707;
  gboolean * D.22708;
  int D.22709;
  unsigned int D.22712;
  int D.22715;
  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.22668 = header->num_clauses;
      D.22669 = (unsigned int) D.22668;
      D.22670 = D.22669 * 4;
      D.22671 = cfg->mempool;
      outer_try = mono_mempool_alloc0 (D.22671, D.22670);
      i = 0;
      goto <D.22282>;
      <D.22281>:
      D.22672 = (long unsigned int) i;
      D.22673 = D.22672 * 4;
      D.22674 = outer_try + D.22673;
      *D.22674 = 1;
      i = i + 1;
      <D.22282>:
      D.22668 = header->num_clauses;
      D.22675 = (int) D.22668;
      if (D.22675 > i) goto <D.22281>; else goto <D.22283>;
      <D.22283>:
      D.22668 = header->num_clauses;
      D.22675 = (int) D.22668;
      i = D.22675 + -1;
      goto <D.22288>;
      <D.22287>:
      D.22676 = header->clauses;
      D.22672 = (long unsigned int) i;
      D.22677 = D.22672 * 32;
      clause = D.22676 + D.22677;
      D.22678 = clause->flags;
      if (D.22678 != 0) goto <D.22679>; else goto <D.22680>;
      <D.22679>:
      D.22672 = (long unsigned int) i;
      D.22673 = D.22672 * 4;
      D.22674 = outer_try + D.22673;
      *D.22674 = 1;
      j = i + -1;
      goto <D.22286>;
      <D.22285>:
      D.22676 = header->clauses;
      D.22681 = (long unsigned int) j;
      D.22682 = D.22681 * 32;
      clause2 = D.22676 + D.22682;
      D.22683 = clause2->flags;
      if (D.22683 == 0) goto <D.22684>; else goto <D.22685>;
      <D.22684>:
      D.22686 = clause->handler_offset;
      D.22687 = clause2->try_offset;
      if (D.22686 <= D.22687) goto <D.22688>; else goto <D.22689>;
      <D.22688>:
      D.22687 = clause2->try_offset;
      D.22686 = clause->handler_offset;
      D.22690 = clause->handler_len;
      D.22691 = D.22686 + D.22690;
      if (D.22687 < D.22691) goto <D.22692>; else goto <D.22693>;
      <D.22692>:
      D.22681 = (long unsigned int) j;
      D.22694 = D.22681 * 4;
      D.22695 = outer_try + D.22694;
      *D.22695 = 0;
      goto <D.22284>;
      <D.22693>:
      <D.22689>:
      <D.22685>:
      D.22687 = clause2->try_offset;
      D.22696 = clause->try_offset;
      if (D.22687 < D.22696) goto <D.22284>; else goto <D.22697>;
      <D.22697>:
      j = j + -1;
      <D.22286>:
      if (j >= 0) goto <D.22285>; else goto <D.22284>;
      <D.22284>:
      <D.22680>:
      i = i + -1;
      <D.22288>:
      if (i >= 0) goto <D.22287>; else goto <D.22289>;
      <D.22289>:
      bb = cfg->bb_entry;
      goto <D.22292>;
      <D.22291>:
      D.22698 = bb->region;
      if (D.22698 == 4294967295) goto <D.22699>; else goto <D.22700>;
      <D.22699>:
      // predicted unlikely by continue predictor.
      goto <D.22290>;
      <D.22700>:
      D.22698 = bb->region;
      D.22701 = D.22698 & 240;
      if (D.22701 == 0) goto <D.22702>; else goto <D.22703>;
      <D.22702>:
      D.22698 = bb->region;
      D.22704 = D.22698 >> 8;
      D.22705 = D.22704 + 4294967295;
      D.22706 = (long unsigned int) D.22705;
      D.22707 = D.22706 * 4;
      D.22708 = outer_try + D.22707;
      D.22709 = *D.22708;
      if (D.22709 != 0) goto <D.22710>; else goto <D.22711>;
      <D.22710>:
      // predicted unlikely by continue predictor.
      goto <D.22290>;
      <D.22711>:
      <D.22703>:
      D.22712 = cfg->verbose_level;
      if (D.22712 > 2) goto <D.22713>; else goto <D.22714>;
      <D.22713>:
      D.22715 = bb->block_num;
      printf ("pessimize variables in bb %d.\n", D.22715);
      <D.22714>:
      visit_bb (cfg, bb, &visited);
      <D.22290>:
      bb = bb->next_bb;
      <D.22292>:
      if (bb != 0B) goto <D.22291>; else goto <D.22293>;
      <D.22293>:
      visited.0 = visited;
      monoeg_g_slist_free (visited.0);
    }
  finally
    {
      visited = {CLOBBER};
    }
}


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

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


visit_bb (struct MonoCompile * cfg, struct MonoBasicBlock * bb, struct GSList * * visited)
{
  struct GSList * D.22719;
  struct GSList * D.22720;
  short unsigned int D.22723;
  int D.22724;
  int D.22725;
  int D.22726;
  char D.22729;
  int iftmp.1;
  int D.22735;
  _Bool D.22738;
  long int D.22739;
  long int D.22740;
  unsigned int D.22745;
  unsigned int D.22746;
  struct MonoInst * * D.22749;
  long unsigned int D.22750;
  long unsigned int D.22751;
  struct MonoInst * * D.22752;
  struct MonoInst * D.22753;
  struct MonoInst * iftmp.2;
  long int D.22760;
  struct MonoMethodVar * D.22761;
  long unsigned int D.22762;
  long unsigned int D.22763;
  struct MonoInst * * D.22764;
  unsigned int D.22765;
  long unsigned int D.22766;
  long unsigned int D.22767;
  struct MonoInst * * D.22768;
  struct MonoInst * D.22769;
  unsigned char D.22770;
  unsigned char D.22771;
  struct MonoInst * iftmp.3;
  int D.22775;
  int D.22776;
  unsigned int D.22777;
  sizetype D.22780;
  sizetype D.22781;
  sizetype D.22782;
  struct MonoInst * * D.22783;
  struct MonoInst * iftmp.4;
  unsigned char D.22789;
  unsigned char D.22790;
  struct MonoInst * iftmp.5;
  int D.22792;
  unsigned int D.22793;
  sizetype D.22796;
  sizetype D.22797;
  struct MonoInst * * D.22798;
  struct MonoInst * iftmp.6;
  unsigned char D.22804;
  unsigned char D.22805;
  int D.22806;
  int D.22807;
  int D.22808;
  signed char D.22809;
  _Bool D.22810;
  long int D.22811;
  long int D.22812;
  unsigned int sreg.7;
  long unsigned int D.22818;
  long unsigned int D.22819;
  struct MonoInst * * D.22820;
  struct MonoInst * D.22821;
  struct MonoInst * iftmp.8;
  long int D.22828;
  long unsigned int D.22829;
  long unsigned int D.22830;
  unsigned int D.22831;
  long unsigned int D.22832;
  long unsigned int D.22833;
  struct MonoInst * * D.22834;
  struct MonoInst * D.22835;
  unsigned char D.22836;
  unsigned char D.22837;
  struct MonoInst * iftmp.9;
  int D.22841;
  int D.22842;
  unsigned int D.22843;
  sizetype D.22846;
  sizetype D.22847;
  sizetype D.22848;
  struct MonoInst * * D.22849;
  struct MonoInst * iftmp.10;
  unsigned char D.22855;
  unsigned char D.22856;
  struct MonoInst * iftmp.11;
  int D.22858;
  unsigned int D.22859;
  sizetype D.22862;
  sizetype D.22863;
  struct MonoInst * * D.22864;
  struct MonoInst * iftmp.12;
  unsigned char D.22870;
  unsigned char D.22871;
  struct GSList * D.22872;
  struct MonoBasicBlock * * D.22873;
  long unsigned int D.22874;
  long unsigned int D.22875;
  struct MonoBasicBlock * * D.22876;
  struct MonoBasicBlock * D.22877;
  short int D.22878;
  int D.22879;
  int i;
  struct MonoInst * ins;

  D.22719 = *visited;
  D.22720 = monoeg_g_slist_find (D.22719, bb);
  if (D.22720 != 0B) goto <D.22721>; else goto <D.22722>;
  <D.22721>:
  return;
  <D.22722>:
  ins = bb->code;
  goto <D.22265>;
  <D.22264>:
  {
    const char * spec;
    int regtype;
    int srcindex;
    int sreg;
    int num_sregs;
    int sregs[3];

    try
      {
        D.22723 = ins->opcode;
        D.22724 = (int) D.22723;
        D.22725 = D.22724 + -313;
        D.22726 = D.22725 * 4;
        spec = &ins_info[D.22726];
        D.22723 = ins->opcode;
        if (D.22723 == 316) goto <D.22727>; else goto <D.22728>;
        <D.22727>:
        // predicted unlikely by continue predictor.
        goto <D.22254>;
        <D.22728>:
        D.22729 = *spec;
        regtype = (int) D.22729;
        D.22735 = ins->dreg;
        if (D.22735 != -1) goto <D.22731>; else goto <D.22736>;
        <D.22736>:
        if (regtype != 32) goto <D.22731>; else goto <D.22732>;
        <D.22731>:
        D.22735 = ins->dreg;
        if (D.22735 == -1) goto <D.22733>; else goto <D.22737>;
        <D.22737>:
        if (regtype == 32) goto <D.22733>; else goto <D.22732>;
        <D.22733>:
        iftmp.1 = 1;
        goto <D.22734>;
        <D.22732>:
        iftmp.1 = 0;
        <D.22734>:
        D.22738 = iftmp.1 != 0;
        D.22739 = (long int) D.22738;
        D.22740 = __builtin_expect (D.22739, 0);
        if (D.22740 != 0) goto <D.22741>; else goto <D.22742>;
        <D.22741>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "liveness.c", 94, "((ins->dreg == -1) && (regtype == \' \')) || ((ins->dreg != -1) && (regtype != \' \'))");
        <D.22742>:
        D.22735 = ins->dreg;
        if (D.22735 != -1) goto <D.22743>; else goto <D.22744>;
        <D.22743>:
        D.22735 = ins->dreg;
        D.22745 = (unsigned int) D.22735;
        D.22746 = cfg->vreg_to_inst_len;
        if (D.22745 < D.22746) goto <D.22747>; else goto <D.22748>;
        <D.22747>:
        D.22749 = cfg->vreg_to_inst;
        D.22735 = ins->dreg;
        D.22750 = (long unsigned int) D.22735;
        D.22751 = D.22750 * 8;
        D.22752 = D.22749 + D.22751;
        D.22753 = *D.22752;
        if (D.22753 != 0B) goto <D.22754>; else goto <D.22755>;
        <D.22754>:
        {
          struct MonoInst * var;
          int idx;
          struct MonoMethodVar * vi;

          D.22735 = ins->dreg;
          D.22745 = (unsigned int) D.22735;
          D.22746 = cfg->vreg_to_inst_len;
          if (D.22745 < D.22746) goto <D.22757>; else goto <D.22758>;
          <D.22757>:
          D.22749 = cfg->vreg_to_inst;
          D.22735 = ins->dreg;
          D.22750 = (long unsigned int) D.22735;
          D.22751 = D.22750 * 8;
          D.22752 = D.22749 + D.22751;
          iftmp.2 = *D.22752;
          goto <D.22759>;
          <D.22758>:
          iftmp.2 = 0B;
          <D.22759>:
          var = iftmp.2;
          D.22760 = var->data.op[0].const_val;
          idx = (int) D.22760;
          D.22761 = cfg->vars;
          D.22762 = (long unsigned int) idx;
          D.22763 = D.22762 * 80;
          vi = D.22761 + D.22763;
          D.22764 = cfg->varinfo;
          D.22765 = vi->idx;
          D.22766 = (long unsigned int) D.22765;
          D.22767 = D.22766 * 8;
          D.22768 = D.22764 + D.22767;
          D.22769 = *D.22768;
          D.22764 = cfg->varinfo;
          D.22765 = vi->idx;
          D.22766 = (long unsigned int) D.22765;
          D.22767 = D.22766 * 8;
          D.22768 = D.22764 + D.22767;
          D.22769 = *D.22768;
          D.22770 = D.22769->flags;
          D.22771 = D.22770 | 4;
          D.22769->flags = D.22771;
          if (0 != 0) goto <D.22772>; else goto <D.22773>;
          <D.22772>:
          D.22775 = var->dreg;
          D.22776 = D.22775 + 1;
          D.22777 = (unsigned int) D.22776;
          D.22746 = cfg->vreg_to_inst_len;
          if (D.22777 < D.22746) goto <D.22778>; else goto <D.22779>;
          <D.22778>:
          D.22749 = cfg->vreg_to_inst;
          D.22775 = var->dreg;
          D.22780 = (sizetype) D.22775;
          D.22781 = D.22780 + 1;
          D.22782 = D.22781 * 8;
          D.22783 = D.22749 + D.22782;
          iftmp.3 = *D.22783;
          goto <D.22784>;
          <D.22779>:
          iftmp.3 = 0B;
          <D.22784>:
          D.22775 = var->dreg;
          D.22776 = D.22775 + 1;
          D.22777 = (unsigned int) D.22776;
          D.22746 = cfg->vreg_to_inst_len;
          if (D.22777 < D.22746) goto <D.22786>; else goto <D.22787>;
          <D.22786>:
          D.22749 = cfg->vreg_to_inst;
          D.22775 = var->dreg;
          D.22780 = (sizetype) D.22775;
          D.22781 = D.22780 + 1;
          D.22782 = D.22781 * 8;
          D.22783 = D.22749 + D.22782;
          iftmp.4 = *D.22783;
          goto <D.22788>;
          <D.22787>:
          iftmp.4 = 0B;
          <D.22788>:
          D.22789 = iftmp.4->flags;
          D.22790 = D.22789 | 4;
          iftmp.3->flags = D.22790;
          D.22775 = var->dreg;
          D.22792 = D.22775 + 2;
          D.22793 = (unsigned int) D.22792;
          D.22746 = cfg->vreg_to_inst_len;
          if (D.22793 < D.22746) goto <D.22794>; else goto <D.22795>;
          <D.22794>:
          D.22749 = cfg->vreg_to_inst;
          D.22775 = var->dreg;
          D.22780 = (sizetype) D.22775;
          D.22796 = D.22780 + 2;
          D.22797 = D.22796 * 8;
          D.22798 = D.22749 + D.22797;
          iftmp.5 = *D.22798;
          goto <D.22799>;
          <D.22795>:
          iftmp.5 = 0B;
          <D.22799>:
          D.22775 = var->dreg;
          D.22792 = D.22775 + 2;
          D.22793 = (unsigned int) D.22792;
          D.22746 = cfg->vreg_to_inst_len;
          if (D.22793 < D.22746) goto <D.22801>; else goto <D.22802>;
          <D.22801>:
          D.22749 = cfg->vreg_to_inst;
          D.22775 = var->dreg;
          D.22780 = (sizetype) D.22775;
          D.22796 = D.22780 + 2;
          D.22797 = D.22796 * 8;
          D.22798 = D.22749 + D.22797;
          iftmp.6 = *D.22798;
          goto <D.22803>;
          <D.22802>:
          iftmp.6 = 0B;
          <D.22803>:
          D.22804 = iftmp.6->flags;
          D.22805 = D.22804 | 4;
          iftmp.5->flags = D.22805;
          <D.22773>:
        }
        <D.22755>:
        <D.22748>:
        <D.22744>:
        D.22806 = ins->sreg1;
        sregs[0] = D.22806;
        D.22807 = ins->sreg2;
        sregs[1] = D.22807;
        D.22808 = ins->sreg3;
        sregs[2] = D.22808;
        D.22723 = ins->opcode;
        D.22724 = (int) D.22723;
        D.22725 = D.22724 + -313;
        D.22809 = ins_sreg_counts[D.22725];
        num_sregs = (int) D.22809;
        srcindex = 0;
        goto <D.22262>;
        <D.22261>:
        sreg = sregs[srcindex];
        D.22810 = sreg == -1;
        D.22811 = (long int) D.22810;
        D.22812 = __builtin_expect (D.22811, 0);
        if (D.22812 != 0) goto <D.22813>; else goto <D.22814>;
        <D.22813>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "liveness.c", 114, "sreg != -1");
        <D.22814>:
        sreg.7 = (unsigned int) sreg;
        D.22746 = cfg->vreg_to_inst_len;
        if (sreg.7 < D.22746) goto <D.22816>; else goto <D.22817>;
        <D.22816>:
        D.22749 = cfg->vreg_to_inst;
        D.22818 = (long unsigned int) sreg;
        D.22819 = D.22818 * 8;
        D.22820 = D.22749 + D.22819;
        D.22821 = *D.22820;
        if (D.22821 != 0B) goto <D.22822>; else goto <D.22823>;
        <D.22822>:
        {
          struct MonoInst * var;
          int idx;
          struct MonoMethodVar * vi;

          sreg.7 = (unsigned int) sreg;
          D.22746 = cfg->vreg_to_inst_len;
          if (sreg.7 < D.22746) goto <D.22825>; else goto <D.22826>;
          <D.22825>:
          D.22749 = cfg->vreg_to_inst;
          D.22818 = (long unsigned int) sreg;
          D.22819 = D.22818 * 8;
          D.22820 = D.22749 + D.22819;
          iftmp.8 = *D.22820;
          goto <D.22827>;
          <D.22826>:
          iftmp.8 = 0B;
          <D.22827>:
          var = iftmp.8;
          D.22828 = var->data.op[0].const_val;
          idx = (int) D.22828;
          D.22761 = cfg->vars;
          D.22829 = (long unsigned int) idx;
          D.22830 = D.22829 * 80;
          vi = D.22761 + D.22830;
          D.22764 = cfg->varinfo;
          D.22831 = vi->idx;
          D.22832 = (long unsigned int) D.22831;
          D.22833 = D.22832 * 8;
          D.22834 = D.22764 + D.22833;
          D.22835 = *D.22834;
          D.22764 = cfg->varinfo;
          D.22831 = vi->idx;
          D.22832 = (long unsigned int) D.22831;
          D.22833 = D.22832 * 8;
          D.22834 = D.22764 + D.22833;
          D.22835 = *D.22834;
          D.22836 = D.22835->flags;
          D.22837 = D.22836 | 4;
          D.22835->flags = D.22837;
          if (0 != 0) goto <D.22838>; else goto <D.22839>;
          <D.22838>:
          D.22841 = var->dreg;
          D.22842 = D.22841 + 1;
          D.22843 = (unsigned int) D.22842;
          D.22746 = cfg->vreg_to_inst_len;
          if (D.22843 < D.22746) goto <D.22844>; else goto <D.22845>;
          <D.22844>:
          D.22749 = cfg->vreg_to_inst;
          D.22841 = var->dreg;
          D.22846 = (sizetype) D.22841;
          D.22847 = D.22846 + 1;
          D.22848 = D.22847 * 8;
          D.22849 = D.22749 + D.22848;
          iftmp.9 = *D.22849;
          goto <D.22850>;
          <D.22845>:
          iftmp.9 = 0B;
          <D.22850>:
          D.22841 = var->dreg;
          D.22842 = D.22841 + 1;
          D.22843 = (unsigned int) D.22842;
          D.22746 = cfg->vreg_to_inst_len;
          if (D.22843 < D.22746) goto <D.22852>; else goto <D.22853>;
          <D.22852>:
          D.22749 = cfg->vreg_to_inst;
          D.22841 = var->dreg;
          D.22846 = (sizetype) D.22841;
          D.22847 = D.22846 + 1;
          D.22848 = D.22847 * 8;
          D.22849 = D.22749 + D.22848;
          iftmp.10 = *D.22849;
          goto <D.22854>;
          <D.22853>:
          iftmp.10 = 0B;
          <D.22854>:
          D.22855 = iftmp.10->flags;
          D.22856 = D.22855 | 4;
          iftmp.9->flags = D.22856;
          D.22841 = var->dreg;
          D.22858 = D.22841 + 2;
          D.22859 = (unsigned int) D.22858;
          D.22746 = cfg->vreg_to_inst_len;
          if (D.22859 < D.22746) goto <D.22860>; else goto <D.22861>;
          <D.22860>:
          D.22749 = cfg->vreg_to_inst;
          D.22841 = var->dreg;
          D.22846 = (sizetype) D.22841;
          D.22862 = D.22846 + 2;
          D.22863 = D.22862 * 8;
          D.22864 = D.22749 + D.22863;
          iftmp.11 = *D.22864;
          goto <D.22865>;
          <D.22861>:
          iftmp.11 = 0B;
          <D.22865>:
          D.22841 = var->dreg;
          D.22858 = D.22841 + 2;
          D.22859 = (unsigned int) D.22858;
          D.22746 = cfg->vreg_to_inst_len;
          if (D.22859 < D.22746) goto <D.22867>; else goto <D.22868>;
          <D.22867>:
          D.22749 = cfg->vreg_to_inst;
          D.22841 = var->dreg;
          D.22846 = (sizetype) D.22841;
          D.22862 = D.22846 + 2;
          D.22863 = D.22862 * 8;
          D.22864 = D.22749 + D.22863;
          iftmp.12 = *D.22864;
          goto <D.22869>;
          <D.22868>:
          iftmp.12 = 0B;
          <D.22869>:
          D.22870 = iftmp.12->flags;
          D.22871 = D.22870 | 4;
          iftmp.11->flags = D.22871;
          <D.22839>:
        }
        <D.22823>:
        <D.22817>:
        srcindex = srcindex + 1;
        <D.22262>:
        if (srcindex < num_sregs) goto <D.22261>; else goto <D.22263>;
        <D.22263>:
      }
    finally
      {
        sregs = {CLOBBER};
      }
  }
  <D.22254>:
  ins = ins->next;
  <D.22265>:
  if (ins != 0B) goto <D.22264>; else goto <D.22266>;
  <D.22266>:
  D.22719 = *visited;
  D.22872 = monoeg_g_slist_append (D.22719, bb);
  *visited = D.22872;
  i = 0;
  goto <D.22268>;
  <D.22267>:
  D.22873 = bb->out_bb;
  D.22874 = (long unsigned int) i;
  D.22875 = D.22874 * 8;
  D.22876 = D.22873 + D.22875;
  D.22877 = *D.22876;
  visit_bb (cfg, D.22877, visited);
  i = i + 1;
  <D.22268>:
  D.22878 = bb->out_count;
  D.22879 = (int) D.22878;
  if (D.22879 > i) goto <D.22267>; else goto <D.22269>;
  <D.22269>:
}


mono_analyze_liveness (struct MonoCompile * cfg)
{
  unsigned int D.22883;
  unsigned int D.22884;
  unsigned int D.22887;
  unsigned int D.22888;
  _Bool D.22889;
  long int D.22890;
  long int D.22891;
  unsigned int D.22894;
  unsigned int max_vars.13;
  unsigned int D.22898;
  struct MonoMethodVar * D.22899;
  long unsigned int D.22900;
  long unsigned int D.22901;
  struct MonoMethodVar * D.22902;
  struct MonoBasicBlock * * D.22903;
  long unsigned int D.22904;
  struct MonoBasicBlock * * D.22905;
  unsigned int bitsize.14;
  struct MonoMemPool * D.22907;
  struct MonoBitSet * D.22908;
  struct MonoBitSet * D.22909;
  int D.22912;
  struct MonoBasicBlock * * D.22913;
  long unsigned int D.22914;
  long unsigned int D.22915;
  struct MonoBasicBlock * * D.22916;
  struct MonoBasicBlock * D.22917;
  int D.22918;
  short int D.22919;
  int D.22920;
  struct MonoBitSet * D.22923;
  struct MonoBitSet * D.22924;
  unsigned int i.15;
  unsigned int D.22926;
  unsigned int D.22927;
  long unsigned int D.22928;
  long unsigned int D.22929;
  long unsigned int D.22930;
  unsigned int l_end.16;
  long unsigned int D.22932;
  long unsigned int D.22933;
  struct MonoBasicBlock * * D.22934;
  int D.22935;
  long unsigned int D.22936;
  long unsigned int D.22937;
  gboolean * D.22938;
  struct MonoBitSet * D.22939;
  long unsigned int D.22942;
  long unsigned int D.22943;
  struct MonoBasicBlock * * D.22944;
  int D.22945;
  long unsigned int D.22946;
  long unsigned int D.22947;
  gboolean * D.22948;
  int D.22951;
  struct MonoBasicBlock * * D.22952;
  struct MonoBasicBlock * * D.22953;
  struct MonoBasicBlock * D.22954;
  int D.22955;
  short int D.22956;
  int D.22957;
  struct MonoBasicBlock * * D.22958;
  struct MonoBasicBlock * * D.22959;
  struct MonoBasicBlock * D.22960;
  int D.22961;
  short int D.22962;
  int D.22963;
  struct MonoBitSet * D.22966;
  long unsigned int D.22970;
  long unsigned int D.22971;
  struct MonoBitSet * D.22972;
  gsize[0:] * D.22973;
  gsize[0:] * D.22974;
  struct MonoBitSet * D.22975;
  struct MonoBitSet * D.22978;
  long unsigned int D.22979;
  long unsigned int D.22980;
  struct MonoBitSet * D.22981;
  gsize[0:] * D.22982;
  gsize[0:] * 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;
  long unsigned int D.22990;
  long unsigned int D.22991;
  long unsigned int D.22992;
  long unsigned int D.22993;
  long unsigned int D.22994;
  struct MonoInst * D.22997;
  short unsigned int D.22999;
  long unsigned int D.23001;
  long unsigned int D.23002;
  long unsigned int D.23003;
  long unsigned int D.23004;
  long unsigned int D.23005;
  int D.23008;
  struct MonoBitSet * D.23011;
  long unsigned int D.23012;
  long unsigned int D.23013;
  gsize[0:] * D.23014;
  long unsigned int D.23015;
  long unsigned int D.23016;
  long unsigned int D.23017;
  long unsigned int D.23018;
  long unsigned int D.23019;
  long unsigned int D.23020;
  long unsigned int D.23021;
  long unsigned int D.23022;
  long unsigned int D.23023;
  long unsigned int D.23024;
  long unsigned int D.23025;
  struct MonoBitSet * D.23026;
  int D.23029;
  long unsigned int D.23030;
  long unsigned int D.23031;
  gboolean * D.23032;
  int D.23033;
  int D.23038;
  unsigned int l_end.17;
  long unsigned int D.23040;
  long unsigned int D.23041;
  struct MonoBasicBlock * * D.23042;
  _Bool D.23043;
  long int D.23044;
  long int D.23045;
  struct MonoBitSet * D.23050;
  struct MonoBitSet * D.23053;
  long unsigned int D.23054;
  long unsigned int D.23055;
  struct MonoBitSet * D.23056;
  gsize[0:] * D.23057;
  gsize[0:] * D.23058;
  long unsigned int D.23059;
  long unsigned int D.23060;
  long unsigned int D.23061;
  long unsigned int D.23062;
  long unsigned int D.23063;
  long unsigned int D.23064;
  long unsigned int D.23065;
  long unsigned int D.23066;
  long unsigned int D.23067;
  long unsigned int D.23068;
  long unsigned int D.23069;
  int D.23070;
  int D.23071;
  struct MonoBitSet * D.23072;
  long unsigned int D.23075;
  long unsigned int D.23076;
  long unsigned int D.23077;
  struct MonoBitSet * D.23078;
  unsigned int j.18;
  unsigned int D.23080;
  long unsigned int D.23081;
  int abs_pos.19;
  long unsigned int D.23085;
  long unsigned int D.23086;
  struct MonoMethodVar * D.23087;
  long unsigned int D.23088;
  unsigned int D.23091;
  int D.23092;
  long unsigned int D.23093;
  unsigned int j.20;
  struct MonoInst * * D.23095;
  unsigned int D.23096;
  long unsigned int D.23097;
  long unsigned int D.23098;
  struct MonoInst * * D.23099;
  struct MonoInst * D.23100;
  short unsigned int D.23101;
  unsigned int D.23104;
  unsigned char D.23107;
  int D.23108;
  int D.23109;
  unsigned char D.23114;
  unsigned char D.23115;
  struct MonoGenericSharingContext * D.23118;
  struct MonoMethod * D.23120;
  struct MonoMethodSignature * D.23121;
  unsigned char D.23122;
  unsigned char D.23123;
  struct MonoInst * * D.23125;
  struct MonoInst * D.23126;
  unsigned char D.23127;
  unsigned int D.23130;
  int D.23131;
  struct MonoBitSet * D.23132;
  struct MonoBitSet * D.23133;
  unsigned int D.23134;
  unsigned int D.23135;
  unsigned char D.23136;
  unsigned char D.23139;
  unsigned char D.23140;
  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.22883 = cfg->num_varinfo;
  max_vars = (int) D.22883;
  D.22884 = cfg->verbose_level;
  if (D.22884 > 1) goto <D.22885>; else goto <D.22886>;
  <D.22885>:
  printf ("\nLIVENESS:\n");
  <D.22886>:
  D.22887 = cfg->comp_done;
  D.22888 = D.22887 & 16;
  D.22889 = D.22888 != 0;
  D.22890 = (long int) D.22889;
  D.22891 = __builtin_expect (D.22890, 0);
  if (D.22891 != 0) goto <D.22892>; else goto <D.22893>;
  <D.22892>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "liveness.c", 316, "!(cfg->comp_done & MONO_COMP_LIVENESS)");
  <D.22893>:
  D.22887 = cfg->comp_done;
  D.22894 = D.22887 | 16;
  cfg->comp_done = D.22894;
  if (max_vars == 0) goto <D.22895>; else goto <D.22896>;
  <D.22895>:
  return;
  <D.22896>:
  max_vars.13 = (unsigned int) max_vars;
  D.22898 = mono_bitset_alloc_size (max_vars.13, 0);
  bitsize = (int) D.22898;
  i = 0;
  goto <D.22340>;
  <D.22339>:
  D.22899 = cfg->vars;
  D.22900 = (long unsigned int) i;
  D.22901 = D.22900 * 80;
  D.22902 = D.22899 + D.22901;
  D.22902->range.first_use.abs_pos = 4294967295;
  D.22899 = cfg->vars;
  D.22900 = (long unsigned int) i;
  D.22901 = D.22900 * 80;
  D.22902 = D.22899 + D.22901;
  D.22902->range.last_use.abs_pos = 0;
  D.22899 = cfg->vars;
  D.22900 = (long unsigned int) i;
  D.22901 = D.22900 * 80;
  D.22902 = D.22899 + D.22901;
  D.22902->spill_costs = 0;
  i = i + 1;
  <D.22340>:
  if (i < max_vars) goto <D.22339>; else goto <D.22341>;
  <D.22341>:
  i = 0;
  goto <D.22347>;
  <D.22346>:
  {
    struct MonoBasicBlock * bb;

    D.22903 = cfg->bblocks;
    D.22900 = (long unsigned int) i;
    D.22904 = D.22900 * 8;
    D.22905 = D.22903 + D.22904;
    bb = *D.22905;
    max_vars.13 = (unsigned int) max_vars;
    bitsize.14 = (unsigned int) bitsize;
    D.22907 = cfg->mempool;
    D.22908 = mono_bitset_mp_new (D.22907, bitsize.14, max_vars.13);
    bb->gen_set = D.22908;
    max_vars.13 = (unsigned int) max_vars;
    bitsize.14 = (unsigned int) bitsize;
    D.22907 = cfg->mempool;
    D.22909 = mono_bitset_mp_new (D.22907, bitsize.14, max_vars.13);
    bb->kill_set = D.22909;
    D.22884 = cfg->verbose_level;
    if (D.22884 > 1) goto <D.22910>; else goto <D.22911>;
    <D.22910>:
    D.22912 = bb->block_num;
    printf ("BLOCK BB%d (", D.22912);
    j = 0;
    goto <D.22344>;
    <D.22343>:
    D.22913 = bb->out_bb;
    D.22914 = (long unsigned int) j;
    D.22915 = D.22914 * 8;
    D.22916 = D.22913 + D.22915;
    D.22917 = *D.22916;
    D.22918 = D.22917->block_num;
    printf ("BB%d, ", D.22918);
    j = j + 1;
    <D.22344>:
    D.22919 = bb->out_count;
    D.22920 = (int) D.22919;
    if (D.22920 > j) goto <D.22343>; else goto <D.22345>;
    <D.22345>:
    printf ("):\n");
    <D.22911>:
    analyze_liveness_bb (cfg, bb);
    D.22884 = cfg->verbose_level;
    if (D.22884 > 1) goto <D.22921>; else goto <D.22922>;
    <D.22921>:
    D.22912 = bb->block_num;
    printf ("GEN  BB%d: ", D.22912);
    D.22923 = bb->gen_set;
    mono_bitset_print (D.22923);
    D.22912 = bb->block_num;
    printf ("KILL BB%d: ", D.22912);
    D.22924 = bb->kill_set;
    mono_bitset_print (D.22924);
    <D.22922>:
  }
  i = i + 1;
  <D.22347>:
  i.15 = (unsigned int) i;
  D.22926 = cfg->num_bblocks;
  if (i.15 < D.22926) goto <D.22346>; else goto <D.22348>;
  <D.22348>:
  max_vars.13 = (unsigned int) max_vars;
  old_live_out_set = mono_bitset_new (max_vars.13, 0);
  D.22926 = cfg->num_bblocks;
  D.22927 = D.22926 + 1;
  D.22928 = (long unsigned int) D.22927;
  D.22929 = D.22928 * 4;
  in_worklist = monoeg_malloc0 (D.22929);
  D.22926 = cfg->num_bblocks;
  D.22927 = D.22926 + 1;
  D.22928 = (long unsigned int) D.22927;
  D.22930 = D.22928 * 8;
  worklist = monoeg_malloc (D.22930);
  l_end = 0;
  i = 0;
  goto <D.22351>;
  <D.22350>:
  {
    struct MonoBasicBlock * bb;

    D.22903 = cfg->bblocks;
    D.22900 = (long unsigned int) i;
    D.22904 = D.22900 * 8;
    D.22905 = D.22903 + D.22904;
    bb = *D.22905;
    l_end.16 = l_end;
    l_end = l_end.16 + 1;
    D.22932 = (long unsigned int) l_end.16;
    D.22933 = D.22932 * 8;
    D.22934 = worklist + D.22933;
    *D.22934 = bb;
    D.22935 = bb->dfn;
    D.22936 = (long unsigned int) D.22935;
    D.22937 = D.22936 * 4;
    D.22938 = in_worklist + D.22937;
    *D.22938 = 1;
    bb->live_in_set = 0B;
    max_vars.13 = (unsigned int) max_vars;
    bitsize.14 = (unsigned int) bitsize;
    D.22907 = cfg->mempool;
    D.22939 = mono_bitset_mp_new (D.22907, bitsize.14, max_vars.13);
    bb->live_out_set = D.22939;
  }
  i = i + 1;
  <D.22351>:
  i.15 = (unsigned int) i;
  D.22926 = cfg->num_bblocks;
  if (i.15 < D.22926) goto <D.22350>; else goto <D.22352>;
  <D.22352>:
  out_iter = 0;
  D.22884 = cfg->verbose_level;
  if (D.22884 > 1) goto <D.22940>; else goto <D.22941>;
  <D.22940>:
  printf ("\nITERATION:\n");
  <D.22941>:
  goto <D.22362>;
  <D.22405>:
  {
    struct MonoBasicBlock * bb;
    struct MonoBasicBlock * out_bb;
    gboolean changed;

    l_end = l_end + 4294967295;
    D.22942 = (long unsigned int) l_end;
    D.22943 = D.22942 * 8;
    D.22944 = worklist + D.22943;
    bb = *D.22944;
    D.22945 = bb->dfn;
    D.22946 = (long unsigned int) D.22945;
    D.22947 = D.22946 * 4;
    D.22948 = in_worklist + D.22947;
    *D.22948 = 0;
    D.22884 = cfg->verbose_level;
    if (D.22884 > 1) goto <D.22949>; else goto <D.22950>;
    <D.22949>:
    D.22945 = bb->dfn;
    D.22951 = bb->block_num;
    printf ("P: BB%d(%d): IN: ", D.22951, D.22945);
    j = 0;
    goto <D.22357>;
    <D.22356>:
    D.22952 = bb->in_bb;
    D.22914 = (long unsigned int) j;
    D.22915 = D.22914 * 8;
    D.22953 = D.22952 + D.22915;
    D.22954 = *D.22953;
    D.22955 = D.22954->block_num;
    printf ("BB%d ", D.22955);
    j = j + 1;
    <D.22357>:
    D.22956 = bb->in_count;
    D.22957 = (int) D.22956;
    if (D.22957 > j) goto <D.22356>; else goto <D.22358>;
    <D.22358>:
    printf ("OUT:");
    j = 0;
    goto <D.22360>;
    <D.22359>:
    D.22958 = bb->out_bb;
    D.22914 = (long unsigned int) j;
    D.22915 = D.22914 * 8;
    D.22959 = D.22958 + D.22915;
    D.22960 = *D.22959;
    D.22961 = D.22960->block_num;
    printf ("BB%d ", D.22961);
    j = j + 1;
    <D.22360>:
    D.22962 = bb->out_count;
    D.22963 = (int) D.22962;
    if (D.22963 > j) goto <D.22359>; else goto <D.22361>;
    <D.22361>:
    printf ("\n");
    <D.22950>:
    D.22962 = bb->out_count;
    if (D.22962 == 0) goto <D.22964>; else goto <D.22965>;
    <D.22964>:
    // predicted unlikely by continue predictor.
    goto <D.22362>;
    <D.22965>:
    out_iter = out_iter + 1;
    D.22966 = bb->live_in_set;
    if (D.22966 == 0B) goto <D.22967>; else goto <D.22968>;
    <D.22967>:
    changed = 1;
    goto <D.22969>;
    <D.22968>:
    changed = 0;
    D.22970 = old_live_out_set->size;
    D.22971 = D.22970 / 8;
    D.22972 = bb->live_out_set;
    D.22973 = &D.22972->data;
    D.22974 = &old_live_out_set->data;
    memcpy (D.22974, D.22973, D.22971);
    <D.22969>:
    j = 0;
    goto <D.22385>;
    <D.22384>:
    D.22958 = bb->out_bb;
    D.22914 = (long unsigned int) j;
    D.22915 = D.22914 * 8;
    D.22959 = D.22958 + D.22915;
    out_bb = *D.22959;
    D.22975 = out_bb->live_in_set;
    if (D.22975 == 0B) goto <D.22976>; else goto <D.22977>;
    <D.22976>:
    max_vars.13 = (unsigned int) max_vars;
    bitsize.14 = (unsigned int) bitsize;
    D.22907 = cfg->mempool;
    D.22978 = mono_bitset_mp_new_noinit (D.22907, bitsize.14, max_vars.13);
    out_bb->live_in_set = D.22978;
    D.22975 = out_bb->live_in_set;
    D.22979 = D.22975->size;
    D.22980 = D.22979 / 8;
    D.22981 = out_bb->live_out_set;
    D.22982 = &D.22981->data;
    D.22975 = out_bb->live_in_set;
    D.22983 = &D.22975->data;
    memcpy (D.22983, D.22982, D.22980);
    {
      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.22984 = tmp_dest->size;
      D.22985 = D.22984 / 64;
      size = (int) D.22985;
      i = 0;
      goto <D.22368>;
      <D.22367>:
      D.22986 = tmp_dest->data[i];
      D.22987 = tmp_src->data[i];
      D.22988 = ~D.22987;
      D.22989 = D.22986 & D.22988;
      tmp_dest->data[i] = D.22989;
      i = i + 1;
      <D.22368>:
      if (i < size) goto <D.22367>; else goto <D.22369>;
      <D.22369>:
    }
    {
      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.22990 = tmp_dest->size;
      D.22991 = D.22990 / 64;
      size = (int) D.22991;
      i = 0;
      goto <D.22375>;
      <D.22374>:
      D.22992 = tmp_dest->data[i];
      D.22993 = tmp_src->data[i];
      D.22994 = D.22992 | D.22993;
      tmp_dest->data[i] = D.22994;
      i = i + 1;
      <D.22375>:
      if (i < size) goto <D.22374>; else goto <D.22376>;
      <D.22376>:
    }
    <D.22977>:
    D.22997 = bb->last_ins;
    if (D.22997 != 0B) goto <D.22998>; else goto <D.22995>;
    <D.22998>:
    D.22997 = bb->last_ins;
    D.22999 = D.22997->opcode;
    if (D.22999 == 802) goto <D.23000>; else goto <D.22995>;
    <D.23000>:
    goto <D.22996>;
    <D.22995>:
    {
      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.23001 = tmp_dest->size;
      D.23002 = D.23001 / 64;
      size = (int) D.23002;
      i = 0;
      goto <D.22382>;
      <D.22381>:
      D.23003 = tmp_dest->data[i];
      D.23004 = tmp_src->data[i];
      D.23005 = D.23003 | D.23004;
      tmp_dest->data[i] = D.23005;
      i = i + 1;
      <D.22382>:
      if (i < size) goto <D.22381>; else goto <D.22383>;
      <D.22383>:
    }
    <D.22996>:
    j = j + 1;
    <D.22385>:
    D.22962 = bb->out_count;
    D.22963 = (int) D.22962;
    if (D.22963 > j) goto <D.22384>; else goto <D.22386>;
    <D.22386>:
    if (changed != 0) goto <D.23006>; else goto <D.23007>;
    <D.23007>:
    D.22972 = bb->live_out_set;
    D.23008 = mono_bitset_equal (old_live_out_set, D.22972);
    if (D.23008 == 0) goto <D.23006>; else goto <D.22404>;
    <D.23006>:
    D.22966 = bb->live_in_set;
    if (D.22966 == 0B) goto <D.23009>; else goto <D.23010>;
    <D.23009>:
    max_vars.13 = (unsigned int) max_vars;
    bitsize.14 = (unsigned int) bitsize;
    D.22907 = cfg->mempool;
    D.23011 = mono_bitset_mp_new_noinit (D.22907, bitsize.14, max_vars.13);
    bb->live_in_set = D.23011;
    <D.23010>:
    D.22966 = bb->live_in_set;
    D.23012 = D.22966->size;
    D.23013 = D.23012 / 8;
    D.22972 = bb->live_out_set;
    D.22973 = &D.22972->data;
    D.22966 = bb->live_in_set;
    D.23014 = &D.22966->data;
    memcpy (D.23014, D.22973, D.23013);
    {
      struct MonoBitSet * tmp_src;
      struct MonoBitSet * tmp_dest;
      int i;
      int size;

      tmp_src = bb->kill_set;
      tmp_dest = bb->live_in_set;
      D.23015 = tmp_dest->size;
      D.23016 = D.23015 / 64;
      size = (int) D.23016;
      i = 0;
      goto <D.22392>;
      <D.22391>:
      D.23017 = tmp_dest->data[i];
      D.23018 = tmp_src->data[i];
      D.23019 = ~D.23018;
      D.23020 = D.23017 & D.23019;
      tmp_dest->data[i] = D.23020;
      i = i + 1;
      <D.22392>:
      if (i < size) goto <D.22391>; else goto <D.22393>;
      <D.22393>:
    }
    {
      struct MonoBitSet * tmp_src;
      struct MonoBitSet * tmp_dest;
      int i;
      int size;

      tmp_src = bb->gen_set;
      tmp_dest = bb->live_in_set;
      D.23021 = tmp_dest->size;
      D.23022 = D.23021 / 64;
      size = (int) D.23022;
      i = 0;
      goto <D.22399>;
      <D.22398>:
      D.23023 = tmp_dest->data[i];
      D.23024 = tmp_src->data[i];
      D.23025 = D.23023 | D.23024;
      tmp_dest->data[i] = D.23025;
      i = i + 1;
      <D.22399>:
      if (i < size) goto <D.22398>; else goto <D.22400>;
      <D.22400>:
    }
    j = 0;
    goto <D.22403>;
    <D.22402>:
    {
      struct MonoBasicBlock * in_bb;

      D.22952 = bb->in_bb;
      D.22914 = (long unsigned int) j;
      D.22915 = D.22914 * 8;
      D.22953 = D.22952 + D.22915;
      in_bb = *D.22953;
      D.23026 = in_bb->gen_set;
      if (D.23026 != 0B) goto <D.23027>; else goto <D.23028>;
      <D.23027>:
      D.23029 = in_bb->dfn;
      D.23030 = (long unsigned int) D.23029;
      D.23031 = D.23030 * 4;
      D.23032 = in_worklist + D.23031;
      D.23033 = *D.23032;
      if (D.23033 == 0) goto <D.23034>; else goto <D.23035>;
      <D.23034>:
      D.22884 = cfg->verbose_level;
      if (D.22884 > 1) goto <D.23036>; else goto <D.23037>;
      <D.23036>:
      D.23038 = in_bb->block_num;
      printf ("\tADD: %d\n", D.23038);
      <D.23037>:
      l_end.17 = l_end;
      l_end = l_end.17 + 1;
      D.23040 = (long unsigned int) l_end.17;
      D.23041 = D.23040 * 8;
      D.23042 = worklist + D.23041;
      *D.23042 = in_bb;
      D.23029 = in_bb->dfn;
      D.23030 = (long unsigned int) D.23029;
      D.23031 = D.23030 * 4;
      D.23032 = in_worklist + D.23031;
      *D.23032 = 1;
      <D.23035>:
      <D.23028>:
    }
    j = j + 1;
    <D.22403>:
    D.22956 = bb->in_count;
    D.22957 = (int) D.22956;
    if (D.22957 > j) goto <D.22402>; else goto <D.22404>;
    <D.22404>:
    D.22884 = cfg->verbose_level;
    D.23043 = D.22884 > 1;
    D.23044 = (long int) D.23043;
    D.23045 = __builtin_expect (D.23044, 0);
    if (D.23045 != 0) goto <D.23046>; else goto <D.23047>;
    <D.23046>:
    D.22951 = bb->block_num;
    printf ("\tLIVE IN  BB%d: ", D.22951);
    D.22966 = bb->live_in_set;
    mono_bitset_print (D.22966);
    <D.23047>:
  }
  <D.22362>:
  if (l_end != 0) goto <D.22405>; else goto <D.22406>;
  <D.22406>:
  D.22884 = cfg->verbose_level;
  if (D.22884 > 1) goto <D.23048>; else goto <D.23049>;
  <D.23048>:
  D.22926 = cfg->num_bblocks;
  printf ("IT: %d %d.\n", D.22926, out_iter);
  <D.23049>:
  mono_bitset_free (old_live_out_set);
  monoeg_g_free (worklist);
  monoeg_g_free (in_worklist);
  i = 0;
  goto <D.22423>;
  <D.22422>:
  {
    struct MonoBasicBlock * bb;

    D.22903 = cfg->bblocks;
    D.22900 = (long unsigned int) i;
    D.22904 = D.22900 * 8;
    D.22905 = D.22903 + D.22904;
    bb = *D.22905;
    D.23050 = bb->live_in_set;
    if (D.23050 == 0B) goto <D.23051>; else goto <D.23052>;
    <D.23051>:
    max_vars.13 = (unsigned int) max_vars;
    bitsize.14 = (unsigned int) bitsize;
    D.22907 = cfg->mempool;
    D.23053 = mono_bitset_mp_new (D.22907, bitsize.14, max_vars.13);
    bb->live_in_set = D.23053;
    D.23050 = bb->live_in_set;
    D.23054 = D.23050->size;
    D.23055 = D.23054 / 8;
    D.23056 = bb->live_out_set;
    D.23057 = &D.23056->data;
    D.23050 = bb->live_in_set;
    D.23058 = &D.23050->data;
    memcpy (D.23058, D.23057, D.23055);
    {
      struct MonoBitSet * tmp_src;
      struct MonoBitSet * tmp_dest;
      int i;
      int size;

      tmp_src = bb->kill_set;
      tmp_dest = bb->live_in_set;
      D.23059 = tmp_dest->size;
      D.23060 = D.23059 / 64;
      size = (int) D.23060;
      i = 0;
      goto <D.22413>;
      <D.22412>:
      D.23061 = tmp_dest->data[i];
      D.23062 = tmp_src->data[i];
      D.23063 = ~D.23062;
      D.23064 = D.23061 & D.23063;
      tmp_dest->data[i] = D.23064;
      i = i + 1;
      <D.22413>:
      if (i < size) goto <D.22412>; else goto <D.22414>;
      <D.22414>:
    }
    {
      struct MonoBitSet * tmp_src;
      struct MonoBitSet * tmp_dest;
      int i;
      int size;

      tmp_src = bb->gen_set;
      tmp_dest = bb->live_in_set;
      D.23065 = tmp_dest->size;
      D.23066 = D.23065 / 64;
      size = (int) D.23066;
      i = 0;
      goto <D.22420>;
      <D.22419>:
      D.23067 = tmp_dest->data[i];
      D.23068 = tmp_src->data[i];
      D.23069 = D.23067 | D.23068;
      tmp_dest->data[i] = D.23069;
      i = i + 1;
      <D.22420>:
      if (i < size) goto <D.22419>; else goto <D.22421>;
      <D.22421>:
    }
    <D.23052>:
  }
  i = i + 1;
  <D.22423>:
  i.15 = (unsigned int) i;
  D.22926 = cfg->num_bblocks;
  if (i.15 < D.22926) goto <D.22422>; else goto <D.22424>;
  <D.22424>:
  i = 0;
  goto <D.22440>;
  <D.22439>:
  {
    struct MonoBasicBlock * bb;
    guint32 max;
    guint32 abs_pos;
    struct MonoMethodVar * vars;

    D.22903 = cfg->bblocks;
    D.22900 = (long unsigned int) i;
    D.22904 = D.22900 * 8;
    D.22905 = D.22903 + D.22904;
    bb = *D.22905;
    D.23070 = bb->dfn;
    D.23071 = D.23070 << 16;
    abs_pos = (guint32) D.23071;
    vars = cfg->vars;
    D.23072 = bb->live_out_set;
    if (D.23072 == 0B) goto <D.23073>; else goto <D.23074>;
    <D.23073>:
    // predicted unlikely by continue predictor.
    goto <D.22429>;
    <D.23074>:
    D.23075 = (long unsigned int) max_vars;
    D.23076 = D.23075 + 63;
    D.23077 = D.23076 / 64;
    max = (guint32) D.23077;
    j = 0;
    goto <D.22437>;
    <D.22436>:
    {
      gsize bits_in;
      gsize bits_out;
      int k;

      D.23078 = bb->live_in_set;
      bits_in = D.23078->data[j];
      D.23072 = bb->live_out_set;
      bits_out = D.23072->data[j];
      j.18 = (unsigned int) j;
      D.23080 = j.18 * 64;
      k = (int) D.23080;
      goto <D.22434>;
      <D.22433>:
      D.23081 = bits_in & 1;
      if (D.23081 != 0) goto <D.23082>; else goto <D.23083>;
      <D.23082>:
      abs_pos.19 = (int) abs_pos;
      D.23085 = (long unsigned int) k;
      D.23086 = D.23085 * 80;
      D.23087 = vars + D.23086;
      update_live_range (D.23087, abs_pos.19);
      <D.23083>:
      D.23088 = bits_out & 1;
      if (D.23088 != 0) goto <D.23089>; else goto <D.23090>;
      <D.23089>:
      D.23091 = abs_pos + 65535;
      D.23092 = (int) D.23091;
      D.23085 = (long unsigned int) k;
      D.23086 = D.23085 * 80;
      D.23087 = vars + D.23086;
      update_live_range (D.23087, D.23092);
      <D.23090>:
      bits_in = bits_in >> 1;
      bits_out = bits_out >> 1;
      k = k + 1;
      <D.22434>:
      D.23093 = bits_in | bits_out;
      if (D.23093 != 0) goto <D.22433>; else goto <D.22435>;
      <D.22435>:
    }
    j = j + 1;
    <D.22437>:
    j.20 = (unsigned int) j;
    if (j.20 < max) goto <D.22436>; else goto <D.22438>;
    <D.22438>:
  }
  <D.22429>:
  i = i + 1;
  <D.22440>:
  i.15 = (unsigned int) i;
  D.22926 = cfg->num_bblocks;
  if (i.15 < D.22926) goto <D.22439>; else goto <D.22441>;
  <D.22441>:
  i = 0;
  goto <D.22444>;
  <D.22443>:
  {
    struct MonoMethodVar * vi;

    D.22899 = cfg->vars;
    D.22900 = (long unsigned int) i;
    D.22901 = D.22900 * 80;
    vi = D.22899 + D.22901;
    D.23095 = cfg->varinfo;
    D.23096 = vi->idx;
    D.23097 = (long unsigned int) D.23096;
    D.23098 = D.23097 * 8;
    D.23099 = D.23095 + D.23098;
    D.23100 = *D.23099;
    D.23101 = D.23100->opcode;
    if (D.23101 == 330) goto <D.23102>; else goto <D.23103>;
    <D.23102>:
    D.23104 = vi->range.last_use.abs_pos;
    if (D.23104 == 0) goto <D.23105>; else goto <D.23106>;
    <D.23105>:
    D.23095 = cfg->varinfo;
    D.23096 = vi->idx;
    D.23097 = (long unsigned int) D.23096;
    D.23098 = D.23097 * 8;
    D.23099 = D.23095 + D.23098;
    D.23100 = *D.23099;
    D.23107 = D.23100->flags;
    D.23108 = (int) D.23107;
    D.23109 = D.23108 & 20;
    if (D.23109 == 0) goto <D.23110>; else goto <D.23111>;
    <D.23110>:
    D.23114 = BIT_FIELD_REF <*cfg, 8, 5616>;
    D.23115 = D.23114 & 128;
    if (D.23115 == 0) goto <D.23116>; else goto <D.23117>;
    <D.23116>:
    D.23118 = cfg->generic_sharing_context;
    if (D.23118 == 0B) goto <D.23112>; else goto <D.23119>;
    <D.23119>:
    D.23120 = cfg->method;
    D.23121 = mono_method_signature (D.23120);
    D.23122 = BIT_FIELD_REF <*D.23121, 8, 112>;
    D.23123 = D.23122 & 64;
    if (D.23123 == 0) goto <D.23112>; else goto <D.23124>;
    <D.23124>:
    D.23095 = cfg->varinfo;
    D.23096 = vi->idx;
    D.23097 = (long unsigned int) D.23096;
    D.23098 = D.23097 * 8;
    D.23099 = D.23095 + D.23098;
    D.23100 = *D.23099;
    D.23125 = cfg->args;
    D.23126 = *D.23125;
    if (D.23100 != D.23126) goto <D.23112>; else goto <D.23113>;
    <D.23112>:
    D.23095 = cfg->varinfo;
    D.23096 = vi->idx;
    D.23097 = (long unsigned int) D.23096;
    D.23098 = D.23097 * 8;
    D.23099 = D.23095 + D.23098;
    D.23100 = *D.23099;
    D.23095 = cfg->varinfo;
    D.23096 = vi->idx;
    D.23097 = (long unsigned int) D.23096;
    D.23098 = D.23097 * 8;
    D.23099 = D.23095 + D.23098;
    D.23100 = *D.23099;
    D.23107 = D.23100->flags;
    D.23127 = D.23107 | 2;
    D.23100->flags = D.23127;
    <D.23113>:
    <D.23117>:
    <D.23111>:
    <D.23106>:
    vi->range.first_use.abs_pos = 0;
    <D.23103>:
  }
  i = i + 1;
  <D.22444>:
  if (i < max_vars) goto <D.22443>; else goto <D.22445>;
  <D.22445>:
  D.22884 = cfg->verbose_level;
  if (D.22884 > 1) goto <D.23128>; else goto <D.23129>;
  <D.23128>:
  D.22926 = cfg->num_bblocks;
  D.23130 = D.22926 + 4294967295;
  i = (int) D.23130;
  goto <D.22448>;
  <D.22447>:
  {
    struct MonoBasicBlock * bb;

    D.22903 = cfg->bblocks;
    D.22900 = (long unsigned int) i;
    D.22904 = D.22900 * 8;
    D.22905 = D.22903 + D.22904;
    bb = *D.22905;
    D.23131 = bb->block_num;
    printf ("LIVE IN  BB%d: ", D.23131);
    D.23132 = bb->live_in_set;
    mono_bitset_print (D.23132);
    D.23131 = bb->block_num;
    printf ("LIVE OUT BB%d: ", D.23131);
    D.23133 = bb->live_out_set;
    mono_bitset_print (D.23133);
  }
  i = i + -1;
  <D.22448>:
  if (i >= 0) goto <D.22447>; else goto <D.22449>;
  <D.22449>:
  i = 0;
  goto <D.22452>;
  <D.22451>:
  {
    struct MonoMethodVar * vi;

    D.22899 = cfg->vars;
    D.22900 = (long unsigned int) i;
    D.22901 = D.22900 * 80;
    vi = D.22899 + D.22901;
    D.23134 = vi->range.last_use.abs_pos;
    D.23135 = vi->range.first_use.abs_pos;
    printf ("V%d: [0x%x - 0x%x]\n", i, D.23135, D.23134);
  }
  i = i + 1;
  <D.22452>:
  if (i < max_vars) goto <D.22451>; else goto <D.22453>;
  <D.22453>:
  <D.23129>:
  D.23114 = BIT_FIELD_REF <*cfg, 8, 5616>;
  D.23136 = D.23114 & 8;
  if (D.23136 == 0) goto <D.23137>; else goto <D.23138>;
  <D.23137>:
  optimize_initlocals (cfg);
  <D.23138>:
  D.23139 = BIT_FIELD_REF <*cfg, 8, 5600>;
  D.23140 = D.23139 & 64;
  if (D.23140 != 0) goto <D.23141>; else goto <D.23142>;
  <D.23141>:
  mono_analyze_liveness2 (cfg);
  <D.23142>:
}


analyze_liveness_bb (struct MonoCompile * cfg, struct MonoBasicBlock * bb)
{
  int D.23144;
  int D.23145;
  short unsigned int D.23146;
  int D.23147;
  int D.23148;
  int D.23149;
  unsigned int D.23150;
  long int D.23157;
  struct MonoMethodVar * D.23158;
  long unsigned int D.23159;
  long unsigned int D.23160;
  int D.23163;
  unsigned int inst_num.21;
  unsigned int D.23165;
  int D.23166;
  struct MonoMethodVar * D.23167;
  struct MonoBitSet * D.23168;
  long unsigned int D.23169;
  long unsigned int D.23170;
  int D.23171;
  long unsigned int D.23172;
  long unsigned int D.23173;
  struct MonoBitSet * D.23176;
  long unsigned int D.23177;
  long unsigned int D.23178;
  long unsigned int D.23179;
  long unsigned int D.23180;
  int D.23181;
  signed char D.23182;
  int D.23183;
  int D.23184;
  int D.23185;
  int D.23186;
  int D.23187;
  int D.23188;
  int D.23189;
  signed char D.23190;
  int D.23191;
  sizetype D.23192;
  const char * D.23193;
  char D.23194;
  unsigned int sreg.22;
  unsigned int D.23198;
  struct MonoInst * * D.23201;
  long unsigned int D.23202;
  long unsigned int D.23203;
  struct MonoInst * * D.23204;
  struct MonoInst * D.23205;
  struct MonoInst * iftmp.23;
  long int D.23212;
  long unsigned int D.23213;
  long unsigned int D.23214;
  struct MonoMethodVar * D.23217;
  long unsigned int D.23218;
  long unsigned int D.23219;
  int D.23220;
  long unsigned int D.23221;
  long unsigned int D.23222;
  long unsigned int D.23225;
  long unsigned int D.23226;
  long unsigned int D.23227;
  long unsigned int D.23228;
  int D.23229;
  int D.23230;
  char D.23231;
  int D.23234;
  unsigned int D.23235;
  long unsigned int D.23238;
  long unsigned int D.23239;
  struct MonoInst * * D.23240;
  struct MonoInst * D.23241;
  struct MonoInst * iftmp.24;
  long int D.23248;
  long unsigned int D.23249;
  long unsigned int D.23250;
  short unsigned int D.23251;
  struct MonoMethodVar * D.23254;
  long unsigned int D.23255;
  long unsigned int D.23256;
  int D.23257;
  long unsigned int D.23258;
  long unsigned int D.23259;
  long unsigned int D.23262;
  long unsigned int D.23263;
  long unsigned int D.23264;
  long unsigned int D.23265;
  int D.23266;
  int D.23267;
  unsigned int D.23271;
  int D.23272;
  long unsigned int D.23273;
  long unsigned int D.23274;
  long unsigned int D.23275;
  struct MonoInst * ins;
  int sreg;
  int inst_num;
  struct MonoMethodVar * vars;
  guint32 abs_pos;

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

    try
      {
        D.23146 = ins->opcode;
        D.23147 = (int) D.23146;
        D.23148 = D.23147 + -313;
        D.23149 = D.23148 * 4;
        spec = &ins_info[D.23149];
        D.23150 = cfg->verbose_level;
        if (D.23150 > 1) goto <D.23151>; else goto <D.23152>;
        <D.23151>:
        printf ("\t");
        mono_print_ins (ins);
        <D.23152>:
        D.23146 = ins->opcode;
        if (D.23146 == 316) goto <D.23153>; else goto <D.23154>;
        <D.23153>:
        // predicted unlikely by continue predictor.
        goto <D.22311>;
        <D.23154>:
        D.23146 = ins->opcode;
        if (D.23146 == 314) goto <D.23155>; else goto <D.23156>;
        <D.23155>:
        {
          struct MonoInst * var;
          int idx;
          struct MonoMethodVar * vi;

          var = ins->data.op[0].p;
          D.23157 = var->data.op[0].const_val;
          idx = (int) D.23157;
          D.23158 = cfg->vars;
          D.23159 = (long unsigned int) idx;
          D.23160 = D.23159 * 80;
          vi = D.23158 + D.23160;
          D.23150 = cfg->verbose_level;
          if (D.23150 > 1) goto <D.23161>; else goto <D.23162>;
          <D.23161>:
          D.23163 = var->dreg;
          printf ("\tGEN: R%d(%d)\n", D.23163, idx);
          <D.23162>:
          inst_num.21 = (unsigned int) inst_num;
          D.23165 = abs_pos + inst_num.21;
          D.23166 = (int) D.23165;
          D.23159 = (long unsigned int) idx;
          D.23160 = D.23159 * 80;
          D.23167 = vars + D.23160;
          update_live_range (D.23167, D.23166);
          D.23168 = bb->kill_set;
          D.23159 = (long unsigned int) idx;
          D.23169 = D.23159 / 64;
          D.23170 = D.23168->data[D.23169];
          D.23171 = idx & 63;
          D.23172 = D.23170 >> D.23171;
          D.23173 = D.23172 & 1;
          if (D.23173 == 0) goto <D.23174>; else goto <D.23175>;
          <D.23174>:
          D.23176 = bb->gen_set;
          D.23159 = (long unsigned int) idx;
          D.23177 = D.23159 / 64;
          D.23176 = bb->gen_set;
          D.23178 = D.23176->data[D.23177];
          D.23171 = idx & 63;
          D.23179 = 1 << D.23171;
          D.23180 = D.23178 | D.23179;
          D.23176->data[D.23177] = D.23180;
          <D.23175>:
          D.23181 = vi->spill_costs;
          D.23182 = bb->nesting;
          D.23183 = (int) D.23182;
          D.23184 = D.23183 << 1;
          D.23185 = 1 << D.23184;
          D.23186 = D.23181 + D.23185;
          vi->spill_costs = D.23186;
        }
        <D.23156>:
        D.23187 = ins->sreg1;
        sregs[0] = D.23187;
        D.23188 = ins->sreg2;
        sregs[1] = D.23188;
        D.23189 = ins->sreg3;
        sregs[2] = D.23189;
        D.23146 = ins->opcode;
        D.23147 = (int) D.23146;
        D.23148 = D.23147 + -313;
        D.23190 = ins_sreg_counts[D.23148];
        num_sregs = (int) D.23190;
        i = 0;
        goto <D.22319>;
        <D.22318>:
        sreg = sregs[i];
        D.23191 = i + 1;
        D.23192 = (sizetype) D.23191;
        D.23193 = spec + D.23192;
        D.23194 = *D.23193;
        if (D.23194 != 32) goto <D.23195>; else goto <D.23196>;
        <D.23195>:
        sreg.22 = (unsigned int) sreg;
        D.23198 = cfg->vreg_to_inst_len;
        if (sreg.22 < D.23198) goto <D.23199>; else goto <D.23200>;
        <D.23199>:
        D.23201 = cfg->vreg_to_inst;
        D.23202 = (long unsigned int) sreg;
        D.23203 = D.23202 * 8;
        D.23204 = D.23201 + D.23203;
        D.23205 = *D.23204;
        if (D.23205 != 0B) goto <D.23206>; else goto <D.23207>;
        <D.23206>:
        {
          struct MonoInst * var;
          int idx;
          struct MonoMethodVar * vi;

          sreg.22 = (unsigned int) sreg;
          D.23198 = cfg->vreg_to_inst_len;
          if (sreg.22 < D.23198) goto <D.23209>; else goto <D.23210>;
          <D.23209>:
          D.23201 = cfg->vreg_to_inst;
          D.23202 = (long unsigned int) sreg;
          D.23203 = D.23202 * 8;
          D.23204 = D.23201 + D.23203;
          iftmp.23 = *D.23204;
          goto <D.23211>;
          <D.23210>:
          iftmp.23 = 0B;
          <D.23211>:
          var = iftmp.23;
          D.23212 = var->data.op[0].const_val;
          idx = (int) D.23212;
          D.23158 = cfg->vars;
          D.23213 = (long unsigned int) idx;
          D.23214 = D.23213 * 80;
          vi = D.23158 + D.23214;
          D.23150 = cfg->verbose_level;
          if (D.23150 > 1) goto <D.23215>; else goto <D.23216>;
          <D.23215>:
          printf ("\tGEN: R%d(%d)\n", sreg, idx);
          <D.23216>:
          inst_num.21 = (unsigned int) inst_num;
          D.23165 = abs_pos + inst_num.21;
          D.23166 = (int) D.23165;
          D.23213 = (long unsigned int) idx;
          D.23214 = D.23213 * 80;
          D.23217 = vars + D.23214;
          update_live_range (D.23217, D.23166);
          D.23168 = bb->kill_set;
          D.23213 = (long unsigned int) idx;
          D.23218 = D.23213 / 64;
          D.23219 = D.23168->data[D.23218];
          D.23220 = idx & 63;
          D.23221 = D.23219 >> D.23220;
          D.23222 = D.23221 & 1;
          if (D.23222 == 0) goto <D.23223>; else goto <D.23224>;
          <D.23223>:
          D.23176 = bb->gen_set;
          D.23213 = (long unsigned int) idx;
          D.23225 = D.23213 / 64;
          D.23176 = bb->gen_set;
          D.23226 = D.23176->data[D.23225];
          D.23220 = idx & 63;
          D.23227 = 1 << D.23220;
          D.23228 = D.23226 | D.23227;
          D.23176->data[D.23225] = D.23228;
          <D.23224>:
          D.23229 = vi->spill_costs;
          D.23182 = bb->nesting;
          D.23183 = (int) D.23182;
          D.23184 = D.23183 << 1;
          D.23185 = 1 << D.23184;
          D.23230 = D.23229 + D.23185;
          vi->spill_costs = D.23230;
        }
        <D.23207>:
        <D.23200>:
        <D.23196>:
        i = i + 1;
        <D.22319>:
        if (i < num_sregs) goto <D.22318>; else goto <D.22320>;
        <D.22320>:
        D.23231 = *spec;
        if (D.23231 != 32) goto <D.23232>; else goto <D.23233>;
        <D.23232>:
        D.23234 = ins->dreg;
        D.23235 = (unsigned int) D.23234;
        D.23198 = cfg->vreg_to_inst_len;
        if (D.23235 < D.23198) goto <D.23236>; else goto <D.23237>;
        <D.23236>:
        D.23201 = cfg->vreg_to_inst;
        D.23234 = ins->dreg;
        D.23238 = (long unsigned int) D.23234;
        D.23239 = D.23238 * 8;
        D.23240 = D.23201 + D.23239;
        D.23241 = *D.23240;
        if (D.23241 != 0B) goto <D.23242>; else goto <D.23243>;
        <D.23242>:
        {
          struct MonoInst * var;
          int idx;
          struct MonoMethodVar * vi;

          D.23234 = ins->dreg;
          D.23235 = (unsigned int) D.23234;
          D.23198 = cfg->vreg_to_inst_len;
          if (D.23235 < D.23198) goto <D.23245>; else goto <D.23246>;
          <D.23245>:
          D.23201 = cfg->vreg_to_inst;
          D.23234 = ins->dreg;
          D.23238 = (long unsigned int) D.23234;
          D.23239 = D.23238 * 8;
          D.23240 = D.23201 + D.23239;
          iftmp.24 = *D.23240;
          goto <D.23247>;
          <D.23246>:
          iftmp.24 = 0B;
          <D.23247>:
          var = iftmp.24;
          D.23248 = var->data.op[0].const_val;
          idx = (int) D.23248;
          D.23158 = cfg->vars;
          D.23249 = (long unsigned int) idx;
          D.23250 = D.23249 * 80;
          vi = D.23158 + D.23250;
          D.23146 = ins->opcode;
          D.23251 = D.23146 + 65162;
          if (D.23251 <= 16) goto <D.23252>; else goto <D.23253>;
          <D.23252>:
          inst_num.21 = (unsigned int) inst_num;
          D.23165 = abs_pos + inst_num.21;
          D.23166 = (int) D.23165;
          D.23249 = (long unsigned int) idx;
          D.23250 = D.23249 * 80;
          D.23254 = vars + D.23250;
          update_live_range (D.23254, D.23166);
          D.23168 = bb->kill_set;
          D.23249 = (long unsigned int) idx;
          D.23255 = D.23249 / 64;
          D.23256 = D.23168->data[D.23255];
          D.23257 = idx & 63;
          D.23258 = D.23256 >> D.23257;
          D.23259 = D.23258 & 1;
          if (D.23259 == 0) goto <D.23260>; else goto <D.23261>;
          <D.23260>:
          D.23176 = bb->gen_set;
          D.23249 = (long unsigned int) idx;
          D.23262 = D.23249 / 64;
          D.23176 = bb->gen_set;
          D.23263 = D.23176->data[D.23262];
          D.23257 = idx & 63;
          D.23264 = 1 << D.23257;
          D.23265 = D.23263 | D.23264;
          D.23176->data[D.23262] = D.23265;
          <D.23261>:
          D.23266 = vi->spill_costs;
          D.23182 = bb->nesting;
          D.23183 = (int) D.23182;
          D.23184 = D.23183 << 1;
          D.23185 = 1 << D.23184;
          D.23267 = D.23266 + D.23185;
          vi->spill_costs = D.23267;
          goto <D.23268>;
          <D.23253>:
          D.23150 = cfg->verbose_level;
          if (D.23150 > 1) goto <D.23269>; else goto <D.23270>;
          <D.23269>:
          D.23234 = ins->dreg;
          printf ("\tKILL: R%d(%d)\n", D.23234, idx);
          <D.23270>:
          inst_num.21 = (unsigned int) inst_num;
          D.23165 = abs_pos + inst_num.21;
          D.23271 = D.23165 + 1;
          D.23272 = (int) D.23271;
          D.23249 = (long unsigned int) idx;
          D.23250 = D.23249 * 80;
          D.23254 = vars + D.23250;
          update_live_range (D.23254, D.23272);
          D.23168 = bb->kill_set;
          D.23249 = (long unsigned int) idx;
          D.23273 = D.23249 / 64;
          D.23168 = bb->kill_set;
          D.23274 = D.23168->data[D.23273];
          D.23257 = idx & 63;
          D.23264 = 1 << D.23257;
          D.23275 = D.23274 | D.23264;
          D.23168->data[D.23273] = D.23275;
          D.23266 = vi->spill_costs;
          D.23182 = bb->nesting;
          D.23183 = (int) D.23182;
          D.23184 = D.23183 << 1;
          D.23185 = 1 << D.23184;
          D.23267 = D.23266 + D.23185;
          vi->spill_costs = D.23267;
          <D.23268>:
        }
        <D.23243>:
        <D.23237>:
        <D.23233>:
      }
    finally
      {
        sregs = {CLOBBER};
      }
  }
  <D.22311>:
  ins = ins->next;
  inst_num = inst_num + 2;
  <D.22325>:
  if (ins != 0B) goto <D.22324>; else goto <D.22326>;
  <D.22326>:
}


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

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


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

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


memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.23282;
  long unsigned int D.23283;

  D.23283 = __builtin_object_size (__dest, 0);
  D.23282 = __builtin___memcpy_chk (__dest, __src, __len, D.23283);
  return D.23282;
}


update_live_range (struct MonoMethodVar * var, int abs_pos)
{
  unsigned int D.23285;
  unsigned int abs_pos.25;
  unsigned int D.23289;

  D.23285 = var->range.first_use.abs_pos;
  abs_pos.25 = (unsigned int) abs_pos;
  if (D.23285 > abs_pos.25) goto <D.23287>; else goto <D.23288>;
  <D.23287>:
  abs_pos.25 = (unsigned int) abs_pos;
  var->range.first_use.abs_pos = abs_pos.25;
  <D.23288>:
  D.23289 = var->range.last_use.abs_pos;
  abs_pos.25 = (unsigned int) abs_pos;
  if (D.23289 < abs_pos.25) goto <D.23290>; else goto <D.23291>;
  <D.23290>:
  abs_pos.25 = (unsigned int) abs_pos;
  var->range.last_use.abs_pos = abs_pos.25;
  <D.23291>:
}


mono_bitset_print (struct MonoBitSet * set)
{
  unsigned int i.26;
  int D.23293;
  unsigned int D.23298;
  int i;
  gboolean first;

  first = 1;
  printf ("{");
  i = 0;
  goto <D.22239>;
  <D.22238>:
  i.26 = (unsigned int) i;
  D.23293 = mono_bitset_test (set, i.26);
  if (D.23293 != 0) goto <D.23294>; else goto <D.23295>;
  <D.23294>:
  if (first == 0) goto <D.23296>; else goto <D.23297>;
  <D.23296>:
  printf (", ");
  <D.23297>:
  printf ("%d", i);
  first = 0;
  <D.23295>:
  i = i + 1;
  <D.22239>:
  i.26 = (unsigned int) i;
  D.23298 = mono_bitset_size (set);
  if (i.26 < D.23298) goto <D.22238>; else goto <D.22240>;
  <D.22240>:
  printf ("}\n");
}


optimize_initlocals (struct MonoCompile * cfg)
{
  unsigned int D.23299;
  unsigned int D.23300;
  struct MonoBasicBlock * D.23301;
  int D.23302;
  int D.23303;
  int D.23304;
  short unsigned int D.23305;
  int D.23306;
  int D.23307;
  signed char D.23308;
  int D.23309;
  long unsigned int D.23310;
  long unsigned int D.23311;
  long unsigned int D.23312;
  int D.23313;
  long unsigned int D.23314;
  long unsigned int D.23315;
  short unsigned int D.23316;
  int D.23319;
  long unsigned int D.23320;
  long unsigned int D.23321;
  long unsigned int D.23322;
  int D.23323;
  long unsigned int D.23324;
  long unsigned int D.23325;
  int D.23326;
  char D.23327;
  struct MonoInst * iftmp.27;
  unsigned int D.23333;
  unsigned int D.23334;
  struct MonoInst * * D.23337;
  long unsigned int D.23338;
  struct MonoInst * * D.23339;
  long unsigned int D.23343;
  long unsigned int D.23344;
  long unsigned int D.23345;
  long unsigned int D.23346;
  struct MonoBitSet * D.23349;
  long int D.23350;
  long unsigned int D.23351;
  long unsigned int D.23352;
  long unsigned int D.23353;
  int D.23354;
  int D.23355;
  long unsigned int D.23356;
  long unsigned int D.23357;
  struct MonoInst * D.23360;
  unsigned char D.23363;
  int D.23364;
  int D.23365;
  unsigned char D.23368;
  unsigned char D.23369;
  unsigned char D.23372;
  short unsigned int D.23375;
  short unsigned int D.23376;
  _Bool D.23377;
  _Bool D.23378;
  _Bool D.23379;
  struct MonoMethodVar * D.23382;
  long unsigned int D.23383;
  struct MonoMethodVar * D.23384;
  int D.23385;
  int D.23386;
  struct MonoBitSet * used;
  struct MonoInst * ins;
  struct MonoBasicBlock * initlocals_bb;

  D.23299 = cfg->next_vreg;
  D.23300 = D.23299 + 1;
  used = mono_bitset_new (D.23300, 0);
  mono_bitset_clear_all (used);
  D.23301 = cfg->bb_entry;
  initlocals_bb = D.23301->next_bb;
  ins = initlocals_bb->code;
  goto <D.22467>;
  <D.22466>:
  {
    int num_sregs;
    int i;
    int sregs[3];

    try
      {
        D.23302 = ins->sreg1;
        sregs[0] = D.23302;
        D.23303 = ins->sreg2;
        sregs[1] = D.23303;
        D.23304 = ins->sreg3;
        sregs[2] = D.23304;
        D.23305 = ins->opcode;
        D.23306 = (int) D.23305;
        D.23307 = D.23306 + -313;
        D.23308 = ins_sreg_counts[D.23307];
        num_sregs = (int) D.23308;
        i = 0;
        goto <D.22464>;
        <D.22463>:
        D.23309 = sregs[i];
        D.23310 = (long unsigned int) D.23309;
        D.23311 = D.23310 / 64;
        D.23312 = used->data[D.23311];
        D.23309 = sregs[i];
        D.23313 = D.23309 & 63;
        D.23314 = 1 << D.23313;
        D.23315 = D.23312 | D.23314;
        used->data[D.23311] = D.23315;
        i = i + 1;
        <D.22464>:
        if (i < num_sregs) goto <D.22463>; else goto <D.22465>;
        <D.22465>:
        D.23305 = ins->opcode;
        D.23316 = D.23305 + 65162;
        if (D.23316 <= 16) goto <D.23317>; else goto <D.23318>;
        <D.23317>:
        D.23319 = ins->dreg;
        D.23320 = (long unsigned int) D.23319;
        D.23321 = D.23320 / 64;
        D.23322 = used->data[D.23321];
        D.23319 = ins->dreg;
        D.23323 = D.23319 & 63;
        D.23324 = 1 << D.23323;
        D.23325 = D.23322 | D.23324;
        used->data[D.23321] = D.23325;
        <D.23318>:
      }
    finally
      {
        sregs = {CLOBBER};
      }
  }
  ins = ins->next;
  <D.22467>:
  if (ins != 0B) goto <D.22466>; else goto <D.22468>;
  <D.22468>:
  ins = initlocals_bb->code;
  goto <D.22473>;
  <D.22472>:
  {
    const char * spec;

    D.23305 = ins->opcode;
    D.23306 = (int) D.23305;
    D.23307 = D.23306 + -313;
    D.23326 = D.23307 * 4;
    spec = &ins_info[D.23326];
    D.23327 = *spec;
    if (D.23327 != 32) goto <D.23328>; else goto <D.23329>;
    <D.23328>:
    D.23305 = ins->opcode;
    D.23316 = D.23305 + 65162;
    if (D.23316 > 16) goto <D.23330>; else goto <D.23331>;
    <D.23330>:
    {
      struct MonoInst * var;

      D.23319 = ins->dreg;
      D.23333 = (unsigned int) D.23319;
      D.23334 = cfg->vreg_to_inst_len;
      if (D.23333 < D.23334) goto <D.23335>; else goto <D.23336>;
      <D.23335>:
      D.23337 = cfg->vreg_to_inst;
      D.23319 = ins->dreg;
      D.23320 = (long unsigned int) D.23319;
      D.23338 = D.23320 * 8;
      D.23339 = D.23337 + D.23338;
      iftmp.27 = *D.23339;
      goto <D.23340>;
      <D.23336>:
      iftmp.27 = 0B;
      <D.23340>:
      var = iftmp.27;
      if (var != 0B) goto <D.23341>; else goto <D.23342>;
      <D.23341>:
      D.23319 = ins->dreg;
      D.23320 = (long unsigned int) D.23319;
      D.23343 = D.23320 / 64;
      D.23344 = used->data[D.23343];
      D.23319 = ins->dreg;
      D.23323 = D.23319 & 63;
      D.23345 = D.23344 >> D.23323;
      D.23346 = D.23345 & 1;
      if (D.23346 == 0) goto <D.23347>; else goto <D.23348>;
      <D.23347>:
      D.23349 = initlocals_bb->live_out_set;
      D.23350 = var->data.op[0].const_val;
      D.23351 = (long unsigned int) D.23350;
      D.23352 = D.23351 / 64;
      D.23353 = D.23349->data[D.23352];
      D.23350 = var->data.op[0].const_val;
      D.23354 = (int) D.23350;
      D.23355 = D.23354 & 63;
      D.23356 = D.23353 >> D.23355;
      D.23357 = D.23356 & 1;
      if (D.23357 == 0) goto <D.23358>; else goto <D.23359>;
      <D.23358>:
      D.23360 = cfg->ret;
      if (D.23360 != var) goto <D.23361>; else goto <D.23362>;
      <D.23361>:
      D.23363 = var->flags;
      D.23364 = (int) D.23363;
      D.23365 = D.23364 & 20;
      if (D.23365 == 0) goto <D.23366>; else goto <D.23367>;
      <D.23366>:
      D.23368 = BIT_FIELD_REF <*cfg, 8, 5616>;
      D.23369 = D.23368 & 16;
      if (D.23369 != 0) goto <D.23370>; else goto <D.23371>;
      <D.23370>:
      D.23372 = var->type;
      if (D.23372 == 6) goto <D.23373>; else goto <D.23374>;
      <D.23373>:
      // predicted unlikely by continue predictor.
      goto <D.22471>;
      <D.23374>:
      <D.23371>:
      D.23375 = ins->opcode;
      D.23376 = D.23375 + 65174;
      D.23377 = D.23376 <= 1;
      D.23378 = D.23375 == 365;
      D.23379 = D.23377 | D.23378;
      if (D.23379 != 0) goto <D.23380>; else goto <D.23381>;
      <D.23380>:
      ins->opcode = 316;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.23304 = ins->sreg3;
      ins->sreg2 = D.23304;
      D.23303 = ins->sreg2;
      ins->sreg1 = D.23303;
      D.23382 = cfg->vars;
      D.23350 = var->data.op[0].const_val;
      D.23351 = (long unsigned int) D.23350;
      D.23383 = D.23351 * 80;
      D.23384 = D.23382 + D.23383;
      D.23382 = cfg->vars;
      D.23350 = var->data.op[0].const_val;
      D.23351 = (long unsigned int) D.23350;
      D.23383 = D.23351 * 80;
      D.23384 = D.23382 + D.23383;
      D.23385 = D.23384->spill_costs;
      D.23386 = D.23385 + -1;
      D.23384->spill_costs = D.23386;
      <D.23381>:
      <D.23367>:
      <D.23362>:
      <D.23359>:
      <D.23348>:
      <D.23342>:
    }
    <D.23331>:
    <D.23329>:
  }
  <D.22471>:
  ins = ins->next;
  <D.22473>:
  if (ins != 0B) goto <D.22472>; else goto <D.22474>;
  <D.22474>:
  monoeg_g_free (used);
}


mono_analyze_liveness2 (struct MonoCompile * cfg)
{
  unsigned int disabled.28;
  const gchar * D.23390;
  _Bool D.23391;
  unsigned int disabled.29;
  unsigned int D.23395;
  struct MonoMethod * D.23398;
  char * D.23399;
  unsigned int D.23400;
  long unsigned int D.23401;
  long unsigned int D.23402;
  long unsigned int D.23403;
  unsigned int D.23404;
  unsigned int D.23405;
  struct MonoMemPool * D.23406;
  struct MonoMethodVar * D.23407;
  long unsigned int D.23408;
  long unsigned int D.23409;
  void * D.23410;
  unsigned int D.23411;
  unsigned int D.23412;
  struct MonoBasicBlock * * D.23413;
  long unsigned int D.23414;
  long unsigned int D.23415;
  struct MonoBasicBlock * * D.23416;
  int D.23417;
  int D.23418;
  unsigned int bnum.30;
  sizetype D.23422;
  sizetype D.23423;
  sizetype D.23424;
  struct MonoBasicBlock * * D.23425;
  struct MonoBasicBlock * D.23426;
  int D.23427;
  int D.23428;
  int D.23432;
  long unsigned int D.23433;
  long unsigned int D.23434;
  struct MonoBitSet * D.23435;
  unsigned int j.31;
  unsigned int D.23437;
  long unsigned int D.23438;
  struct MonoInst * * D.23443;
  long unsigned int D.23444;
  long unsigned int D.23445;
  struct MonoInst * * D.23446;
  struct MonoInst * D.23447;
  int D.23448;
  long unsigned int D.23449;
  gint32 * D.23450;
  struct MonoInst * D.23451;
  long int D.23454;
  long unsigned int D.23455;
  long unsigned int D.23456;
  gint32 * D.23457;
  long unsigned int D.23460;
  unsigned int D.23461;
  unsigned int D.23462;
  long unsigned int D.23463;
  long unsigned int D.23464;
  long unsigned int D.23465;
  struct MonoInst * * D.23466;
  long unsigned int D.23467;
  long unsigned int D.23468;
  struct MonoInst * * D.23469;
  long unsigned int D.23470;
  gint32 * D.23471;
  int D.23472;
  long unsigned int D.23477;
  struct MonoInst * * D.23478;
  struct MonoInst * D.23479;
  int D.23480;
  struct MonoLiveInterval * D.23481;
  long unsigned int D.23482;
  unsigned int D.23483;
  long unsigned int D.23484;
  long unsigned int D.23485;
  struct MonoInst * * D.23486;
  struct MonoInst * D.23487;
  short unsigned int D.23488;
  struct MonoLiveInterval * D.23491;
  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.28 = disabled;
  if (disabled.28 == 4294967295) goto <D.23388>; else goto <D.23389>;
  <D.23388>:
  D.23390 = monoeg_g_getenv ("DISABLED");
  D.23391 = D.23390 != 0B;
  disabled.29 = (unsigned int) D.23391;
  disabled = disabled.29;
  <D.23389>:
  disabled.28 = disabled;
  if (disabled.28 != 0) goto <D.23393>; else goto <D.23394>;
  <D.23393>:
  return;
  <D.23394>:
  D.23395 = cfg->verbose_level;
  if (D.23395 > 1) goto <D.23396>; else goto <D.23397>;
  <D.23396>:
  D.23398 = cfg->method;
  D.23399 = mono_method_full_name (D.23398, 1);
  printf ("LIVENESS 2 %s\n", D.23399);
  <D.23397>:
  D.23400 = cfg->num_varinfo;
  max_vars = (int) D.23400;
  D.23401 = (long unsigned int) max_vars;
  D.23402 = D.23401 * 4;
  last_use = monoeg_malloc0 (D.23402);
  reverse_len = 1024;
  D.23403 = (long unsigned int) reverse_len;
  D.23404 = (unsigned int) D.23403;
  D.23405 = D.23404 * 8;
  D.23406 = cfg->mempool;
  reverse = mono_mempool_alloc (D.23406, D.23405);
  idx = 0;
  goto <D.22567>;
  <D.22566>:
  {
    struct MonoMethodVar * vi;

    D.23407 = cfg->vars;
    D.23408 = (long unsigned int) idx;
    D.23409 = D.23408 * 80;
    vi = D.23407 + D.23409;
    D.23406 = cfg->mempool;
    D.23410 = mono_mempool_alloc0 (D.23406, 16);
    vi->interval = D.23410;
  }
  idx = idx + 1;
  <D.22567>:
  if (idx < max_vars) goto <D.22566>; else goto <D.22568>;
  <D.22568>:
  D.23411 = cfg->num_bblocks;
  D.23412 = D.23411 + 4294967295;
  bnum = (int) D.23412;
  goto <D.22593>;
  <D.22592>:
  {
    struct MonoBasicBlock * bb;
    struct MonoInst * ins;

    D.23413 = cfg->bblocks;
    D.23414 = (long unsigned int) bnum;
    D.23415 = D.23414 * 8;
    D.23416 = D.23413 + D.23415;
    bb = *D.23416;
    D.23417 = bb->dfn;
    D.23418 = D.23417 << 16;
    block_from = D.23418 + 1;
    bnum.30 = (unsigned int) bnum;
    D.23411 = cfg->num_bblocks;
    D.23412 = D.23411 + 4294967295;
    if (bnum.30 < D.23412) goto <D.23420>; else goto <D.23421>;
    <D.23420>:
    D.23413 = cfg->bblocks;
    D.23422 = (sizetype) bnum;
    D.23423 = D.23422 + 1;
    D.23424 = D.23423 * 8;
    D.23425 = D.23413 + D.23424;
    D.23426 = *D.23425;
    D.23427 = D.23426->dfn;
    D.23428 = D.23427 << 16;
    block_to = D.23428 + 1;
    goto <D.23429>;
    <D.23421>:
    D.23417 = bb->dfn;
    D.23418 = D.23417 << 16;
    block_to = D.23418 + 65535;
    <D.23429>:
    D.23395 = cfg->verbose_level;
    if (D.23395 > 1) goto <D.23430>; else goto <D.23431>;
    <D.23430>:
    D.23432 = bb->block_num;
    printf ("LIVENESS BLOCK BB%d:\n", D.23432);
    <D.23431>:
    D.23401 = (long unsigned int) max_vars;
    D.23402 = D.23401 * 4;
    memset (last_use, 0, D.23402);
    D.23401 = (long unsigned int) max_vars;
    D.23433 = D.23401 + 63;
    D.23434 = D.23433 / 64;
    max = (int) D.23434;
    j = 0;
    goto <D.22577>;
    <D.22576>:
    {
      gsize bits_out;
      int k;

      D.23435 = bb->live_out_set;
      bits_out = D.23435->data[j];
      j.31 = (unsigned int) j;
      D.23437 = j.31 * 64;
      k = (int) D.23437;
      goto <D.22574>;
      <D.22573>:
      D.23438 = bits_out & 1;
      if (D.23438 != 0) goto <D.23439>; else goto <D.23440>;
      <D.23439>:
      D.23395 = cfg->verbose_level;
      if (D.23395 > 1) goto <D.23441>; else goto <D.23442>;
      <D.23441>:
      D.23443 = cfg->varinfo;
      D.23444 = (long unsigned int) k;
      D.23445 = D.23444 * 8;
      D.23446 = D.23443 + D.23445;
      D.23447 = *D.23446;
      D.23448 = D.23447->dreg;
      printf ("Var R%d live at exit, set last_use to %x\n", D.23448, block_to);
      <D.23442>:
      D.23444 = (long unsigned int) k;
      D.23449 = D.23444 * 4;
      D.23450 = last_use + D.23449;
      *D.23450 = block_to;
      <D.23440>:
      bits_out = bits_out >> 1;
      k = k + 1;
      <D.22574>:
      if (bits_out != 0) goto <D.22573>; else goto <D.22575>;
      <D.22575>:
    }
    j = j + 1;
    <D.22577>:
    if (j < max) goto <D.22576>; else goto <D.22578>;
    <D.22578>:
    D.23451 = cfg->ret;
    if (D.23451 != 0B) goto <D.23452>; else goto <D.23453>;
    <D.23452>:
    D.23451 = cfg->ret;
    D.23454 = D.23451->data.op[0].const_val;
    D.23455 = (long unsigned int) D.23454;
    D.23456 = D.23455 * 4;
    D.23457 = last_use + D.23456;
    *D.23457 = block_to;
    <D.23453>:
    nins = 0;
    pos = block_from;
    ins = bb->code;
    goto <D.22582>;
    <D.22581>:
    if (nins >= reverse_len) goto <D.23458>; else goto <D.23459>;
    <D.23458>:
    {
      int new_reverse_len;
      struct MonoInst * * new_reverse;

      new_reverse_len = reverse_len * 2;
      D.23460 = (long unsigned int) new_reverse_len;
      D.23461 = (unsigned int) D.23460;
      D.23462 = D.23461 * 8;
      D.23406 = cfg->mempool;
      new_reverse = mono_mempool_alloc (D.23406, D.23462);
      D.23403 = (long unsigned int) reverse_len;
      D.23463 = D.23403 * 8;
      memcpy (new_reverse, reverse, D.23463);
      reverse = new_reverse;
      reverse_len = new_reverse_len;
    }
    <D.23459>:
    D.23464 = (long unsigned int) nins;
    D.23465 = D.23464 * 8;
    D.23466 = reverse + D.23465;
    *D.23466 = ins;
    ins = ins->next;
    nins = nins + 1;
    pos = pos + 1;
    <D.22582>:
    if (ins != 0B) goto <D.22581>; else goto <D.22583>;
    <D.22583>:
    i = nins + -1;
    goto <D.22586>;
    <D.22585>:
    {
      struct MonoInst * ins;

      D.23467 = (long unsigned int) i;
      D.23468 = D.23467 * 8;
      D.23469 = reverse + D.23468;
      ins = *D.23469;
      update_liveness2 (cfg, ins, 0, pos, last_use);
      pos = pos + -1;
    }
    i = i + -1;
    <D.22586>:
    if (i >= 0) goto <D.22585>; else goto <D.22587>;
    <D.22587>:
    idx = 0;
    goto <D.22590>;
    <D.22589>:
    {
      struct MonoMethodVar * vi;

      D.23407 = cfg->vars;
      D.23408 = (long unsigned int) idx;
      D.23409 = D.23408 * 80;
      vi = D.23407 + D.23409;
      D.23408 = (long unsigned int) idx;
      D.23470 = D.23408 * 4;
      D.23471 = last_use + D.23470;
      D.23472 = *D.23471;
      if (D.23472 != 0) goto <D.23473>; else goto <D.23474>;
      <D.23473>:
      D.23395 = cfg->verbose_level;
      if (D.23395 > 1) goto <D.23475>; else goto <D.23476>;
      <D.23475>:
      D.23408 = (long unsigned int) idx;
      D.23470 = D.23408 * 4;
      D.23471 = last_use + D.23470;
      D.23472 = *D.23471;
      D.23443 = cfg->varinfo;
      D.23408 = (long unsigned int) idx;
      D.23477 = D.23408 * 8;
      D.23478 = D.23443 + D.23477;
      D.23479 = *D.23478;
      D.23480 = D.23479->dreg;
      D.23443 = cfg->varinfo;
      D.23408 = (long unsigned int) idx;
      D.23477 = D.23408 * 8;
      D.23478 = D.23443 + D.23477;
      D.23479 = *D.23478;
      D.23480 = D.23479->dreg;
      printf ("Var R%d live at enter, add range to R%d: [%x, %x)\n", D.23480, D.23480, block_from, D.23472);
      <D.23476>:
      D.23408 = (long unsigned int) idx;
      D.23470 = D.23408 * 4;
      D.23471 = last_use + D.23470;
      D.23472 = *D.23471;
      D.23481 = vi->interval;
      mono_linterval_add_range (cfg, D.23481, block_from, D.23472);
      <D.23474>:
    }
    idx = idx + 1;
    <D.22590>:
    if (idx < max_vars) goto <D.22589>; else goto <D.22591>;
    <D.22591>:
  }
  bnum = bnum + -1;
  <D.22593>:
  if (bnum >= 0) goto <D.22592>; else goto <D.22594>;
  <D.22594>:
  i = 0;
  goto <D.22597>;
  <D.22596>:
  {
    struct MonoMethodVar * vi;

    D.23407 = cfg->vars;
    D.23467 = (long unsigned int) i;
    D.23482 = D.23467 * 80;
    vi = D.23407 + D.23482;
    D.23443 = cfg->varinfo;
    D.23483 = vi->idx;
    D.23484 = (long unsigned int) D.23483;
    D.23485 = D.23484 * 8;
    D.23486 = D.23443 + D.23485;
    D.23487 = *D.23486;
    D.23488 = D.23487->opcode;
    if (D.23488 == 330) goto <D.23489>; else goto <D.23490>;
    <D.23489>:
    D.23491 = vi->interval;
    mono_linterval_add_range (cfg, D.23491, 0, 1);
    <D.23490>:
  }
  i = i + 1;
  <D.22597>:
  if (i < max_vars) goto <D.22596>; else goto <D.22598>;
  <D.22598>:
  monoeg_g_free (last_use);
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.23495;
  int D.23500;
  void * D.23502;
  long unsigned int D.23503;

  D.23495 = __builtin_constant_p (__len);
  if (D.23495 != 0) goto <D.23496>; else goto <D.23497>;
  <D.23496>:
  if (__len == 0) goto <D.23498>; else goto <D.23499>;
  <D.23498>:
  D.23500 = __builtin_constant_p (__ch);
  if (D.23500 == 0) goto <D.23493>; else goto <D.23501>;
  <D.23501>:
  if (__ch != 0) goto <D.23493>; else goto <D.23494>;
  <D.23493>:
  __warn_memset_zero_len ();
  D.23502 = __dest;
  return D.23502;
  <D.23494>:
  <D.23499>:
  <D.23497>:
  D.23503 = __builtin_object_size (__dest, 0);
  D.23502 = __builtin___memset_chk (__dest, __ch, __len, D.23503);
  return D.23502;
}


update_liveness2 (struct MonoCompile * cfg, struct MonoInst * ins, gboolean set_volatile, int inst_num, gint32 * last_use)
{
  short unsigned int D.23505;
  int D.23506;
  int D.23507;
  int D.23508;
  unsigned int D.23509;
  char D.23514;
  int D.23517;
  unsigned int D.23518;
  unsigned int D.23519;
  struct MonoInst * * D.23522;
  long unsigned int D.23523;
  long unsigned int D.23524;
  struct MonoInst * * D.23525;
  struct MonoInst * D.23526;
  struct MonoInst * iftmp.32;
  long int D.23533;
  struct MonoMethodVar * D.23534;
  long unsigned int D.23535;
  long unsigned int D.23536;
  short unsigned int D.23537;
  long unsigned int D.23540;
  gint32 * D.23541;
  int D.23542;
  struct MonoLiveInterval * D.23552;
  struct MonoInst * D.23554;
  unsigned char D.23557;
  int D.23558;
  int D.23559;
  short unsigned int D.23562;
  short unsigned int D.23563;
  _Bool D.23564;
  _Bool D.23565;
  _Bool D.23566;
  int D.23569;
  int D.23574;
  int D.23575;
  int D.23578;
  int D.23579;
  signed char D.23580;
  int D.23581;
  sizetype D.23582;
  const char * D.23583;
  char D.23584;
  unsigned int sreg.33;
  long unsigned int D.23590;
  long unsigned int D.23591;
  struct MonoInst * * D.23592;
  struct MonoInst * D.23593;
  struct MonoInst * iftmp.34;
  long int D.23600;
  long unsigned int D.23601;
  long unsigned int D.23602;
  gint32 * D.23603;
  int D.23604;
  const char * spec;
  int sreg;
  int num_sregs;
  int i;
  int sregs[3];

  try
    {
      D.23505 = ins->opcode;
      D.23506 = (int) D.23505;
      D.23507 = D.23506 + -313;
      D.23508 = D.23507 * 4;
      spec = &ins_info[D.23508];
      D.23509 = cfg->verbose_level;
      if (D.23509 > 1) goto <D.23510>; else goto <D.23511>;
      <D.23510>:
      printf ("\t%x: ", inst_num);
      mono_print_ins (ins);
      <D.23511>:
      D.23505 = ins->opcode;
      if (D.23505 == 316) goto <D.23512>; else goto <D.23513>;
      <D.23512>:
      return;
      <D.23513>:
      D.23514 = *spec;
      if (D.23514 != 32) goto <D.23515>; else goto <D.23516>;
      <D.23515>:
      D.23517 = ins->dreg;
      D.23518 = (unsigned int) D.23517;
      D.23519 = cfg->vreg_to_inst_len;
      if (D.23518 < D.23519) goto <D.23520>; else goto <D.23521>;
      <D.23520>:
      D.23522 = cfg->vreg_to_inst;
      D.23517 = ins->dreg;
      D.23523 = (long unsigned int) D.23517;
      D.23524 = D.23523 * 8;
      D.23525 = D.23522 + D.23524;
      D.23526 = *D.23525;
      if (D.23526 != 0B) goto <D.23527>; else goto <D.23528>;
      <D.23527>:
      {
        struct MonoInst * var;
        int idx;
        struct MonoMethodVar * vi;

        D.23517 = ins->dreg;
        D.23518 = (unsigned int) D.23517;
        D.23519 = cfg->vreg_to_inst_len;
        if (D.23518 < D.23519) goto <D.23530>; else goto <D.23531>;
        <D.23530>:
        D.23522 = cfg->vreg_to_inst;
        D.23517 = ins->dreg;
        D.23523 = (long unsigned int) D.23517;
        D.23524 = D.23523 * 8;
        D.23525 = D.23522 + D.23524;
        iftmp.32 = *D.23525;
        goto <D.23532>;
        <D.23531>:
        iftmp.32 = 0B;
        <D.23532>:
        var = iftmp.32;
        D.23533 = var->data.op[0].const_val;
        idx = (int) D.23533;
        D.23534 = cfg->vars;
        D.23535 = (long unsigned int) idx;
        D.23536 = D.23535 * 80;
        vi = D.23534 + D.23536;
        D.23505 = ins->opcode;
        D.23537 = D.23505 + 65162;
        if (D.23537 <= 16) goto <D.23538>; else goto <D.23539>;
        <D.23538>:
        D.23535 = (long unsigned int) idx;
        D.23540 = D.23535 * 4;
        D.23541 = last_use + D.23540;
        D.23542 = *D.23541;
        if (D.23542 == 0) goto <D.23543>; else goto <D.23544>;
        <D.23543>:
        D.23509 = cfg->verbose_level;
        if (D.23509 > 1) goto <D.23545>; else goto <D.23546>;
        <D.23545>:
        D.23517 = ins->dreg;
        printf ("\tlast use of R%d set to %x\n", D.23517, inst_num);
        <D.23546>:
        D.23535 = (long unsigned int) idx;
        D.23540 = D.23535 * 4;
        D.23541 = last_use + D.23540;
        *D.23541 = inst_num;
        <D.23544>:
        goto <D.23547>;
        <D.23539>:
        D.23535 = (long unsigned int) idx;
        D.23540 = D.23535 * 4;
        D.23541 = last_use + D.23540;
        D.23542 = *D.23541;
        if (D.23542 > 0) goto <D.23548>; else goto <D.23549>;
        <D.23548>:
        D.23509 = cfg->verbose_level;
        if (D.23509 > 1) goto <D.23550>; else goto <D.23551>;
        <D.23550>:
        D.23535 = (long unsigned int) idx;
        D.23540 = D.23535 * 4;
        D.23541 = last_use + D.23540;
        D.23542 = *D.23541;
        D.23517 = ins->dreg;
        printf ("\tadd range to R%d: [%x, %x)\n", D.23517, inst_num, D.23542);
        <D.23551>:
        D.23535 = (long unsigned int) idx;
        D.23540 = D.23535 * 4;
        D.23541 = last_use + D.23540;
        D.23542 = *D.23541;
        D.23552 = vi->interval;
        mono_linterval_add_range (cfg, D.23552, inst_num, D.23542);
        D.23535 = (long unsigned int) idx;
        D.23540 = D.23535 * 4;
        D.23541 = last_use + D.23540;
        *D.23541 = 0;
        goto <D.23553>;
        <D.23549>:
        D.23554 = cfg->ret;
        if (D.23554 != var) goto <D.23555>; else goto <D.23556>;
        <D.23555>:
        D.23557 = var->flags;
        D.23558 = (int) D.23557;
        D.23559 = D.23558 & 20;
        if (D.23559 == 0) goto <D.23560>; else goto <D.23561>;
        <D.23560>:
        D.23562 = ins->opcode;
        D.23563 = D.23562 + 65174;
        D.23564 = D.23563 <= 1;
        D.23565 = D.23562 == 365;
        D.23566 = D.23564 | D.23565;
        if (D.23566 != 0) goto <D.23567>; else goto <D.23568>;
        <D.23567>:
        D.23557 = var->flags;
        D.23558 = (int) D.23557;
        D.23569 = D.23558 & 4;
        if (D.23569 == 0) goto <D.23570>; else goto <D.23571>;
        <D.23570>:
        D.23509 = cfg->verbose_level;
        if (D.23509 > 1) goto <D.23572>; else goto <D.23573>;
        <D.23572>:
        D.23517 = ins->dreg;
        printf ("\tdead def of R%d, eliminated\n", D.23517);
        <D.23573>:
        ins->opcode = 316;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.23574 = ins->sreg3;
        ins->sreg2 = D.23574;
        D.23575 = ins->sreg2;
        ins->sreg1 = D.23575;
        return;
        <D.23571>:
        <D.23568>:
        <D.23561>:
        <D.23556>:
        D.23509 = cfg->verbose_level;
        if (D.23509 > 1) goto <D.23576>; else goto <D.23577>;
        <D.23576>:
        D.23578 = inst_num + 1;
        D.23517 = ins->dreg;
        D.23517 = ins->dreg;
        printf ("\tdead def of R%d, add range to R%d: [%x, %x]\n", D.23517, D.23517, inst_num, D.23578);
        <D.23577>:
        D.23578 = inst_num + 1;
        D.23552 = vi->interval;
        mono_linterval_add_range (cfg, D.23552, inst_num, D.23578);
        <D.23553>:
        <D.23547>:
      }
      <D.23528>:
      <D.23521>:
      <D.23516>:
      D.23579 = ins->sreg1;
      sregs[0] = D.23579;
      D.23575 = ins->sreg2;
      sregs[1] = D.23575;
      D.23574 = ins->sreg3;
      sregs[2] = D.23574;
      D.23505 = ins->opcode;
      D.23506 = (int) D.23505;
      D.23507 = D.23506 + -313;
      D.23580 = ins_sreg_counts[D.23507];
      num_sregs = (int) D.23580;
      i = 0;
      goto <D.22546>;
      <D.22545>:
      sreg = sregs[i];
      D.23581 = i + 1;
      D.23582 = (sizetype) D.23581;
      D.23583 = spec + D.23582;
      D.23584 = *D.23583;
      if (D.23584 != 32) goto <D.23585>; else goto <D.23586>;
      <D.23585>:
      sreg.33 = (unsigned int) sreg;
      D.23519 = cfg->vreg_to_inst_len;
      if (sreg.33 < D.23519) goto <D.23588>; else goto <D.23589>;
      <D.23588>:
      D.23522 = cfg->vreg_to_inst;
      D.23590 = (long unsigned int) sreg;
      D.23591 = D.23590 * 8;
      D.23592 = D.23522 + D.23591;
      D.23593 = *D.23592;
      if (D.23593 != 0B) goto <D.23594>; else goto <D.23595>;
      <D.23594>:
      {
        struct MonoInst * var;
        int idx;

        sreg.33 = (unsigned int) sreg;
        D.23519 = cfg->vreg_to_inst_len;
        if (sreg.33 < D.23519) goto <D.23597>; else goto <D.23598>;
        <D.23597>:
        D.23522 = cfg->vreg_to_inst;
        D.23590 = (long unsigned int) sreg;
        D.23591 = D.23590 * 8;
        D.23592 = D.23522 + D.23591;
        iftmp.34 = *D.23592;
        goto <D.23599>;
        <D.23598>:
        iftmp.34 = 0B;
        <D.23599>:
        var = iftmp.34;
        D.23600 = var->data.op[0].const_val;
        idx = (int) D.23600;
        D.23601 = (long unsigned int) idx;
        D.23602 = D.23601 * 4;
        D.23603 = last_use + D.23602;
        D.23604 = *D.23603;
        if (D.23604 == 0) goto <D.23605>; else goto <D.23606>;
        <D.23605>:
        D.23509 = cfg->verbose_level;
        if (D.23509 > 1) goto <D.23607>; else goto <D.23608>;
        <D.23607>:
        printf ("\tlast use of R%d set to %x\n", sreg, inst_num);
        <D.23608>:
        D.23601 = (long unsigned int) idx;
        D.23602 = D.23601 * 4;
        D.23603 = last_use + D.23602;
        *D.23603 = inst_num;
        <D.23606>:
      }
      <D.23595>:
      <D.23589>:
      <D.23586>:
      i = i + 1;
      <D.22546>:
      if (i < num_sregs) goto <D.22545>; else goto <D.22547>;
      <D.22547>:
    }
  finally
    {
      sregs = {CLOBBER};
    }
}


mono_linterval_add_range (struct MonoCompile * cfg, struct MonoLiveInterval * interval, int from, int to)
{
  _Bool D.23612;
  long int D.23613;
  long int D.23614;
  int iftmp.35;
  struct MonoLiveRange2 * D.23620;
  int D.23622;
  _Bool D.23625;
  long int D.23626;
  long int D.23627;
  int D.23631;
  int D.23635;
  struct MonoMemPool * D.23641;
  struct MonoLiveRange2 * prev_range;
  struct MonoLiveRange2 * next_range;
  struct MonoLiveRange2 * new_range;

  D.23612 = to < from;
  D.23613 = (long int) D.23612;
  D.23614 = __builtin_expect (D.23613, 0);
  if (D.23614 != 0) goto <D.23615>; else goto <D.23616>;
  <D.23615>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "liveness.c", 637, "to >= from");
  <D.23616>:
  D.23620 = interval->range;
  if (D.23620 != 0B) goto <D.23621>; else goto <D.23618>;
  <D.23621>:
  D.23620 = interval->range;
  D.23622 = D.23620->from;
  if (D.23622 > from) goto <D.23623>; else goto <D.23618>;
  <D.23623>:
  D.23620 = interval->range;
  D.23622 = D.23620->from;
  if (D.23622 == to) goto <D.23624>; else goto <D.23618>;
  <D.23624>:
  iftmp.35 = 1;
  goto <D.23619>;
  <D.23618>:
  iftmp.35 = 0;
  <D.23619>:
  D.23625 = iftmp.35 != 0;
  D.23626 = (long int) D.23625;
  D.23627 = __builtin_expect (D.23626, 1);
  if (D.23627 != 0) goto <D.23628>; else goto <D.23629>;
  <D.23628>:
  D.23620 = interval->range;
  D.23620->from = from;
  return;
  <D.23629>:
  prev_range = 0B;
  next_range = interval->range;
  goto <D.22485>;
  <D.22484>:
  prev_range = next_range;
  next_range = next_range->next;
  <D.22485>:
  if (next_range != 0B) goto <D.23630>; else goto <D.22486>;
  <D.23630>:
  D.23631 = next_range->from;
  if (D.23631 <= from) goto <D.22484>; else goto <D.22486>;
  <D.22486>:
  if (prev_range != 0B) goto <D.23634>; else goto <D.23632>;
  <D.23634>:
  D.23635 = prev_range->to;
  if (D.23635 == from) goto <D.23636>; else goto <D.23632>;
  <D.23636>:
  prev_range->to = to;
  goto <D.23633>;
  <D.23632>:
  if (next_range != 0B) goto <D.23639>; else goto <D.23637>;
  <D.23639>:
  D.23631 = next_range->from;
  if (D.23631 == to) goto <D.23640>; else goto <D.23637>;
  <D.23640>:
  next_range->from = from;
  goto <D.23638>;
  <D.23637>:
  D.23641 = cfg->mempool;
  new_range = mono_mempool_alloc (D.23641, 16);
  new_range->from = from;
  new_range->to = to;
  new_range->next = 0B;
  if (prev_range != 0B) goto <D.23642>; else goto <D.23643>;
  <D.23642>:
  prev_range->next = new_range;
  goto <D.23644>;
  <D.23643>:
  interval->range = new_range;
  <D.23644>:
  if (next_range != 0B) goto <D.23645>; else goto <D.23646>;
  <D.23645>:
  new_range->next = next_range;
  goto <D.23647>;
  <D.23646>:
  interval->last_range = new_range;
  <D.23647>:
  <D.23638>:
  <D.23633>:
}


mono_linterval_print (struct MonoLiveInterval * interval)
{
  int D.23649;
  int D.23650;
  struct MonoLiveRange2 * range;

  range = interval->range;
  goto <D.22492>;
  <D.22491>:
  D.23649 = range->to;
  D.23650 = range->from;
  printf ("[%x-%x] ", D.23650, D.23649);
  range = range->next;
  <D.22492>:
  if (range != 0B) goto <D.22491>; else goto <D.22493>;
  <D.22493>:
}


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


mono_linterval_covers (struct MonoLiveInterval * interval, int pos)
{
  int D.23651;
  int D.23654;
  gboolean D.23657;
  struct MonoLiveRange2 * range;

  range = interval->range;
  goto <D.22503>;
  <D.22502>:
  D.23651 = range->from;
  if (D.23651 <= pos) goto <D.23652>; else goto <D.23653>;
  <D.23652>:
  D.23654 = range->to;
  if (D.23654 >= pos) goto <D.23655>; else goto <D.23656>;
  <D.23655>:
  D.23657 = 1;
  return D.23657;
  <D.23656>:
  <D.23653>:
  D.23651 = range->from;
  if (D.23651 > pos) goto <D.23658>; else goto <D.23659>;
  <D.23658>:
  D.23657 = 0;
  return D.23657;
  <D.23659>:
  range = range->next;
  <D.22503>:
  if (range != 0B) goto <D.22502>; else goto <D.22504>;
  <D.22504>:
  D.23657 = 0;
  return D.23657;
}


mono_linterval_get_intersect_pos (struct MonoLiveInterval * i1, struct MonoLiveInterval * i2)
{
  int D.23661;
  int D.23662;
  int D.23665;
  int D.23666;
  gint32 D.23671;
  struct MonoLiveRange2 * r1;
  struct MonoLiveRange2 * r2;

  r1 = i1->range;
  goto <D.22515>;
  <D.22514>:
  r2 = i2->range;
  goto <D.22512>;
  <D.22511>:
  D.23661 = r2->to;
  D.23662 = r1->from;
  if (D.23661 > D.23662) goto <D.23663>; else goto <D.23664>;
  <D.23663>:
  D.23665 = r2->from;
  D.23666 = r1->to;
  if (D.23665 < D.23666) goto <D.23667>; else goto <D.23668>;
  <D.23667>:
  D.23665 = r2->from;
  D.23662 = r1->from;
  if (D.23665 <= D.23662) goto <D.23669>; else goto <D.23670>;
  <D.23669>:
  D.23671 = r1->from;
  return D.23671;
  <D.23670>:
  D.23671 = r2->from;
  return D.23671;
  <D.23668>:
  <D.23664>:
  r2 = r2->next;
  <D.22512>:
  if (r2 != 0B) goto <D.22511>; else goto <D.22513>;
  <D.22513>:
  r1 = r1->next;
  <D.22515>:
  if (r1 != 0B) goto <D.22514>; else goto <D.22516>;
  <D.22516>:
  D.23671 = -1;
  return D.23671;
}


mono_linterval_split (struct MonoCompile * cfg, struct MonoLiveInterval * interval, struct MonoLiveInterval * * i1, struct MonoLiveInterval * * i2, int pos)
{
  int iftmp.36;
  struct MonoLiveRange2 * D.23677;
  int D.23678;
  struct MonoLiveRange2 * D.23680;
  int D.23681;
  _Bool D.23682;
  long int D.23683;
  long int D.23684;
  struct MonoMemPool * D.23687;
  void * D.23688;
  void * D.23689;
  int D.23690;
  int D.23693;
  struct MonoLiveInterval * D.23694;
  int D.23700;
  struct MonoLiveInterval * D.23701;
  struct MonoLiveRange2 * r;

  D.23677 = interval->range;
  D.23678 = D.23677->from;
  if (D.23678 >= pos) goto <D.23674>; else goto <D.23679>;
  <D.23679>:
  D.23680 = interval->last_range;
  D.23681 = D.23680->to;
  if (D.23681 < pos) goto <D.23674>; else goto <D.23675>;
  <D.23674>:
  iftmp.36 = 1;
  goto <D.23676>;
  <D.23675>:
  iftmp.36 = 0;
  <D.23676>:
  D.23682 = iftmp.36 != 0;
  D.23683 = (long int) D.23682;
  D.23684 = __builtin_expect (D.23683, 0);
  if (D.23684 != 0) goto <D.23685>; else goto <D.23686>;
  <D.23685>:
  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.23686>:
  D.23687 = cfg->mempool;
  D.23688 = mono_mempool_alloc0 (D.23687, 16);
  *i1 = D.23688;
  D.23687 = cfg->mempool;
  D.23689 = mono_mempool_alloc0 (D.23687, 16);
  *i2 = D.23689;
  r = interval->range;
  goto <D.22526>;
  <D.22525>:
  D.23690 = r->to;
  if (D.23690 < pos) goto <D.23691>; else goto <D.23692>;
  <D.23691>:
  D.23690 = r->to;
  D.23693 = r->from;
  D.23694 = *i1;
  mono_linterval_add_range (cfg, D.23694, D.23693, D.23690);
  goto <D.23695>;
  <D.23692>:
  D.23693 = r->from;
  if (D.23693 < pos) goto <D.23698>; else goto <D.23696>;
  <D.23698>:
  D.23690 = r->to;
  if (D.23690 >= pos) goto <D.23699>; else goto <D.23696>;
  <D.23699>:
  D.23700 = pos + -1;
  D.23693 = r->from;
  D.23694 = *i1;
  mono_linterval_add_range (cfg, D.23694, D.23693, D.23700);
  D.23690 = r->to;
  D.23701 = *i2;
  mono_linterval_add_range (cfg, D.23701, pos, D.23690);
  goto <D.23697>;
  <D.23696>:
  D.23690 = r->to;
  D.23693 = r->from;
  D.23701 = *i2;
  mono_linterval_add_range (cfg, D.23701, D.23693, D.23690);
  <D.23697>:
  <D.23695>:
  r = r->next;
  <D.22526>:
  if (r != 0B) goto <D.22525>; else goto <D.22527>;
  <D.22527>:
}


mono_analyze_liveness_gc (struct MonoCompile * cfg)
{
  unsigned int D.23702;
  unsigned int D.23705;
  long unsigned int D.23706;
  long unsigned int D.23707;
  unsigned int D.23708;
  long unsigned int D.23709;
  long unsigned int D.23710;
  struct MonoMethodVar * D.23711;
  long unsigned int D.23712;
  long unsigned int D.23713;
  int D.23714;
  long unsigned int D.23715;
  long unsigned int D.23716;
  struct MonoMethodVar * * D.23717;
  long unsigned int D.23718;
  unsigned int D.23719;
  unsigned int D.23720;
  struct MonoMemPool * D.23721;
  int D.23722;
  int D.23723;
  int D.23726;
  struct MonoInst * D.23727;
  long unsigned int D.23730;
  long unsigned int D.23731;
  struct MonoBitSet * D.23732;
  unsigned int j.37;
  unsigned int D.23736;
  long unsigned int D.23737;
  struct MonoInst * * D.23740;
  long unsigned int D.23741;
  long unsigned int D.23742;
  struct MonoInst * * D.23743;
  struct MonoInst * D.23744;
  unsigned char D.23745;
  signed char D.23746;
  long unsigned int D.23751;
  gint32 * D.23752;
  long unsigned int D.23755;
  unsigned int D.23756;
  unsigned int D.23757;
  long unsigned int D.23758;
  long unsigned int D.23759;
  long unsigned int D.23760;
  struct MonoInst * * D.23761;
  long unsigned int D.23762;
  long unsigned int D.23763;
  struct MonoInst * * D.23764;
  struct GSList * callsites.38;
  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.23702 = cfg->verbose_level;
      if (D.23702 > 1) goto <D.23703>; else goto <D.23704>;
      <D.23703>:
      printf ("\n------------ GC LIVENESS: ----------\n");
      <D.23704>:
      D.23705 = cfg->num_varinfo;
      max_vars = (int) D.23705;
      D.23706 = (long unsigned int) max_vars;
      D.23707 = D.23706 * 4;
      last_use = monoeg_malloc0 (D.23707);
      D.23708 = cfg->next_vreg;
      D.23709 = (long unsigned int) D.23708;
      D.23710 = D.23709 * 8;
      vreg_to_varinfo = monoeg_malloc0 (D.23710);
      idx = 0;
      goto <D.22641>;
      <D.22640>:
      {
        struct MonoMethodVar * vi;

        D.23711 = cfg->vars;
        D.23712 = (long unsigned int) idx;
        D.23713 = D.23712 * 80;
        vi = D.23711 + D.23713;
        D.23714 = vi->vreg;
        D.23715 = (long unsigned int) D.23714;
        D.23716 = D.23715 * 8;
        D.23717 = vreg_to_varinfo + D.23716;
        *D.23717 = vi;
      }
      idx = idx + 1;
      <D.22641>:
      if (idx < max_vars) goto <D.22640>; else goto <D.22642>;
      <D.22642>:
      reverse_len = 1024;
      D.23718 = (long unsigned int) reverse_len;
      D.23719 = (unsigned int) D.23718;
      D.23720 = D.23719 * 8;
      D.23721 = cfg->mempool;
      reverse = mono_mempool_alloc (D.23721, D.23720);
      bb = cfg->bb_entry;
      goto <D.22665>;
      <D.22664>:
      {
        struct MonoInst * ins;

        block_from = bb->real_native_offset;
        D.23722 = bb->native_offset;
        D.23723 = bb->native_length;
        block_to = D.23722 + D.23723;
        D.23702 = cfg->verbose_level;
        if (D.23702 > 1) goto <D.23724>; else goto <D.23725>;
        <D.23724>:
        D.23726 = bb->block_num;
        printf ("GC LIVENESS BB%d:\n", D.23726);
        <D.23725>:
        D.23727 = bb->code;
        if (D.23727 == 0B) goto <D.23728>; else goto <D.23729>;
        <D.23728>:
        // predicted unlikely by continue predictor.
        goto <D.22644>;
        <D.23729>:
        D.23706 = (long unsigned int) max_vars;
        D.23707 = D.23706 * 4;
        memset (last_use, 0, D.23707);
        D.23706 = (long unsigned int) max_vars;
        D.23730 = D.23706 + 63;
        D.23731 = D.23730 / 64;
        max = (int) D.23731;
        j = 0;
        goto <D.22653>;
        <D.22652>:
        {
          gsize bits_out;
          int k;

          D.23732 = bb->live_out_set;
          if (D.23732 == 0B) goto <D.23733>; else goto <D.23734>;
          <D.23733>:
          // predicted unlikely by continue predictor.
          goto <D.22647>;
          <D.23734>:
          D.23732 = bb->live_out_set;
          bits_out = D.23732->data[j];
          j.37 = (unsigned int) j;
          D.23736 = j.37 * 64;
          k = (int) D.23736;
          goto <D.22650>;
          <D.22649>:
          D.23737 = bits_out & 1;
          if (D.23737 != 0) goto <D.23738>; else goto <D.23739>;
          <D.23738>:
          D.23740 = cfg->varinfo;
          D.23741 = (long unsigned int) k;
          D.23742 = D.23741 * 8;
          D.23743 = D.23740 + D.23742;
          D.23744 = *D.23743;
          D.23745 = D.23744->flags;
          D.23746 = (signed char) D.23745;
          if (D.23746 < 0) goto <D.23747>; else goto <D.23748>;
          <D.23747>:
          {
            int vreg;

            D.23740 = cfg->varinfo;
            D.23741 = (long unsigned int) k;
            D.23742 = D.23741 * 8;
            D.23743 = D.23740 + D.23742;
            D.23744 = *D.23743;
            vreg = get_vreg_from_var (cfg, D.23744);
            D.23702 = cfg->verbose_level;
            if (D.23702 > 1) goto <D.23749>; else goto <D.23750>;
            <D.23749>:
            printf ("Var R%d live at exit, last_use set to %x.\n", vreg, block_to);
            <D.23750>:
            D.23741 = (long unsigned int) k;
            D.23751 = D.23741 * 4;
            D.23752 = last_use + D.23751;
            *D.23752 = block_to;
          }
          <D.23748>:
          <D.23739>:
          bits_out = bits_out >> 1;
          k = k + 1;
          <D.22650>:
          if (bits_out != 0) goto <D.22649>; else goto <D.22651>;
          <D.22651>:
        }
        <D.22647>:
        j = j + 1;
        <D.22653>:
        if (j < max) goto <D.22652>; else goto <D.22654>;
        <D.22654>:
        nins = 0;
        pos = block_from;
        ins = bb->code;
        goto <D.22658>;
        <D.22657>:
        if (nins >= reverse_len) goto <D.23753>; else goto <D.23754>;
        <D.23753>:
        {
          int new_reverse_len;
          struct MonoInst * * new_reverse;

          new_reverse_len = reverse_len * 2;
          D.23755 = (long unsigned int) new_reverse_len;
          D.23756 = (unsigned int) D.23755;
          D.23757 = D.23756 * 8;
          D.23721 = cfg->mempool;
          new_reverse = mono_mempool_alloc (D.23721, D.23757);
          D.23718 = (long unsigned int) reverse_len;
          D.23758 = D.23718 * 8;
          memcpy (new_reverse, reverse, D.23758);
          reverse = new_reverse;
          reverse_len = new_reverse_len;
        }
        <D.23754>:
        D.23759 = (long unsigned int) nins;
        D.23760 = D.23759 * 8;
        D.23761 = reverse + D.23760;
        *D.23761 = ins;
        ins = ins->next;
        nins = nins + 1;
        pos = pos + 1;
        <D.22658>:
        if (ins != 0B) goto <D.22657>; else goto <D.22659>;
        <D.22659>:
        callsites = 0B;
        i = nins + -1;
        goto <D.22662>;
        <D.22661>:
        {
          struct MonoInst * ins;

          D.23762 = (long unsigned int) i;
          D.23763 = D.23762 * 8;
          D.23764 = reverse + D.23763;
          ins = *D.23764;
          update_liveness_gc (cfg, bb, ins, last_use, vreg_to_varinfo, &callsites);
        }
        i = i + -1;
        <D.22662>:
        if (i >= 0) goto <D.22661>; else goto <D.22663>;
        <D.22663>:
        callsites.38 = callsites;
        bb->gc_callsites = callsites.38;
      }
      <D.22644>:
      bb = bb->next_bb;
      <D.22665>:
      if (bb != 0B) goto <D.22664>; else goto <D.22666>;
      <D.22666>:
      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.23766;
  int D.23769;
  struct MonoMethodVar * D.23770;
  long int D.23771;
  long unsigned int D.23772;
  long unsigned int D.23773;
  struct MonoMethodVar * D.23774;

  D.23766 = var->opcode;
  if (D.23766 == 366) goto <D.23767>; else goto <D.23768>;
  <D.23767>:
  D.23770 = cfg->vars;
  D.23771 = var->data.op[0].const_val;
  D.23772 = (long unsigned int) D.23771;
  D.23773 = D.23772 * 80;
  D.23774 = D.23770 + D.23773;
  D.23769 = D.23774->vreg;
  return D.23769;
  <D.23768>:
  D.23769 = var->dreg;
  return D.23769;
}


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.23776;
  short unsigned int D.23777;
  long int D.23780;
  long unsigned int D.23781;
  long unsigned int D.23782;
  struct MonoMethodVar * * D.23783;
  unsigned int D.23784;
  unsigned int D.23785;
  long unsigned int D.23790;
  long unsigned int D.23791;
  gint32 * D.23792;
  int D.23793;
  struct GSList * D.23806;
  _Bool D.23807;
  long int D.23808;
  long int D.23809;
  struct GSList * D.23812;
  struct MonoMemPool * D.23813;
  struct GSList * D.23814;
  unsigned char D.23816;
  signed char D.23817;
  int D.23822;
  unsigned int D.23825;
  long unsigned int D.23826;
  long unsigned int D.23827;
  long unsigned int D.23828;
  long unsigned int D.23829;
  unsigned int D.23830;
  void * D.23831;
  long unsigned int D.23832;
  long unsigned int D.23833;
  gint32 * D.23834;
  int D.23835;
  struct MonoMethodVar * D.23840;
  long unsigned int D.23841;
  struct MonoMethodVar * D.23842;
  int D.23843;
  guint8 * D.23844;
  int D.23845;
  sizetype D.23846;
  guint8 * D.23847;
  unsigned char D.23848;
  signed char D.23849;
  int D.23850;
  int D.23851;
  signed char D.23852;
  signed char D.23853;
  unsigned char D.23854;
  unsigned int i.39;
  struct GSList * D.23858;

  D.23776 = ins->opcode;
  D.23777 = D.23776 + 64536;
  if (D.23777 <= 1) goto <D.23778>; else goto <D.23779>;
  <D.23778>:
  {
    int vreg;
    struct MonoMethodVar * vi;
    int idx;
    int pc_offset;

    D.23780 = ins->data.op[1].const_val;
    vreg = (int) D.23780;
    D.23781 = (long unsigned int) vreg;
    D.23782 = D.23781 * 8;
    D.23783 = vreg_to_varinfo + D.23782;
    vi = *D.23783;
    D.23784 = vi->idx;
    idx = (int) D.23784;
    pc_offset = ins->backend.pc_offset;
    D.23785 = cfg->verbose_level;
    if (D.23785 > 1) goto <D.23786>; else goto <D.23787>;
    <D.23786>:
    printf ("\t%x: ", pc_offset);
    mono_print_ins (ins);
    <D.23787>:
    D.23776 = ins->opcode;
    if (D.23776 == 1000) goto <D.23788>; else goto <D.23789>;
    <D.23788>:
    D.23790 = (long unsigned int) idx;
    D.23791 = D.23790 * 4;
    D.23792 = last_use + D.23791;
    D.23793 = *D.23792;
    if (D.23793 > 0) goto <D.23794>; else goto <D.23795>;
    <D.23794>:
    D.23785 = cfg->verbose_level;
    if (D.23785 > 1) goto <D.23796>; else goto <D.23797>;
    <D.23796>:
    D.23790 = (long unsigned int) idx;
    D.23791 = D.23790 * 4;
    D.23792 = last_use + D.23791;
    D.23793 = *D.23792;
    printf ("\tadd range to R%d: [%x, %x)\n", vreg, pc_offset, D.23793);
    <D.23797>:
    D.23790 = (long unsigned int) idx;
    D.23791 = D.23790 * 4;
    D.23792 = last_use + D.23791;
    *D.23792 = 0;
    <D.23795>:
    goto <D.23798>;
    <D.23789>:
    D.23790 = (long unsigned int) idx;
    D.23791 = D.23790 * 4;
    D.23792 = last_use + D.23791;
    D.23793 = *D.23792;
    if (D.23793 == 0) goto <D.23799>; else goto <D.23800>;
    <D.23799>:
    D.23785 = cfg->verbose_level;
    if (D.23785 > 1) goto <D.23801>; else goto <D.23802>;
    <D.23801>:
    printf ("\tlast use of R%d set to %x\n", vreg, pc_offset);
    <D.23802>:
    D.23790 = (long unsigned int) idx;
    D.23791 = D.23790 * 4;
    D.23792 = last_use + D.23791;
    *D.23792 = pc_offset;
    <D.23800>:
    <D.23798>:
  }
  goto <D.23803>;
  <D.23779>:
  D.23776 = ins->opcode;
  if (D.23776 == 1003) goto <D.23804>; else goto <D.23805>;
  <D.23804>:
  {
    struct GCCallSite * last;

    D.23806 = *callsites;
    D.23807 = D.23806 == 0B;
    D.23808 = (long int) D.23807;
    D.23809 = __builtin_expect (D.23808, 0);
    if (D.23809 != 0) goto <D.23810>; else goto <D.23811>;
    <D.23810>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "liveness.c", 1003, "*callsites");
    <D.23811>:
    D.23806 = *callsites;
    last = D.23806->data;
    D.23812 = last->param_slots;
    D.23813 = cfg->mempool;
    D.23814 = g_slist_prepend_mempool (D.23813, D.23812, ins);
    last->param_slots = D.23814;
  }
  goto <D.23815>;
  <D.23805>:
  D.23816 = ins->flags;
  D.23817 = (signed char) D.23816;
  if (D.23817 < 0) goto <D.23818>; else goto <D.23819>;
  <D.23818>:
  {
    struct GCCallSite * callsite;
    int i;

    D.23813 = cfg->mempool;
    callsite = mono_mempool_alloc0 (D.23813, 32);
    D.23785 = cfg->verbose_level;
    if (D.23785 > 1) goto <D.23820>; else goto <D.23821>;
    <D.23820>:
    D.23822 = ins->backend.pc_offset;
    printf ("\t%x: ", D.23822);
    mono_print_ins (ins);
    <D.23821>:
    D.23785 = cfg->verbose_level;
    if (D.23785 > 1) goto <D.23823>; else goto <D.23824>;
    <D.23823>:
    printf ("\t\tlive: ");
    <D.23824>:
    callsite->bb = bb;
    D.23825 = cfg->num_varinfo;
    D.23826 = (long unsigned int) D.23825;
    D.23827 = D.23826 + 7;
    D.23828 = D.23827 & 18446744073709551608;
    D.23829 = D.23828 / 8;
    D.23830 = (unsigned int) D.23829;
    D.23813 = cfg->mempool;
    D.23831 = mono_mempool_alloc0 (D.23813, D.23830);
    callsite->liveness = D.23831;
    D.23822 = ins->backend.pc_offset;
    callsite->pc_offset = D.23822;
    i = 0;
    goto <D.22615>;
    <D.22614>:
    D.23832 = (long unsigned int) i;
    D.23833 = D.23832 * 4;
    D.23834 = last_use + D.23833;
    D.23835 = *D.23834;
    if (D.23835 != 0) goto <D.23836>; else goto <D.23837>;
    <D.23836>:
    D.23785 = cfg->verbose_level;
    if (D.23785 > 1) goto <D.23838>; else goto <D.23839>;
    <D.23838>:
    D.23840 = cfg->vars;
    D.23832 = (long unsigned int) i;
    D.23841 = D.23832 * 80;
    D.23842 = D.23840 + D.23841;
    D.23843 = D.23842->vreg;
    printf ("R%d", D.23843);
    <D.23839>:
    D.23844 = callsite->liveness;
    D.23845 = i / 8;
    D.23846 = (sizetype) D.23845;
    D.23847 = D.23844 + D.23846;
    D.23844 = callsite->liveness;
    D.23846 = (sizetype) D.23845;
    D.23847 = D.23844 + D.23846;
    D.23848 = *D.23847;
    D.23849 = (signed char) D.23848;
    D.23850 = i % 8;
    D.23851 = 1 << D.23850;
    D.23852 = (signed char) D.23851;
    D.23853 = D.23849 | D.23852;
    D.23854 = (unsigned char) D.23853;
    *D.23847 = D.23854;
    <D.23837>:
    i = i + 1;
    <D.22615>:
    i.39 = (unsigned int) i;
    D.23825 = cfg->num_varinfo;
    if (i.39 < D.23825) goto <D.22614>; else goto <D.22616>;
    <D.22616>:
    D.23785 = cfg->verbose_level;
    if (D.23785 > 1) goto <D.23856>; else goto <D.23857>;
    <D.23856>:
    printf ("\n");
    <D.23857>:
    D.23806 = *callsites;
    D.23813 = cfg->mempool;
    D.23858 = g_slist_prepend_mempool (D.23813, D.23806, callsite);
    *callsites = D.23858;
  }
  <D.23819>:
  <D.23815>:
  <D.23803>:
}


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

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