mono_ssa_compute (struct MonoCompile * cfg)
{
  unsigned int D.22701;
  long unsigned int D.22702;
  long unsigned int D.22703;
  unsigned int D.22704;
  unsigned int D.22705;
  _Bool D.22706;
  long int D.22707;
  long int D.22708;
  unsigned char D.22711;
  unsigned char D.22712;
  _Bool D.22713;
  long int D.22714;
  long int D.22715;
  unsigned int D.22718;
  unsigned int D.22721;
  unsigned int D.22722;
  unsigned int D.22725;
  unsigned int D.22726;
  unsigned int D.22727;
  unsigned int D.22728;
  long unsigned int D.22729;
  long unsigned int D.22730;
  long unsigned int D.22731;
  struct MonoMethodVar * D.22732;
  struct MonoBitSet * D.22733;
  sizetype D.22734;
  unsigned int i.0;
  struct MonoInst * * D.22736;
  long unsigned int D.22737;
  struct MonoInst * * D.22738;
  struct MonoInst * D.22739;
  short unsigned int D.22740;
  struct MonoBitSet * D.22743;
  long unsigned int D.22744;
  long unsigned int D.22745;
  struct MonoBasicBlock * * D.22746;
  struct MonoBasicBlock * * D.22747;
  struct MonoBasicBlock * D.22748;
  short unsigned int D.22749;
  short unsigned int D.22752;
  int D.22755;
  unsigned int D.22756;
  unsigned int D.22757;
  struct MonoInst * * D.22760;
  long unsigned int D.22761;
  long unsigned int D.22762;
  struct MonoInst * * D.22763;
  struct MonoInst * D.22764;
  struct MonoInst * iftmp.1;
  long int D.22771;
  long unsigned int D.22772;
  long unsigned int D.22773;
  struct MonoMethodVar * D.22774;
  struct MonoBitSet * D.22775;
  long unsigned int D.22776;
  struct MonoInst * iftmp.2;
  long int D.22781;
  long unsigned int D.22782;
  long unsigned int D.22783;
  struct MonoMethodVar * D.22784;
  struct MonoBitSet * D.22785;
  long unsigned int D.22786;
  int D.22787;
  long unsigned int D.22788;
  long unsigned int D.22789;
  unsigned char D.22790;
  int D.22791;
  int D.22792;
  unsigned int D.22795;
  unsigned int D.22800;
  int D.22803;
  long unsigned int D.22804;
  long unsigned int D.22805;
  struct MonoBasicBlock * * D.22806;
  struct MonoBasicBlock * D.22807;
  struct MonoBitSet * D.22812;
  long unsigned int D.22813;
  long unsigned int D.22814;
  long unsigned int D.22815;
  long unsigned int D.22816;
  struct MonoMemPool * D.22819;
  long int D.22820;
  int D.22821;
  int D.22822;
  unsigned char D.22823;
  int D.22824;
  guint16 iftmp.3;
  unsigned int D.22828;
  unsigned int D.22829;
  struct MonoClass * D.22831;
  unsigned char D.22832;
  unsigned char D.22833;
  struct MonoType * D.22836;
  unsigned char D.22837;
  unsigned char D.22838;
  struct MonoClass * D.22841;
  struct MonoBasicBlock * D.22843;
  short int D.22844;
  int D.22845;
  int D.22846;
  long unsigned int D.22847;
  unsigned int D.22848;
  unsigned int D.22849;
  void * D.22850;
  int * D.22851;
  sizetype D.22852;
  sizetype D.22853;
  sizetype D.22854;
  int * D.22855;
  int D.22856;
  struct MonoInst * D.22857;
  unsigned int idx.4;
  long unsigned int D.22860;
  long unsigned int D.22861;
  long unsigned int D.22862;
  long unsigned int D.22863;
  long unsigned int D.22864;
  long unsigned int D.22865;
  struct MonoBasicBlock * D.22866;
  int D.22867;
  unsigned int D.22870;
  int i;
  int j;
  int idx;
  int bitsize;
  struct MonoBitSet * set;
  struct MonoMethodVar * vinfo;
  struct MonoInst * ins;
  struct MonoInst * * stack;
  guint8 * buf;
  guint8 * buf_start;
  struct RenameInfo * stack_history;
  int stack_history_size;
  gboolean * originals;
  guint32 * lvreg_stack;
  gboolean * lvreg_defined;

  D.22701 = cfg->num_varinfo;
  D.22702 = (long unsigned int) D.22701;
  D.22703 = D.22702 * 80;
  vinfo = monoeg_malloc0 (D.22703);
  D.22704 = cfg->comp_done;
  D.22705 = D.22704 & 32;
  D.22706 = D.22705 != 0;
  D.22707 = (long int) D.22706;
  D.22708 = __builtin_expect (D.22707, 0);
  if (D.22708 != 0) goto <D.22709>; else goto <D.22710>;
  <D.22709>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 342, "!(cfg->comp_done & MONO_COMP_SSA)");
  <D.22710>:
  D.22711 = BIT_FIELD_REF <*cfg, 8, 5600>;
  D.22712 = D.22711 & 2;
  D.22713 = D.22712 != 0;
  D.22714 = (long int) D.22713;
  D.22715 = __builtin_expect (D.22714, 0);
  if (D.22715 != 0) goto <D.22716>; else goto <D.22717>;
  <D.22716>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 344, "!cfg->disable_ssa");
  <D.22717>:
  D.22718 = cfg->verbose_level;
  if (D.22718 > 3) goto <D.22719>; else goto <D.22720>;
  <D.22719>:
  D.22721 = cfg->next_vreg;
  D.22701 = cfg->num_varinfo;
  printf ("\nCOMPUTE SSA %d (R%d-)\n\n", D.22701, D.22721);
  <D.22720>:
  D.22704 = cfg->comp_done;
  D.22722 = D.22704 & 16;
  if (D.22722 == 0) goto <D.22723>; else goto <D.22724>;
  <D.22723>:
  mono_analyze_liveness (cfg);
  <D.22724>:
  mono_compile_dominator_info (cfg, 7);
  D.22725 = cfg->num_bblocks;
  D.22726 = mono_bitset_alloc_size (D.22725, 0);
  bitsize = (int) D.22726;
  D.22725 = cfg->num_bblocks;
  D.22727 = mono_bitset_alloc_size (D.22725, 0);
  D.22701 = cfg->num_varinfo;
  D.22728 = D.22727 * D.22701;
  D.22729 = (long unsigned int) D.22728;
  buf_start = monoeg_malloc0 (D.22729);
  buf = buf_start;
  i = 0;
  goto <D.22356>;
  <D.22355>:
  D.22730 = (long unsigned int) i;
  D.22731 = D.22730 * 80;
  D.22732 = vinfo + D.22731;
  D.22725 = cfg->num_bblocks;
  D.22733 = mono_bitset_mem_new (buf, D.22725, 0);
  D.22732->def_in = D.22733;
  D.22734 = (sizetype) bitsize;
  buf = buf + D.22734;
  D.22730 = (long unsigned int) i;
  D.22731 = D.22730 * 80;
  D.22732 = vinfo + D.22731;
  i.0 = (unsigned int) i;
  D.22732->idx = i.0;
  D.22736 = cfg->varinfo;
  D.22730 = (long unsigned int) i;
  D.22737 = D.22730 * 8;
  D.22738 = D.22736 + D.22737;
  D.22739 = *D.22738;
  D.22740 = D.22739->opcode;
  if (D.22740 == 330) goto <D.22741>; else goto <D.22742>;
  <D.22741>:
  D.22730 = (long unsigned int) i;
  D.22731 = D.22730 * 80;
  D.22732 = vinfo + D.22731;
  D.22743 = D.22732->def_in;
  D.22730 = (long unsigned int) i;
  D.22731 = D.22730 * 80;
  D.22732 = vinfo + D.22731;
  D.22743 = D.22732->def_in;
  D.22744 = D.22743->data[0];
  D.22745 = D.22744 | 1;
  D.22743->data[0] = D.22745;
  <D.22742>:
  i = i + 1;
  <D.22356>:
  i.0 = (unsigned int) i;
  D.22701 = cfg->num_varinfo;
  if (i.0 < D.22701) goto <D.22355>; else goto <D.22357>;
  <D.22357>:
  i = 0;
  goto <D.22363>;
  <D.22362>:
  D.22746 = cfg->bblocks;
  D.22730 = (long unsigned int) i;
  D.22737 = D.22730 * 8;
  D.22747 = D.22746 + D.22737;
  D.22748 = *D.22747;
  ins = D.22748->code;
  goto <D.22360>;
  <D.22359>:
  D.22749 = ins->opcode;
  if (D.22749 == 316) goto <D.22750>; else goto <D.22751>;
  <D.22750>:
  // predicted unlikely by continue predictor.
  goto <D.22358>;
  <D.22751>:
  D.22749 = ins->opcode;
  D.22752 = D.22749 + 65162;
  if (D.22752 > 16) goto <D.22753>; else goto <D.22754>;
  <D.22753>:
  D.22755 = ins->dreg;
  D.22756 = (unsigned int) D.22755;
  D.22757 = cfg->vreg_to_inst_len;
  if (D.22756 < D.22757) goto <D.22758>; else goto <D.22759>;
  <D.22758>:
  D.22760 = cfg->vreg_to_inst;
  D.22755 = ins->dreg;
  D.22761 = (long unsigned int) D.22755;
  D.22762 = D.22761 * 8;
  D.22763 = D.22760 + D.22762;
  D.22764 = *D.22763;
  if (D.22764 != 0B) goto <D.22765>; else goto <D.22766>;
  <D.22765>:
  D.22755 = ins->dreg;
  D.22756 = (unsigned int) D.22755;
  D.22757 = cfg->vreg_to_inst_len;
  if (D.22756 < D.22757) goto <D.22768>; else goto <D.22769>;
  <D.22768>:
  D.22760 = cfg->vreg_to_inst;
  D.22755 = ins->dreg;
  D.22761 = (long unsigned int) D.22755;
  D.22762 = D.22761 * 8;
  D.22763 = D.22760 + D.22762;
  iftmp.1 = *D.22763;
  goto <D.22770>;
  <D.22769>:
  iftmp.1 = 0B;
  <D.22770>:
  D.22771 = iftmp.1->data.op[0].const_val;
  D.22772 = (long unsigned int) D.22771;
  D.22773 = D.22772 * 80;
  D.22774 = vinfo + D.22773;
  D.22775 = D.22774->def_in;
  D.22730 = (long unsigned int) i;
  D.22776 = D.22730 / 64;
  D.22755 = ins->dreg;
  D.22756 = (unsigned int) D.22755;
  D.22757 = cfg->vreg_to_inst_len;
  if (D.22756 < D.22757) goto <D.22778>; else goto <D.22779>;
  <D.22778>:
  D.22760 = cfg->vreg_to_inst;
  D.22755 = ins->dreg;
  D.22761 = (long unsigned int) D.22755;
  D.22762 = D.22761 * 8;
  D.22763 = D.22760 + D.22762;
  iftmp.2 = *D.22763;
  goto <D.22780>;
  <D.22779>:
  iftmp.2 = 0B;
  <D.22780>:
  D.22781 = iftmp.2->data.op[0].const_val;
  D.22782 = (long unsigned int) D.22781;
  D.22783 = D.22782 * 80;
  D.22784 = vinfo + D.22783;
  D.22785 = D.22784->def_in;
  D.22786 = D.22785->data[D.22776];
  D.22787 = i & 63;
  D.22788 = 1 << D.22787;
  D.22789 = D.22786 | D.22788;
  D.22775->data[D.22776] = D.22789;
  <D.22766>:
  <D.22759>:
  <D.22754>:
  <D.22358>:
  ins = ins->next;
  <D.22360>:
  if (ins != 0B) goto <D.22359>; else goto <D.22361>;
  <D.22361>:
  i = i + 1;
  <D.22363>:
  i.0 = (unsigned int) i;
  D.22725 = cfg->num_bblocks;
  if (i.0 < D.22725) goto <D.22362>; else goto <D.22364>;
  <D.22364>:
  i = 0;
  goto <D.22384>;
  <D.22383>:
  {
    struct MonoInst * var;

    D.22736 = cfg->varinfo;
    D.22730 = (long unsigned int) i;
    D.22737 = D.22730 * 8;
    D.22738 = D.22736 + D.22737;
    var = *D.22738;
    D.22790 = var->flags;
    D.22791 = (int) D.22790;
    D.22792 = D.22791 & 20;
    if (D.22792 != 0) goto <D.22793>; else goto <D.22794>;
    <D.22793>:
    // predicted unlikely by continue predictor.
    goto <D.22366>;
    <D.22794>:
    D.22730 = (long unsigned int) i;
    D.22731 = D.22730 * 80;
    D.22732 = vinfo + D.22731;
    D.22743 = D.22732->def_in;
    D.22795 = mono_bitset_count (D.22743);
    if (D.22795 <= 1) goto <D.22796>; else goto <D.22797>;
    <D.22796>:
    // predicted unlikely by continue predictor.
    goto <D.22366>;
    <D.22797>:
    D.22730 = (long unsigned int) i;
    D.22731 = D.22730 * 80;
    D.22732 = vinfo + D.22731;
    D.22743 = D.22732->def_in;
    set = mono_compile_iterated_dfrontier (cfg, D.22743);
    D.22718 = cfg->verbose_level;
    if (D.22718 > 3) goto <D.22798>; else goto <D.22799>;
    <D.22798>:
    D.22800 = mono_bitset_count (set);
    if (D.22800 != 0) goto <D.22801>; else goto <D.22802>;
    <D.22801>:
    D.22803 = var->dreg;
    printf ("\tR%d needs PHI functions in ", D.22803);
    mono_blockset_print (cfg, set, "", 4294967295);
    <D.22802>:
    <D.22799>:
    idx = mono_bitset_find_start (set);
    goto <D.22381>;
    <D.22380>:
    {
      struct MonoBasicBlock * bb;

      D.22746 = cfg->bblocks;
      D.22804 = (long unsigned int) idx;
      D.22805 = D.22804 * 8;
      D.22806 = D.22746 + D.22805;
      bb = *D.22806;
      D.22807 = cfg->bb_exit;
      if (D.22807 == bb) goto <D.22808>; else goto <D.22809>;
      <D.22808>:
      // predicted unlikely by continue predictor.
      goto <D.22368>;
      <D.22809>:
      D.22704 = cfg->comp_done;
      D.22722 = D.22704 & 16;
      if (D.22722 != 0) goto <D.22810>; else goto <D.22811>;
      <D.22810>:
      D.22812 = bb->live_in_set;
      D.22730 = (long unsigned int) i;
      D.22813 = D.22730 / 64;
      D.22814 = D.22812->data[D.22813];
      D.22787 = i & 63;
      D.22815 = D.22814 >> D.22787;
      D.22816 = D.22815 & 1;
      if (D.22816 == 0) goto <D.22817>; else goto <D.22818>;
      <D.22817>:
      // predicted unlikely by continue predictor.
      goto <D.22368>;
      <D.22818>:
      <D.22811>:
      D.22819 = cfg->mempool;
      ins = mono_mempool_alloc0 (D.22819, 80);
      ins->opcode = 319;
      D.22820 = (long int) i;
      ins->data.op[0].const_val = D.22820;
      ins->sreg2 = -1;
      D.22821 = ins->sreg2;
      ins->sreg1 = D.22821;
      D.22822 = ins->sreg1;
      ins->dreg = D.22822;
      D.22823 = var->type;
      D.22824 = (int) D.22823;
      switch (D.22824) <default: <D.22835>, case 1: <D.22369>, case 2: <D.22370>, case 3: <D.22371>, case 4: <D.22375>, case 5: <D.22372>, case 6: <D.22373>, case 7: <D.22376>>
      <D.22369>:
      <D.22370>:
      <D.22371>:
      <D.22372>:
      <D.22373>:
      ins->opcode = 319;
      goto <D.22374>;
      <D.22375>:
      ins->opcode = 320;
      goto <D.22374>;
      <D.22376>:
      D.22828 = cfg->opt;
      D.22829 = D.22828 & 67108864;
      if (D.22829 != 0) goto <D.22830>; else goto <D.22826>;
      <D.22830>:
      D.22831 = var->klass;
      D.22832 = BIT_FIELD_REF <*D.22831, 8, 288>;
      D.22833 = D.22832 & 2;
      if (D.22833 != 0) goto <D.22834>; else goto <D.22826>;
      <D.22834>:
      iftmp.3 = 964;
      goto <D.22827>;
      <D.22826>:
      iftmp.3 = 321;
      <D.22827>:
      ins->opcode = iftmp.3;
      goto <D.22374>;
      <D.22835>:
      <D.22374>:
      D.22836 = var->data.op[1].vtype;
      D.22837 = BIT_FIELD_REF <*D.22836, 8, 88>;
      D.22838 = D.22837 & 64;
      if (D.22838 != 0) goto <D.22839>; else goto <D.22840>;
      <D.22839>:
      D.22841 = mono_defaults.int_class;
      ins->klass = D.22841;
      goto <D.22842>;
      <D.22840>:
      D.22831 = var->klass;
      ins->klass = D.22831;
      <D.22842>:
      D.22746 = cfg->bblocks;
      D.22804 = (long unsigned int) idx;
      D.22805 = D.22804 * 8;
      D.22806 = D.22746 + D.22805;
      D.22843 = *D.22806;
      D.22844 = D.22843->in_count;
      D.22845 = (int) D.22844;
      D.22846 = D.22845 + 1;
      D.22847 = (long unsigned int) D.22846;
      D.22848 = (unsigned int) D.22847;
      D.22849 = D.22848 * 4;
      D.22819 = cfg->mempool;
      D.22850 = mono_mempool_alloc0 (D.22819, D.22849);
      ins->data.op[1].phi_args = D.22850;
      D.22851 = ins->data.op[1].phi_args;
      D.22746 = cfg->bblocks;
      D.22804 = (long unsigned int) idx;
      D.22805 = D.22804 * 8;
      D.22806 = D.22746 + D.22805;
      D.22843 = *D.22806;
      D.22844 = D.22843->in_count;
      D.22845 = (int) D.22844;
      *D.22851 = D.22845;
      j = 0;
      goto <D.22378>;
      <D.22377>:
      D.22851 = ins->data.op[1].phi_args;
      D.22852 = (sizetype) j;
      D.22853 = D.22852 + 1;
      D.22854 = D.22853 * 4;
      D.22855 = D.22851 + D.22854;
      *D.22855 = -1;
      j = j + 1;
      <D.22378>:
      D.22746 = cfg->bblocks;
      D.22804 = (long unsigned int) idx;
      D.22805 = D.22804 * 8;
      D.22806 = D.22746 + D.22805;
      D.22843 = *D.22806;
      D.22844 = D.22843->in_count;
      D.22845 = (int) D.22844;
      if (D.22845 > j) goto <D.22377>; else goto <D.22379>;
      <D.22379>:
      D.22736 = cfg->varinfo;
      D.22730 = (long unsigned int) i;
      D.22737 = D.22730 * 8;
      D.22738 = D.22736 + D.22737;
      D.22739 = *D.22738;
      D.22856 = D.22739->dreg;
      ins->dreg = D.22856;
      D.22857 = bb->code;
      mono_bblock_insert_before_ins (bb, D.22857, ins);
    }
    <D.22368>:
    idx = mono_bitset_find_first (set, idx);
    <D.22381>:
    idx.4 = (unsigned int) idx;
    D.22725 = cfg->num_bblocks;
    if (idx.4 < D.22725) goto <D.22859>; else goto <D.22382>;
    <D.22859>:
    if (idx >= 0) goto <D.22380>; else goto <D.22382>;
    <D.22382>:
  }
  <D.22366>:
  i = i + 1;
  <D.22384>:
  i.0 = (unsigned int) i;
  D.22701 = cfg->num_varinfo;
  if (i.0 < D.22701) goto <D.22383>; else goto <D.22385>;
  <D.22385>:
  monoeg_g_free (vinfo);
  monoeg_g_free (buf_start);
  D.22701 = cfg->num_varinfo;
  D.22702 = (long unsigned int) D.22701;
  D.22860 = D.22702 * 8;
  stack = __builtin_alloca (D.22860);
  D.22701 = cfg->num_varinfo;
  D.22702 = (long unsigned int) D.22701;
  D.22860 = D.22702 * 8;
  memset (stack, 0, D.22860);
  D.22721 = cfg->next_vreg;
  D.22861 = (long unsigned int) D.22721;
  D.22862 = D.22861 * 4;
  lvreg_stack = monoeg_malloc0 (D.22862);
  D.22721 = cfg->next_vreg;
  D.22861 = (long unsigned int) D.22721;
  D.22862 = D.22861 * 4;
  lvreg_defined = monoeg_malloc0 (D.22862);
  stack_history_size = 10240;
  D.22863 = (long unsigned int) stack_history_size;
  D.22864 = D.22863 * 16;
  stack_history = monoeg_malloc (D.22864);
  D.22701 = cfg->num_varinfo;
  D.22702 = (long unsigned int) D.22701;
  D.22865 = D.22702 * 4;
  originals = monoeg_malloc0 (D.22865);
  D.22866 = cfg->bb_entry;
  D.22701 = cfg->num_varinfo;
  D.22867 = (int) D.22701;
  mono_ssa_rename_vars (cfg, D.22867, D.22866, originals, stack, lvreg_stack, lvreg_defined, stack_history, stack_history_size);
  monoeg_g_free (stack_history);
  monoeg_g_free (originals);
  monoeg_g_free (lvreg_stack);
  monoeg_g_free (lvreg_defined);
  D.22718 = cfg->verbose_level;
  if (D.22718 > 3) goto <D.22868>; else goto <D.22869>;
  <D.22868>:
  printf ("\nEND COMPUTE SSA.\n\n");
  <D.22869>:
  D.22704 = cfg->comp_done;
  D.22870 = D.22704 | 32;
  cfg->comp_done = D.22870;
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.22873;
  int D.22878;
  void * D.22880;
  long unsigned int D.22881;

  D.22873 = __builtin_constant_p (__len);
  if (D.22873 != 0) goto <D.22874>; else goto <D.22875>;
  <D.22874>:
  if (__len == 0) goto <D.22876>; else goto <D.22877>;
  <D.22876>:
  D.22878 = __builtin_constant_p (__ch);
  if (D.22878 == 0) goto <D.22871>; else goto <D.22879>;
  <D.22879>:
  if (__ch != 0) goto <D.22871>; else goto <D.22872>;
  <D.22871>:
  __warn_memset_zero_len ();
  D.22880 = __dest;
  return D.22880;
  <D.22872>:
  <D.22877>:
  <D.22875>:
  D.22881 = __builtin_object_size (__dest, 0);
  D.22880 = __builtin___memset_chk (__dest, __ch, __len, D.22881);
  return D.22880;
}


