mono_liveness_handle_exception_clauses (struct MonoCompile * cfg)
{
  struct MonoMemPool * D.22758;
  <unnamed-unsigned:15> D.22759;
  unsigned int D.22760;
  unsigned int D.22761;
  long unsigned int D.22762;
  long unsigned int D.22763;
  gboolean * D.22764;
  int D.22765;
  struct MonoExceptionClause * D.22766;
  long unsigned int D.22767;
  unsigned int D.22768;
  long unsigned int D.22771;
  long unsigned int D.22772;
  unsigned int D.22773;
  unsigned int D.22776;
  unsigned int D.22777;
  unsigned int D.22780;
  unsigned int D.22781;
  long unsigned int D.22784;
  gboolean * D.22785;
  unsigned int D.22786;
  unsigned int D.22788;
  unsigned int D.22791;
  unsigned int D.22794;
  unsigned int D.22795;
  long unsigned int D.22796;
  long unsigned int D.22797;
  gboolean * D.22798;
  int D.22799;
  unsigned int D.22802;
  int D.22805;
  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.22758 = cfg->mempool;
      D.22759 = header->num_clauses;
      D.22760 = (unsigned int) D.22759;
      D.22761 = D.22760 * 4;
      outer_try = mono_mempool_alloc0 (D.22758, D.22761);
      i = 0;
      goto <D.22372>;
      <D.22371>:
      D.22762 = (long unsigned int) i;
      D.22763 = D.22762 * 4;
      D.22764 = outer_try + D.22763;
      *D.22764 = 1;
      i = i + 1;
      <D.22372>:
      D.22759 = header->num_clauses;
      D.22765 = (int) D.22759;
      if (D.22765 > i) goto <D.22371>; else goto <D.22373>;
      <D.22373>:
      D.22759 = header->num_clauses;
      D.22765 = (int) D.22759;
      i = D.22765 + -1;
      goto <D.22378>;
      <D.22377>:
      D.22766 = header->clauses;
      D.22762 = (long unsigned int) i;
      D.22767 = D.22762 * 32;
      clause = D.22766 + D.22767;
      D.22768 = clause->flags;
      if (D.22768 != 0) goto <D.22769>; else goto <D.22770>;
      <D.22769>:
      D.22762 = (long unsigned int) i;
      D.22763 = D.22762 * 4;
      D.22764 = outer_try + D.22763;
      *D.22764 = 1;
      j = i + -1;
      goto <D.22376>;
      <D.22375>:
      D.22766 = header->clauses;
      D.22771 = (long unsigned int) j;
      D.22772 = D.22771 * 32;
      clause2 = D.22766 + D.22772;
      D.22773 = clause2->flags;
      if (D.22773 == 0) goto <D.22774>; else goto <D.22775>;
      <D.22774>:
      D.22776 = clause->handler_offset;
      D.22777 = clause2->try_offset;
      if (D.22776 <= D.22777) goto <D.22778>; else goto <D.22779>;
      <D.22778>:
      D.22777 = clause2->try_offset;
      D.22776 = clause->handler_offset;
      D.22780 = clause->handler_len;
      D.22781 = D.22776 + D.22780;
      if (D.22777 < D.22781) goto <D.22782>; else goto <D.22783>;
      <D.22782>:
      D.22771 = (long unsigned int) j;
      D.22784 = D.22771 * 4;
      D.22785 = outer_try + D.22784;
      *D.22785 = 0;
      goto <D.22374>;
      <D.22783>:
      <D.22779>:
      <D.22775>:
      D.22777 = clause2->try_offset;
      D.22786 = clause->try_offset;
      if (D.22777 < D.22786) goto <D.22374>; else goto <D.22787>;
      <D.22787>:
      j = j + -1;
      <D.22376>:
      if (j >= 0) goto <D.22375>; else goto <D.22374>;
      <D.22374>:
      <D.22770>:
      i = i + -1;
      <D.22378>:
      if (i >= 0) goto <D.22377>; else goto <D.22379>;
      <D.22379>:
      bb = cfg->bb_entry;
      goto <D.22382>;
      <D.22381>:
      D.22788 = bb->region;
      if (D.22788 == 4294967295) goto <D.22789>; else goto <D.22790>;
      <D.22789>:
      // predicted unlikely by continue predictor.
      goto <D.22380>;
      <D.22790>:
      D.22788 = bb->region;
      D.22791 = D.22788 & 240;
      if (D.22791 == 0) goto <D.22792>; else goto <D.22793>;
      <D.22792>:
      D.22788 = bb->region;
      D.22794 = D.22788 >> 8;
      D.22795 = D.22794 + 4294967295;
      D.22796 = (long unsigned int) D.22795;
      D.22797 = D.22796 * 4;
      D.22798 = outer_try + D.22797;
      D.22799 = *D.22798;
      if (D.22799 != 0) goto <D.22800>; else goto <D.22801>;
      <D.22800>:
      // predicted unlikely by continue predictor.
      goto <D.22380>;
      <D.22801>:
      <D.22793>:
      D.22802 = cfg->verbose_level;
      if (D.22802 > 2) goto <D.22803>; else goto <D.22804>;
      <D.22803>:
      D.22805 = bb->block_num;
      printf ("pessimize variables in bb %d.\n", D.22805);
      <D.22804>:
      visit_bb (cfg, bb, &visited);
      <D.22380>:
      bb = bb->next_bb;
      <D.22382>:
      if (bb != 0B) goto <D.22381>; else goto <D.22383>;
      <D.22383>:
      visited.0 = visited;
      monoeg_g_slist_free (visited.0);
    }
  finally
    {
      visited = {CLOBBER};
    }
}


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

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


visit_bb (struct MonoCompile * cfg, struct MonoBasicBlock * bb, struct GSList * * visited)
{
  struct GSList * D.22809;
  struct GSList * D.22810;
  short unsigned int D.22813;
  int D.22814;
  int D.22815;
  int D.22816;
  char D.22819;
  int iftmp.1;
  int D.22825;
  _Bool D.22828;
  long int D.22829;
  long int D.22830;
  unsigned int D.22835;
  unsigned int D.22836;
  struct MonoInst * * D.22839;
  long unsigned int D.22840;
  long unsigned int D.22841;
  struct MonoInst * * D.22842;
  struct MonoInst * D.22843;
  struct MonoInst * iftmp.2;
  long int D.22850;
  struct MonoMethodVar * D.22851;
  long unsigned int D.22852;
  long unsigned int D.22853;
  struct MonoInst * * D.22854;
  unsigned int D.22855;
  long unsigned int D.22856;
  long unsigned int D.22857;
  struct MonoInst * * D.22858;
  struct MonoInst * D.22859;
  unsigned char D.22860;
  unsigned char D.22861;
  struct MonoInst * iftmp.3;
  int D.22865;
  int D.22866;
  unsigned int D.22867;
  sizetype D.22870;
  sizetype D.22871;
  sizetype D.22872;
  struct MonoInst * * D.22873;
  struct MonoInst * iftmp.4;
  unsigned char D.22879;
  unsigned char D.22880;
  struct MonoInst * iftmp.5;
  int D.22882;
  unsigned int D.22883;
  sizetype D.22886;
  sizetype D.22887;
  struct MonoInst * * D.22888;
  struct MonoInst * iftmp.6;
  unsigned char D.22894;
  unsigned char D.22895;
  int D.22896;
  int D.22897;
  int D.22898;
  signed char D.22899;
  _Bool D.22900;
  long int D.22901;
  long int D.22902;
  unsigned int sreg.7;
  long unsigned int D.22908;
  long unsigned int D.22909;
  struct MonoInst * * D.22910;
  struct MonoInst * D.22911;
  struct MonoInst * iftmp.8;
  long int D.22918;
  long unsigned int D.22919;
  long unsigned int D.22920;
  unsigned int D.22921;
  long unsigned int D.22922;
  long unsigned int D.22923;
  struct MonoInst * * D.22924;
  struct MonoInst * D.22925;
  unsigned char D.22926;
  unsigned char D.22927;
  struct MonoInst * iftmp.9;
  int D.22931;
  int D.22932;
  unsigned int D.22933;
  sizetype D.22936;
  sizetype D.22937;
  sizetype D.22938;
  struct MonoInst * * D.22939;
  struct MonoInst * iftmp.10;
  unsigned char D.22945;
  unsigned char D.22946;
  struct MonoInst * iftmp.11;
  int D.22948;
  unsigned int D.22949;
  sizetype D.22952;
  sizetype D.22953;
  struct MonoInst * * D.22954;
  struct MonoInst * iftmp.12;
  unsigned char D.22960;
  unsigned char D.22961;
  struct GSList * D.22962;
  struct MonoBasicBlock * * D.22963;
  long unsigned int D.22964;
  long unsigned int D.22965;
  struct MonoBasicBlock * * D.22966;
  struct MonoBasicBlock * D.22967;
  short int D.22968;
  int D.22969;
  int i;
  struct MonoInst * ins;

  D.22809 = *visited;
  D.22810 = monoeg_g_slist_find (D.22809, bb);
  if (D.22810 != 0B) goto <D.22811>; else goto <D.22812>;
  <D.22811>:
  return;
  <D.22812>:
  ins = bb->code;
  goto <D.22355>;
  <D.22354>:
  {
    const char * spec;
    int regtype;
    int srcindex;
    int sreg;
    int num_sregs;
    int sregs[3];

    try
      {
        D.22813 = ins->opcode;
        D.22814 = (int) D.22813;
        D.22815 = D.22814 + -313;
        D.22816 = D.22815 * 4;
        spec = &ins_info[D.22816];
        D.22813 = ins->opcode;
        if (D.22813 == 316) goto <D.22817>; else goto <D.22818>;
        <D.22817>:
        // predicted unlikely by continue predictor.
        goto <D.22344>;
        <D.22818>:
        D.22819 = *spec;
        regtype = (int) D.22819;
        D.22825 = ins->dreg;
        if (D.22825 != -1) goto <D.22821>; else goto <D.22826>;
        <D.22826>:
        if (regtype != 32) goto <D.22821>; else goto <D.22822>;
        <D.22821>:
        D.22825 = ins->dreg;
        if (D.22825 == -1) goto <D.22823>; else goto <D.22827>;
        <D.22827>:
        if (regtype == 32) goto <D.22823>; else goto <D.22822>;
        <D.22823>:
        iftmp.1 = 1;
        goto <D.22824>;
        <D.22822>:
        iftmp.1 = 0;
        <D.22824>:
        D.22828 = iftmp.1 != 0;
        D.22829 = (long int) D.22828;
        D.22830 = __builtin_expect (D.22829, 0);
        if (D.22830 != 0) goto <D.22831>; else goto <D.22832>;
        <D.22831>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "liveness.c", 94, "((ins->dreg == -1) && (regtype == \' \')) || ((ins->dreg != -1) && (regtype != \' \'))");
        <D.22832>:
        D.22825 = ins->dreg;
        if (D.22825 != -1) goto <D.22833>; else goto <D.22834>;
        <D.22833>:
        D.22825 = ins->dreg;
        D.22835 = (unsigned int) D.22825;
        D.22836 = cfg->vreg_to_inst_len;
        if (D.22835 < D.22836) goto <D.22837>; else goto <D.22838>;
        <D.22837>:
        D.22839 = cfg->vreg_to_inst;
        D.22825 = ins->dreg;
        D.22840 = (long unsigned int) D.22825;
        D.22841 = D.22840 * 8;
        D.22842 = D.22839 + D.22841;
        D.22843 = *D.22842;
        if (D.22843 != 0B) goto <D.22844>; else goto <D.22845>;
        <D.22844>:
        {
          struct MonoInst * var;
          int idx;
          struct MonoMethodVar * vi;

          D.22825 = ins->dreg;
          D.22835 = (unsigned int) D.22825;
          D.22836 = cfg->vreg_to_inst_len;
          if (D.22835 < D.22836) goto <D.22847>; else goto <D.22848>;
          <D.22847>:
          D.22839 = cfg->vreg_to_inst;
          D.22825 = ins->dreg;
          D.22840 = (long unsigned int) D.22825;
          D.22841 = D.22840 * 8;
          D.22842 = D.22839 + D.22841;
          iftmp.2 = *D.22842;
          goto <D.22849>;
          <D.22848>:
          iftmp.2 = 0B;
          <D.22849>:
          var = iftmp.2;
          D.22850 = var->data.op[0].const_val;
          idx = (int) D.22850;
          D.22851 = cfg->vars;
          D.22852 = (long unsigned int) idx;
          D.22853 = D.22852 * 80;
          vi = D.22851 + D.22853;
          D.22854 = cfg->varinfo;
          D.22855 = vi->idx;
          D.22856 = (long unsigned int) D.22855;
          D.22857 = D.22856 * 8;
          D.22858 = D.22854 + D.22857;
          D.22859 = *D.22858;
          D.22854 = cfg->varinfo;
          D.22855 = vi->idx;
          D.22856 = (long unsigned int) D.22855;
          D.22857 = D.22856 * 8;
          D.22858 = D.22854 + D.22857;
          D.22859 = *D.22858;
          D.22860 = D.22859->flags;
          D.22861 = D.22860 | 4;
          D.22859->flags = D.22861;
          if (0 != 0) goto <D.22862>; else goto <D.22863>;
          <D.22862>:
          D.22865 = var->dreg;
          D.22866 = D.22865 + 1;
          D.22867 = (unsigned int) D.22866;
          D.22836 = cfg->vreg_to_inst_len;
          if (D.22867 < D.22836) goto <D.22868>; else goto <D.22869>;
          <D.22868>:
          D.22839 = cfg->vreg_to_inst;
          D.22865 = var->dreg;
          D.22870 = (sizetype) D.22865;
          D.22871 = D.22870 + 1;
          D.22872 = D.22871 * 8;
          D.22873 = D.22839 + D.22872;
          iftmp.3 = *D.22873;
          goto <D.22874>;
          <D.22869>:
          iftmp.3 = 0B;
          <D.22874>:
          D.22865 = var->dreg;
          D.22866 = D.22865 + 1;
          D.22867 = (unsigned int) D.22866;
          D.22836 = cfg->vreg_to_inst_len;
          if (D.22867 < D.22836) goto <D.22876>; else goto <D.22877>;
          <D.22876>:
          D.22839 = cfg->vreg_to_inst;
          D.22865 = var->dreg;
          D.22870 = (sizetype) D.22865;
          D.22871 = D.22870 + 1;
          D.22872 = D.22871 * 8;
          D.22873 = D.22839 + D.22872;
          iftmp.4 = *D.22873;
          goto <D.22878>;
          <D.22877>:
          iftmp.4 = 0B;
          <D.22878>:
          D.22879 = iftmp.4->flags;
          D.22880 = D.22879 | 4;
          iftmp.3->flags = D.22880;
          D.22865 = var->dreg;
          D.22882 = D.22865 + 2;
          D.22883 = (unsigned int) D.22882;
          D.22836 = cfg->vreg_to_inst_len;
          if (D.22883 < D.22836) goto <D.22884>; else goto <D.22885>;
          <D.22884>:
          D.22839 = cfg->vreg_to_inst;
          D.22865 = var->dreg;
          D.22870 = (sizetype) D.22865;
          D.22886 = D.22870 + 2;
          D.22887 = D.22886 * 8;
          D.22888 = D.22839 + D.22887;
          iftmp.5 = *D.22888;
          goto <D.22889>;
          <D.22885>:
          iftmp.5 = 0B;
          <D.22889>:
          D.22865 = var->dreg;
          D.22882 = D.22865 + 2;
          D.22883 = (unsigned int) D.22882;
          D.22836 = cfg->vreg_to_inst_len;
          if (D.22883 < D.22836) goto <D.22891>; else goto <D.22892>;
          <D.22891>:
          D.22839 = cfg->vreg_to_inst;
          D.22865 = var->dreg;
          D.22870 = (sizetype) D.22865;
          D.22886 = D.22870 + 2;
          D.22887 = D.22886 * 8;
          D.22888 = D.22839 + D.22887;
          iftmp.6 = *D.22888;
          goto <D.22893>;
          <D.22892>:
          iftmp.6 = 0B;
          <D.22893>:
          D.22894 = iftmp.6->flags;
          D.22895 = D.22894 | 4;
          iftmp.5->flags = D.22895;
          <D.22863>:
        }
        <D.22845>:
        <D.22838>:
        <D.22834>:
        D.22896 = ins->sreg1;
        sregs[0] = D.22896;
        D.22897 = ins->sreg2;
        sregs[1] = D.22897;
        D.22898 = ins->sreg3;
        sregs[2] = D.22898;
        D.22813 = ins->opcode;
        D.22814 = (int) D.22813;
        D.22815 = D.22814 + -313;
        D.22899 = ins_sreg_counts[D.22815];
        num_sregs = (int) D.22899;
        srcindex = 0;
        goto <D.22352>;
        <D.22351>:
        sreg = sregs[srcindex];
        D.22900 = sreg == -1;
        D.22901 = (long int) D.22900;
        D.22902 = __builtin_expect (D.22901, 0);
        if (D.22902 != 0) goto <D.22903>; else goto <D.22904>;
        <D.22903>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "liveness.c", 114, "sreg != -1");
        <D.22904>:
        sreg.7 = (unsigned int) sreg;
        D.22836 = cfg->vreg_to_inst_len;
        if (sreg.7 < D.22836) goto <D.22906>; else goto <D.22907>;
        <D.22906>:
        D.22839 = cfg->vreg_to_inst;
        D.22908 = (long unsigned int) sreg;
        D.22909 = D.22908 * 8;
        D.22910 = D.22839 + D.22909;
        D.22911 = *D.22910;
        if (D.22911 != 0B) goto <D.22912>; else goto <D.22913>;
        <D.22912>:
        {
          struct MonoInst * var;
          int idx;
          struct MonoMethodVar * vi;

          sreg.7 = (unsigned int) sreg;
          D.22836 = cfg->vreg_to_inst_len;
          if (sreg.7 < D.22836) goto <D.22915>; else goto <D.22916>;
          <D.22915>:
          D.22839 = cfg->vreg_to_inst;
          D.22908 = (long unsigned int) sreg;
          D.22909 = D.22908 * 8;
          D.22910 = D.22839 + D.22909;
          iftmp.8 = *D.22910;
          goto <D.22917>;
          <D.22916>:
          iftmp.8 = 0B;
          <D.22917>:
          var = iftmp.8;
          D.22918 = var->data.op[0].const_val;
          idx = (int) D.22918;
          D.22851 = cfg->vars;
          D.22919 = (long unsigned int) idx;
          D.22920 = D.22919 * 80;
          vi = D.22851 + D.22920;
          D.22854 = cfg->varinfo;
          D.22921 = vi->idx;
          D.22922 = (long unsigned int) D.22921;
          D.22923 = D.22922 * 8;
          D.22924 = D.22854 + D.22923;
          D.22925 = *D.22924;
          D.22854 = cfg->varinfo;
          D.22921 = vi->idx;
          D.22922 = (long unsigned int) D.22921;
          D.22923 = D.22922 * 8;
          D.22924 = D.22854 + D.22923;
          D.22925 = *D.22924;
          D.22926 = D.22925->flags;
          D.22927 = D.22926 | 4;
          D.22925->flags = D.22927;
          if (0 != 0) goto <D.22928>; else goto <D.22929>;
          <D.22928>:
          D.22931 = var->dreg;
          D.22932 = D.22931 + 1;
          D.22933 = (unsigned int) D.22932;
          D.22836 = cfg->vreg_to_inst_len;
          if (D.22933 < D.22836) goto <D.22934>; else goto <D.22935>;
          <D.22934>:
          D.22839 = cfg->vreg_to_inst;
          D.22931 = var->dreg;
          D.22936 = (sizetype) D.22931;
          D.22937 = D.22936 + 1;
          D.22938 = D.22937 * 8;
          D.22939 = D.22839 + D.22938;
          iftmp.9 = *D.22939;
          goto <D.22940>;
          <D.22935>:
          iftmp.9 = 0B;
          <D.22940>:
          D.22931 = var->dreg;
          D.22932 = D.22931 + 1;
          D.22933 = (unsigned int) D.22932;
          D.22836 = cfg->vreg_to_inst_len;
          if (D.22933 < D.22836) goto <D.22942>; else goto <D.22943>;
          <D.22942>:
          D.22839 = cfg->vreg_to_inst;
          D.22931 = var->dreg;
          D.22936 = (sizetype) D.22931;
          D.22937 = D.22936 + 1;
          D.22938 = D.22937 * 8;
          D.22939 = D.22839 + D.22938;
          iftmp.10 = *D.22939;
          goto <D.22944>;
          <D.22943>:
          iftmp.10 = 0B;
          <D.22944>:
          D.22945 = iftmp.10->flags;
          D.22946 = D.22945 | 4;
          iftmp.9->flags = D.22946;
          D.22931 = var->dreg;
          D.22948 = D.22931 + 2;
          D.22949 = (unsigned int) D.22948;
          D.22836 = cfg->vreg_to_inst_len;
          if (D.22949 < D.22836) goto <D.22950>; else goto <D.22951>;
          <D.22950>:
          D.22839 = cfg->vreg_to_inst;
          D.22931 = var->dreg;
          D.22936 = (sizetype) D.22931;
          D.22952 = D.22936 + 2;
          D.22953 = D.22952 * 8;
          D.22954 = D.22839 + D.22953;
          iftmp.11 = *D.22954;
          goto <D.22955>;
          <D.22951>:
          iftmp.11 = 0B;
          <D.22955>:
          D.22931 = var->dreg;
          D.22948 = D.22931 + 2;
          D.22949 = (unsigned int) D.22948;
          D.22836 = cfg->vreg_to_inst_len;
          if (D.22949 < D.22836) goto <D.22957>; else goto <D.22958>;
          <D.22957>:
          D.22839 = cfg->vreg_to_inst;
          D.22931 = var->dreg;
          D.22936 = (sizetype) D.22931;
          D.22952 = D.22936 + 2;
          D.22953 = D.22952 * 8;
          D.22954 = D.22839 + D.22953;
          iftmp.12 = *D.22954;
          goto <D.22959>;
          <D.22958>:
          iftmp.12 = 0B;
          <D.22959>:
          D.22960 = iftmp.12->flags;
          D.22961 = D.22960 | 4;
          iftmp.11->flags = D.22961;
          <D.22929>:
        }
        <D.22913>:
        <D.22907>:
        srcindex = srcindex + 1;
        <D.22352>:
        if (srcindex < num_sregs) goto <D.22351>; else goto <D.22353>;
        <D.22353>:
      }
    finally
      {
        sregs = {CLOBBER};
      }
  }
  <D.22344>:
  ins = ins->next;
  <D.22355>:
  if (ins != 0B) goto <D.22354>; else goto <D.22356>;
  <D.22356>:
  D.22809 = *visited;
  D.22962 = monoeg_g_slist_append (D.22809, bb);
  *visited = D.22962;
  i = 0;
  goto <D.22358>;
  <D.22357>:
  D.22963 = bb->out_bb;
  D.22964 = (long unsigned int) i;
  D.22965 = D.22964 * 8;
  D.22966 = D.22963 + D.22965;
  D.22967 = *D.22966;
  visit_bb (cfg, D.22967, visited);
  i = i + 1;
  <D.22358>:
  D.22968 = bb->out_count;
  D.22969 = (int) D.22968;
  if (D.22969 > i) goto <D.22357>; else goto <D.22359>;
  <D.22359>:
}


