mono_liveness_handle_exception_clauses (struct MonoCompile * cfg)
{
  struct MonoMemPool * D.24671;
  <unnamed-unsigned:15> D.24672;
  unsigned int D.24673;
  unsigned int D.24674;
  unsigned int i.0;
  unsigned int D.24676;
  gboolean * D.24677;
  int D.24678;
  struct MonoExceptionClause * D.24679;
  unsigned int D.24680;
  unsigned int D.24681;
  unsigned int j.1;
  unsigned int D.24685;
  unsigned int D.24686;
  unsigned int D.24689;
  unsigned int D.24690;
  unsigned int D.24693;
  unsigned int D.24694;
  unsigned int D.24697;
  gboolean * D.24698;
  unsigned int D.24699;
  unsigned int D.24701;
  unsigned int D.24704;
  unsigned int D.24707;
  sizetype D.24708;
  sizetype D.24709;
  gboolean * D.24710;
  int D.24711;
  unsigned int D.24714;
  int D.24717;
  struct GSList * visited.2;
  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.24671 = cfg->mempool;
      D.24672 = header->num_clauses;
      D.24673 = (unsigned int) D.24672;
      D.24674 = D.24673 * 4;
      outer_try = mono_mempool_alloc0 (D.24671, D.24674);
      i = 0;
      goto <D.24354>;
      <D.24353>:
      i.0 = (unsigned int) i;
      D.24676 = i.0 * 4;
      D.24677 = outer_try + D.24676;
      *D.24677 = 1;
      i = i + 1;
      <D.24354>:
      D.24672 = header->num_clauses;
      D.24678 = (int) D.24672;
      if (D.24678 > i) goto <D.24353>; else goto <D.24355>;
      <D.24355>:
      D.24672 = header->num_clauses;
      D.24678 = (int) D.24672;
      i = D.24678 + -1;
      goto <D.24360>;
      <D.24359>:
      D.24679 = header->clauses;
      i.0 = (unsigned int) i;
      D.24680 = i.0 * 24;
      clause = D.24679 + D.24680;
      D.24681 = clause->flags;
      if (D.24681 != 0) goto <D.24682>; else goto <D.24683>;
      <D.24682>:
      i.0 = (unsigned int) i;
      D.24676 = i.0 * 4;
      D.24677 = outer_try + D.24676;
      *D.24677 = 1;
      j = i + -1;
      goto <D.24358>;
      <D.24357>:
      D.24679 = header->clauses;
      j.1 = (unsigned int) j;
      D.24685 = j.1 * 24;
      clause2 = D.24679 + D.24685;
      D.24686 = clause2->flags;
      if (D.24686 == 0) goto <D.24687>; else goto <D.24688>;
      <D.24687>:
      D.24689 = clause->handler_offset;
      D.24690 = clause2->try_offset;
      if (D.24689 <= D.24690) goto <D.24691>; else goto <D.24692>;
      <D.24691>:
      D.24690 = clause2->try_offset;
      D.24689 = clause->handler_offset;
      D.24693 = clause->handler_len;
      D.24694 = D.24689 + D.24693;
      if (D.24690 < D.24694) goto <D.24695>; else goto <D.24696>;
      <D.24695>:
      j.1 = (unsigned int) j;
      D.24697 = j.1 * 4;
      D.24698 = outer_try + D.24697;
      *D.24698 = 0;
      goto <D.24356>;
      <D.24696>:
      <D.24692>:
      <D.24688>:
      D.24690 = clause2->try_offset;
      D.24699 = clause->try_offset;
      if (D.24690 < D.24699) goto <D.24356>; else goto <D.24700>;
      <D.24700>:
      j = j + -1;
      <D.24358>:
      if (j >= 0) goto <D.24357>; else goto <D.24356>;
      <D.24356>:
      <D.24683>:
      i = i + -1;
      <D.24360>:
      if (i >= 0) goto <D.24359>; else goto <D.24361>;
      <D.24361>:
      bb = cfg->bb_entry;
      goto <D.24364>;
      <D.24363>:
      D.24701 = bb->region;
      if (D.24701 == 4294967295) goto <D.24702>; else goto <D.24703>;
      <D.24702>:
      // predicted unlikely by continue predictor.
      goto <D.24362>;
      <D.24703>:
      D.24701 = bb->region;
      D.24704 = D.24701 & 240;
      if (D.24704 == 0) goto <D.24705>; else goto <D.24706>;
      <D.24705>:
      D.24701 = bb->region;
      D.24707 = D.24701 >> 8;
      D.24708 = D.24707 + 1073741823;
      D.24709 = D.24708 * 4;
      D.24710 = outer_try + D.24709;
      D.24711 = *D.24710;
      if (D.24711 != 0) goto <D.24712>; else goto <D.24713>;
      <D.24712>:
      // predicted unlikely by continue predictor.
      goto <D.24362>;
      <D.24713>:
      <D.24706>:
      D.24714 = cfg->verbose_level;
      if (D.24714 > 2) goto <D.24715>; else goto <D.24716>;
      <D.24715>:
      D.24717 = bb->block_num;
      printf ("pessimize variables in bb %d.\n", D.24717);
      <D.24716>:
      visit_bb (cfg, bb, &visited);
      <D.24362>:
      bb = bb->next_bb;
      <D.24364>:
      if (bb != 0B) goto <D.24363>; else goto <D.24365>;
      <D.24365>:
      visited.2 = visited;
      monoeg_g_slist_free (visited.2);
    }
  finally
    {
      visited = {CLOBBER};
    }
}


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

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