mono_ssa_rename_vars (struct MonoCompile * cfg, int max_vars, struct MonoBasicBlock * bb, gboolean * originals_used, struct MonoInst * * stack, guint32 * lvreg_stack, gboolean * lvreg_defined, struct RenameInfo * stack_history, int stack_history_size)
{
  unsigned int D.22883;
  int D.22886;
  short unsigned int D.22887;
  int D.22888;
  int D.22889;
  int D.22890;
  int D.22893;
  int D.22894;
  int D.22895;
  signed char D.22896;
  int D.22897;
  sizetype D.22898;
  const char * D.22899;
  char D.22900;
  struct MonoInst * iftmp.5;
  int D.22904;
  unsigned int D.22905;
  unsigned int D.22906;
  struct MonoInst * * D.22909;
  long unsigned int D.22910;
  long unsigned int D.22911;
  struct MonoInst * * D.22912;
  unsigned char D.22917;
  int D.22918;
  int D.22919;
  long int D.22921;
  long unsigned int D.22922;
  long unsigned int D.22923;
  struct MonoInst * * D.22924;
  struct MonoInst * D.22925;
  short unsigned int D.22928;
  _Bool D.22931;
  long int D.22932;
  long int D.22933;
  int D.22936;
  int iftmp.6;
  long unsigned int D.22942;
  guint32 * D.22943;
  unsigned int D.22944;
  _Bool D.22946;
  long int D.22947;
  long int D.22948;
  int D.22951;
  short unsigned int D.22952;
  struct MonoInst * iftmp.7;
  int D.22956;
  unsigned int D.22957;
  long unsigned int D.22960;
  long unsigned int D.22961;
  struct MonoInst * * D.22962;
  unsigned char D.22967;
  int D.22968;
  int D.22969;
  long int D.22971;
  long unsigned int D.22972;
  long unsigned int D.22973;
  struct MonoInst * * D.22974;
  struct MonoInst * D.22975;
  short unsigned int D.22978;
  _Bool D.22981;
  long int D.22982;
  long int D.22983;
  int D.22986;
  int iftmp.8;
  long unsigned int D.22992;
  guint32 * D.22993;
  unsigned int D.22994;
  _Bool D.22996;
  long int D.22997;
  long int D.22998;
  int D.23001;
  char D.23002;
  struct MonoInst * iftmp.9;
  unsigned char D.23014;
  int D.23015;
  int D.23016;
  long int D.23018;
  _Bool D.23019;
  long int D.23020;
  long int D.23021;
  short unsigned int D.23024;
  long unsigned int D.23027;
  long unsigned int D.23028;
  gboolean * D.23029;
  _Bool D.23030;
  long int D.23031;
  long int D.23032;
  long unsigned int D.23035;
  long unsigned int D.23036;
  struct RenameInfo * D.23037;
  long unsigned int D.23038;
  struct MonoInst * * D.23039;
  struct MonoInst * D.23040;
  int D.23041;
  struct MonoType * D.23044;
  struct MonoMethodVar * D.23045;
  long int D.23046;
  long unsigned int D.23047;
  long unsigned int D.23048;
  struct MonoMethodVar * D.23049;
  int D.23052;
  int D.23053;
  long unsigned int D.23055;
  long unsigned int D.23056;
  int iftmp.10;
  gboolean * D.23061;
  int D.23062;
  _Bool D.23065;
  long int D.23066;
  long int D.23067;
  guint32 iftmp.11;
  unsigned int D.23073;
  gboolean * D.23075;
  gboolean * D.23076;
  int D.23077;
  struct MonoBasicBlock * * D.23080;
  long unsigned int D.23081;
  long unsigned int D.23082;
  struct MonoBasicBlock * * D.23083;
  struct MonoBasicBlock * * D.23084;
  long unsigned int D.23085;
  long unsigned int D.23086;
  struct MonoBasicBlock * * D.23087;
  struct MonoBasicBlock * D.23088;
  short int D.23090;
  int D.23091;
  short unsigned int D.23092;
  short unsigned int D.23093;
  _Bool D.23094;
  _Bool D.23095;
  _Bool D.23096;
  long int D.23098;
  struct MonoInst * * D.23102;
  struct MonoInst * * D.23103;
  int * D.23104;
  sizetype D.23105;
  sizetype D.23106;
  sizetype D.23107;
  int * D.23108;
  _Bool D.23109;
  long int D.23110;
  long int D.23111;
  int D.23114;
  short int D.23115;
  int D.23116;
  struct GSList * D.23117;
  int D.23120;
  void * D.23121;
  long unsigned int D.23122;
  struct RenameInfo * D.23123;
  int D.23124;
  long unsigned int D.23125;
  long unsigned int D.23126;
  struct MonoInst * * D.23127;
  struct MonoInst * D.23128;
  unsigned int D.23129;
  unsigned int D.23130;
  struct MonoInst * ins;
  struct MonoInst * new_var;
  int i;
  int j;
  int idx;
  struct GSList * tmp;
  int stack_history_len;

  stack_history_len = 0;
  D.22883 = cfg->verbose_level;
  if (D.22883 > 3) goto <D.22884>; else goto <D.22885>;
  <D.22884>:
  D.22886 = bb->block_num;
  printf ("\nRENAME VARS BLOCK %d:\n", D.22886);
  <D.22885>:
  ins = bb->code;
  goto <D.22319>;
  <D.22318>:
  {
    const char * spec;
    int num_sregs;
    int sregs[3];

    try
      {
        D.22887 = ins->opcode;
        D.22888 = (int) D.22887;
        D.22889 = D.22888 + -313;
        D.22890 = D.22889 * 4;
        spec = &ins_info[D.22890];
        D.22887 = ins->opcode;
        if (D.22887 == 316) goto <D.22891>; else goto <D.22892>;
        <D.22891>:
        // predicted unlikely by continue predictor.
        goto <D.22308>;
        <D.22892>:
        D.22893 = ins->sreg1;
        sregs[0] = D.22893;
        D.22894 = ins->sreg2;
        sregs[1] = D.22894;
        D.22895 = ins->sreg3;
        sregs[2] = D.22895;
        D.22887 = ins->opcode;
        D.22888 = (int) D.22887;
        D.22889 = D.22888 + -313;
        D.22896 = ins_sreg_counts[D.22889];
        num_sregs = (int) D.22896;
        i = 0;
        goto <D.22312>;
        <D.22311>:
        D.22897 = i + 1;
        D.22898 = (sizetype) D.22897;
        D.22899 = spec + D.22898;
        D.22900 = *D.22899;
        if (D.22900 != 32) goto <D.22901>; else goto <D.22902>;
        <D.22901>:
        {
          struct MonoInst * var;

          D.22904 = sregs[i];
          D.22905 = (unsigned int) D.22904;
          D.22906 = cfg->vreg_to_inst_len;
          if (D.22905 < D.22906) goto <D.22907>; else goto <D.22908>;
          <D.22907>:
          D.22909 = cfg->vreg_to_inst;
          D.22904 = sregs[i];
          D.22910 = (long unsigned int) D.22904;
          D.22911 = D.22910 * 8;
          D.22912 = D.22909 + D.22911;
          iftmp.5 = *D.22912;
          goto <D.22913>;
          <D.22908>:
          iftmp.5 = 0B;
          <D.22913>:
          var = iftmp.5;
          if (var != 0B) goto <D.22916>; else goto <D.22914>;
          <D.22916>:
          D.22917 = var->flags;
          D.22918 = (int) D.22917;
          D.22919 = D.22918 & 20;
          if (D.22919 == 0) goto <D.22920>; else goto <D.22914>;
          <D.22920>:
          {
            int idx;

            D.22921 = var->data.op[0].const_val;
            idx = (int) D.22921;
            D.22922 = (long unsigned int) idx;
            D.22923 = D.22922 * 8;
            D.22924 = stack + D.22923;
            D.22925 = *D.22924;
            if (D.22925 != 0B) goto <D.22926>; else goto <D.22927>;
            <D.22926>:
            D.22928 = var->opcode;
            if (D.22928 != 330) goto <D.22929>; else goto <D.22930>;
            <D.22929>:
            D.22922 = (long unsigned int) idx;
            D.22923 = D.22922 * 8;
            D.22924 = stack + D.22923;
            D.22925 = *D.22924;
            D.22931 = D.22925 == 0B;
            D.22932 = (long int) D.22931;
            D.22933 = __builtin_expect (D.22932, 0);
            if (D.22933 != 0) goto <D.22934>; else goto <D.22935>;
            <D.22934>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 200, "stack [idx]");
            <D.22935>:
            <D.22930>:
            D.22922 = (long unsigned int) idx;
            D.22923 = D.22922 * 8;
            D.22924 = stack + D.22923;
            D.22925 = *D.22924;
            D.22936 = D.22925->dreg;
            sregs[i] = D.22936;
            D.22922 = (long unsigned int) idx;
            D.22923 = D.22922 * 8;
            D.22924 = stack + D.22923;
            D.22925 = *D.22924;
            record_use (cfg, D.22925, bb, ins);
            goto <D.22937>;
            <D.22927>:
            record_use (cfg, var, bb, ins);
            <D.22937>:
          }
          goto <D.22915>;
          <D.22914>:
          if (var == 0B) goto <D.22941>; else goto <D.22939>;
          <D.22941>:
          D.22904 = sregs[i];
          D.22910 = (long unsigned int) D.22904;
          D.22942 = D.22910 * 4;
          D.22943 = lvreg_stack + D.22942;
          D.22944 = *D.22943;
          if (D.22944 != 0) goto <D.22945>; else goto <D.22939>;
          <D.22945>:
          iftmp.6 = 1;
          goto <D.22940>;
          <D.22939>:
          iftmp.6 = 0;
          <D.22940>:
          D.22946 = iftmp.6 != 0;
          D.22947 = (long int) D.22946;
          D.22948 = __builtin_expect (D.22947, 0);
          if (D.22948 != 0) goto <D.22949>; else goto <D.22950>;
          <D.22949>:
          D.22904 = sregs[i];
          D.22910 = (long unsigned int) D.22904;
          D.22942 = D.22910 * 4;
          D.22943 = lvreg_stack + D.22942;
          D.22944 = *D.22943;
          D.22951 = (int) D.22944;
          sregs[i] = D.22951;
          <D.22950>:
          <D.22915>:
        }
        <D.22902>:
        i = i + 1;
        <D.22312>:
        if (i < num_sregs) goto <D.22311>; else goto <D.22313>;
        <D.22313>:
        mono_inst_set_src_registers (ins, &sregs);
        D.22887 = ins->opcode;
        D.22952 = D.22887 + 65162;
        if (D.22952 <= 16) goto <D.22953>; else goto <D.22954>;
        <D.22953>:
        {
          struct MonoInst * var;

          D.22956 = ins->dreg;
          D.22957 = (unsigned int) D.22956;
          D.22906 = cfg->vreg_to_inst_len;
          if (D.22957 < D.22906) goto <D.22958>; else goto <D.22959>;
          <D.22958>:
          D.22909 = cfg->vreg_to_inst;
          D.22956 = ins->dreg;
          D.22960 = (long unsigned int) D.22956;
          D.22961 = D.22960 * 8;
          D.22962 = D.22909 + D.22961;
          iftmp.7 = *D.22962;
          goto <D.22963>;
          <D.22959>:
          iftmp.7 = 0B;
          <D.22963>:
          var = iftmp.7;
          if (var != 0B) goto <D.22966>; else goto <D.22964>;
          <D.22966>:
          D.22967 = var->flags;
          D.22968 = (int) D.22967;
          D.22969 = D.22968 & 20;
          if (D.22969 == 0) goto <D.22970>; else goto <D.22964>;
          <D.22970>:
          {
            int idx;

            D.22971 = var->data.op[0].const_val;
            idx = (int) D.22971;
            D.22972 = (long unsigned int) idx;
            D.22973 = D.22972 * 8;
            D.22974 = stack + D.22973;
            D.22975 = *D.22974;
            if (D.22975 != 0B) goto <D.22976>; else goto <D.22977>;
            <D.22976>:
            D.22978 = var->opcode;
            if (D.22978 != 330) goto <D.22979>; else goto <D.22980>;
            <D.22979>:
            D.22972 = (long unsigned int) idx;
            D.22973 = D.22972 * 8;
            D.22974 = stack + D.22973;
            D.22975 = *D.22974;
            D.22981 = D.22975 == 0B;
            D.22982 = (long int) D.22981;
            D.22983 = __builtin_expect (D.22982, 0);
            if (D.22983 != 0) goto <D.22984>; else goto <D.22985>;
            <D.22984>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 219, "stack [idx]");
            <D.22985>:
            <D.22980>:
            D.22972 = (long unsigned int) idx;
            D.22973 = D.22972 * 8;
            D.22974 = stack + D.22973;
            D.22975 = *D.22974;
            D.22986 = D.22975->dreg;
            ins->dreg = D.22986;
            D.22972 = (long unsigned int) idx;
            D.22973 = D.22972 * 8;
            D.22974 = stack + D.22973;
            D.22975 = *D.22974;
            record_use (cfg, D.22975, bb, ins);
            goto <D.22987>;
            <D.22977>:
            record_use (cfg, var, bb, ins);
            <D.22987>:
          }
          goto <D.22965>;
          <D.22964>:
          if (var == 0B) goto <D.22991>; else goto <D.22989>;
          <D.22991>:
          D.22956 = ins->dreg;
          D.22960 = (long unsigned int) D.22956;
          D.22992 = D.22960 * 4;
          D.22993 = lvreg_stack + D.22992;
          D.22994 = *D.22993;
          if (D.22994 != 0) goto <D.22995>; else goto <D.22989>;
          <D.22995>:
          iftmp.8 = 1;
          goto <D.22990>;
          <D.22989>:
          iftmp.8 = 0;
          <D.22990>:
          D.22996 = iftmp.8 != 0;
          D.22997 = (long int) D.22996;
          D.22998 = __builtin_expect (D.22997, 0);
          if (D.22998 != 0) goto <D.22999>; else goto <D.23000>;
          <D.22999>:
          D.22956 = ins->dreg;
          D.22960 = (long unsigned int) D.22956;
          D.22992 = D.22960 * 4;
          D.22993 = lvreg_stack + D.22992;
          D.22994 = *D.22993;
          D.23001 = (int) D.22994;
          ins->dreg = D.23001;
          <D.23000>:
          <D.22965>:
        }
        <D.22954>:
        D.23002 = *spec;
        if (D.23002 != 32) goto <D.23003>; else goto <D.23004>;
        <D.23003>:
        D.22887 = ins->opcode;
        D.22952 = D.22887 + 65162;
        if (D.22952 > 16) goto <D.23005>; else goto <D.23006>;
        <D.23005>:
        {
          struct MonoInst * var;
          struct MonoMethodVar * info;

          D.22956 = ins->dreg;
          D.22957 = (unsigned int) D.22956;
          D.22906 = cfg->vreg_to_inst_len;
          if (D.22957 < D.22906) goto <D.23008>; else goto <D.23009>;
          <D.23008>:
          D.22909 = cfg->vreg_to_inst;
          D.22956 = ins->dreg;
          D.22960 = (long unsigned int) D.22956;
          D.22961 = D.22960 * 8;
          D.22962 = D.22909 + D.22961;
          iftmp.9 = *D.22962;
          goto <D.23010>;
          <D.23009>:
          iftmp.9 = 0B;
          <D.23010>:
          var = iftmp.9;
          if (var != 0B) goto <D.23013>; else goto <D.23011>;
          <D.23013>:
          D.23014 = var->flags;
          D.23015 = (int) D.23014;
          D.23016 = D.23015 & 20;
          if (D.23016 == 0) goto <D.23017>; else goto <D.23011>;
          <D.23017>:
          D.23018 = var->data.op[0].const_val;
          idx = (int) D.23018;
          D.23019 = idx >= max_vars;
          D.23020 = (long int) D.23019;
          D.23021 = __builtin_expect (D.23020, 0);
          if (D.23021 != 0) goto <D.23022>; else goto <D.23023>;
          <D.23022>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 237, "idx < max_vars");
          <D.23023>:
          D.23024 = var->opcode;
          if (D.23024 == 330) goto <D.23025>; else goto <D.23026>;
          <D.23025>:
          D.23027 = (long unsigned int) idx;
          D.23028 = D.23027 * 4;
          D.23029 = originals_used + D.23028;
          *D.23029 = 1;
          <D.23026>:
          D.23030 = stack_history_len >= stack_history_size;
          D.23031 = (long int) D.23030;
          D.23032 = __builtin_expect (D.23031, 0);
          if (D.23032 != 0) goto <D.23033>; else goto <D.23034>;
          <D.23033>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 243, "stack_history_len < stack_history_size");
          <D.23034>:
          D.23035 = (long unsigned int) stack_history_len;
          D.23036 = D.23035 * 16;
          D.23037 = stack_history + D.23036;
          D.23027 = (long unsigned int) idx;
          D.23038 = D.23027 * 8;
          D.23039 = stack + D.23038;
          D.23040 = *D.23039;
          D.23037->var = D.23040;
          D.23035 = (long unsigned int) stack_history_len;
          D.23036 = D.23035 * 16;
          D.23037 = stack_history + D.23036;
          D.23037->idx = idx;
          stack_history_len = stack_history_len + 1;
          D.23027 = (long unsigned int) idx;
          D.23028 = D.23027 * 4;
          D.23029 = originals_used + D.23028;
          D.23041 = *D.23029;
          if (D.23041 != 0) goto <D.23042>; else goto <D.23043>;
          <D.23042>:
          D.23044 = var->data.op[1].vtype;
          new_var = mono_compile_create_var (cfg, D.23044, 329);
          D.23014 = var->flags;
          new_var->flags = D.23014;
          D.23045 = cfg->vars;
          D.23046 = new_var->data.op[0].const_val;
          D.23047 = (long unsigned int) D.23046;
          D.23048 = D.23047 * 80;
          D.23049 = D.23045 + D.23048;
          D.23049->reg = idx;
          D.22883 = cfg->verbose_level;
          if (D.22883 > 3) goto <D.23050>; else goto <D.23051>;
          <D.23050>:
          D.23052 = new_var->dreg;
          D.23053 = var->dreg;
          printf ("  R%d -> R%d\n", D.23053, D.23052);
          <D.23051>:
          D.23027 = (long unsigned int) idx;
          D.23038 = D.23027 * 8;
          D.23039 = stack + D.23038;
          *D.23039 = new_var;
          D.23052 = new_var->dreg;
          ins->dreg = D.23052;
          var = new_var;
          goto <D.23054>;
          <D.23043>:
          D.23027 = (long unsigned int) idx;
          D.23038 = D.23027 * 8;
          D.23039 = stack + D.23038;
          *D.23039 = var;
          D.23027 = (long unsigned int) idx;
          D.23028 = D.23027 * 4;
          D.23029 = originals_used + D.23028;
          *D.23029 = 1;
          <D.23054>:
          D.23045 = cfg->vars;
          D.23018 = var->data.op[0].const_val;
          D.23055 = (long unsigned int) D.23018;
          D.23056 = D.23055 * 80;
          info = D.23045 + D.23056;
          info->def = ins;
          info->def_bb = bb;
          goto <D.23012>;
          <D.23011>:
          if (var == 0B) goto <D.23060>; else goto <D.23058>;
          <D.23060>:
          D.22956 = ins->dreg;
          D.22960 = (long unsigned int) D.22956;
          D.22992 = D.22960 * 4;
          D.23061 = lvreg_defined + D.22992;
          D.23062 = *D.23061;
          if (D.23062 != 0) goto <D.23063>; else goto <D.23058>;
          <D.23063>:
          D.22956 = ins->dreg;
          if (D.22956 > 15) goto <D.23064>; else goto <D.23058>;
          <D.23064>:
          iftmp.10 = 1;
          goto <D.23059>;
          <D.23058>:
          iftmp.10 = 0;
          <D.23059>:
          D.23065 = iftmp.10 != 0;
          D.23066 = (long int) D.23065;
          D.23067 = __builtin_expect (D.23066, 0);
          if (D.23067 != 0) goto <D.23068>; else goto <D.23069>;
          <D.23068>:
          D.22956 = ins->dreg;
          D.22960 = (long unsigned int) D.22956;
          D.22992 = D.22960 * 4;
          D.22993 = lvreg_stack + D.22992;
          D.22956 = ins->dreg;
          D.22957 = (unsigned int) D.22956;
          D.23073 = cfg->vreg_is_ref_len;
          if (D.22957 < D.23073) goto <D.23074>; else goto <D.23071>;
          <D.23074>:
          D.23075 = cfg->vreg_is_ref;
          D.22956 = ins->dreg;
          D.22960 = (long unsigned int) D.22956;
          D.22992 = D.22960 * 4;
          D.23076 = D.23075 + D.22992;
          D.23077 = *D.23076;
          if (D.23077 != 0) goto <D.23078>; else goto <D.23071>;
          <D.23078>:
          iftmp.11 = mono_alloc_ireg_ref (cfg);
          goto <D.23072>;
          <D.23071>:
          iftmp.11 = mono_alloc_preg (cfg);
          <D.23072>:
          *D.22993 = iftmp.11;
          D.22956 = ins->dreg;
          D.22960 = (long unsigned int) D.22956;
          D.22992 = D.22960 * 4;
          D.22993 = lvreg_stack + D.22992;
          D.22994 = *D.22993;
          D.23001 = (int) D.22994;
          ins->dreg = D.23001;
          goto <D.23079>;
          <D.23069>:
          D.22956 = ins->dreg;
          D.22960 = (long unsigned int) D.22956;
          D.22992 = D.22960 * 4;
          D.23061 = lvreg_defined + D.22992;
          *D.23061 = 1;
          <D.23079>:
          <D.23012>:
        }
        <D.23006>:
        <D.23004>:
      }
    finally
      {
        sregs = {CLOBBER};
      }
  }
  <D.22308>:
  ins = ins->next;
  <D.22319>:
  if (ins != 0B) goto <D.22318>; else goto <D.22320>;
  <D.22320>:
  i = 0;
  goto <D.22329>;
  <D.22328>:
  {
    struct MonoBasicBlock * n;

    D.23080 = bb->out_bb;
    D.23081 = (long unsigned int) i;
    D.23082 = D.23081 * 8;
    D.23083 = D.23080 + D.23082;
    n = *D.23083;
    j = 0;
    goto <D.22324>;
    <D.22323>:
    D.23084 = n->in_bb;
    D.23085 = (long unsigned int) j;
    D.23086 = D.23085 * 8;
    D.23087 = D.23084 + D.23086;
    D.23088 = *D.23087;
    if (D.23088 == bb) goto <D.22322>; else goto <D.23089>;
    <D.23089>:
    j = j + 1;
    <D.22324>:
    D.23090 = n->in_count;
    D.23091 = (int) D.23090;
    if (D.23091 > j) goto <D.22323>; else goto <D.22322>;
    <D.22322>:
    ins = n->code;
    goto <D.22327>;
    <D.22326>:
    D.23092 = ins->opcode;
    D.23093 = D.23092 + 65217;
    D.23094 = D.23093 <= 2;
    D.23095 = D.23092 == 964;
    D.23096 = D.23094 | D.23095;
    if (D.23096 != 0) goto <D.23097>; else goto <D.22325>;
    <D.23097>:
    D.23098 = ins->data.op[0].const_val;
    idx = (int) D.23098;
    D.23027 = (long unsigned int) idx;
    D.23038 = D.23027 * 8;
    D.23039 = stack + D.23038;
    D.23040 = *D.23039;
    if (D.23040 != 0B) goto <D.23099>; else goto <D.23100>;
    <D.23099>:
    D.23027 = (long unsigned int) idx;
    D.23038 = D.23027 * 8;
    D.23039 = stack + D.23038;
    new_var = *D.23039;
    goto <D.23101>;
    <D.23100>:
    D.23102 = cfg->varinfo;
    D.23027 = (long unsigned int) idx;
    D.23038 = D.23027 * 8;
    D.23103 = D.23102 + D.23038;
    new_var = *D.23103;
    <D.23101>:
    D.23104 = ins->data.op[1].phi_args;
    D.23105 = (sizetype) j;
    D.23106 = D.23105 + 1;
    D.23107 = D.23106 * 4;
    D.23108 = D.23104 + D.23107;
    D.23052 = new_var->dreg;
    *D.23108 = D.23052;
    record_use (cfg, new_var, n, ins);
    D.22883 = cfg->verbose_level;
    D.23109 = D.22883 > 3;
    D.23110 = (long int) D.23109;
    D.23111 = __builtin_expect (D.23110, 0);
    if (D.23111 != 0) goto <D.23112>; else goto <D.23113>;
    <D.23112>:
    D.23114 = n->block_num;
    D.23052 = new_var->dreg;
    D.22956 = ins->dreg;
    printf ("\tAdd PHI R%d <- R%d to BB%d\n", D.22956, D.23052, D.23114);
    <D.23113>:
    ins = ins->next;
    <D.22327>:
    if (ins != 0B) goto <D.22326>; else goto <D.22325>;
    <D.22325>:
  }
  i = i + 1;
  <D.22329>:
  D.23115 = bb->out_count;
  D.23116 = (int) D.23115;
  if (D.23116 > i) goto <D.22328>; else goto <D.22330>;
  <D.22330>:
  D.23117 = bb->dominated;
  if (D.23117 != 0B) goto <D.23118>; else goto <D.23119>;
  <D.23118>:
  tmp = bb->dominated;
  goto <D.22332>;
  <D.22331>:
  D.23120 = stack_history_size - stack_history_len;
  D.23035 = (long unsigned int) stack_history_len;
  D.23036 = D.23035 * 16;
  D.23037 = stack_history + D.23036;
  D.23121 = tmp->data;
  mono_ssa_rename_vars (cfg, max_vars, D.23121, originals_used, stack, lvreg_stack, lvreg_defined, D.23037, D.23120);
  tmp = tmp->next;
  <D.22332>:
  if (tmp != 0B) goto <D.22331>; else goto <D.22333>;
  <D.22333>:
  <D.23119>:
  i = stack_history_len + -1;
  goto <D.22335>;
  <D.22334>:
  D.23081 = (long unsigned int) i;
  D.23122 = D.23081 * 16;
  D.23123 = stack_history + D.23122;
  D.23124 = D.23123->idx;
  D.23125 = (long unsigned int) D.23124;
  D.23126 = D.23125 * 8;
  D.23127 = stack + D.23126;
  D.23081 = (long unsigned int) i;
  D.23122 = D.23081 * 16;
  D.23123 = stack_history + D.23122;
  D.23128 = D.23123->var;
  *D.23127 = D.23128;
  i = i + -1;
  <D.22335>:
  if (i >= 0) goto <D.22334>; else goto <D.22336>;
  <D.22336>:
  D.23129 = cfg->comp_done;
  D.23130 = D.23129 | 64;
  cfg->comp_done = D.23130;
}


record_use (struct MonoCompile * cfg, struct MonoInst * var, struct MonoBasicBlock * bb, struct MonoInst * ins)
{
  struct MonoMemPool * D.23133;
  struct MonoMethodVar * D.23134;
  long int D.23135;
  long unsigned int D.23136;
  long unsigned int D.23137;
  struct GList * D.23138;
  struct GList * D.23139;
  struct MonoMethodVar * info;
  struct MonoVarUsageInfo * ui;

  D.23133 = cfg->mempool;
  ui = mono_mempool_alloc (D.23133, 16);
  D.23134 = cfg->vars;
  D.23135 = var->data.op[0].const_val;
  D.23136 = (long unsigned int) D.23135;
  D.23137 = D.23136 * 80;
  info = D.23134 + D.23137;
  ui->bb = bb;
  ui->inst = ins;
  D.23138 = info->uses;
  D.23133 = cfg->mempool;
  D.23139 = g_list_prepend_mempool (D.23133, D.23138, ui);
  info->uses = D.23139;
}


g_list_prepend_mempool (struct MonoMemPool * mp, struct GList * list, void * data)
{
  struct GList * iftmp.12;
  struct GList * D.23144;
  struct GList * D.23149;
  struct GList * new_list;

  new_list = mono_mempool_alloc (mp, 24);
  new_list->data = data;
  if (list != 0B) goto <D.23141>; else goto <D.23142>;
  <D.23141>:
  iftmp.12 = list->prev;
  goto <D.23143>;
  <D.23142>:
  iftmp.12 = 0B;
  <D.23143>:
  new_list->prev = iftmp.12;
  new_list->next = list;
  D.23144 = new_list->prev;
  if (D.23144 != 0B) goto <D.23145>; else goto <D.23146>;
  <D.23145>:
  D.23144 = new_list->prev;
  D.23144->next = new_list;
  <D.23146>:
  if (list != 0B) goto <D.23147>; else goto <D.23148>;
  <D.23147>:
  list->prev = new_list;
  <D.23148>:
  D.23149 = new_list;
  return D.23149;
}


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

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