mono_analyze_liveness (struct MonoCompile * cfg)
{
  unsigned int D.22973;
  unsigned int D.22974;
  unsigned int D.22977;
  unsigned int D.22978;
  _Bool D.22979;
  long int D.22980;
  long int D.22981;
  unsigned int D.22984;
  unsigned int max_vars.13;
  unsigned int D.22988;
  struct MonoMethodVar * D.22989;
  long unsigned int D.22990;
  long unsigned int D.22991;
  struct MonoMethodVar * D.22992;
  struct MonoBasicBlock * * D.22993;
  long unsigned int D.22994;
  struct MonoBasicBlock * * D.22995;
  struct MonoMemPool * D.22996;
  unsigned int bitsize.14;
  struct MonoBitSet * D.22998;
  struct MonoBitSet * D.22999;
  int D.23002;
  struct MonoBasicBlock * * D.23003;
  long unsigned int D.23004;
  long unsigned int D.23005;
  struct MonoBasicBlock * * D.23006;
  struct MonoBasicBlock * D.23007;
  int D.23008;
  short int D.23009;
  int D.23010;
  struct MonoBitSet * D.23013;
  struct MonoBitSet * D.23014;
  unsigned int i.15;
  unsigned int D.23016;
  unsigned int D.23017;
  long unsigned int D.23018;
  long unsigned int D.23019;
  long unsigned int D.23020;
  unsigned int l_end.16;
  long unsigned int D.23022;
  long unsigned int D.23023;
  struct MonoBasicBlock * * D.23024;
  int D.23025;
  long unsigned int D.23026;
  long unsigned int D.23027;
  gboolean * D.23028;
  struct MonoBitSet * D.23029;
  long unsigned int D.23032;
  long unsigned int D.23033;
  struct MonoBasicBlock * * D.23034;
  int D.23035;
  long unsigned int D.23036;
  long unsigned int D.23037;
  gboolean * D.23038;
  int D.23041;
  struct MonoBasicBlock * * D.23042;
  struct MonoBasicBlock * * D.23043;
  struct MonoBasicBlock * D.23044;
  int D.23045;
  short int D.23046;
  int D.23047;
  struct MonoBasicBlock * * D.23048;
  struct MonoBasicBlock * * D.23049;
  struct MonoBasicBlock * D.23050;
  int D.23051;
  short int D.23052;
  int D.23053;
  struct MonoBitSet * D.23056;
  gsize[0:] * D.23060;
  struct MonoBitSet * D.23061;
  gsize[0:] * D.23062;
  long unsigned int D.23063;
  long unsigned int D.23064;
  struct MonoBitSet * D.23065;
  struct MonoBitSet * D.23068;
  gsize[0:] * D.23069;
  struct MonoBitSet * D.23070;
  gsize[0:] * D.23071;
  long unsigned int D.23072;
  long unsigned int D.23073;
  long unsigned int D.23074;
  long unsigned int D.23075;
  long unsigned int D.23076;
  long unsigned int D.23077;
  long unsigned int D.23078;
  long unsigned int D.23079;
  long unsigned int D.23080;
  long unsigned int D.23081;
  long unsigned int D.23082;
  long unsigned int D.23083;
  long unsigned int D.23084;
  struct MonoInst * D.23087;
  short unsigned int D.23089;
  long unsigned int D.23091;
  long unsigned int D.23092;
  long unsigned int D.23093;
  long unsigned int D.23094;
  long unsigned int D.23095;
  int D.23098;
  struct MonoBitSet * D.23101;
  gsize[0:] * D.23102;
  long unsigned int D.23103;
  long unsigned int D.23104;
  long unsigned int D.23105;
  long unsigned int D.23106;
  long unsigned int D.23107;
  long unsigned int D.23108;
  long unsigned int D.23109;
  long unsigned int D.23110;
  long unsigned int D.23111;
  long unsigned int D.23112;
  long unsigned int D.23113;
  long unsigned int D.23114;
  long unsigned int D.23115;
  struct MonoBitSet * D.23116;
  int D.23119;
  long unsigned int D.23120;
  long unsigned int D.23121;
  gboolean * D.23122;
  int D.23123;
  int D.23128;
  unsigned int l_end.17;
  long unsigned int D.23130;
  long unsigned int D.23131;
  struct MonoBasicBlock * * D.23132;
  _Bool D.23133;
  long int D.23134;
  long int D.23135;
  struct MonoBitSet * D.23140;
  struct MonoBitSet * D.23143;
  gsize[0:] * D.23144;
  struct MonoBitSet * D.23145;
  gsize[0:] * D.23146;
  long unsigned int D.23147;
  long unsigned int D.23148;
  long unsigned int D.23149;
  long unsigned int D.23150;
  long unsigned int D.23151;
  long unsigned int D.23152;
  long unsigned int D.23153;
  long unsigned int D.23154;
  long unsigned int D.23155;
  long unsigned int D.23156;
  long unsigned int D.23157;
  long unsigned int D.23158;
  long unsigned int D.23159;
  int D.23160;
  int D.23161;
  struct MonoBitSet * D.23162;
  long unsigned int D.23165;
  long unsigned int D.23166;
  long unsigned int D.23167;
  struct MonoBitSet * D.23168;
  unsigned int j.18;
  unsigned int D.23170;
  long unsigned int D.23171;
  long unsigned int D.23174;
  long unsigned int D.23175;
  struct MonoMethodVar * D.23176;
  int abs_pos.19;
  long unsigned int D.23178;
  unsigned int D.23181;
  int D.23182;
  long unsigned int D.23183;
  unsigned int j.20;
  struct MonoInst * * D.23185;
  unsigned int D.23186;
  long unsigned int D.23187;
  long unsigned int D.23188;
  struct MonoInst * * D.23189;
  struct MonoInst * D.23190;
  short unsigned int D.23191;
  unsigned int D.23194;
  unsigned char D.23197;
  int D.23198;
  int D.23199;
  long unsigned int D.23204;
  long unsigned int D.23205;
  struct MonoGenericSharingContext * D.23208;
  struct MonoMethod * D.23210;
  struct MonoMethodSignature * D.23211;
  long unsigned int D.23212;
  long unsigned int D.23213;
  struct MonoInst * * D.23215;
  struct MonoInst * D.23216;
  unsigned char D.23217;
  unsigned int D.23220;
  int D.23221;
  struct MonoBitSet * D.23222;
  struct MonoBitSet * D.23223;
  unsigned int D.23224;
  unsigned int D.23225;
  long unsigned int D.23226;
  long unsigned int D.23229;
  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.22973 = cfg->num_varinfo;
  max_vars = (int) D.22973;
  D.22974 = cfg->verbose_level;
  if (D.22974 > 1) goto <D.22975>; else goto <D.22976>;
  <D.22975>:
  printf ("\nLIVENESS:\n");
  <D.22976>:
  D.22977 = cfg->comp_done;
  D.22978 = D.22977 & 16;
  D.22979 = D.22978 != 0;
  D.22980 = (long int) D.22979;
  D.22981 = __builtin_expect (D.22980, 0);
  if (D.22981 != 0) goto <D.22982>; else goto <D.22983>;
  <D.22982>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "liveness.c", 316, "!(cfg->comp_done & MONO_COMP_LIVENESS)");
  <D.22983>:
  D.22977 = cfg->comp_done;
  D.22984 = D.22977 | 16;
  cfg->comp_done = D.22984;
  if (max_vars == 0) goto <D.22985>; else goto <D.22986>;
  <D.22985>:
  return;
  <D.22986>:
  max_vars.13 = (unsigned int) max_vars;
  D.22988 = mono_bitset_alloc_size (max_vars.13, 0);
  bitsize = (int) D.22988;
  i = 0;
  goto <D.22430>;
  <D.22429>:
  D.22989 = cfg->vars;
  D.22990 = (long unsigned int) i;
  D.22991 = D.22990 * 80;
  D.22992 = D.22989 + D.22991;
  D.22992->range.first_use.abs_pos = 4294967295;
  D.22989 = cfg->vars;
  D.22990 = (long unsigned int) i;
  D.22991 = D.22990 * 80;
  D.22992 = D.22989 + D.22991;
  D.22992->range.last_use.abs_pos = 0;
  D.22989 = cfg->vars;
  D.22990 = (long unsigned int) i;
  D.22991 = D.22990 * 80;
  D.22992 = D.22989 + D.22991;
  D.22992->spill_costs = 0;
  i = i + 1;
  <D.22430>:
  if (i < max_vars) goto <D.22429>; else goto <D.22431>;
  <D.22431>:
  i = 0;
  goto <D.22437>;
  <D.22436>:
  {
    struct MonoBasicBlock * bb;

    D.22993 = cfg->bblocks;
    D.22990 = (long unsigned int) i;
    D.22994 = D.22990 * 8;
    D.22995 = D.22993 + D.22994;
    bb = *D.22995;
    D.22996 = cfg->mempool;
    bitsize.14 = (unsigned int) bitsize;
    max_vars.13 = (unsigned int) max_vars;
    D.22998 = mono_bitset_mp_new (D.22996, bitsize.14, max_vars.13);
    bb->gen_set = D.22998;
    D.22996 = cfg->mempool;
    bitsize.14 = (unsigned int) bitsize;
    max_vars.13 = (unsigned int) max_vars;
    D.22999 = mono_bitset_mp_new (D.22996, bitsize.14, max_vars.13);
    bb->kill_set = D.22999;
    D.22974 = cfg->verbose_level;
    if (D.22974 > 1) goto <D.23000>; else goto <D.23001>;
    <D.23000>:
    D.23002 = bb->block_num;
    printf ("BLOCK BB%d (", D.23002);
    j = 0;
    goto <D.22434>;
    <D.22433>:
    D.23003 = bb->out_bb;
    D.23004 = (long unsigned int) j;
    D.23005 = D.23004 * 8;
    D.23006 = D.23003 + D.23005;
    D.23007 = *D.23006;
    D.23008 = D.23007->block_num;
    printf ("BB%d, ", D.23008);
    j = j + 1;
    <D.22434>:
    D.23009 = bb->out_count;
    D.23010 = (int) D.23009;
    if (D.23010 > j) goto <D.22433>; else goto <D.22435>;
    <D.22435>:
    printf ("):\n");
    <D.23001>:
    analyze_liveness_bb (cfg, bb);
    D.22974 = cfg->verbose_level;
    if (D.22974 > 1) goto <D.23011>; else goto <D.23012>;
    <D.23011>:
    D.23002 = bb->block_num;
    printf ("GEN  BB%d: ", D.23002);
    D.23013 = bb->gen_set;
    mono_bitset_print (D.23013);
    D.23002 = bb->block_num;
    printf ("KILL BB%d: ", D.23002);
    D.23014 = bb->kill_set;
    mono_bitset_print (D.23014);
    <D.23012>:
  }
  i = i + 1;
  <D.22437>:
  i.15 = (unsigned int) i;
  D.23016 = cfg->num_bblocks;
  if (i.15 < D.23016) goto <D.22436>; else goto <D.22438>;
  <D.22438>:
  max_vars.13 = (unsigned int) max_vars;
  old_live_out_set = mono_bitset_new (max_vars.13, 0);
  D.23016 = cfg->num_bblocks;
  D.23017 = D.23016 + 1;
  D.23018 = (long unsigned int) D.23017;
  D.23019 = D.23018 * 4;
  in_worklist = monoeg_malloc0 (D.23019);
  D.23016 = cfg->num_bblocks;
  D.23017 = D.23016 + 1;
  D.23018 = (long unsigned int) D.23017;
  D.23020 = D.23018 * 8;
  worklist = monoeg_malloc (D.23020);
  l_end = 0;
  i = 0;
  goto <D.22441>;
  <D.22440>:
  {
    struct MonoBasicBlock * bb;

    D.22993 = cfg->bblocks;
    D.22990 = (long unsigned int) i;
    D.22994 = D.22990 * 8;
    D.22995 = D.22993 + D.22994;
    bb = *D.22995;
    l_end.16 = l_end;
    l_end = l_end.16 + 1;
    D.23022 = (long unsigned int) l_end.16;
    D.23023 = D.23022 * 8;
    D.23024 = worklist + D.23023;
    *D.23024 = bb;
    D.23025 = bb->dfn;
    D.23026 = (long unsigned int) D.23025;
    D.23027 = D.23026 * 4;
    D.23028 = in_worklist + D.23027;
    *D.23028 = 1;
    bb->live_in_set = 0B;
    D.22996 = cfg->mempool;
    bitsize.14 = (unsigned int) bitsize;
    max_vars.13 = (unsigned int) max_vars;
    D.23029 = mono_bitset_mp_new (D.22996, bitsize.14, max_vars.13);
    bb->live_out_set = D.23029;
  }
  i = i + 1;
  <D.22441>:
  i.15 = (unsigned int) i;
  D.23016 = cfg->num_bblocks;
  if (i.15 < D.23016) goto <D.22440>; else goto <D.22442>;
  <D.22442>:
  out_iter = 0;
  D.22974 = cfg->verbose_level;
  if (D.22974 > 1) goto <D.23030>; else goto <D.23031>;
  <D.23030>:
  printf ("\nITERATION:\n");
  <D.23031>:
  goto <D.22452>;
  <D.22495>:
  {
    struct MonoBasicBlock * bb;
    struct MonoBasicBlock * out_bb;
    gboolean changed;

    l_end = l_end + 4294967295;
    D.23032 = (long unsigned int) l_end;
    D.23033 = D.23032 * 8;
    D.23034 = worklist + D.23033;
    bb = *D.23034;
    D.23035 = bb->dfn;
    D.23036 = (long unsigned int) D.23035;
    D.23037 = D.23036 * 4;
    D.23038 = in_worklist + D.23037;
    *D.23038 = 0;
    D.22974 = cfg->verbose_level;
    if (D.22974 > 1) goto <D.23039>; else goto <D.23040>;
    <D.23039>:
    D.23041 = bb->block_num;
    D.23035 = bb->dfn;
    printf ("P: BB%d(%d): IN: ", D.23041, D.23035);
    j = 0;
    goto <D.22447>;
    <D.22446>:
    D.23042 = bb->in_bb;
    D.23004 = (long unsigned int) j;
    D.23005 = D.23004 * 8;
    D.23043 = D.23042 + D.23005;
    D.23044 = *D.23043;
    D.23045 = D.23044->block_num;
    printf ("BB%d ", D.23045);
    j = j + 1;
    <D.22447>:
    D.23046 = bb->in_count;
    D.23047 = (int) D.23046;
    if (D.23047 > j) goto <D.22446>; else goto <D.22448>;
    <D.22448>:
    printf ("OUT:");
    j = 0;
    goto <D.22450>;
    <D.22449>:
    D.23048 = bb->out_bb;
    D.23004 = (long unsigned int) j;
    D.23005 = D.23004 * 8;
    D.23049 = D.23048 + D.23005;
    D.23050 = *D.23049;
    D.23051 = D.23050->block_num;
    printf ("BB%d ", D.23051);
    j = j + 1;
    <D.22450>:
    D.23052 = bb->out_count;
    D.23053 = (int) D.23052;
    if (D.23053 > j) goto <D.22449>; else goto <D.22451>;
    <D.22451>:
    printf ("\n");
    <D.23040>:
    D.23052 = bb->out_count;
    if (D.23052 == 0) goto <D.23054>; else goto <D.23055>;
    <D.23054>:
    // predicted unlikely by continue predictor.
    goto <D.22452>;
    <D.23055>:
    out_iter = out_iter + 1;
    D.23056 = bb->live_in_set;
    if (D.23056 == 0B) goto <D.23057>; else goto <D.23058>;
    <D.23057>:
    changed = 1;
    goto <D.23059>;
    <D.23058>:
    changed = 0;
    D.23060 = &old_live_out_set->data;
    D.23061 = bb->live_out_set;
    D.23062 = &D.23061->data;
    D.23063 = old_live_out_set->size;
    D.23064 = D.23063 / 8;
    memcpy (D.23060, D.23062, D.23064);
    <D.23059>:
    j = 0;
    goto <D.22475>;
    <D.22474>:
    D.23048 = bb->out_bb;
    D.23004 = (long unsigned int) j;
    D.23005 = D.23004 * 8;
    D.23049 = D.23048 + D.23005;
    out_bb = *D.23049;
    D.23065 = out_bb->live_in_set;
    if (D.23065 == 0B) goto <D.23066>; else goto <D.23067>;
    <D.23066>:
    D.22996 = cfg->mempool;
    bitsize.14 = (unsigned int) bitsize;
    max_vars.13 = (unsigned int) max_vars;
    D.23068 = mono_bitset_mp_new_noinit (D.22996, bitsize.14, max_vars.13);
    out_bb->live_in_set = D.23068;
    D.23065 = out_bb->live_in_set;
    D.23069 = &D.23065->data;
    D.23070 = out_bb->live_out_set;
    D.23071 = &D.23070->data;
    D.23065 = out_bb->live_in_set;
    D.23072 = D.23065->size;
    D.23073 = D.23072 / 8;
    memcpy (D.23069, D.23071, D.23073);
    {
      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.23074 = tmp_dest->size;
      D.23075 = D.23074 / 64;
      size = (int) D.23075;
      i = 0;
      goto <D.22458>;
      <D.22457>:
      D.23076 = tmp_dest->data[i];
      D.23077 = tmp_src->data[i];
      D.23078 = ~D.23077;
      D.23079 = D.23076 & D.23078;
      tmp_dest->data[i] = D.23079;
      i = i + 1;
      <D.22458>:
      if (i < size) goto <D.22457>; else goto <D.22459>;
      <D.22459>:
    }
    {
      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.23080 = tmp_dest->size;
      D.23081 = D.23080 / 64;
      size = (int) D.23081;
      i = 0;
      goto <D.22465>;
      <D.22464>:
      D.23082 = tmp_dest->data[i];
      D.23083 = tmp_src->data[i];
      D.23084 = D.23082 | D.23083;
      tmp_dest->data[i] = D.23084;
      i = i + 1;
      <D.22465>:
      if (i < size) goto <D.22464>; else goto <D.22466>;
      <D.22466>:
    }
    <D.23067>:
    D.23087 = bb->last_ins;
    if (D.23087 != 0B) goto <D.23088>; else goto <D.23085>;
    <D.23088>:
    D.23087 = bb->last_ins;
    D.23089 = D.23087->opcode;
    if (D.23089 == 798) goto <D.23090>; else goto <D.23085>;
    <D.23090>:
    goto <D.23086>;
    <D.23085>:
    {
      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.23091 = tmp_dest->size;
      D.23092 = D.23091 / 64;
      size = (int) D.23092;
      i = 0;
      goto <D.22472>;
      <D.22471>:
      D.23093 = tmp_dest->data[i];
      D.23094 = tmp_src->data[i];
      D.23095 = D.23093 | D.23094;
      tmp_dest->data[i] = D.23095;
      i = i + 1;
      <D.22472>:
      if (i < size) goto <D.22471>; else goto <D.22473>;
      <D.22473>:
    }
    <D.23086>:
    j = j + 1;
    <D.22475>:
    D.23052 = bb->out_count;
    D.23053 = (int) D.23052;
    if (D.23053 > j) goto <D.22474>; else goto <D.22476>;
    <D.22476>:
    if (changed != 0) goto <D.23096>; else goto <D.23097>;
    <D.23097>:
    D.23061 = bb->live_out_set;
    D.23098 = mono_bitset_equal (old_live_out_set, D.23061);
    if (D.23098 == 0) goto <D.23096>; else goto <D.22494>;
    <D.23096>:
    D.23056 = bb->live_in_set;
    if (D.23056 == 0B) goto <D.23099>; else goto <D.23100>;
    <D.23099>:
    D.22996 = cfg->mempool;
    bitsize.14 = (unsigned int) bitsize;
    max_vars.13 = (unsigned int) max_vars;
    D.23101 = mono_bitset_mp_new_noinit (D.22996, bitsize.14, max_vars.13);
    bb->live_in_set = D.23101;
    <D.23100>:
    D.23056 = bb->live_in_set;
    D.23102 = &D.23056->data;
    D.23061 = bb->live_out_set;
    D.23062 = &D.23061->data;
    D.23056 = bb->live_in_set;
    D.23103 = D.23056->size;
    D.23104 = D.23103 / 8;
    memcpy (D.23102, D.23062, D.23104);
    {
      struct MonoBitSet * tmp_src;
      struct MonoBitSet * tmp_dest;
      int i;
      int size;

      tmp_src = bb->kill_set;
      tmp_dest = bb->live_in_set;
      D.23105 = tmp_dest->size;
      D.23106 = D.23105 / 64;
      size = (int) D.23106;
      i = 0;
      goto <D.22482>;
      <D.22481>:
      D.23107 = tmp_dest->data[i];
      D.23108 = tmp_src->data[i];
      D.23109 = ~D.23108;
      D.23110 = D.23107 & D.23109;
      tmp_dest->data[i] = D.23110;
      i = i + 1;
      <D.22482>:
      if (i < size) goto <D.22481>; else goto <D.22483>;
      <D.22483>:
    }
    {
      struct MonoBitSet * tmp_src;
      struct MonoBitSet * tmp_dest;
      int i;
      int size;

      tmp_src = bb->gen_set;
      tmp_dest = bb->live_in_set;
      D.23111 = tmp_dest->size;
      D.23112 = D.23111 / 64;
      size = (int) D.23112;
      i = 0;
      goto <D.22489>;
      <D.22488>:
      D.23113 = tmp_dest->data[i];
      D.23114 = tmp_src->data[i];
      D.23115 = D.23113 | D.23114;
      tmp_dest->data[i] = D.23115;
      i = i + 1;
      <D.22489>:
      if (i < size) goto <D.22488>; else goto <D.22490>;
      <D.22490>:
    }
    j = 0;
    goto <D.22493>;
    <D.22492>:
    {
      struct MonoBasicBlock * in_bb;

      D.23042 = bb->in_bb;
      D.23004 = (long unsigned int) j;
      D.23005 = D.23004 * 8;
      D.23043 = D.23042 + D.23005;
      in_bb = *D.23043;
      D.23116 = in_bb->gen_set;
      if (D.23116 != 0B) goto <D.23117>; else goto <D.23118>;
      <D.23117>:
      D.23119 = in_bb->dfn;
      D.23120 = (long unsigned int) D.23119;
      D.23121 = D.23120 * 4;
      D.23122 = in_worklist + D.23121;
      D.23123 = *D.23122;
      if (D.23123 == 0) goto <D.23124>; else goto <D.23125>;
      <D.23124>:
      D.22974 = cfg->verbose_level;
      if (D.22974 > 1) goto <D.23126>; else goto <D.23127>;
      <D.23126>:
      D.23128 = in_bb->block_num;
      printf ("\tADD: %d\n", D.23128);
      <D.23127>:
      l_end.17 = l_end;
      l_end = l_end.17 + 1;
      D.23130 = (long unsigned int) l_end.17;
      D.23131 = D.23130 * 8;
      D.23132 = worklist + D.23131;
      *D.23132 = in_bb;
      D.23119 = in_bb->dfn;
      D.23120 = (long unsigned int) D.23119;
      D.23121 = D.23120 * 4;
      D.23122 = in_worklist + D.23121;
      *D.23122 = 1;
      <D.23125>:
      <D.23118>:
    }
    j = j + 1;
    <D.22493>:
    D.23046 = bb->in_count;
    D.23047 = (int) D.23046;
    if (D.23047 > j) goto <D.22492>; else goto <D.22494>;
    <D.22494>:
    D.22974 = cfg->verbose_level;
    D.23133 = D.22974 > 1;
    D.23134 = (long int) D.23133;
    D.23135 = __builtin_expect (D.23134, 0);
    if (D.23135 != 0) goto <D.23136>; else goto <D.23137>;
    <D.23136>:
    D.23041 = bb->block_num;
    printf ("\tLIVE IN  BB%d: ", D.23041);
    D.23056 = bb->live_in_set;
    mono_bitset_print (D.23056);
    <D.23137>:
  }
  <D.22452>:
  if (l_end != 0) goto <D.22495>; else goto <D.22496>;
  <D.22496>:
  D.22974 = cfg->verbose_level;
  if (D.22974 > 1) goto <D.23138>; else goto <D.23139>;
  <D.23138>:
  D.23016 = cfg->num_bblocks;
  printf ("IT: %d %d.\n", D.23016, out_iter);
  <D.23139>:
  mono_bitset_free (old_live_out_set);
  monoeg_g_free (worklist);
  monoeg_g_free (in_worklist);
  i = 0;
  goto <D.22513>;
  <D.22512>:
  {
    struct MonoBasicBlock * bb;

    D.22993 = cfg->bblocks;
    D.22990 = (long unsigned int) i;
    D.22994 = D.22990 * 8;
    D.22995 = D.22993 + D.22994;
    bb = *D.22995;
    D.23140 = bb->live_in_set;
    if (D.23140 == 0B) goto <D.23141>; else goto <D.23142>;
    <D.23141>:
    D.22996 = cfg->mempool;
    bitsize.14 = (unsigned int) bitsize;
    max_vars.13 = (unsigned int) max_vars;
    D.23143 = mono_bitset_mp_new (D.22996, bitsize.14, max_vars.13);
    bb->live_in_set = D.23143;
    D.23140 = bb->live_in_set;
    D.23144 = &D.23140->data;
    D.23145 = bb->live_out_set;
    D.23146 = &D.23145->data;
    D.23140 = bb->live_in_set;
    D.23147 = D.23140->size;
    D.23148 = D.23147 / 8;
    memcpy (D.23144, D.23146, D.23148);
    {
      struct MonoBitSet * tmp_src;
      struct MonoBitSet * tmp_dest;
      int i;
      int size;

      tmp_src = bb->kill_set;
      tmp_dest = bb->live_in_set;
      D.23149 = tmp_dest->size;
      D.23150 = D.23149 / 64;
      size = (int) D.23150;
      i = 0;
      goto <D.22503>;
      <D.22502>:
      D.23151 = tmp_dest->data[i];
      D.23152 = tmp_src->data[i];
      D.23153 = ~D.23152;
      D.23154 = D.23151 & D.23153;
      tmp_dest->data[i] = D.23154;
      i = i + 1;
      <D.22503>:
      if (i < size) goto <D.22502>; else goto <D.22504>;
      <D.22504>:
    }
    {
      struct MonoBitSet * tmp_src;
      struct MonoBitSet * tmp_dest;
      int i;
      int size;

      tmp_src = bb->gen_set;
      tmp_dest = bb->live_in_set;
      D.23155 = tmp_dest->size;
      D.23156 = D.23155 / 64;
      size = (int) D.23156;
      i = 0;
      goto <D.22510>;
      <D.22509>:
      D.23157 = tmp_dest->data[i];
      D.23158 = tmp_src->data[i];
      D.23159 = D.23157 | D.23158;
      tmp_dest->data[i] = D.23159;
      i = i + 1;
      <D.22510>:
      if (i < size) goto <D.22509>; else goto <D.22511>;
      <D.22511>:
    }
    <D.23142>:
  }
  i = i + 1;
  <D.22513>:
  i.15 = (unsigned int) i;
  D.23016 = cfg->num_bblocks;
  if (i.15 < D.23016) goto <D.22512>; else goto <D.22514>;
  <D.22514>:
  i = 0;
  goto <D.22530>;
  <D.22529>:
  {
    struct MonoBasicBlock * bb;
    guint32 max;
    guint32 abs_pos;
    struct MonoMethodVar * vars;

    D.22993 = cfg->bblocks;
    D.22990 = (long unsigned int) i;
    D.22994 = D.22990 * 8;
    D.22995 = D.22993 + D.22994;
    bb = *D.22995;
    D.23160 = bb->dfn;
    D.23161 = D.23160 << 16;
    abs_pos = (guint32) D.23161;
    vars = cfg->vars;
    D.23162 = bb->live_out_set;
    if (D.23162 == 0B) goto <D.23163>; else goto <D.23164>;
    <D.23163>:
    // predicted unlikely by continue predictor.
    goto <D.22519>;
    <D.23164>:
    D.23165 = (long unsigned int) max_vars;
    D.23166 = D.23165 + 63;
    D.23167 = D.23166 / 64;
    max = (guint32) D.23167;
    j = 0;
    goto <D.22527>;
    <D.22526>:
    {
      gsize bits_in;
      gsize bits_out;
      int k;

      D.23168 = bb->live_in_set;
      bits_in = D.23168->data[j];
      D.23162 = bb->live_out_set;
      bits_out = D.23162->data[j];
      j.18 = (unsigned int) j;
      D.23170 = j.18 * 64;
      k = (int) D.23170;
      goto <D.22524>;
      <D.22523>:
      D.23171 = bits_in & 1;
      if (D.23171 != 0) goto <D.23172>; else goto <D.23173>;
      <D.23172>:
      D.23174 = (long unsigned int) k;
      D.23175 = D.23174 * 80;
      D.23176 = vars + D.23175;
      abs_pos.19 = (int) abs_pos;
      update_live_range (D.23176, abs_pos.19);
      <D.23173>:
      D.23178 = bits_out & 1;
      if (D.23178 != 0) goto <D.23179>; else goto <D.23180>;
      <D.23179>:
      D.23174 = (long unsigned int) k;
      D.23175 = D.23174 * 80;
      D.23176 = vars + D.23175;
      D.23181 = abs_pos + 65535;
      D.23182 = (int) D.23181;
      update_live_range (D.23176, D.23182);
      <D.23180>:
      bits_in = bits_in >> 1;
      bits_out = bits_out >> 1;
      k = k + 1;
      <D.22524>:
      D.23183 = bits_in | bits_out;
      if (D.23183 != 0) goto <D.22523>; else goto <D.22525>;
      <D.22525>:
    }
    j = j + 1;
    <D.22527>:
    j.20 = (unsigned int) j;
    if (j.20 < max) goto <D.22526>; else goto <D.22528>;
    <D.22528>:
  }
  <D.22519>:
  i = i + 1;
  <D.22530>:
  i.15 = (unsigned int) i;
  D.23016 = cfg->num_bblocks;
  if (i.15 < D.23016) goto <D.22529>; else goto <D.22531>;
  <D.22531>:
  i = 0;
  goto <D.22534>;
  <D.22533>:
  {
    struct MonoMethodVar * vi;

    D.22989 = cfg->vars;
    D.22990 = (long unsigned int) i;
    D.22991 = D.22990 * 80;
    vi = D.22989 + D.22991;
    D.23185 = cfg->varinfo;
    D.23186 = vi->idx;
    D.23187 = (long unsigned int) D.23186;
    D.23188 = D.23187 * 8;
    D.23189 = D.23185 + D.23188;
    D.23190 = *D.23189;
    D.23191 = D.23190->opcode;
    if (D.23191 == 330) goto <D.23192>; else goto <D.23193>;
    <D.23192>:
    D.23194 = vi->range.last_use.abs_pos;
    if (D.23194 == 0) goto <D.23195>; else goto <D.23196>;
    <D.23195>:
    D.23185 = cfg->varinfo;
    D.23186 = vi->idx;
    D.23187 = (long unsigned int) D.23186;
    D.23188 = D.23187 * 8;
    D.23189 = D.23185 + D.23188;
    D.23190 = *D.23189;
    D.23197 = D.23190->flags;
    D.23198 = (int) D.23197;
    D.23199 = D.23198 & 20;
    if (D.23199 == 0) goto <D.23200>; else goto <D.23201>;
    <D.23200>:
    D.23204 = BIT_FIELD_REF <*cfg, 64, 5568>;
    D.23205 = D.23204 & 36028797018963968;
    if (D.23205 == 0) goto <D.23206>; else goto <D.23207>;
    <D.23206>:
    D.23208 = cfg->generic_sharing_context;
    if (D.23208 == 0B) goto <D.23202>; else goto <D.23209>;
    <D.23209>:
    D.23210 = cfg->method;
    D.23211 = mono_method_signature (D.23210);
    D.23212 = BIT_FIELD_REF <*D.23211, 64, 64>;
    D.23213 = D.23212 & 18014398509481984;
    if (D.23213 == 0) goto <D.23202>; else goto <D.23214>;
    <D.23214>:
    D.23185 = cfg->varinfo;
    D.23186 = vi->idx;
    D.23187 = (long unsigned int) D.23186;
    D.23188 = D.23187 * 8;
    D.23189 = D.23185 + D.23188;
    D.23190 = *D.23189;
    D.23215 = cfg->args;
    D.23216 = *D.23215;
    if (D.23190 != D.23216) goto <D.23202>; else goto <D.23203>;
    <D.23202>:
    D.23185 = cfg->varinfo;
    D.23186 = vi->idx;
    D.23187 = (long unsigned int) D.23186;
    D.23188 = D.23187 * 8;
    D.23189 = D.23185 + D.23188;
    D.23190 = *D.23189;
    D.23185 = cfg->varinfo;
    D.23186 = vi->idx;
    D.23187 = (long unsigned int) D.23186;
    D.23188 = D.23187 * 8;
    D.23189 = D.23185 + D.23188;
    D.23190 = *D.23189;
    D.23197 = D.23190->flags;
    D.23217 = D.23197 | 2;
    D.23190->flags = D.23217;
    <D.23203>:
    <D.23207>:
    <D.23201>:
    <D.23196>:
    vi->range.first_use.abs_pos = 0;
    <D.23193>:
  }
  i = i + 1;
  <D.22534>:
  if (i < max_vars) goto <D.22533>; else goto <D.22535>;
  <D.22535>:
  D.22974 = cfg->verbose_level;
  if (D.22974 > 1) goto <D.23218>; else goto <D.23219>;
  <D.23218>:
  D.23016 = cfg->num_bblocks;
  D.23220 = D.23016 + 4294967295;
  i = (int) D.23220;
  goto <D.22538>;
  <D.22537>:
  {
    struct MonoBasicBlock * bb;

    D.22993 = cfg->bblocks;
    D.22990 = (long unsigned int) i;
    D.22994 = D.22990 * 8;
    D.22995 = D.22993 + D.22994;
    bb = *D.22995;
    D.23221 = bb->block_num;
    printf ("LIVE IN  BB%d: ", D.23221);
    D.23222 = bb->live_in_set;
    mono_bitset_print (D.23222);
    D.23221 = bb->block_num;
    printf ("LIVE OUT BB%d: ", D.23221);
    D.23223 = bb->live_out_set;
    mono_bitset_print (D.23223);
  }
  i = i + -1;
  <D.22538>:
  if (i >= 0) goto <D.22537>; else goto <D.22539>;
  <D.22539>:
  i = 0;
  goto <D.22542>;
  <D.22541>:
  {
    struct MonoMethodVar * vi;

    D.22989 = cfg->vars;
    D.22990 = (long unsigned int) i;
    D.22991 = D.22990 * 80;
    vi = D.22989 + D.22991;
    D.23224 = vi->range.first_use.abs_pos;
    D.23225 = vi->range.last_use.abs_pos;
    printf ("V%d: [0x%x - 0x%x]\n", i, D.23224, D.23225);
  }
  i = i + 1;
  <D.22542>:
  if (i < max_vars) goto <D.22541>; else goto <D.22543>;
  <D.22543>:
  <D.23219>:
  D.23204 = BIT_FIELD_REF <*cfg, 64, 5568>;
  D.23226 = D.23204 & 2251799813685248;
  if (D.23226 == 0) goto <D.23227>; else goto <D.23228>;
  <D.23227>:
  optimize_initlocals (cfg);
  <D.23228>:
  D.23204 = BIT_FIELD_REF <*cfg, 64, 5568>;
  D.23229 = D.23204 & 274877906944;
  if (D.23229 != 0) goto <D.23230>; else goto <D.23231>;
  <D.23230>:
  mono_analyze_liveness2 (cfg);
  <D.23231>:
}