visit_bb (struct MonoCompile * cfg, struct MonoBasicBlock * bb, struct GSList * * visited)
{
  struct GSList * D.24721;
  struct GSList * D.24722;
  short unsigned int D.24725;
  int D.24726;
  int D.24727;
  int D.24728;
  char D.24731;
  int iftmp.3;
  int D.24737;
  _Bool D.24740;
  long int D.24741;
  long int D.24742;
  unsigned int D.24747;
  unsigned int D.24748;
  struct MonoInst * * D.24751;
  unsigned int D.24752;
  unsigned int D.24753;
  struct MonoInst * * D.24754;
  struct MonoInst * D.24755;
  struct MonoInst * iftmp.4;
  struct MonoMethodVar * D.24762;
  unsigned int idx.5;
  unsigned int D.24764;
  struct MonoInst * * D.24765;
  unsigned int D.24766;
  unsigned int D.24767;
  struct MonoInst * * D.24768;
  struct MonoInst * D.24769;
  unsigned char D.24770;
  unsigned char D.24771;
  unsigned char D.24772;
  struct MonoInst * iftmp.6;
  int D.24776;
  int D.24777;
  unsigned int D.24778;
  sizetype D.24781;
  sizetype D.24782;
  sizetype D.24783;
  struct MonoInst * * D.24784;
  struct MonoInst * iftmp.7;
  unsigned char D.24790;
  unsigned char D.24791;
  struct MonoInst * iftmp.8;
  int D.24793;
  unsigned int D.24794;
  sizetype D.24797;
  sizetype D.24798;
  struct MonoInst * * D.24799;
  struct MonoInst * iftmp.9;
  unsigned char D.24805;
  unsigned char D.24806;
  int D.24807;
  int D.24808;
  int D.24809;
  signed char D.24810;
  _Bool D.24811;
  long int D.24812;
  long int D.24813;
  unsigned int sreg.10;
  unsigned int sreg.11;
  unsigned int D.24820;
  struct MonoInst * * D.24821;
  struct MonoInst * D.24822;
  struct MonoInst * iftmp.12;
  unsigned int idx.13;
  unsigned int D.24830;
  unsigned int D.24831;
  unsigned int D.24832;
  struct MonoInst * * D.24833;
  struct MonoInst * D.24834;
  unsigned char D.24835;
  unsigned char D.24836;
  unsigned char D.24837;
  struct MonoInst * iftmp.14;
  int D.24841;
  int D.24842;
  unsigned int D.24843;
  sizetype D.24846;
  sizetype D.24847;
  sizetype D.24848;
  struct MonoInst * * D.24849;
  struct MonoInst * iftmp.15;
  unsigned char D.24855;
  unsigned char D.24856;
  struct MonoInst * iftmp.16;
  int D.24858;
  unsigned int D.24859;
  sizetype D.24862;
  sizetype D.24863;
  struct MonoInst * * D.24864;
  struct MonoInst * iftmp.17;
  unsigned char D.24870;
  unsigned char D.24871;
  struct GSList * D.24872;
  struct MonoBasicBlock * * D.24873;
  unsigned int i.18;
  unsigned int D.24875;
  struct MonoBasicBlock * * D.24876;
  struct MonoBasicBlock * D.24877;
  short int D.24878;
  int D.24879;
  int i;
  struct MonoInst * ins;

  D.24721 = *visited;
  D.24722 = monoeg_g_slist_find (D.24721, bb);
  if (D.24722 != 0B) goto <D.24723>; else goto <D.24724>;
  <D.24723>:
  return;
  <D.24724>:
  ins = bb->code;
  goto <D.24337>;
  <D.24336>:
  {
    const char * spec;
    int regtype;
    int srcindex;
    int sreg;
    int num_sregs;
    int sregs[3];

    try
      {
        D.24725 = ins->opcode;
        D.24726 = (int) D.24725;
        D.24727 = D.24726 + -313;
        D.24728 = D.24727 * 4;
        spec = &ins_info[D.24728];
        D.24725 = ins->opcode;
        if (D.24725 == 316) goto <D.24729>; else goto <D.24730>;
        <D.24729>:
        // predicted unlikely by continue predictor.
        goto <D.24326>;
        <D.24730>:
        D.24731 = *spec;
        regtype = (int) D.24731;
        D.24737 = ins->dreg;
        if (D.24737 != -1) goto <D.24733>; else goto <D.24738>;
        <D.24738>:
        if (regtype != 32) goto <D.24733>; else goto <D.24734>;
        <D.24733>:
        D.24737 = ins->dreg;
        if (D.24737 == -1) goto <D.24735>; else goto <D.24739>;
        <D.24739>:
        if (regtype == 32) goto <D.24735>; else goto <D.24734>;
        <D.24735>:
        iftmp.3 = 1;
        goto <D.24736>;
        <D.24734>:
        iftmp.3 = 0;
        <D.24736>:
        D.24740 = iftmp.3 != 0;
        D.24741 = (long int) D.24740;
        D.24742 = __builtin_expect (D.24741, 0);
        if (D.24742 != 0) goto <D.24743>; else goto <D.24744>;
        <D.24743>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "liveness.c", 94, "((ins->dreg == -1) && (regtype == \' \')) || ((ins->dreg != -1) && (regtype != \' \'))");
        <D.24744>:
        D.24737 = ins->dreg;
        if (D.24737 != -1) goto <D.24745>; else goto <D.24746>;
        <D.24745>:
        D.24737 = ins->dreg;
        D.24747 = (unsigned int) D.24737;
        D.24748 = cfg->vreg_to_inst_len;
        if (D.24747 < D.24748) goto <D.24749>; else goto <D.24750>;
        <D.24749>:
        D.24751 = cfg->vreg_to_inst;
        D.24737 = ins->dreg;
        D.24752 = (unsigned int) D.24737;
        D.24753 = D.24752 * 4;
        D.24754 = D.24751 + D.24753;
        D.24755 = *D.24754;
        if (D.24755 != 0B) goto <D.24756>; else goto <D.24757>;
        <D.24756>:
        {
          struct MonoInst * var;
          int idx;
          struct MonoMethodVar * vi;

          D.24737 = ins->dreg;
          D.24747 = (unsigned int) D.24737;
          D.24748 = cfg->vreg_to_inst_len;
          if (D.24747 < D.24748) goto <D.24759>; else goto <D.24760>;
          <D.24759>:
          D.24751 = cfg->vreg_to_inst;
          D.24737 = ins->dreg;
          D.24752 = (unsigned int) D.24737;
          D.24753 = D.24752 * 4;
          D.24754 = D.24751 + D.24753;
          iftmp.4 = *D.24754;
          goto <D.24761>;
          <D.24760>:
          iftmp.4 = 0B;
          <D.24761>:
          var = iftmp.4;
          idx = var->data.op[0].const_val;
          D.24762 = cfg->vars;
          idx.5 = (unsigned int) idx;
          D.24764 = idx.5 * 56;
          vi = D.24762 + D.24764;
          D.24765 = cfg->varinfo;
          D.24766 = vi->idx;
          D.24767 = D.24766 * 4;
          D.24768 = D.24765 + D.24767;
          D.24769 = *D.24768;
          D.24765 = cfg->varinfo;
          D.24766 = vi->idx;
          D.24767 = D.24766 * 4;
          D.24768 = D.24765 + D.24767;
          D.24769 = *D.24768;
          D.24770 = D.24769->flags;
          D.24771 = D.24770 | 4;
          D.24769->flags = D.24771;
          D.24772 = var->type;
          if (D.24772 == 2) goto <D.24773>; else goto <D.24774>;
          <D.24773>:
          D.24776 = var->dreg;
          D.24777 = D.24776 + 1;
          D.24778 = (unsigned int) D.24777;
          D.24748 = cfg->vreg_to_inst_len;
          if (D.24778 < D.24748) goto <D.24779>; else goto <D.24780>;
          <D.24779>:
          D.24751 = cfg->vreg_to_inst;
          D.24776 = var->dreg;
          D.24781 = (sizetype) D.24776;
          D.24782 = D.24781 + 1;
          D.24783 = D.24782 * 4;
          D.24784 = D.24751 + D.24783;
          iftmp.6 = *D.24784;
          goto <D.24785>;
          <D.24780>:
          iftmp.6 = 0B;
          <D.24785>:
          D.24776 = var->dreg;
          D.24777 = D.24776 + 1;
          D.24778 = (unsigned int) D.24777;
          D.24748 = cfg->vreg_to_inst_len;
          if (D.24778 < D.24748) goto <D.24787>; else goto <D.24788>;
          <D.24787>:
          D.24751 = cfg->vreg_to_inst;
          D.24776 = var->dreg;
          D.24781 = (sizetype) D.24776;
          D.24782 = D.24781 + 1;
          D.24783 = D.24782 * 4;
          D.24784 = D.24751 + D.24783;
          iftmp.7 = *D.24784;
          goto <D.24789>;
          <D.24788>:
          iftmp.7 = 0B;
          <D.24789>:
          D.24790 = iftmp.7->flags;
          D.24791 = D.24790 | 4;
          iftmp.6->flags = D.24791;
          D.24776 = var->dreg;
          D.24793 = D.24776 + 2;
          D.24794 = (unsigned int) D.24793;
          D.24748 = cfg->vreg_to_inst_len;
          if (D.24794 < D.24748) goto <D.24795>; else goto <D.24796>;
          <D.24795>:
          D.24751 = cfg->vreg_to_inst;
          D.24776 = var->dreg;
          D.24781 = (sizetype) D.24776;
          D.24797 = D.24781 + 2;
          D.24798 = D.24797 * 4;
          D.24799 = D.24751 + D.24798;
          iftmp.8 = *D.24799;
          goto <D.24800>;
          <D.24796>:
          iftmp.8 = 0B;
          <D.24800>:
          D.24776 = var->dreg;
          D.24793 = D.24776 + 2;
          D.24794 = (unsigned int) D.24793;
          D.24748 = cfg->vreg_to_inst_len;
          if (D.24794 < D.24748) goto <D.24802>; else goto <D.24803>;
          <D.24802>:
          D.24751 = cfg->vreg_to_inst;
          D.24776 = var->dreg;
          D.24781 = (sizetype) D.24776;
          D.24797 = D.24781 + 2;
          D.24798 = D.24797 * 4;
          D.24799 = D.24751 + D.24798;
          iftmp.9 = *D.24799;
          goto <D.24804>;
          <D.24803>:
          iftmp.9 = 0B;
          <D.24804>:
          D.24805 = iftmp.9->flags;
          D.24806 = D.24805 | 4;
          iftmp.8->flags = D.24806;
          <D.24774>:
        }
        <D.24757>:
        <D.24750>:
        <D.24746>:
        D.24807 = ins->sreg1;
        sregs[0] = D.24807;
        D.24808 = ins->sreg2;
        sregs[1] = D.24808;
        D.24809 = ins->sreg3;
        sregs[2] = D.24809;
        D.24725 = ins->opcode;
        D.24726 = (int) D.24725;
        D.24727 = D.24726 + -313;
        D.24810 = ins_sreg_counts[D.24727];
        num_sregs = (int) D.24810;
        srcindex = 0;
        goto <D.24334>;
        <D.24333>:
        sreg = sregs[srcindex];
        D.24811 = sreg == -1;
        D.24812 = (long int) D.24811;
        D.24813 = __builtin_expect (D.24812, 0);
        if (D.24813 != 0) goto <D.24814>; else goto <D.24815>;
        <D.24814>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "liveness.c", 114, "sreg != -1");
        <D.24815>:
        sreg.10 = (unsigned int) sreg;
        D.24748 = cfg->vreg_to_inst_len;
        if (sreg.10 < D.24748) goto <D.24817>; else goto <D.24818>;
        <D.24817>:
        D.24751 = cfg->vreg_to_inst;
        sreg.11 = (unsigned int) sreg;
        D.24820 = sreg.11 * 4;
        D.24821 = D.24751 + D.24820;
        D.24822 = *D.24821;
        if (D.24822 != 0B) goto <D.24823>; else goto <D.24824>;
        <D.24823>:
        {
          struct MonoInst * var;
          int idx;
          struct MonoMethodVar * vi;

          sreg.10 = (unsigned int) sreg;
          D.24748 = cfg->vreg_to_inst_len;
          if (sreg.10 < D.24748) goto <D.24826>; else goto <D.24827>;
          <D.24826>:
          D.24751 = cfg->vreg_to_inst;
          sreg.11 = (unsigned int) sreg;
          D.24820 = sreg.11 * 4;
          D.24821 = D.24751 + D.24820;
          iftmp.12 = *D.24821;
          goto <D.24828>;
          <D.24827>:
          iftmp.12 = 0B;
          <D.24828>:
          var = iftmp.12;
          idx = var->data.op[0].const_val;
          D.24762 = cfg->vars;
          idx.13 = (unsigned int) idx;
          D.24830 = idx.13 * 56;
          vi = D.24762 + D.24830;
          D.24765 = cfg->varinfo;
          D.24831 = vi->idx;
          D.24832 = D.24831 * 4;
          D.24833 = D.24765 + D.24832;
          D.24834 = *D.24833;
          D.24765 = cfg->varinfo;
          D.24831 = vi->idx;
          D.24832 = D.24831 * 4;
          D.24833 = D.24765 + D.24832;
          D.24834 = *D.24833;
          D.24835 = D.24834->flags;
          D.24836 = D.24835 | 4;
          D.24834->flags = D.24836;
          D.24837 = var->type;
          if (D.24837 == 2) goto <D.24838>; else goto <D.24839>;
          <D.24838>:
          D.24841 = var->dreg;
          D.24842 = D.24841 + 1;
          D.24843 = (unsigned int) D.24842;
          D.24748 = cfg->vreg_to_inst_len;
          if (D.24843 < D.24748) goto <D.24844>; else goto <D.24845>;
          <D.24844>:
          D.24751 = cfg->vreg_to_inst;
          D.24841 = var->dreg;
          D.24846 = (sizetype) D.24841;
          D.24847 = D.24846 + 1;
          D.24848 = D.24847 * 4;
          D.24849 = D.24751 + D.24848;
          iftmp.14 = *D.24849;
          goto <D.24850>;
          <D.24845>:
          iftmp.14 = 0B;
          <D.24850>:
          D.24841 = var->dreg;
          D.24842 = D.24841 + 1;
          D.24843 = (unsigned int) D.24842;
          D.24748 = cfg->vreg_to_inst_len;
          if (D.24843 < D.24748) goto <D.24852>; else goto <D.24853>;
          <D.24852>:
          D.24751 = cfg->vreg_to_inst;
          D.24841 = var->dreg;
          D.24846 = (sizetype) D.24841;
          D.24847 = D.24846 + 1;
          D.24848 = D.24847 * 4;
          D.24849 = D.24751 + D.24848;
          iftmp.15 = *D.24849;
          goto <D.24854>;
          <D.24853>:
          iftmp.15 = 0B;
          <D.24854>:
          D.24855 = iftmp.15->flags;
          D.24856 = D.24855 | 4;
          iftmp.14->flags = D.24856;
          D.24841 = var->dreg;
          D.24858 = D.24841 + 2;
          D.24859 = (unsigned int) D.24858;
          D.24748 = cfg->vreg_to_inst_len;
          if (D.24859 < D.24748) goto <D.24860>; else goto <D.24861>;
          <D.24860>:
          D.24751 = cfg->vreg_to_inst;
          D.24841 = var->dreg;
          D.24846 = (sizetype) D.24841;
          D.24862 = D.24846 + 2;
          D.24863 = D.24862 * 4;
          D.24864 = D.24751 + D.24863;
          iftmp.16 = *D.24864;
          goto <D.24865>;
          <D.24861>:
          iftmp.16 = 0B;
          <D.24865>:
          D.24841 = var->dreg;
          D.24858 = D.24841 + 2;
          D.24859 = (unsigned int) D.24858;
          D.24748 = cfg->vreg_to_inst_len;
          if (D.24859 < D.24748) goto <D.24867>; else goto <D.24868>;
          <D.24867>:
          D.24751 = cfg->vreg_to_inst;
          D.24841 = var->dreg;
          D.24846 = (sizetype) D.24841;
          D.24862 = D.24846 + 2;
          D.24863 = D.24862 * 4;
          D.24864 = D.24751 + D.24863;
          iftmp.17 = *D.24864;
          goto <D.24869>;
          <D.24868>:
          iftmp.17 = 0B;
          <D.24869>:
          D.24870 = iftmp.17->flags;
          D.24871 = D.24870 | 4;
          iftmp.16->flags = D.24871;
          <D.24839>:
        }
        <D.24824>:
        <D.24818>:
        srcindex = srcindex + 1;
        <D.24334>:
        if (srcindex < num_sregs) goto <D.24333>; else goto <D.24335>;
        <D.24335>:
      }
    finally
      {
        sregs = {CLOBBER};
      }
  }
  <D.24326>:
  ins = ins->next;
  <D.24337>:
  if (ins != 0B) goto <D.24336>; else goto <D.24338>;
  <D.24338>:
  D.24721 = *visited;
  D.24872 = monoeg_g_slist_append (D.24721, bb);
  *visited = D.24872;
  i = 0;
  goto <D.24340>;
  <D.24339>:
  D.24873 = bb->out_bb;
  i.18 = (unsigned int) i;
  D.24875 = i.18 * 4;
  D.24876 = D.24873 + D.24875;
  D.24877 = *D.24876;
  visit_bb (cfg, D.24877, visited);
  i = i + 1;
  <D.24340>:
  D.24878 = bb->out_count;
  D.24879 = (int) D.24878;
  if (D.24879 > i) goto <D.24339>; else goto <D.24341>;
  <D.24341>:
}