mono_ssa_remove (struct MonoCompile * cfg)
{
  unsigned int D.23153;
  unsigned int D.23154;
  _Bool D.23155;
  long int D.23156;
  long int D.23157;
  struct MonoBasicBlock * * D.23160;
  long unsigned int D.23161;
  long unsigned int D.23162;
  struct MonoBasicBlock * * D.23163;
  unsigned int D.23164;
  int D.23167;
  short unsigned int D.23168;
  short unsigned int D.23169;
  _Bool D.23170;
  _Bool D.23171;
  _Bool D.23172;
  int * D.23175;
  int D.23176;
  short int D.23177;
  int D.23178;
  _Bool D.23179;
  long int D.23180;
  long int D.23181;
  struct MonoInst * iftmp.13;
  int D.23185;
  unsigned int D.23186;
  unsigned int D.23187;
  struct MonoInst * * D.23190;
  long unsigned int D.23191;
  long unsigned int D.23192;
  struct MonoInst * * D.23193;
  sizetype D.23195;
  sizetype D.23196;
  sizetype D.23197;
  int * D.23198;
  int D.23199;
  short unsigned int D.23205;
  int D.23206;
  int D.23207;
  short unsigned int D.23208;
  struct MonoClass * D.23211;
  _Bool D.23212;
  long int D.23213;
  long int D.23214;
  struct MonoBasicBlock * * D.23217;
  long unsigned int D.23218;
  long unsigned int D.23219;
  struct MonoBasicBlock * * D.23220;
  int D.23223;
  int D.23224;
  struct MonoMemPool * D.23227;
  int D.23228;
  short unsigned int D.23229;
  int D.23230;
  int D.23231;
  const unsigned char * D.23232;
  short unsigned int D.23233;
  unsigned int i.14;
  unsigned int D.23239;
  long unsigned int D.23242;
  long unsigned int D.23243;
  struct MonoBasicBlock * * D.23244;
  int D.23245;
  int D.23246;
  char D.23249;
  struct MonoInst * iftmp.15;
  struct MonoMethodVar * D.23258;
  long int D.23259;
  long unsigned int D.23260;
  long unsigned int D.23261;
  int D.23262;
  unsigned int D.23265;
  unsigned int D.23266;
  long unsigned int D.23269;
  long unsigned int D.23270;
  struct MonoMethodVar * D.23271;
  int D.23272;
  struct MonoInst * * D.23275;
  long unsigned int D.23276;
  struct MonoInst * * D.23277;
  struct MonoInst * D.23278;
  int D.23279;
  int D.23280;
  int D.23281;
  int D.23282;
  signed char D.23283;
  struct MonoInst * iftmp.16;
  int D.23285;
  unsigned int D.23286;
  long unsigned int D.23289;
  long unsigned int D.23290;
  struct MonoInst * * D.23291;
  long int D.23295;
  long unsigned int D.23296;
  long unsigned int D.23297;
  int D.23298;
  unsigned int D.23301;
  unsigned int D.23302;
  long unsigned int D.23305;
  long unsigned int D.23306;
  struct MonoMethodVar * D.23307;
  int D.23308;
  long unsigned int D.23311;
  struct MonoInst * * D.23312;
  struct MonoInst * D.23313;
  int D.23314;
  unsigned int bbindex.17;
  long unsigned int D.23316;
  struct MonoMethodVar * D.23317;
  unsigned int D.23318;
  unsigned int D.23319;
  unsigned int D.23322;
  unsigned int D.23323;
  struct MonoInst * ins;
  struct MonoInst * var;
  struct MonoInst * move;
  int bbindex;
  int i;
  int j;
  int first;

  D.23153 = cfg->comp_done;
  D.23154 = D.23153 & 32;
  D.23155 = D.23154 == 0;
  D.23156 = (long int) D.23155;
  D.23157 = __builtin_expect (D.23156, 0);
  if (D.23157 != 0) goto <D.23158>; else goto <D.23159>;
  <D.23158>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 489, "cfg->comp_done & MONO_COMP_SSA");
  <D.23159>:
  i = 0;
  goto <D.22409>;
  <D.22408>:
  {
    struct MonoBasicBlock * bb;

    D.23160 = cfg->bblocks;
    D.23161 = (long unsigned int) i;
    D.23162 = D.23161 * 8;
    D.23163 = D.23160 + D.23162;
    bb = *D.23163;
    D.23164 = cfg->verbose_level;
    if (D.23164 > 3) goto <D.23165>; else goto <D.23166>;
    <D.23165>:
    D.23167 = bb->block_num;
    printf ("\nREMOVE SSA %d:\n", D.23167);
    <D.23166>:
    ins = bb->code;
    goto <D.22406>;
    <D.22405>:
    D.23168 = ins->opcode;
    D.23169 = D.23168 + 65217;
    D.23170 = D.23169 <= 2;
    D.23171 = D.23168 == 964;
    D.23172 = D.23170 | D.23171;
    if (D.23172 != 0) goto <D.23173>; else goto <D.23174>;
    <D.23173>:
    D.23175 = ins->data.op[1].phi_args;
    D.23176 = *D.23175;
    D.23177 = bb->in_count;
    D.23178 = (int) D.23177;
    D.23179 = D.23176 != D.23178;
    D.23180 = (long int) D.23179;
    D.23181 = __builtin_expect (D.23180, 0);
    if (D.23181 != 0) goto <D.23182>; else goto <D.23183>;
    <D.23182>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 499, "ins->inst_phi_args [0] == bb->in_count");
    <D.23183>:
    D.23185 = ins->dreg;
    D.23186 = (unsigned int) D.23185;
    D.23187 = cfg->vreg_to_inst_len;
    if (D.23186 < D.23187) goto <D.23188>; else goto <D.23189>;
    <D.23188>:
    D.23190 = cfg->vreg_to_inst;
    D.23185 = ins->dreg;
    D.23191 = (long unsigned int) D.23185;
    D.23192 = D.23191 * 8;
    D.23193 = D.23190 + D.23192;
    iftmp.13 = *D.23193;
    goto <D.23194>;
    <D.23189>:
    iftmp.13 = 0B;
    <D.23194>:
    var = iftmp.13;
    D.23175 = ins->data.op[1].phi_args;
    first = MEM[(int *)D.23175 + 4B];
    j = 1;
    goto <D.22399>;
    <D.22398>:
    D.23175 = ins->data.op[1].phi_args;
    D.23195 = (sizetype) j;
    D.23196 = D.23195 + 1;
    D.23197 = D.23196 * 4;
    D.23198 = D.23175 + D.23197;
    D.23199 = *D.23198;
    if (D.23199 != first) goto <D.22397>; else goto <D.23200>;
    <D.23200>:
    j = j + 1;
    <D.22399>:
    D.23177 = bb->in_count;
    D.23178 = (int) D.23177;
    if (D.23178 > j) goto <D.22398>; else goto <D.22397>;
    <D.22397>:
    D.23177 = bb->in_count;
    if (D.23177 > 1) goto <D.23203>; else goto <D.23201>;
    <D.23203>:
    D.23177 = bb->in_count;
    D.23178 = (int) D.23177;
    if (D.23178 == j) goto <D.23204>; else goto <D.23201>;
    <D.23204>:
    D.23205 = ins->opcode;
    D.23206 = (int) D.23205;
    D.23207 = op_phi_to_move (D.23206);
    D.23208 = (short unsigned int) D.23207;
    ins->opcode = D.23208;
    D.23205 = ins->opcode;
    if (D.23205 == 431) goto <D.23209>; else goto <D.23210>;
    <D.23209>:
    D.23211 = ins->klass;
    D.23212 = D.23211 == 0B;
    D.23213 = (long int) D.23212;
    D.23214 = __builtin_expect (D.23213, 0);
    if (D.23214 != 0) goto <D.23215>; else goto <D.23216>;
    <D.23215>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 512, "ins->klass");
    <D.23216>:
    <D.23210>:
    ins->sreg1 = first;
    goto <D.23202>;
    <D.23201>:
    j = 0;
    goto <D.22403>;
    <D.22402>:
    {
      struct MonoBasicBlock * pred;
      int sreg;

      D.23217 = bb->in_bb;
      D.23218 = (long unsigned int) j;
      D.23219 = D.23218 * 8;
      D.23220 = D.23217 + D.23219;
      pred = *D.23220;
      D.23175 = ins->data.op[1].phi_args;
      D.23195 = (sizetype) j;
      D.23196 = D.23195 + 1;
      D.23197 = D.23196 * 4;
      D.23198 = D.23175 + D.23197;
      sreg = *D.23198;
      D.23164 = cfg->verbose_level;
      if (D.23164 > 3) goto <D.23221>; else goto <D.23222>;
      <D.23221>:
      D.23223 = pred->block_num;
      D.23224 = var->dreg;
      printf ("\tADD R%d <- R%d in BB%d\n", D.23224, sreg, D.23223);
      <D.23222>:
      D.23224 = var->dreg;
      if (D.23224 != sreg) goto <D.23225>; else goto <D.23226>;
      <D.23225>:
      D.23227 = cfg->mempool;
      move = mono_mempool_alloc0 (D.23227, 80);
      D.23205 = ins->opcode;
      D.23206 = (int) D.23205;
      D.23228 = op_phi_to_move (D.23206);
      D.23229 = (short unsigned int) D.23228;
      move->opcode = D.23229;
      move->dreg = -1;
      move->sreg3 = -1;
      D.23230 = move->sreg3;
      move->sreg2 = D.23230;
      D.23231 = move->sreg2;
      move->sreg1 = D.23231;
      D.23232 = cfg->ip;
      move->cil_code = D.23232;
      D.23233 = move->opcode;
      if (D.23233 == 431) goto <D.23234>; else goto <D.23235>;
      <D.23234>:
      D.23211 = ins->klass;
      D.23212 = D.23211 == 0B;
      D.23213 = (long int) D.23212;
      D.23214 = __builtin_expect (D.23213, 0);
      if (D.23214 != 0) goto <D.23236>; else goto <D.23237>;
      <D.23236>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 524, "ins->klass");
      <D.23237>:
      D.23211 = ins->klass;
      move->klass = D.23211;
      <D.23235>:
      D.23224 = var->dreg;
      move->dreg = D.23224;
      move->sreg1 = sreg;
      mono_add_ins_to_end (pred, move);
      <D.23226>:
    }
    j = j + 1;
    <D.22403>:
    D.23177 = bb->in_count;
    D.23178 = (int) D.23177;
    if (D.23178 > j) goto <D.22402>; else goto <D.22404>;
    <D.22404>:
    ins->opcode = 316;
    ins->dreg = -1;
    <D.23202>:
    <D.23174>:
    ins = ins->next;
    <D.22406>:
    if (ins != 0B) goto <D.22405>; else goto <D.22407>;
    <D.22407>:
  }
  i = i + 1;
  <D.22409>:
  i.14 = (unsigned int) i;
  D.23239 = cfg->num_bblocks;
  if (i.14 < D.23239) goto <D.22408>; else goto <D.22410>;
  <D.22410>:
  D.23164 = cfg->verbose_level;
  if (D.23164 > 3) goto <D.23240>; else goto <D.23241>;
  <D.23240>:
  i = 0;
  goto <D.22413>;
  <D.22412>:
  {
    struct MonoBasicBlock * bb;

    D.23160 = cfg->bblocks;
    D.23161 = (long unsigned int) i;
    D.23162 = D.23161 * 8;
    D.23163 = D.23160 + D.23162;
    bb = *D.23163;
    mono_print_bb (bb, "AFTER REMOVE SSA:");
  }
  i = i + 1;
  <D.22413>:
  i.14 = (unsigned int) i;
  D.23239 = cfg->num_bblocks;
  if (i.14 < D.23239) goto <D.22412>; else goto <D.22414>;
  <D.22414>:
  <D.23241>:
  bbindex = 0;
  goto <D.22431>;
  <D.22430>:
  {
    struct MonoBasicBlock * bb;

    D.23160 = cfg->bblocks;
    D.23242 = (long unsigned int) bbindex;
    D.23243 = D.23242 * 8;
    D.23244 = D.23160 + D.23243;
    bb = *D.23244;
    ins = bb->code;
    goto <D.22428>;
    <D.22427>:
    {
      const char * spec;
      int num_sregs;
      int sregs[3];

      try
        {
          D.23205 = ins->opcode;
          D.23206 = (int) D.23205;
          D.23245 = D.23206 + -313;
          D.23246 = D.23245 * 4;
          spec = &ins_info[D.23246];
          D.23205 = ins->opcode;
          if (D.23205 == 316) goto <D.23247>; else goto <D.23248>;
          <D.23247>:
          // predicted unlikely by continue predictor.
          goto <D.22419>;
          <D.23248>:
          D.23249 = *spec;
          if (D.23249 != 32) goto <D.23250>; else goto <D.23251>;
          <D.23250>:
          {
            struct MonoInst * var;

            D.23185 = ins->dreg;
            D.23186 = (unsigned int) D.23185;
            D.23187 = cfg->vreg_to_inst_len;
            if (D.23186 < D.23187) goto <D.23253>; else goto <D.23254>;
            <D.23253>:
            D.23190 = cfg->vreg_to_inst;
            D.23185 = ins->dreg;
            D.23191 = (long unsigned int) D.23185;
            D.23192 = D.23191 * 8;
            D.23193 = D.23190 + D.23192;
            iftmp.15 = *D.23193;
            goto <D.23255>;
            <D.23254>:
            iftmp.15 = 0B;
            <D.23255>:
            var = iftmp.15;
            if (var != 0B) goto <D.23256>; else goto <D.23257>;
            <D.23256>:
            {
              struct MonoMethodVar * vmv;

              D.23258 = cfg->vars;
              D.23259 = var->data.op[0].const_val;
              D.23260 = (long unsigned int) D.23259;
              D.23261 = D.23260 * 80;
              vmv = D.23258 + D.23261;
              D.23262 = vmv->reg;
              if (D.23262 != -1) goto <D.23263>; else goto <D.23264>;
              <D.23263>:
              D.23265 = vmv->idx;
              D.23262 = vmv->reg;
              D.23266 = (unsigned int) D.23262;
              if (D.23265 != D.23266) goto <D.23267>; else goto <D.23268>;
              <D.23267>:
              D.23258 = cfg->vars;
              D.23262 = vmv->reg;
              D.23269 = (long unsigned int) D.23262;
              D.23270 = D.23269 * 80;
              D.23271 = D.23258 + D.23270;
              D.23272 = D.23271->reg;
              if (D.23272 != -1) goto <D.23273>; else goto <D.23274>;
              <D.23273>:
              D.23275 = cfg->varinfo;
              D.23262 = vmv->reg;
              D.23269 = (long unsigned int) D.23262;
              D.23276 = D.23269 * 8;
              D.23277 = D.23275 + D.23276;
              D.23278 = *D.23277;
              D.23279 = D.23278->dreg;
              D.23185 = ins->dreg;
              printf ("COALESCE: R%d -> R%d\n", D.23185, D.23279);
              D.23275 = cfg->varinfo;
              D.23262 = vmv->reg;
              D.23269 = (long unsigned int) D.23262;
              D.23276 = D.23269 * 8;
              D.23277 = D.23275 + D.23276;
              D.23278 = *D.23277;
              D.23279 = D.23278->dreg;
              ins->dreg = D.23279;
              <D.23274>:
              <D.23268>:
              <D.23264>:
            }
            <D.23257>:
          }
          <D.23251>:
          D.23280 = ins->sreg1;
          sregs[0] = D.23280;
          D.23281 = ins->sreg2;
          sregs[1] = D.23281;
          D.23282 = ins->sreg3;
          sregs[2] = D.23282;
          D.23205 = ins->opcode;
          D.23206 = (int) D.23205;
          D.23245 = D.23206 + -313;
          D.23283 = ins_sreg_counts[D.23245];
          num_sregs = (int) D.23283;
          i = 0;
          goto <D.22425>;
          <D.22424>:
          {
            struct MonoInst * var;

            D.23285 = sregs[i];
            D.23286 = (unsigned int) D.23285;
            D.23187 = cfg->vreg_to_inst_len;
            if (D.23286 < D.23187) goto <D.23287>; else goto <D.23288>;
            <D.23287>:
            D.23190 = cfg->vreg_to_inst;
            D.23285 = sregs[i];
            D.23289 = (long unsigned int) D.23285;
            D.23290 = D.23289 * 8;
            D.23291 = D.23190 + D.23290;
            iftmp.16 = *D.23291;
            goto <D.23292>;
            <D.23288>:
            iftmp.16 = 0B;
            <D.23292>:
            var = iftmp.16;
            if (var != 0B) goto <D.23293>; else goto <D.23294>;
            <D.23293>:
            {
              struct MonoMethodVar * vmv;

              D.23258 = cfg->vars;
              D.23295 = var->data.op[0].const_val;
              D.23296 = (long unsigned int) D.23295;
              D.23297 = D.23296 * 80;
              vmv = D.23258 + D.23297;
              D.23298 = vmv->reg;
              if (D.23298 != -1) goto <D.23299>; else goto <D.23300>;
              <D.23299>:
              D.23301 = vmv->idx;
              D.23298 = vmv->reg;
              D.23302 = (unsigned int) D.23298;
              if (D.23301 != D.23302) goto <D.23303>; else goto <D.23304>;
              <D.23303>:
              D.23258 = cfg->vars;
              D.23298 = vmv->reg;
              D.23305 = (long unsigned int) D.23298;
              D.23306 = D.23305 * 80;
              D.23307 = D.23258 + D.23306;
              D.23308 = D.23307->reg;
              if (D.23308 != -1) goto <D.23309>; else goto <D.23310>;
              <D.23309>:
              D.23275 = cfg->varinfo;
              D.23298 = vmv->reg;
              D.23305 = (long unsigned int) D.23298;
              D.23311 = D.23305 * 8;
              D.23312 = D.23275 + D.23311;
              D.23313 = *D.23312;
              D.23314 = D.23313->dreg;
              D.23285 = sregs[i];
              printf ("COALESCE: R%d -> R%d\n", D.23285, D.23314);
              D.23275 = cfg->varinfo;
              D.23298 = vmv->reg;
              D.23305 = (long unsigned int) D.23298;
              D.23311 = D.23305 * 8;
              D.23312 = D.23275 + D.23311;
              D.23313 = *D.23312;
              D.23314 = D.23313->dreg;
              sregs[i] = D.23314;
              <D.23310>:
              <D.23304>:
              <D.23300>:
            }
            <D.23294>:
          }
          i = i + 1;
          <D.22425>:
          if (i < num_sregs) goto <D.22424>; else goto <D.22426>;
          <D.22426>:
          mono_inst_set_src_registers (ins, &sregs);
        }
      finally
        {
          sregs = {CLOBBER};
        }
    }
    <D.22419>:
    ins = ins->next;
    <D.22428>:
    if (ins != 0B) goto <D.22427>; else goto <D.22429>;
    <D.22429>:
  }
  bbindex = bbindex + 1;
  <D.22431>:
  bbindex.17 = (unsigned int) bbindex;
  D.23239 = cfg->num_bblocks;
  if (bbindex.17 < D.23239) goto <D.22430>; else goto <D.22432>;
  <D.22432>:
  i = 0;
  goto <D.22434>;
  <D.22433>:
  D.23258 = cfg->vars;
  D.23161 = (long unsigned int) i;
  D.23316 = D.23161 * 80;
  D.23317 = D.23258 + D.23316;
  D.23317->reg = -1;
  i = i + 1;
  <D.22434>:
  i.14 = (unsigned int) i;
  D.23318 = cfg->num_varinfo;
  if (i.14 < D.23318) goto <D.22433>; else goto <D.22435>;
  <D.22435>:
  D.23153 = cfg->comp_done;
  D.23319 = D.23153 & 128;
  if (D.23319 != 0) goto <D.23320>; else goto <D.23321>;
  <D.23320>:
  unlink_unused_bblocks (cfg);
  <D.23321>:
  D.23153 = cfg->comp_done;
  D.23322 = D.23153 & 4294967279;
  cfg->comp_done = D.23322;
  D.23153 = cfg->comp_done;
  D.23323 = D.23153 & 4294967263;
  cfg->comp_done = D.23323;
}


op_phi_to_move (int opcode)
{
  int D.23326;

  switch (opcode) <default: <D.22274>, case 319: <D.22270>, case 320: <D.22271>, case 321: <D.22272>, case 964: <D.22273>>
  <D.22270>:
  D.23326 = 428;
  return D.23326;
  <D.22271>:
  D.23326 = 430;
  return D.23326;
  <D.22272>:
  D.23326 = 431;
  return D.23326;
  <D.22273>:
  D.23326 = 962;
  return D.23326;
  <D.22274>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "ssa.c", 137);
  D.23326 = -1;
  return D.23326;
}


unlink_unused_bblocks (struct MonoCompile * cfg)
{
  unsigned int D.23328;
  unsigned int D.23329;
  _Bool D.23330;
  long int D.23331;
  long int D.23332;
  unsigned int D.23335;
  _Bool D.23336;
  long int D.23337;
  long int D.23338;
  struct MonoBasicBlock * D.23341;
  unsigned int D.23342;
  unsigned int D.23343;
  struct MonoBasicBlock * D.23346;
  struct MonoBasicBlock * * D.23349;
  long unsigned int D.23350;
  long unsigned int D.23351;
  struct MonoBasicBlock * * D.23352;
  unsigned int D.23353;
  unsigned int D.23354;
  struct MonoBasicBlock * * D.23357;
  long unsigned int D.23358;
  long unsigned int D.23359;
  struct MonoBasicBlock * * D.23360;
  struct MonoBasicBlock * D.23361;
  short int D.23362;
  int D.23363;
  struct MonoBasicBlock * * D.23364;
  struct MonoBasicBlock * * D.23365;
  struct MonoBasicBlock * D.23366;
  short int D.23367;
  int D.23368;
  int D.23371;
  unsigned int i.18;
  unsigned int D.23373;
  int i;
  int j;
  struct MonoBasicBlock * bb;

  D.23328 = cfg->comp_done;
  D.23329 = D.23328 & 128;
  D.23330 = D.23329 == 0;
  D.23331 = (long int) D.23330;
  D.23332 = __builtin_expect (D.23331, 0);
  if (D.23332 != 0) goto <D.23333>; else goto <D.23334>;
  <D.23333>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 66, "cfg->comp_done & MONO_COMP_REACHABILITY");
  <D.23334>:
  D.23335 = cfg->verbose_level;
  D.23336 = D.23335 > 1;
  D.23337 = (long int) D.23336;
  D.23338 = __builtin_expect (D.23337, 0);
  if (D.23338 != 0) goto <D.23339>; else goto <D.23340>;
  <D.23339>:
  printf ("\nUNLINK UNUSED BBLOCKS:\n");
  <D.23340>:
  bb = cfg->bb_entry;
  goto <D.22239>;
  <D.22238>:
  D.23341 = bb->next_bb;
  D.23342 = D.23341->flags;
  D.23343 = D.23342 & 2;
  if (D.23343 == 0) goto <D.23344>; else goto <D.23345>;
  <D.23344>:
  D.23341 = bb->next_bb;
  D.23346 = D.23341->next_bb;
  bb->next_bb = D.23346;
  goto <D.23347>;
  <D.23345>:
  bb = bb->next_bb;
  <D.23347>:
  <D.22239>:
  if (bb != 0B) goto <D.23348>; else goto <D.22240>;
  <D.23348>:
  D.23341 = bb->next_bb;
  if (D.23341 != 0B) goto <D.22238>; else goto <D.22240>;
  <D.22240>:
  i = 1;
  goto <D.22248>;
  <D.22247>:
  D.23349 = cfg->bblocks;
  D.23350 = (long unsigned int) i;
  D.23351 = D.23350 * 8;
  D.23352 = D.23349 + D.23351;
  bb = *D.23352;
  D.23353 = bb->flags;
  D.23354 = D.23353 & 2;
  if (D.23354 == 0) goto <D.23355>; else goto <D.23356>;
  <D.23355>:
  j = 0;
  goto <D.22242>;
  <D.22241>:
  D.23357 = bb->in_bb;
  D.23358 = (long unsigned int) j;
  D.23359 = D.23358 * 8;
  D.23360 = D.23357 + D.23359;
  D.23361 = *D.23360;
  unlink_target (D.23361, bb);
  j = j + 1;
  <D.22242>:
  D.23362 = bb->in_count;
  D.23363 = (int) D.23362;
  if (D.23363 > j) goto <D.22241>; else goto <D.22243>;
  <D.22243>:
  j = 0;
  goto <D.22245>;
  <D.22244>:
  D.23364 = bb->out_bb;
  D.23358 = (long unsigned int) j;
  D.23359 = D.23358 * 8;
  D.23365 = D.23364 + D.23359;
  D.23366 = *D.23365;
  unlink_target (bb, D.23366);
  j = j + 1;
  <D.22245>:
  D.23367 = bb->out_count;
  D.23368 = (int) D.23367;
  if (D.23368 > j) goto <D.22244>; else goto <D.22246>;
  <D.22246>:
  D.23335 = cfg->verbose_level;
  D.23336 = D.23335 > 1;
  D.23337 = (long int) D.23336;
  D.23338 = __builtin_expect (D.23337, 0);
  if (D.23338 != 0) goto <D.23369>; else goto <D.23370>;
  <D.23369>:
  D.23371 = bb->block_num;
  printf ("\tUnlinked BB%d\n", D.23371);
  <D.23370>:
  <D.23356>:
  i = i + 1;
  <D.22248>:
  i.18 = (unsigned int) i;
  D.23373 = cfg->num_bblocks;
  if (i.18 < D.23373) goto <D.22247>; else goto <D.22249>;
  <D.22249>:
}