analyze_liveness_bb (struct MonoCompile * cfg, struct MonoBasicBlock * bb)
{
  int D.23233;
  int D.23234;
  short unsigned int D.23235;
  int D.23236;
  int D.23237;
  int D.23238;
  unsigned int D.23239;
  long int D.23246;
  struct MonoMethodVar * D.23247;
  long unsigned int D.23248;
  long unsigned int D.23249;
  int D.23252;
  struct MonoMethodVar * D.23253;
  unsigned int inst_num.21;
  unsigned int D.23255;
  int D.23256;
  struct MonoBitSet * D.23257;
  long unsigned int D.23258;
  long unsigned int D.23259;
  int D.23260;
  long unsigned int D.23261;
  long unsigned int D.23262;
  struct MonoBitSet * D.23265;
  long unsigned int D.23266;
  long unsigned int D.23267;
  long unsigned int D.23268;
  long unsigned int D.23269;
  int D.23270;
  signed char D.23271;
  int D.23272;
  int D.23273;
  int D.23274;
  int D.23275;
  int D.23276;
  int D.23277;
  int D.23278;
  signed char D.23279;
  int D.23280;
  sizetype D.23281;
  const char * D.23282;
  char D.23283;
  unsigned int sreg.22;
  unsigned int D.23287;
  struct MonoInst * * D.23290;
  long unsigned int D.23291;
  long unsigned int D.23292;
  struct MonoInst * * D.23293;
  struct MonoInst * D.23294;
  struct MonoInst * iftmp.23;
  long int D.23301;
  long unsigned int D.23302;
  long unsigned int D.23303;
  struct MonoMethodVar * D.23306;
  long unsigned int D.23307;
  long unsigned int D.23308;
  int D.23309;
  long unsigned int D.23310;
  long unsigned int D.23311;
  long unsigned int D.23314;
  long unsigned int D.23315;
  long unsigned int D.23316;
  long unsigned int D.23317;
  int D.23318;
  int D.23319;
  char D.23320;
  int D.23323;
  unsigned int D.23324;
  long unsigned int D.23327;
  long unsigned int D.23328;
  struct MonoInst * * D.23329;
  struct MonoInst * D.23330;
  struct MonoInst * iftmp.24;
  long int D.23337;
  long unsigned int D.23338;
  long unsigned int D.23339;
  short unsigned int D.23340;
  struct MonoMethodVar * D.23343;
  long unsigned int D.23344;
  long unsigned int D.23345;
  int D.23346;
  long unsigned int D.23347;
  long unsigned int D.23348;
  long unsigned int D.23351;
  long unsigned int D.23352;
  long unsigned int D.23353;
  long unsigned int D.23354;
  int D.23355;
  int D.23356;
  unsigned int D.23360;
  int D.23361;
  long unsigned int D.23362;
  long unsigned int D.23363;
  long unsigned int D.23364;
  struct MonoInst * ins;
  int sreg;
  int inst_num;
  struct MonoMethodVar * vars;
  guint32 abs_pos;

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

    try
      {
        D.23235 = ins->opcode;
        D.23236 = (int) D.23235;
        D.23237 = D.23236 + -313;
        D.23238 = D.23237 * 4;
        spec = &ins_info[D.23238];
        D.23239 = cfg->verbose_level;
        if (D.23239 > 1) goto <D.23240>; else goto <D.23241>;
        <D.23240>:
        printf ("\t");
        mono_print_ins (ins);
        <D.23241>:
        D.23235 = ins->opcode;
        if (D.23235 == 316) goto <D.23242>; else goto <D.23243>;
        <D.23242>:
        // predicted unlikely by continue predictor.
        goto <D.22401>;
        <D.23243>:
        D.23235 = ins->opcode;
        if (D.23235 == 314) goto <D.23244>; else goto <D.23245>;
        <D.23244>:
        {
          struct MonoInst * var;
          int idx;
          struct MonoMethodVar * vi;

          var = ins->data.op[0].p;
          D.23246 = var->data.op[0].const_val;
          idx = (int) D.23246;
          D.23247 = cfg->vars;
          D.23248 = (long unsigned int) idx;
          D.23249 = D.23248 * 80;
          vi = D.23247 + D.23249;
          D.23239 = cfg->verbose_level;
          if (D.23239 > 1) goto <D.23250>; else goto <D.23251>;
          <D.23250>:
          D.23252 = var->dreg;
          printf ("\tGEN: R%d(%d)\n", D.23252, idx);
          <D.23251>:
          D.23248 = (long unsigned int) idx;
          D.23249 = D.23248 * 80;
          D.23253 = vars + D.23249;
          inst_num.21 = (unsigned int) inst_num;
          D.23255 = abs_pos + inst_num.21;
          D.23256 = (int) D.23255;
          update_live_range (D.23253, D.23256);
          D.23257 = bb->kill_set;
          D.23248 = (long unsigned int) idx;
          D.23258 = D.23248 / 64;
          D.23259 = D.23257->data[D.23258];
          D.23260 = idx & 63;
          D.23261 = D.23259 >> D.23260;
          D.23262 = D.23261 & 1;
          if (D.23262 == 0) goto <D.23263>; else goto <D.23264>;
          <D.23263>:
          D.23265 = bb->gen_set;
          D.23248 = (long unsigned int) idx;
          D.23266 = D.23248 / 64;
          D.23265 = bb->gen_set;
          D.23267 = D.23265->data[D.23266];
          D.23260 = idx & 63;
          D.23268 = 1 << D.23260;
          D.23269 = D.23267 | D.23268;
          D.23265->data[D.23266] = D.23269;
          <D.23264>:
          D.23270 = vi->spill_costs;
          D.23271 = bb->nesting;
          D.23272 = (int) D.23271;
          D.23273 = D.23272 << 1;
          D.23274 = 1 << D.23273;
          D.23275 = D.23270 + D.23274;
          vi->spill_costs = D.23275;
        }
        <D.23245>:
        D.23276 = ins->sreg1;
        sregs[0] = D.23276;
        D.23277 = ins->sreg2;
        sregs[1] = D.23277;
        D.23278 = ins->sreg3;
        sregs[2] = D.23278;
        D.23235 = ins->opcode;
        D.23236 = (int) D.23235;
        D.23237 = D.23236 + -313;
        D.23279 = ins_sreg_counts[D.23237];
        num_sregs = (int) D.23279;
        i = 0;
        goto <D.22409>;
        <D.22408>:
        sreg = sregs[i];
        D.23280 = i + 1;
        D.23281 = (sizetype) D.23280;
        D.23282 = spec + D.23281;
        D.23283 = *D.23282;
        if (D.23283 != 32) goto <D.23284>; else goto <D.23285>;
        <D.23284>:
        sreg.22 = (unsigned int) sreg;
        D.23287 = cfg->vreg_to_inst_len;
        if (sreg.22 < D.23287) goto <D.23288>; else goto <D.23289>;
        <D.23288>:
        D.23290 = cfg->vreg_to_inst;
        D.23291 = (long unsigned int) sreg;
        D.23292 = D.23291 * 8;
        D.23293 = D.23290 + D.23292;
        D.23294 = *D.23293;
        if (D.23294 != 0B) goto <D.23295>; else goto <D.23296>;
        <D.23295>:
        {
          struct MonoInst * var;
          int idx;
          struct MonoMethodVar * vi;

          sreg.22 = (unsigned int) sreg;
          D.23287 = cfg->vreg_to_inst_len;
          if (sreg.22 < D.23287) goto <D.23298>; else goto <D.23299>;
          <D.23298>:
          D.23290 = cfg->vreg_to_inst;
          D.23291 = (long unsigned int) sreg;
          D.23292 = D.23291 * 8;
          D.23293 = D.23290 + D.23292;
          iftmp.23 = *D.23293;
          goto <D.23300>;
          <D.23299>:
          iftmp.23 = 0B;
          <D.23300>:
          var = iftmp.23;
          D.23301 = var->data.op[0].const_val;
          idx = (int) D.23301;
          D.23247 = cfg->vars;
          D.23302 = (long unsigned int) idx;
          D.23303 = D.23302 * 80;
          vi = D.23247 + D.23303;
          D.23239 = cfg->verbose_level;
          if (D.23239 > 1) goto <D.23304>; else goto <D.23305>;
          <D.23304>:
          printf ("\tGEN: R%d(%d)\n", sreg, idx);
          <D.23305>:
          D.23302 = (long unsigned int) idx;
          D.23303 = D.23302 * 80;
          D.23306 = vars + D.23303;
          inst_num.21 = (unsigned int) inst_num;
          D.23255 = abs_pos + inst_num.21;
          D.23256 = (int) D.23255;
          update_live_range (D.23306, D.23256);
          D.23257 = bb->kill_set;
          D.23302 = (long unsigned int) idx;
          D.23307 = D.23302 / 64;
          D.23308 = D.23257->data[D.23307];
          D.23309 = idx & 63;
          D.23310 = D.23308 >> D.23309;
          D.23311 = D.23310 & 1;
          if (D.23311 == 0) goto <D.23312>; else goto <D.23313>;
          <D.23312>:
          D.23265 = bb->gen_set;
          D.23302 = (long unsigned int) idx;
          D.23314 = D.23302 / 64;
          D.23265 = bb->gen_set;
          D.23315 = D.23265->data[D.23314];
          D.23309 = idx & 63;
          D.23316 = 1 << D.23309;
          D.23317 = D.23315 | D.23316;
          D.23265->data[D.23314] = D.23317;
          <D.23313>:
          D.23318 = vi->spill_costs;
          D.23271 = bb->nesting;
          D.23272 = (int) D.23271;
          D.23273 = D.23272 << 1;
          D.23274 = 1 << D.23273;
          D.23319 = D.23318 + D.23274;
          vi->spill_costs = D.23319;
        }
        <D.23296>:
        <D.23289>:
        <D.23285>:
        i = i + 1;
        <D.22409>:
        if (i < num_sregs) goto <D.22408>; else goto <D.22410>;
        <D.22410>:
        D.23320 = *spec;
        if (D.23320 != 32) goto <D.23321>; else goto <D.23322>;
        <D.23321>:
        D.23323 = ins->dreg;
        D.23324 = (unsigned int) D.23323;
        D.23287 = cfg->vreg_to_inst_len;
        if (D.23324 < D.23287) goto <D.23325>; else goto <D.23326>;
        <D.23325>:
        D.23290 = cfg->vreg_to_inst;
        D.23323 = ins->dreg;
        D.23327 = (long unsigned int) D.23323;
        D.23328 = D.23327 * 8;
        D.23329 = D.23290 + D.23328;
        D.23330 = *D.23329;
        if (D.23330 != 0B) goto <D.23331>; else goto <D.23332>;
        <D.23331>:
        {
          struct MonoInst * var;
          int idx;
          struct MonoMethodVar * vi;

          D.23323 = ins->dreg;
          D.23324 = (unsigned int) D.23323;
          D.23287 = cfg->vreg_to_inst_len;
          if (D.23324 < D.23287) goto <D.23334>; else goto <D.23335>;
          <D.23334>:
          D.23290 = cfg->vreg_to_inst;
          D.23323 = ins->dreg;
          D.23327 = (long unsigned int) D.23323;
          D.23328 = D.23327 * 8;
          D.23329 = D.23290 + D.23328;
          iftmp.24 = *D.23329;
          goto <D.23336>;
          <D.23335>:
          iftmp.24 = 0B;
          <D.23336>:
          var = iftmp.24;
          D.23337 = var->data.op[0].const_val;
          idx = (int) D.23337;
          D.23247 = cfg->vars;
          D.23338 = (long unsigned int) idx;
          D.23339 = D.23338 * 80;
          vi = D.23247 + D.23339;
          D.23235 = ins->opcode;
          D.23340 = D.23235 + 65162;
          if (D.23340 <= 13) goto <D.23341>; else goto <D.23342>;
          <D.23341>:
          D.23338 = (long unsigned int) idx;
          D.23339 = D.23338 * 80;
          D.23343 = vars + D.23339;
          inst_num.21 = (unsigned int) inst_num;
          D.23255 = abs_pos + inst_num.21;
          D.23256 = (int) D.23255;
          update_live_range (D.23343, D.23256);
          D.23257 = bb->kill_set;
          D.23338 = (long unsigned int) idx;
          D.23344 = D.23338 / 64;
          D.23345 = D.23257->data[D.23344];
          D.23346 = idx & 63;
          D.23347 = D.23345 >> D.23346;
          D.23348 = D.23347 & 1;
          if (D.23348 == 0) goto <D.23349>; else goto <D.23350>;
          <D.23349>:
          D.23265 = bb->gen_set;
          D.23338 = (long unsigned int) idx;
          D.23351 = D.23338 / 64;
          D.23265 = bb->gen_set;
          D.23352 = D.23265->data[D.23351];
          D.23346 = idx & 63;
          D.23353 = 1 << D.23346;
          D.23354 = D.23352 | D.23353;
          D.23265->data[D.23351] = D.23354;
          <D.23350>:
          D.23355 = vi->spill_costs;
          D.23271 = bb->nesting;
          D.23272 = (int) D.23271;
          D.23273 = D.23272 << 1;
          D.23274 = 1 << D.23273;
          D.23356 = D.23355 + D.23274;
          vi->spill_costs = D.23356;
          goto <D.23357>;
          <D.23342>:
          D.23239 = cfg->verbose_level;
          if (D.23239 > 1) goto <D.23358>; else goto <D.23359>;
          <D.23358>:
          D.23323 = ins->dreg;
          printf ("\tKILL: R%d(%d)\n", D.23323, idx);
          <D.23359>:
          D.23338 = (long unsigned int) idx;
          D.23339 = D.23338 * 80;
          D.23343 = vars + D.23339;
          inst_num.21 = (unsigned int) inst_num;
          D.23255 = abs_pos + inst_num.21;
          D.23360 = D.23255 + 1;
          D.23361 = (int) D.23360;
          update_live_range (D.23343, D.23361);
          D.23257 = bb->kill_set;
          D.23338 = (long unsigned int) idx;
          D.23362 = D.23338 / 64;
          D.23257 = bb->kill_set;
          D.23363 = D.23257->data[D.23362];
          D.23346 = idx & 63;
          D.23353 = 1 << D.23346;
          D.23364 = D.23363 | D.23353;
          D.23257->data[D.23362] = D.23364;
          D.23355 = vi->spill_costs;
          D.23271 = bb->nesting;
          D.23272 = (int) D.23271;
          D.23273 = D.23272 << 1;
          D.23274 = 1 << D.23273;
          D.23356 = D.23355 + D.23274;
          vi->spill_costs = D.23356;
          <D.23357>:
        }
        <D.23332>:
        <D.23326>:
        <D.23322>:
      }
    finally
      {
        sregs = {CLOBBER};
      }
  }
  <D.22401>:
  ins = ins->next;
  inst_num = inst_num + 2;
  <D.22415>:
  if (ins != 0B) goto <D.22414>; else goto <D.22416>;
  <D.22416>:
}


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

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


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

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


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

  D.23372 = __builtin_object_size (__dest, 0);
  D.23371 = __builtin___memcpy_chk (__dest, __src, __len, D.23372);
  return D.23371;
}


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

  D.23374 = var->range.first_use.abs_pos;
  abs_pos.25 = (unsigned int) abs_pos;
  if (D.23374 > abs_pos.25) goto <D.23376>; else goto <D.23377>;
  <D.23376>:
  abs_pos.25 = (unsigned int) abs_pos;
  var->range.first_use.abs_pos = abs_pos.25;
  <D.23377>:
  D.23378 = var->range.last_use.abs_pos;
  abs_pos.25 = (unsigned int) abs_pos;
  if (D.23378 < abs_pos.25) goto <D.23379>; else goto <D.23380>;
  <D.23379>:
  abs_pos.25 = (unsigned int) abs_pos;
  var->range.last_use.abs_pos = abs_pos.25;
  <D.23380>:
}


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

  first = 1;
  printf ("{");
  i = 0;
  goto <D.22329>;
  <D.22328>:
  i.26 = (unsigned int) i;
  D.23382 = mono_bitset_test (set, i.26);
  if (D.23382 != 0) goto <D.23383>; else goto <D.23384>;
  <D.23383>:
  if (first == 0) goto <D.23385>; else goto <D.23386>;
  <D.23385>:
  printf (", ");
  <D.23386>:
  printf ("%d", i);
  first = 0;
  <D.23384>:
  i = i + 1;
  <D.22329>:
  i.26 = (unsigned int) i;
  D.23387 = mono_bitset_size (set);
  if (i.26 < D.23387) goto <D.22328>; else goto <D.22330>;
  <D.22330>:
  printf ("}\n");
}