mono_analyze_liveness (struct MonoCompile * cfg)
{
  unsigned int D.24883;
  unsigned int D.24884;
  unsigned int D.24887;
  unsigned int D.24888;
  _Bool D.24889;
  long int D.24890;
  long int D.24891;
  unsigned int D.24894;
  unsigned int max_vars.19;
  unsigned int D.24898;
  struct MonoMethodVar * D.24899;
  unsigned int i.20;
  unsigned int D.24901;
  struct MonoMethodVar * D.24902;
  struct MonoBasicBlock * * D.24903;
  unsigned int D.24904;
  struct MonoBasicBlock * * D.24905;
  struct MonoMemPool * D.24906;
  unsigned int bitsize.21;
  struct MonoBitSet * D.24908;
  struct MonoBitSet * D.24909;
  int D.24912;
  struct MonoBasicBlock * * D.24913;
  unsigned int j.22;
  unsigned int D.24915;
  struct MonoBasicBlock * * D.24916;
  struct MonoBasicBlock * D.24917;
  int D.24918;
  short int D.24919;
  int D.24920;
  struct MonoBitSet * D.24923;
  struct MonoBitSet * D.24924;
  unsigned int i.23;
  unsigned int D.24926;
  unsigned int D.24927;
  unsigned int D.24928;
  unsigned int l_end.24;
  unsigned int D.24930;
  struct MonoBasicBlock * * D.24931;
  int D.24932;
  unsigned int D.24933;
  unsigned int D.24934;
  gboolean * D.24935;
  struct MonoBitSet * D.24936;
  unsigned int D.24939;
  struct MonoBasicBlock * * D.24940;
  int D.24941;
  unsigned int D.24942;
  unsigned int D.24943;
  gboolean * D.24944;
  int D.24947;
  struct MonoBasicBlock * * D.24948;
  struct MonoBasicBlock * * D.24949;
  struct MonoBasicBlock * D.24950;
  int D.24951;
  short int D.24952;
  int D.24953;
  struct MonoBasicBlock * * D.24954;
  struct MonoBasicBlock * * D.24955;
  struct MonoBasicBlock * D.24956;
  int D.24957;
  short int D.24958;
  int D.24959;
  struct MonoBitSet * D.24962;
  gsize[0:] * D.24966;
  struct MonoBitSet * D.24967;
  gsize[0:] * D.24968;
  unsigned int D.24969;
  unsigned int D.24970;
  struct MonoBitSet * D.24971;
  struct MonoBitSet * D.24974;
  gsize[0:] * D.24975;
  struct MonoBitSet * D.24976;
  gsize[0:] * D.24977;
  unsigned int D.24978;
  unsigned int D.24979;
  unsigned int D.24980;
  unsigned int D.24981;
  unsigned int D.24982;
  unsigned int D.24983;
  unsigned int D.24984;
  unsigned int D.24985;
  unsigned int D.24986;
  unsigned int D.24987;
  unsigned int D.24988;
  unsigned int D.24989;
  unsigned int D.24990;
  struct MonoInst * D.24993;
  short unsigned int D.24995;
  unsigned int D.24997;
  unsigned int D.24998;
  unsigned int D.24999;
  unsigned int D.25000;
  unsigned int D.25001;
  int D.25004;
  struct MonoBitSet * D.25007;
  gsize[0:] * D.25008;
  unsigned int D.25009;
  unsigned int D.25010;
  unsigned int D.25011;
  unsigned int D.25012;
  unsigned int D.25013;
  unsigned int D.25014;
  unsigned int D.25015;
  unsigned int D.25016;
  unsigned int D.25017;
  unsigned int D.25018;
  unsigned int D.25019;
  unsigned int D.25020;
  unsigned int D.25021;
  struct MonoBitSet * D.25022;
  int D.25025;
  unsigned int D.25026;
  unsigned int D.25027;
  gboolean * D.25028;
  int D.25029;
  int D.25034;
  unsigned int l_end.25;
  unsigned int D.25036;
  struct MonoBasicBlock * * D.25037;
  _Bool D.25038;
  long int D.25039;
  long int D.25040;
  struct MonoBitSet * D.25045;
  struct MonoBitSet * D.25048;
  gsize[0:] * D.25049;
  struct MonoBitSet * D.25050;
  gsize[0:] * D.25051;
  unsigned int D.25052;
  unsigned int D.25053;
  unsigned int D.25054;
  unsigned int D.25055;
  unsigned int D.25056;
  unsigned int D.25057;
  unsigned int D.25058;
  unsigned int D.25059;
  unsigned int D.25060;
  unsigned int D.25061;
  unsigned int D.25062;
  unsigned int D.25063;
  unsigned int D.25064;
  int D.25065;
  int D.25066;
  struct MonoBitSet * D.25067;
  unsigned int max_vars.26;
  unsigned int D.25071;
  struct MonoBitSet * D.25072;
  unsigned int D.25073;
  unsigned int D.25074;
  unsigned int k.27;
  unsigned int D.25078;
  struct MonoMethodVar * D.25079;
  int abs_pos.28;
  unsigned int D.25081;
  unsigned int D.25084;
  int D.25085;
  unsigned int D.25086;
  unsigned int j.29;
  struct MonoInst * * D.25088;
  unsigned int D.25089;
  unsigned int D.25090;
  struct MonoInst * * D.25091;
  struct MonoInst * D.25092;
  short unsigned int D.25093;
  unsigned int D.25096;
  unsigned char D.25099;
  int D.25100;
  int D.25101;
  unsigned char D.25106;
  unsigned char D.25107;
  struct MonoGenericSharingContext * D.25110;
  struct MonoMethod * D.25112;
  struct MonoMethodSignature * D.25113;
  unsigned char D.25114;
  unsigned char D.25115;
  struct MonoInst * * D.25117;
  struct MonoInst * D.25118;
  unsigned char D.25119;
  unsigned int D.25122;
  int D.25123;
  struct MonoBitSet * D.25124;
  struct MonoBitSet * D.25125;
  unsigned int D.25126;
  unsigned int D.25127;
  unsigned char D.25128;
  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.24883 = cfg->num_varinfo;
  max_vars = (int) D.24883;
  D.24884 = cfg->verbose_level;
  if (D.24884 > 1) goto <D.24885>; else goto <D.24886>;
  <D.24885>:
  printf ("\nLIVENESS:\n");
  <D.24886>:
  D.24887 = cfg->comp_done;
  D.24888 = D.24887 & 16;
  D.24889 = D.24888 != 0;
  D.24890 = (long int) D.24889;
  D.24891 = __builtin_expect (D.24890, 0);
  if (D.24891 != 0) goto <D.24892>; else goto <D.24893>;
  <D.24892>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "liveness.c", 316, "!(cfg->comp_done & MONO_COMP_LIVENESS)");
  <D.24893>:
  D.24887 = cfg->comp_done;
  D.24894 = D.24887 | 16;
  cfg->comp_done = D.24894;
  if (max_vars == 0) goto <D.24895>; else goto <D.24896>;
  <D.24895>:
  return;
  <D.24896>:
  max_vars.19 = (unsigned int) max_vars;
  D.24898 = mono_bitset_alloc_size (max_vars.19, 0);
  bitsize = (int) D.24898;
  i = 0;
  goto <D.24412>;
  <D.24411>:
  D.24899 = cfg->vars;
  i.20 = (unsigned int) i;
  D.24901 = i.20 * 56;
  D.24902 = D.24899 + D.24901;
  D.24902->range.first_use.abs_pos = 4294967295;
  D.24899 = cfg->vars;
  i.20 = (unsigned int) i;
  D.24901 = i.20 * 56;
  D.24902 = D.24899 + D.24901;
  D.24902->range.last_use.abs_pos = 0;
  D.24899 = cfg->vars;
  i.20 = (unsigned int) i;
  D.24901 = i.20 * 56;
  D.24902 = D.24899 + D.24901;
  D.24902->spill_costs = 0;
  i = i + 1;
  <D.24412>:
  if (i < max_vars) goto <D.24411>; else goto <D.24413>;
  <D.24413>:
  i = 0;
  goto <D.24419>;
  <D.24418>:
  {
    struct MonoBasicBlock * bb;

    D.24903 = cfg->bblocks;
    i.20 = (unsigned int) i;
    D.24904 = i.20 * 4;
    D.24905 = D.24903 + D.24904;
    bb = *D.24905;
    D.24906 = cfg->mempool;
    bitsize.21 = (unsigned int) bitsize;
    max_vars.19 = (unsigned int) max_vars;
    D.24908 = mono_bitset_mp_new (D.24906, bitsize.21, max_vars.19);
    bb->gen_set = D.24908;
    D.24906 = cfg->mempool;
    bitsize.21 = (unsigned int) bitsize;
    max_vars.19 = (unsigned int) max_vars;
    D.24909 = mono_bitset_mp_new (D.24906, bitsize.21, max_vars.19);
    bb->kill_set = D.24909;
    D.24884 = cfg->verbose_level;
    if (D.24884 > 1) goto <D.24910>; else goto <D.24911>;
    <D.24910>:
    D.24912 = bb->block_num;
    printf ("BLOCK BB%d (", D.24912);
    j = 0;
    goto <D.24416>;
    <D.24415>:
    D.24913 = bb->out_bb;
    j.22 = (unsigned int) j;
    D.24915 = j.22 * 4;
    D.24916 = D.24913 + D.24915;
    D.24917 = *D.24916;
    D.24918 = D.24917->block_num;
    printf ("BB%d, ", D.24918);
    j = j + 1;
    <D.24416>:
    D.24919 = bb->out_count;
    D.24920 = (int) D.24919;
    if (D.24920 > j) goto <D.24415>; else goto <D.24417>;
    <D.24417>:
    printf ("):\n");
    <D.24911>:
    analyze_liveness_bb (cfg, bb);
    D.24884 = cfg->verbose_level;
    if (D.24884 > 1) goto <D.24921>; else goto <D.24922>;
    <D.24921>:
    D.24912 = bb->block_num;
    printf ("GEN  BB%d: ", D.24912);
    D.24923 = bb->gen_set;
    mono_bitset_print (D.24923);
    D.24912 = bb->block_num;
    printf ("KILL BB%d: ", D.24912);
    D.24924 = bb->kill_set;
    mono_bitset_print (D.24924);
    <D.24922>:
  }
  i = i + 1;
  <D.24419>:
  i.23 = (unsigned int) i;
  D.24926 = cfg->num_bblocks;
  if (i.23 < D.24926) goto <D.24418>; else goto <D.24420>;
  <D.24420>:
  max_vars.19 = (unsigned int) max_vars;
  old_live_out_set = mono_bitset_new (max_vars.19, 0);
  D.24926 = cfg->num_bblocks;
  D.24927 = D.24926 + 1;
  D.24928 = D.24927 * 4;
  in_worklist = monoeg_malloc0 (D.24928);
  D.24926 = cfg->num_bblocks;
  D.24927 = D.24926 + 1;
  D.24928 = D.24927 * 4;
  worklist = monoeg_malloc (D.24928);
  l_end = 0;
  i = 0;
  goto <D.24423>;
  <D.24422>:
  {
    struct MonoBasicBlock * bb;

    D.24903 = cfg->bblocks;
    i.20 = (unsigned int) i;
    D.24904 = i.20 * 4;
    D.24905 = D.24903 + D.24904;
    bb = *D.24905;
    l_end.24 = l_end;
    l_end = l_end.24 + 1;
    D.24930 = l_end.24 * 4;
    D.24931 = worklist + D.24930;
    *D.24931 = bb;
    D.24932 = bb->dfn;
    D.24933 = (unsigned int) D.24932;
    D.24934 = D.24933 * 4;
    D.24935 = in_worklist + D.24934;
    *D.24935 = 1;
    bb->live_in_set = 0B;
    D.24906 = cfg->mempool;
    bitsize.21 = (unsigned int) bitsize;
    max_vars.19 = (unsigned int) max_vars;
    D.24936 = mono_bitset_mp_new (D.24906, bitsize.21, max_vars.19);
    bb->live_out_set = D.24936;
  }
  i = i + 1;
  <D.24423>:
  i.23 = (unsigned int) i;
  D.24926 = cfg->num_bblocks;
  if (i.23 < D.24926) goto <D.24422>; else goto <D.24424>;
  <D.24424>:
  out_iter = 0;
  D.24884 = cfg->verbose_level;
  if (D.24884 > 1) goto <D.24937>; else goto <D.24938>;
  <D.24937>:
  printf ("\nITERATION:\n");
  <D.24938>:
  goto <D.24434>;
  <D.24477>:
  {
    struct MonoBasicBlock * bb;
    struct MonoBasicBlock * out_bb;
    gboolean changed;

    l_end = l_end + 4294967295;
    D.24939 = l_end * 4;
    D.24940 = worklist + D.24939;
    bb = *D.24940;
    D.24941 = bb->dfn;
    D.24942 = (unsigned int) D.24941;
    D.24943 = D.24942 * 4;
    D.24944 = in_worklist + D.24943;
    *D.24944 = 0;
    D.24884 = cfg->verbose_level;
    if (D.24884 > 1) goto <D.24945>; else goto <D.24946>;
    <D.24945>:
    D.24947 = bb->block_num;
    D.24941 = bb->dfn;
    printf ("P: BB%d(%d): IN: ", D.24947, D.24941);
    j = 0;
    goto <D.24429>;
    <D.24428>:
    D.24948 = bb->in_bb;
    j.22 = (unsigned int) j;
    D.24915 = j.22 * 4;
    D.24949 = D.24948 + D.24915;
    D.24950 = *D.24949;
    D.24951 = D.24950->block_num;
    printf ("BB%d ", D.24951);
    j = j + 1;
    <D.24429>:
    D.24952 = bb->in_count;
    D.24953 = (int) D.24952;
    if (D.24953 > j) goto <D.24428>; else goto <D.24430>;
    <D.24430>:
    printf ("OUT:");
    j = 0;
    goto <D.24432>;
    <D.24431>:
    D.24954 = bb->out_bb;
    j.22 = (unsigned int) j;
    D.24915 = j.22 * 4;
    D.24955 = D.24954 + D.24915;
    D.24956 = *D.24955;
    D.24957 = D.24956->block_num;
    printf ("BB%d ", D.24957);
    j = j + 1;
    <D.24432>:
    D.24958 = bb->out_count;
    D.24959 = (int) D.24958;
    if (D.24959 > j) goto <D.24431>; else goto <D.24433>;
    <D.24433>:
    printf ("\n");
    <D.24946>:
    D.24958 = bb->out_count;
    if (D.24958 == 0) goto <D.24960>; else goto <D.24961>;
    <D.24960>:
    // predicted unlikely by continue predictor.
    goto <D.24434>;
    <D.24961>:
    out_iter = out_iter + 1;
    D.24962 = bb->live_in_set;
    if (D.24962 == 0B) goto <D.24963>; else goto <D.24964>;
    <D.24963>:
    changed = 1;
    goto <D.24965>;
    <D.24964>:
    changed = 0;
    D.24966 = &old_live_out_set->data;
    D.24967 = bb->live_out_set;
    D.24968 = &D.24967->data;
    D.24969 = old_live_out_set->size;
    D.24970 = D.24969 / 8;
    memcpy (D.24966, D.24968, D.24970);
    <D.24965>:
    j = 0;
    goto <D.24457>;
    <D.24456>:
    D.24954 = bb->out_bb;
    j.22 = (unsigned int) j;
    D.24915 = j.22 * 4;
    D.24955 = D.24954 + D.24915;
    out_bb = *D.24955;
    D.24971 = out_bb->live_in_set;
    if (D.24971 == 0B) goto <D.24972>; else goto <D.24973>;
    <D.24972>:
    D.24906 = cfg->mempool;
    bitsize.21 = (unsigned int) bitsize;
    max_vars.19 = (unsigned int) max_vars;
    D.24974 = mono_bitset_mp_new_noinit (D.24906, bitsize.21, max_vars.19);
    out_bb->live_in_set = D.24974;
    D.24971 = out_bb->live_in_set;
    D.24975 = &D.24971->data;
    D.24976 = out_bb->live_out_set;
    D.24977 = &D.24976->data;
    D.24971 = out_bb->live_in_set;
    D.24978 = D.24971->size;
    D.24979 = D.24978 / 8;
    memcpy (D.24975, D.24977, D.24979);
    {
      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.24980 = tmp_dest->size;
      D.24981 = D.24980 / 32;
      size = (int) D.24981;
      i = 0;
      goto <D.24440>;
      <D.24439>:
      D.24982 = tmp_dest->data[i];
      D.24983 = tmp_src->data[i];
      D.24984 = ~D.24983;
      D.24985 = D.24982 & D.24984;
      tmp_dest->data[i] = D.24985;
      i = i + 1;
      <D.24440>:
      if (i < size) goto <D.24439>; else goto <D.24441>;
      <D.24441>:
    }
    {
      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.24986 = tmp_dest->size;
      D.24987 = D.24986 / 32;
      size = (int) D.24987;
      i = 0;
      goto <D.24447>;
      <D.24446>:
      D.24988 = tmp_dest->data[i];
      D.24989 = tmp_src->data[i];
      D.24990 = D.24988 | D.24989;
      tmp_dest->data[i] = D.24990;
      i = i + 1;
      <D.24447>:
      if (i < size) goto <D.24446>; else goto <D.24448>;
      <D.24448>:
    }
    <D.24973>:
    D.24993 = bb->last_ins;
    if (D.24993 != 0B) goto <D.24994>; else goto <D.24991>;
    <D.24994>:
    D.24993 = bb->last_ins;
    D.24995 = D.24993->opcode;
    if (D.24995 == 798) goto <D.24996>; else goto <D.24991>;
    <D.24996>:
    goto <D.24992>;
    <D.24991>:
    {
      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.24997 = tmp_dest->size;
      D.24998 = D.24997 / 32;
      size = (int) D.24998;
      i = 0;
      goto <D.24454>;
      <D.24453>:
      D.24999 = tmp_dest->data[i];
      D.25000 = tmp_src->data[i];
      D.25001 = D.24999 | D.25000;
      tmp_dest->data[i] = D.25001;
      i = i + 1;
      <D.24454>:
      if (i < size) goto <D.24453>; else goto <D.24455>;
      <D.24455>:
    }
    <D.24992>:
    j = j + 1;
    <D.24457>:
    D.24958 = bb->out_count;
    D.24959 = (int) D.24958;
    if (D.24959 > j) goto <D.24456>; else goto <D.24458>;
    <D.24458>:
    if (changed != 0) goto <D.25002>; else goto <D.25003>;
    <D.25003>:
    D.24967 = bb->live_out_set;
    D.25004 = mono_bitset_equal (old_live_out_set, D.24967);
    if (D.25004 == 0) goto <D.25002>; else goto <D.24476>;
    <D.25002>:
    D.24962 = bb->live_in_set;
    if (D.24962 == 0B) goto <D.25005>; else goto <D.25006>;
    <D.25005>:
    D.24906 = cfg->mempool;
    bitsize.21 = (unsigned int) bitsize;
    max_vars.19 = (unsigned int) max_vars;
    D.25007 = mono_bitset_mp_new_noinit (D.24906, bitsize.21, max_vars.19);
    bb->live_in_set = D.25007;
    <D.25006>:
    D.24962 = bb->live_in_set;
    D.25008 = &D.24962->data;
    D.24967 = bb->live_out_set;
    D.24968 = &D.24967->data;
    D.24962 = bb->live_in_set;
    D.25009 = D.24962->size;
    D.25010 = D.25009 / 8;
    memcpy (D.25008, D.24968, D.25010);
    {
      struct MonoBitSet * tmp_src;
      struct MonoBitSet * tmp_dest;
      int i;
      int size;

      tmp_src = bb->kill_set;
      tmp_dest = bb->live_in_set;
      D.25011 = tmp_dest->size;
      D.25012 = D.25011 / 32;
      size = (int) D.25012;
      i = 0;
      goto <D.24464>;
      <D.24463>:
      D.25013 = tmp_dest->data[i];
      D.25014 = tmp_src->data[i];
      D.25015 = ~D.25014;
      D.25016 = D.25013 & D.25015;
      tmp_dest->data[i] = D.25016;
      i = i + 1;
      <D.24464>:
      if (i < size) goto <D.24463>; else goto <D.24465>;
      <D.24465>:
    }
    {
      struct MonoBitSet * tmp_src;
      struct MonoBitSet * tmp_dest;
      int i;
      int size;

      tmp_src = bb->gen_set;
      tmp_dest = bb->live_in_set;
      D.25017 = tmp_dest->size;
      D.25018 = D.25017 / 32;
      size = (int) D.25018;
      i = 0;
      goto <D.24471>;
      <D.24470>:
      D.25019 = tmp_dest->data[i];
      D.25020 = tmp_src->data[i];
      D.25021 = D.25019 | D.25020;
      tmp_dest->data[i] = D.25021;
      i = i + 1;
      <D.24471>:
      if (i < size) goto <D.24470>; else goto <D.24472>;
      <D.24472>:
    }
    j = 0;
    goto <D.24475>;
    <D.24474>:
    {
      struct MonoBasicBlock * in_bb;

      D.24948 = bb->in_bb;
      j.22 = (unsigned int) j;
      D.24915 = j.22 * 4;
      D.24949 = D.24948 + D.24915;
      in_bb = *D.24949;
      D.25022 = in_bb->gen_set;
      if (D.25022 != 0B) goto <D.25023>; else goto <D.25024>;
      <D.25023>:
      D.25025 = in_bb->dfn;
      D.25026 = (unsigned int) D.25025;
      D.25027 = D.25026 * 4;
      D.25028 = in_worklist + D.25027;
      D.25029 = *D.25028;
      if (D.25029 == 0) goto <D.25030>; else goto <D.25031>;
      <D.25030>:
      D.24884 = cfg->verbose_level;
      if (D.24884 > 1) goto <D.25032>; else goto <D.25033>;
      <D.25032>:
      D.25034 = in_bb->block_num;
      printf ("\tADD: %d\n", D.25034);
      <D.25033>:
      l_end.25 = l_end;
      l_end = l_end.25 + 1;
      D.25036 = l_end.25 * 4;
      D.25037 = worklist + D.25036;
      *D.25037 = in_bb;
      D.25025 = in_bb->dfn;
      D.25026 = (unsigned int) D.25025;
      D.25027 = D.25026 * 4;
      D.25028 = in_worklist + D.25027;
      *D.25028 = 1;
      <D.25031>:
      <D.25024>:
    }
    j = j + 1;
    <D.24475>:
    D.24952 = bb->in_count;
    D.24953 = (int) D.24952;
    if (D.24953 > j) goto <D.24474>; else goto <D.24476>;
    <D.24476>:
    D.24884 = cfg->verbose_level;
    D.25038 = D.24884 > 1;
    D.25039 = (long int) D.25038;
    D.25040 = __builtin_expect (D.25039, 0);
    if (D.25040 != 0) goto <D.25041>; else goto <D.25042>;
    <D.25041>:
    D.24947 = bb->block_num;
    printf ("\tLIVE IN  BB%d: ", D.24947);
    D.24962 = bb->live_in_set;
    mono_bitset_print (D.24962);
    <D.25042>:
  }
  <D.24434>:
  if (l_end != 0) goto <D.24477>; else goto <D.24478>;
  <D.24478>:
  D.24884 = cfg->verbose_level;
  if (D.24884 > 1) goto <D.25043>; else goto <D.25044>;
  <D.25043>:
  D.24926 = cfg->num_bblocks;
  printf ("IT: %d %d.\n", D.24926, out_iter);
  <D.25044>:
  mono_bitset_free (old_live_out_set);
  monoeg_g_free (worklist);
  monoeg_g_free (in_worklist);
  i = 0;
  goto <D.24495>;
  <D.24494>:
  {
    struct MonoBasicBlock * bb;

    D.24903 = cfg->bblocks;
    i.20 = (unsigned int) i;
    D.24904 = i.20 * 4;
    D.24905 = D.24903 + D.24904;
    bb = *D.24905;
    D.25045 = bb->live_in_set;
    if (D.25045 == 0B) goto <D.25046>; else goto <D.25047>;
    <D.25046>:
    D.24906 = cfg->mempool;
    bitsize.21 = (unsigned int) bitsize;
    max_vars.19 = (unsigned int) max_vars;
    D.25048 = mono_bitset_mp_new (D.24906, bitsize.21, max_vars.19);
    bb->live_in_set = D.25048;
    D.25045 = bb->live_in_set;
    D.25049 = &D.25045->data;
    D.25050 = bb->live_out_set;
    D.25051 = &D.25050->data;
    D.25045 = bb->live_in_set;
    D.25052 = D.25045->size;
    D.25053 = D.25052 / 8;
    memcpy (D.25049, D.25051, D.25053);
    {
      struct MonoBitSet * tmp_src;
      struct MonoBitSet * tmp_dest;
      int i;
      int size;

      tmp_src = bb->kill_set;
      tmp_dest = bb->live_in_set;
      D.25054 = tmp_dest->size;
      D.25055 = D.25054 / 32;
      size = (int) D.25055;
      i = 0;
      goto <D.24485>;
      <D.24484>:
      D.25056 = tmp_dest->data[i];
      D.25057 = tmp_src->data[i];
      D.25058 = ~D.25057;
      D.25059 = D.25056 & D.25058;
      tmp_dest->data[i] = D.25059;
      i = i + 1;
      <D.24485>:
      if (i < size) goto <D.24484>; else goto <D.24486>;
      <D.24486>:
    }
    {
      struct MonoBitSet * tmp_src;
      struct MonoBitSet * tmp_dest;
      int i;
      int size;

      tmp_src = bb->gen_set;
      tmp_dest = bb->live_in_set;
      D.25060 = tmp_dest->size;
      D.25061 = D.25060 / 32;
      size = (int) D.25061;
      i = 0;
      goto <D.24492>;
      <D.24491>:
      D.25062 = tmp_dest->data[i];
      D.25063 = tmp_src->data[i];
      D.25064 = D.25062 | D.25063;
      tmp_dest->data[i] = D.25064;
      i = i + 1;
      <D.24492>:
      if (i < size) goto <D.24491>; else goto <D.24493>;
      <D.24493>:
    }
    <D.25047>:
  }
  i = i + 1;
  <D.24495>:
  i.23 = (unsigned int) i;
  D.24926 = cfg->num_bblocks;
  if (i.23 < D.24926) goto <D.24494>; else goto <D.24496>;
  <D.24496>:
  i = 0;
  goto <D.24512>;
  <D.24511>:
  {
    struct MonoBasicBlock * bb;
    guint32 max;
    guint32 abs_pos;
    struct MonoMethodVar * vars;

    D.24903 = cfg->bblocks;
    i.20 = (unsigned int) i;
    D.24904 = i.20 * 4;
    D.24905 = D.24903 + D.24904;
    bb = *D.24905;
    D.25065 = bb->dfn;
    D.25066 = D.25065 << 16;
    abs_pos = (guint32) D.25066;
    vars = cfg->vars;
    D.25067 = bb->live_out_set;
    if (D.25067 == 0B) goto <D.25068>; else goto <D.25069>;
    <D.25068>:
    // predicted unlikely by continue predictor.
    goto <D.24501>;
    <D.25069>:
    max_vars.26 = (unsigned int) max_vars;
    D.25071 = max_vars.26 + 31;
    max = D.25071 / 32;
    j = 0;
    goto <D.24509>;
    <D.24508>:
    {
      gsize bits_in;
      gsize bits_out;
      int k;

      D.25072 = bb->live_in_set;
      bits_in = D.25072->data[j];
      D.25067 = bb->live_out_set;
      bits_out = D.25067->data[j];
      j.22 = (unsigned int) j;
      D.25073 = j.22 * 32;
      k = (int) D.25073;
      goto <D.24506>;
      <D.24505>:
      D.25074 = bits_in & 1;
      if (D.25074 != 0) goto <D.25075>; else goto <D.25076>;
      <D.25075>:
      k.27 = (unsigned int) k;
      D.25078 = k.27 * 56;
      D.25079 = vars + D.25078;
      abs_pos.28 = (int) abs_pos;
      update_live_range (D.25079, abs_pos.28);
      <D.25076>:
      D.25081 = bits_out & 1;
      if (D.25081 != 0) goto <D.25082>; else goto <D.25083>;
      <D.25082>:
      k.27 = (unsigned int) k;
      D.25078 = k.27 * 56;
      D.25079 = vars + D.25078;
      D.25084 = abs_pos + 65535;
      D.25085 = (int) D.25084;
      update_live_range (D.25079, D.25085);
      <D.25083>:
      bits_in = bits_in >> 1;
      bits_out = bits_out >> 1;
      k = k + 1;
      <D.24506>:
      D.25086 = bits_in | bits_out;
      if (D.25086 != 0) goto <D.24505>; else goto <D.24507>;
      <D.24507>:
    }
    j = j + 1;
    <D.24509>:
    j.29 = (unsigned int) j;
    if (j.29 < max) goto <D.24508>; else goto <D.24510>;
    <D.24510>:
  }
  <D.24501>:
  i = i + 1;
  <D.24512>:
  i.23 = (unsigned int) i;
  D.24926 = cfg->num_bblocks;
  if (i.23 < D.24926) goto <D.24511>; else goto <D.24513>;
  <D.24513>:
  i = 0;
  goto <D.24516>;
  <D.24515>:
  {
    struct MonoMethodVar * vi;

    D.24899 = cfg->vars;
    i.20 = (unsigned int) i;
    D.24901 = i.20 * 56;
    vi = D.24899 + D.24901;
    D.25088 = cfg->varinfo;
    D.25089 = vi->idx;
    D.25090 = D.25089 * 4;
    D.25091 = D.25088 + D.25090;
    D.25092 = *D.25091;
    D.25093 = D.25092->opcode;
    if (D.25093 == 330) goto <D.25094>; else goto <D.25095>;
    <D.25094>:
    D.25096 = vi->range.last_use.abs_pos;
    if (D.25096 == 0) goto <D.25097>; else goto <D.25098>;
    <D.25097>:
    D.25088 = cfg->varinfo;
    D.25089 = vi->idx;
    D.25090 = D.25089 * 4;
    D.25091 = D.25088 + D.25090;
    D.25092 = *D.25091;
    D.25099 = D.25092->flags;
    D.25100 = (int) D.25099;
    D.25101 = D.25100 & 20;
    if (D.25101 == 0) goto <D.25102>; else goto <D.25103>;
    <D.25102>:
    D.25106 = BIT_FIELD_REF <*cfg, 8, 3408>;
    D.25107 = D.25106 & 128;
    if (D.25107 == 0) goto <D.25108>; else goto <D.25109>;
    <D.25108>:
    D.25110 = cfg->generic_sharing_context;
    if (D.25110 == 0B) goto <D.25104>; else goto <D.25111>;
    <D.25111>:
    D.25112 = cfg->method;
    D.25113 = mono_method_signature (D.25112);
    D.25114 = BIT_FIELD_REF <*D.25113, 8, 80>;
    D.25115 = D.25114 & 64;
    if (D.25115 == 0) goto <D.25104>; else goto <D.25116>;
    <D.25116>:
    D.25088 = cfg->varinfo;
    D.25089 = vi->idx;
    D.25090 = D.25089 * 4;
    D.25091 = D.25088 + D.25090;
    D.25092 = *D.25091;
    D.25117 = cfg->args;
    D.25118 = *D.25117;
    if (D.25092 != D.25118) goto <D.25104>; else goto <D.25105>;
    <D.25104>:
    D.25088 = cfg->varinfo;
    D.25089 = vi->idx;
    D.25090 = D.25089 * 4;
    D.25091 = D.25088 + D.25090;
    D.25092 = *D.25091;
    D.25088 = cfg->varinfo;
    D.25089 = vi->idx;
    D.25090 = D.25089 * 4;
    D.25091 = D.25088 + D.25090;
    D.25092 = *D.25091;
    D.25099 = D.25092->flags;
    D.25119 = D.25099 | 2;
    D.25092->flags = D.25119;
    <D.25105>:
    <D.25109>:
    <D.25103>:
    <D.25098>:
    vi->range.first_use.abs_pos = 0;
    <D.25095>:
  }
  i = i + 1;
  <D.24516>:
  if (i < max_vars) goto <D.24515>; else goto <D.24517>;
  <D.24517>:
  D.24884 = cfg->verbose_level;
  if (D.24884 > 1) goto <D.25120>; else goto <D.25121>;
  <D.25120>:
  D.24926 = cfg->num_bblocks;
  D.25122 = D.24926 + 4294967295;
  i = (int) D.25122;
  goto <D.24520>;
  <D.24519>:
  {
    struct MonoBasicBlock * bb;

    D.24903 = cfg->bblocks;
    i.20 = (unsigned int) i;
    D.24904 = i.20 * 4;
    D.24905 = D.24903 + D.24904;
    bb = *D.24905;
    D.25123 = bb->block_num;
    printf ("LIVE IN  BB%d: ", D.25123);
    D.25124 = bb->live_in_set;
    mono_bitset_print (D.25124);
    D.25123 = bb->block_num;
    printf ("LIVE OUT BB%d: ", D.25123);
    D.25125 = bb->live_out_set;
    mono_bitset_print (D.25125);
  }
  i = i + -1;
  <D.24520>:
  if (i >= 0) goto <D.24519>; else goto <D.24521>;
  <D.24521>:
  i = 0;
  goto <D.24524>;
  <D.24523>:
  {
    struct MonoMethodVar * vi;

    D.24899 = cfg->vars;
    i.20 = (unsigned int) i;
    D.24901 = i.20 * 56;
    vi = D.24899 + D.24901;
    D.25126 = vi->range.first_use.abs_pos;
    D.25127 = vi->range.last_use.abs_pos;
    printf ("V%d: [0x%x - 0x%x]\n", i, D.25126, D.25127);
  }
  i = i + 1;
  <D.24524>:
  if (i < max_vars) goto <D.24523>; else goto <D.24525>;
  <D.24525>:
  <D.25121>:
  D.25106 = BIT_FIELD_REF <*cfg, 8, 3408>;
  D.25128 = D.25106 & 8;
  if (D.25128 == 0) goto <D.25129>; else goto <D.25130>;
  <D.25129>:
  optimize_initlocals (cfg);
  <D.25130>:
}