unlink_target (struct MonoBasicBlock * bb, struct MonoBasicBlock * target)
{
  struct MonoBasicBlock * * D.23374;
  long unsigned int D.23375;
  long unsigned int D.23376;
  struct MonoBasicBlock * * D.23377;
  struct MonoBasicBlock * D.23378;
  short int D.23381;
  unsigned short D.23382;
  unsigned short D.23383;
  short int D.23384;
  long unsigned int D.23385;
  long unsigned int D.23386;
  struct MonoBasicBlock * * D.23387;
  struct MonoBasicBlock * D.23388;
  int D.23389;
  struct MonoBasicBlock * * D.23390;
  struct MonoBasicBlock * * D.23391;
  struct MonoBasicBlock * D.23392;
  short int D.23395;
  unsigned short D.23396;
  unsigned short D.23397;
  short int D.23398;
  long unsigned int D.23399;
  long unsigned int D.23400;
  struct MonoBasicBlock * * D.23401;
  struct MonoBasicBlock * D.23402;
  int D.23403;
  int i;

  i = 0;
  goto <D.22228>;
  <D.22227>:
  D.23374 = bb->out_bb;
  D.23375 = (long unsigned int) i;
  D.23376 = D.23375 * 8;
  D.23377 = D.23374 + D.23376;
  D.23378 = *D.23377;
  if (D.23378 == target) goto <D.23379>; else goto <D.23380>;
  <D.23379>:
  D.23374 = bb->out_bb;
  D.23375 = (long unsigned int) i;
  D.23376 = D.23375 * 8;
  D.23377 = D.23374 + D.23376;
  D.23374 = bb->out_bb;
  D.23381 = bb->out_count;
  D.23382 = (unsigned short) D.23381;
  D.23383 = D.23382 + 65535;
  D.23384 = (short int) D.23383;
  bb->out_count = D.23384;
  D.23381 = bb->out_count;
  D.23385 = (long unsigned int) D.23381;
  D.23386 = D.23385 * 8;
  D.23387 = D.23374 + D.23386;
  D.23388 = *D.23387;
  *D.23377 = D.23388;
  goto <D.22226>;
  <D.23380>:
  i = i + 1;
  <D.22228>:
  D.23381 = bb->out_count;
  D.23389 = (int) D.23381;
  if (D.23389 > i) goto <D.22227>; else goto <D.22226>;
  <D.22226>:
  i = 0;
  goto <D.22231>;
  <D.22230>:
  D.23390 = target->in_bb;
  D.23375 = (long unsigned int) i;
  D.23376 = D.23375 * 8;
  D.23391 = D.23390 + D.23376;
  D.23392 = *D.23391;
  if (D.23392 == bb) goto <D.23393>; else goto <D.23394>;
  <D.23393>:
  D.23390 = target->in_bb;
  D.23375 = (long unsigned int) i;
  D.23376 = D.23375 * 8;
  D.23391 = D.23390 + D.23376;
  D.23390 = target->in_bb;
  D.23395 = target->in_count;
  D.23396 = (unsigned short) D.23395;
  D.23397 = D.23396 + 65535;
  D.23398 = (short int) D.23397;
  target->in_count = D.23398;
  D.23395 = target->in_count;
  D.23399 = (long unsigned int) D.23395;
  D.23400 = D.23399 * 8;
  D.23401 = D.23390 + D.23400;
  D.23402 = *D.23401;
  *D.23391 = D.23402;
  goto <D.22229>;
  <D.23394>:
  i = i + 1;
  <D.22231>:
  D.23395 = target->in_count;
  D.23403 = (int) D.23395;
  if (D.23403 > i) goto <D.22230>; else goto <D.22229>;
  <D.22229>:
}


mono_ssa_cprop (struct MonoCompile * cfg)
{
  unsigned int D.23404;
  long unsigned int D.23405;
  long unsigned int D.23406;
  unsigned int D.23407;
  unsigned int D.23408;
  struct MonoBasicBlock * D.23411;
  struct GList * bblock_list.19;
  unsigned int D.23413;
  unsigned int D.23414;
  unsigned int D.23415;
  long unsigned int D.23416;
  long unsigned int D.23417;
  struct MonoMethodVar * D.23418;
  long unsigned int D.23419;
  long unsigned int D.23420;
  struct MonoInst * D.23421;
  unsigned int i.20;
  unsigned int D.23425;
  struct GList * bblock_list.21;
  struct GList * bblock_list.22;
  unsigned int D.23430;
  unsigned int D.23431;
  _Bool D.23432;
  long int D.23433;
  long int D.23434;
  struct MonoInst * D.23438;
  short unsigned int D.23440;
  short unsigned int D.23441;
  _Bool D.23442;
  short unsigned int D.23443;
  _Bool D.23444;
  _Bool D.23445;
  short unsigned int D.23447;
  short unsigned int D.23448;
  struct MonoBasicBlock * * D.23452;
  long unsigned int D.23453;
  struct MonoBasicBlock * * D.23454;
  struct MonoBasicBlock * D.23455;
  short int D.23456;
  int D.23457;
  unsigned int D.23458;
  int D.23461;
  struct GList * cvars.23;
  struct GList * cvars.24;
  struct MonoBasicBlock * D.23464;
  unsigned int D.23465;
  unsigned int D.23466;
  struct MonoInst * D.23469;
  unsigned int D.23470;
  unsigned int D.23471;
  struct MonoInst * * carray;
  struct MonoBasicBlock * bb;
  struct GList * bblock_list;
  struct GList * cvars;
  struct GList * tmp;
  int i;

  try
    {
      D.23404 = cfg->next_vreg;
      D.23405 = (long unsigned int) D.23404;
      D.23406 = D.23405 * 8;
      carray = monoeg_malloc0 (D.23406);
      D.23407 = cfg->comp_done;
      D.23408 = D.23407 & 64;
      if (D.23408 == 0) goto <D.23409>; else goto <D.23410>;
      <D.23409>:
      mono_ssa_create_def_use (cfg);
      <D.23410>:
      D.23411 = cfg->bb_entry;
      bblock_list.19 = monoeg_g_list_prepend (0B, D.23411);
      bblock_list = bblock_list.19;
      D.23411 = cfg->bb_entry;
      D.23411 = cfg->bb_entry;
      D.23413 = D.23411->flags;
      D.23414 = D.23413 | 2;
      D.23411->flags = D.23414;
      D.23415 = cfg->num_varinfo;
      D.23416 = (long unsigned int) D.23415;
      D.23417 = D.23416 * 8;
      memset (carray, 0, D.23417);
      i = 0;
      goto <D.22598>;
      <D.22597>:
      {
        struct MonoMethodVar * info;

        D.23418 = cfg->vars;
        D.23419 = (long unsigned int) i;
        D.23420 = D.23419 * 80;
        info = D.23418 + D.23420;
        D.23421 = info->def;
        if (D.23421 == 0B) goto <D.23422>; else goto <D.23423>;
        <D.23422>:
        info->cpstate = 2;
        <D.23423>:
      }
      i = i + 1;
      <D.22598>:
      i.20 = (unsigned int) i;
      D.23415 = cfg->num_varinfo;
      if (i.20 < D.23415) goto <D.22597>; else goto <D.22599>;
      <D.22599>:
      D.23411 = cfg->bb_entry;
      bb = D.23411->next_bb;
      goto <D.22601>;
      <D.22600>:
      D.23425 = bb->region;
      if (D.23425 != 0) goto <D.23426>; else goto <D.23427>;
      <D.23426>:
      add_cprop_bb (cfg, bb, &bblock_list);
      <D.23427>:
      bb = bb->next_bb;
      <D.22601>:
      if (bb != 0B) goto <D.22600>; else goto <D.22602>;
      <D.22602>:
      cvars = 0B;
      goto <D.22620>;
      <D.22619>:
      {
        struct MonoInst * inst;

        bblock_list.21 = bblock_list;
        bb = bblock_list.21->data;
        bblock_list.21 = bblock_list;
        bblock_list.21 = bblock_list;
        bblock_list.22 = monoeg_g_list_delete_link (bblock_list.21, bblock_list.21);
        bblock_list = bblock_list.22;
        D.23430 = bb->flags;
        D.23431 = D.23430 & 2;
        D.23432 = D.23431 == 0;
        D.23433 = (long int) D.23432;
        D.23434 = __builtin_expect (D.23433, 0);
        if (D.23434 != 0) goto <D.23435>; else goto <D.23436>;
        <D.23435>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 1185, "bb->flags & BB_REACHABLE");
        <D.23436>:
        D.23438 = bb->last_ins;
        if (D.23438 == 0B) goto <D.23437>; else goto <D.23439>;
        <D.23439>:
        D.23438 = bb->last_ins;
        D.23440 = D.23438->opcode;
        D.23441 = D.23440 + 64981;
        D.23442 = D.23441 > 9;
        D.23443 = D.23440 + 64874;
        D.23444 = D.23443 > 9;
        D.23445 = D.23442 & D.23444;
        if (D.23445 != 0) goto <D.23446>; else goto <D.22606>;
        <D.23446>:
        D.23438 = bb->last_ins;
        D.23447 = D.23438->opcode;
        D.23448 = D.23447 + 64884;
        if (D.23448 > 9) goto <D.23449>; else goto <D.22606>;
        <D.23449>:
        D.23438 = bb->last_ins;
        D.23447 = D.23438->opcode;
        if (D.23447 != 446) goto <D.23450>; else goto <D.22606>;
        <D.23450>:
        D.23438 = bb->last_ins;
        D.23447 = D.23438->opcode;
        if (D.23447 != 763) goto <D.23451>; else goto <D.22606>;
        <D.23451>:
        D.23438 = bb->last_ins;
        D.23447 = D.23438->opcode;
        if (D.23447 != 370) goto <D.23437>; else goto <D.22606>;
        <D.23437>:
        i = 0;
        goto <D.22605>;
        <D.22604>:
        D.23452 = bb->out_bb;
        D.23419 = (long unsigned int) i;
        D.23453 = D.23419 * 8;
        D.23454 = D.23452 + D.23453;
        D.23455 = *D.23454;
        add_cprop_bb (cfg, D.23455, &bblock_list);
        i = i + 1;
        <D.22605>:
        D.23456 = bb->out_count;
        D.23457 = (int) D.23456;
        if (D.23457 > i) goto <D.22604>; else goto <D.22606>;
        <D.22606>:
        D.23458 = cfg->verbose_level;
        if (D.23458 > 1) goto <D.23459>; else goto <D.23460>;
        <D.23459>:
        D.23461 = bb->block_num;
        printf ("\nSSA CONSPROP BB%d:\n", D.23461);
        <D.23460>:
        inst = bb->code;
        goto <D.22608>;
        <D.22607>:
        visit_inst (cfg, bb, inst, &cvars, &bblock_list, carray);
        inst = inst->next;
        <D.22608>:
        if (inst != 0B) goto <D.22607>; else goto <D.22609>;
        <D.22609>:
        goto <D.22617>;
        <D.22616>:
        {
          struct MonoMethodVar * info;

          cvars.23 = cvars;
          info = cvars.23->data;
          cvars.23 = cvars;
          cvars.23 = cvars;
          cvars.24 = monoeg_g_list_delete_link (cvars.23, cvars.23);
          cvars = cvars.24;
          tmp = info->uses;
          goto <D.22614>;
          <D.22613>:
          {
            struct MonoVarUsageInfo * ui;

            ui = tmp->data;
            D.23464 = ui->bb;
            D.23465 = D.23464->flags;
            D.23466 = D.23465 & 2;
            if (D.23466 == 0) goto <D.23467>; else goto <D.23468>;
            <D.23467>:
            // predicted unlikely by continue predictor.
            goto <D.22612>;
            <D.23468>:
            D.23469 = ui->inst;
            D.23464 = ui->bb;
            visit_inst (cfg, D.23464, D.23469, &cvars, &bblock_list, carray);
          }
          <D.22612>:
          tmp = tmp->next;
          <D.22614>:
          if (tmp != 0B) goto <D.22613>; else goto <D.22615>;
          <D.22615>:
        }
        <D.22617>:
        cvars.23 = cvars;
        if (cvars.23 != 0B) goto <D.22616>; else goto <D.22618>;
        <D.22618>:
      }
      <D.22620>:
      bblock_list.21 = bblock_list;
      if (bblock_list.21 != 0B) goto <D.22619>; else goto <D.22621>;
      <D.22621>:
      D.23411 = cfg->bb_entry;
      bb = D.23411->next_bb;
      goto <D.22627>;
      <D.22626>:
      {
        struct MonoInst * inst;

        inst = bb->code;
        goto <D.22624>;
        <D.22623>:
        fold_ins (cfg, bb, inst, carray);
        inst = inst->next;
        <D.22624>:
        if (inst != 0B) goto <D.22623>; else goto <D.22625>;
        <D.22625>:
      }
      bb = bb->next_bb;
      <D.22627>:
      if (bb != 0B) goto <D.22626>; else goto <D.22628>;
      <D.22628>:
      monoeg_g_free (carray);
      D.23407 = cfg->comp_done;
      D.23470 = D.23407 | 128;
      cfg->comp_done = D.23470;
      D.23407 = cfg->comp_done;
      D.23471 = D.23407 & 4294967231;
      cfg->comp_done = D.23471;
      i = 0;
      goto <D.22631>;
      <D.22630>:
      {
        struct MonoMethodVar * info;

        D.23418 = cfg->vars;
        D.23419 = (long unsigned int) i;
        D.23420 = D.23419 * 80;
        info = D.23418 + D.23420;
        info->def = 0B;
        info->uses = 0B;
      }
      i = i + 1;
      <D.22631>:
      i.20 = (unsigned int) i;
      D.23415 = cfg->num_varinfo;
      if (i.20 < D.23415) goto <D.22630>; else goto <D.22632>;
      <D.22632>:
    }
  finally
    {
      bblock_list = {CLOBBER};
      cvars = {CLOBBER};
    }
}


mono_ssa_create_def_use (struct MonoCompile * cfg)
{
  unsigned int D.23472;
  unsigned int D.23473;
  _Bool D.23474;
  long int D.23475;
  long int D.23476;
  short unsigned int D.23479;
  int D.23480;
  int D.23481;
  int D.23482;
  int D.23485;
  int D.23486;
  int D.23487;
  signed char D.23488;
  struct MonoInst * iftmp.25;
  int D.23490;
  unsigned int D.23491;
  unsigned int D.23492;
  struct MonoInst * * D.23495;
  long unsigned int D.23496;
  long unsigned int D.23497;
  struct MonoInst * * D.23498;
  unsigned char D.23502;
  int D.23503;
  int D.23504;
  short unsigned int D.23507;
  struct MonoInst * iftmp.26;
  int D.23511;
  unsigned int D.23512;
  long unsigned int D.23515;
  long unsigned int D.23516;
  struct MonoInst * * D.23517;
  unsigned char D.23521;
  int D.23522;
  int D.23523;
  short unsigned int D.23526;
  short unsigned int D.23527;
  _Bool D.23528;
  _Bool D.23529;
  _Bool D.23530;
  int * D.23533;
  long unsigned int D.23534;
  long unsigned int D.23535;
  int * D.23536;
  int D.23537;
  _Bool D.23538;
  long int D.23539;
  long int D.23540;
  struct MonoInst * iftmp.27;
  unsigned int D.23544;
  long unsigned int D.23547;
  long unsigned int D.23548;
  struct MonoInst * * D.23549;
  char D.23551;
  struct MonoInst * iftmp.28;
  unsigned char D.23562;
  int D.23563;
  int D.23564;
  struct MonoMethodVar * D.23567;
  long int D.23568;
  long unsigned int D.23569;
  long unsigned int D.23570;
  unsigned int D.23571;
  struct MonoBasicBlock * bb;
  struct MonoInst * ins;
  int i;

  D.23472 = cfg->comp_done;
  D.23473 = D.23472 & 64;
  D.23474 = D.23473 != 0;
  D.23475 = (long int) D.23474;
  D.23476 = __builtin_expect (D.23475, 0);
  if (D.23476 != 0) goto <D.23477>; else goto <D.23478>;
  <D.23477>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 619, "!(cfg->comp_done & MONO_COMP_SSA_DEF_USE)");
  <D.23478>:
  bb = cfg->bb_entry;
  goto <D.22460>;
  <D.22459>:
  ins = bb->code;
  goto <D.22457>;
  <D.22456>:
  {
    const char * spec;
    struct MonoMethodVar * info;
    int num_sregs;
    int sregs[3];

    try
      {
        D.23479 = ins->opcode;
        D.23480 = (int) D.23479;
        D.23481 = D.23480 + -313;
        D.23482 = D.23481 * 4;
        spec = &ins_info[D.23482];
        D.23479 = ins->opcode;
        if (D.23479 == 316) goto <D.23483>; else goto <D.23484>;
        <D.23483>:
        // predicted unlikely by continue predictor.
        goto <D.22446>;
        <D.23484>:
        D.23485 = ins->sreg1;
        sregs[0] = D.23485;
        D.23486 = ins->sreg2;
        sregs[1] = D.23486;
        D.23487 = ins->sreg3;
        sregs[2] = D.23487;
        D.23479 = ins->opcode;
        D.23480 = (int) D.23479;
        D.23481 = D.23480 + -313;
        D.23488 = ins_sreg_counts[D.23481];
        num_sregs = (int) D.23488;
        i = 0;
        goto <D.22449>;
        <D.22448>:
        {
          struct MonoInst * var;

          D.23490 = sregs[i];
          D.23491 = (unsigned int) D.23490;
          D.23492 = cfg->vreg_to_inst_len;
          if (D.23491 < D.23492) goto <D.23493>; else goto <D.23494>;
          <D.23493>:
          D.23495 = cfg->vreg_to_inst;
          D.23490 = sregs[i];
          D.23496 = (long unsigned int) D.23490;
          D.23497 = D.23496 * 8;
          D.23498 = D.23495 + D.23497;
          iftmp.25 = *D.23498;
          goto <D.23499>;
          <D.23494>:
          iftmp.25 = 0B;
          <D.23499>:
          var = iftmp.25;
          if (var != 0B) goto <D.23500>; else goto <D.23501>;
          <D.23500>:
          D.23502 = var->flags;
          D.23503 = (int) D.23502;
          D.23504 = D.23503 & 20;
          if (D.23504 == 0) goto <D.23505>; else goto <D.23506>;
          <D.23505>:
          record_use (cfg, var, bb, ins);
          <D.23506>:
          <D.23501>:
        }
        i = i + 1;
        <D.22449>:
        if (i < num_sregs) goto <D.22448>; else goto <D.22450>;
        <D.22450>:
        D.23479 = ins->opcode;
        D.23507 = D.23479 + 65162;
        if (D.23507 <= 16) goto <D.23508>; else goto <D.23509>;
        <D.23508>:
        {
          struct MonoInst * var;

          D.23511 = ins->dreg;
          D.23512 = (unsigned int) D.23511;
          D.23492 = cfg->vreg_to_inst_len;
          if (D.23512 < D.23492) goto <D.23513>; else goto <D.23514>;
          <D.23513>:
          D.23495 = cfg->vreg_to_inst;
          D.23511 = ins->dreg;
          D.23515 = (long unsigned int) D.23511;
          D.23516 = D.23515 * 8;
          D.23517 = D.23495 + D.23516;
          iftmp.26 = *D.23517;
          goto <D.23518>;
          <D.23514>:
          iftmp.26 = 0B;
          <D.23518>:
          var = iftmp.26;
          if (var != 0B) goto <D.23519>; else goto <D.23520>;
          <D.23519>:
          D.23521 = var->flags;
          D.23522 = (int) D.23521;
          D.23523 = D.23522 & 20;
          if (D.23523 == 0) goto <D.23524>; else goto <D.23525>;
          <D.23524>:
          record_use (cfg, var, bb, ins);
          <D.23525>:
          <D.23520>:
        }
        <D.23509>:
        D.23526 = ins->opcode;
        D.23527 = D.23526 + 65217;
        D.23528 = D.23527 <= 2;
        D.23529 = D.23526 == 964;
        D.23530 = D.23528 | D.23529;
        if (D.23530 != 0) goto <D.23531>; else goto <D.23532>;
        <D.23531>:
        D.23533 = ins->data.op[1].phi_args;
        i = *D.23533;
        goto <D.22453>;
        <D.22452>:
        D.23533 = ins->data.op[1].phi_args;
        D.23534 = (long unsigned int) i;
        D.23535 = D.23534 * 4;
        D.23536 = D.23533 + D.23535;
        D.23537 = *D.23536;
        D.23538 = D.23537 == -1;
        D.23539 = (long int) D.23538;
        D.23540 = __builtin_expect (D.23539, 0);
        if (D.23540 != 0) goto <D.23541>; else goto <D.23542>;
        <D.23541>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 647, "ins->inst_phi_args [i] != -1");
        <D.23542>:
        D.23533 = ins->data.op[1].phi_args;
        D.23534 = (long unsigned int) i;
        D.23535 = D.23534 * 4;
        D.23536 = D.23533 + D.23535;
        D.23537 = *D.23536;
        D.23544 = (unsigned int) D.23537;
        D.23492 = cfg->vreg_to_inst_len;
        if (D.23544 < D.23492) goto <D.23545>; else goto <D.23546>;
        <D.23545>:
        D.23495 = cfg->vreg_to_inst;
        D.23533 = ins->data.op[1].phi_args;
        D.23534 = (long unsigned int) i;
        D.23535 = D.23534 * 4;
        D.23536 = D.23533 + D.23535;
        D.23537 = *D.23536;
        D.23547 = (long unsigned int) D.23537;
        D.23548 = D.23547 * 8;
        D.23549 = D.23495 + D.23548;
        iftmp.27 = *D.23549;
        goto <D.23550>;
        <D.23546>:
        iftmp.27 = 0B;
        <D.23550>:
        record_use (cfg, iftmp.27, bb, ins);
        i = i + -1;
        <D.22453>:
        if (i > 0) goto <D.22452>; else goto <D.22454>;
        <D.22454>:
        <D.23532>:
        D.23551 = *spec;
        if (D.23551 != 32) goto <D.23552>; else goto <D.23553>;
        <D.23552>:
        D.23479 = ins->opcode;
        D.23507 = D.23479 + 65162;
        if (D.23507 > 16) goto <D.23554>; else goto <D.23555>;
        <D.23554>:
        {
          struct MonoInst * var;

          D.23511 = ins->dreg;
          D.23512 = (unsigned int) D.23511;
          D.23492 = cfg->vreg_to_inst_len;
          if (D.23512 < D.23492) goto <D.23557>; else goto <D.23558>;
          <D.23557>:
          D.23495 = cfg->vreg_to_inst;
          D.23511 = ins->dreg;
          D.23515 = (long unsigned int) D.23511;
          D.23516 = D.23515 * 8;
          D.23517 = D.23495 + D.23516;
          iftmp.28 = *D.23517;
          goto <D.23559>;
          <D.23558>:
          iftmp.28 = 0B;
          <D.23559>:
          var = iftmp.28;
          if (var != 0B) goto <D.23560>; else goto <D.23561>;
          <D.23560>:
          D.23562 = var->flags;
          D.23563 = (int) D.23562;
          D.23564 = D.23563 & 20;
          if (D.23564 == 0) goto <D.23565>; else goto <D.23566>;
          <D.23565>:
          D.23567 = cfg->vars;
          D.23568 = var->data.op[0].const_val;
          D.23569 = (long unsigned int) D.23568;
          D.23570 = D.23569 * 80;
          info = D.23567 + D.23570;
          info->def = ins;
          info->def_bb = bb;
          <D.23566>:
          <D.23561>:
        }
        <D.23555>:
        <D.23553>:
      }
    finally
      {
        sregs = {CLOBBER};
      }
  }
  <D.22446>:
  ins = ins->next;
  <D.22457>:
  if (ins != 0B) goto <D.22456>; else goto <D.22458>;
  <D.22458>:
  bb = bb->next_bb;
  <D.22460>:
  if (bb != 0B) goto <D.22459>; else goto <D.22461>;
  <D.22461>:
  D.23472 = cfg->comp_done;
  D.23571 = D.23472 | 64;
  cfg->comp_done = D.23571;
}


add_cprop_bb (struct MonoCompile * cfg, struct MonoBasicBlock * bb, struct GList * * bblist)
{
  unsigned int D.23574;
  _Bool D.23575;
  long int D.23576;
  long int D.23577;
  int D.23580;
  unsigned int D.23581;
  unsigned int D.23582;
  unsigned int D.23585;
  struct GList * D.23586;
  struct GList * D.23587;

  D.23574 = cfg->verbose_level;
  D.23575 = D.23574 > 1;
  D.23576 = (long int) D.23575;
  D.23577 = __builtin_expect (D.23576, 0);
  if (D.23577 != 0) goto <D.23578>; else goto <D.23579>;
  <D.23578>:
  D.23580 = bb->block_num;
  printf ("\tAdd BB%d to worklist\n", D.23580);
  <D.23579>:
  D.23581 = bb->flags;
  D.23582 = D.23581 & 2;
  if (D.23582 == 0) goto <D.23583>; else goto <D.23584>;
  <D.23583>:
  D.23581 = bb->flags;
  D.23585 = D.23581 | 2;
  bb->flags = D.23585;
  D.23586 = *bblist;
  D.23587 = monoeg_g_list_prepend (D.23586, bb);
  *bblist = D.23587;
  <D.23584>:
}