optimize_initlocals (struct MonoCompile * cfg)
{
  unsigned int D.23388;
  unsigned int D.23389;
  struct MonoBasicBlock * D.23390;
  int D.23391;
  int D.23392;
  int D.23393;
  short unsigned int D.23394;
  int D.23395;
  int D.23396;
  signed char D.23397;
  int D.23398;
  long unsigned int D.23399;
  long unsigned int D.23400;
  long unsigned int D.23401;
  int D.23402;
  long unsigned int D.23403;
  long unsigned int D.23404;
  short unsigned int D.23405;
  int D.23408;
  long unsigned int D.23409;
  long unsigned int D.23410;
  long unsigned int D.23411;
  int D.23412;
  long unsigned int D.23413;
  long unsigned int D.23414;
  int D.23415;
  char D.23416;
  struct MonoInst * iftmp.27;
  unsigned int D.23422;
  unsigned int D.23423;
  struct MonoInst * * D.23426;
  long unsigned int D.23427;
  struct MonoInst * * D.23428;
  long unsigned int D.23432;
  long unsigned int D.23433;
  long unsigned int D.23434;
  long unsigned int D.23435;
  struct MonoBitSet * D.23438;
  long int D.23439;
  long unsigned int D.23440;
  long unsigned int D.23441;
  long unsigned int D.23442;
  int D.23443;
  int D.23444;
  long unsigned int D.23445;
  long unsigned int D.23446;
  struct MonoInst * D.23449;
  unsigned char D.23452;
  int D.23453;
  int D.23454;
  long unsigned int D.23457;
  long unsigned int D.23458;
  unsigned char D.23461;
  short unsigned int D.23466;
  struct MonoMethodVar * D.23468;
  long unsigned int D.23469;
  struct MonoMethodVar * D.23470;
  int D.23471;
  int D.23472;
  struct MonoBitSet * used;
  struct MonoInst * ins;
  struct MonoBasicBlock * initlocals_bb;

  D.23388 = cfg->next_vreg;
  D.23389 = D.23388 + 1;
  used = mono_bitset_new (D.23389, 0);
  mono_bitset_clear_all (used);
  D.23390 = cfg->bb_entry;
  initlocals_bb = D.23390->next_bb;
  ins = initlocals_bb->code;
  goto <D.22557>;
  <D.22556>:
  {
    int num_sregs;
    int i;
    int sregs[3];

    try
      {
        D.23391 = ins->sreg1;
        sregs[0] = D.23391;
        D.23392 = ins->sreg2;
        sregs[1] = D.23392;
        D.23393 = ins->sreg3;
        sregs[2] = D.23393;
        D.23394 = ins->opcode;
        D.23395 = (int) D.23394;
        D.23396 = D.23395 + -313;
        D.23397 = ins_sreg_counts[D.23396];
        num_sregs = (int) D.23397;
        i = 0;
        goto <D.22554>;
        <D.22553>:
        D.23398 = sregs[i];
        D.23399 = (long unsigned int) D.23398;
        D.23400 = D.23399 / 64;
        D.23401 = used->data[D.23400];
        D.23398 = sregs[i];
        D.23402 = D.23398 & 63;
        D.23403 = 1 << D.23402;
        D.23404 = D.23401 | D.23403;
        used->data[D.23400] = D.23404;
        i = i + 1;
        <D.22554>:
        if (i < num_sregs) goto <D.22553>; else goto <D.22555>;
        <D.22555>:
        D.23394 = ins->opcode;
        D.23405 = D.23394 + 65162;
        if (D.23405 <= 13) goto <D.23406>; else goto <D.23407>;
        <D.23406>:
        D.23408 = ins->dreg;
        D.23409 = (long unsigned int) D.23408;
        D.23410 = D.23409 / 64;
        D.23411 = used->data[D.23410];
        D.23408 = ins->dreg;
        D.23412 = D.23408 & 63;
        D.23413 = 1 << D.23412;
        D.23414 = D.23411 | D.23413;
        used->data[D.23410] = D.23414;
        <D.23407>:
      }
    finally
      {
        sregs = {CLOBBER};
      }
  }
  ins = ins->next;
  <D.22557>:
  if (ins != 0B) goto <D.22556>; else goto <D.22558>;
  <D.22558>:
  ins = initlocals_bb->code;
  goto <D.22563>;
  <D.22562>:
  {
    const char * spec;

    D.23394 = ins->opcode;
    D.23395 = (int) D.23394;
    D.23396 = D.23395 + -313;
    D.23415 = D.23396 * 4;
    spec = &ins_info[D.23415];
    D.23416 = *spec;
    if (D.23416 != 32) goto <D.23417>; else goto <D.23418>;
    <D.23417>:
    D.23394 = ins->opcode;
    D.23405 = D.23394 + 65162;
    if (D.23405 > 13) goto <D.23419>; else goto <D.23420>;
    <D.23419>:
    {
      struct MonoInst * var;

      D.23408 = ins->dreg;
      D.23422 = (unsigned int) D.23408;
      D.23423 = cfg->vreg_to_inst_len;
      if (D.23422 < D.23423) goto <D.23424>; else goto <D.23425>;
      <D.23424>:
      D.23426 = cfg->vreg_to_inst;
      D.23408 = ins->dreg;
      D.23409 = (long unsigned int) D.23408;
      D.23427 = D.23409 * 8;
      D.23428 = D.23426 + D.23427;
      iftmp.27 = *D.23428;
      goto <D.23429>;
      <D.23425>:
      iftmp.27 = 0B;
      <D.23429>:
      var = iftmp.27;
      if (var != 0B) goto <D.23430>; else goto <D.23431>;
      <D.23430>:
      D.23408 = ins->dreg;
      D.23409 = (long unsigned int) D.23408;
      D.23432 = D.23409 / 64;
      D.23433 = used->data[D.23432];
      D.23408 = ins->dreg;
      D.23412 = D.23408 & 63;
      D.23434 = D.23433 >> D.23412;
      D.23435 = D.23434 & 1;
      if (D.23435 == 0) goto <D.23436>; else goto <D.23437>;
      <D.23436>:
      D.23438 = initlocals_bb->live_out_set;
      D.23439 = var->data.op[0].const_val;
      D.23440 = (long unsigned int) D.23439;
      D.23441 = D.23440 / 64;
      D.23442 = D.23438->data[D.23441];
      D.23439 = var->data.op[0].const_val;
      D.23443 = (int) D.23439;
      D.23444 = D.23443 & 63;
      D.23445 = D.23442 >> D.23444;
      D.23446 = D.23445 & 1;
      if (D.23446 == 0) goto <D.23447>; else goto <D.23448>;
      <D.23447>:
      D.23449 = cfg->ret;
      if (D.23449 != var) goto <D.23450>; else goto <D.23451>;
      <D.23450>:
      D.23452 = var->flags;
      D.23453 = (int) D.23452;
      D.23454 = D.23453 & 20;
      if (D.23454 == 0) goto <D.23455>; else goto <D.23456>;
      <D.23455>:
      D.23457 = BIT_FIELD_REF <*cfg, 64, 5568>;
      D.23458 = D.23457 & 4503599627370496;
      if (D.23458 != 0) goto <D.23459>; else goto <D.23460>;
      <D.23459>:
      D.23461 = var->type;
      if (D.23461 == 6) goto <D.23462>; else goto <D.23463>;
      <D.23462>:
      // predicted unlikely by continue predictor.
      goto <D.22561>;
      <D.23463>:
      <D.23460>:
      D.23394 = ins->opcode;
      D.23466 = D.23394 + 65174;
      if (D.23466 <= 1) goto <D.23464>; else goto <D.23467>;
      <D.23467>:
      D.23394 = ins->opcode;
      if (D.23394 == 365) goto <D.23464>; else goto <D.23465>;
      <D.23464>:
      ins->opcode = 316;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.23393 = ins->sreg3;
      ins->sreg2 = D.23393;
      D.23392 = ins->sreg2;
      ins->sreg1 = D.23392;
      D.23468 = cfg->vars;
      D.23439 = var->data.op[0].const_val;
      D.23440 = (long unsigned int) D.23439;
      D.23469 = D.23440 * 80;
      D.23470 = D.23468 + D.23469;
      D.23468 = cfg->vars;
      D.23439 = var->data.op[0].const_val;
      D.23440 = (long unsigned int) D.23439;
      D.23469 = D.23440 * 80;
      D.23470 = D.23468 + D.23469;
      D.23471 = D.23470->spill_costs;
      D.23472 = D.23471 + -1;
      D.23470->spill_costs = D.23472;
      <D.23465>:
      <D.23456>:
      <D.23451>:
      <D.23448>:
      <D.23437>:
      <D.23431>:
    }
    <D.23420>:
    <D.23418>:
  }
  <D.22561>:
  ins = ins->next;
  <D.22563>:
  if (ins != 0B) goto <D.22562>; else goto <D.22564>;
  <D.22564>:
  monoeg_g_free (used);
}