analyze_liveness_bb (struct MonoCompile * cfg, struct MonoBasicBlock * bb)
{
  int D.25132;
  int D.25133;
  short unsigned int D.25134;
  int D.25135;
  int D.25136;
  int D.25137;
  unsigned int D.25138;
  struct MonoMethodVar * D.25145;
  unsigned int idx.30;
  unsigned int D.25147;
  int D.25150;
  struct MonoMethodVar * D.25151;
  unsigned int inst_num.31;
  unsigned int D.25153;
  int D.25154;
  struct MonoBitSet * D.25155;
  unsigned int D.25156;
  unsigned int D.25157;
  int D.25158;
  unsigned int D.25159;
  unsigned int D.25160;
  struct MonoBitSet * D.25163;
  unsigned int D.25164;
  unsigned int D.25165;
  unsigned int D.25166;
  int D.25167;
  signed char D.25168;
  int D.25169;
  int D.25170;
  int D.25171;
  int D.25172;
  int D.25173;
  int D.25174;
  int D.25175;
  signed char D.25176;
  int D.25177;
  sizetype D.25178;
  const char * D.25179;
  char D.25180;
  unsigned int sreg.32;
  unsigned int D.25184;
  struct MonoInst * * D.25187;
  unsigned int sreg.33;
  unsigned int D.25189;
  struct MonoInst * * D.25190;
  struct MonoInst * D.25191;
  struct MonoInst * iftmp.34;
  unsigned int idx.35;
  unsigned int D.25199;
  struct MonoMethodVar * D.25202;
  unsigned int D.25203;
  unsigned int D.25204;
  int D.25205;
  unsigned int D.25206;
  unsigned int D.25207;
  unsigned int D.25210;
  unsigned int D.25211;
  unsigned int D.25212;
  int D.25213;
  int D.25214;
  char D.25215;
  int D.25218;
  unsigned int D.25219;
  unsigned int D.25222;
  unsigned int D.25223;
  struct MonoInst * * D.25224;
  struct MonoInst * D.25225;
  struct MonoInst * iftmp.36;
  unsigned int idx.37;
  unsigned int D.25233;
  short unsigned int D.25234;
  struct MonoMethodVar * D.25237;
  unsigned int D.25238;
  unsigned int D.25239;
  int D.25240;
  unsigned int D.25241;
  unsigned int D.25242;
  unsigned int D.25245;
  unsigned int D.25246;
  unsigned int D.25247;
  int D.25248;
  int D.25249;
  unsigned int D.25253;
  int D.25254;
  unsigned int D.25255;
  unsigned int D.25256;
  unsigned int D.25257;
  struct MonoInst * ins;
  int sreg;
  int inst_num;
  struct MonoMethodVar * vars;
  guint32 abs_pos;

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

    try
      {
        D.25134 = ins->opcode;
        D.25135 = (int) D.25134;
        D.25136 = D.25135 + -313;
        D.25137 = D.25136 * 4;
        spec = &ins_info[D.25137];
        D.25138 = cfg->verbose_level;
        if (D.25138 > 1) goto <D.25139>; else goto <D.25140>;
        <D.25139>:
        printf ("\t");
        mono_print_ins (ins);
        <D.25140>:
        D.25134 = ins->opcode;
        if (D.25134 == 316) goto <D.25141>; else goto <D.25142>;
        <D.25141>:
        // predicted unlikely by continue predictor.
        goto <D.24383>;
        <D.25142>:
        D.25134 = ins->opcode;
        if (D.25134 == 314) goto <D.25143>; else goto <D.25144>;
        <D.25143>:
        {
          struct MonoInst * var;
          int idx;
          struct MonoMethodVar * vi;

          var = ins->data.op[0].p;
          idx = var->data.op[0].const_val;
          D.25145 = cfg->vars;
          idx.30 = (unsigned int) idx;
          D.25147 = idx.30 * 56;
          vi = D.25145 + D.25147;
          D.25138 = cfg->verbose_level;
          if (D.25138 > 1) goto <D.25148>; else goto <D.25149>;
          <D.25148>:
          D.25150 = var->dreg;
          printf ("\tGEN: R%d(%d)\n", D.25150, idx);
          <D.25149>:
          idx.30 = (unsigned int) idx;
          D.25147 = idx.30 * 56;
          D.25151 = vars + D.25147;
          inst_num.31 = (unsigned int) inst_num;
          D.25153 = abs_pos + inst_num.31;
          D.25154 = (int) D.25153;
          update_live_range (D.25151, D.25154);
          D.25155 = bb->kill_set;
          idx.30 = (unsigned int) idx;
          D.25156 = idx.30 / 32;
          D.25157 = D.25155->data[D.25156];
          D.25158 = idx & 31;
          D.25159 = 1 << D.25158;
          D.25160 = D.25157 & D.25159;
          if (D.25160 == 0) goto <D.25161>; else goto <D.25162>;
          <D.25161>:
          D.25163 = bb->gen_set;
          idx.30 = (unsigned int) idx;
          D.25164 = idx.30 / 32;
          D.25163 = bb->gen_set;
          D.25165 = D.25163->data[D.25164];
          D.25158 = idx & 31;
          D.25159 = 1 << D.25158;
          D.25166 = D.25165 | D.25159;
          D.25163->data[D.25164] = D.25166;
          <D.25162>:
          D.25167 = vi->spill_costs;
          D.25168 = bb->nesting;
          D.25169 = (int) D.25168;
          D.25170 = D.25169 << 1;
          D.25171 = 1 << D.25170;
          D.25172 = D.25167 + D.25171;
          vi->spill_costs = D.25172;
        }
        <D.25144>:
        D.25173 = ins->sreg1;
        sregs[0] = D.25173;
        D.25174 = ins->sreg2;
        sregs[1] = D.25174;
        D.25175 = ins->sreg3;
        sregs[2] = D.25175;
        D.25134 = ins->opcode;
        D.25135 = (int) D.25134;
        D.25136 = D.25135 + -313;
        D.25176 = ins_sreg_counts[D.25136];
        num_sregs = (int) D.25176;
        i = 0;
        goto <D.24391>;
        <D.24390>:
        sreg = sregs[i];
        D.25177 = i + 1;
        D.25178 = (sizetype) D.25177;
        D.25179 = spec + D.25178;
        D.25180 = *D.25179;
        if (D.25180 != 32) goto <D.25181>; else goto <D.25182>;
        <D.25181>:
        sreg.32 = (unsigned int) sreg;
        D.25184 = cfg->vreg_to_inst_len;
        if (sreg.32 < D.25184) goto <D.25185>; else goto <D.25186>;
        <D.25185>:
        D.25187 = cfg->vreg_to_inst;
        sreg.33 = (unsigned int) sreg;
        D.25189 = sreg.33 * 4;
        D.25190 = D.25187 + D.25189;
        D.25191 = *D.25190;
        if (D.25191 != 0B) goto <D.25192>; else goto <D.25193>;
        <D.25192>:
        {
          struct MonoInst * var;
          int idx;
          struct MonoMethodVar * vi;

          sreg.32 = (unsigned int) sreg;
          D.25184 = cfg->vreg_to_inst_len;
          if (sreg.32 < D.25184) goto <D.25195>; else goto <D.25196>;
          <D.25195>:
          D.25187 = cfg->vreg_to_inst;
          sreg.33 = (unsigned int) sreg;
          D.25189 = sreg.33 * 4;
          D.25190 = D.25187 + D.25189;
          iftmp.34 = *D.25190;
          goto <D.25197>;
          <D.25196>:
          iftmp.34 = 0B;
          <D.25197>:
          var = iftmp.34;
          idx = var->data.op[0].const_val;
          D.25145 = cfg->vars;
          idx.35 = (unsigned int) idx;
          D.25199 = idx.35 * 56;
          vi = D.25145 + D.25199;
          D.25138 = cfg->verbose_level;
          if (D.25138 > 1) goto <D.25200>; else goto <D.25201>;
          <D.25200>:
          printf ("\tGEN: R%d(%d)\n", sreg, idx);
          <D.25201>:
          idx.35 = (unsigned int) idx;
          D.25199 = idx.35 * 56;
          D.25202 = vars + D.25199;
          inst_num.31 = (unsigned int) inst_num;
          D.25153 = abs_pos + inst_num.31;
          D.25154 = (int) D.25153;
          update_live_range (D.25202, D.25154);
          D.25155 = bb->kill_set;
          idx.35 = (unsigned int) idx;
          D.25203 = idx.35 / 32;
          D.25204 = D.25155->data[D.25203];
          D.25205 = idx & 31;
          D.25206 = 1 << D.25205;
          D.25207 = D.25204 & D.25206;
          if (D.25207 == 0) goto <D.25208>; else goto <D.25209>;
          <D.25208>:
          D.25163 = bb->gen_set;
          idx.35 = (unsigned int) idx;
          D.25210 = idx.35 / 32;
          D.25163 = bb->gen_set;
          D.25211 = D.25163->data[D.25210];
          D.25205 = idx & 31;
          D.25206 = 1 << D.25205;
          D.25212 = D.25211 | D.25206;
          D.25163->data[D.25210] = D.25212;
          <D.25209>:
          D.25213 = vi->spill_costs;
          D.25168 = bb->nesting;
          D.25169 = (int) D.25168;
          D.25170 = D.25169 << 1;
          D.25171 = 1 << D.25170;
          D.25214 = D.25213 + D.25171;
          vi->spill_costs = D.25214;
        }
        <D.25193>:
        <D.25186>:
        <D.25182>:
        i = i + 1;
        <D.24391>:
        if (i < num_sregs) goto <D.24390>; else goto <D.24392>;
        <D.24392>:
        D.25215 = *spec;
        if (D.25215 != 32) goto <D.25216>; else goto <D.25217>;
        <D.25216>:
        D.25218 = ins->dreg;
        D.25219 = (unsigned int) D.25218;
        D.25184 = cfg->vreg_to_inst_len;
        if (D.25219 < D.25184) goto <D.25220>; else goto <D.25221>;
        <D.25220>:
        D.25187 = cfg->vreg_to_inst;
        D.25218 = ins->dreg;
        D.25222 = (unsigned int) D.25218;
        D.25223 = D.25222 * 4;
        D.25224 = D.25187 + D.25223;
        D.25225 = *D.25224;
        if (D.25225 != 0B) goto <D.25226>; else goto <D.25227>;
        <D.25226>:
        {
          struct MonoInst * var;
          int idx;
          struct MonoMethodVar * vi;

          D.25218 = ins->dreg;
          D.25219 = (unsigned int) D.25218;
          D.25184 = cfg->vreg_to_inst_len;
          if (D.25219 < D.25184) goto <D.25229>; else goto <D.25230>;
          <D.25229>:
          D.25187 = cfg->vreg_to_inst;
          D.25218 = ins->dreg;
          D.25222 = (unsigned int) D.25218;
          D.25223 = D.25222 * 4;
          D.25224 = D.25187 + D.25223;
          iftmp.36 = *D.25224;
          goto <D.25231>;
          <D.25230>:
          iftmp.36 = 0B;
          <D.25231>:
          var = iftmp.36;
          idx = var->data.op[0].const_val;
          D.25145 = cfg->vars;
          idx.37 = (unsigned int) idx;
          D.25233 = idx.37 * 56;
          vi = D.25145 + D.25233;
          D.25134 = ins->opcode;
          D.25234 = D.25134 + 65162;
          if (D.25234 <= 13) goto <D.25235>; else goto <D.25236>;
          <D.25235>:
          idx.37 = (unsigned int) idx;
          D.25233 = idx.37 * 56;
          D.25237 = vars + D.25233;
          inst_num.31 = (unsigned int) inst_num;
          D.25153 = abs_pos + inst_num.31;
          D.25154 = (int) D.25153;
          update_live_range (D.25237, D.25154);
          D.25155 = bb->kill_set;
          idx.37 = (unsigned int) idx;
          D.25238 = idx.37 / 32;
          D.25239 = D.25155->data[D.25238];
          D.25240 = idx & 31;
          D.25241 = 1 << D.25240;
          D.25242 = D.25239 & D.25241;
          if (D.25242 == 0) goto <D.25243>; else goto <D.25244>;
          <D.25243>:
          D.25163 = bb->gen_set;
          idx.37 = (unsigned int) idx;
          D.25245 = idx.37 / 32;
          D.25163 = bb->gen_set;
          D.25246 = D.25163->data[D.25245];
          D.25240 = idx & 31;
          D.25241 = 1 << D.25240;
          D.25247 = D.25246 | D.25241;
          D.25163->data[D.25245] = D.25247;
          <D.25244>:
          D.25248 = vi->spill_costs;
          D.25168 = bb->nesting;
          D.25169 = (int) D.25168;
          D.25170 = D.25169 << 1;
          D.25171 = 1 << D.25170;
          D.25249 = D.25248 + D.25171;
          vi->spill_costs = D.25249;
          goto <D.25250>;
          <D.25236>:
          D.25138 = cfg->verbose_level;
          if (D.25138 > 1) goto <D.25251>; else goto <D.25252>;
          <D.25251>:
          D.25218 = ins->dreg;
          printf ("\tKILL: R%d(%d)\n", D.25218, idx);
          <D.25252>:
          idx.37 = (unsigned int) idx;
          D.25233 = idx.37 * 56;
          D.25237 = vars + D.25233;
          inst_num.31 = (unsigned int) inst_num;
          D.25153 = abs_pos + inst_num.31;
          D.25253 = D.25153 + 1;
          D.25254 = (int) D.25253;
          update_live_range (D.25237, D.25254);
          D.25155 = bb->kill_set;
          idx.37 = (unsigned int) idx;
          D.25255 = idx.37 / 32;
          D.25155 = bb->kill_set;
          D.25256 = D.25155->data[D.25255];
          D.25240 = idx & 31;
          D.25241 = 1 << D.25240;
          D.25257 = D.25256 | D.25241;
          D.25155->data[D.25255] = D.25257;
          D.25248 = vi->spill_costs;
          D.25168 = bb->nesting;
          D.25169 = (int) D.25168;
          D.25170 = D.25169 << 1;
          D.25171 = 1 << D.25170;
          D.25249 = D.25248 + D.25171;
          vi->spill_costs = D.25249;
          <D.25250>:
        }
        <D.25227>:
        <D.25221>:
        <D.25217>:
      }
    finally
      {
        sregs = {CLOBBER};
      }
  }
  <D.24383>:
  ins = ins->next;
  inst_num = inst_num + 2;
  <D.24397>:
  if (ins != 0B) goto <D.24396>; else goto <D.24398>;
  <D.24398>:
}


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

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


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

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


memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.25264;
  unsigned int D.25265;

  D.25265 = __builtin_object_size (__dest, 0);
  D.25264 = __builtin___memcpy_chk (__dest, __src, __len, D.25265);
  return D.25264;
}


update_live_range (struct MonoMethodVar * var, int abs_pos)
{
  unsigned int D.25267;
  unsigned int abs_pos.38;
  unsigned int D.25271;

  D.25267 = var->range.first_use.abs_pos;
  abs_pos.38 = (unsigned int) abs_pos;
  if (D.25267 > abs_pos.38) goto <D.25269>; else goto <D.25270>;
  <D.25269>:
  abs_pos.38 = (unsigned int) abs_pos;
  var->range.first_use.abs_pos = abs_pos.38;
  <D.25270>:
  D.25271 = var->range.last_use.abs_pos;
  abs_pos.38 = (unsigned int) abs_pos;
  if (D.25271 < abs_pos.38) goto <D.25272>; else goto <D.25273>;
  <D.25272>:
  abs_pos.38 = (unsigned int) abs_pos;
  var->range.last_use.abs_pos = abs_pos.38;
  <D.25273>:
}


mono_bitset_print (struct MonoBitSet * set)
{
  unsigned int i.39;
  int D.25275;
  unsigned int D.25280;
  int i;
  gboolean first;

  first = 1;
  printf ("{");
  i = 0;
  goto <D.24311>;
  <D.24310>:
  i.39 = (unsigned int) i;
  D.25275 = mono_bitset_test (set, i.39);
  if (D.25275 != 0) goto <D.25276>; else goto <D.25277>;
  <D.25276>:
  if (first == 0) goto <D.25278>; else goto <D.25279>;
  <D.25278>:
  printf (", ");
  <D.25279>:
  printf ("%d", i);
  first = 0;
  <D.25277>:
  i = i + 1;
  <D.24311>:
  i.39 = (unsigned int) i;
  D.25280 = mono_bitset_size (set);
  if (i.39 < D.25280) goto <D.24310>; else goto <D.24312>;
  <D.24312>:
  printf ("}\n");
}