visit_inst (struct MonoCompile * cfg, struct MonoBasicBlock * bb, struct MonoInst * ins, struct GList * * cvars, struct GList * * bblist, struct MonoInst * * carray)
{
  short unsigned int D.23588;
  int D.23589;
  int D.23590;
  int D.23591;
  unsigned int D.23594;
  short unsigned int D.23597;
  short unsigned int D.23598;
  _Bool D.23599;
  _Bool D.23600;
  _Bool D.23601;
  struct MonoMethodVar * D.23604;
  struct MonoInst * iftmp.29;
  int D.23606;
  unsigned int D.23607;
  unsigned int D.23608;
  struct MonoInst * * D.23611;
  long unsigned int D.23612;
  long unsigned int D.23613;
  struct MonoInst * * D.23614;
  long int D.23616;
  long unsigned int D.23617;
  long unsigned int D.23618;
  struct MonoInst * iftmp.30;
  int * D.23620;
  long unsigned int D.23621;
  long unsigned int D.23622;
  int * D.23623;
  int D.23624;
  unsigned int D.23625;
  long unsigned int D.23628;
  long unsigned int D.23629;
  struct MonoInst * * D.23630;
  long int D.23632;
  long unsigned int D.23633;
  long unsigned int D.23634;
  struct MonoBasicBlock * D.23635;
  unsigned int D.23638;
  unsigned int D.23639;
  struct MonoInst * D.23644;
  char D.23647;
  int D.23650;
  long unsigned int D.23651;
  long unsigned int D.23652;
  struct MonoInst * * D.23653;
  struct MonoInst * D.23654;
  _Bool D.23655;
  long int D.23656;
  long int D.23657;
  short unsigned int D.23662;
  long int D.23665;
  long int D.23666;
  int D.23669;
  char D.23672;
  _Bool D.23675;
  long int D.23676;
  long int D.23677;
  short unsigned int D.23684;
  const char * D.23686;
  char D.23687;
  const char * D.23689;
  char D.23690;
  char D.23692;
  struct MonoInst * iftmp.31;
  unsigned char D.23703;
  int D.23704;
  int D.23705;
  long int D.23707;
  long unsigned int D.23708;
  long unsigned int D.23709;
  char D.23710;
  struct MonoInst * c0.32;
  struct MonoInst * * D.23725;
  struct MonoInst * D.23727;
  struct GList * D.23730;
  struct GList * D.23731;
  struct GList * D.23734;
  struct MonoInst * D.23740;
  struct MonoInst * D.23743;
  struct MonoJumpInfoBBTable * iftmp.33;
  struct MonoJumpInfoBBTable * iftmp.34;
  struct MonoJumpInfoBBTable * iftmp.35;
  struct MonoJumpInfoBBTable * iftmp.36;
  struct MonoInst * D.23764;
  short unsigned int D.23766;
  struct MonoBasicBlock * * D.23767;
  long unsigned int D.23768;
  long unsigned int D.23769;
  struct MonoBasicBlock * * D.23770;
  struct MonoBasicBlock * D.23771;
  int D.23774;
  _Bool D.23775;
  long int D.23776;
  long int D.23777;
  int D.23780;
  _Bool D.23781;
  long int D.23782;
  long int D.23783;
  int D.23786;
  long unsigned int D.23787;
  long unsigned int D.23788;
  struct MonoInst * * D.23789;
  struct MonoInst * D.23790;
  long int D.23793;
  long int D.23794;
  long unsigned int D.23798;
  long unsigned int D.23799;
  struct MonoBasicBlock * * D.23800;
  struct MonoBasicBlock * D.23801;
  struct MonoBasicBlock * * D.23809;
  long unsigned int D.23810;
  long unsigned int D.23811;
  struct MonoBasicBlock * * D.23812;
  struct MonoBasicBlock * D.23813;
  int D.23816;
  short unsigned int D.23821;
  short unsigned int D.23822;
  _Bool D.23823;
  short unsigned int D.23824;
  _Bool D.23825;
  _Bool D.23826;
  short unsigned int D.23828;
  short unsigned int D.23831;
  _Bool D.23832;
  long int D.23833;
  long int D.23834;
  long int D.23837;
  unsigned char D.23840;
  unsigned char D.23841;
  unsigned char D.23843;
  unsigned char D.23845;
  struct MonoBasicBlock * D.23848;
  short unsigned int D.23852;
  short unsigned int D.23853;
  _Bool D.23854;
  short unsigned int D.23855;
  _Bool D.23856;
  _Bool D.23857;
  short unsigned int D.23859;
  unsigned char D.23860;
  int D.23861;
  int D.23862;
  struct MonoBasicBlock * * D.23865;
  struct MonoBasicBlock * D.23866;
  int D.23868;
  struct MonoBasicBlock * * D.23871;
  struct MonoBasicBlock * D.23872;
  const char * spec;

  D.23588 = ins->opcode;
  D.23589 = (int) D.23588;
  D.23590 = D.23589 + -313;
  D.23591 = D.23590 * 4;
  spec = &ins_info[D.23591];
  D.23588 = ins->opcode;
  if (D.23588 == 316) goto <D.23592>; else goto <D.23593>;
  <D.23592>:
  return;
  <D.23593>:
  D.23594 = cfg->verbose_level;
  if (D.23594 > 1) goto <D.23595>; else goto <D.23596>;
  <D.23595>:
  mono_print_ins (ins);
  <D.23596>:
  D.23597 = ins->opcode;
  D.23598 = D.23597 + 65217;
  D.23599 = D.23598 <= 2;
  D.23600 = D.23597 == 964;
  D.23601 = D.23599 | D.23600;
  if (D.23601 != 0) goto <D.23602>; else goto <D.23603>;
  <D.23602>:
  {
    struct MonoMethodVar * info;
    struct MonoInst * c0;
    int j;

    D.23604 = cfg->vars;
    D.23606 = ins->dreg;
    D.23607 = (unsigned int) D.23606;
    D.23608 = cfg->vreg_to_inst_len;
    if (D.23607 < D.23608) goto <D.23609>; else goto <D.23610>;
    <D.23609>:
    D.23611 = cfg->vreg_to_inst;
    D.23606 = ins->dreg;
    D.23612 = (long unsigned int) D.23606;
    D.23613 = D.23612 * 8;
    D.23614 = D.23611 + D.23613;
    iftmp.29 = *D.23614;
    goto <D.23615>;
    <D.23610>:
    iftmp.29 = 0B;
    <D.23615>:
    D.23616 = iftmp.29->data.op[0].const_val;
    D.23617 = (long unsigned int) D.23616;
    D.23618 = D.23617 * 80;
    info = D.23604 + D.23618;
    c0 = 0B;
    j = 1;
    goto <D.22550>;
    <D.22549>:
    {
      struct MonoInst * var;
      struct MonoMethodVar * mv;
      struct MonoInst * src;

      D.23620 = ins->data.op[1].phi_args;
      D.23621 = (long unsigned int) j;
      D.23622 = D.23621 * 4;
      D.23623 = D.23620 + D.23622;
      D.23624 = *D.23623;
      D.23625 = (unsigned int) D.23624;
      D.23608 = cfg->vreg_to_inst_len;
      if (D.23625 < D.23608) goto <D.23626>; else goto <D.23627>;
      <D.23626>:
      D.23611 = cfg->vreg_to_inst;
      D.23620 = ins->data.op[1].phi_args;
      D.23621 = (long unsigned int) j;
      D.23622 = D.23621 * 4;
      D.23623 = D.23620 + D.23622;
      D.23624 = *D.23623;
      D.23628 = (long unsigned int) D.23624;
      D.23629 = D.23628 * 8;
      D.23630 = D.23611 + D.23629;
      iftmp.30 = *D.23630;
      goto <D.23631>;
      <D.23627>:
      iftmp.30 = 0B;
      <D.23631>:
      var = iftmp.30;
      D.23604 = cfg->vars;
      D.23632 = var->data.op[0].const_val;
      D.23633 = (long unsigned int) D.23632;
      D.23634 = D.23633 * 80;
      mv = D.23604 + D.23634;
      src = mv->def;
      D.23635 = mv->def_bb;
      if (D.23635 != 0B) goto <D.23636>; else goto <D.23637>;
      <D.23636>:
      D.23635 = mv->def_bb;
      D.23638 = D.23635->flags;
      D.23639 = D.23638 & 2;
      if (D.23639 == 0) goto <D.23640>; else goto <D.23641>;
      <D.23640>:
      // predicted unlikely by continue predictor.
      goto <D.22547>;
      <D.23641>:
      <D.23637>:
      D.23644 = mv->def;
      if (D.23644 == 0B) goto <D.23642>; else goto <D.23645>;
      <D.23645>:
      if (src == 0B) goto <D.23642>; else goto <D.23646>;
      <D.23646>:
      D.23647 = mv->cpstate;
      if (D.23647 == 2) goto <D.23642>; else goto <D.23643>;
      <D.23642>:
      change_varstate (cfg, cvars, info, 2, 0B, carray);
      goto <D.22548>;
      <D.23643>:
      D.23647 = mv->cpstate;
      if (D.23647 == 0) goto <D.23648>; else goto <D.23649>;
      <D.23648>:
      // predicted unlikely by continue predictor.
      goto <D.22547>;
      <D.23649>:
      D.23650 = var->dreg;
      D.23651 = (long unsigned int) D.23650;
      D.23652 = D.23651 * 8;
      D.23653 = carray + D.23652;
      D.23654 = *D.23653;
      D.23655 = D.23654 == 0B;
      D.23656 = (long int) D.23655;
      D.23657 = __builtin_expect (D.23656, 0);
      if (D.23657 != 0) goto <D.23658>; else goto <D.23659>;
      <D.23658>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 873, "carray [var->dreg]");
      <D.23659>:
      if (c0 == 0B) goto <D.23660>; else goto <D.23661>;
      <D.23660>:
      D.23650 = var->dreg;
      D.23651 = (long unsigned int) D.23650;
      D.23652 = D.23651 * 8;
      D.23653 = carray + D.23652;
      c0 = *D.23653;
      <D.23661>:
      D.23662 = c0->opcode;
      if (D.23662 != 362) goto <D.23663>; else goto <D.23664>;
      <D.23663>:
      change_varstate (cfg, cvars, info, 2, 0B, carray);
      goto <D.22548>;
      <D.23664>:
      D.23650 = var->dreg;
      D.23651 = (long unsigned int) D.23650;
      D.23652 = D.23651 * 8;
      D.23653 = carray + D.23652;
      D.23654 = *D.23653;
      D.23665 = D.23654->data.op[0].const_val;
      D.23666 = c0->data.op[0].const_val;
      if (D.23665 != D.23666) goto <D.23667>; else goto <D.23668>;
      <D.23667>:
      change_varstate (cfg, cvars, info, 2, 0B, carray);
      goto <D.22548>;
      <D.23668>:
    }
    <D.22547>:
    j = j + 1;
    <D.22550>:
    D.23620 = ins->data.op[1].phi_args;
    D.23669 = *D.23620;
    if (D.23669 >= j) goto <D.22549>; else goto <D.22548>;
    <D.22548>:
    if (c0 != 0B) goto <D.23670>; else goto <D.23671>;
    <D.23670>:
    D.23672 = info->cpstate;
    if (D.23672 <= 0) goto <D.23673>; else goto <D.23674>;
    <D.23673>:
    change_varstate (cfg, cvars, info, 1, c0, carray);
    D.23662 = c0->opcode;
    D.23675 = D.23662 != 362;
    D.23676 = (long int) D.23675;
    D.23677 = __builtin_expect (D.23676, 0);
    if (D.23677 != 0) goto <D.23678>; else goto <D.23679>;
    <D.23678>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 893, "c0->opcode == OP_ICONST");
    <D.23679>:
    <D.23674>:
    <D.23671>:
  }
  goto <D.23680>;
  <D.23603>:
  D.23588 = ins->opcode;
  D.23684 = D.23588 + 65162;
  if (D.23684 > 16) goto <D.23685>; else goto <D.23681>;
  <D.23685>:
  D.23686 = spec + 1;
  D.23687 = *D.23686;
  if (D.23687 != 32) goto <D.23682>; else goto <D.23688>;
  <D.23688>:
  D.23689 = spec + 2;
  D.23690 = *D.23689;
  if (D.23690 != 32) goto <D.23682>; else goto <D.23691>;
  <D.23691>:
  D.23692 = *spec;
  if (D.23692 != 32) goto <D.23682>; else goto <D.23681>;
  <D.23682>:
  {
    struct MonoInst * var;
    struct MonoInst * c0;
    int state;

    try
      {
        D.23692 = *spec;
        if (D.23692 != 32) goto <D.23693>; else goto <D.23694>;
        <D.23693>:
        D.23606 = ins->dreg;
        D.23607 = (unsigned int) D.23606;
        D.23608 = cfg->vreg_to_inst_len;
        if (D.23607 < D.23608) goto <D.23696>; else goto <D.23697>;
        <D.23696>:
        D.23611 = cfg->vreg_to_inst;
        D.23606 = ins->dreg;
        D.23612 = (long unsigned int) D.23606;
        D.23613 = D.23612 * 8;
        D.23614 = D.23611 + D.23613;
        iftmp.31 = *D.23614;
        goto <D.23698>;
        <D.23697>:
        iftmp.31 = 0B;
        <D.23698>:
        var = iftmp.31;
        goto <D.23699>;
        <D.23694>:
        var = 0B;
        <D.23699>:
        c0 = 0B;
        state = evaluate_ins (cfg, ins, &c0, carray);
        if (var != 0B) goto <D.23702>; else goto <D.23700>;
        <D.23702>:
        D.23703 = var->flags;
        D.23704 = (int) D.23703;
        D.23705 = D.23704 & 20;
        if (D.23705 == 0) goto <D.23706>; else goto <D.23700>;
        <D.23706>:
        {
          struct MonoMethodVar * info;

          D.23604 = cfg->vars;
          D.23707 = var->data.op[0].const_val;
          D.23708 = (long unsigned int) D.23707;
          D.23709 = D.23708 * 80;
          info = D.23604 + D.23709;
          D.23710 = info->cpstate;
          if (D.23710 <= 1) goto <D.23711>; else goto <D.23712>;
          <D.23711>:
          if (state == 1) goto <D.23713>; else goto <D.23714>;
          <D.23713>:
          c0.32 = c0;
          change_varstate (cfg, cvars, info, 1, c0.32, carray);
          goto <D.23716>;
          <D.23714>:
          if (state == 2) goto <D.23717>; else goto <D.23718>;
          <D.23717>:
          change_varstate (cfg, cvars, info, 2, 0B, carray);
          <D.23718>:
          <D.23716>:
          <D.23712>:
        }
        goto <D.23701>;
        <D.23700>:
        if (var == 0B) goto <D.23719>; else goto <D.23720>;
        <D.23719>:
        D.23606 = ins->dreg;
        if (D.23606 != -1) goto <D.23721>; else goto <D.23722>;
        <D.23721>:
        c0.32 = c0;
        if (c0.32 != 0B) goto <D.23723>; else goto <D.23724>;
        <D.23723>:
        D.23606 = ins->dreg;
        D.23612 = (long unsigned int) D.23606;
        D.23613 = D.23612 * 8;
        D.23725 = carray + D.23613;
        c0.32 = c0;
        *D.23725 = c0.32;
        goto <D.23726>;
        <D.23724>:
        D.23606 = ins->dreg;
        D.23612 = (long unsigned int) D.23606;
        D.23613 = D.23612 * 8;
        D.23725 = carray + D.23613;
        D.23727 = *D.23725;
        if (D.23727 != 0B) goto <D.23728>; else goto <D.23729>;
        <D.23728>:
        D.23606 = ins->dreg;
        D.23612 = (long unsigned int) D.23606;
        D.23613 = D.23612 * 8;
        D.23725 = carray + D.23613;
        *D.23725 = 0B;
        D.23730 = *bblist;
        D.23731 = monoeg_g_list_find (D.23730, bb);
        if (D.23731 == 0B) goto <D.23732>; else goto <D.23733>;
        <D.23732>:
        D.23730 = *bblist;
        D.23734 = monoeg_g_list_prepend (D.23730, bb);
        *bblist = D.23734;
        <D.23733>:
        <D.23729>:
        <D.23726>:
        <D.23722>:
        <D.23720>:
        <D.23701>:
        D.23588 = ins->opcode;
        if (D.23588 == 735) goto <D.23735>; else goto <D.23738>;
        <D.23738>:
        D.23588 = ins->opcode;
        if (D.23588 == 736) goto <D.23739>; else goto <D.23736>;
        <D.23739>:
        D.23740 = ins->data.op[1].src;
        if (D.23740 == 8B) goto <D.23735>; else goto <D.23736>;
        <D.23736>:
        D.23588 = ins->opcode;
        if (D.23588 == 370) goto <D.23735>; else goto <D.23741>;
        <D.23741>:
        D.23588 = ins->opcode;
        if (D.23588 == 738) goto <D.23742>; else goto <D.23737>;
        <D.23742>:
        D.23740 = ins->data.op[1].src;
        D.23743 = D.23740->data.op[1].src;
        if (D.23743 == 8B) goto <D.23735>; else goto <D.23737>;
        <D.23735>:
        {
          int i;
          struct MonoJumpInfoBBTable * table;

          D.23588 = ins->opcode;
          if (D.23588 == 735) goto <D.23745>; else goto <D.23746>;
          <D.23745>:
          iftmp.33 = ins->data.op[0].p;
          goto <D.23747>;
          <D.23746>:
          D.23588 = ins->opcode;
          if (D.23588 == 736) goto <D.23751>; else goto <D.23749>;
          <D.23751>:
          D.23740 = ins->data.op[1].src;
          if (D.23740 == 8B) goto <D.23752>; else goto <D.23749>;
          <D.23752>:
          iftmp.34 = ins->data.op[0].p;
          goto <D.23750>;
          <D.23749>:
          D.23588 = ins->opcode;
          if (D.23588 == 370) goto <D.23754>; else goto <D.23755>;
          <D.23754>:
          iftmp.35 = ins->data.op[0].p;
          goto <D.23756>;
          <D.23755>:
          D.23588 = ins->opcode;
          if (D.23588 == 738) goto <D.23760>; else goto <D.23758>;
          <D.23760>:
          D.23740 = ins->data.op[1].src;
          D.23743 = D.23740->data.op[1].src;
          if (D.23743 == 8B) goto <D.23761>; else goto <D.23758>;
          <D.23761>:
          D.23740 = ins->data.op[1].src;
          iftmp.36 = D.23740->data.op[0].p;
          goto <D.23759>;
          <D.23758>:
          iftmp.36 = 0B;
          <D.23759>:
          iftmp.35 = iftmp.36;
          <D.23756>:
          iftmp.34 = iftmp.35;
          <D.23750>:
          iftmp.33 = iftmp.34;
          <D.23747>:
          table = iftmp.33;
          D.23764 = ins->next;
          if (D.23764 == 0B) goto <D.23762>; else goto <D.23765>;
          <D.23765>:
          D.23764 = ins->next;
          D.23766 = D.23764->opcode;
          if (D.23766 != 483) goto <D.23762>; else goto <D.23763>;
          <D.23762>:
          i = 0;
          goto <D.22558>;
          <D.22557>:
          D.23767 = table->table;
          D.23768 = (long unsigned int) i;
          D.23769 = D.23768 * 8;
          D.23770 = D.23767 + D.23769;
          D.23771 = *D.23770;
          if (D.23771 != 0B) goto <D.23772>; else goto <D.23773>;
          <D.23772>:
          D.23767 = table->table;
          D.23768 = (long unsigned int) i;
          D.23769 = D.23768 * 8;
          D.23770 = D.23767 + D.23769;
          D.23771 = *D.23770;
          add_cprop_bb (cfg, D.23771, bblist);
          <D.23773>:
          i = i + 1;
          <D.22558>:
          D.23774 = table->table_size;
          if (D.23774 > i) goto <D.22557>; else goto <D.22559>;
          <D.22559>:
          return;
          <D.23763>:
          D.23764 = ins->next;
          D.23766 = D.23764->opcode;
          D.23775 = D.23766 != 483;
          D.23776 = (long int) D.23775;
          D.23777 = __builtin_expect (D.23776, 0);
          if (D.23777 != 0) goto <D.23778>; else goto <D.23779>;
          <D.23778>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 955, "ins->next->opcode == OP_PADD");
          <D.23779>:
          D.23764 = ins->next;
          D.23780 = D.23764->sreg1;
          D.23606 = ins->dreg;
          D.23781 = D.23780 != D.23606;
          D.23782 = (long int) D.23781;
          D.23783 = __builtin_expect (D.23782, 0);
          if (D.23783 != 0) goto <D.23784>; else goto <D.23785>;
          <D.23784>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 956, "ins->next->sreg1 == ins->dreg");
          <D.23785>:
          D.23764 = ins->next;
          D.23786 = D.23764->sreg2;
          D.23787 = (long unsigned int) D.23786;
          D.23788 = D.23787 * 8;
          D.23789 = carray + D.23788;
          D.23790 = *D.23789;
          if (D.23790 != 0B) goto <D.23791>; else goto <D.23792>;
          <D.23791>:
          {
            int idx;

            D.23764 = ins->next;
            D.23786 = D.23764->sreg2;
            D.23787 = (long unsigned int) D.23786;
            D.23788 = D.23787 * 8;
            D.23789 = carray + D.23788;
            D.23790 = *D.23789;
            D.23793 = D.23790->data.op[0].const_val;
            D.23794 = D.23793 >> 3;
            idx = (int) D.23794;
            if (idx < 0) goto <D.23795>; else goto <D.23797>;
            <D.23797>:
            D.23774 = table->table_size;
            if (D.23774 <= idx) goto <D.23795>; else goto <D.23796>;
            <D.23795>:
            return;
            <D.23796>:
            D.23767 = table->table;
            D.23798 = (long unsigned int) idx;
            D.23799 = D.23798 * 8;
            D.23800 = D.23767 + D.23799;
            D.23801 = *D.23800;
            if (D.23801 != 0B) goto <D.23802>; else goto <D.23803>;
            <D.23802>:
            D.23767 = table->table;
            D.23798 = (long unsigned int) idx;
            D.23799 = D.23798 * 8;
            D.23800 = D.23767 + D.23799;
            D.23801 = *D.23800;
            add_cprop_bb (cfg, D.23801, bblist);
            <D.23803>:
          }
          goto <D.23804>;
          <D.23792>:
          i = 0;
          goto <D.22562>;
          <D.22561>:
          D.23767 = table->table;
          D.23768 = (long unsigned int) i;
          D.23769 = D.23768 * 8;
          D.23770 = D.23767 + D.23769;
          D.23771 = *D.23770;
          if (D.23771 != 0B) goto <D.23805>; else goto <D.23806>;
          <D.23805>:
          D.23767 = table->table;
          D.23768 = (long unsigned int) i;
          D.23769 = D.23768 * 8;
          D.23770 = D.23767 + D.23769;
          D.23771 = *D.23770;
          add_cprop_bb (cfg, D.23771, bblist);
          <D.23806>:
          i = i + 1;
          <D.22562>:
          D.23774 = table->table_size;
          if (D.23774 > i) goto <D.22561>; else goto <D.22563>;
          <D.22563>:
          <D.23804>:
        }
        <D.23737>:
        D.23588 = ins->opcode;
        if (D.23588 == 370) goto <D.23807>; else goto <D.23808>;
        <D.23807>:
        {
          int i;
          struct MonoJumpInfoBBTable * table;

          table = ins->data.op[0].p;
          i = 0;
          goto <D.22567>;
          <D.22566>:
          D.23809 = table->table;
          D.23810 = (long unsigned int) i;
          D.23811 = D.23810 * 8;
          D.23812 = D.23809 + D.23811;
          D.23813 = *D.23812;
          if (D.23813 != 0B) goto <D.23814>; else goto <D.23815>;
          <D.23814>:
          D.23809 = table->table;
          D.23810 = (long unsigned int) i;
          D.23811 = D.23810 * 8;
          D.23812 = D.23809 + D.23811;
          D.23813 = *D.23812;
          add_cprop_bb (cfg, D.23813, bblist);
          <D.23815>:
          i = i + 1;
          <D.22567>:
          D.23816 = table->table_size;
          if (D.23816 > i) goto <D.22566>; else goto <D.22568>;
          <D.22568>:
        }
        <D.23808>:
        D.23764 = ins->next;
        if (D.23764 != 0B) goto <D.23819>; else goto <D.23820>;
        <D.23819>:
        D.23764 = ins->next;
        D.23821 = D.23764->opcode;
        D.23822 = D.23821 + 64981;
        D.23823 = D.23822 <= 9;
        D.23824 = D.23821 + 64874;
        D.23825 = D.23824 <= 9;
        D.23826 = D.23823 | D.23825;
        if (D.23826 != 0) goto <D.23817>; else goto <D.23827>;
        <D.23827>:
        D.23764 = ins->next;
        D.23766 = D.23764->opcode;
        D.23828 = D.23766 + 64884;
        if (D.23828 <= 9) goto <D.23817>; else goto <D.23818>;
        <D.23817>:
        c0.32 = c0;
        if (c0.32 != 0B) goto <D.23829>; else goto <D.23830>;
        <D.23829>:
        c0.32 = c0;
        D.23831 = c0.32->opcode;
        D.23832 = D.23831 != 362;
        D.23833 = (long int) D.23832;
        D.23834 = __builtin_expect (D.23833, 0);
        if (D.23834 != 0) goto <D.23835>; else goto <D.23836>;
        <D.23835>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 990, "c0->opcode == OP_ICONST");
        <D.23836>:
        c0.32 = c0;
        D.23837 = c0.32->data.op[0].const_val;
        if (D.23837 != 0) goto <D.23838>; else goto <D.23839>;
        <D.23838>:
        D.23764 = ins->next;
        D.23764 = ins->next;
        D.23840 = D.23764->flags;
        D.23841 = D.23840 | 8;
        D.23764->flags = D.23841;
        goto <D.23842>;
        <D.23839>:
        D.23764 = ins->next;
        D.23764 = ins->next;
        D.23840 = D.23764->flags;
        D.23843 = D.23840 | 16;
        D.23764->flags = D.23843;
        <D.23842>:
        goto <D.23844>;
        <D.23830>:
        D.23764 = ins->next;
        D.23764 = ins->next;
        D.23840 = D.23764->flags;
        D.23845 = D.23840 & 231;
        D.23764->flags = D.23845;
        <D.23844>:
        D.23764 = ins->next;
        visit_inst (cfg, bb, D.23764, cvars, bblist, carray);
        <D.23818>:
        <D.23820>:
      }
    finally
      {
        c0 = {CLOBBER};
      }
  }
  goto <D.23683>;
  <D.23681>:
  D.23588 = ins->opcode;
  if (D.23588 == 446) goto <D.23846>; else goto <D.23847>;
  <D.23846>:
  D.23848 = ins->data.op[0].target_block;
  add_cprop_bb (cfg, D.23848, bblist);
  goto <D.23849>;
  <D.23847>:
  D.23852 = ins->opcode;
  D.23853 = D.23852 + 64981;
  D.23854 = D.23853 <= 9;
  D.23855 = D.23852 + 64874;
  D.23856 = D.23855 <= 9;
  D.23857 = D.23854 | D.23856;
  if (D.23857 != 0) goto <D.23850>; else goto <D.23858>;
  <D.23858>:
  D.23588 = ins->opcode;
  D.23859 = D.23588 + 64884;
  if (D.23859 <= 9) goto <D.23850>; else goto <D.23851>;
  <D.23850>:
  D.23860 = ins->flags;
  D.23861 = (int) D.23860;
  D.23862 = D.23861 & 8;
  if (D.23862 != 0) goto <D.23863>; else goto <D.23864>;
  <D.23863>:
  D.23865 = ins->data.op[1].many_blocks;
  D.23866 = *D.23865;
  add_cprop_bb (cfg, D.23866, bblist);
  goto <D.23867>;
  <D.23864>:
  D.23860 = ins->flags;
  D.23861 = (int) D.23860;
  D.23868 = D.23861 & 16;
  if (D.23868 != 0) goto <D.23869>; else goto <D.23870>;
  <D.23869>:
  D.23865 = ins->data.op[1].many_blocks;
  D.23871 = D.23865 + 8;
  D.23872 = *D.23871;
  if (D.23872 != 0B) goto <D.23873>; else goto <D.23874>;
  <D.23873>:
  D.23865 = ins->data.op[1].many_blocks;
  D.23871 = D.23865 + 8;
  D.23872 = *D.23871;
  add_cprop_bb (cfg, D.23872, bblist);
  <D.23874>:
  goto <D.23875>;
  <D.23870>:
  D.23865 = ins->data.op[1].many_blocks;
  D.23866 = *D.23865;
  add_cprop_bb (cfg, D.23866, bblist);
  D.23865 = ins->data.op[1].many_blocks;
  D.23871 = D.23865 + 8;
  D.23872 = *D.23871;
  if (D.23872 != 0B) goto <D.23876>; else goto <D.23877>;
  <D.23876>:
  D.23865 = ins->data.op[1].many_blocks;
  D.23871 = D.23865 + 8;
  D.23872 = *D.23871;
  add_cprop_bb (cfg, D.23872, bblist);
  <D.23877>:
  <D.23875>:
  <D.23867>:
  <D.23851>:
  <D.23849>:
  <D.23683>:
  <D.23680>:
}