mono_analyze_liveness2 (struct MonoCompile * cfg)
{
  unsigned int disabled.28;
  const gchar * D.23476;
  _Bool D.23477;
  unsigned int disabled.29;
  unsigned int D.23481;
  struct MonoMethod * D.23484;
  char * D.23485;
  unsigned int D.23486;
  long unsigned int D.23487;
  long unsigned int D.23488;
  struct MonoMemPool * D.23489;
  long unsigned int D.23490;
  unsigned int D.23491;
  unsigned int D.23492;
  struct MonoMethodVar * D.23493;
  long unsigned int D.23494;
  long unsigned int D.23495;
  void * D.23496;
  unsigned int D.23497;
  unsigned int D.23498;
  struct MonoBasicBlock * * D.23499;
  long unsigned int D.23500;
  long unsigned int D.23501;
  struct MonoBasicBlock * * D.23502;
  int D.23503;
  int D.23504;
  unsigned int bnum.30;
  sizetype D.23508;
  sizetype D.23509;
  sizetype D.23510;
  struct MonoBasicBlock * * D.23511;
  struct MonoBasicBlock * D.23512;
  int D.23513;
  int D.23514;
  int D.23518;
  long unsigned int D.23519;
  long unsigned int D.23520;
  struct MonoBitSet * D.23521;
  unsigned int j.31;
  unsigned int D.23523;
  long unsigned int D.23524;
  struct MonoInst * * D.23529;
  long unsigned int D.23530;
  long unsigned int D.23531;
  struct MonoInst * * D.23532;
  struct MonoInst * D.23533;
  int D.23534;
  long unsigned int D.23535;
  gint32 * D.23536;
  struct MonoInst * D.23537;
  long int D.23540;
  long unsigned int D.23541;
  long unsigned int D.23542;
  gint32 * D.23543;
  long unsigned int D.23546;
  unsigned int D.23547;
  unsigned int D.23548;
  long unsigned int D.23549;
  long unsigned int D.23550;
  long unsigned int D.23551;
  struct MonoInst * * D.23552;
  long unsigned int D.23553;
  long unsigned int D.23554;
  struct MonoInst * * D.23555;
  long unsigned int D.23556;
  gint32 * D.23557;
  int D.23558;
  long unsigned int D.23563;
  struct MonoInst * * D.23564;
  struct MonoInst * D.23565;
  int D.23566;
  struct MonoLiveInterval * D.23567;
  long unsigned int D.23568;
  unsigned int D.23569;
  long unsigned int D.23570;
  long unsigned int D.23571;
  struct MonoInst * * D.23572;
  struct MonoInst * D.23573;
  short unsigned int D.23574;
  struct MonoLiveInterval * D.23577;
  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.23474>; else goto <D.23475>;
  <D.23474>:
  D.23476 = monoeg_g_getenv ("DISABLED");
  D.23477 = D.23476 != 0B;
  disabled.29 = (unsigned int) D.23477;
  disabled = disabled.29;
  <D.23475>:
  disabled.28 = disabled;
  if (disabled.28 != 0) goto <D.23479>; else goto <D.23480>;
  <D.23479>:
  return;
  <D.23480>:
  D.23481 = cfg->verbose_level;
  if (D.23481 > 1) goto <D.23482>; else goto <D.23483>;
  <D.23482>:
  D.23484 = cfg->method;
  D.23485 = mono_method_full_name (D.23484, 1);
  printf ("LIVENESS 2 %s\n", D.23485);
  <D.23483>:
  D.23486 = cfg->num_varinfo;
  max_vars = (int) D.23486;
  D.23487 = (long unsigned int) max_vars;
  D.23488 = D.23487 * 4;
  last_use = monoeg_malloc0 (D.23488);
  reverse_len = 1024;
  D.23489 = cfg->mempool;
  D.23490 = (long unsigned int) reverse_len;
  D.23491 = (unsigned int) D.23490;
  D.23492 = D.23491 * 8;
  reverse = mono_mempool_alloc (D.23489, D.23492);
  idx = 0;
  goto <D.22657>;
  <D.22656>:
  {
    struct MonoMethodVar * vi;

    D.23493 = cfg->vars;
    D.23494 = (long unsigned int) idx;
    D.23495 = D.23494 * 80;
    vi = D.23493 + D.23495;
    D.23489 = cfg->mempool;
    D.23496 = mono_mempool_alloc0 (D.23489, 16);
    vi->interval = D.23496;
  }
  idx = idx + 1;
  <D.22657>:
  if (idx < max_vars) goto <D.22656>; else goto <D.22658>;
  <D.22658>:
  D.23497 = cfg->num_bblocks;
  D.23498 = D.23497 + 4294967295;
  bnum = (int) D.23498;
  goto <D.22683>;
  <D.22682>:
  {
    struct MonoBasicBlock * bb;
    struct MonoInst * ins;

    D.23499 = cfg->bblocks;
    D.23500 = (long unsigned int) bnum;
    D.23501 = D.23500 * 8;
    D.23502 = D.23499 + D.23501;
    bb = *D.23502;
    D.23503 = bb->dfn;
    D.23504 = D.23503 << 16;
    block_from = D.23504 + 1;
    bnum.30 = (unsigned int) bnum;
    D.23497 = cfg->num_bblocks;
    D.23498 = D.23497 + 4294967295;
    if (bnum.30 < D.23498) goto <D.23506>; else goto <D.23507>;
    <D.23506>:
    D.23499 = cfg->bblocks;
    D.23508 = (sizetype) bnum;
    D.23509 = D.23508 + 1;
    D.23510 = D.23509 * 8;
    D.23511 = D.23499 + D.23510;
    D.23512 = *D.23511;
    D.23513 = D.23512->dfn;
    D.23514 = D.23513 << 16;
    block_to = D.23514 + 1;
    goto <D.23515>;
    <D.23507>:
    D.23503 = bb->dfn;
    D.23504 = D.23503 << 16;
    block_to = D.23504 + 65535;
    <D.23515>:
    D.23481 = cfg->verbose_level;
    if (D.23481 > 1) goto <D.23516>; else goto <D.23517>;
    <D.23516>:
    D.23518 = bb->block_num;
    printf ("LIVENESS BLOCK BB%d:\n", D.23518);
    <D.23517>:
    D.23487 = (long unsigned int) max_vars;
    D.23488 = D.23487 * 4;
    memset (last_use, 0, D.23488);
    D.23487 = (long unsigned int) max_vars;
    D.23519 = D.23487 + 63;
    D.23520 = D.23519 / 64;
    max = (int) D.23520;
    j = 0;
    goto <D.22667>;
    <D.22666>:
    {
      gsize bits_out;
      int k;

      D.23521 = bb->live_out_set;
      bits_out = D.23521->data[j];
      j.31 = (unsigned int) j;
      D.23523 = j.31 * 64;
      k = (int) D.23523;
      goto <D.22664>;
      <D.22663>:
      D.23524 = bits_out & 1;
      if (D.23524 != 0) goto <D.23525>; else goto <D.23526>;
      <D.23525>:
      D.23481 = cfg->verbose_level;
      if (D.23481 > 1) goto <D.23527>; else goto <D.23528>;
      <D.23527>:
      D.23529 = cfg->varinfo;
      D.23530 = (long unsigned int) k;
      D.23531 = D.23530 * 8;
      D.23532 = D.23529 + D.23531;
      D.23533 = *D.23532;
      D.23534 = D.23533->dreg;
      printf ("Var R%d live at exit, set last_use to %x\n", D.23534, block_to);
      <D.23528>:
      D.23530 = (long unsigned int) k;
      D.23535 = D.23530 * 4;
      D.23536 = last_use + D.23535;
      *D.23536 = block_to;
      <D.23526>:
      bits_out = bits_out >> 1;
      k = k + 1;
      <D.22664>:
      if (bits_out != 0) goto <D.22663>; else goto <D.22665>;
      <D.22665>:
    }
    j = j + 1;
    <D.22667>:
    if (j < max) goto <D.22666>; else goto <D.22668>;
    <D.22668>:
    D.23537 = cfg->ret;
    if (D.23537 != 0B) goto <D.23538>; else goto <D.23539>;
    <D.23538>:
    D.23537 = cfg->ret;
    D.23540 = D.23537->data.op[0].const_val;
    D.23541 = (long unsigned int) D.23540;
    D.23542 = D.23541 * 4;
    D.23543 = last_use + D.23542;
    *D.23543 = block_to;
    <D.23539>:
    nins = 0;
    pos = block_from;
    ins = bb->code;
    goto <D.22672>;
    <D.22671>:
    if (nins >= reverse_len) goto <D.23544>; else goto <D.23545>;
    <D.23544>:
    {
      int new_reverse_len;
      struct MonoInst * * new_reverse;

      new_reverse_len = reverse_len * 2;
      D.23489 = cfg->mempool;
      D.23546 = (long unsigned int) new_reverse_len;
      D.23547 = (unsigned int) D.23546;
      D.23548 = D.23547 * 8;
      new_reverse = mono_mempool_alloc (D.23489, D.23548);
      D.23490 = (long unsigned int) reverse_len;
      D.23549 = D.23490 * 8;
      memcpy (new_reverse, reverse, D.23549);
      reverse = new_reverse;
      reverse_len = new_reverse_len;
    }
    <D.23545>:
    D.23550 = (long unsigned int) nins;
    D.23551 = D.23550 * 8;
    D.23552 = reverse + D.23551;
    *D.23552 = ins;
    ins = ins->next;
    nins = nins + 1;
    pos = pos + 1;
    <D.22672>:
    if (ins != 0B) goto <D.22671>; else goto <D.22673>;
    <D.22673>:
    i = nins + -1;
    goto <D.22676>;
    <D.22675>:
    {
      struct MonoInst * ins;

      D.23553 = (long unsigned int) i;
      D.23554 = D.23553 * 8;
      D.23555 = reverse + D.23554;
      ins = *D.23555;
      update_liveness2 (cfg, ins, 0, pos, last_use);
      pos = pos + -1;
    }
    i = i + -1;
    <D.22676>:
    if (i >= 0) goto <D.22675>; else goto <D.22677>;
    <D.22677>:
    idx = 0;
    goto <D.22680>;
    <D.22679>:
    {
      struct MonoMethodVar * vi;

      D.23493 = cfg->vars;
      D.23494 = (long unsigned int) idx;
      D.23495 = D.23494 * 80;
      vi = D.23493 + D.23495;
      D.23494 = (long unsigned int) idx;
      D.23556 = D.23494 * 4;
      D.23557 = last_use + D.23556;
      D.23558 = *D.23557;
      if (D.23558 != 0) goto <D.23559>; else goto <D.23560>;
      <D.23559>:
      D.23481 = cfg->verbose_level;
      if (D.23481 > 1) goto <D.23561>; else goto <D.23562>;
      <D.23561>:
      D.23529 = cfg->varinfo;
      D.23494 = (long unsigned int) idx;
      D.23563 = D.23494 * 8;
      D.23564 = D.23529 + D.23563;
      D.23565 = *D.23564;
      D.23566 = D.23565->dreg;
      D.23529 = cfg->varinfo;
      D.23494 = (long unsigned int) idx;
      D.23563 = D.23494 * 8;
      D.23564 = D.23529 + D.23563;
      D.23565 = *D.23564;
      D.23566 = D.23565->dreg;
      D.23494 = (long unsigned int) idx;
      D.23556 = D.23494 * 4;
      D.23557 = last_use + D.23556;
      D.23558 = *D.23557;
      printf ("Var R%d live at enter, add range to R%d: [%x, %x)\n", D.23566, D.23566, block_from, D.23558);
      <D.23562>:
      D.23567 = vi->interval;
      D.23494 = (long unsigned int) idx;
      D.23556 = D.23494 * 4;
      D.23557 = last_use + D.23556;
      D.23558 = *D.23557;
      mono_linterval_add_range (cfg, D.23567, block_from, D.23558);
      <D.23560>:
    }
    idx = idx + 1;
    <D.22680>:
    if (idx < max_vars) goto <D.22679>; else goto <D.22681>;
    <D.22681>:
  }
  bnum = bnum + -1;
  <D.22683>:
  if (bnum >= 0) goto <D.22682>; else goto <D.22684>;
  <D.22684>:
  i = 0;
  goto <D.22687>;
  <D.22686>:
  {
    struct MonoMethodVar * vi;

    D.23493 = cfg->vars;
    D.23553 = (long unsigned int) i;
    D.23568 = D.23553 * 80;
    vi = D.23493 + D.23568;
    D.23529 = cfg->varinfo;
    D.23569 = vi->idx;
    D.23570 = (long unsigned int) D.23569;
    D.23571 = D.23570 * 8;
    D.23572 = D.23529 + D.23571;
    D.23573 = *D.23572;
    D.23574 = D.23573->opcode;
    if (D.23574 == 330) goto <D.23575>; else goto <D.23576>;
    <D.23575>:
    D.23577 = vi->interval;
    mono_linterval_add_range (cfg, D.23577, 0, 1);
    <D.23576>:
  }
  i = i + 1;
  <D.22687>:
  if (i < max_vars) goto <D.22686>; else goto <D.22688>;
  <D.22688>:
  monoeg_g_free (last_use);
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.23581;
  int D.23586;
  void * D.23588;
  long unsigned int D.23589;

  D.23581 = __builtin_constant_p (__len);
  if (D.23581 != 0) goto <D.23582>; else goto <D.23583>;
  <D.23582>:
  if (__len == 0) goto <D.23584>; else goto <D.23585>;
  <D.23584>:
  D.23586 = __builtin_constant_p (__ch);
  if (D.23586 == 0) goto <D.23579>; else goto <D.23587>;
  <D.23587>:
  if (__ch != 0) goto <D.23579>; else goto <D.23580>;
  <D.23579>:
  __warn_memset_zero_len ();
  D.23588 = __dest;
  return D.23588;
  <D.23580>:
  <D.23585>:
  <D.23583>:
  D.23589 = __builtin_object_size (__dest, 0);
  D.23588 = __builtin___memset_chk (__dest, __ch, __len, D.23589);
  return D.23588;
}