optimize_initlocals (struct MonoCompile * cfg)
{
  unsigned int D.25281;
  unsigned int D.25282;
  struct MonoBasicBlock * D.25283;
  int D.25284;
  int D.25285;
  int D.25286;
  short unsigned int D.25287;
  int D.25288;
  int D.25289;
  signed char D.25290;
  int D.25291;
  unsigned int D.25292;
  unsigned int D.25293;
  unsigned int D.25294;
  int D.25295;
  unsigned int D.25296;
  unsigned int D.25297;
  short unsigned int D.25298;
  int D.25301;
  unsigned int D.25302;
  unsigned int D.25303;
  unsigned int D.25304;
  int D.25305;
  unsigned int D.25306;
  unsigned int D.25307;
  int D.25308;
  char D.25309;
  struct MonoInst * iftmp.40;
  unsigned int D.25315;
  unsigned int D.25316;
  struct MonoInst * * D.25319;
  unsigned int D.25320;
  struct MonoInst * * D.25321;
  unsigned int D.25325;
  unsigned int D.25326;
  unsigned int D.25327;
  struct MonoBitSet * D.25330;
  int D.25331;
  unsigned int D.25332;
  unsigned int D.25333;
  unsigned int D.25334;
  int D.25335;
  unsigned int D.25336;
  unsigned int D.25337;
  struct MonoInst * D.25340;
  unsigned char D.25343;
  int D.25344;
  int D.25345;
  unsigned char D.25348;
  unsigned char D.25349;
  unsigned char D.25352;
  short unsigned int D.25355;
  short unsigned int D.25356;
  _Bool D.25357;
  _Bool D.25358;
  _Bool D.25359;
  struct MonoMethodVar * D.25362;
  unsigned int D.25363;
  struct MonoMethodVar * D.25364;
  int D.25365;
  int D.25366;
  struct MonoBitSet * used;
  struct MonoInst * ins;
  struct MonoBasicBlock * initlocals_bb;

  D.25281 = cfg->next_vreg;
  D.25282 = D.25281 + 1;
  used = mono_bitset_new (D.25282, 0);
  mono_bitset_clear_all (used);
  D.25283 = cfg->bb_entry;
  initlocals_bb = D.25283->next_bb;
  ins = initlocals_bb->code;
  goto <D.24539>;
  <D.24538>:
  {
    int num_sregs;
    int i;
    int sregs[3];

    try
      {
        D.25284 = ins->sreg1;
        sregs[0] = D.25284;
        D.25285 = ins->sreg2;
        sregs[1] = D.25285;
        D.25286 = ins->sreg3;
        sregs[2] = D.25286;
        D.25287 = ins->opcode;
        D.25288 = (int) D.25287;
        D.25289 = D.25288 + -313;
        D.25290 = ins_sreg_counts[D.25289];
        num_sregs = (int) D.25290;
        i = 0;
        goto <D.24536>;
        <D.24535>:
        D.25291 = sregs[i];
        D.25292 = (unsigned int) D.25291;
        D.25293 = D.25292 / 32;
        D.25294 = used->data[D.25293];
        D.25291 = sregs[i];
        D.25295 = D.25291 & 31;
        D.25296 = 1 << D.25295;
        D.25297 = D.25294 | D.25296;
        used->data[D.25293] = D.25297;
        i = i + 1;
        <D.24536>:
        if (i < num_sregs) goto <D.24535>; else goto <D.24537>;
        <D.24537>:
        D.25287 = ins->opcode;
        D.25298 = D.25287 + 65162;
        if (D.25298 <= 13) goto <D.25299>; else goto <D.25300>;
        <D.25299>:
        D.25301 = ins->dreg;
        D.25302 = (unsigned int) D.25301;
        D.25303 = D.25302 / 32;
        D.25304 = used->data[D.25303];
        D.25301 = ins->dreg;
        D.25305 = D.25301 & 31;
        D.25306 = 1 << D.25305;
        D.25307 = D.25304 | D.25306;
        used->data[D.25303] = D.25307;
        <D.25300>:
      }
    finally
      {
        sregs = {CLOBBER};
      }
  }
  ins = ins->next;
  <D.24539>:
  if (ins != 0B) goto <D.24538>; else goto <D.24540>;
  <D.24540>:
  ins = initlocals_bb->code;
  goto <D.24545>;
  <D.24544>:
  {
    const char * spec;

    D.25287 = ins->opcode;
    D.25288 = (int) D.25287;
    D.25289 = D.25288 + -313;
    D.25308 = D.25289 * 4;
    spec = &ins_info[D.25308];
    D.25309 = *spec;
    if (D.25309 != 32) goto <D.25310>; else goto <D.25311>;
    <D.25310>:
    D.25287 = ins->opcode;
    D.25298 = D.25287 + 65162;
    if (D.25298 > 13) goto <D.25312>; else goto <D.25313>;
    <D.25312>:
    {
      struct MonoInst * var;

      D.25301 = ins->dreg;
      D.25315 = (unsigned int) D.25301;
      D.25316 = cfg->vreg_to_inst_len;
      if (D.25315 < D.25316) goto <D.25317>; else goto <D.25318>;
      <D.25317>:
      D.25319 = cfg->vreg_to_inst;
      D.25301 = ins->dreg;
      D.25302 = (unsigned int) D.25301;
      D.25320 = D.25302 * 4;
      D.25321 = D.25319 + D.25320;
      iftmp.40 = *D.25321;
      goto <D.25322>;
      <D.25318>:
      iftmp.40 = 0B;
      <D.25322>:
      var = iftmp.40;
      if (var != 0B) goto <D.25323>; else goto <D.25324>;
      <D.25323>:
      D.25301 = ins->dreg;
      D.25302 = (unsigned int) D.25301;
      D.25325 = D.25302 / 32;
      D.25326 = used->data[D.25325];
      D.25301 = ins->dreg;
      D.25305 = D.25301 & 31;
      D.25306 = 1 << D.25305;
      D.25327 = D.25326 & D.25306;
      if (D.25327 == 0) goto <D.25328>; else goto <D.25329>;
      <D.25328>:
      D.25330 = initlocals_bb->live_out_set;
      D.25331 = var->data.op[0].const_val;
      D.25332 = (unsigned int) D.25331;
      D.25333 = D.25332 / 32;
      D.25334 = D.25330->data[D.25333];
      D.25331 = var->data.op[0].const_val;
      D.25335 = D.25331 & 31;
      D.25336 = 1 << D.25335;
      D.25337 = D.25334 & D.25336;
      if (D.25337 == 0) goto <D.25338>; else goto <D.25339>;
      <D.25338>:
      D.25340 = cfg->ret;
      if (D.25340 != var) goto <D.25341>; else goto <D.25342>;
      <D.25341>:
      D.25343 = var->flags;
      D.25344 = (int) D.25343;
      D.25345 = D.25344 & 20;
      if (D.25345 == 0) goto <D.25346>; else goto <D.25347>;
      <D.25346>:
      D.25348 = BIT_FIELD_REF <*cfg, 8, 3408>;
      D.25349 = D.25348 & 16;
      if (D.25349 != 0) goto <D.25350>; else goto <D.25351>;
      <D.25350>:
      D.25352 = var->type;
      if (D.25352 == 6) goto <D.25353>; else goto <D.25354>;
      <D.25353>:
      // predicted unlikely by continue predictor.
      goto <D.24543>;
      <D.25354>:
      <D.25351>:
      D.25355 = ins->opcode;
      D.25356 = D.25355 + 65174;
      D.25357 = D.25356 <= 1;
      D.25358 = D.25355 == 365;
      D.25359 = D.25357 | D.25358;
      if (D.25359 != 0) goto <D.25360>; else goto <D.25361>;
      <D.25360>:
      ins->opcode = 316;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.25286 = ins->sreg3;
      ins->sreg2 = D.25286;
      D.25285 = ins->sreg2;
      ins->sreg1 = D.25285;
      D.25362 = cfg->vars;
      D.25331 = var->data.op[0].const_val;
      D.25332 = (unsigned int) D.25331;
      D.25363 = D.25332 * 56;
      D.25364 = D.25362 + D.25363;
      D.25362 = cfg->vars;
      D.25331 = var->data.op[0].const_val;
      D.25332 = (unsigned int) D.25331;
      D.25363 = D.25332 * 56;
      D.25364 = D.25362 + D.25363;
      D.25365 = D.25364->spill_costs;
      D.25366 = D.25365 + -1;
      D.25364->spill_costs = D.25366;
      <D.25361>:
      <D.25347>:
      <D.25342>:
      <D.25339>:
      <D.25329>:
      <D.25324>:
    }
    <D.25313>:
    <D.25311>:
  }
  <D.24543>:
  ins = ins->next;
  <D.24545>:
  if (ins != 0B) goto <D.24544>; else goto <D.24546>;
  <D.24546>:
  monoeg_g_free (used);
}