evaluate_ins (struct MonoCompile * cfg, struct MonoInst * ins, struct MonoInst * * res, struct MonoInst * * carray)
{
  short unsigned int D.23881;
  int D.23882;
  int D.23883;
  int D.23884;
  int D.23887;
  int D.23890;
  int D.23891;
  int D.23892;
  signed char D.23893;
  struct MonoInst * iftmp.37;
  int D.23895;
  unsigned int D.23896;
  unsigned int D.23897;
  struct MonoInst * * D.23900;
  long unsigned int D.23901;
  long unsigned int D.23902;
  struct MonoInst * * D.23903;
  struct MonoInst * * D.23905;
  struct MonoInst * D.23906;
  struct MonoInst * D.23907;
  unsigned char D.23913;
  int D.23914;
  int D.23915;
  struct MonoMethodVar * D.23918;
  long int D.23919;
  long unsigned int D.23920;
  long unsigned int D.23921;
  struct MonoMethodVar * D.23922;
  char D.23923;
  int D.23924;
  int D.23925;
  _Bool D.23928;
  _Bool D.23929;
  _Bool D.23930;
  _Bool D.23933;
  long int D.23934;
  long int D.23935;
  char D.23938;
  int D.23941;
  long unsigned int D.23942;
  long unsigned int D.23943;
  struct MonoInst * * D.23944;
  struct MonoInst * D.23945;
  struct MonoInst * D.23948;
  struct MonoInst * D.23949;
  unsigned int D.23952;
  _Bool D.23953;
  long int D.23954;
  long int D.23955;
  struct MonoInst * args[3];
  int rs[3];
  struct MonoInst * c0;
  gboolean const_args;
  const char * spec;
  int num_sregs;
  int i;
  int sregs[3];

  try
    {
      const_args = 1;
      D.23881 = ins->opcode;
      D.23882 = (int) D.23881;
      D.23883 = D.23882 + -313;
      D.23884 = D.23883 * 4;
      spec = &ins_info[D.23884];
      D.23881 = ins->opcode;
      if (D.23881 == 362) goto <D.23885>; else goto <D.23886>;
      <D.23885>:
      *res = ins;
      D.23887 = 1;
      return D.23887;
      <D.23886>:
      D.23881 = ins->opcode;
      if (D.23881 == 316) goto <D.23888>; else goto <D.23889>;
      <D.23888>:
      D.23887 = 2;
      return D.23887;
      <D.23889>:
      D.23890 = ins->sreg1;
      sregs[0] = D.23890;
      D.23891 = ins->sreg2;
      sregs[1] = D.23891;
      D.23892 = ins->sreg3;
      sregs[2] = D.23892;
      D.23881 = ins->opcode;
      D.23882 = (int) D.23881;
      D.23883 = D.23882 + -313;
      D.23893 = ins_sreg_counts[D.23883];
      num_sregs = (int) D.23893;
      i = 0;
      goto <D.22510>;
      <D.22509>:
      args[i] = 0B;
      i = i + 1;
      <D.22510>:
      if (i <= 2) goto <D.22509>; else goto <D.22511>;
      <D.22511>:
      i = 0;
      goto <D.22514>;
      <D.22513>:
      {
        struct MonoInst * var;

        D.23895 = sregs[i];
        D.23896 = (unsigned int) D.23895;
        D.23897 = cfg->vreg_to_inst_len;
        if (D.23896 < D.23897) goto <D.23898>; else goto <D.23899>;
        <D.23898>:
        D.23900 = cfg->vreg_to_inst;
        D.23895 = sregs[i];
        D.23901 = (long unsigned int) D.23895;
        D.23902 = D.23901 * 8;
        D.23903 = D.23900 + D.23902;
        iftmp.37 = *D.23903;
        goto <D.23904>;
        <D.23899>:
        iftmp.37 = 0B;
        <D.23904>:
        var = iftmp.37;
        rs[i] = 2;
        D.23895 = sregs[i];
        D.23901 = (long unsigned int) D.23895;
        D.23902 = D.23901 * 8;
        D.23905 = carray + D.23902;
        D.23906 = *D.23905;
        args[i] = D.23906;
        D.23907 = args[i];
        if (D.23907 != 0B) goto <D.23908>; else goto <D.23909>;
        <D.23908>:
        rs[i] = 1;
        goto <D.23910>;
        <D.23909>:
        if (var != 0B) goto <D.23911>; else goto <D.23912>;
        <D.23911>:
        D.23913 = var->flags;
        D.23914 = (int) D.23913;
        D.23915 = D.23914 & 20;
        if (D.23915 == 0) goto <D.23916>; else goto <D.23917>;
        <D.23916>:
        D.23918 = cfg->vars;
        D.23919 = var->data.op[0].const_val;
        D.23920 = (long unsigned int) D.23919;
        D.23921 = D.23920 * 80;
        D.23922 = D.23918 + D.23921;
        D.23923 = D.23922->cpstate;
        D.23924 = (int) D.23923;
        rs[i] = D.23924;
        <D.23917>:
        <D.23912>:
        <D.23910>:
        D.23925 = rs[i];
        if (D.23925 != 1) goto <D.23926>; else goto <D.23927>;
        <D.23926>:
        const_args = 0;
        <D.23927>:
      }
      i = i + 1;
      <D.22514>:
      if (i < num_sregs) goto <D.22513>; else goto <D.22515>;
      <D.22515>:
      c0 = 0B;
      D.23928 = num_sregs > 0;
      D.23929 = const_args != 0;
      D.23930 = D.23928 & D.23929;
      if (D.23930 != 0) goto <D.23931>; else goto <D.23932>;
      <D.23931>:
      D.23933 = num_sregs > 2;
      D.23934 = (long int) D.23933;
      D.23935 = __builtin_expect (D.23934, 0);
      if (D.23935 != 0) goto <D.23936>; else goto <D.23937>;
      <D.23936>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 776, "num_sregs <= 2");
      <D.23937>:
      D.23938 = *spec;
      if (D.23938 != 32) goto <D.23939>; else goto <D.23940>;
      <D.23939>:
      D.23941 = ins->dreg;
      D.23942 = (long unsigned int) D.23941;
      D.23943 = D.23942 * 8;
      D.23944 = carray + D.23943;
      D.23945 = *D.23944;
      if (D.23945 != 0B) goto <D.23946>; else goto <D.23947>;
      <D.23946>:
      D.23941 = ins->dreg;
      D.23942 = (long unsigned int) D.23941;
      D.23943 = D.23942 * 8;
      D.23944 = carray + D.23943;
      D.23945 = *D.23944;
      *res = D.23945;
      D.23887 = 1;
      return D.23887;
      <D.23947>:
      <D.23940>:
      D.23948 = args[1];
      D.23949 = args[0];
      c0 = mono_constant_fold_ins (cfg, ins, D.23949, D.23948, 0);
      if (c0 != 0B) goto <D.23950>; else goto <D.23951>;
      <D.23950>:
      D.23952 = cfg->verbose_level;
      D.23953 = D.23952 > 1;
      D.23954 = (long int) D.23953;
      D.23955 = __builtin_expect (D.23954, 0);
      if (D.23955 != 0) goto <D.23956>; else goto <D.23957>;
      <D.23956>:
      printf ("\t cfold -> ");
      mono_print_ins (c0);
      <D.23957>:
      *res = c0;
      D.23887 = 1;
      return D.23887;
      <D.23951>:
      D.23887 = 2;
      return D.23887;
      <D.23932>:
      if (num_sregs == 0) goto <D.23958>; else goto <D.23959>;
      <D.23958>:
      D.23887 = 2;
      return D.23887;
      <D.23959>:
      i = 0;
      goto <D.22517>;
      <D.22516>:
      D.23925 = rs[i];
      if (D.23925 == 2) goto <D.23960>; else goto <D.23961>;
      <D.23960>:
      D.23887 = 2;
      return D.23887;
      <D.23961>:
      i = i + 1;
      <D.22517>:
      if (i < num_sregs) goto <D.22516>; else goto <D.22518>;
      <D.22518>:
      D.23887 = 0;
      return D.23887;
    }
  finally
    {
      args = {CLOBBER};
      rs = {CLOBBER};
      sregs = {CLOBBER};
    }
}


change_varstate (struct MonoCompile * cfg, struct GList * * cvars, struct MonoMethodVar * info, int state, struct MonoInst * c0, struct MonoInst * * carray)
{
  char D.23964;
  int D.23965;
  char D.23968;
  unsigned int D.23969;
  _Bool D.23970;
  long int D.23971;
  long int D.23972;
  struct MonoInst * * D.23975;
  unsigned int D.23976;
  long unsigned int D.23977;
  long unsigned int D.23978;
  struct MonoInst * * D.23979;
  struct MonoInst * D.23980;
  int D.23981;
  _Bool D.23984;
  long int D.23985;
  long int D.23986;
  long unsigned int D.23989;
  long unsigned int D.23990;
  struct MonoInst * * D.23991;
  struct GList * D.23992;
  struct GList * D.23993;
  struct GList * D.23996;

  D.23964 = info->cpstate;
  D.23965 = (int) D.23964;
  if (D.23965 >= state) goto <D.23966>; else goto <D.23967>;
  <D.23966>:
  return;
  <D.23967>:
  D.23968 = (char) state;
  info->cpstate = D.23968;
  D.23969 = cfg->verbose_level;
  D.23970 = D.23969 > 1;
  D.23971 = (long int) D.23970;
  D.23972 = __builtin_expect (D.23971, 0);
  if (D.23972 != 0) goto <D.23973>; else goto <D.23974>;
  <D.23973>:
  D.23964 = info->cpstate;
  D.23965 = (int) D.23964;
  D.23975 = cfg->varinfo;
  D.23976 = info->idx;
  D.23977 = (long unsigned int) D.23976;
  D.23978 = D.23977 * 8;
  D.23979 = D.23975 + D.23978;
  D.23980 = *D.23979;
  D.23981 = D.23980->dreg;
  printf ("\tState of R%d set to %d\n", D.23981, D.23965);
  <D.23974>:
  if (state == 1) goto <D.23982>; else goto <D.23983>;
  <D.23982>:
  D.23984 = c0 == 0B;
  D.23985 = (long int) D.23984;
  D.23986 = __builtin_expect (D.23985, 0);
  if (D.23986 != 0) goto <D.23987>; else goto <D.23988>;
  <D.23987>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 817, "c0");
  <D.23988>:
  <D.23983>:
  D.23975 = cfg->varinfo;
  D.23976 = info->idx;
  D.23977 = (long unsigned int) D.23976;
  D.23978 = D.23977 * 8;
  D.23979 = D.23975 + D.23978;
  D.23980 = *D.23979;
  D.23981 = D.23980->dreg;
  D.23989 = (long unsigned int) D.23981;
  D.23990 = D.23989 * 8;
  D.23991 = carray + D.23990;
  *D.23991 = c0;
  D.23992 = *cvars;
  D.23993 = monoeg_g_list_find (D.23992, info);
  if (D.23993 == 0B) goto <D.23994>; else goto <D.23995>;
  <D.23994>:
  D.23992 = *cvars;
  D.23996 = monoeg_g_list_prepend (D.23992, info);
  *cvars = D.23996;
  <D.23995>:
}


fold_ins (struct MonoCompile * cfg, struct MonoBasicBlock * bb, struct MonoInst * ins, struct MonoInst * * carray)
{
  short unsigned int D.23998;
  int D.23999;
  int D.24000;
  int D.24001;
  signed char D.24002;
  int D.24006;
  short unsigned int D.24008;
  long unsigned int D.24012;
  long unsigned int D.24013;
  struct MonoInst * * D.24014;
  struct MonoInst * D.24015;
  char D.24017;
  short unsigned int D.24020;
  _Bool D.24021;
  long int D.24022;
  long int D.24023;
  long int D.24026;
  int D.24027;
  int D.24028;
  long unsigned int D.24031;
  long unsigned int D.24032;
  struct MonoInst * * D.24033;
  struct MonoInst * D.24034;
  short unsigned int D.24039;
  long int D.24040;
  _Bool D.24043;
  _Bool D.24044;
  _Bool D.24045;
  _Bool D.24047;
  _Bool D.24048;
  _Bool D.24049;
  long int D.24050;
  const void * D.24051;
  struct MonoInst * D.24058;
  struct MonoInst * D.24061;
  struct MonoJumpInfoBBTable * iftmp.38;
  struct MonoJumpInfoBBTable * iftmp.39;
  struct MonoJumpInfoBBTable * iftmp.40;
  struct MonoJumpInfoBBTable * iftmp.41;
  struct MonoInst * D.24082;
  short unsigned int D.24084;
  _Bool D.24085;
  long int D.24086;
  long int D.24087;
  int D.24090;
  _Bool D.24091;
  long int D.24092;
  long int D.24093;
  struct MonoInst * D.24096;
  short unsigned int D.24097;
  _Bool D.24098;
  long int D.24099;
  long int D.24100;
  int D.24103;
  long unsigned int D.24104;
  long unsigned int D.24105;
  struct MonoInst * * D.24106;
  struct MonoInst * D.24107;
  long int D.24110;
  long int D.24111;
  int D.24115;
  struct MonoBasicBlock * * D.24116;
  long unsigned int D.24117;
  long unsigned int D.24118;
  struct MonoBasicBlock * * D.24119;
  struct MonoBasicBlock * D.24120;
  int D.24121;
  int D.24122;
  int D.24123;
  struct MonoInst * D.24124;
  int D.24127;
  int D.24128;
  short unsigned int D.24132;
  unsigned int D.24133;
  _Bool D.24134;
  long int D.24135;
  long int D.24136;
  long unsigned int D.24141;
  long unsigned int D.24142;
  struct MonoBasicBlock * * D.24143;
  struct MonoBasicBlock * D.24144;
  short unsigned int D.24149;
  short unsigned int D.24150;
  _Bool D.24151;
  short unsigned int D.24152;
  _Bool D.24153;
  _Bool D.24154;
  short unsigned int D.24156;
  unsigned char D.24157;
  int D.24158;
  int D.24159;
  struct MonoBasicBlock * * D.24162;
  struct MonoBasicBlock * * D.24163;
  struct MonoBasicBlock * D.24164;
  struct MonoBasicBlock * D.24165;
  int D.24167;
  struct MonoBasicBlock * D.24170;
  const char * spec;
  int opcode2;
  int num_sregs;

  D.23998 = ins->opcode;
  D.23999 = (int) D.23998;
  D.24000 = D.23999 + -313;
  D.24001 = D.24000 * 4;
  spec = &ins_info[D.24001];
  D.23998 = ins->opcode;
  D.23999 = (int) D.23998;
  D.24000 = D.23999 + -313;
  D.24002 = ins_sreg_counts[D.24000];
  num_sregs = (int) D.24002;
  D.23998 = ins->opcode;
  if (D.23998 != 316) goto <D.24005>; else goto <D.24003>;
  <D.24005>:
  D.24006 = ins->dreg;
  if (D.24006 != -1) goto <D.24007>; else goto <D.24003>;
  <D.24007>:
  D.23998 = ins->opcode;
  D.24008 = D.23998 + 65162;
  if (D.24008 > 16) goto <D.24009>; else goto <D.24003>;
  <D.24009>:
  D.24006 = ins->dreg;
  D.24012 = (long unsigned int) D.24006;
  D.24013 = D.24012 * 8;
  D.24014 = carray + D.24013;
  D.24015 = *D.24014;
  if (D.24015 != 0B) goto <D.24016>; else goto <D.24010>;
  <D.24016>:
  D.24017 = *spec;
  if (D.24017 == 105) goto <D.24018>; else goto <D.24010>;
  <D.24018>:
  D.24006 = ins->dreg;
  if (D.24006 > 15) goto <D.24019>; else goto <D.24010>;
  <D.24019>:
  D.24006 = ins->dreg;
  D.24012 = (long unsigned int) D.24006;
  D.24013 = D.24012 * 8;
  D.24014 = carray + D.24013;
  D.24015 = *D.24014;
  D.24020 = D.24015->opcode;
  D.24021 = D.24020 != 362;
  D.24022 = (long int) D.24021;
  D.24023 = __builtin_expect (D.24022, 0);
  if (D.24023 != 0) goto <D.24024>; else goto <D.24025>;
  <D.24024>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 1035, "carray [ins->dreg]->opcode == OP_ICONST");
  <D.24025>:
  ins->opcode = 362;
  D.24006 = ins->dreg;
  D.24012 = (long unsigned int) D.24006;
  D.24013 = D.24012 * 8;
  D.24014 = carray + D.24013;
  D.24015 = *D.24014;
  D.24026 = D.24015->data.op[0].const_val;
  ins->data.op[0].const_val = D.24026;
  ins->sreg3 = -1;
  D.24027 = ins->sreg3;
  ins->sreg2 = D.24027;
  D.24028 = ins->sreg2;
  ins->sreg1 = D.24028;
  goto <D.24011>;
  <D.24010>:
  if (num_sregs == 2) goto <D.24029>; else goto <D.24030>;
  <D.24029>:
  D.24028 = ins->sreg2;
  D.24031 = (long unsigned int) D.24028;
  D.24032 = D.24031 * 8;
  D.24033 = carray + D.24032;
  D.24034 = *D.24033;
  if (D.24034 != 0B) goto <D.24035>; else goto <D.24036>;
  <D.24035>:
  D.23998 = ins->opcode;
  D.23999 = (int) D.23998;
  opcode2 = mono_op_to_op_imm (D.23999);
  if (opcode2 != -1) goto <D.24037>; else goto <D.24038>;
  <D.24037>:
  D.24039 = (short unsigned int) opcode2;
  ins->opcode = D.24039;
  D.24028 = ins->sreg2;
  D.24031 = (long unsigned int) D.24028;
  D.24032 = D.24031 * 8;
  D.24033 = carray + D.24032;
  D.24034 = *D.24033;
  D.24040 = D.24034->data.op[0].const_val;
  ins->data.op[1].const_val = D.24040;
  ins->sreg2 = -1;
  D.24043 = opcode2 == 343;
  D.24044 = opcode2 == 346;
  D.24045 = D.24043 | D.24044;
  if (D.24045 != 0) goto <D.24041>; else goto <D.24046>;
  <D.24046>:
  D.24047 = opcode2 == 352;
  D.24048 = opcode2 == 349;
  D.24049 = D.24047 | D.24048;
  if (D.24049 != 0) goto <D.24041>; else goto <D.24042>;
  <D.24041>:
  D.24050 = ins->data.op[1].const_val;
  D.24051 = (const void *) D.24050;
  MEM[(struct MonoCallInst *)ins].fptr = D.24051;
  <D.24042>:
  <D.24038>:
  goto <D.24052>;
  <D.24036>:
  <D.24052>:
  <D.24030>:
  <D.24011>:
  D.23998 = ins->opcode;
  if (D.23998 == 735) goto <D.24053>; else goto <D.24056>;
  <D.24056>:
  D.23998 = ins->opcode;
  if (D.23998 == 736) goto <D.24057>; else goto <D.24054>;
  <D.24057>:
  D.24058 = ins->data.op[1].src;
  if (D.24058 == 8B) goto <D.24053>; else goto <D.24054>;
  <D.24054>:
  D.23998 = ins->opcode;
  if (D.23998 == 370) goto <D.24053>; else goto <D.24059>;
  <D.24059>:
  D.23998 = ins->opcode;
  if (D.23998 == 738) goto <D.24060>; else goto <D.24055>;
  <D.24060>:
  D.24058 = ins->data.op[1].src;
  D.24061 = D.24058->data.op[1].src;
  if (D.24061 == 8B) goto <D.24053>; else goto <D.24055>;
  <D.24053>:
  {
    int i;
    struct MonoJumpInfoBBTable * table;

    D.23998 = ins->opcode;
    if (D.23998 == 735) goto <D.24063>; else goto <D.24064>;
    <D.24063>:
    iftmp.38 = ins->data.op[0].p;
    goto <D.24065>;
    <D.24064>:
    D.23998 = ins->opcode;
    if (D.23998 == 736) goto <D.24069>; else goto <D.24067>;
    <D.24069>:
    D.24058 = ins->data.op[1].src;
    if (D.24058 == 8B) goto <D.24070>; else goto <D.24067>;
    <D.24070>:
    iftmp.39 = ins->data.op[0].p;
    goto <D.24068>;
    <D.24067>:
    D.23998 = ins->opcode;
    if (D.23998 == 370) goto <D.24072>; else goto <D.24073>;
    <D.24072>:
    iftmp.40 = ins->data.op[0].p;
    goto <D.24074>;
    <D.24073>:
    D.23998 = ins->opcode;
    if (D.23998 == 738) goto <D.24078>; else goto <D.24076>;
    <D.24078>:
    D.24058 = ins->data.op[1].src;
    D.24061 = D.24058->data.op[1].src;
    if (D.24061 == 8B) goto <D.24079>; else goto <D.24076>;
    <D.24079>:
    D.24058 = ins->data.op[1].src;
    iftmp.41 = D.24058->data.op[0].p;
    goto <D.24077>;
    <D.24076>:
    iftmp.41 = 0B;
    <D.24077>:
    iftmp.40 = iftmp.41;
    <D.24074>:
    iftmp.39 = iftmp.40;
    <D.24068>:
    iftmp.38 = iftmp.39;
    <D.24065>:
    table = iftmp.38;
    D.24082 = ins->next;
    if (D.24082 == 0B) goto <D.24080>; else goto <D.24083>;
    <D.24083>:
    D.24082 = ins->next;
    D.24084 = D.24082->opcode;
    if (D.24084 != 483) goto <D.24080>; else goto <D.24081>;
    <D.24080>:
    return;
    <D.24081>:
    D.24082 = ins->next;
    D.24084 = D.24082->opcode;
    D.24085 = D.24084 != 483;
    D.24086 = (long int) D.24085;
    D.24087 = __builtin_expect (D.24086, 0);
    if (D.24087 != 0) goto <D.24088>; else goto <D.24089>;
    <D.24088>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 1064, "ins->next->opcode == OP_PADD");
    <D.24089>:
    D.24082 = ins->next;
    D.24090 = D.24082->sreg1;
    D.24006 = ins->dreg;
    D.24091 = D.24090 != D.24006;
    D.24092 = (long int) D.24091;
    D.24093 = __builtin_expect (D.24092, 0);
    if (D.24093 != 0) goto <D.24094>; else goto <D.24095>;
    <D.24094>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 1065, "ins->next->sreg1 == ins->dreg");
    <D.24095>:
    D.24082 = ins->next;
    D.24096 = D.24082->next;
    D.24097 = D.24096->opcode;
    D.24098 = D.24097 != 391;
    D.24099 = (long int) D.24098;
    D.24100 = __builtin_expect (D.24099, 0);
    if (D.24100 != 0) goto <D.24101>; else goto <D.24102>;
    <D.24101>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 1066, "ins->next->next->opcode == OP_LOAD_MEMBASE");
    <D.24102>:
    D.24082 = ins->next;
    D.24103 = D.24082->sreg2;
    D.24104 = (long unsigned int) D.24103;
    D.24105 = D.24104 * 8;
    D.24106 = carray + D.24105;
    D.24107 = *D.24106;
    if (D.24107 != 0B) goto <D.24108>; else goto <D.24109>;
    <D.24108>:
    {
      int idx;

      D.24082 = ins->next;
      D.24103 = D.24082->sreg2;
      D.24104 = (long unsigned int) D.24103;
      D.24105 = D.24104 * 8;
      D.24106 = carray + D.24105;
      D.24107 = *D.24106;
      D.24110 = D.24107->data.op[0].const_val;
      D.24111 = D.24110 >> 3;
      idx = (int) D.24111;
      if (idx < 0) goto <D.24112>; else goto <D.24114>;
      <D.24114>:
      D.24115 = table->table_size;
      if (D.24115 <= idx) goto <D.24112>; else goto <D.24113>;
      <D.24112>:
      i = 0;
      goto <D.22582>;
      <D.22581>:
      D.24116 = table->table;
      D.24117 = (long unsigned int) i;
      D.24118 = D.24117 * 8;
      D.24119 = D.24116 + D.24118;
      D.24120 = *D.24119;
      remove_bb_from_phis (cfg, bb, D.24120);
      D.24116 = table->table;
      D.24117 = (long unsigned int) i;
      D.24118 = D.24117 * 8;
      D.24119 = D.24116 + D.24118;
      D.24120 = *D.24119;
      mono_unlink_bblock (cfg, bb, D.24120);
      i = i + 1;
      <D.22582>:
      D.24115 = table->table_size;
      if (D.24115 > i) goto <D.22581>; else goto <D.22583>;
      <D.22583>:
      ins->opcode = 316;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.24027 = ins->sreg3;
      ins->sreg2 = D.24027;
      D.24028 = ins->sreg2;
      ins->sreg1 = D.24028;
      D.24082 = ins->next;
      D.24082->opcode = 316;
      D.24082 = ins->next;
      D.24082->dreg = -1;
      D.24082 = ins->next;
      D.24082 = ins->next;
      D.24082 = ins->next;
      D.24082->sreg3 = -1;
      D.24121 = D.24082->sreg3;
      D.24082->sreg2 = D.24121;
      D.24103 = D.24082->sreg2;
      D.24082->sreg1 = D.24103;
      D.24082 = ins->next;
      D.24096 = D.24082->next;
      D.24096->opcode = 316;
      D.24082 = ins->next;
      D.24096 = D.24082->next;
      D.24096->dreg = -1;
      D.24082 = ins->next;
      D.24096 = D.24082->next;
      D.24082 = ins->next;
      D.24096 = D.24082->next;
      D.24082 = ins->next;
      D.24096 = D.24082->next;
      D.24096->sreg3 = -1;
      D.24122 = D.24096->sreg3;
      D.24096->sreg2 = D.24122;
      D.24123 = D.24096->sreg2;
      D.24096->sreg1 = D.24123;
      D.24082 = ins->next;
      D.24096 = D.24082->next;
      D.24124 = D.24096->next;
      if (D.24124 != 0B) goto <D.24125>; else goto <D.24126>;
      <D.24125>:
      D.24082 = ins->next;
      D.24096 = D.24082->next;
      D.24124 = D.24096->next;
      D.24124->opcode = 316;
      D.24082 = ins->next;
      D.24096 = D.24082->next;
      D.24124 = D.24096->next;
      D.24124->dreg = -1;
      D.24082 = ins->next;
      D.24096 = D.24082->next;
      D.24124 = D.24096->next;
      D.24082 = ins->next;
      D.24096 = D.24082->next;
      D.24124 = D.24096->next;
      D.24082 = ins->next;
      D.24096 = D.24082->next;
      D.24124 = D.24096->next;
      D.24124->sreg3 = -1;
      D.24127 = D.24124->sreg3;
      D.24124->sreg2 = D.24127;
      D.24128 = D.24124->sreg2;
      D.24124->sreg1 = D.24128;
      <D.24126>:
      return;
      <D.24113>:
      D.24082 = ins->next;
      D.24096 = D.24082->next;
      D.24124 = D.24096->next;
      if (D.24124 == 0B) goto <D.24129>; else goto <D.24131>;
      <D.24131>:
      D.24082 = ins->next;
      D.24096 = D.24082->next;
      D.24124 = D.24096->next;
      D.24132 = D.24124->opcode;
      if (D.24132 != 763) goto <D.24129>; else goto <D.24130>;
      <D.24129>:
      D.24133 = cfg->verbose_level;
      D.24134 = D.24133 > 1;
      D.24135 = (long int) D.24134;
      D.24136 = __builtin_expect (D.24135, 0);
      if (D.24136 != 0) goto <D.24137>; else goto <D.24138>;
      <D.24137>:
      printf ("\tNo cfold on ");
      mono_print_ins (ins);
      <D.24138>:
      return;
      <D.24130>:
      D.24133 = cfg->verbose_level;
      D.24134 = D.24133 > 1;
      D.24135 = (long int) D.24134;
      D.24136 = __builtin_expect (D.24135, 0);
      if (D.24136 != 0) goto <D.24139>; else goto <D.24140>;
      <D.24139>:
      printf ("\tcfold on ");
      mono_print_ins (ins);
      <D.24140>:
      i = 0;
      goto <D.22585>;
      <D.22584>:
      D.24116 = table->table;
      D.24117 = (long unsigned int) i;
      D.24118 = D.24117 * 8;
      D.24119 = D.24116 + D.24118;
      D.24120 = *D.24119;
      D.24116 = table->table;
      D.24141 = (long unsigned int) idx;
      D.24142 = D.24141 * 8;
      D.24143 = D.24116 + D.24142;
      D.24144 = *D.24143;
      if (D.24120 != D.24144) goto <D.24145>; else goto <D.24146>;
      <D.24145>:
      D.24116 = table->table;
      D.24117 = (long unsigned int) i;
      D.24118 = D.24117 * 8;
      D.24119 = D.24116 + D.24118;
      D.24120 = *D.24119;
      remove_bb_from_phis (cfg, bb, D.24120);
      D.24116 = table->table;
      D.24117 = (long unsigned int) i;
      D.24118 = D.24117 * 8;
      D.24119 = D.24116 + D.24118;
      D.24120 = *D.24119;
      mono_unlink_bblock (cfg, bb, D.24120);
      <D.24146>:
      i = i + 1;
      <D.22585>:
      D.24115 = table->table_size;
      if (D.24115 > i) goto <D.22584>; else goto <D.22586>;
      <D.22586>:
      D.24082 = ins->next;
      D.24096 = D.24082->next;
      D.24124 = D.24096->next;
      D.24124->opcode = 446;
      D.24082 = ins->next;
      D.24096 = D.24082->next;
      D.24124 = D.24096->next;
      D.24116 = table->table;
      D.24141 = (long unsigned int) idx;
      D.24142 = D.24141 * 8;
      D.24143 = D.24116 + D.24142;
      D.24144 = *D.24143;
      D.24124->data.op[0].target_block = D.24144;
      D.24082 = ins->next;
      D.24096 = D.24082->next;
      D.24124 = D.24096->next;
      D.24124->sreg1 = -1;
      ins->opcode = 316;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.24027 = ins->sreg3;
      ins->sreg2 = D.24027;
      D.24028 = ins->sreg2;
      ins->sreg1 = D.24028;
      D.24082 = ins->next;
      D.24082->opcode = 316;
      D.24082 = ins->next;
      D.24082->dreg = -1;
      D.24082 = ins->next;
      D.24082 = ins->next;
      D.24082 = ins->next;
      D.24082->sreg3 = -1;
      D.24121 = D.24082->sreg3;
      D.24082->sreg2 = D.24121;
      D.24103 = D.24082->sreg2;
      D.24082->sreg1 = D.24103;
      D.24082 = ins->next;
      D.24096 = D.24082->next;
      D.24096->opcode = 316;
      D.24082 = ins->next;
      D.24096 = D.24082->next;
      D.24096->dreg = -1;
      D.24082 = ins->next;
      D.24096 = D.24082->next;
      D.24082 = ins->next;
      D.24096 = D.24082->next;
      D.24082 = ins->next;
      D.24096 = D.24082->next;
      D.24096->sreg3 = -1;
      D.24122 = D.24096->sreg3;
      D.24096->sreg2 = D.24122;
      D.24123 = D.24096->sreg2;
      D.24096->sreg1 = D.24123;
    }
    <D.24109>:
  }
  <D.24055>:
  goto <D.24004>;
  <D.24003>:
  D.24149 = ins->opcode;
  D.24150 = D.24149 + 64981;
  D.24151 = D.24150 <= 9;
  D.24152 = D.24149 + 64874;
  D.24153 = D.24152 <= 9;
  D.24154 = D.24151 | D.24153;
  if (D.24154 != 0) goto <D.24147>; else goto <D.24155>;
  <D.24155>:
  D.23998 = ins->opcode;
  D.24156 = D.23998 + 64884;
  if (D.24156 <= 9) goto <D.24147>; else goto <D.24148>;
  <D.24147>:
  D.24157 = ins->flags;
  D.24158 = (int) D.24157;
  D.24159 = D.24158 & 8;
  if (D.24159 != 0) goto <D.24160>; else goto <D.24161>;
  <D.24160>:
  D.24162 = ins->data.op[1].many_blocks;
  D.24163 = D.24162 + 8;
  D.24164 = *D.24163;
  remove_bb_from_phis (cfg, bb, D.24164);
  D.24162 = ins->data.op[1].many_blocks;
  D.24163 = D.24162 + 8;
  D.24164 = *D.24163;
  mono_unlink_bblock (cfg, bb, D.24164);
  ins->opcode = 446;
  D.24162 = ins->data.op[1].many_blocks;
  D.24165 = *D.24162;
  ins->data.op[0].target_block = D.24165;
  goto <D.24166>;
  <D.24161>:
  D.24157 = ins->flags;
  D.24158 = (int) D.24157;
  D.24167 = D.24158 & 16;
  if (D.24167 != 0) goto <D.24168>; else goto <D.24169>;
  <D.24168>:
  D.24162 = ins->data.op[1].many_blocks;
  D.24165 = *D.24162;
  remove_bb_from_phis (cfg, bb, D.24165);
  D.24162 = ins->data.op[1].many_blocks;
  D.24165 = *D.24162;
  mono_unlink_bblock (cfg, bb, D.24165);
  ins->opcode = 446;
  D.24162 = ins->data.op[1].many_blocks;
  D.24170 = MEM[(struct MonoBasicBlock * *)D.24162 + 8B];
  ins->data.op[0].target_block = D.24170;
  <D.24169>:
  <D.24166>:
  <D.24148>:
  <D.24004>:
}