update_liveness2 (struct MonoCompile * cfg, struct MonoInst * ins, gboolean set_volatile, int inst_num, gint32 * last_use)
{
  short unsigned int D.23591;
  int D.23592;
  int D.23593;
  int D.23594;
  unsigned int D.23595;
  char D.23600;
  int D.23603;
  unsigned int D.23604;
  unsigned int D.23605;
  struct MonoInst * * D.23608;
  long unsigned int D.23609;
  long unsigned int D.23610;
  struct MonoInst * * D.23611;
  struct MonoInst * D.23612;
  struct MonoInst * iftmp.32;
  long int D.23619;
  struct MonoMethodVar * D.23620;
  long unsigned int D.23621;
  long unsigned int D.23622;
  short unsigned int D.23623;
  long unsigned int D.23626;
  gint32 * D.23627;
  int D.23628;
  struct MonoLiveInterval * D.23638;
  struct MonoInst * D.23642;
  unsigned char D.23645;
  int D.23646;
  int D.23647;
  short unsigned int D.23650;
  int D.23652;
  int D.23657;
  int D.23658;
  int D.23661;
  int D.23662;
  signed char D.23663;
  int D.23664;
  sizetype D.23665;
  const char * D.23666;
  char D.23667;
  unsigned int sreg.33;
  long unsigned int D.23673;
  long unsigned int D.23674;
  struct MonoInst * * D.23675;
  struct MonoInst * D.23676;
  struct MonoInst * iftmp.34;
  long int D.23683;
  long unsigned int D.23684;
  long unsigned int D.23685;
  gint32 * D.23686;
  int D.23687;
  const char * spec;
  int sreg;
  int num_sregs;
  int i;
  int sregs[3];

  try
    {
      D.23591 = ins->opcode;
      D.23592 = (int) D.23591;
      D.23593 = D.23592 + -313;
      D.23594 = D.23593 * 4;
      spec = &ins_info[D.23594];
      D.23595 = cfg->verbose_level;
      if (D.23595 > 1) goto <D.23596>; else goto <D.23597>;
      <D.23596>:
      printf ("\t%x: ", inst_num);
      mono_print_ins (ins);
      <D.23597>:
      D.23591 = ins->opcode;
      if (D.23591 == 316) goto <D.23598>; else goto <D.23599>;
      <D.23598>:
      return;
      <D.23599>:
      D.23600 = *spec;
      if (D.23600 != 32) goto <D.23601>; else goto <D.23602>;
      <D.23601>:
      D.23603 = ins->dreg;
      D.23604 = (unsigned int) D.23603;
      D.23605 = cfg->vreg_to_inst_len;
      if (D.23604 < D.23605) goto <D.23606>; else goto <D.23607>;
      <D.23606>:
      D.23608 = cfg->vreg_to_inst;
      D.23603 = ins->dreg;
      D.23609 = (long unsigned int) D.23603;
      D.23610 = D.23609 * 8;
      D.23611 = D.23608 + D.23610;
      D.23612 = *D.23611;
      if (D.23612 != 0B) goto <D.23613>; else goto <D.23614>;
      <D.23613>:
      {
        struct MonoInst * var;
        int idx;
        struct MonoMethodVar * vi;

        D.23603 = ins->dreg;
        D.23604 = (unsigned int) D.23603;
        D.23605 = cfg->vreg_to_inst_len;
        if (D.23604 < D.23605) goto <D.23616>; else goto <D.23617>;
        <D.23616>:
        D.23608 = cfg->vreg_to_inst;
        D.23603 = ins->dreg;
        D.23609 = (long unsigned int) D.23603;
        D.23610 = D.23609 * 8;
        D.23611 = D.23608 + D.23610;
        iftmp.32 = *D.23611;
        goto <D.23618>;
        <D.23617>:
        iftmp.32 = 0B;
        <D.23618>:
        var = iftmp.32;
        D.23619 = var->data.op[0].const_val;
        idx = (int) D.23619;
        D.23620 = cfg->vars;
        D.23621 = (long unsigned int) idx;
        D.23622 = D.23621 * 80;
        vi = D.23620 + D.23622;
        D.23591 = ins->opcode;
        D.23623 = D.23591 + 65162;
        if (D.23623 <= 13) goto <D.23624>; else goto <D.23625>;
        <D.23624>:
        D.23621 = (long unsigned int) idx;
        D.23626 = D.23621 * 4;
        D.23627 = last_use + D.23626;
        D.23628 = *D.23627;
        if (D.23628 == 0) goto <D.23629>; else goto <D.23630>;
        <D.23629>:
        D.23595 = cfg->verbose_level;
        if (D.23595 > 1) goto <D.23631>; else goto <D.23632>;
        <D.23631>:
        D.23603 = ins->dreg;
        printf ("\tlast use of R%d set to %x\n", D.23603, inst_num);
        <D.23632>:
        D.23621 = (long unsigned int) idx;
        D.23626 = D.23621 * 4;
        D.23627 = last_use + D.23626;
        *D.23627 = inst_num;
        <D.23630>:
        goto <D.23633>;
        <D.23625>:
        D.23621 = (long unsigned int) idx;
        D.23626 = D.23621 * 4;
        D.23627 = last_use + D.23626;
        D.23628 = *D.23627;
        if (D.23628 > 0) goto <D.23634>; else goto <D.23635>;
        <D.23634>:
        D.23595 = cfg->verbose_level;
        if (D.23595 > 1) goto <D.23636>; else goto <D.23637>;
        <D.23636>:
        D.23603 = ins->dreg;
        D.23621 = (long unsigned int) idx;
        D.23626 = D.23621 * 4;
        D.23627 = last_use + D.23626;
        D.23628 = *D.23627;
        printf ("\tadd range to R%d: [%x, %x)\n", D.23603, inst_num, D.23628);
        <D.23637>:
        D.23638 = vi->interval;
        D.23621 = (long unsigned int) idx;
        D.23626 = D.23621 * 4;
        D.23627 = last_use + D.23626;
        D.23628 = *D.23627;
        mono_linterval_add_range (cfg, D.23638, inst_num, D.23628);
        D.23621 = (long unsigned int) idx;
        D.23626 = D.23621 * 4;
        D.23627 = last_use + D.23626;
        *D.23627 = 0;
        goto <D.23639>;
        <D.23635>:
        D.23642 = cfg->ret;
        if (D.23642 != var) goto <D.23643>; else goto <D.23644>;
        <D.23643>:
        D.23645 = var->flags;
        D.23646 = (int) D.23645;
        D.23647 = D.23646 & 20;
        if (D.23647 == 0) goto <D.23648>; else goto <D.23649>;
        <D.23648>:
        D.23591 = ins->opcode;
        D.23650 = D.23591 + 65174;
        if (D.23650 <= 1) goto <D.23640>; else goto <D.23651>;
        <D.23651>:
        D.23591 = ins->opcode;
        if (D.23591 == 365) goto <D.23640>; else goto <D.23641>;
        <D.23640>:
        D.23645 = var->flags;
        D.23646 = (int) D.23645;
        D.23652 = D.23646 & 4;
        if (D.23652 == 0) goto <D.23653>; else goto <D.23654>;
        <D.23653>:
        D.23595 = cfg->verbose_level;
        if (D.23595 > 1) goto <D.23655>; else goto <D.23656>;
        <D.23655>:
        D.23603 = ins->dreg;
        printf ("\tdead def of R%d, eliminated\n", D.23603);
        <D.23656>:
        ins->opcode = 316;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.23657 = ins->sreg3;
        ins->sreg2 = D.23657;
        D.23658 = ins->sreg2;
        ins->sreg1 = D.23658;
        return;
        <D.23654>:
        <D.23641>:
        <D.23649>:
        <D.23644>:
        D.23595 = cfg->verbose_level;
        if (D.23595 > 1) goto <D.23659>; else goto <D.23660>;
        <D.23659>:
        D.23603 = ins->dreg;
        D.23603 = ins->dreg;
        D.23661 = inst_num + 1;
        printf ("\tdead def of R%d, add range to R%d: [%x, %x]\n", D.23603, D.23603, inst_num, D.23661);
        <D.23660>:
        D.23638 = vi->interval;
        D.23661 = inst_num + 1;
        mono_linterval_add_range (cfg, D.23638, inst_num, D.23661);
        <D.23639>:
        <D.23633>:
      }
      <D.23614>:
      <D.23607>:
      <D.23602>:
      D.23662 = ins->sreg1;
      sregs[0] = D.23662;
      D.23658 = ins->sreg2;
      sregs[1] = D.23658;
      D.23657 = ins->sreg3;
      sregs[2] = D.23657;
      D.23591 = ins->opcode;
      D.23592 = (int) D.23591;
      D.23593 = D.23592 + -313;
      D.23663 = ins_sreg_counts[D.23593];
      num_sregs = (int) D.23663;
      i = 0;
      goto <D.22636>;
      <D.22635>:
      sreg = sregs[i];
      D.23664 = i + 1;
      D.23665 = (sizetype) D.23664;
      D.23666 = spec + D.23665;
      D.23667 = *D.23666;
      if (D.23667 != 32) goto <D.23668>; else goto <D.23669>;
      <D.23668>:
      sreg.33 = (unsigned int) sreg;
      D.23605 = cfg->vreg_to_inst_len;
      if (sreg.33 < D.23605) goto <D.23671>; else goto <D.23672>;
      <D.23671>:
      D.23608 = cfg->vreg_to_inst;
      D.23673 = (long unsigned int) sreg;
      D.23674 = D.23673 * 8;
      D.23675 = D.23608 + D.23674;
      D.23676 = *D.23675;
      if (D.23676 != 0B) goto <D.23677>; else goto <D.23678>;
      <D.23677>:
      {
        struct MonoInst * var;
        int idx;

        sreg.33 = (unsigned int) sreg;
        D.23605 = cfg->vreg_to_inst_len;
        if (sreg.33 < D.23605) goto <D.23680>; else goto <D.23681>;
        <D.23680>:
        D.23608 = cfg->vreg_to_inst;
        D.23673 = (long unsigned int) sreg;
        D.23674 = D.23673 * 8;
        D.23675 = D.23608 + D.23674;
        iftmp.34 = *D.23675;
        goto <D.23682>;
        <D.23681>:
        iftmp.34 = 0B;
        <D.23682>:
        var = iftmp.34;
        D.23683 = var->data.op[0].const_val;
        idx = (int) D.23683;
        D.23684 = (long unsigned int) idx;
        D.23685 = D.23684 * 4;
        D.23686 = last_use + D.23685;
        D.23687 = *D.23686;
        if (D.23687 == 0) goto <D.23688>; else goto <D.23689>;
        <D.23688>:
        D.23595 = cfg->verbose_level;
        if (D.23595 > 1) goto <D.23690>; else goto <D.23691>;
        <D.23690>:
        printf ("\tlast use of R%d set to %x\n", sreg, inst_num);
        <D.23691>:
        D.23684 = (long unsigned int) idx;
        D.23685 = D.23684 * 4;
        D.23686 = last_use + D.23685;
        *D.23686 = inst_num;
        <D.23689>:
      }
      <D.23678>:
      <D.23672>:
      <D.23669>:
      i = i + 1;
      <D.22636>:
      if (i < num_sregs) goto <D.22635>; else goto <D.22637>;
      <D.22637>:
    }
  finally
    {
      sregs = {CLOBBER};
    }
}