mono_linterval_add_range (struct MonoCompile * cfg, struct MonoLiveInterval * interval, int from, int to)
{
  _Bool D.25367;
  long int D.25368;
  long int D.25369;
  int iftmp.41;
  struct MonoLiveRange2 * D.25375;
  int D.25377;
  _Bool D.25380;
  long int D.25381;
  long int D.25382;
  int D.25386;
  int D.25390;
  struct MonoMemPool * D.25396;
  struct MonoLiveRange2 * prev_range;
  struct MonoLiveRange2 * next_range;
  struct MonoLiveRange2 * new_range;

  D.25367 = to < from;
  D.25368 = (long int) D.25367;
  D.25369 = __builtin_expect (D.25368, 0);
  if (D.25369 != 0) goto <D.25370>; else goto <D.25371>;
  <D.25370>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "liveness.c", 637, "to >= from");
  <D.25371>:
  D.25375 = interval->range;
  if (D.25375 != 0B) goto <D.25376>; else goto <D.25373>;
  <D.25376>:
  D.25375 = interval->range;
  D.25377 = D.25375->from;
  if (D.25377 > from) goto <D.25378>; else goto <D.25373>;
  <D.25378>:
  D.25375 = interval->range;
  D.25377 = D.25375->from;
  if (D.25377 == to) goto <D.25379>; else goto <D.25373>;
  <D.25379>:
  iftmp.41 = 1;
  goto <D.25374>;
  <D.25373>:
  iftmp.41 = 0;
  <D.25374>:
  D.25380 = iftmp.41 != 0;
  D.25381 = (long int) D.25380;
  D.25382 = __builtin_expect (D.25381, 1);
  if (D.25382 != 0) goto <D.25383>; else goto <D.25384>;
  <D.25383>:
  D.25375 = interval->range;
  D.25375->from = from;
  return;
  <D.25384>:
  prev_range = 0B;
  next_range = interval->range;
  goto <D.24557>;
  <D.24556>:
  prev_range = next_range;
  next_range = next_range->next;
  <D.24557>:
  if (next_range != 0B) goto <D.25385>; else goto <D.24558>;
  <D.25385>:
  D.25386 = next_range->from;
  if (D.25386 <= from) goto <D.24556>; else goto <D.24558>;
  <D.24558>:
  if (prev_range != 0B) goto <D.25389>; else goto <D.25387>;
  <D.25389>:
  D.25390 = prev_range->to;
  if (D.25390 == from) goto <D.25391>; else goto <D.25387>;
  <D.25391>:
  prev_range->to = to;
  goto <D.25388>;
  <D.25387>:
  if (next_range != 0B) goto <D.25394>; else goto <D.25392>;
  <D.25394>:
  D.25386 = next_range->from;
  if (D.25386 == to) goto <D.25395>; else goto <D.25392>;
  <D.25395>:
  next_range->from = from;
  goto <D.25393>;
  <D.25392>:
  D.25396 = cfg->mempool;
  new_range = mono_mempool_alloc (D.25396, 12);
  new_range->from = from;
  new_range->to = to;
  new_range->next = 0B;
  if (prev_range != 0B) goto <D.25397>; else goto <D.25398>;
  <D.25397>:
  prev_range->next = new_range;
  goto <D.25399>;
  <D.25398>:
  interval->range = new_range;
  <D.25399>:
  if (next_range != 0B) goto <D.25400>; else goto <D.25401>;
  <D.25400>:
  new_range->next = next_range;
  goto <D.25402>;
  <D.25401>:
  interval->last_range = new_range;
  <D.25402>:
  <D.25393>:
  <D.25388>:
}


mono_linterval_print (struct MonoLiveInterval * interval)
{
  int D.25404;
  int D.25405;
  struct MonoLiveRange2 * range;

  range = interval->range;
  goto <D.24564>;
  <D.24563>:
  D.25404 = range->from;
  D.25405 = range->to;
  printf ("[%x-%x] ", D.25404, D.25405);
  range = range->next;
  <D.24564>:
  if (range != 0B) goto <D.24563>; else goto <D.24565>;
  <D.24565>:
}


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


mono_linterval_covers (struct MonoLiveInterval * interval, int pos)
{
  int D.25406;
  int D.25409;
  gboolean D.25412;
  struct MonoLiveRange2 * range;

  range = interval->range;
  goto <D.24575>;
  <D.24574>:
  D.25406 = range->from;
  if (D.25406 <= pos) goto <D.25407>; else goto <D.25408>;
  <D.25407>:
  D.25409 = range->to;
  if (D.25409 >= pos) goto <D.25410>; else goto <D.25411>;
  <D.25410>:
  D.25412 = 1;
  return D.25412;
  <D.25411>:
  <D.25408>:
  D.25406 = range->from;
  if (D.25406 > pos) goto <D.25413>; else goto <D.25414>;
  <D.25413>:
  D.25412 = 0;
  return D.25412;
  <D.25414>:
  range = range->next;
  <D.24575>:
  if (range != 0B) goto <D.24574>; else goto <D.24576>;
  <D.24576>:
  D.25412 = 0;
  return D.25412;
}


mono_linterval_get_intersect_pos (struct MonoLiveInterval * i1, struct MonoLiveInterval * i2)
{
  int D.25416;
  int D.25417;
  int D.25420;
  int D.25421;
  gint32 D.25426;
  struct MonoLiveRange2 * r1;
  struct MonoLiveRange2 * r2;

  r1 = i1->range;
  goto <D.24587>;
  <D.24586>:
  r2 = i2->range;
  goto <D.24584>;
  <D.24583>:
  D.25416 = r2->to;
  D.25417 = r1->from;
  if (D.25416 > D.25417) goto <D.25418>; else goto <D.25419>;
  <D.25418>:
  D.25420 = r2->from;
  D.25421 = r1->to;
  if (D.25420 < D.25421) goto <D.25422>; else goto <D.25423>;
  <D.25422>:
  D.25420 = r2->from;
  D.25417 = r1->from;
  if (D.25420 <= D.25417) goto <D.25424>; else goto <D.25425>;
  <D.25424>:
  D.25426 = r1->from;
  return D.25426;
  <D.25425>:
  D.25426 = r2->from;
  return D.25426;
  <D.25423>:
  <D.25419>:
  r2 = r2->next;
  <D.24584>:
  if (r2 != 0B) goto <D.24583>; else goto <D.24585>;
  <D.24585>:
  r1 = r1->next;
  <D.24587>:
  if (r1 != 0B) goto <D.24586>; else goto <D.24588>;
  <D.24588>:
  D.25426 = -1;
  return D.25426;
}


mono_linterval_split (struct MonoCompile * cfg, struct MonoLiveInterval * interval, struct MonoLiveInterval * * i1, struct MonoLiveInterval * * i2, int pos)
{
  int iftmp.42;
  struct MonoLiveRange2 * D.25432;
  int D.25433;
  struct MonoLiveRange2 * D.25435;
  int D.25436;
  _Bool D.25437;
  long int D.25438;
  long int D.25439;
  struct MonoMemPool * D.25442;
  void * D.25443;
  void * D.25444;
  int D.25445;
  struct MonoLiveInterval * D.25448;
  int D.25449;
  int D.25455;
  struct MonoLiveInterval * D.25456;
  struct MonoLiveRange2 * r;

  D.25432 = interval->range;
  D.25433 = D.25432->from;
  if (D.25433 >= pos) goto <D.25429>; else goto <D.25434>;
  <D.25434>:
  D.25435 = interval->last_range;
  D.25436 = D.25435->to;
  if (D.25436 < pos) goto <D.25429>; else goto <D.25430>;
  <D.25429>:
  iftmp.42 = 1;
  goto <D.25431>;
  <D.25430>:
  iftmp.42 = 0;
  <D.25431>:
  D.25437 = iftmp.42 != 0;
  D.25438 = (long int) D.25437;
  D.25439 = __builtin_expect (D.25438, 0);
  if (D.25439 != 0) goto <D.25440>; else goto <D.25441>;
  <D.25440>:
  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.25441>:
  D.25442 = cfg->mempool;
  D.25443 = mono_mempool_alloc0 (D.25442, 8);
  *i1 = D.25443;
  D.25442 = cfg->mempool;
  D.25444 = mono_mempool_alloc0 (D.25442, 8);
  *i2 = D.25444;
  r = interval->range;
  goto <D.24598>;
  <D.24597>:
  D.25445 = r->to;
  if (D.25445 < pos) goto <D.25446>; else goto <D.25447>;
  <D.25446>:
  D.25448 = *i1;
  D.25449 = r->from;
  D.25445 = r->to;
  mono_linterval_add_range (cfg, D.25448, D.25449, D.25445);
  goto <D.25450>;
  <D.25447>:
  D.25449 = r->from;
  if (D.25449 < pos) goto <D.25453>; else goto <D.25451>;
  <D.25453>:
  D.25445 = r->to;
  if (D.25445 >= pos) goto <D.25454>; else goto <D.25451>;
  <D.25454>:
  D.25448 = *i1;
  D.25449 = r->from;
  D.25455 = pos + -1;
  mono_linterval_add_range (cfg, D.25448, D.25449, D.25455);
  D.25456 = *i2;
  D.25445 = r->to;
  mono_linterval_add_range (cfg, D.25456, pos, D.25445);
  goto <D.25452>;
  <D.25451>:
  D.25456 = *i2;
  D.25449 = r->from;
  D.25445 = r->to;
  mono_linterval_add_range (cfg, D.25456, D.25449, D.25445);
  <D.25452>:
  <D.25450>:
  r = r->next;
  <D.24598>:
  if (r != 0B) goto <D.24597>; else goto <D.24599>;
  <D.24599>:
}