remove_bb_from_phis (struct MonoCompile * cfg, struct MonoBasicBlock * bb, struct MonoBasicBlock * target)
{
  struct MonoBasicBlock * * D.24172;
  long unsigned int D.24173;
  long unsigned int D.24174;
  struct MonoBasicBlock * * D.24175;
  struct MonoBasicBlock * D.24176;
  short int D.24178;
  int D.24179;
  _Bool D.24180;
  long int D.24181;
  long int D.24182;
  short unsigned int D.24185;
  short unsigned int D.24186;
  _Bool D.24187;
  _Bool D.24188;
  _Bool D.24189;
  int * D.24191;
  sizetype D.24192;
  sizetype D.24193;
  sizetype D.24194;
  int * D.24195;
  sizetype D.24196;
  sizetype D.24197;
  int * D.24198;
  int D.24199;
  int D.24200;
  int D.24201;
  struct MonoInst * ins;
  int i;
  int j;

  i = 0;
  goto <D.22260>;
  <D.22259>:
  D.24172 = target->in_bb;
  D.24173 = (long unsigned int) i;
  D.24174 = D.24173 * 8;
  D.24175 = D.24172 + D.24174;
  D.24176 = *D.24175;
  if (D.24176 == bb) goto <D.22258>; else goto <D.24177>;
  <D.24177>:
  i = i + 1;
  <D.22260>:
  D.24178 = target->in_count;
  D.24179 = (int) D.24178;
  if (D.24179 > i) goto <D.22259>; else goto <D.22258>;
  <D.22258>:
  D.24178 = target->in_count;
  D.24179 = (int) D.24178;
  D.24180 = D.24179 <= i;
  D.24181 = (long int) D.24180;
  D.24182 = __builtin_expect (D.24181, 0);
  if (D.24182 != 0) goto <D.24183>; else goto <D.24184>;
  <D.24183>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 111, "i < target->in_count");
  <D.24184>:
  ins = target->code;
  goto <D.22266>;
  <D.22265>:
  D.24185 = ins->opcode;
  D.24186 = D.24185 + 65217;
  D.24187 = D.24186 <= 2;
  D.24188 = D.24185 == 964;
  D.24189 = D.24187 | D.24188;
  if (D.24189 != 0) goto <D.24190>; else goto <D.22264>;
  <D.24190>:
  j = i;
  goto <D.22262>;
  <D.22261>:
  D.24191 = ins->data.op[1].phi_args;
  D.24192 = (sizetype) j;
  D.24193 = D.24192 + 1;
  D.24194 = D.24193 * 4;
  D.24195 = D.24191 + D.24194;
  D.24191 = ins->data.op[1].phi_args;
  D.24192 = (sizetype) j;
  D.24196 = D.24192 + 2;
  D.24197 = D.24196 * 4;
  D.24198 = D.24191 + D.24197;
  D.24199 = *D.24198;
  *D.24195 = D.24199;
  j = j + 1;
  <D.22262>:
  D.24191 = ins->data.op[1].phi_args;
  D.24200 = *D.24191;
  D.24201 = D.24200 + -1;
  if (D.24201 > j) goto <D.22261>; else goto <D.22263>;
  <D.22263>:
  D.24191 = ins->data.op[1].phi_args;
  D.24200 = *D.24191;
  D.24201 = D.24200 + -1;
  *D.24191 = D.24201;
  ins = ins->next;
  <D.22266>:
  if (ins != 0B) goto <D.22265>; else goto <D.22264>;
  <D.22264>:
}


mono_ssa_deadce (struct MonoCompile * cfg)
{
  unsigned int D.24202;
  unsigned int D.24203;
  _Bool D.24204;
  long int D.24205;
  long int D.24206;
  unsigned int D.24209;
  struct MonoMethodVar * D.24212;
  long unsigned int D.24213;
  long unsigned int D.24214;
  struct GList * work_list.42;
  struct MonoMemPool * D.24216;
  struct GList * work_list.43;
  unsigned int i.44;
  unsigned int D.24219;
  struct GList * work_list.45;
  struct MonoInst * D.24223;
  struct GList * D.24226;
  struct GList * D.24228;
  void * D.24230;
  struct MonoInst * D.24231;
  short unsigned int D.24235;
  _Bool D.24236;
  _Bool D.24237;
  _Bool D.24238;
  short unsigned int D.24240;
  struct MonoInst * iftmp.46;
  int D.24244;
  unsigned int D.24245;
  unsigned int D.24246;
  struct MonoInst * * D.24249;
  long unsigned int D.24250;
  long unsigned int D.24251;
  struct MonoInst * * D.24252;
  unsigned char D.24256;
  int D.24257;
  int D.24258;
  long int D.24261;
  long unsigned int D.24262;
  long unsigned int D.24263;
  struct MonoMethodVar * D.24264;
  int D.24265;
  short unsigned int D.24269;
  short unsigned int D.24271;
  _Bool D.24272;
  _Bool D.24273;
  _Bool D.24274;
  short unsigned int D.24275;
  short unsigned int D.24276;
  _Bool D.24277;
  _Bool D.24278;
  _Bool D.24279;
  int * D.24282;
  struct MonoInst * iftmp.47;
  long unsigned int D.24284;
  long unsigned int D.24285;
  int * D.24286;
  int D.24287;
  unsigned int D.24288;
  long unsigned int D.24291;
  long unsigned int D.24292;
  struct MonoInst * * D.24293;
  long int D.24295;
  long unsigned int D.24296;
  long unsigned int D.24297;
  int i;
  struct GList * work_list;

  try
    {
      D.24202 = cfg->comp_done;
      D.24203 = D.24202 & 32;
      D.24204 = D.24203 == 0;
      D.24205 = (long int) D.24204;
      D.24206 = __builtin_expect (D.24205, 0);
      if (D.24206 != 0) goto <D.24207>; else goto <D.24208>;
      <D.24207>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 1259, "cfg->comp_done & MONO_COMP_SSA");
      <D.24208>:
      D.24202 = cfg->comp_done;
      D.24209 = D.24202 & 64;
      if (D.24209 == 0) goto <D.24210>; else goto <D.24211>;
      <D.24210>:
      mono_ssa_create_def_use (cfg);
      <D.24211>:
      mono_ssa_copyprop (cfg);
      work_list = 0B;
      i = 0;
      goto <D.22651>;
      <D.22650>:
      {
        struct MonoMethodVar * info;

        D.24212 = cfg->vars;
        D.24213 = (long unsigned int) i;
        D.24214 = D.24213 * 80;
        info = D.24212 + D.24214;
        work_list.42 = work_list;
        D.24216 = cfg->mempool;
        work_list.43 = g_list_prepend_mempool (D.24216, work_list.42, info);
        work_list = work_list.43;
      }
      i = i + 1;
      <D.22651>:
      i.44 = (unsigned int) i;
      D.24219 = cfg->num_varinfo;
      if (i.44 < D.24219) goto <D.22650>; else goto <D.22652>;
      <D.22652>:
      goto <D.22662>;
      <D.22661>:
      {
        struct MonoMethodVar * info;

        work_list.42 = work_list;
        info = work_list.42->data;
        work_list.42 = work_list;
        work_list.42 = work_list;
        work_list.45 = monoeg_g_list_remove_link (work_list.42, work_list.42);
        work_list = work_list.45;
        D.24223 = info->def;
        if (D.24223 != 0B) goto <D.24224>; else goto <D.24225>;
        <D.24224>:
        D.24226 = info->uses;
        if (D.24226 == 0B) goto <D.24221>; else goto <D.24227>;
        <D.24227>:
        D.24226 = info->uses;
        D.24228 = D.24226->next;
        if (D.24228 == 0B) goto <D.24229>; else goto <D.24222>;
        <D.24229>:
        D.24226 = info->uses;
        D.24230 = D.24226->data;
        D.24231 = MEM[(struct MonoVarUsageInfo *)D.24230].inst;
        D.24223 = info->def;
        if (D.24231 == D.24223) goto <D.24221>; else goto <D.24222>;
        <D.24221>:
        {
          struct MonoInst * def;

          def = info->def;
          D.24235 = def->opcode;
          D.24236 = D.24235 == 428;
          D.24237 = D.24235 == 430;
          D.24238 = D.24236 | D.24237;
          if (D.24238 != 0) goto <D.24232>; else goto <D.24239>;
          <D.24239>:
          D.24240 = def->opcode;
          if (D.24240 == 431) goto <D.24232>; else goto <D.24241>;
          <D.24241>:
          D.24240 = def->opcode;
          if (D.24240 == 962) goto <D.24232>; else goto <D.24233>;
          <D.24232>:
          if (1 != 0) goto <D.24242>; else goto <D.24233>;
          <D.24242>:
          {
            struct MonoInst * src_var;

            D.24244 = def->sreg1;
            D.24245 = (unsigned int) D.24244;
            D.24246 = cfg->vreg_to_inst_len;
            if (D.24245 < D.24246) goto <D.24247>; else goto <D.24248>;
            <D.24247>:
            D.24249 = cfg->vreg_to_inst;
            D.24244 = def->sreg1;
            D.24250 = (long unsigned int) D.24244;
            D.24251 = D.24250 * 8;
            D.24252 = D.24249 + D.24251;
            iftmp.46 = *D.24252;
            goto <D.24253>;
            <D.24248>:
            iftmp.46 = 0B;
            <D.24253>:
            src_var = iftmp.46;
            if (src_var != 0B) goto <D.24254>; else goto <D.24255>;
            <D.24254>:
            D.24256 = src_var->flags;
            D.24257 = (int) D.24256;
            D.24258 = D.24257 & 20;
            if (D.24258 == 0) goto <D.24259>; else goto <D.24260>;
            <D.24259>:
            D.24212 = cfg->vars;
            D.24261 = src_var->data.op[0].const_val;
            D.24262 = (long unsigned int) D.24261;
            D.24263 = D.24262 * 80;
            D.24264 = D.24212 + D.24263;
            add_to_dce_worklist (cfg, info, D.24264, &work_list);
            <D.24260>:
            <D.24255>:
            def->opcode = 316;
            def->sreg2 = -1;
            D.24265 = def->sreg2;
            def->sreg1 = D.24265;
            D.24244 = def->sreg1;
            def->dreg = D.24244;
            info->reg = -1;
          }
          goto <D.24234>;
          <D.24233>:
          D.24240 = def->opcode;
          D.24269 = D.24240 + 65174;
          if (D.24269 <= 1) goto <D.24266>; else goto <D.24270>;
          <D.24270>:
          D.24271 = def->opcode;
          D.24272 = D.24271 == 432;
          D.24273 = D.24271 == 963;
          D.24274 = D.24272 | D.24273;
          if (D.24274 != 0) goto <D.24266>; else goto <D.24267>;
          <D.24266>:
          def->opcode = 316;
          def->sreg2 = -1;
          D.24265 = def->sreg2;
          def->sreg1 = D.24265;
          D.24244 = def->sreg1;
          def->dreg = D.24244;
          info->reg = -1;
          goto <D.24268>;
          <D.24267>:
          D.24275 = def->opcode;
          D.24276 = D.24275 + 65217;
          D.24277 = D.24276 <= 2;
          D.24278 = D.24275 == 964;
          D.24279 = D.24277 | D.24278;
          if (D.24279 != 0) goto <D.24280>; else goto <D.24281>;
          <D.24280>:
          {
            int j;

            D.24282 = def->data.op[1].phi_args;
            j = *D.24282;
            goto <D.22659>;
            <D.22658>:
            {
              struct MonoMethodVar * u;

              D.24212 = cfg->vars;
              D.24282 = def->data.op[1].phi_args;
              D.24284 = (long unsigned int) j;
              D.24285 = D.24284 * 4;
              D.24286 = D.24282 + D.24285;
              D.24287 = *D.24286;
              D.24288 = (unsigned int) D.24287;
              D.24246 = cfg->vreg_to_inst_len;
              if (D.24288 < D.24246) goto <D.24289>; else goto <D.24290>;
              <D.24289>:
              D.24249 = cfg->vreg_to_inst;
              D.24282 = def->data.op[1].phi_args;
              D.24284 = (long unsigned int) j;
              D.24285 = D.24284 * 4;
              D.24286 = D.24282 + D.24285;
              D.24287 = *D.24286;
              D.24291 = (long unsigned int) D.24287;
              D.24292 = D.24291 * 8;
              D.24293 = D.24249 + D.24292;
              iftmp.47 = *D.24293;
              goto <D.24294>;
              <D.24290>:
              iftmp.47 = 0B;
              <D.24294>:
              D.24295 = iftmp.47->data.op[0].const_val;
              D.24296 = (long unsigned int) D.24295;
              D.24297 = D.24296 * 80;
              u = D.24212 + D.24297;
              add_to_dce_worklist (cfg, info, u, &work_list);
            }
            j = j + -1;
            <D.22659>:
            if (j > 0) goto <D.22658>; else goto <D.22660>;
            <D.22660>:
            def->opcode = 316;
            def->sreg2 = -1;
            D.24265 = def->sreg2;
            def->sreg1 = D.24265;
            D.24244 = def->sreg1;
            def->dreg = D.24244;
            info->reg = -1;
          }
          goto <D.24298>;
          <D.24281>:
          D.24240 = def->opcode;
          if (D.24240 == 316) goto <D.24299>; else goto <D.24300>;
          <D.24299>:
          <D.24300>:
          <D.24298>:
          <D.24268>:
          <D.24234>:
        }
        <D.24222>:
        <D.24225>:
      }
      <D.22662>:
      work_list.42 = work_list;
      if (work_list.42 != 0B) goto <D.22661>; else goto <D.22663>;
      <D.22663>:
    }
  finally
    {
      work_list = {CLOBBER};
    }
}