mono_linterval_add_range (struct MonoCompile * cfg, struct MonoLiveInterval * interval, int from, int to)
{
  _Bool D.23695;
  long int D.23696;
  long int D.23697;
  int iftmp.35;
  struct MonoLiveRange2 * D.23703;
  int D.23705;
  _Bool D.23708;
  long int D.23709;
  long int D.23710;
  int D.23714;
  int D.23718;
  struct MonoMemPool * D.23724;
  struct MonoLiveRange2 * prev_range;
  struct MonoLiveRange2 * next_range;
  struct MonoLiveRange2 * new_range;

  D.23695 = to < from;
  D.23696 = (long int) D.23695;
  D.23697 = __builtin_expect (D.23696, 0);
  if (D.23697 != 0) goto <D.23698>; else goto <D.23699>;
  <D.23698>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "liveness.c", 637, "to >= from");
  <D.23699>:
  D.23703 = interval->range;
  if (D.23703 != 0B) goto <D.23704>; else goto <D.23701>;
  <D.23704>:
  D.23703 = interval->range;
  D.23705 = D.23703->from;
  if (D.23705 > from) goto <D.23706>; else goto <D.23701>;
  <D.23706>:
  D.23703 = interval->range;
  D.23705 = D.23703->from;
  if (D.23705 == to) goto <D.23707>; else goto <D.23701>;
  <D.23707>:
  iftmp.35 = 1;
  goto <D.23702>;
  <D.23701>:
  iftmp.35 = 0;
  <D.23702>:
  D.23708 = iftmp.35 != 0;
  D.23709 = (long int) D.23708;
  D.23710 = __builtin_expect (D.23709, 1);
  if (D.23710 != 0) goto <D.23711>; else goto <D.23712>;
  <D.23711>:
  D.23703 = interval->range;
  D.23703->from = from;
  return;
  <D.23712>:
  prev_range = 0B;
  next_range = interval->range;
  goto <D.22575>;
  <D.22574>:
  prev_range = next_range;
  next_range = next_range->next;
  <D.22575>:
  if (next_range != 0B) goto <D.23713>; else goto <D.22576>;
  <D.23713>:
  D.23714 = next_range->from;
  if (D.23714 <= from) goto <D.22574>; else goto <D.22576>;
  <D.22576>:
  if (prev_range != 0B) goto <D.23717>; else goto <D.23715>;
  <D.23717>:
  D.23718 = prev_range->to;
  if (D.23718 == from) goto <D.23719>; else goto <D.23715>;
  <D.23719>:
  prev_range->to = to;
  goto <D.23716>;
  <D.23715>:
  if (next_range != 0B) goto <D.23722>; else goto <D.23720>;
  <D.23722>:
  D.23714 = next_range->from;
  if (D.23714 == to) goto <D.23723>; else goto <D.23720>;
  <D.23723>:
  next_range->from = from;
  goto <D.23721>;
  <D.23720>:
  D.23724 = cfg->mempool;
  new_range = mono_mempool_alloc (D.23724, 16);
  new_range->from = from;
  new_range->to = to;
  new_range->next = 0B;
  if (prev_range != 0B) goto <D.23725>; else goto <D.23726>;
  <D.23725>:
  prev_range->next = new_range;
  goto <D.23727>;
  <D.23726>:
  interval->range = new_range;
  <D.23727>:
  if (next_range != 0B) goto <D.23728>; else goto <D.23729>;
  <D.23728>:
  new_range->next = next_range;
  goto <D.23730>;
  <D.23729>:
  interval->last_range = new_range;
  <D.23730>:
  <D.23721>:
  <D.23716>:
}


mono_linterval_print (struct MonoLiveInterval * interval)
{
  int D.23732;
  int D.23733;
  struct MonoLiveRange2 * range;

  range = interval->range;
  goto <D.22582>;
  <D.22581>:
  D.23732 = range->from;
  D.23733 = range->to;
  printf ("[%x-%x] ", D.23732, D.23733);
  range = range->next;
  <D.22582>:
  if (range != 0B) goto <D.22581>; else goto <D.22583>;
  <D.22583>:
}


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


mono_linterval_covers (struct MonoLiveInterval * interval, int pos)
{
  int D.23734;
  int D.23737;
  gboolean D.23740;
  struct MonoLiveRange2 * range;

  range = interval->range;
  goto <D.22593>;
  <D.22592>:
  D.23734 = range->from;
  if (D.23734 <= pos) goto <D.23735>; else goto <D.23736>;
  <D.23735>:
  D.23737 = range->to;
  if (D.23737 >= pos) goto <D.23738>; else goto <D.23739>;
  <D.23738>:
  D.23740 = 1;
  return D.23740;
  <D.23739>:
  <D.23736>:
  D.23734 = range->from;
  if (D.23734 > pos) goto <D.23741>; else goto <D.23742>;
  <D.23741>:
  D.23740 = 0;
  return D.23740;
  <D.23742>:
  range = range->next;
  <D.22593>:
  if (range != 0B) goto <D.22592>; else goto <D.22594>;
  <D.22594>:
  D.23740 = 0;
  return D.23740;
}


mono_linterval_get_intersect_pos (struct MonoLiveInterval * i1, struct MonoLiveInterval * i2)
{
  int D.23744;
  int D.23745;
  int D.23748;
  int D.23749;
  gint32 D.23754;
  struct MonoLiveRange2 * r1;
  struct MonoLiveRange2 * r2;

  r1 = i1->range;
  goto <D.22605>;
  <D.22604>:
  r2 = i2->range;
  goto <D.22602>;
  <D.22601>:
  D.23744 = r2->to;
  D.23745 = r1->from;
  if (D.23744 > D.23745) goto <D.23746>; else goto <D.23747>;
  <D.23746>:
  D.23748 = r2->from;
  D.23749 = r1->to;
  if (D.23748 < D.23749) goto <D.23750>; else goto <D.23751>;
  <D.23750>:
  D.23748 = r2->from;
  D.23745 = r1->from;
  if (D.23748 <= D.23745) goto <D.23752>; else goto <D.23753>;
  <D.23752>:
  D.23754 = r1->from;
  return D.23754;
  <D.23753>:
  D.23754 = r2->from;
  return D.23754;
  <D.23751>:
  <D.23747>:
  r2 = r2->next;
  <D.22602>:
  if (r2 != 0B) goto <D.22601>; else goto <D.22603>;
  <D.22603>:
  r1 = r1->next;
  <D.22605>:
  if (r1 != 0B) goto <D.22604>; else goto <D.22606>;
  <D.22606>:
  D.23754 = -1;
  return D.23754;
}


mono_linterval_split (struct MonoCompile * cfg, struct MonoLiveInterval * interval, struct MonoLiveInterval * * i1, struct MonoLiveInterval * * i2, int pos)
{
  int iftmp.36;
  struct MonoLiveRange2 * D.23760;
  int D.23761;
  struct MonoLiveRange2 * D.23763;
  int D.23764;
  _Bool D.23765;
  long int D.23766;
  long int D.23767;
  struct MonoMemPool * D.23770;
  void * D.23771;
  void * D.23772;
  int D.23773;
  struct MonoLiveInterval * D.23776;
  int D.23777;
  int D.23783;
  struct MonoLiveInterval * D.23784;
  struct MonoLiveRange2 * r;

  D.23760 = interval->range;
  D.23761 = D.23760->from;
  if (D.23761 >= pos) goto <D.23757>; else goto <D.23762>;
  <D.23762>:
  D.23763 = interval->last_range;
  D.23764 = D.23763->to;
  if (D.23764 < pos) goto <D.23757>; else goto <D.23758>;
  <D.23757>:
  iftmp.36 = 1;
  goto <D.23759>;
  <D.23758>:
  iftmp.36 = 0;
  <D.23759>:
  D.23765 = iftmp.36 != 0;
  D.23766 = (long int) D.23765;
  D.23767 = __builtin_expect (D.23766, 0);
  if (D.23767 != 0) goto <D.23768>; else goto <D.23769>;
  <D.23768>:
  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.23769>:
  D.23770 = cfg->mempool;
  D.23771 = mono_mempool_alloc0 (D.23770, 16);
  *i1 = D.23771;
  D.23770 = cfg->mempool;
  D.23772 = mono_mempool_alloc0 (D.23770, 16);
  *i2 = D.23772;
  r = interval->range;
  goto <D.22616>;
  <D.22615>:
  D.23773 = r->to;
  if (D.23773 < pos) goto <D.23774>; else goto <D.23775>;
  <D.23774>:
  D.23776 = *i1;
  D.23777 = r->from;
  D.23773 = r->to;
  mono_linterval_add_range (cfg, D.23776, D.23777, D.23773);
  goto <D.23778>;
  <D.23775>:
  D.23777 = r->from;
  if (D.23777 < pos) goto <D.23781>; else goto <D.23779>;
  <D.23781>:
  D.23773 = r->to;
  if (D.23773 >= pos) goto <D.23782>; else goto <D.23779>;
  <D.23782>:
  D.23776 = *i1;
  D.23777 = r->from;
  D.23783 = pos + -1;
  mono_linterval_add_range (cfg, D.23776, D.23777, D.23783);
  D.23784 = *i2;
  D.23773 = r->to;
  mono_linterval_add_range (cfg, D.23784, pos, D.23773);
  goto <D.23780>;
  <D.23779>:
  D.23784 = *i2;
  D.23777 = r->from;
  D.23773 = r->to;
  mono_linterval_add_range (cfg, D.23784, D.23777, D.23773);
  <D.23780>:
  <D.23778>:
  r = r->next;
  <D.22616>:
  if (r != 0B) goto <D.22615>; else goto <D.22617>;
  <D.22617>:
}