mono_analyze_liveness_gc (struct MonoCompile * cfg)
{
  unsigned int D.25457;
  unsigned int D.25460;
  unsigned int max_vars.43;
  unsigned int D.25462;
  unsigned int D.25463;
  unsigned int D.25464;
  struct MonoMethodVar * D.25465;
  unsigned int idx.44;
  unsigned int D.25467;
  int D.25468;
  unsigned int D.25469;
  unsigned int D.25470;
  struct MonoMethodVar * * D.25471;
  struct MonoMemPool * D.25472;
  unsigned int reverse_len.45;
  unsigned int D.25474;
  int D.25475;
  int D.25476;
  int D.25479;
  struct MonoInst * D.25480;
  unsigned int D.25483;
  unsigned int D.25484;
  struct MonoBitSet * D.25485;
  unsigned int j.46;
  unsigned int D.25489;
  unsigned int D.25490;
  struct MonoInst * * D.25493;
  unsigned int k.47;
  unsigned int D.25495;
  struct MonoInst * * D.25496;
  struct MonoInst * D.25497;
  unsigned char D.25498;
  signed char D.25499;
  gint32 * D.25504;
  unsigned int new_reverse_len.48;
  unsigned int D.25508;
  unsigned int nins.49;
  unsigned int D.25510;
  struct MonoInst * * D.25511;
  unsigned int i.50;
  unsigned int D.25513;
  struct MonoInst * * D.25514;
  struct GSList * callsites.51;
  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.25457 = cfg->verbose_level;
      if (D.25457 > 1) goto <D.25458>; else goto <D.25459>;
      <D.25458>:
      printf ("\n------------ GC LIVENESS: ----------\n");
      <D.25459>:
      D.25460 = cfg->num_varinfo;
      max_vars = (int) D.25460;
      max_vars.43 = (unsigned int) max_vars;
      D.25462 = max_vars.43 * 4;
      last_use = monoeg_malloc0 (D.25462);
      D.25463 = cfg->next_vreg;
      D.25464 = D.25463 * 4;
      vreg_to_varinfo = monoeg_malloc0 (D.25464);
      idx = 0;
      goto <D.24642>;
      <D.24641>:
      {
        struct MonoMethodVar * vi;

        D.25465 = cfg->vars;
        idx.44 = (unsigned int) idx;
        D.25467 = idx.44 * 56;
        vi = D.25465 + D.25467;
        D.25468 = vi->vreg;
        D.25469 = (unsigned int) D.25468;
        D.25470 = D.25469 * 4;
        D.25471 = vreg_to_varinfo + D.25470;
        *D.25471 = vi;
      }
      idx = idx + 1;
      <D.24642>:
      if (idx < max_vars) goto <D.24641>; else goto <D.24643>;
      <D.24643>:
      reverse_len = 1024;
      D.25472 = cfg->mempool;
      reverse_len.45 = (unsigned int) reverse_len;
      D.25474 = reverse_len.45 * 4;
      reverse = mono_mempool_alloc (D.25472, D.25474);
      bb = cfg->bb_entry;
      goto <D.24666>;
      <D.24665>:
      {
        struct MonoInst * ins;

        block_from = bb->real_native_offset;
        D.25475 = bb->native_offset;
        D.25476 = bb->native_length;
        block_to = D.25475 + D.25476;
        D.25457 = cfg->verbose_level;
        if (D.25457 > 1) goto <D.25477>; else goto <D.25478>;
        <D.25477>:
        D.25479 = bb->block_num;
        printf ("GC LIVENESS BB%d:\n", D.25479);
        <D.25478>:
        D.25480 = bb->code;
        if (D.25480 == 0B) goto <D.25481>; else goto <D.25482>;
        <D.25481>:
        // predicted unlikely by continue predictor.
        goto <D.24645>;
        <D.25482>:
        max_vars.43 = (unsigned int) max_vars;
        D.25462 = max_vars.43 * 4;
        memset (last_use, 0, D.25462);
        max_vars.43 = (unsigned int) max_vars;
        D.25483 = max_vars.43 + 31;
        D.25484 = D.25483 / 32;
        max = (int) D.25484;
        j = 0;
        goto <D.24654>;
        <D.24653>:
        {
          gsize bits_out;
          int k;

          D.25485 = bb->live_out_set;
          if (D.25485 == 0B) goto <D.25486>; else goto <D.25487>;
          <D.25486>:
          // predicted unlikely by continue predictor.
          goto <D.24648>;
          <D.25487>:
          D.25485 = bb->live_out_set;
          bits_out = D.25485->data[j];
          j.46 = (unsigned int) j;
          D.25489 = j.46 * 32;
          k = (int) D.25489;
          goto <D.24651>;
          <D.24650>:
          D.25490 = bits_out & 1;
          if (D.25490 != 0) goto <D.25491>; else goto <D.25492>;
          <D.25491>:
          D.25493 = cfg->varinfo;
          k.47 = (unsigned int) k;
          D.25495 = k.47 * 4;
          D.25496 = D.25493 + D.25495;
          D.25497 = *D.25496;
          D.25498 = D.25497->flags;
          D.25499 = (signed char) D.25498;
          if (D.25499 < 0) goto <D.25500>; else goto <D.25501>;
          <D.25500>:
          {
            int vreg;

            D.25493 = cfg->varinfo;
            k.47 = (unsigned int) k;
            D.25495 = k.47 * 4;
            D.25496 = D.25493 + D.25495;
            D.25497 = *D.25496;
            vreg = get_vreg_from_var (cfg, D.25497);
            D.25457 = cfg->verbose_level;
            if (D.25457 > 1) goto <D.25502>; else goto <D.25503>;
            <D.25502>:
            printf ("Var R%d live at exit, last_use set to %x.\n", vreg, block_to);
            <D.25503>:
            k.47 = (unsigned int) k;
            D.25495 = k.47 * 4;
            D.25504 = last_use + D.25495;
            *D.25504 = block_to;
          }
          <D.25501>:
          <D.25492>:
          bits_out = bits_out >> 1;
          k = k + 1;
          <D.24651>:
          if (bits_out != 0) goto <D.24650>; else goto <D.24652>;
          <D.24652>:
        }
        <D.24648>:
        j = j + 1;
        <D.24654>:
        if (j < max) goto <D.24653>; else goto <D.24655>;
        <D.24655>:
        nins = 0;
        pos = block_from;
        ins = bb->code;
        goto <D.24659>;
        <D.24658>:
        if (nins >= reverse_len) goto <D.25505>; else goto <D.25506>;
        <D.25505>:
        {
          int new_reverse_len;
          struct MonoInst * * new_reverse;

          new_reverse_len = reverse_len * 2;
          D.25472 = cfg->mempool;
          new_reverse_len.48 = (unsigned int) new_reverse_len;
          D.25508 = new_reverse_len.48 * 4;
          new_reverse = mono_mempool_alloc (D.25472, D.25508);
          reverse_len.45 = (unsigned int) reverse_len;
          D.25474 = reverse_len.45 * 4;
          memcpy (new_reverse, reverse, D.25474);
          reverse = new_reverse;
          reverse_len = new_reverse_len;
        }
        <D.25506>:
        nins.49 = (unsigned int) nins;
        D.25510 = nins.49 * 4;
        D.25511 = reverse + D.25510;
        *D.25511 = ins;
        ins = ins->next;
        nins = nins + 1;
        pos = pos + 1;
        <D.24659>:
        if (ins != 0B) goto <D.24658>; else goto <D.24660>;
        <D.24660>:
        callsites = 0B;
        i = nins + -1;
        goto <D.24663>;
        <D.24662>:
        {
          struct MonoInst * ins;

          i.50 = (unsigned int) i;
          D.25513 = i.50 * 4;
          D.25514 = reverse + D.25513;
          ins = *D.25514;
          update_liveness_gc (cfg, bb, ins, last_use, vreg_to_varinfo, &callsites);
        }
        i = i + -1;
        <D.24663>:
        if (i >= 0) goto <D.24662>; else goto <D.24664>;
        <D.24664>:
        callsites.51 = callsites;
        bb->gc_callsites = callsites.51;
      }
      <D.24645>:
      bb = bb->next_bb;
      <D.24666>:
      if (bb != 0B) goto <D.24665>; else goto <D.24667>;
      <D.24667>:
      monoeg_g_free (last_use);
      monoeg_g_free (vreg_to_varinfo);
    }
  finally
    {
      callsites = {CLOBBER};
    }
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.25518;
  int D.25523;
  void * D.25525;
  unsigned int D.25526;

  D.25518 = __builtin_constant_p (__len);
  if (D.25518 != 0) goto <D.25519>; else goto <D.25520>;
  <D.25519>:
  if (__len == 0) goto <D.25521>; else goto <D.25522>;
  <D.25521>:
  D.25523 = __builtin_constant_p (__ch);
  if (D.25523 == 0) goto <D.25516>; else goto <D.25524>;
  <D.25524>:
  if (__ch != 0) goto <D.25516>; else goto <D.25517>;
  <D.25516>:
  __warn_memset_zero_len ();
  D.25525 = __dest;
  return D.25525;
  <D.25517>:
  <D.25522>:
  <D.25520>:
  D.25526 = __builtin_object_size (__dest, 0);
  D.25525 = __builtin___memset_chk (__dest, __ch, __len, D.25526);
  return D.25525;
}


get_vreg_from_var (struct MonoCompile * cfg, struct MonoInst * var)
{
  short unsigned int D.25528;
  int D.25531;
  struct MonoMethodVar * D.25532;
  int D.25533;
  unsigned int D.25534;
  unsigned int D.25535;
  struct MonoMethodVar * D.25536;

  D.25528 = var->opcode;
  if (D.25528 == 366) goto <D.25529>; else goto <D.25530>;
  <D.25529>:
  D.25532 = cfg->vars;
  D.25533 = var->data.op[0].const_val;
  D.25534 = (unsigned int) D.25533;
  D.25535 = D.25534 * 56;
  D.25536 = D.25532 + D.25535;
  D.25531 = D.25536->vreg;
  return D.25531;
  <D.25530>:
  D.25531 = var->dreg;
  return D.25531;
}


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.25538;
  short unsigned int D.25539;
  unsigned int vreg.52;
  unsigned int D.25543;
  struct MonoMethodVar * * D.25544;
  unsigned int D.25545;
  unsigned int D.25546;
  unsigned int idx.53;
  unsigned int D.25552;
  gint32 * D.25553;
  int D.25554;
  struct GSList * D.25567;
  _Bool D.25568;
  long int D.25569;
  long int D.25570;
  struct MonoMemPool * D.25573;
  struct GSList * D.25574;
  struct GSList * D.25575;
  unsigned char D.25577;
  signed char D.25578;
  int D.25583;
  unsigned int D.25586;
  long long unsigned int D.25587;
  long long unsigned int D.25588;
  long long unsigned int D.25589;
  long long unsigned int D.25590;
  unsigned int D.25591;
  void * D.25592;
  unsigned int i.54;
  unsigned int D.25594;
  gint32 * D.25595;
  int D.25596;
  struct MonoMethodVar * D.25601;
  unsigned int D.25602;
  struct MonoMethodVar * D.25603;
  int D.25604;
  guint8 * D.25605;
  int D.25606;
  sizetype D.25607;
  guint8 * D.25608;
  unsigned char D.25609;
  signed char D.25610;
  int D.25611;
  int D.25612;
  signed char D.25613;
  signed char D.25614;
  unsigned char D.25615;
  unsigned int i.55;
  struct GSList * D.25619;

  D.25538 = ins->opcode;
  D.25539 = D.25538 + 64698;
  if (D.25539 <= 1) goto <D.25540>; else goto <D.25541>;
  <D.25540>:
  {
    int vreg;
    struct MonoMethodVar * vi;
    int idx;
    int pc_offset;

    vreg = ins->data.op[1].const_val;
    vreg.52 = (unsigned int) vreg;
    D.25543 = vreg.52 * 4;
    D.25544 = vreg_to_varinfo + D.25543;
    vi = *D.25544;
    D.25545 = vi->idx;
    idx = (int) D.25545;
    pc_offset = ins->backend.pc_offset;
    D.25546 = cfg->verbose_level;
    if (D.25546 > 1) goto <D.25547>; else goto <D.25548>;
    <D.25547>:
    printf ("\t%x: ", pc_offset);
    mono_print_ins (ins);
    <D.25548>:
    D.25538 = ins->opcode;
    if (D.25538 == 838) goto <D.25549>; else goto <D.25550>;
    <D.25549>:
    idx.53 = (unsigned int) idx;
    D.25552 = idx.53 * 4;
    D.25553 = last_use + D.25552;
    D.25554 = *D.25553;
    if (D.25554 > 0) goto <D.25555>; else goto <D.25556>;
    <D.25555>:
    D.25546 = cfg->verbose_level;
    if (D.25546 > 1) goto <D.25557>; else goto <D.25558>;
    <D.25557>:
    idx.53 = (unsigned int) idx;
    D.25552 = idx.53 * 4;
    D.25553 = last_use + D.25552;
    D.25554 = *D.25553;
    printf ("\tadd range to R%d: [%x, %x)\n", vreg, pc_offset, D.25554);
    <D.25558>:
    idx.53 = (unsigned int) idx;
    D.25552 = idx.53 * 4;
    D.25553 = last_use + D.25552;
    *D.25553 = 0;
    <D.25556>:
    goto <D.25559>;
    <D.25550>:
    idx.53 = (unsigned int) idx;
    D.25552 = idx.53 * 4;
    D.25553 = last_use + D.25552;
    D.25554 = *D.25553;
    if (D.25554 == 0) goto <D.25560>; else goto <D.25561>;
    <D.25560>:
    D.25546 = cfg->verbose_level;
    if (D.25546 > 1) goto <D.25562>; else goto <D.25563>;
    <D.25562>:
    printf ("\tlast use of R%d set to %x\n", vreg, pc_offset);
    <D.25563>:
    idx.53 = (unsigned int) idx;
    D.25552 = idx.53 * 4;
    D.25553 = last_use + D.25552;
    *D.25553 = pc_offset;
    <D.25561>:
    <D.25559>:
  }
  goto <D.25564>;
  <D.25541>:
  D.25538 = ins->opcode;
  if (D.25538 == 841) goto <D.25565>; else goto <D.25566>;
  <D.25565>:
  {
    struct GCCallSite * last;

    D.25567 = *callsites;
    D.25568 = D.25567 == 0B;
    D.25569 = (long int) D.25568;
    D.25570 = __builtin_expect (D.25569, 0);
    if (D.25570 != 0) goto <D.25571>; else goto <D.25572>;
    <D.25571>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "liveness.c", 1003, "*callsites");
    <D.25572>:
    D.25567 = *callsites;
    last = D.25567->data;
    D.25573 = cfg->mempool;
    D.25574 = last->param_slots;
    D.25575 = g_slist_prepend_mempool (D.25573, D.25574, ins);
    last->param_slots = D.25575;
  }
  goto <D.25576>;
  <D.25566>:
  D.25577 = ins->flags;
  D.25578 = (signed char) D.25577;
  if (D.25578 < 0) goto <D.25579>; else goto <D.25580>;
  <D.25579>:
  {
    struct GCCallSite * callsite;
    int i;

    D.25573 = cfg->mempool;
    callsite = mono_mempool_alloc0 (D.25573, 16);
    D.25546 = cfg->verbose_level;
    if (D.25546 > 1) goto <D.25581>; else goto <D.25582>;
    <D.25581>:
    D.25583 = ins->backend.pc_offset;
    printf ("\t%x: ", D.25583);
    mono_print_ins (ins);
    <D.25582>:
    D.25546 = cfg->verbose_level;
    if (D.25546 > 1) goto <D.25584>; else goto <D.25585>;
    <D.25584>:
    printf ("\t\tlive: ");
    <D.25585>:
    callsite->bb = bb;
    D.25573 = cfg->mempool;
    D.25586 = cfg->num_varinfo;
    D.25587 = (long long unsigned int) D.25586;
    D.25588 = D.25587 + 7;
    D.25589 = D.25588 & 18446744073709551608;
    D.25590 = D.25589 / 8;
    D.25591 = (unsigned int) D.25590;
    D.25592 = mono_mempool_alloc0 (D.25573, D.25591);
    callsite->liveness = D.25592;
    D.25583 = ins->backend.pc_offset;
    callsite->pc_offset = D.25583;
    i = 0;
    goto <D.24616>;
    <D.24615>:
    i.54 = (unsigned int) i;
    D.25594 = i.54 * 4;
    D.25595 = last_use + D.25594;
    D.25596 = *D.25595;
    if (D.25596 != 0) goto <D.25597>; else goto <D.25598>;
    <D.25597>:
    D.25546 = cfg->verbose_level;
    if (D.25546 > 1) goto <D.25599>; else goto <D.25600>;
    <D.25599>:
    D.25601 = cfg->vars;
    i.54 = (unsigned int) i;
    D.25602 = i.54 * 56;
    D.25603 = D.25601 + D.25602;
    D.25604 = D.25603->vreg;
    printf ("R%d", D.25604);
    <D.25600>:
    D.25605 = callsite->liveness;
    D.25606 = i / 8;
    D.25607 = (sizetype) D.25606;
    D.25608 = D.25605 + D.25607;
    D.25605 = callsite->liveness;
    D.25607 = (sizetype) D.25606;
    D.25608 = D.25605 + D.25607;
    D.25609 = *D.25608;
    D.25610 = (signed char) D.25609;
    D.25611 = i % 8;
    D.25612 = 1 << D.25611;
    D.25613 = (signed char) D.25612;
    D.25614 = D.25610 | D.25613;
    D.25615 = (unsigned char) D.25614;
    *D.25608 = D.25615;
    <D.25598>:
    i = i + 1;
    <D.24616>:
    i.55 = (unsigned int) i;
    D.25586 = cfg->num_varinfo;
    if (i.55 < D.25586) goto <D.24615>; else goto <D.24617>;
    <D.24617>:
    D.25546 = cfg->verbose_level;
    if (D.25546 > 1) goto <D.25617>; else goto <D.25618>;
    <D.25617>:
    printf ("\n");
    <D.25618>:
    D.25573 = cfg->mempool;
    D.25567 = *callsites;
    D.25619 = g_slist_prepend_mempool (D.25573, D.25567, callsite);
    *callsites = D.25619;
  }
  <D.25580>:
  <D.25576>:
  <D.25564>:
}


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

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