mono_ssa_copyprop (struct MonoCompile * cfg)
{
  unsigned int D.24301;
  unsigned int D.24302;
  _Bool D.24303;
  long int D.24304;
  long int D.24305;
  struct MonoInst * * D.24308;
  long unsigned int D.24309;
  long unsigned int D.24310;
  struct MonoInst * * D.24311;
  struct MonoMethodVar * D.24312;
  long unsigned int D.24313;
  struct MonoInst * D.24316;
  short unsigned int D.24319;
  _Bool D.24320;
  _Bool D.24321;
  _Bool D.24322;
  short unsigned int D.24324;
  struct MonoInst * iftmp.48;
  int D.24327;
  unsigned int D.24328;
  unsigned int D.24329;
  struct MonoInst * * D.24332;
  long unsigned int D.24333;
  long unsigned int D.24334;
  struct MonoInst * * D.24335;
  unsigned char D.24339;
  int D.24340;
  int D.24341;
  long int D.24344;
  long unsigned int D.24345;
  long unsigned int D.24346;
  struct MonoMethodVar * D.24347;
  struct MonoInst * D.24348;
  short unsigned int D.24351;
  short unsigned int D.24352;
  _Bool D.24353;
  _Bool D.24354;
  _Bool D.24355;
  int D.24358;
  int D.24359;
  int D.24360;
  short unsigned int D.24361;
  int D.24362;
  int D.24363;
  signed char D.24364;
  int D.24365;
  _Bool D.24369;
  long int D.24370;
  long int D.24371;
  short unsigned int D.24377;
  int D.24379;
  short unsigned int D.24381;
  short unsigned int D.24382;
  _Bool D.24383;
  _Bool D.24384;
  _Bool D.24385;
  int * D.24388;
  long unsigned int D.24389;
  long unsigned int D.24390;
  int * D.24391;
  int D.24392;
  _Bool D.24394;
  long int D.24395;
  long int D.24396;
  struct MonoBasicBlock * D.24400;
  unsigned int index.49;
  unsigned int D.24402;
  unsigned int D.24403;
  int i;
  int index;
  struct GList * l;

  D.24301 = cfg->comp_done;
  D.24302 = D.24301 & 64;
  D.24303 = D.24302 == 0;
  D.24304 = (long int) D.24303;
  D.24305 = __builtin_expect (D.24304, 0);
  if (D.24305 != 0) goto <D.24306>; else goto <D.24307>;
  <D.24306>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 674, "(cfg->comp_done & MONO_COMP_SSA_DEF_USE)");
  <D.24307>:
  index = 0;
  goto <D.22489>;
  <D.22488>:
  {
    struct MonoInst * var;
    struct MonoMethodVar * info;

    D.24308 = cfg->varinfo;
    D.24309 = (long unsigned int) index;
    D.24310 = D.24309 * 8;
    D.24311 = D.24308 + D.24310;
    var = *D.24311;
    D.24312 = cfg->vars;
    D.24309 = (long unsigned int) index;
    D.24313 = D.24309 * 80;
    info = D.24312 + D.24313;
    D.24316 = info->def;
    if (D.24316 != 0B) goto <D.24317>; else goto <D.24318>;
    <D.24317>:
    D.24316 = info->def;
    D.24319 = D.24316->opcode;
    D.24320 = D.24319 == 428;
    D.24321 = D.24319 == 430;
    D.24322 = D.24320 | D.24321;
    if (D.24322 != 0) goto <D.24314>; else goto <D.24323>;
    <D.24323>:
    D.24316 = info->def;
    D.24324 = D.24316->opcode;
    if (D.24324 == 431) goto <D.24314>; else goto <D.24325>;
    <D.24325>:
    D.24316 = info->def;
    D.24324 = D.24316->opcode;
    if (D.24324 == 962) goto <D.24314>; else goto <D.24315>;
    <D.24314>:
    {
      struct MonoInst * var2;

      D.24316 = info->def;
      D.24327 = D.24316->sreg1;
      D.24328 = (unsigned int) D.24327;
      D.24329 = cfg->vreg_to_inst_len;
      if (D.24328 < D.24329) goto <D.24330>; else goto <D.24331>;
      <D.24330>:
      D.24332 = cfg->vreg_to_inst;
      D.24316 = info->def;
      D.24327 = D.24316->sreg1;
      D.24333 = (long unsigned int) D.24327;
      D.24334 = D.24333 * 8;
      D.24335 = D.24332 + D.24334;
      iftmp.48 = *D.24335;
      goto <D.24336>;
      <D.24331>:
      iftmp.48 = 0B;
      <D.24336>:
      var2 = iftmp.48;
      if (var2 != 0B) goto <D.24337>; else goto <D.24338>;
      <D.24337>:
      D.24339 = var2->flags;
      D.24340 = (int) D.24339;
      D.24341 = D.24340 & 20;
      if (D.24341 == 0) goto <D.24342>; else goto <D.24343>;
      <D.24342>:
      D.24312 = cfg->vars;
      D.24344 = var2->data.op[0].const_val;
      D.24345 = (long unsigned int) D.24344;
      D.24346 = D.24345 * 80;
      D.24347 = D.24312 + D.24346;
      D.24348 = D.24347->def;
      if (D.24348 != 0B) goto <D.24349>; else goto <D.24350>;
      <D.24349>:
      D.24312 = cfg->vars;
      D.24344 = var2->data.op[0].const_val;
      D.24345 = (long unsigned int) D.24344;
      D.24346 = D.24345 * 80;
      D.24347 = D.24312 + D.24346;
      D.24348 = D.24347->def;
      D.24351 = D.24348->opcode;
      D.24352 = D.24351 + 65217;
      D.24353 = D.24352 > 2;
      D.24354 = D.24351 != 964;
      D.24355 = D.24353 & D.24354;
      if (D.24355 != 0) goto <D.24356>; else goto <D.24357>;
      <D.24356>:
      {
        int dreg;
        int sreg1;

        dreg = var->dreg;
        sreg1 = var2->dreg;
        l = info->uses;
        goto <D.22486>;
        <D.22485>:
        {
          struct MonoVarUsageInfo * u;
          struct MonoInst * ins;
          struct GList * next;
          int num_sregs;
          int sregs[3];

          try
            {
              u = l->data;
              ins = u->inst;
              next = l->next;
              D.24358 = ins->sreg1;
              sregs[0] = D.24358;
              D.24359 = ins->sreg2;
              sregs[1] = D.24359;
              D.24360 = ins->sreg3;
              sregs[2] = D.24360;
              D.24361 = ins->opcode;
              D.24362 = (int) D.24361;
              D.24363 = D.24362 + -313;
              D.24364 = ins_sreg_counts[D.24363];
              num_sregs = (int) D.24364;
              i = 0;
              goto <D.22480>;
              <D.22479>:
              D.24365 = sregs[i];
              if (D.24365 == dreg) goto <D.22478>; else goto <D.24366>;
              <D.24366>:
              i = i + 1;
              <D.22480>:
              if (i < num_sregs) goto <D.22479>; else goto <D.22478>;
              <D.22478>:
              if (i < num_sregs) goto <D.24367>; else goto <D.24368>;
              <D.24367>:
              D.24365 = sregs[i];
              D.24369 = D.24365 != dreg;
              D.24370 = (long int) D.24369;
              D.24371 = __builtin_expect (D.24370, 0);
              if (D.24371 != 0) goto <D.24372>; else goto <D.24373>;
              <D.24372>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 702, "sregs [i] == dreg");
              <D.24373>:
              sregs[i] = sreg1;
              mono_inst_set_src_registers (ins, &sregs);
              goto <D.24374>;
              <D.24368>:
              D.24361 = ins->opcode;
              D.24377 = D.24361 + 65162;
              if (D.24377 <= 16) goto <D.24378>; else goto <D.24375>;
              <D.24378>:
              D.24379 = ins->dreg;
              if (D.24379 == dreg) goto <D.24380>; else goto <D.24375>;
              <D.24380>:
              ins->dreg = sreg1;
              goto <D.24376>;
              <D.24375>:
              D.24381 = ins->opcode;
              D.24382 = D.24381 + 65217;
              D.24383 = D.24382 <= 2;
              D.24384 = D.24381 == 964;
              D.24385 = D.24383 | D.24384;
              if (D.24385 != 0) goto <D.24386>; else goto <D.24387>;
              <D.24386>:
              D.24388 = ins->data.op[1].phi_args;
              i = *D.24388;
              goto <D.22484>;
              <D.22483>:
              {
                int sreg;

                D.24388 = ins->data.op[1].phi_args;
                D.24389 = (long unsigned int) i;
                D.24390 = D.24389 * 4;
                D.24391 = D.24388 + D.24390;
                sreg = *D.24391;
                D.24392 = var->dreg;
                if (D.24392 == sreg) goto <D.22482>; else goto <D.24393>;
                <D.24393>:
              }
              i = i + -1;
              <D.22484>:
              if (i > 0) goto <D.22483>; else goto <D.22482>;
              <D.22482>:
              D.24394 = i <= 0;
              D.24395 = (long int) D.24394;
              D.24396 = __builtin_expect (D.24395, 0);
              if (D.24396 != 0) goto <D.24397>; else goto <D.24398>;
              <D.24397>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 713, "i > 0");
              <D.24398>:
              D.24388 = ins->data.op[1].phi_args;
              D.24389 = (long unsigned int) i;
              D.24390 = D.24389 * 4;
              D.24391 = D.24388 + D.24390;
              *D.24391 = sreg1;
              goto <D.24399>;
              <D.24387>:
              monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "ssa.c", 717);
              <D.24399>:
              <D.24376>:
              <D.24374>:
              D.24400 = u->bb;
              record_use (cfg, var2, D.24400, ins);
              l = next;
            }
          finally
            {
              sregs = {CLOBBER};
            }
        }
        <D.22486>:
        if (l != 0B) goto <D.22485>; else goto <D.22487>;
        <D.22487>:
        info->uses = 0B;
      }
      <D.24357>:
      <D.24350>:
      <D.24343>:
      <D.24338>:
    }
    <D.24315>:
    <D.24318>:
  }
  index = index + 1;
  <D.22489>:
  index.49 = (unsigned int) index;
  D.24402 = cfg->num_varinfo;
  if (index.49 < D.24402) goto <D.22488>; else goto <D.22490>;
  <D.22490>:
  D.24403 = cfg->verbose_level;
  if (D.24403 > 3) goto <D.24404>; else goto <D.24405>;
  <D.24404>:
  {
    struct MonoBasicBlock * bb;

    bb = cfg->bb_entry;
    goto <D.22493>;
    <D.22492>:
    mono_print_bb (bb, "AFTER SSA COPYPROP");
    bb = bb->next_bb;
    <D.22493>:
    if (bb != 0B) goto <D.22492>; else goto <D.22494>;
    <D.22494>:
  }
  <D.24405>:
}


add_to_dce_worklist (struct MonoCompile * cfg, struct MonoMethodVar * var, struct MonoMethodVar * use, struct GList * * wl)
{
  struct GList * D.24406;
  struct MonoMemPool * D.24407;
  struct GList * D.24408;
  struct MonoInst * D.24409;
  struct MonoInst * D.24410;
  struct GList * D.24413;
  struct GList * D.24414;
  struct GList * tmp;

  D.24406 = *wl;
  D.24407 = cfg->mempool;
  D.24408 = g_list_prepend_mempool (D.24407, D.24406, use);
  *wl = D.24408;
  tmp = use->uses;
  goto <D.22643>;
  <D.22642>:
  {
    struct MonoVarUsageInfo * ui;

    ui = tmp->data;
    D.24409 = ui->inst;
    D.24410 = var->def;
    if (D.24409 == D.24410) goto <D.24411>; else goto <D.24412>;
    <D.24411>:
    D.24413 = use->uses;
    D.24414 = monoeg_g_list_remove_link (D.24413, tmp);
    use->uses = D.24414;
    goto <D.22641>;
    <D.24412>:
  }
  tmp = tmp->next;
  <D.22643>:
  if (tmp != 0B) goto <D.22642>; else goto <D.22641>;
  <D.22641>:
}


mono_ssa_loop_invariant_code_motion (struct MonoCompile * cfg)
{
  unsigned int D.24415;
  unsigned int D.24416;
  _Bool D.24417;
  long int D.24418;
  long int D.24419;
  unsigned int D.24422;
  unsigned int D.24423;
  struct MonoBasicBlock * D.24426;
  struct MonoInst * iftmp.50;
  short unsigned int D.24435;
  unsigned char D.24438;
  unsigned char D.24439;
  <unnamed type> D.24442;
  short unsigned int D.24447;
  _Bool D.24448;
  _Bool D.24449;
  _Bool D.24450;
  struct MonoInst * D.24457;
  short unsigned int D.24459;
  struct MonoBasicBlock * D.24461;
  signed char D.24463;
  short unsigned int D.24465;
  _Bool D.24466;
  _Bool D.24467;
  _Bool D.24468;
  short unsigned int D.24471;
  short unsigned int D.24480;
  _Bool D.24481;
  _Bool D.24482;
  _Bool D.24483;
  short unsigned int D.24539;
  _Bool D.24540;
  _Bool D.24541;
  _Bool D.24542;
  short unsigned int D.24546;
  int D.24547;
  int D.24548;
  int D.24549;
  int D.24552;
  char D.24555;
  unsigned int D.24562;
  int D.24565;
  struct MonoInst * D.24566;
  struct MonoInst * D.24569;
  struct MonoInst * D.24572;
  struct MonoInst * D.24575;
  short unsigned int D.24578;
  _Bool D.24579;
  _Bool D.24580;
  _Bool D.24581;
  struct MonoInst * iftmp.51;
  unsigned int D.24588;
  struct MonoMethodVar * D.24589;
  long unsigned int D.24590;
  long unsigned int D.24591;
  unsigned int i.52;
  unsigned int D.24593;
  struct MonoBasicBlock * bb;
  struct MonoBasicBlock * h;
  struct MonoBasicBlock * idom;
  struct MonoInst * ins;
  struct MonoInst * n;
  struct MonoInst * tins;
  int i;

  D.24415 = cfg->comp_done;
  D.24416 = D.24415 & 32;
  D.24417 = D.24416 == 0;
  D.24418 = (long int) D.24417;
  D.24419 = __builtin_expect (D.24418, 0);
  if (D.24419 != 0) goto <D.24420>; else goto <D.24421>;
  <D.24420>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 1360, "cfg->comp_done & MONO_COMP_SSA");
  <D.24421>:
  D.24422 = BIT_FIELD_REF <*cfg, 32, 5408>;
  D.24423 = D.24422 & 320;
  if (D.24423 != 320) goto <D.24424>; else goto <D.24425>;
  <D.24424>:
  return;
  <D.24425>:
  D.24426 = cfg->bb_entry;
  bb = D.24426->next_bb;
  goto <D.22694>;
  <D.22693>:
  {
    struct GList * lp;

    lp = bb->loop_blocks;
    if (lp == 0B) goto <D.24427>; else goto <D.24428>;
    <D.24427>:
    // predicted unlikely by continue predictor.
    goto <D.22675>;
    <D.24428>:
    h = lp->data;
    if (bb != h) goto <D.24429>; else goto <D.24430>;
    <D.24429>:
    // predicted unlikely by continue predictor.
    goto <D.22675>;
    <D.24430>:
    ins = bb->code;
    if (ins != 0B) goto <D.24432>; else goto <D.24433>;
    <D.24432>:
    iftmp.50 = ins->next;
    goto <D.24434>;
    <D.24433>:
    iftmp.50 = 0B;
    <D.24434>:
    n = iftmp.50;
    goto <D.22691>;
    <D.22690>:
    {
      gboolean is_class_init;

      is_class_init = 0;
      D.24435 = ins->opcode;
      if (D.24435 == 343) goto <D.24436>; else goto <D.24437>;
      <D.24436>:
      {
        struct MonoCallInst * call;

        call = ins;
        D.24438 = BIT_FIELD_REF <*call, 8, 1088>;
        D.24439 = D.24438 & 4;
        if (D.24439 != 0) goto <D.24440>; else goto <D.24441>;
        <D.24440>:
        {
          struct MonoJumpInfo * ji;

          ji = call->fptr;
          D.24442 = ji->type;
          if (D.24442 == 15) goto <D.24443>; else goto <D.24444>;
          <D.24443>:
          is_class_init = 1;
          <D.24444>:
        }
        <D.24441>:
      }
      <D.24437>:
      D.24447 = ins->opcode;
      D.24448 = D.24447 == 787;
      D.24449 = D.24447 == 785;
      D.24450 = D.24448 | D.24449;
      if (D.24450 != 0) goto <D.24445>; else goto <D.24451>;
      <D.24451>:
      D.24435 = ins->opcode;
      if (D.24435 == 340) goto <D.24445>; else goto <D.24452>;
      <D.24452>:
      D.24435 = ins->opcode;
      if (D.24435 == 736) goto <D.24445>; else goto <D.24453>;
      <D.24453>:
      if (is_class_init != 0) goto <D.24445>; else goto <D.24446>;
      <D.24445>:
      {
        gboolean skip;
        int sreg;

        idom = h->idom;
        if (idom == 0B) goto <D.24454>; else goto <D.24456>;
        <D.24456>:
        D.24457 = idom->last_ins;
        if (D.24457 == 0B) goto <D.24454>; else goto <D.24458>;
        <D.24458>:
        D.24457 = idom->last_ins;
        D.24459 = D.24457->opcode;
        if (D.24459 != 446) goto <D.24454>; else goto <D.24460>;
        <D.24460>:
        D.24457 = idom->last_ins;
        D.24461 = D.24457->data.op[0].target_block;
        if (D.24461 != h) goto <D.24454>; else goto <D.24462>;
        <D.24462>:
        D.24463 = h->nesting;
        if (D.24463 != 1) goto <D.24454>; else goto <D.24455>;
        <D.24454>:
        // predicted unlikely by continue predictor.
        goto <D.22681>;
        <D.24455>:
        skip = 0;
        tins = bb->code;
        goto <D.22684>;
        <D.22683>:
        if (tins == ins) goto <D.22682>; else goto <D.24464>;
        <D.24464>:
        D.24465 = tins->opcode;
        D.24466 = D.24465 != 428;
        D.24467 = D.24465 != 430;
        D.24468 = D.24466 & D.24467;
        if (D.24468 != 0) goto <D.24469>; else goto <D.24470>;
        <D.24469>:
        D.24471 = tins->opcode;
        if (D.24471 != 431) goto <D.24472>; else goto <D.24473>;
        <D.24472>:
        D.24471 = tins->opcode;
        if (D.24471 != 962) goto <D.24474>; else goto <D.24475>;
        <D.24474>:
        D.24471 = tins->opcode;
        if (D.24471 != 362) goto <D.24476>; else goto <D.24477>;
        <D.24476>:
        D.24471 = tins->opcode;
        if (D.24471 != 363) goto <D.24478>; else goto <D.24479>;
        <D.24478>:
        D.24480 = tins->opcode;
        D.24481 = D.24480 != 432;
        D.24482 = D.24480 != 963;
        D.24483 = D.24481 & D.24482;
        if (D.24483 != 0) goto <D.24484>; else goto <D.24485>;
        <D.24484>:
        D.24471 = tins->opcode;
        if (D.24471 != 433) goto <D.24486>; else goto <D.24487>;
        <D.24486>:
        D.24471 = tins->opcode;
        if (D.24471 != 365) goto <D.24488>; else goto <D.24489>;
        <D.24488>:
        D.24471 = tins->opcode;
        if (D.24471 != 542) goto <D.24490>; else goto <D.24491>;
        <D.24490>:
        D.24471 = tins->opcode;
        if (D.24471 != 630) goto <D.24492>; else goto <D.24493>;
        <D.24492>:
        D.24471 = tins->opcode;
        if (D.24471 != 629) goto <D.24494>; else goto <D.24495>;
        <D.24494>:
        D.24471 = tins->opcode;
        if (D.24471 != 496) goto <D.24496>; else goto <D.24497>;
        <D.24496>:
        D.24471 = tins->opcode;
        if (D.24471 != 570) goto <D.24498>; else goto <D.24499>;
        <D.24498>:
        D.24471 = tins->opcode;
        if (D.24471 != 979) goto <D.24500>; else goto <D.24501>;
        <D.24500>:
        D.24471 = tins->opcode;
        if (D.24471 != 639) goto <D.24502>; else goto <D.24503>;
        <D.24502>:
        D.24471 = tins->opcode;
        if (D.24471 != 640) goto <D.24504>; else goto <D.24505>;
        <D.24504>:
        D.24471 = tins->opcode;
        if (D.24471 != 641) goto <D.24506>; else goto <D.24507>;
        <D.24506>:
        D.24471 = tins->opcode;
        if (D.24471 != 636) goto <D.24508>; else goto <D.24509>;
        <D.24508>:
        D.24471 = tins->opcode;
        if (D.24471 != 595) goto <D.24510>; else goto <D.24511>;
        <D.24510>:
        D.24471 = tins->opcode;
        if (D.24471 != 584) goto <D.24512>; else goto <D.24513>;
        <D.24512>:
        D.24471 = tins->opcode;
        if (D.24471 != 766) goto <D.24514>; else goto <D.24515>;
        <D.24514>:
        D.24471 = tins->opcode;
        if (D.24471 != 507) goto <D.24516>; else goto <D.24517>;
        <D.24516>:
        D.24471 = tins->opcode;
        if (D.24471 != 594) goto <D.24518>; else goto <D.24519>;
        <D.24518>:
        D.24471 = tins->opcode;
        if (D.24471 != 585) goto <D.24520>; else goto <D.24521>;
        <D.24520>:
        D.24471 = tins->opcode;
        if (D.24471 != 499) goto <D.24522>; else goto <D.24523>;
        <D.24522>:
        D.24471 = tins->opcode;
        if (D.24471 != 314) goto <D.24524>; else goto <D.24525>;
        <D.24524>:
        D.24471 = tins->opcode;
        if (D.24471 != 319) goto <D.24526>; else goto <D.24527>;
        <D.24526>:
        D.24471 = tins->opcode;
        if (D.24471 != 316) goto <D.24528>; else goto <D.24529>;
        <D.24528>:
        D.24471 = tins->opcode;
        if (D.24471 != 769) goto <D.24530>; else goto <D.24531>;
        <D.24530>:
        D.24471 = tins->opcode;
        if (D.24471 != 803) goto <D.24532>; else goto <D.24533>;
        <D.24532>:
        skip = 1;
        goto <D.22682>;
        <D.24533>:
        <D.24531>:
        <D.24529>:
        <D.24527>:
        <D.24525>:
        <D.24523>:
        <D.24521>:
        <D.24519>:
        <D.24517>:
        <D.24515>:
        <D.24513>:
        <D.24511>:
        <D.24509>:
        <D.24507>:
        <D.24505>:
        <D.24503>:
        <D.24501>:
        <D.24499>:
        <D.24497>:
        <D.24495>:
        <D.24493>:
        <D.24491>:
        <D.24489>:
        <D.24487>:
        <D.24485>:
        <D.24479>:
        <D.24477>:
        <D.24475>:
        <D.24473>:
        <D.24470>:
        tins = tins->next;
        <D.22684>:
        if (tins != 0B) goto <D.22683>; else goto <D.22682>;
        <D.22682>:
        if (skip != 0) goto <D.24534>; else goto <D.24535>;
        <D.24534>:
        // predicted unlikely by continue predictor.
        goto <D.22681>;
        <D.24535>:
        D.24539 = ins->opcode;
        D.24540 = D.24539 == 787;
        D.24541 = D.24539 == 785;
        D.24542 = D.24540 | D.24541;
        if (D.24542 != 0) goto <D.24536>; else goto <D.24543>;
        <D.24543>:
        D.24435 = ins->opcode;
        if (D.24435 == 340) goto <D.24536>; else goto <D.24537>;
        <D.24536>:
        sreg = ins->sreg1;
        goto <D.24538>;
        <D.24537>:
        sreg = -1;
        <D.24538>:
        if (sreg != -1) goto <D.24544>; else goto <D.24545>;
        <D.24544>:
        {
          struct MonoInst * tins;

          skip = 0;
          tins = ins->prev;
          goto <D.22689>;
          <D.22688>:
          {
            const char * spec;

            D.24546 = tins->opcode;
            D.24547 = (int) D.24546;
            D.24548 = D.24547 + -313;
            D.24549 = D.24548 * 4;
            spec = &ins_info[D.24549];
            D.24546 = tins->opcode;
            if (D.24546 == 428) goto <D.24550>; else goto <D.24551>;
            <D.24550>:
            D.24552 = tins->dreg;
            if (D.24552 == sreg) goto <D.24553>; else goto <D.24554>;
            <D.24553>:
            sreg = tins->sreg1;
            <D.24554>:
            <D.24551>:
            D.24555 = *spec;
            if (D.24555 != 32) goto <D.24556>; else goto <D.24557>;
            <D.24556>:
            D.24552 = tins->dreg;
            if (D.24552 == sreg) goto <D.24558>; else goto <D.24559>;
            <D.24558>:
            skip = 1;
            goto <D.22687>;
            <D.24559>:
            <D.24557>:
          }
          tins = tins->prev;
          <D.22689>:
          if (tins != 0B) goto <D.22688>; else goto <D.22687>;
          <D.22687>:
          if (skip != 0) goto <D.24560>; else goto <D.24561>;
          <D.24560>:
          // predicted unlikely by continue predictor.
          goto <D.22681>;
          <D.24561>:
          ins->sreg1 = sreg;
        }
        <D.24545>:
        D.24562 = cfg->verbose_level;
        if (D.24562 > 1) goto <D.24563>; else goto <D.24564>;
        <D.24563>:
        D.24565 = bb->block_num;
        printf ("licm in BB%d on ", D.24565);
        mono_print_ins (ins);
        <D.24564>:
        D.24566 = ins->prev;
        if (D.24566 != 0B) goto <D.24567>; else goto <D.24568>;
        <D.24567>:
        D.24566 = ins->prev;
        D.24569 = ins->next;
        D.24566->next = D.24569;
        <D.24568>:
        D.24569 = ins->next;
        if (D.24569 != 0B) goto <D.24570>; else goto <D.24571>;
        <D.24570>:
        D.24569 = ins->next;
        D.24566 = ins->prev;
        D.24569->prev = D.24566;
        <D.24571>:
        D.24572 = bb->code;
        if (D.24572 == ins) goto <D.24573>; else goto <D.24574>;
        <D.24573>:
        D.24569 = ins->next;
        bb->code = D.24569;
        <D.24574>:
        D.24575 = bb->last_ins;
        if (D.24575 == ins) goto <D.24576>; else goto <D.24577>;
        <D.24576>:
        D.24566 = ins->prev;
        bb->last_ins = D.24566;
        <D.24577>:
        D.24457 = idom->last_ins;
        mono_bblock_insert_before_ins (idom, D.24457, ins);
        D.24578 = ins->opcode;
        D.24579 = D.24578 == 787;
        D.24580 = D.24578 == 785;
        D.24581 = D.24579 | D.24580;
        if (D.24581 != 0) goto <D.24582>; else goto <D.24583>;
        <D.24582>:
        idom->has_array_access = 1;
        <D.24583>:
      }
      <D.24446>:
    }
    <D.22681>:
    ins = n;
    if (ins != 0B) goto <D.24585>; else goto <D.24586>;
    <D.24585>:
    iftmp.51 = ins->next;
    goto <D.24587>;
    <D.24586>:
    iftmp.51 = 0B;
    <D.24587>:
    n = iftmp.51;
    <D.22691>:
    if (ins != 0B) goto <D.22690>; else goto <D.22692>;
    <D.22692>:
  }
  <D.22675>:
  bb = bb->next_bb;
  <D.22694>:
  if (bb != 0B) goto <D.22693>; else goto <D.22695>;
  <D.22695>:
  D.24415 = cfg->comp_done;
  D.24588 = D.24415 & 4294967231;
  cfg->comp_done = D.24588;
  i = 0;
  goto <D.22698>;
  <D.22697>:
  {
    struct MonoMethodVar * info;

    D.24589 = cfg->vars;
    D.24590 = (long unsigned int) i;
    D.24591 = D.24590 * 80;
    info = D.24589 + D.24591;
    info->def = 0B;
    info->uses = 0B;
  }
  i = i + 1;
  <D.22698>:
  i.52 = (unsigned int) i;
  D.24593 = cfg->num_varinfo;
  if (i.52 < D.24593) goto <D.22697>; else goto <D.22699>;
  <D.22699>:
}