mono_analyze_liveness_gc (struct MonoCompile * cfg)
{
  unsigned int D.23785;
  unsigned int D.23788;
  long unsigned int D.23789;
  long unsigned int D.23790;
  unsigned int D.23791;
  long unsigned int D.23792;
  long unsigned int D.23793;
  struct MonoMethodVar * D.23794;
  long unsigned int D.23795;
  long unsigned int D.23796;
  int D.23797;
  long unsigned int D.23798;
  long unsigned int D.23799;
  struct MonoMethodVar * * D.23800;
  struct MonoMemPool * D.23801;
  long unsigned int D.23802;
  unsigned int D.23803;
  unsigned int D.23804;
  int D.23805;
  int D.23806;
  int D.23809;
  struct MonoInst * D.23810;
  long unsigned int D.23813;
  long unsigned int D.23814;
  struct MonoBitSet * D.23815;
  unsigned int j.37;
  unsigned int D.23819;
  long unsigned int D.23820;
  struct MonoInst * * D.23823;
  long unsigned int D.23824;
  long unsigned int D.23825;
  struct MonoInst * * D.23826;
  struct MonoInst * D.23827;
  unsigned char D.23828;
  signed char D.23829;
  long unsigned int D.23834;
  gint32 * D.23835;
  long unsigned int D.23838;
  unsigned int D.23839;
  unsigned int D.23840;
  long unsigned int D.23841;
  long unsigned int D.23842;
  long unsigned int D.23843;
  struct MonoInst * * D.23844;
  long unsigned int D.23845;
  long unsigned int D.23846;
  struct MonoInst * * D.23847;
  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.23785 = cfg->verbose_level;
      if (D.23785 > 1) goto <D.23786>; else goto <D.23787>;
      <D.23786>:
      printf ("\n------------ GC LIVENESS: ----------\n");
      <D.23787>:
      D.23788 = cfg->num_varinfo;
      max_vars = (int) D.23788;
      D.23789 = (long unsigned int) max_vars;
      D.23790 = D.23789 * 4;
      last_use = monoeg_malloc0 (D.23790);
      D.23791 = cfg->next_vreg;
      D.23792 = (long unsigned int) D.23791;
      D.23793 = D.23792 * 8;
      vreg_to_varinfo = monoeg_malloc0 (D.23793);
      idx = 0;
      goto <D.22731>;
      <D.22730>:
      {
        struct MonoMethodVar * vi;

        D.23794 = cfg->vars;
        D.23795 = (long unsigned int) idx;
        D.23796 = D.23795 * 80;
        vi = D.23794 + D.23796;
        D.23797 = vi->vreg;
        D.23798 = (long unsigned int) D.23797;
        D.23799 = D.23798 * 8;
        D.23800 = vreg_to_varinfo + D.23799;
        *D.23800 = vi;
      }
      idx = idx + 1;
      <D.22731>:
      if (idx < max_vars) goto <D.22730>; else goto <D.22732>;
      <D.22732>:
      reverse_len = 1024;
      D.23801 = cfg->mempool;
      D.23802 = (long unsigned int) reverse_len;
      D.23803 = (unsigned int) D.23802;
      D.23804 = D.23803 * 8;
      reverse = mono_mempool_alloc (D.23801, D.23804);
      bb = cfg->bb_entry;
      goto <D.22755>;
      <D.22754>:
      {
        struct MonoInst * ins;

        block_from = bb->real_native_offset;
        D.23805 = bb->native_offset;
        D.23806 = bb->native_length;
        block_to = D.23805 + D.23806;
        D.23785 = cfg->verbose_level;
        if (D.23785 > 1) goto <D.23807>; else goto <D.23808>;
        <D.23807>:
        D.23809 = bb->block_num;
        printf ("GC LIVENESS BB%d:\n", D.23809);
        <D.23808>:
        D.23810 = bb->code;
        if (D.23810 == 0B) goto <D.23811>; else goto <D.23812>;
        <D.23811>:
        // predicted unlikely by continue predictor.
        goto <D.22734>;
        <D.23812>:
        D.23789 = (long unsigned int) max_vars;
        D.23790 = D.23789 * 4;
        memset (last_use, 0, D.23790);
        D.23789 = (long unsigned int) max_vars;
        D.23813 = D.23789 + 63;
        D.23814 = D.23813 / 64;
        max = (int) D.23814;
        j = 0;
        goto <D.22743>;
        <D.22742>:
        {
          gsize bits_out;
          int k;

          D.23815 = bb->live_out_set;
          if (D.23815 == 0B) goto <D.23816>; else goto <D.23817>;
          <D.23816>:
          // predicted unlikely by continue predictor.
          goto <D.22737>;
          <D.23817>:
          D.23815 = bb->live_out_set;
          bits_out = D.23815->data[j];
          j.37 = (unsigned int) j;
          D.23819 = j.37 * 64;
          k = (int) D.23819;
          goto <D.22740>;
          <D.22739>:
          D.23820 = bits_out & 1;
          if (D.23820 != 0) goto <D.23821>; else goto <D.23822>;
          <D.23821>:
          D.23823 = cfg->varinfo;
          D.23824 = (long unsigned int) k;
          D.23825 = D.23824 * 8;
          D.23826 = D.23823 + D.23825;
          D.23827 = *D.23826;
          D.23828 = D.23827->flags;
          D.23829 = (signed char) D.23828;
          if (D.23829 < 0) goto <D.23830>; else goto <D.23831>;
          <D.23830>:
          {
            int vreg;

            D.23823 = cfg->varinfo;
            D.23824 = (long unsigned int) k;
            D.23825 = D.23824 * 8;
            D.23826 = D.23823 + D.23825;
            D.23827 = *D.23826;
            vreg = get_vreg_from_var (cfg, D.23827);
            D.23785 = cfg->verbose_level;
            if (D.23785 > 1) goto <D.23832>; else goto <D.23833>;
            <D.23832>:
            printf ("Var R%d live at exit, last_use set to %x.\n", vreg, block_to);
            <D.23833>:
            D.23824 = (long unsigned int) k;
            D.23834 = D.23824 * 4;
            D.23835 = last_use + D.23834;
            *D.23835 = block_to;
          }
          <D.23831>:
          <D.23822>:
          bits_out = bits_out >> 1;
          k = k + 1;
          <D.22740>:
          if (bits_out != 0) goto <D.22739>; else goto <D.22741>;
          <D.22741>:
        }
        <D.22737>:
        j = j + 1;
        <D.22743>:
        if (j < max) goto <D.22742>; else goto <D.22744>;
        <D.22744>:
        nins = 0;
        pos = block_from;
        ins = bb->code;
        goto <D.22748>;
        <D.22747>:
        if (nins >= reverse_len) goto <D.23836>; else goto <D.23837>;
        <D.23836>:
        {
          int new_reverse_len;
          struct MonoInst * * new_reverse;

          new_reverse_len = reverse_len * 2;
          D.23801 = cfg->mempool;
          D.23838 = (long unsigned int) new_reverse_len;
          D.23839 = (unsigned int) D.23838;
          D.23840 = D.23839 * 8;
          new_reverse = mono_mempool_alloc (D.23801, D.23840);
          D.23802 = (long unsigned int) reverse_len;
          D.23841 = D.23802 * 8;
          memcpy (new_reverse, reverse, D.23841);
          reverse = new_reverse;
          reverse_len = new_reverse_len;
        }
        <D.23837>:
        D.23842 = (long unsigned int) nins;
        D.23843 = D.23842 * 8;
        D.23844 = reverse + D.23843;
        *D.23844 = ins;
        ins = ins->next;
        nins = nins + 1;
        pos = pos + 1;
        <D.22748>:
        if (ins != 0B) goto <D.22747>; else goto <D.22749>;
        <D.22749>:
        callsites = 0B;
        i = nins + -1;
        goto <D.22752>;
        <D.22751>:
        {
          struct MonoInst * ins;

          D.23845 = (long unsigned int) i;
          D.23846 = D.23845 * 8;
          D.23847 = reverse + D.23846;
          ins = *D.23847;
          update_liveness_gc (cfg, bb, ins, last_use, vreg_to_varinfo, &callsites);
        }
        i = i + -1;
        <D.22752>:
        if (i >= 0) goto <D.22751>; else goto <D.22753>;
        <D.22753>:
        callsites.38 = callsites;
        bb->gc_callsites = callsites.38;
      }
      <D.22734>:
      bb = bb->next_bb;
      <D.22755>:
      if (bb != 0B) goto <D.22754>; else goto <D.22756>;
      <D.22756>:
      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.23849;
  int D.23852;
  struct MonoMethodVar * D.23853;
  long int D.23854;
  long unsigned int D.23855;
  long unsigned int D.23856;
  struct MonoMethodVar * D.23857;

  D.23849 = var->opcode;
  if (D.23849 == 366) goto <D.23850>; else goto <D.23851>;
  <D.23850>:
  D.23853 = cfg->vars;
  D.23854 = var->data.op[0].const_val;
  D.23855 = (long unsigned int) D.23854;
  D.23856 = D.23855 * 80;
  D.23857 = D.23853 + D.23856;
  D.23852 = D.23857->vreg;
  return D.23852;
  <D.23851>:
  D.23852 = var->dreg;
  return D.23852;
}


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.23859;
  short unsigned int D.23860;
  long int D.23863;
  long unsigned int D.23864;
  long unsigned int D.23865;
  struct MonoMethodVar * * D.23866;
  unsigned int D.23867;
  unsigned int D.23868;
  long unsigned int D.23873;
  long unsigned int D.23874;
  gint32 * D.23875;
  int D.23876;
  struct GSList * D.23889;
  _Bool D.23890;
  long int D.23891;
  long int D.23892;
  struct MonoMemPool * D.23895;
  struct GSList * D.23896;
  struct GSList * D.23897;
  unsigned char D.23899;
  signed char D.23900;
  int D.23905;
  unsigned int D.23908;
  long unsigned int D.23909;
  long unsigned int D.23910;
  long unsigned int D.23911;
  long unsigned int D.23912;
  unsigned int D.23913;
  void * D.23914;
  long unsigned int D.23915;
  long unsigned int D.23916;
  gint32 * D.23917;
  int D.23918;
  struct MonoMethodVar * D.23923;
  long unsigned int D.23924;
  struct MonoMethodVar * D.23925;
  int D.23926;
  guint8 * D.23927;
  int D.23928;
  sizetype D.23929;
  guint8 * D.23930;
  unsigned char D.23931;
  signed char D.23932;
  int D.23933;
  int D.23934;
  signed char D.23935;
  signed char D.23936;
  unsigned char D.23937;
  unsigned int i.39;
  struct GSList * D.23941;

  D.23859 = ins->opcode;
  D.23860 = D.23859 + 64698;
  if (D.23860 <= 1) goto <D.23861>; else goto <D.23862>;
  <D.23861>:
  {
    int vreg;
    struct MonoMethodVar * vi;
    int idx;
    int pc_offset;

    D.23863 = ins->data.op[1].const_val;
    vreg = (int) D.23863;
    D.23864 = (long unsigned int) vreg;
    D.23865 = D.23864 * 8;
    D.23866 = vreg_to_varinfo + D.23865;
    vi = *D.23866;
    D.23867 = vi->idx;
    idx = (int) D.23867;
    pc_offset = ins->backend.pc_offset;
    D.23868 = cfg->verbose_level;
    if (D.23868 > 1) goto <D.23869>; else goto <D.23870>;
    <D.23869>:
    printf ("\t%x: ", pc_offset);
    mono_print_ins (ins);
    <D.23870>:
    D.23859 = ins->opcode;
    if (D.23859 == 838) goto <D.23871>; else goto <D.23872>;
    <D.23871>:
    D.23873 = (long unsigned int) idx;
    D.23874 = D.23873 * 4;
    D.23875 = last_use + D.23874;
    D.23876 = *D.23875;
    if (D.23876 > 0) goto <D.23877>; else goto <D.23878>;
    <D.23877>:
    D.23868 = cfg->verbose_level;
    if (D.23868 > 1) goto <D.23879>; else goto <D.23880>;
    <D.23879>:
    D.23873 = (long unsigned int) idx;
    D.23874 = D.23873 * 4;
    D.23875 = last_use + D.23874;
    D.23876 = *D.23875;
    printf ("\tadd range to R%d: [%x, %x)\n", vreg, pc_offset, D.23876);
    <D.23880>:
    D.23873 = (long unsigned int) idx;
    D.23874 = D.23873 * 4;
    D.23875 = last_use + D.23874;
    *D.23875 = 0;
    <D.23878>:
    goto <D.23881>;
    <D.23872>:
    D.23873 = (long unsigned int) idx;
    D.23874 = D.23873 * 4;
    D.23875 = last_use + D.23874;
    D.23876 = *D.23875;
    if (D.23876 == 0) goto <D.23882>; else goto <D.23883>;
    <D.23882>:
    D.23868 = cfg->verbose_level;
    if (D.23868 > 1) goto <D.23884>; else goto <D.23885>;
    <D.23884>:
    printf ("\tlast use of R%d set to %x\n", vreg, pc_offset);
    <D.23885>:
    D.23873 = (long unsigned int) idx;
    D.23874 = D.23873 * 4;
    D.23875 = last_use + D.23874;
    *D.23875 = pc_offset;
    <D.23883>:
    <D.23881>:
  }
  goto <D.23886>;
  <D.23862>:
  D.23859 = ins->opcode;
  if (D.23859 == 841) goto <D.23887>; else goto <D.23888>;
  <D.23887>:
  {
    struct GCCallSite * last;

    D.23889 = *callsites;
    D.23890 = D.23889 == 0B;
    D.23891 = (long int) D.23890;
    D.23892 = __builtin_expect (D.23891, 0);
    if (D.23892 != 0) goto <D.23893>; else goto <D.23894>;
    <D.23893>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "liveness.c", 1003, "*callsites");
    <D.23894>:
    D.23889 = *callsites;
    last = D.23889->data;
    D.23895 = cfg->mempool;
    D.23896 = last->param_slots;
    D.23897 = g_slist_prepend_mempool (D.23895, D.23896, ins);
    last->param_slots = D.23897;
  }
  goto <D.23898>;
  <D.23888>:
  D.23899 = ins->flags;
  D.23900 = (signed char) D.23899;
  if (D.23900 < 0) goto <D.23901>; else goto <D.23902>;
  <D.23901>:
  {
    struct GCCallSite * callsite;
    int i;

    D.23895 = cfg->mempool;
    callsite = mono_mempool_alloc0 (D.23895, 32);
    D.23868 = cfg->verbose_level;
    if (D.23868 > 1) goto <D.23903>; else goto <D.23904>;
    <D.23903>:
    D.23905 = ins->backend.pc_offset;
    printf ("\t%x: ", D.23905);
    mono_print_ins (ins);
    <D.23904>:
    D.23868 = cfg->verbose_level;
    if (D.23868 > 1) goto <D.23906>; else goto <D.23907>;
    <D.23906>:
    printf ("\t\tlive: ");
    <D.23907>:
    callsite->bb = bb;
    D.23895 = cfg->mempool;
    D.23908 = cfg->num_varinfo;
    D.23909 = (long unsigned int) D.23908;
    D.23910 = D.23909 + 7;
    D.23911 = D.23910 & 18446744073709551608;
    D.23912 = D.23911 / 8;
    D.23913 = (unsigned int) D.23912;
    D.23914 = mono_mempool_alloc0 (D.23895, D.23913);
    callsite->liveness = D.23914;
    D.23905 = ins->backend.pc_offset;
    callsite->pc_offset = D.23905;
    i = 0;
    goto <D.22705>;
    <D.22704>:
    D.23915 = (long unsigned int) i;
    D.23916 = D.23915 * 4;
    D.23917 = last_use + D.23916;
    D.23918 = *D.23917;
    if (D.23918 != 0) goto <D.23919>; else goto <D.23920>;
    <D.23919>:
    D.23868 = cfg->verbose_level;
    if (D.23868 > 1) goto <D.23921>; else goto <D.23922>;
    <D.23921>:
    D.23923 = cfg->vars;
    D.23915 = (long unsigned int) i;
    D.23924 = D.23915 * 80;
    D.23925 = D.23923 + D.23924;
    D.23926 = D.23925->vreg;
    printf ("R%d", D.23926);
    <D.23922>:
    D.23927 = callsite->liveness;
    D.23928 = i / 8;
    D.23929 = (sizetype) D.23928;
    D.23930 = D.23927 + D.23929;
    D.23927 = callsite->liveness;
    D.23929 = (sizetype) D.23928;
    D.23930 = D.23927 + D.23929;
    D.23931 = *D.23930;
    D.23932 = (signed char) D.23931;
    D.23933 = i % 8;
    D.23934 = 1 << D.23933;
    D.23935 = (signed char) D.23934;
    D.23936 = D.23932 | D.23935;
    D.23937 = (unsigned char) D.23936;
    *D.23930 = D.23937;
    <D.23920>:
    i = i + 1;
    <D.22705>:
    i.39 = (unsigned int) i;
    D.23908 = cfg->num_varinfo;
    if (i.39 < D.23908) goto <D.22704>; else goto <D.22706>;
    <D.22706>:
    D.23868 = cfg->verbose_level;
    if (D.23868 > 1) goto <D.23939>; else goto <D.23940>;
    <D.23939>:
    printf ("\n");
    <D.23940>:
    D.23895 = cfg->mempool;
    D.23889 = *callsites;
    D.23941 = g_slist_prepend_mempool (D.23895, D.23889, callsite);
    *callsites = D.23941;
  }
  <D.23902>:
  <D.23898>:
  <D.23886>:
}


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

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


