mono_ssa_compute (struct MonoCompile * cfg)
{
  unsigned int D.22791;
  long unsigned int D.22792;
  long unsigned int D.22793;
  unsigned int D.22794;
  unsigned int D.22795;
  _Bool D.22796;
  long int D.22797;
  long int D.22798;
  long unsigned int D.22801;
  long unsigned int D.22802;
  _Bool D.22803;
  long int D.22804;
  long int D.22805;
  unsigned int D.22808;
  unsigned int D.22811;
  unsigned int D.22812;
  unsigned int D.22815;
  unsigned int D.22816;
  unsigned int D.22817;
  unsigned int D.22818;
  long unsigned int D.22819;
  long unsigned int D.22820;
  long unsigned int D.22821;
  struct MonoMethodVar * D.22822;
  struct MonoBitSet * D.22823;
  sizetype D.22824;
  unsigned int i.0;
  struct MonoInst * * D.22826;
  long unsigned int D.22827;
  struct MonoInst * * D.22828;
  struct MonoInst * D.22829;
  short unsigned int D.22830;
  struct MonoBitSet * D.22833;
  long unsigned int D.22834;
  long unsigned int D.22835;
  struct MonoBasicBlock * * D.22836;
  struct MonoBasicBlock * * D.22837;
  struct MonoBasicBlock * D.22838;
  short unsigned int D.22839;
  short unsigned int D.22842;
  int D.22845;
  unsigned int D.22846;
  unsigned int D.22847;
  struct MonoInst * * D.22850;
  long unsigned int D.22851;
  long unsigned int D.22852;
  struct MonoInst * * D.22853;
  struct MonoInst * D.22854;
  struct MonoInst * iftmp.1;
  long int D.22861;
  long unsigned int D.22862;
  long unsigned int D.22863;
  struct MonoMethodVar * D.22864;
  struct MonoBitSet * D.22865;
  long unsigned int D.22866;
  struct MonoInst * iftmp.2;
  long int D.22871;
  long unsigned int D.22872;
  long unsigned int D.22873;
  struct MonoMethodVar * D.22874;
  struct MonoBitSet * D.22875;
  long unsigned int D.22876;
  int D.22877;
  long unsigned int D.22878;
  long unsigned int D.22879;
  unsigned char D.22880;
  int D.22881;
  int D.22882;
  unsigned int D.22885;
  unsigned int D.22890;
  int D.22893;
  long unsigned int D.22894;
  long unsigned int D.22895;
  struct MonoBasicBlock * * D.22896;
  struct MonoBasicBlock * D.22897;
  struct MonoBitSet * D.22902;
  long unsigned int D.22903;
  long unsigned int D.22904;
  long unsigned int D.22905;
  long unsigned int D.22906;
  struct MonoMemPool * D.22909;
  long int D.22910;
  int D.22911;
  int D.22912;
  unsigned char D.22913;
  int D.22914;
  struct MonoType * D.22916;
  long unsigned int D.22917;
  long unsigned int D.22918;
  struct MonoClass * D.22921;
  struct MonoClass * D.22923;
  struct MonoBasicBlock * D.22924;
  short int D.22925;
  int D.22926;
  int D.22927;
  long unsigned int D.22928;
  unsigned int D.22929;
  unsigned int D.22930;
  void * D.22931;
  int * D.22932;
  sizetype D.22933;
  sizetype D.22934;
  sizetype D.22935;
  int * D.22936;
  int D.22937;
  struct MonoInst * D.22938;
  unsigned int idx.3;
  long unsigned int D.22941;
  long unsigned int D.22942;
  long unsigned int D.22943;
  long unsigned int D.22944;
  long unsigned int D.22945;
  long unsigned int D.22946;
  int D.22947;
  struct MonoBasicBlock * D.22948;
  unsigned int D.22951;
  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.22791 = cfg->num_varinfo;
  D.22792 = (long unsigned int) D.22791;
  D.22793 = D.22792 * 80;
  vinfo = monoeg_malloc0 (D.22793);
  D.22794 = cfg->comp_done;
  D.22795 = D.22794 & 32;
  D.22796 = D.22795 != 0;
  D.22797 = (long int) D.22796;
  D.22798 = __builtin_expect (D.22797, 0);
  if (D.22798 != 0) goto <D.22799>; else goto <D.22800>;
  <D.22799>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 342, "!(cfg->comp_done & MONO_COMP_SSA)");
  <D.22800>:
  D.22801 = BIT_FIELD_REF <*cfg, 64, 5568>;
  D.22802 = D.22801 & 8589934592;
  D.22803 = D.22802 != 0;
  D.22804 = (long int) D.22803;
  D.22805 = __builtin_expect (D.22804, 0);
  if (D.22805 != 0) goto <D.22806>; else goto <D.22807>;
  <D.22806>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 344, "!cfg->disable_ssa");
  <D.22807>:
  D.22808 = cfg->verbose_level;
  if (D.22808 > 3) goto <D.22809>; else goto <D.22810>;
  <D.22809>:
  D.22791 = cfg->num_varinfo;
  D.22811 = cfg->next_vreg;
  printf ("\nCOMPUTE SSA %d (R%d-)\n\n", D.22791, D.22811);
  <D.22810>:
  D.22794 = cfg->comp_done;
  D.22812 = D.22794 & 16;
  if (D.22812 == 0) goto <D.22813>; else goto <D.22814>;
  <D.22813>:
  mono_analyze_liveness (cfg);
  <D.22814>:
  mono_compile_dominator_info (cfg, 7);
  D.22815 = cfg->num_bblocks;
  D.22816 = mono_bitset_alloc_size (D.22815, 0);
  bitsize = (int) D.22816;
  D.22815 = cfg->num_bblocks;
  D.22817 = mono_bitset_alloc_size (D.22815, 0);
  D.22791 = cfg->num_varinfo;
  D.22818 = D.22817 * D.22791;
  D.22819 = (long unsigned int) D.22818;
  buf_start = monoeg_malloc0 (D.22819);
  buf = buf_start;
  i = 0;
  goto <D.22446>;
  <D.22445>:
  D.22820 = (long unsigned int) i;
  D.22821 = D.22820 * 80;
  D.22822 = vinfo + D.22821;
  D.22815 = cfg->num_bblocks;
  D.22823 = mono_bitset_mem_new (buf, D.22815, 0);
  D.22822->def_in = D.22823;
  D.22824 = (sizetype) bitsize;
  buf = buf + D.22824;
  D.22820 = (long unsigned int) i;
  D.22821 = D.22820 * 80;
  D.22822 = vinfo + D.22821;
  i.0 = (unsigned int) i;
  D.22822->idx = i.0;
  D.22826 = cfg->varinfo;
  D.22820 = (long unsigned int) i;
  D.22827 = D.22820 * 8;
  D.22828 = D.22826 + D.22827;
  D.22829 = *D.22828;
  D.22830 = D.22829->opcode;
  if (D.22830 == 330) goto <D.22831>; else goto <D.22832>;
  <D.22831>:
  D.22820 = (long unsigned int) i;
  D.22821 = D.22820 * 80;
  D.22822 = vinfo + D.22821;
  D.22833 = D.22822->def_in;
  D.22820 = (long unsigned int) i;
  D.22821 = D.22820 * 80;
  D.22822 = vinfo + D.22821;
  D.22833 = D.22822->def_in;
  D.22834 = D.22833->data[0];
  D.22835 = D.22834 | 1;
  D.22833->data[0] = D.22835;
  <D.22832>:
  i = i + 1;
  <D.22446>:
  i.0 = (unsigned int) i;
  D.22791 = cfg->num_varinfo;
  if (i.0 < D.22791) goto <D.22445>; else goto <D.22447>;
  <D.22447>:
  i = 0;
  goto <D.22453>;
  <D.22452>:
  D.22836 = cfg->bblocks;
  D.22820 = (long unsigned int) i;
  D.22827 = D.22820 * 8;
  D.22837 = D.22836 + D.22827;
  D.22838 = *D.22837;
  ins = D.22838->code;
  goto <D.22450>;
  <D.22449>:
  D.22839 = ins->opcode;
  if (D.22839 == 316) goto <D.22840>; else goto <D.22841>;
  <D.22840>:
  // predicted unlikely by continue predictor.
  goto <D.22448>;
  <D.22841>:
  D.22839 = ins->opcode;
  D.22842 = D.22839 + 65162;
  if (D.22842 > 13) goto <D.22843>; else goto <D.22844>;
  <D.22843>:
  D.22845 = ins->dreg;
  D.22846 = (unsigned int) D.22845;
  D.22847 = cfg->vreg_to_inst_len;
  if (D.22846 < D.22847) goto <D.22848>; else goto <D.22849>;
  <D.22848>:
  D.22850 = cfg->vreg_to_inst;
  D.22845 = ins->dreg;
  D.22851 = (long unsigned int) D.22845;
  D.22852 = D.22851 * 8;
  D.22853 = D.22850 + D.22852;
  D.22854 = *D.22853;
  if (D.22854 != 0B) goto <D.22855>; else goto <D.22856>;
  <D.22855>:
  D.22845 = ins->dreg;
  D.22846 = (unsigned int) D.22845;
  D.22847 = cfg->vreg_to_inst_len;
  if (D.22846 < D.22847) goto <D.22858>; else goto <D.22859>;
  <D.22858>:
  D.22850 = cfg->vreg_to_inst;
  D.22845 = ins->dreg;
  D.22851 = (long unsigned int) D.22845;
  D.22852 = D.22851 * 8;
  D.22853 = D.22850 + D.22852;
  iftmp.1 = *D.22853;
  goto <D.22860>;
  <D.22859>:
  iftmp.1 = 0B;
  <D.22860>:
  D.22861 = iftmp.1->data.op[0].const_val;
  D.22862 = (long unsigned int) D.22861;
  D.22863 = D.22862 * 80;
  D.22864 = vinfo + D.22863;
  D.22865 = D.22864->def_in;
  D.22820 = (long unsigned int) i;
  D.22866 = D.22820 / 64;
  D.22845 = ins->dreg;
  D.22846 = (unsigned int) D.22845;
  D.22847 = cfg->vreg_to_inst_len;
  if (D.22846 < D.22847) goto <D.22868>; else goto <D.22869>;
  <D.22868>:
  D.22850 = cfg->vreg_to_inst;
  D.22845 = ins->dreg;
  D.22851 = (long unsigned int) D.22845;
  D.22852 = D.22851 * 8;
  D.22853 = D.22850 + D.22852;
  iftmp.2 = *D.22853;
  goto <D.22870>;
  <D.22869>:
  iftmp.2 = 0B;
  <D.22870>:
  D.22871 = iftmp.2->data.op[0].const_val;
  D.22872 = (long unsigned int) D.22871;
  D.22873 = D.22872 * 80;
  D.22874 = vinfo + D.22873;
  D.22875 = D.22874->def_in;
  D.22876 = D.22875->data[D.22866];
  D.22877 = i & 63;
  D.22878 = 1 << D.22877;
  D.22879 = D.22876 | D.22878;
  D.22865->data[D.22866] = D.22879;
  <D.22856>:
  <D.22849>:
  <D.22844>:
  <D.22448>:
  ins = ins->next;
  <D.22450>:
  if (ins != 0B) goto <D.22449>; else goto <D.22451>;
  <D.22451>:
  i = i + 1;
  <D.22453>:
  i.0 = (unsigned int) i;
  D.22815 = cfg->num_bblocks;
  if (i.0 < D.22815) goto <D.22452>; else goto <D.22454>;
  <D.22454>:
  i = 0;
  goto <D.22474>;
  <D.22473>:
  {
    struct MonoInst * var;

    D.22826 = cfg->varinfo;
    D.22820 = (long unsigned int) i;
    D.22827 = D.22820 * 8;
    D.22828 = D.22826 + D.22827;
    var = *D.22828;
    D.22880 = var->flags;
    D.22881 = (int) D.22880;
    D.22882 = D.22881 & 20;
    if (D.22882 != 0) goto <D.22883>; else goto <D.22884>;
    <D.22883>:
    // predicted unlikely by continue predictor.
    goto <D.22456>;
    <D.22884>:
    D.22820 = (long unsigned int) i;
    D.22821 = D.22820 * 80;
    D.22822 = vinfo + D.22821;
    D.22833 = D.22822->def_in;
    D.22885 = mono_bitset_count (D.22833);
    if (D.22885 <= 1) goto <D.22886>; else goto <D.22887>;
    <D.22886>:
    // predicted unlikely by continue predictor.
    goto <D.22456>;
    <D.22887>:
    D.22820 = (long unsigned int) i;
    D.22821 = D.22820 * 80;
    D.22822 = vinfo + D.22821;
    D.22833 = D.22822->def_in;
    set = mono_compile_iterated_dfrontier (cfg, D.22833);
    D.22808 = cfg->verbose_level;
    if (D.22808 > 3) goto <D.22888>; else goto <D.22889>;
    <D.22888>:
    D.22890 = mono_bitset_count (set);
    if (D.22890 != 0) goto <D.22891>; else goto <D.22892>;
    <D.22891>:
    D.22893 = var->dreg;
    printf ("\tR%d needs PHI functions in ", D.22893);
    mono_blockset_print (cfg, set, "", 4294967295);
    <D.22892>:
    <D.22889>:
    idx = mono_bitset_find_start (set);
    goto <D.22471>;
    <D.22470>:
    {
      struct MonoBasicBlock * bb;

      D.22836 = cfg->bblocks;
      D.22894 = (long unsigned int) idx;
      D.22895 = D.22894 * 8;
      D.22896 = D.22836 + D.22895;
      bb = *D.22896;
      D.22897 = cfg->bb_exit;
      if (D.22897 == bb) goto <D.22898>; else goto <D.22899>;
      <D.22898>:
      // predicted unlikely by continue predictor.
      goto <D.22458>;
      <D.22899>:
      D.22794 = cfg->comp_done;
      D.22812 = D.22794 & 16;
      if (D.22812 != 0) goto <D.22900>; else goto <D.22901>;
      <D.22900>:
      D.22902 = bb->live_in_set;
      D.22820 = (long unsigned int) i;
      D.22903 = D.22820 / 64;
      D.22904 = D.22902->data[D.22903];
      D.22877 = i & 63;
      D.22905 = D.22904 >> D.22877;
      D.22906 = D.22905 & 1;
      if (D.22906 == 0) goto <D.22907>; else goto <D.22908>;
      <D.22907>:
      // predicted unlikely by continue predictor.
      goto <D.22458>;
      <D.22908>:
      <D.22901>:
      D.22909 = cfg->mempool;
      ins = mono_mempool_alloc0 (D.22909, 80);
      ins->opcode = 319;
      D.22910 = (long int) i;
      ins->data.op[0].const_val = D.22910;
      ins->sreg2 = -1;
      D.22911 = ins->sreg2;
      ins->sreg1 = D.22911;
      D.22912 = ins->sreg1;
      ins->dreg = D.22912;
      D.22913 = var->type;
      D.22914 = (int) D.22913;
      switch (D.22914) <default: <D.22915>, case 1: <D.22459>, case 2: <D.22460>, case 3: <D.22461>, case 4: <D.22465>, case 5: <D.22462>, case 6: <D.22463>, case 7: <D.22466>>
      <D.22459>:
      <D.22460>:
      <D.22461>:
      <D.22462>:
      <D.22463>:
      ins->opcode = 319;
      goto <D.22464>;
      <D.22465>:
      ins->opcode = 320;
      goto <D.22464>;
      <D.22466>:
      ins->opcode = 321;
      goto <D.22464>;
      <D.22915>:
      <D.22464>:
      D.22916 = var->data.op[1].vtype;
      D.22917 = BIT_FIELD_REF <*D.22916, 64, 64>;
      D.22918 = D.22917 & 1073741824;
      if (D.22918 != 0) goto <D.22919>; else goto <D.22920>;
      <D.22919>:
      D.22921 = mono_defaults.int_class;
      ins->klass = D.22921;
      goto <D.22922>;
      <D.22920>:
      D.22923 = var->klass;
      ins->klass = D.22923;
      <D.22922>:
      D.22909 = cfg->mempool;
      D.22836 = cfg->bblocks;
      D.22894 = (long unsigned int) idx;
      D.22895 = D.22894 * 8;
      D.22896 = D.22836 + D.22895;
      D.22924 = *D.22896;
      D.22925 = D.22924->in_count;
      D.22926 = (int) D.22925;
      D.22927 = D.22926 + 1;
      D.22928 = (long unsigned int) D.22927;
      D.22929 = (unsigned int) D.22928;
      D.22930 = D.22929 * 4;
      D.22931 = mono_mempool_alloc0 (D.22909, D.22930);
      ins->data.op[1].phi_args = D.22931;
      D.22932 = ins->data.op[1].phi_args;
      D.22836 = cfg->bblocks;
      D.22894 = (long unsigned int) idx;
      D.22895 = D.22894 * 8;
      D.22896 = D.22836 + D.22895;
      D.22924 = *D.22896;
      D.22925 = D.22924->in_count;
      D.22926 = (int) D.22925;
      *D.22932 = D.22926;
      j = 0;
      goto <D.22468>;
      <D.22467>:
      D.22932 = ins->data.op[1].phi_args;
      D.22933 = (sizetype) j;
      D.22934 = D.22933 + 1;
      D.22935 = D.22934 * 4;
      D.22936 = D.22932 + D.22935;
      *D.22936 = -1;
      j = j + 1;
      <D.22468>:
      D.22836 = cfg->bblocks;
      D.22894 = (long unsigned int) idx;
      D.22895 = D.22894 * 8;
      D.22896 = D.22836 + D.22895;
      D.22924 = *D.22896;
      D.22925 = D.22924->in_count;
      D.22926 = (int) D.22925;
      if (D.22926 > j) goto <D.22467>; else goto <D.22469>;
      <D.22469>:
      D.22826 = cfg->varinfo;
      D.22820 = (long unsigned int) i;
      D.22827 = D.22820 * 8;
      D.22828 = D.22826 + D.22827;
      D.22829 = *D.22828;
      D.22937 = D.22829->dreg;
      ins->dreg = D.22937;
      D.22938 = bb->code;
      mono_bblock_insert_before_ins (bb, D.22938, ins);
    }
    <D.22458>:
    idx = mono_bitset_find_first (set, idx);
    <D.22471>:
    idx.3 = (unsigned int) idx;
    D.22815 = cfg->num_bblocks;
    if (idx.3 < D.22815) goto <D.22940>; else goto <D.22472>;
    <D.22940>:
    if (idx >= 0) goto <D.22470>; else goto <D.22472>;
    <D.22472>:
  }
  <D.22456>:
  i = i + 1;
  <D.22474>:
  i.0 = (unsigned int) i;
  D.22791 = cfg->num_varinfo;
  if (i.0 < D.22791) goto <D.22473>; else goto <D.22475>;
  <D.22475>:
  monoeg_g_free (vinfo);
  monoeg_g_free (buf_start);
  D.22791 = cfg->num_varinfo;
  D.22792 = (long unsigned int) D.22791;
  D.22941 = D.22792 * 8;
  stack = __builtin_alloca (D.22941);
  D.22791 = cfg->num_varinfo;
  D.22792 = (long unsigned int) D.22791;
  D.22941 = D.22792 * 8;
  memset (stack, 0, D.22941);
  D.22811 = cfg->next_vreg;
  D.22942 = (long unsigned int) D.22811;
  D.22943 = D.22942 * 4;
  lvreg_stack = monoeg_malloc0 (D.22943);
  D.22811 = cfg->next_vreg;
  D.22942 = (long unsigned int) D.22811;
  D.22943 = D.22942 * 4;
  lvreg_defined = monoeg_malloc0 (D.22943);
  stack_history_size = 10240;
  D.22944 = (long unsigned int) stack_history_size;
  D.22945 = D.22944 * 16;
  stack_history = monoeg_malloc (D.22945);
  D.22791 = cfg->num_varinfo;
  D.22792 = (long unsigned int) D.22791;
  D.22946 = D.22792 * 4;
  originals = monoeg_malloc0 (D.22946);
  D.22791 = cfg->num_varinfo;
  D.22947 = (int) D.22791;
  D.22948 = cfg->bb_entry;
  mono_ssa_rename_vars (cfg, D.22947, D.22948, 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.22808 = cfg->verbose_level;
  if (D.22808 > 3) goto <D.22949>; else goto <D.22950>;
  <D.22949>:
  printf ("\nEND COMPUTE SSA.\n\n");
  <D.22950>:
  D.22794 = cfg->comp_done;
  D.22951 = D.22794 | 32;
  cfg->comp_done = D.22951;
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.22954;
  int D.22959;
  void * D.22961;
  long unsigned int D.22962;

  D.22954 = __builtin_constant_p (__len);
  if (D.22954 != 0) goto <D.22955>; else goto <D.22956>;
  <D.22955>:
  if (__len == 0) goto <D.22957>; else goto <D.22958>;
  <D.22957>:
  D.22959 = __builtin_constant_p (__ch);
  if (D.22959 == 0) goto <D.22952>; else goto <D.22960>;
  <D.22960>:
  if (__ch != 0) goto <D.22952>; else goto <D.22953>;
  <D.22952>:
  __warn_memset_zero_len ();
  D.22961 = __dest;
  return D.22961;
  <D.22953>:
  <D.22958>:
  <D.22956>:
  D.22962 = __builtin_object_size (__dest, 0);
  D.22961 = __builtin___memset_chk (__dest, __ch, __len, D.22962);
  return D.22961;
}


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.22964;
  int D.22967;
  short unsigned int D.22968;
  int D.22969;
  int D.22970;
  int D.22971;
  int D.22974;
  int D.22975;
  int D.22976;
  signed char D.22977;
  int D.22978;
  sizetype D.22979;
  const char * D.22980;
  char D.22981;
  struct MonoInst * iftmp.4;
  int D.22985;
  unsigned int D.22986;
  unsigned int D.22987;
  struct MonoInst * * D.22990;
  long unsigned int D.22991;
  long unsigned int D.22992;
  struct MonoInst * * D.22993;
  unsigned char D.22998;
  int D.22999;
  int D.23000;
  long int D.23002;
  long unsigned int D.23003;
  long unsigned int D.23004;
  struct MonoInst * * D.23005;
  struct MonoInst * D.23006;
  short unsigned int D.23009;
  _Bool D.23012;
  long int D.23013;
  long int D.23014;
  int D.23017;
  int iftmp.5;
  long unsigned int D.23023;
  guint32 * D.23024;
  unsigned int D.23025;
  _Bool D.23027;
  long int D.23028;
  long int D.23029;
  int D.23032;
  short unsigned int D.23033;
  struct MonoInst * iftmp.6;
  int D.23037;
  unsigned int D.23038;
  long unsigned int D.23041;
  long unsigned int D.23042;
  struct MonoInst * * D.23043;
  unsigned char D.23048;
  int D.23049;
  int D.23050;
  long int D.23052;
  long unsigned int D.23053;
  long unsigned int D.23054;
  struct MonoInst * * D.23055;
  struct MonoInst * D.23056;
  short unsigned int D.23059;
  _Bool D.23062;
  long int D.23063;
  long int D.23064;
  int D.23067;
  int iftmp.7;
  long unsigned int D.23073;
  guint32 * D.23074;
  unsigned int D.23075;
  _Bool D.23077;
  long int D.23078;
  long int D.23079;
  int D.23082;
  char D.23083;
  struct MonoInst * iftmp.8;
  unsigned char D.23095;
  int D.23096;
  int D.23097;
  long int D.23099;
  _Bool D.23100;
  long int D.23101;
  long int D.23102;
  short unsigned int D.23105;
  long unsigned int D.23108;
  long unsigned int D.23109;
  gboolean * D.23110;
  _Bool D.23111;
  long int D.23112;
  long int D.23113;
  long unsigned int D.23116;
  long unsigned int D.23117;
  struct RenameInfo * D.23118;
  long unsigned int D.23119;
  struct MonoInst * * D.23120;
  struct MonoInst * D.23121;
  int D.23122;
  struct MonoType * D.23125;
  struct MonoMethodVar * D.23126;
  long int D.23127;
  long unsigned int D.23128;
  long unsigned int D.23129;
  struct MonoMethodVar * D.23130;
  int D.23133;
  int D.23134;
  long unsigned int D.23136;
  long unsigned int D.23137;
  int iftmp.9;
  gboolean * D.23142;
  int D.23143;
  _Bool D.23146;
  long int D.23147;
  long int D.23148;
  guint32 iftmp.10;
  unsigned int D.23154;
  gboolean * D.23156;
  gboolean * D.23157;
  int D.23158;
  struct MonoBasicBlock * * D.23161;
  long unsigned int D.23162;
  long unsigned int D.23163;
  struct MonoBasicBlock * * D.23164;
  struct MonoBasicBlock * * D.23165;
  long unsigned int D.23166;
  long unsigned int D.23167;
  struct MonoBasicBlock * * D.23168;
  struct MonoBasicBlock * D.23169;
  short int D.23171;
  int D.23172;
  short unsigned int D.23173;
  long int D.23175;
  struct MonoInst * * D.23179;
  struct MonoInst * * D.23180;
  int * D.23181;
  sizetype D.23182;
  sizetype D.23183;
  sizetype D.23184;
  int * D.23185;
  _Bool D.23186;
  long int D.23187;
  long int D.23188;
  int D.23191;
  short int D.23192;
  int D.23193;
  struct GSList * D.23194;
  void * D.23197;
  int D.23198;
  long unsigned int D.23199;
  struct RenameInfo * D.23200;
  int D.23201;
  long unsigned int D.23202;
  long unsigned int D.23203;
  struct MonoInst * * D.23204;
  struct MonoInst * D.23205;
  unsigned int D.23206;
  unsigned int D.23207;
  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.22964 = cfg->verbose_level;
  if (D.22964 > 3) goto <D.22965>; else goto <D.22966>;
  <D.22965>:
  D.22967 = bb->block_num;
  printf ("\nRENAME VARS BLOCK %d:\n", D.22967);
  <D.22966>:
  ins = bb->code;
  goto <D.22409>;
  <D.22408>:
  {
    const char * spec;
    int num_sregs;
    int sregs[3];

    try
      {
        D.22968 = ins->opcode;
        D.22969 = (int) D.22968;
        D.22970 = D.22969 + -313;
        D.22971 = D.22970 * 4;
        spec = &ins_info[D.22971];
        D.22968 = ins->opcode;
        if (D.22968 == 316) goto <D.22972>; else goto <D.22973>;
        <D.22972>:
        // predicted unlikely by continue predictor.
        goto <D.22398>;
        <D.22973>:
        D.22974 = ins->sreg1;
        sregs[0] = D.22974;
        D.22975 = ins->sreg2;
        sregs[1] = D.22975;
        D.22976 = ins->sreg3;
        sregs[2] = D.22976;
        D.22968 = ins->opcode;
        D.22969 = (int) D.22968;
        D.22970 = D.22969 + -313;
        D.22977 = ins_sreg_counts[D.22970];
        num_sregs = (int) D.22977;
        i = 0;
        goto <D.22402>;
        <D.22401>:
        D.22978 = i + 1;
        D.22979 = (sizetype) D.22978;
        D.22980 = spec + D.22979;
        D.22981 = *D.22980;
        if (D.22981 != 32) goto <D.22982>; else goto <D.22983>;
        <D.22982>:
        {
          struct MonoInst * var;

          D.22985 = sregs[i];
          D.22986 = (unsigned int) D.22985;
          D.22987 = cfg->vreg_to_inst_len;
          if (D.22986 < D.22987) goto <D.22988>; else goto <D.22989>;
          <D.22988>:
          D.22990 = cfg->vreg_to_inst;
          D.22985 = sregs[i];
          D.22991 = (long unsigned int) D.22985;
          D.22992 = D.22991 * 8;
          D.22993 = D.22990 + D.22992;
          iftmp.4 = *D.22993;
          goto <D.22994>;
          <D.22989>:
          iftmp.4 = 0B;
          <D.22994>:
          var = iftmp.4;
          if (var != 0B) goto <D.22997>; else goto <D.22995>;
          <D.22997>:
          D.22998 = var->flags;
          D.22999 = (int) D.22998;
          D.23000 = D.22999 & 20;
          if (D.23000 == 0) goto <D.23001>; else goto <D.22995>;
          <D.23001>:
          {
            int idx;

            D.23002 = var->data.op[0].const_val;
            idx = (int) D.23002;
            D.23003 = (long unsigned int) idx;
            D.23004 = D.23003 * 8;
            D.23005 = stack + D.23004;
            D.23006 = *D.23005;
            if (D.23006 != 0B) goto <D.23007>; else goto <D.23008>;
            <D.23007>:
            D.23009 = var->opcode;
            if (D.23009 != 330) goto <D.23010>; else goto <D.23011>;
            <D.23010>:
            D.23003 = (long unsigned int) idx;
            D.23004 = D.23003 * 8;
            D.23005 = stack + D.23004;
            D.23006 = *D.23005;
            D.23012 = D.23006 == 0B;
            D.23013 = (long int) D.23012;
            D.23014 = __builtin_expect (D.23013, 0);
            if (D.23014 != 0) goto <D.23015>; else goto <D.23016>;
            <D.23015>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 200, "stack [idx]");
            <D.23016>:
            <D.23011>:
            D.23003 = (long unsigned int) idx;
            D.23004 = D.23003 * 8;
            D.23005 = stack + D.23004;
            D.23006 = *D.23005;
            D.23017 = D.23006->dreg;
            sregs[i] = D.23017;
            D.23003 = (long unsigned int) idx;
            D.23004 = D.23003 * 8;
            D.23005 = stack + D.23004;
            D.23006 = *D.23005;
            record_use (cfg, D.23006, bb, ins);
            goto <D.23018>;
            <D.23008>:
            record_use (cfg, var, bb, ins);
            <D.23018>:
          }
          goto <D.22996>;
          <D.22995>:
          if (var == 0B) goto <D.23022>; else goto <D.23020>;
          <D.23022>:
          D.22985 = sregs[i];
          D.22991 = (long unsigned int) D.22985;
          D.23023 = D.22991 * 4;
          D.23024 = lvreg_stack + D.23023;
          D.23025 = *D.23024;
          if (D.23025 != 0) goto <D.23026>; else goto <D.23020>;
          <D.23026>:
          iftmp.5 = 1;
          goto <D.23021>;
          <D.23020>:
          iftmp.5 = 0;
          <D.23021>:
          D.23027 = iftmp.5 != 0;
          D.23028 = (long int) D.23027;
          D.23029 = __builtin_expect (D.23028, 0);
          if (D.23029 != 0) goto <D.23030>; else goto <D.23031>;
          <D.23030>:
          D.22985 = sregs[i];
          D.22991 = (long unsigned int) D.22985;
          D.23023 = D.22991 * 4;
          D.23024 = lvreg_stack + D.23023;
          D.23025 = *D.23024;
          D.23032 = (int) D.23025;
          sregs[i] = D.23032;
          <D.23031>:
          <D.22996>:
        }
        <D.22983>:
        i = i + 1;
        <D.22402>:
        if (i < num_sregs) goto <D.22401>; else goto <D.22403>;
        <D.22403>:
        mono_inst_set_src_registers (ins, &sregs);
        D.22968 = ins->opcode;
        D.23033 = D.22968 + 65162;
        if (D.23033 <= 13) goto <D.23034>; else goto <D.23035>;
        <D.23034>:
        {
          struct MonoInst * var;

          D.23037 = ins->dreg;
          D.23038 = (unsigned int) D.23037;
          D.22987 = cfg->vreg_to_inst_len;
          if (D.23038 < D.22987) goto <D.23039>; else goto <D.23040>;
          <D.23039>:
          D.22990 = cfg->vreg_to_inst;
          D.23037 = ins->dreg;
          D.23041 = (long unsigned int) D.23037;
          D.23042 = D.23041 * 8;
          D.23043 = D.22990 + D.23042;
          iftmp.6 = *D.23043;
          goto <D.23044>;
          <D.23040>:
          iftmp.6 = 0B;
          <D.23044>:
          var = iftmp.6;
          if (var != 0B) goto <D.23047>; else goto <D.23045>;
          <D.23047>:
          D.23048 = var->flags;
          D.23049 = (int) D.23048;
          D.23050 = D.23049 & 20;
          if (D.23050 == 0) goto <D.23051>; else goto <D.23045>;
          <D.23051>:
          {
            int idx;

            D.23052 = var->data.op[0].const_val;
            idx = (int) D.23052;
            D.23053 = (long unsigned int) idx;
            D.23054 = D.23053 * 8;
            D.23055 = stack + D.23054;
            D.23056 = *D.23055;
            if (D.23056 != 0B) goto <D.23057>; else goto <D.23058>;
            <D.23057>:
            D.23059 = var->opcode;
            if (D.23059 != 330) goto <D.23060>; else goto <D.23061>;
            <D.23060>:
            D.23053 = (long unsigned int) idx;
            D.23054 = D.23053 * 8;
            D.23055 = stack + D.23054;
            D.23056 = *D.23055;
            D.23062 = D.23056 == 0B;
            D.23063 = (long int) D.23062;
            D.23064 = __builtin_expect (D.23063, 0);
            if (D.23064 != 0) goto <D.23065>; else goto <D.23066>;
            <D.23065>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 219, "stack [idx]");
            <D.23066>:
            <D.23061>:
            D.23053 = (long unsigned int) idx;
            D.23054 = D.23053 * 8;
            D.23055 = stack + D.23054;
            D.23056 = *D.23055;
            D.23067 = D.23056->dreg;
            ins->dreg = D.23067;
            D.23053 = (long unsigned int) idx;
            D.23054 = D.23053 * 8;
            D.23055 = stack + D.23054;
            D.23056 = *D.23055;
            record_use (cfg, D.23056, bb, ins);
            goto <D.23068>;
            <D.23058>:
            record_use (cfg, var, bb, ins);
            <D.23068>:
          }
          goto <D.23046>;
          <D.23045>:
          if (var == 0B) goto <D.23072>; else goto <D.23070>;
          <D.23072>:
          D.23037 = ins->dreg;
          D.23041 = (long unsigned int) D.23037;
          D.23073 = D.23041 * 4;
          D.23074 = lvreg_stack + D.23073;
          D.23075 = *D.23074;
          if (D.23075 != 0) goto <D.23076>; else goto <D.23070>;
          <D.23076>:
          iftmp.7 = 1;
          goto <D.23071>;
          <D.23070>:
          iftmp.7 = 0;
          <D.23071>:
          D.23077 = iftmp.7 != 0;
          D.23078 = (long int) D.23077;
          D.23079 = __builtin_expect (D.23078, 0);
          if (D.23079 != 0) goto <D.23080>; else goto <D.23081>;
          <D.23080>:
          D.23037 = ins->dreg;
          D.23041 = (long unsigned int) D.23037;
          D.23073 = D.23041 * 4;
          D.23074 = lvreg_stack + D.23073;
          D.23075 = *D.23074;
          D.23082 = (int) D.23075;
          ins->dreg = D.23082;
          <D.23081>:
          <D.23046>:
        }
        <D.23035>:
        D.23083 = *spec;
        if (D.23083 != 32) goto <D.23084>; else goto <D.23085>;
        <D.23084>:
        D.22968 = ins->opcode;
        D.23033 = D.22968 + 65162;
        if (D.23033 > 13) goto <D.23086>; else goto <D.23087>;
        <D.23086>:
        {
          struct MonoInst * var;
          struct MonoMethodVar * info;

          D.23037 = ins->dreg;
          D.23038 = (unsigned int) D.23037;
          D.22987 = cfg->vreg_to_inst_len;
          if (D.23038 < D.22987) goto <D.23089>; else goto <D.23090>;
          <D.23089>:
          D.22990 = cfg->vreg_to_inst;
          D.23037 = ins->dreg;
          D.23041 = (long unsigned int) D.23037;
          D.23042 = D.23041 * 8;
          D.23043 = D.22990 + D.23042;
          iftmp.8 = *D.23043;
          goto <D.23091>;
          <D.23090>:
          iftmp.8 = 0B;
          <D.23091>:
          var = iftmp.8;
          if (var != 0B) goto <D.23094>; else goto <D.23092>;
          <D.23094>:
          D.23095 = var->flags;
          D.23096 = (int) D.23095;
          D.23097 = D.23096 & 20;
          if (D.23097 == 0) goto <D.23098>; else goto <D.23092>;
          <D.23098>:
          D.23099 = var->data.op[0].const_val;
          idx = (int) D.23099;
          D.23100 = idx >= max_vars;
          D.23101 = (long int) D.23100;
          D.23102 = __builtin_expect (D.23101, 0);
          if (D.23102 != 0) goto <D.23103>; else goto <D.23104>;
          <D.23103>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 237, "idx < max_vars");
          <D.23104>:
          D.23105 = var->opcode;
          if (D.23105 == 330) goto <D.23106>; else goto <D.23107>;
          <D.23106>:
          D.23108 = (long unsigned int) idx;
          D.23109 = D.23108 * 4;
          D.23110 = originals_used + D.23109;
          *D.23110 = 1;
          <D.23107>:
          D.23111 = stack_history_len >= stack_history_size;
          D.23112 = (long int) D.23111;
          D.23113 = __builtin_expect (D.23112, 0);
          if (D.23113 != 0) goto <D.23114>; else goto <D.23115>;
          <D.23114>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 243, "stack_history_len < stack_history_size");
          <D.23115>:
          D.23116 = (long unsigned int) stack_history_len;
          D.23117 = D.23116 * 16;
          D.23118 = stack_history + D.23117;
          D.23108 = (long unsigned int) idx;
          D.23119 = D.23108 * 8;
          D.23120 = stack + D.23119;
          D.23121 = *D.23120;
          D.23118->var = D.23121;
          D.23116 = (long unsigned int) stack_history_len;
          D.23117 = D.23116 * 16;
          D.23118 = stack_history + D.23117;
          D.23118->idx = idx;
          stack_history_len = stack_history_len + 1;
          D.23108 = (long unsigned int) idx;
          D.23109 = D.23108 * 4;
          D.23110 = originals_used + D.23109;
          D.23122 = *D.23110;
          if (D.23122 != 0) goto <D.23123>; else goto <D.23124>;
          <D.23123>:
          D.23125 = var->data.op[1].vtype;
          new_var = mono_compile_create_var (cfg, D.23125, 329);
          D.23095 = var->flags;
          new_var->flags = D.23095;
          D.23126 = cfg->vars;
          D.23127 = new_var->data.op[0].const_val;
          D.23128 = (long unsigned int) D.23127;
          D.23129 = D.23128 * 80;
          D.23130 = D.23126 + D.23129;
          D.23130->reg = idx;
          D.22964 = cfg->verbose_level;
          if (D.22964 > 3) goto <D.23131>; else goto <D.23132>;
          <D.23131>:
          D.23133 = var->dreg;
          D.23134 = new_var->dreg;
          printf ("  R%d -> R%d\n", D.23133, D.23134);
          <D.23132>:
          D.23108 = (long unsigned int) idx;
          D.23119 = D.23108 * 8;
          D.23120 = stack + D.23119;
          *D.23120 = new_var;
          D.23134 = new_var->dreg;
          ins->dreg = D.23134;
          var = new_var;
          goto <D.23135>;
          <D.23124>:
          D.23108 = (long unsigned int) idx;
          D.23119 = D.23108 * 8;
          D.23120 = stack + D.23119;
          *D.23120 = var;
          D.23108 = (long unsigned int) idx;
          D.23109 = D.23108 * 4;
          D.23110 = originals_used + D.23109;
          *D.23110 = 1;
          <D.23135>:
          D.23126 = cfg->vars;
          D.23099 = var->data.op[0].const_val;
          D.23136 = (long unsigned int) D.23099;
          D.23137 = D.23136 * 80;
          info = D.23126 + D.23137;
          info->def = ins;
          info->def_bb = bb;
          goto <D.23093>;
          <D.23092>:
          if (var == 0B) goto <D.23141>; else goto <D.23139>;
          <D.23141>:
          D.23037 = ins->dreg;
          D.23041 = (long unsigned int) D.23037;
          D.23073 = D.23041 * 4;
          D.23142 = lvreg_defined + D.23073;
          D.23143 = *D.23142;
          if (D.23143 != 0) goto <D.23144>; else goto <D.23139>;
          <D.23144>:
          D.23037 = ins->dreg;
          if (D.23037 > 31) goto <D.23145>; else goto <D.23139>;
          <D.23145>:
          iftmp.9 = 1;
          goto <D.23140>;
          <D.23139>:
          iftmp.9 = 0;
          <D.23140>:
          D.23146 = iftmp.9 != 0;
          D.23147 = (long int) D.23146;
          D.23148 = __builtin_expect (D.23147, 0);
          if (D.23148 != 0) goto <D.23149>; else goto <D.23150>;
          <D.23149>:
          D.23037 = ins->dreg;
          D.23041 = (long unsigned int) D.23037;
          D.23073 = D.23041 * 4;
          D.23074 = lvreg_stack + D.23073;
          D.23037 = ins->dreg;
          D.23038 = (unsigned int) D.23037;
          D.23154 = cfg->vreg_is_ref_len;
          if (D.23038 < D.23154) goto <D.23155>; else goto <D.23152>;
          <D.23155>:
          D.23156 = cfg->vreg_is_ref;
          D.23037 = ins->dreg;
          D.23041 = (long unsigned int) D.23037;
          D.23073 = D.23041 * 4;
          D.23157 = D.23156 + D.23073;
          D.23158 = *D.23157;
          if (D.23158 != 0) goto <D.23159>; else goto <D.23152>;
          <D.23159>:
          iftmp.10 = mono_alloc_ireg_ref (cfg);
          goto <D.23153>;
          <D.23152>:
          iftmp.10 = mono_alloc_preg (cfg);
          <D.23153>:
          *D.23074 = iftmp.10;
          D.23037 = ins->dreg;
          D.23041 = (long unsigned int) D.23037;
          D.23073 = D.23041 * 4;
          D.23074 = lvreg_stack + D.23073;
          D.23075 = *D.23074;
          D.23082 = (int) D.23075;
          ins->dreg = D.23082;
          goto <D.23160>;
          <D.23150>:
          D.23037 = ins->dreg;
          D.23041 = (long unsigned int) D.23037;
          D.23073 = D.23041 * 4;
          D.23142 = lvreg_defined + D.23073;
          *D.23142 = 1;
          <D.23160>:
          <D.23093>:
        }
        <D.23087>:
        <D.23085>:
      }
    finally
      {
        sregs = {CLOBBER};
      }
  }
  <D.22398>:
  ins = ins->next;
  <D.22409>:
  if (ins != 0B) goto <D.22408>; else goto <D.22410>;
  <D.22410>:
  i = 0;
  goto <D.22419>;
  <D.22418>:
  {
    struct MonoBasicBlock * n;

    D.23161 = bb->out_bb;
    D.23162 = (long unsigned int) i;
    D.23163 = D.23162 * 8;
    D.23164 = D.23161 + D.23163;
    n = *D.23164;
    j = 0;
    goto <D.22414>;
    <D.22413>:
    D.23165 = n->in_bb;
    D.23166 = (long unsigned int) j;
    D.23167 = D.23166 * 8;
    D.23168 = D.23165 + D.23167;
    D.23169 = *D.23168;
    if (D.23169 == bb) goto <D.22412>; else goto <D.23170>;
    <D.23170>:
    j = j + 1;
    <D.22414>:
    D.23171 = n->in_count;
    D.23172 = (int) D.23171;
    if (D.23172 > j) goto <D.22413>; else goto <D.22412>;
    <D.22412>:
    ins = n->code;
    goto <D.22417>;
    <D.22416>:
    D.22968 = ins->opcode;
    D.23173 = D.22968 + 65217;
    if (D.23173 <= 2) goto <D.23174>; else goto <D.22415>;
    <D.23174>:
    D.23175 = ins->data.op[0].const_val;
    idx = (int) D.23175;
    D.23108 = (long unsigned int) idx;
    D.23119 = D.23108 * 8;
    D.23120 = stack + D.23119;
    D.23121 = *D.23120;
    if (D.23121 != 0B) goto <D.23176>; else goto <D.23177>;
    <D.23176>:
    D.23108 = (long unsigned int) idx;
    D.23119 = D.23108 * 8;
    D.23120 = stack + D.23119;
    new_var = *D.23120;
    goto <D.23178>;
    <D.23177>:
    D.23179 = cfg->varinfo;
    D.23108 = (long unsigned int) idx;
    D.23119 = D.23108 * 8;
    D.23180 = D.23179 + D.23119;
    new_var = *D.23180;
    <D.23178>:
    D.23181 = ins->data.op[1].phi_args;
    D.23182 = (sizetype) j;
    D.23183 = D.23182 + 1;
    D.23184 = D.23183 * 4;
    D.23185 = D.23181 + D.23184;
    D.23134 = new_var->dreg;
    *D.23185 = D.23134;
    record_use (cfg, new_var, n, ins);
    D.22964 = cfg->verbose_level;
    D.23186 = D.22964 > 3;
    D.23187 = (long int) D.23186;
    D.23188 = __builtin_expect (D.23187, 0);
    if (D.23188 != 0) goto <D.23189>; else goto <D.23190>;
    <D.23189>:
    D.23037 = ins->dreg;
    D.23134 = new_var->dreg;
    D.23191 = n->block_num;
    printf ("\tAdd PHI R%d <- R%d to BB%d\n", D.23037, D.23134, D.23191);
    <D.23190>:
    ins = ins->next;
    <D.22417>:
    if (ins != 0B) goto <D.22416>; else goto <D.22415>;
    <D.22415>:
  }
  i = i + 1;
  <D.22419>:
  D.23192 = bb->out_count;
  D.23193 = (int) D.23192;
  if (D.23193 > i) goto <D.22418>; else goto <D.22420>;
  <D.22420>:
  D.23194 = bb->dominated;
  if (D.23194 != 0B) goto <D.23195>; else goto <D.23196>;
  <D.23195>:
  tmp = bb->dominated;
  goto <D.22422>;
  <D.22421>:
  D.23197 = tmp->data;
  D.23116 = (long unsigned int) stack_history_len;
  D.23117 = D.23116 * 16;
  D.23118 = stack_history + D.23117;
  D.23198 = stack_history_size - stack_history_len;
  mono_ssa_rename_vars (cfg, max_vars, D.23197, originals_used, stack, lvreg_stack, lvreg_defined, D.23118, D.23198);
  tmp = tmp->next;
  <D.22422>:
  if (tmp != 0B) goto <D.22421>; else goto <D.22423>;
  <D.22423>:
  <D.23196>:
  i = stack_history_len + -1;
  goto <D.22425>;
  <D.22424>:
  D.23162 = (long unsigned int) i;
  D.23199 = D.23162 * 16;
  D.23200 = stack_history + D.23199;
  D.23201 = D.23200->idx;
  D.23202 = (long unsigned int) D.23201;
  D.23203 = D.23202 * 8;
  D.23204 = stack + D.23203;
  D.23162 = (long unsigned int) i;
  D.23199 = D.23162 * 16;
  D.23200 = stack_history + D.23199;
  D.23205 = D.23200->var;
  *D.23204 = D.23205;
  i = i + -1;
  <D.22425>:
  if (i >= 0) goto <D.22424>; else goto <D.22426>;
  <D.22426>:
  D.23206 = cfg->comp_done;
  D.23207 = D.23206 | 64;
  cfg->comp_done = D.23207;
}


record_use (struct MonoCompile * cfg, struct MonoInst * var, struct MonoBasicBlock * bb, struct MonoInst * ins)
{
  struct MonoMemPool * D.23210;
  struct MonoMethodVar * D.23211;
  long int D.23212;
  long unsigned int D.23213;
  long unsigned int D.23214;
  struct GList * D.23215;
  struct GList * D.23216;
  struct MonoMethodVar * info;
  struct MonoVarUsageInfo * ui;

  D.23210 = cfg->mempool;
  ui = mono_mempool_alloc (D.23210, 16);
  D.23211 = cfg->vars;
  D.23212 = var->data.op[0].const_val;
  D.23213 = (long unsigned int) D.23212;
  D.23214 = D.23213 * 80;
  info = D.23211 + D.23214;
  ui->bb = bb;
  ui->inst = ins;
  D.23210 = cfg->mempool;
  D.23215 = info->uses;
  D.23216 = g_list_prepend_mempool (D.23210, D.23215, ui);
  info->uses = D.23216;
}


g_list_prepend_mempool (struct MonoMemPool * mp, struct GList * list, void * data)
{
  struct GList * iftmp.11;
  struct GList * D.23221;
  struct GList * D.23226;
  struct GList * new_list;

  new_list = mono_mempool_alloc (mp, 24);
  new_list->data = data;
  if (list != 0B) goto <D.23218>; else goto <D.23219>;
  <D.23218>:
  iftmp.11 = list->prev;
  goto <D.23220>;
  <D.23219>:
  iftmp.11 = 0B;
  <D.23220>:
  new_list->prev = iftmp.11;
  new_list->next = list;
  D.23221 = new_list->prev;
  if (D.23221 != 0B) goto <D.23222>; else goto <D.23223>;
  <D.23222>:
  D.23221 = new_list->prev;
  D.23221->next = new_list;
  <D.23223>:
  if (list != 0B) goto <D.23224>; else goto <D.23225>;
  <D.23224>:
  list->prev = new_list;
  <D.23225>:
  D.23226 = new_list;
  return D.23226;
}


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

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


mono_ssa_remove (struct MonoCompile * cfg)
{
  unsigned int D.23230;
  unsigned int D.23231;
  _Bool D.23232;
  long int D.23233;
  long int D.23234;
  struct MonoBasicBlock * * D.23237;
  long unsigned int D.23238;
  long unsigned int D.23239;
  struct MonoBasicBlock * * D.23240;
  unsigned int D.23241;
  int D.23244;
  short unsigned int D.23245;
  short unsigned int D.23246;
  int * D.23249;
  int D.23250;
  short int D.23251;
  int D.23252;
  _Bool D.23253;
  long int D.23254;
  long int D.23255;
  struct MonoInst * iftmp.12;
  int D.23259;
  unsigned int D.23260;
  unsigned int D.23261;
  struct MonoInst * * D.23264;
  long unsigned int D.23265;
  long unsigned int D.23266;
  struct MonoInst * * D.23267;
  sizetype D.23269;
  sizetype D.23270;
  sizetype D.23271;
  int * D.23272;
  int D.23273;
  int D.23279;
  int D.23280;
  short unsigned int D.23281;
  struct MonoClass * D.23284;
  _Bool D.23285;
  long int D.23286;
  long int D.23287;
  struct MonoBasicBlock * * D.23290;
  long unsigned int D.23291;
  long unsigned int D.23292;
  struct MonoBasicBlock * * D.23293;
  int D.23296;
  int D.23297;
  struct MonoMemPool * D.23300;
  int D.23301;
  short unsigned int D.23302;
  int D.23303;
  int D.23304;
  const unsigned char * D.23305;
  short unsigned int D.23306;
  unsigned int i.13;
  unsigned int D.23312;
  long unsigned int D.23315;
  long unsigned int D.23316;
  struct MonoBasicBlock * * D.23317;
  int D.23318;
  int D.23319;
  char D.23322;
  struct MonoInst * iftmp.14;
  struct MonoMethodVar * D.23331;
  long int D.23332;
  long unsigned int D.23333;
  long unsigned int D.23334;
  int D.23335;
  unsigned int D.23338;
  unsigned int D.23339;
  long unsigned int D.23342;
  long unsigned int D.23343;
  struct MonoMethodVar * D.23344;
  int D.23345;
  struct MonoInst * * D.23348;
  long unsigned int D.23349;
  struct MonoInst * * D.23350;
  struct MonoInst * D.23351;
  int D.23352;
  int D.23353;
  int D.23354;
  int D.23355;
  signed char D.23356;
  struct MonoInst * iftmp.15;
  int D.23358;
  unsigned int D.23359;
  long unsigned int D.23362;
  long unsigned int D.23363;
  struct MonoInst * * D.23364;
  long int D.23368;
  long unsigned int D.23369;
  long unsigned int D.23370;
  int D.23371;
  unsigned int D.23374;
  unsigned int D.23375;
  long unsigned int D.23378;
  long unsigned int D.23379;
  struct MonoMethodVar * D.23380;
  int D.23381;
  long unsigned int D.23384;
  struct MonoInst * * D.23385;
  struct MonoInst * D.23386;
  int D.23387;
  unsigned int bbindex.16;
  long unsigned int D.23389;
  struct MonoMethodVar * D.23390;
  unsigned int D.23391;
  unsigned int D.23392;
  unsigned int D.23395;
  unsigned int D.23396;
  struct MonoInst * ins;
  struct MonoInst * var;
  struct MonoInst * move;
  int bbindex;
  int i;
  int j;
  int first;

  D.23230 = cfg->comp_done;
  D.23231 = D.23230 & 32;
  D.23232 = D.23231 == 0;
  D.23233 = (long int) D.23232;
  D.23234 = __builtin_expect (D.23233, 0);
  if (D.23234 != 0) goto <D.23235>; else goto <D.23236>;
  <D.23235>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 489, "cfg->comp_done & MONO_COMP_SSA");
  <D.23236>:
  i = 0;
  goto <D.22499>;
  <D.22498>:
  {
    struct MonoBasicBlock * bb;

    D.23237 = cfg->bblocks;
    D.23238 = (long unsigned int) i;
    D.23239 = D.23238 * 8;
    D.23240 = D.23237 + D.23239;
    bb = *D.23240;
    D.23241 = cfg->verbose_level;
    if (D.23241 > 3) goto <D.23242>; else goto <D.23243>;
    <D.23242>:
    D.23244 = bb->block_num;
    printf ("\nREMOVE SSA %d:\n", D.23244);
    <D.23243>:
    ins = bb->code;
    goto <D.22496>;
    <D.22495>:
    D.23245 = ins->opcode;
    D.23246 = D.23245 + 65217;
    if (D.23246 <= 2) goto <D.23247>; else goto <D.23248>;
    <D.23247>:
    D.23249 = ins->data.op[1].phi_args;
    D.23250 = *D.23249;
    D.23251 = bb->in_count;
    D.23252 = (int) D.23251;
    D.23253 = D.23250 != D.23252;
    D.23254 = (long int) D.23253;
    D.23255 = __builtin_expect (D.23254, 0);
    if (D.23255 != 0) goto <D.23256>; else goto <D.23257>;
    <D.23256>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 499, "ins->inst_phi_args [0] == bb->in_count");
    <D.23257>:
    D.23259 = ins->dreg;
    D.23260 = (unsigned int) D.23259;
    D.23261 = cfg->vreg_to_inst_len;
    if (D.23260 < D.23261) goto <D.23262>; else goto <D.23263>;
    <D.23262>:
    D.23264 = cfg->vreg_to_inst;
    D.23259 = ins->dreg;
    D.23265 = (long unsigned int) D.23259;
    D.23266 = D.23265 * 8;
    D.23267 = D.23264 + D.23266;
    iftmp.12 = *D.23267;
    goto <D.23268>;
    <D.23263>:
    iftmp.12 = 0B;
    <D.23268>:
    var = iftmp.12;
    D.23249 = ins->data.op[1].phi_args;
    first = MEM[(int *)D.23249 + 4B];
    j = 1;
    goto <D.22489>;
    <D.22488>:
    D.23249 = ins->data.op[1].phi_args;
    D.23269 = (sizetype) j;
    D.23270 = D.23269 + 1;
    D.23271 = D.23270 * 4;
    D.23272 = D.23249 + D.23271;
    D.23273 = *D.23272;
    if (D.23273 != first) goto <D.22487>; else goto <D.23274>;
    <D.23274>:
    j = j + 1;
    <D.22489>:
    D.23251 = bb->in_count;
    D.23252 = (int) D.23251;
    if (D.23252 > j) goto <D.22488>; else goto <D.22487>;
    <D.22487>:
    D.23251 = bb->in_count;
    if (D.23251 > 1) goto <D.23277>; else goto <D.23275>;
    <D.23277>:
    D.23251 = bb->in_count;
    D.23252 = (int) D.23251;
    if (D.23252 == j) goto <D.23278>; else goto <D.23275>;
    <D.23278>:
    D.23245 = ins->opcode;
    D.23279 = (int) D.23245;
    D.23280 = op_phi_to_move (D.23279);
    D.23281 = (short unsigned int) D.23280;
    ins->opcode = D.23281;
    D.23245 = ins->opcode;
    if (D.23245 == 427) goto <D.23282>; else goto <D.23283>;
    <D.23282>:
    D.23284 = ins->klass;
    D.23285 = D.23284 == 0B;
    D.23286 = (long int) D.23285;
    D.23287 = __builtin_expect (D.23286, 0);
    if (D.23287 != 0) goto <D.23288>; else goto <D.23289>;
    <D.23288>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 512, "ins->klass");
    <D.23289>:
    <D.23283>:
    ins->sreg1 = first;
    goto <D.23276>;
    <D.23275>:
    j = 0;
    goto <D.22493>;
    <D.22492>:
    {
      struct MonoBasicBlock * pred;
      int sreg;

      D.23290 = bb->in_bb;
      D.23291 = (long unsigned int) j;
      D.23292 = D.23291 * 8;
      D.23293 = D.23290 + D.23292;
      pred = *D.23293;
      D.23249 = ins->data.op[1].phi_args;
      D.23269 = (sizetype) j;
      D.23270 = D.23269 + 1;
      D.23271 = D.23270 * 4;
      D.23272 = D.23249 + D.23271;
      sreg = *D.23272;
      D.23241 = cfg->verbose_level;
      if (D.23241 > 3) goto <D.23294>; else goto <D.23295>;
      <D.23294>:
      D.23296 = var->dreg;
      D.23297 = pred->block_num;
      printf ("\tADD R%d <- R%d in BB%d\n", D.23296, sreg, D.23297);
      <D.23295>:
      D.23296 = var->dreg;
      if (D.23296 != sreg) goto <D.23298>; else goto <D.23299>;
      <D.23298>:
      D.23300 = cfg->mempool;
      move = mono_mempool_alloc0 (D.23300, 80);
      D.23245 = ins->opcode;
      D.23279 = (int) D.23245;
      D.23301 = op_phi_to_move (D.23279);
      D.23302 = (short unsigned int) D.23301;
      move->opcode = D.23302;
      move->dreg = -1;
      move->sreg3 = -1;
      D.23303 = move->sreg3;
      move->sreg2 = D.23303;
      D.23304 = move->sreg2;
      move->sreg1 = D.23304;
      D.23305 = cfg->ip;
      move->cil_code = D.23305;
      D.23306 = move->opcode;
      if (D.23306 == 427) goto <D.23307>; else goto <D.23308>;
      <D.23307>:
      D.23284 = ins->klass;
      D.23285 = D.23284 == 0B;
      D.23286 = (long int) D.23285;
      D.23287 = __builtin_expect (D.23286, 0);
      if (D.23287 != 0) goto <D.23309>; else goto <D.23310>;
      <D.23309>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 524, "ins->klass");
      <D.23310>:
      D.23284 = ins->klass;
      move->klass = D.23284;
      <D.23308>:
      D.23296 = var->dreg;
      move->dreg = D.23296;
      move->sreg1 = sreg;
      mono_add_ins_to_end (pred, move);
      <D.23299>:
    }
    j = j + 1;
    <D.22493>:
    D.23251 = bb->in_count;
    D.23252 = (int) D.23251;
    if (D.23252 > j) goto <D.22492>; else goto <D.22494>;
    <D.22494>:
    ins->opcode = 316;
    ins->dreg = -1;
    <D.23276>:
    <D.23248>:
    ins = ins->next;
    <D.22496>:
    if (ins != 0B) goto <D.22495>; else goto <D.22497>;
    <D.22497>:
  }
  i = i + 1;
  <D.22499>:
  i.13 = (unsigned int) i;
  D.23312 = cfg->num_bblocks;
  if (i.13 < D.23312) goto <D.22498>; else goto <D.22500>;
  <D.22500>:
  D.23241 = cfg->verbose_level;
  if (D.23241 > 3) goto <D.23313>; else goto <D.23314>;
  <D.23313>:
  i = 0;
  goto <D.22503>;
  <D.22502>:
  {
    struct MonoBasicBlock * bb;

    D.23237 = cfg->bblocks;
    D.23238 = (long unsigned int) i;
    D.23239 = D.23238 * 8;
    D.23240 = D.23237 + D.23239;
    bb = *D.23240;
    mono_print_bb (bb, "AFTER REMOVE SSA:");
  }
  i = i + 1;
  <D.22503>:
  i.13 = (unsigned int) i;
  D.23312 = cfg->num_bblocks;
  if (i.13 < D.23312) goto <D.22502>; else goto <D.22504>;
  <D.22504>:
  <D.23314>:
  bbindex = 0;
  goto <D.22521>;
  <D.22520>:
  {
    struct MonoBasicBlock * bb;

    D.23237 = cfg->bblocks;
    D.23315 = (long unsigned int) bbindex;
    D.23316 = D.23315 * 8;
    D.23317 = D.23237 + D.23316;
    bb = *D.23317;
    ins = bb->code;
    goto <D.22518>;
    <D.22517>:
    {
      const char * spec;
      int num_sregs;
      int sregs[3];

      try
        {
          D.23245 = ins->opcode;
          D.23279 = (int) D.23245;
          D.23318 = D.23279 + -313;
          D.23319 = D.23318 * 4;
          spec = &ins_info[D.23319];
          D.23245 = ins->opcode;
          if (D.23245 == 316) goto <D.23320>; else goto <D.23321>;
          <D.23320>:
          // predicted unlikely by continue predictor.
          goto <D.22509>;
          <D.23321>:
          D.23322 = *spec;
          if (D.23322 != 32) goto <D.23323>; else goto <D.23324>;
          <D.23323>:
          {
            struct MonoInst * var;

            D.23259 = ins->dreg;
            D.23260 = (unsigned int) D.23259;
            D.23261 = cfg->vreg_to_inst_len;
            if (D.23260 < D.23261) goto <D.23326>; else goto <D.23327>;
            <D.23326>:
            D.23264 = cfg->vreg_to_inst;
            D.23259 = ins->dreg;
            D.23265 = (long unsigned int) D.23259;
            D.23266 = D.23265 * 8;
            D.23267 = D.23264 + D.23266;
            iftmp.14 = *D.23267;
            goto <D.23328>;
            <D.23327>:
            iftmp.14 = 0B;
            <D.23328>:
            var = iftmp.14;
            if (var != 0B) goto <D.23329>; else goto <D.23330>;
            <D.23329>:
            {
              struct MonoMethodVar * vmv;

              D.23331 = cfg->vars;
              D.23332 = var->data.op[0].const_val;
              D.23333 = (long unsigned int) D.23332;
              D.23334 = D.23333 * 80;
              vmv = D.23331 + D.23334;
              D.23335 = vmv->reg;
              if (D.23335 != -1) goto <D.23336>; else goto <D.23337>;
              <D.23336>:
              D.23338 = vmv->idx;
              D.23335 = vmv->reg;
              D.23339 = (unsigned int) D.23335;
              if (D.23338 != D.23339) goto <D.23340>; else goto <D.23341>;
              <D.23340>:
              D.23331 = cfg->vars;
              D.23335 = vmv->reg;
              D.23342 = (long unsigned int) D.23335;
              D.23343 = D.23342 * 80;
              D.23344 = D.23331 + D.23343;
              D.23345 = D.23344->reg;
              if (D.23345 != -1) goto <D.23346>; else goto <D.23347>;
              <D.23346>:
              D.23259 = ins->dreg;
              D.23348 = cfg->varinfo;
              D.23335 = vmv->reg;
              D.23342 = (long unsigned int) D.23335;
              D.23349 = D.23342 * 8;
              D.23350 = D.23348 + D.23349;
              D.23351 = *D.23350;
              D.23352 = D.23351->dreg;
              printf ("COALESCE: R%d -> R%d\n", D.23259, D.23352);
              D.23348 = cfg->varinfo;
              D.23335 = vmv->reg;
              D.23342 = (long unsigned int) D.23335;
              D.23349 = D.23342 * 8;
              D.23350 = D.23348 + D.23349;
              D.23351 = *D.23350;
              D.23352 = D.23351->dreg;
              ins->dreg = D.23352;
              <D.23347>:
              <D.23341>:
              <D.23337>:
            }
            <D.23330>:
          }
          <D.23324>:
          D.23353 = ins->sreg1;
          sregs[0] = D.23353;
          D.23354 = ins->sreg2;
          sregs[1] = D.23354;
          D.23355 = ins->sreg3;
          sregs[2] = D.23355;
          D.23245 = ins->opcode;
          D.23279 = (int) D.23245;
          D.23318 = D.23279 + -313;
          D.23356 = ins_sreg_counts[D.23318];
          num_sregs = (int) D.23356;
          i = 0;
          goto <D.22515>;
          <D.22514>:
          {
            struct MonoInst * var;

            D.23358 = sregs[i];
            D.23359 = (unsigned int) D.23358;
            D.23261 = cfg->vreg_to_inst_len;
            if (D.23359 < D.23261) goto <D.23360>; else goto <D.23361>;
            <D.23360>:
            D.23264 = cfg->vreg_to_inst;
            D.23358 = sregs[i];
            D.23362 = (long unsigned int) D.23358;
            D.23363 = D.23362 * 8;
            D.23364 = D.23264 + D.23363;
            iftmp.15 = *D.23364;
            goto <D.23365>;
            <D.23361>:
            iftmp.15 = 0B;
            <D.23365>:
            var = iftmp.15;
            if (var != 0B) goto <D.23366>; else goto <D.23367>;
            <D.23366>:
            {
              struct MonoMethodVar * vmv;

              D.23331 = cfg->vars;
              D.23368 = var->data.op[0].const_val;
              D.23369 = (long unsigned int) D.23368;
              D.23370 = D.23369 * 80;
              vmv = D.23331 + D.23370;
              D.23371 = vmv->reg;
              if (D.23371 != -1) goto <D.23372>; else goto <D.23373>;
              <D.23372>:
              D.23374 = vmv->idx;
              D.23371 = vmv->reg;
              D.23375 = (unsigned int) D.23371;
              if (D.23374 != D.23375) goto <D.23376>; else goto <D.23377>;
              <D.23376>:
              D.23331 = cfg->vars;
              D.23371 = vmv->reg;
              D.23378 = (long unsigned int) D.23371;
              D.23379 = D.23378 * 80;
              D.23380 = D.23331 + D.23379;
              D.23381 = D.23380->reg;
              if (D.23381 != -1) goto <D.23382>; else goto <D.23383>;
              <D.23382>:
              D.23358 = sregs[i];
              D.23348 = cfg->varinfo;
              D.23371 = vmv->reg;
              D.23378 = (long unsigned int) D.23371;
              D.23384 = D.23378 * 8;
              D.23385 = D.23348 + D.23384;
              D.23386 = *D.23385;
              D.23387 = D.23386->dreg;
              printf ("COALESCE: R%d -> R%d\n", D.23358, D.23387);
              D.23348 = cfg->varinfo;
              D.23371 = vmv->reg;
              D.23378 = (long unsigned int) D.23371;
              D.23384 = D.23378 * 8;
              D.23385 = D.23348 + D.23384;
              D.23386 = *D.23385;
              D.23387 = D.23386->dreg;
              sregs[i] = D.23387;
              <D.23383>:
              <D.23377>:
              <D.23373>:
            }
            <D.23367>:
          }
          i = i + 1;
          <D.22515>:
          if (i < num_sregs) goto <D.22514>; else goto <D.22516>;
          <D.22516>:
          mono_inst_set_src_registers (ins, &sregs);
        }
      finally
        {
          sregs = {CLOBBER};
        }
    }
    <D.22509>:
    ins = ins->next;
    <D.22518>:
    if (ins != 0B) goto <D.22517>; else goto <D.22519>;
    <D.22519>:
  }
  bbindex = bbindex + 1;
  <D.22521>:
  bbindex.16 = (unsigned int) bbindex;
  D.23312 = cfg->num_bblocks;
  if (bbindex.16 < D.23312) goto <D.22520>; else goto <D.22522>;
  <D.22522>:
  i = 0;
  goto <D.22524>;
  <D.22523>:
  D.23331 = cfg->vars;
  D.23238 = (long unsigned int) i;
  D.23389 = D.23238 * 80;
  D.23390 = D.23331 + D.23389;
  D.23390->reg = -1;
  i = i + 1;
  <D.22524>:
  i.13 = (unsigned int) i;
  D.23391 = cfg->num_varinfo;
  if (i.13 < D.23391) goto <D.22523>; else goto <D.22525>;
  <D.22525>:
  D.23230 = cfg->comp_done;
  D.23392 = D.23230 & 128;
  if (D.23392 != 0) goto <D.23393>; else goto <D.23394>;
  <D.23393>:
  unlink_unused_bblocks (cfg);
  <D.23394>:
  D.23230 = cfg->comp_done;
  D.23395 = D.23230 & 4294967279;
  cfg->comp_done = D.23395;
  D.23230 = cfg->comp_done;
  D.23396 = D.23230 & 4294967263;
  cfg->comp_done = D.23396;
}


op_phi_to_move (int opcode)
{
  int D.23399;

  switch (opcode) <default: <D.22364>, case 319: <D.22360>, case 320: <D.22361>, case 321: <D.22362>, case 802: <D.22363>>
  <D.22360>:
  D.23399 = 424;
  return D.23399;
  <D.22361>:
  D.23399 = 426;
  return D.23399;
  <D.22362>:
  D.23399 = 427;
  return D.23399;
  <D.22363>:
  D.23399 = 800;
  return D.23399;
  <D.22364>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "ssa.c", 137);
  D.23399 = -1;
  return D.23399;
}


unlink_unused_bblocks (struct MonoCompile * cfg)
{
  unsigned int D.23401;
  unsigned int D.23402;
  _Bool D.23403;
  long int D.23404;
  long int D.23405;
  unsigned int D.23408;
  _Bool D.23409;
  long int D.23410;
  long int D.23411;
  struct MonoBasicBlock * D.23414;
  unsigned int D.23415;
  unsigned int D.23416;
  struct MonoBasicBlock * D.23419;
  struct MonoBasicBlock * * D.23422;
  long unsigned int D.23423;
  long unsigned int D.23424;
  struct MonoBasicBlock * * D.23425;
  unsigned int D.23426;
  unsigned int D.23427;
  struct MonoBasicBlock * * D.23430;
  long unsigned int D.23431;
  long unsigned int D.23432;
  struct MonoBasicBlock * * D.23433;
  struct MonoBasicBlock * D.23434;
  short int D.23435;
  int D.23436;
  struct MonoBasicBlock * * D.23437;
  struct MonoBasicBlock * * D.23438;
  struct MonoBasicBlock * D.23439;
  short int D.23440;
  int D.23441;
  int D.23444;
  unsigned int i.17;
  unsigned int D.23446;
  int i;
  int j;
  struct MonoBasicBlock * bb;

  D.23401 = cfg->comp_done;
  D.23402 = D.23401 & 128;
  D.23403 = D.23402 == 0;
  D.23404 = (long int) D.23403;
  D.23405 = __builtin_expect (D.23404, 0);
  if (D.23405 != 0) goto <D.23406>; else goto <D.23407>;
  <D.23406>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 66, "cfg->comp_done & MONO_COMP_REACHABILITY");
  <D.23407>:
  D.23408 = cfg->verbose_level;
  D.23409 = D.23408 > 1;
  D.23410 = (long int) D.23409;
  D.23411 = __builtin_expect (D.23410, 0);
  if (D.23411 != 0) goto <D.23412>; else goto <D.23413>;
  <D.23412>:
  printf ("\nUNLINK UNUSED BBLOCKS:\n");
  <D.23413>:
  bb = cfg->bb_entry;
  goto <D.22329>;
  <D.22328>:
  D.23414 = bb->next_bb;
  D.23415 = D.23414->flags;
  D.23416 = D.23415 & 2;
  if (D.23416 == 0) goto <D.23417>; else goto <D.23418>;
  <D.23417>:
  D.23414 = bb->next_bb;
  D.23419 = D.23414->next_bb;
  bb->next_bb = D.23419;
  goto <D.23420>;
  <D.23418>:
  bb = bb->next_bb;
  <D.23420>:
  <D.22329>:
  if (bb != 0B) goto <D.23421>; else goto <D.22330>;
  <D.23421>:
  D.23414 = bb->next_bb;
  if (D.23414 != 0B) goto <D.22328>; else goto <D.22330>;
  <D.22330>:
  i = 1;
  goto <D.22338>;
  <D.22337>:
  D.23422 = cfg->bblocks;
  D.23423 = (long unsigned int) i;
  D.23424 = D.23423 * 8;
  D.23425 = D.23422 + D.23424;
  bb = *D.23425;
  D.23426 = bb->flags;
  D.23427 = D.23426 & 2;
  if (D.23427 == 0) goto <D.23428>; else goto <D.23429>;
  <D.23428>:
  j = 0;
  goto <D.22332>;
  <D.22331>:
  D.23430 = bb->in_bb;
  D.23431 = (long unsigned int) j;
  D.23432 = D.23431 * 8;
  D.23433 = D.23430 + D.23432;
  D.23434 = *D.23433;
  unlink_target (D.23434, bb);
  j = j + 1;
  <D.22332>:
  D.23435 = bb->in_count;
  D.23436 = (int) D.23435;
  if (D.23436 > j) goto <D.22331>; else goto <D.22333>;
  <D.22333>:
  j = 0;
  goto <D.22335>;
  <D.22334>:
  D.23437 = bb->out_bb;
  D.23431 = (long unsigned int) j;
  D.23432 = D.23431 * 8;
  D.23438 = D.23437 + D.23432;
  D.23439 = *D.23438;
  unlink_target (bb, D.23439);
  j = j + 1;
  <D.22335>:
  D.23440 = bb->out_count;
  D.23441 = (int) D.23440;
  if (D.23441 > j) goto <D.22334>; else goto <D.22336>;
  <D.22336>:
  D.23408 = cfg->verbose_level;
  D.23409 = D.23408 > 1;
  D.23410 = (long int) D.23409;
  D.23411 = __builtin_expect (D.23410, 0);
  if (D.23411 != 0) goto <D.23442>; else goto <D.23443>;
  <D.23442>:
  D.23444 = bb->block_num;
  printf ("\tUnlinked BB%d\n", D.23444);
  <D.23443>:
  <D.23429>:
  i = i + 1;
  <D.22338>:
  i.17 = (unsigned int) i;
  D.23446 = cfg->num_bblocks;
  if (i.17 < D.23446) goto <D.22337>; else goto <D.22339>;
  <D.22339>:
}


unlink_target (struct MonoBasicBlock * bb, struct MonoBasicBlock * target)
{
  struct MonoBasicBlock * * D.23447;
  long unsigned int D.23448;
  long unsigned int D.23449;
  struct MonoBasicBlock * * D.23450;
  struct MonoBasicBlock * D.23451;
  short int D.23454;
  unsigned short D.23455;
  unsigned short D.23456;
  short int D.23457;
  long unsigned int D.23458;
  long unsigned int D.23459;
  struct MonoBasicBlock * * D.23460;
  struct MonoBasicBlock * D.23461;
  int D.23462;
  struct MonoBasicBlock * * D.23463;
  struct MonoBasicBlock * * D.23464;
  struct MonoBasicBlock * D.23465;
  short int D.23468;
  unsigned short D.23469;
  unsigned short D.23470;
  short int D.23471;
  long unsigned int D.23472;
  long unsigned int D.23473;
  struct MonoBasicBlock * * D.23474;
  struct MonoBasicBlock * D.23475;
  int D.23476;
  int i;

  i = 0;
  goto <D.22318>;
  <D.22317>:
  D.23447 = bb->out_bb;
  D.23448 = (long unsigned int) i;
  D.23449 = D.23448 * 8;
  D.23450 = D.23447 + D.23449;
  D.23451 = *D.23450;
  if (D.23451 == target) goto <D.23452>; else goto <D.23453>;
  <D.23452>:
  D.23447 = bb->out_bb;
  D.23448 = (long unsigned int) i;
  D.23449 = D.23448 * 8;
  D.23450 = D.23447 + D.23449;
  D.23447 = bb->out_bb;
  D.23454 = bb->out_count;
  D.23455 = (unsigned short) D.23454;
  D.23456 = D.23455 + 65535;
  D.23457 = (short int) D.23456;
  bb->out_count = D.23457;
  D.23454 = bb->out_count;
  D.23458 = (long unsigned int) D.23454;
  D.23459 = D.23458 * 8;
  D.23460 = D.23447 + D.23459;
  D.23461 = *D.23460;
  *D.23450 = D.23461;
  goto <D.22316>;
  <D.23453>:
  i = i + 1;
  <D.22318>:
  D.23454 = bb->out_count;
  D.23462 = (int) D.23454;
  if (D.23462 > i) goto <D.22317>; else goto <D.22316>;
  <D.22316>:
  i = 0;
  goto <D.22321>;
  <D.22320>:
  D.23463 = target->in_bb;
  D.23448 = (long unsigned int) i;
  D.23449 = D.23448 * 8;
  D.23464 = D.23463 + D.23449;
  D.23465 = *D.23464;
  if (D.23465 == bb) goto <D.23466>; else goto <D.23467>;
  <D.23466>:
  D.23463 = target->in_bb;
  D.23448 = (long unsigned int) i;
  D.23449 = D.23448 * 8;
  D.23464 = D.23463 + D.23449;
  D.23463 = target->in_bb;
  D.23468 = target->in_count;
  D.23469 = (unsigned short) D.23468;
  D.23470 = D.23469 + 65535;
  D.23471 = (short int) D.23470;
  target->in_count = D.23471;
  D.23468 = target->in_count;
  D.23472 = (long unsigned int) D.23468;
  D.23473 = D.23472 * 8;
  D.23474 = D.23463 + D.23473;
  D.23475 = *D.23474;
  *D.23464 = D.23475;
  goto <D.22319>;
  <D.23467>:
  i = i + 1;
  <D.22321>:
  D.23468 = target->in_count;
  D.23476 = (int) D.23468;
  if (D.23476 > i) goto <D.22320>; else goto <D.22319>;
  <D.22319>:
}


mono_ssa_cprop (struct MonoCompile * cfg)
{
  unsigned int D.23477;
  long unsigned int D.23478;
  long unsigned int D.23479;
  unsigned int D.23480;
  unsigned int D.23481;
  struct MonoBasicBlock * D.23484;
  struct GList * bblock_list.18;
  unsigned int D.23486;
  unsigned int D.23487;
  unsigned int D.23488;
  long unsigned int D.23489;
  long unsigned int D.23490;
  struct MonoMethodVar * D.23491;
  long unsigned int D.23492;
  long unsigned int D.23493;
  struct MonoInst * D.23494;
  unsigned int i.19;
  unsigned int D.23498;
  struct GList * bblock_list.20;
  struct GList * bblock_list.21;
  unsigned int D.23503;
  unsigned int D.23504;
  _Bool D.23505;
  long int D.23506;
  long int D.23507;
  struct MonoInst * D.23511;
  short unsigned int D.23513;
  short unsigned int D.23514;
  short unsigned int D.23516;
  short unsigned int D.23518;
  struct MonoBasicBlock * * D.23522;
  long unsigned int D.23523;
  struct MonoBasicBlock * * D.23524;
  struct MonoBasicBlock * D.23525;
  short int D.23526;
  int D.23527;
  unsigned int D.23528;
  int D.23531;
  struct GList * cvars.22;
  struct GList * cvars.23;
  struct MonoBasicBlock * D.23534;
  unsigned int D.23535;
  unsigned int D.23536;
  struct MonoInst * D.23539;
  unsigned int D.23540;
  unsigned int D.23541;
  struct MonoInst * * carray;
  struct MonoBasicBlock * bb;
  struct GList * bblock_list;
  struct GList * cvars;
  struct GList * tmp;
  int i;

  try
    {
      D.23477 = cfg->next_vreg;
      D.23478 = (long unsigned int) D.23477;
      D.23479 = D.23478 * 8;
      carray = monoeg_malloc0 (D.23479);
      D.23480 = cfg->comp_done;
      D.23481 = D.23480 & 64;
      if (D.23481 == 0) goto <D.23482>; else goto <D.23483>;
      <D.23482>:
      mono_ssa_create_def_use (cfg);
      <D.23483>:
      D.23484 = cfg->bb_entry;
      bblock_list.18 = monoeg_g_list_prepend (0B, D.23484);
      bblock_list = bblock_list.18;
      D.23484 = cfg->bb_entry;
      D.23484 = cfg->bb_entry;
      D.23486 = D.23484->flags;
      D.23487 = D.23486 | 2;
      D.23484->flags = D.23487;
      D.23488 = cfg->num_varinfo;
      D.23489 = (long unsigned int) D.23488;
      D.23490 = D.23489 * 8;
      memset (carray, 0, D.23490);
      i = 0;
      goto <D.22688>;
      <D.22687>:
      {
        struct MonoMethodVar * info;

        D.23491 = cfg->vars;
        D.23492 = (long unsigned int) i;
        D.23493 = D.23492 * 80;
        info = D.23491 + D.23493;
        D.23494 = info->def;
        if (D.23494 == 0B) goto <D.23495>; else goto <D.23496>;
        <D.23495>:
        info->cpstate = 2;
        <D.23496>:
      }
      i = i + 1;
      <D.22688>:
      i.19 = (unsigned int) i;
      D.23488 = cfg->num_varinfo;
      if (i.19 < D.23488) goto <D.22687>; else goto <D.22689>;
      <D.22689>:
      D.23484 = cfg->bb_entry;
      bb = D.23484->next_bb;
      goto <D.22691>;
      <D.22690>:
      D.23498 = bb->region;
      if (D.23498 != 0) goto <D.23499>; else goto <D.23500>;
      <D.23499>:
      add_cprop_bb (cfg, bb, &bblock_list);
      <D.23500>:
      bb = bb->next_bb;
      <D.22691>:
      if (bb != 0B) goto <D.22690>; else goto <D.22692>;
      <D.22692>:
      cvars = 0B;
      goto <D.22710>;
      <D.22709>:
      {
        struct MonoInst * inst;

        bblock_list.20 = bblock_list;
        bb = bblock_list.20->data;
        bblock_list.20 = bblock_list;
        bblock_list.20 = bblock_list;
        bblock_list.21 = monoeg_g_list_delete_link (bblock_list.20, bblock_list.20);
        bblock_list = bblock_list.21;
        D.23503 = bb->flags;
        D.23504 = D.23503 & 2;
        D.23505 = D.23504 == 0;
        D.23506 = (long int) D.23505;
        D.23507 = __builtin_expect (D.23506, 0);
        if (D.23507 != 0) goto <D.23508>; else goto <D.23509>;
        <D.23508>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 1185, "bb->flags & BB_REACHABLE");
        <D.23509>:
        D.23511 = bb->last_ins;
        if (D.23511 == 0B) goto <D.23510>; else goto <D.23512>;
        <D.23512>:
        D.23511 = bb->last_ins;
        D.23513 = D.23511->opcode;
        D.23514 = D.23513 + 64985;
        if (D.23514 > 9) goto <D.23515>; else goto <D.22696>;
        <D.23515>:
        D.23511 = bb->last_ins;
        D.23513 = D.23511->opcode;
        D.23516 = D.23513 + 64878;
        if (D.23516 > 9) goto <D.23517>; else goto <D.22696>;
        <D.23517>:
        D.23511 = bb->last_ins;
        D.23513 = D.23511->opcode;
        D.23518 = D.23513 + 64888;
        if (D.23518 > 9) goto <D.23519>; else goto <D.22696>;
        <D.23519>:
        D.23511 = bb->last_ins;
        D.23513 = D.23511->opcode;
        if (D.23513 != 442) goto <D.23520>; else goto <D.22696>;
        <D.23520>:
        D.23511 = bb->last_ins;
        D.23513 = D.23511->opcode;
        if (D.23513 != 759) goto <D.23521>; else goto <D.22696>;
        <D.23521>:
        D.23511 = bb->last_ins;
        D.23513 = D.23511->opcode;
        if (D.23513 != 370) goto <D.23510>; else goto <D.22696>;
        <D.23510>:
        i = 0;
        goto <D.22695>;
        <D.22694>:
        D.23522 = bb->out_bb;
        D.23492 = (long unsigned int) i;
        D.23523 = D.23492 * 8;
        D.23524 = D.23522 + D.23523;
        D.23525 = *D.23524;
        add_cprop_bb (cfg, D.23525, &bblock_list);
        i = i + 1;
        <D.22695>:
        D.23526 = bb->out_count;
        D.23527 = (int) D.23526;
        if (D.23527 > i) goto <D.22694>; else goto <D.22696>;
        <D.22696>:
        D.23528 = cfg->verbose_level;
        if (D.23528 > 1) goto <D.23529>; else goto <D.23530>;
        <D.23529>:
        D.23531 = bb->block_num;
        printf ("\nSSA CONSPROP BB%d:\n", D.23531);
        <D.23530>:
        inst = bb->code;
        goto <D.22698>;
        <D.22697>:
        visit_inst (cfg, bb, inst, &cvars, &bblock_list, carray);
        inst = inst->next;
        <D.22698>:
        if (inst != 0B) goto <D.22697>; else goto <D.22699>;
        <D.22699>:
        goto <D.22707>;
        <D.22706>:
        {
          struct MonoMethodVar * info;

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

            ui = tmp->data;
            D.23534 = ui->bb;
            D.23535 = D.23534->flags;
            D.23536 = D.23535 & 2;
            if (D.23536 == 0) goto <D.23537>; else goto <D.23538>;
            <D.23537>:
            // predicted unlikely by continue predictor.
            goto <D.22702>;
            <D.23538>:
            D.23534 = ui->bb;
            D.23539 = ui->inst;
            visit_inst (cfg, D.23534, D.23539, &cvars, &bblock_list, carray);
          }
          <D.22702>:
          tmp = tmp->next;
          <D.22704>:
          if (tmp != 0B) goto <D.22703>; else goto <D.22705>;
          <D.22705>:
        }
        <D.22707>:
        cvars.22 = cvars;
        if (cvars.22 != 0B) goto <D.22706>; else goto <D.22708>;
        <D.22708>:
      }
      <D.22710>:
      bblock_list.20 = bblock_list;
      if (bblock_list.20 != 0B) goto <D.22709>; else goto <D.22711>;
      <D.22711>:
      D.23484 = cfg->bb_entry;
      bb = D.23484->next_bb;
      goto <D.22717>;
      <D.22716>:
      {
        struct MonoInst * inst;

        inst = bb->code;
        goto <D.22714>;
        <D.22713>:
        fold_ins (cfg, bb, inst, carray);
        inst = inst->next;
        <D.22714>:
        if (inst != 0B) goto <D.22713>; else goto <D.22715>;
        <D.22715>:
      }
      bb = bb->next_bb;
      <D.22717>:
      if (bb != 0B) goto <D.22716>; else goto <D.22718>;
      <D.22718>:
      monoeg_g_free (carray);
      D.23480 = cfg->comp_done;
      D.23540 = D.23480 | 128;
      cfg->comp_done = D.23540;
      D.23480 = cfg->comp_done;
      D.23541 = D.23480 & 4294967231;
      cfg->comp_done = D.23541;
      i = 0;
      goto <D.22721>;
      <D.22720>:
      {
        struct MonoMethodVar * info;

        D.23491 = cfg->vars;
        D.23492 = (long unsigned int) i;
        D.23493 = D.23492 * 80;
        info = D.23491 + D.23493;
        info->def = 0B;
        info->uses = 0B;
      }
      i = i + 1;
      <D.22721>:
      i.19 = (unsigned int) i;
      D.23488 = cfg->num_varinfo;
      if (i.19 < D.23488) goto <D.22720>; else goto <D.22722>;
      <D.22722>:
    }
  finally
    {
      bblock_list = {CLOBBER};
      cvars = {CLOBBER};
    }
}


mono_ssa_create_def_use (struct MonoCompile * cfg)
{
  unsigned int D.23542;
  unsigned int D.23543;
  _Bool D.23544;
  long int D.23545;
  long int D.23546;
  short unsigned int D.23549;
  int D.23550;
  int D.23551;
  int D.23552;
  int D.23555;
  int D.23556;
  int D.23557;
  signed char D.23558;
  struct MonoInst * iftmp.24;
  int D.23560;
  unsigned int D.23561;
  unsigned int D.23562;
  struct MonoInst * * D.23565;
  long unsigned int D.23566;
  long unsigned int D.23567;
  struct MonoInst * * D.23568;
  unsigned char D.23572;
  int D.23573;
  int D.23574;
  short unsigned int D.23577;
  struct MonoInst * iftmp.25;
  int D.23581;
  unsigned int D.23582;
  long unsigned int D.23585;
  long unsigned int D.23586;
  struct MonoInst * * D.23587;
  unsigned char D.23591;
  int D.23592;
  int D.23593;
  short unsigned int D.23596;
  int * D.23599;
  long unsigned int D.23600;
  long unsigned int D.23601;
  int * D.23602;
  int D.23603;
  _Bool D.23604;
  long int D.23605;
  long int D.23606;
  struct MonoInst * iftmp.26;
  unsigned int D.23610;
  long unsigned int D.23613;
  long unsigned int D.23614;
  struct MonoInst * * D.23615;
  char D.23617;
  struct MonoInst * iftmp.27;
  unsigned char D.23628;
  int D.23629;
  int D.23630;
  struct MonoMethodVar * D.23633;
  long int D.23634;
  long unsigned int D.23635;
  long unsigned int D.23636;
  unsigned int D.23637;
  struct MonoBasicBlock * bb;
  struct MonoInst * ins;
  int i;

  D.23542 = cfg->comp_done;
  D.23543 = D.23542 & 64;
  D.23544 = D.23543 != 0;
  D.23545 = (long int) D.23544;
  D.23546 = __builtin_expect (D.23545, 0);
  if (D.23546 != 0) goto <D.23547>; else goto <D.23548>;
  <D.23547>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 619, "!(cfg->comp_done & MONO_COMP_SSA_DEF_USE)");
  <D.23548>:
  bb = cfg->bb_entry;
  goto <D.22550>;
  <D.22549>:
  ins = bb->code;
  goto <D.22547>;
  <D.22546>:
  {
    const char * spec;
    struct MonoMethodVar * info;
    int num_sregs;
    int sregs[3];

    try
      {
        D.23549 = ins->opcode;
        D.23550 = (int) D.23549;
        D.23551 = D.23550 + -313;
        D.23552 = D.23551 * 4;
        spec = &ins_info[D.23552];
        D.23549 = ins->opcode;
        if (D.23549 == 316) goto <D.23553>; else goto <D.23554>;
        <D.23553>:
        // predicted unlikely by continue predictor.
        goto <D.22536>;
        <D.23554>:
        D.23555 = ins->sreg1;
        sregs[0] = D.23555;
        D.23556 = ins->sreg2;
        sregs[1] = D.23556;
        D.23557 = ins->sreg3;
        sregs[2] = D.23557;
        D.23549 = ins->opcode;
        D.23550 = (int) D.23549;
        D.23551 = D.23550 + -313;
        D.23558 = ins_sreg_counts[D.23551];
        num_sregs = (int) D.23558;
        i = 0;
        goto <D.22539>;
        <D.22538>:
        {
          struct MonoInst * var;

          D.23560 = sregs[i];
          D.23561 = (unsigned int) D.23560;
          D.23562 = cfg->vreg_to_inst_len;
          if (D.23561 < D.23562) goto <D.23563>; else goto <D.23564>;
          <D.23563>:
          D.23565 = cfg->vreg_to_inst;
          D.23560 = sregs[i];
          D.23566 = (long unsigned int) D.23560;
          D.23567 = D.23566 * 8;
          D.23568 = D.23565 + D.23567;
          iftmp.24 = *D.23568;
          goto <D.23569>;
          <D.23564>:
          iftmp.24 = 0B;
          <D.23569>:
          var = iftmp.24;
          if (var != 0B) goto <D.23570>; else goto <D.23571>;
          <D.23570>:
          D.23572 = var->flags;
          D.23573 = (int) D.23572;
          D.23574 = D.23573 & 20;
          if (D.23574 == 0) goto <D.23575>; else goto <D.23576>;
          <D.23575>:
          record_use (cfg, var, bb, ins);
          <D.23576>:
          <D.23571>:
        }
        i = i + 1;
        <D.22539>:
        if (i < num_sregs) goto <D.22538>; else goto <D.22540>;
        <D.22540>:
        D.23549 = ins->opcode;
        D.23577 = D.23549 + 65162;
        if (D.23577 <= 13) goto <D.23578>; else goto <D.23579>;
        <D.23578>:
        {
          struct MonoInst * var;

          D.23581 = ins->dreg;
          D.23582 = (unsigned int) D.23581;
          D.23562 = cfg->vreg_to_inst_len;
          if (D.23582 < D.23562) goto <D.23583>; else goto <D.23584>;
          <D.23583>:
          D.23565 = cfg->vreg_to_inst;
          D.23581 = ins->dreg;
          D.23585 = (long unsigned int) D.23581;
          D.23586 = D.23585 * 8;
          D.23587 = D.23565 + D.23586;
          iftmp.25 = *D.23587;
          goto <D.23588>;
          <D.23584>:
          iftmp.25 = 0B;
          <D.23588>:
          var = iftmp.25;
          if (var != 0B) goto <D.23589>; else goto <D.23590>;
          <D.23589>:
          D.23591 = var->flags;
          D.23592 = (int) D.23591;
          D.23593 = D.23592 & 20;
          if (D.23593 == 0) goto <D.23594>; else goto <D.23595>;
          <D.23594>:
          record_use (cfg, var, bb, ins);
          <D.23595>:
          <D.23590>:
        }
        <D.23579>:
        D.23549 = ins->opcode;
        D.23596 = D.23549 + 65217;
        if (D.23596 <= 2) goto <D.23597>; else goto <D.23598>;
        <D.23597>:
        D.23599 = ins->data.op[1].phi_args;
        i = *D.23599;
        goto <D.22543>;
        <D.22542>:
        D.23599 = ins->data.op[1].phi_args;
        D.23600 = (long unsigned int) i;
        D.23601 = D.23600 * 4;
        D.23602 = D.23599 + D.23601;
        D.23603 = *D.23602;
        D.23604 = D.23603 == -1;
        D.23605 = (long int) D.23604;
        D.23606 = __builtin_expect (D.23605, 0);
        if (D.23606 != 0) goto <D.23607>; else goto <D.23608>;
        <D.23607>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 647, "ins->inst_phi_args [i] != -1");
        <D.23608>:
        D.23599 = ins->data.op[1].phi_args;
        D.23600 = (long unsigned int) i;
        D.23601 = D.23600 * 4;
        D.23602 = D.23599 + D.23601;
        D.23603 = *D.23602;
        D.23610 = (unsigned int) D.23603;
        D.23562 = cfg->vreg_to_inst_len;
        if (D.23610 < D.23562) goto <D.23611>; else goto <D.23612>;
        <D.23611>:
        D.23565 = cfg->vreg_to_inst;
        D.23599 = ins->data.op[1].phi_args;
        D.23600 = (long unsigned int) i;
        D.23601 = D.23600 * 4;
        D.23602 = D.23599 + D.23601;
        D.23603 = *D.23602;
        D.23613 = (long unsigned int) D.23603;
        D.23614 = D.23613 * 8;
        D.23615 = D.23565 + D.23614;
        iftmp.26 = *D.23615;
        goto <D.23616>;
        <D.23612>:
        iftmp.26 = 0B;
        <D.23616>:
        record_use (cfg, iftmp.26, bb, ins);
        i = i + -1;
        <D.22543>:
        if (i > 0) goto <D.22542>; else goto <D.22544>;
        <D.22544>:
        <D.23598>:
        D.23617 = *spec;
        if (D.23617 != 32) goto <D.23618>; else goto <D.23619>;
        <D.23618>:
        D.23549 = ins->opcode;
        D.23577 = D.23549 + 65162;
        if (D.23577 > 13) goto <D.23620>; else goto <D.23621>;
        <D.23620>:
        {
          struct MonoInst * var;

          D.23581 = ins->dreg;
          D.23582 = (unsigned int) D.23581;
          D.23562 = cfg->vreg_to_inst_len;
          if (D.23582 < D.23562) goto <D.23623>; else goto <D.23624>;
          <D.23623>:
          D.23565 = cfg->vreg_to_inst;
          D.23581 = ins->dreg;
          D.23585 = (long unsigned int) D.23581;
          D.23586 = D.23585 * 8;
          D.23587 = D.23565 + D.23586;
          iftmp.27 = *D.23587;
          goto <D.23625>;
          <D.23624>:
          iftmp.27 = 0B;
          <D.23625>:
          var = iftmp.27;
          if (var != 0B) goto <D.23626>; else goto <D.23627>;
          <D.23626>:
          D.23628 = var->flags;
          D.23629 = (int) D.23628;
          D.23630 = D.23629 & 20;
          if (D.23630 == 0) goto <D.23631>; else goto <D.23632>;
          <D.23631>:
          D.23633 = cfg->vars;
          D.23634 = var->data.op[0].const_val;
          D.23635 = (long unsigned int) D.23634;
          D.23636 = D.23635 * 80;
          info = D.23633 + D.23636;
          info->def = ins;
          info->def_bb = bb;
          <D.23632>:
          <D.23627>:
        }
        <D.23621>:
        <D.23619>:
      }
    finally
      {
        sregs = {CLOBBER};
      }
  }
  <D.22536>:
  ins = ins->next;
  <D.22547>:
  if (ins != 0B) goto <D.22546>; else goto <D.22548>;
  <D.22548>:
  bb = bb->next_bb;
  <D.22550>:
  if (bb != 0B) goto <D.22549>; else goto <D.22551>;
  <D.22551>:
  D.23542 = cfg->comp_done;
  D.23637 = D.23542 | 64;
  cfg->comp_done = D.23637;
}


add_cprop_bb (struct MonoCompile * cfg, struct MonoBasicBlock * bb, struct GList * * bblist)
{
  unsigned int D.23640;
  _Bool D.23641;
  long int D.23642;
  long int D.23643;
  int D.23646;
  unsigned int D.23647;
  unsigned int D.23648;
  unsigned int D.23651;
  struct GList * D.23652;
  struct GList * D.23653;

  D.23640 = cfg->verbose_level;
  D.23641 = D.23640 > 1;
  D.23642 = (long int) D.23641;
  D.23643 = __builtin_expect (D.23642, 0);
  if (D.23643 != 0) goto <D.23644>; else goto <D.23645>;
  <D.23644>:
  D.23646 = bb->block_num;
  printf ("\tAdd BB%d to worklist\n", D.23646);
  <D.23645>:
  D.23647 = bb->flags;
  D.23648 = D.23647 & 2;
  if (D.23648 == 0) goto <D.23649>; else goto <D.23650>;
  <D.23649>:
  D.23647 = bb->flags;
  D.23651 = D.23647 | 2;
  bb->flags = D.23651;
  D.23652 = *bblist;
  D.23653 = monoeg_g_list_prepend (D.23652, bb);
  *bblist = D.23653;
  <D.23650>:
}


visit_inst (struct MonoCompile * cfg, struct MonoBasicBlock * bb, struct MonoInst * ins, struct GList * * cvars, struct GList * * bblist, struct MonoInst * * carray)
{
  short unsigned int D.23654;
  int D.23655;
  int D.23656;
  int D.23657;
  unsigned int D.23660;
  short unsigned int D.23663;
  struct MonoMethodVar * D.23666;
  struct MonoInst * iftmp.28;
  int D.23668;
  unsigned int D.23669;
  unsigned int D.23670;
  struct MonoInst * * D.23673;
  long unsigned int D.23674;
  long unsigned int D.23675;
  struct MonoInst * * D.23676;
  long int D.23678;
  long unsigned int D.23679;
  long unsigned int D.23680;
  struct MonoInst * iftmp.29;
  int * D.23682;
  long unsigned int D.23683;
  long unsigned int D.23684;
  int * D.23685;
  int D.23686;
  unsigned int D.23687;
  long unsigned int D.23690;
  long unsigned int D.23691;
  struct MonoInst * * D.23692;
  long int D.23694;
  long unsigned int D.23695;
  long unsigned int D.23696;
  struct MonoBasicBlock * D.23697;
  unsigned int D.23700;
  unsigned int D.23701;
  struct MonoInst * D.23706;
  char D.23709;
  int D.23712;
  long unsigned int D.23713;
  long unsigned int D.23714;
  struct MonoInst * * D.23715;
  struct MonoInst * D.23716;
  _Bool D.23717;
  long int D.23718;
  long int D.23719;
  short unsigned int D.23724;
  long int D.23727;
  long int D.23728;
  int D.23731;
  char D.23734;
  _Bool D.23737;
  long int D.23738;
  long int D.23739;
  short unsigned int D.23746;
  const char * D.23748;
  char D.23749;
  const char * D.23751;
  char D.23752;
  char D.23754;
  struct MonoInst * iftmp.30;
  unsigned char D.23765;
  int D.23766;
  int D.23767;
  long int D.23769;
  long unsigned int D.23770;
  long unsigned int D.23771;
  char D.23772;
  struct MonoInst * c0.31;
  struct MonoInst * * D.23787;
  struct MonoInst * D.23789;
  struct GList * D.23792;
  struct GList * D.23793;
  struct GList * D.23796;
  struct MonoInst * D.23802;
  struct MonoInst * D.23805;
  struct MonoJumpInfoBBTable * iftmp.32;
  struct MonoJumpInfoBBTable * iftmp.33;
  struct MonoJumpInfoBBTable * iftmp.34;
  struct MonoJumpInfoBBTable * iftmp.35;
  struct MonoInst * D.23826;
  short unsigned int D.23828;
  struct MonoBasicBlock * * D.23829;
  long unsigned int D.23830;
  long unsigned int D.23831;
  struct MonoBasicBlock * * D.23832;
  struct MonoBasicBlock * D.23833;
  int D.23836;
  _Bool D.23837;
  long int D.23838;
  long int D.23839;
  int D.23842;
  _Bool D.23843;
  long int D.23844;
  long int D.23845;
  int D.23848;
  long unsigned int D.23849;
  long unsigned int D.23850;
  struct MonoInst * * D.23851;
  struct MonoInst * D.23852;
  long int D.23855;
  long int D.23856;
  long unsigned int D.23860;
  long unsigned int D.23861;
  struct MonoBasicBlock * * D.23862;
  struct MonoBasicBlock * D.23863;
  struct MonoBasicBlock * * D.23871;
  long unsigned int D.23872;
  long unsigned int D.23873;
  struct MonoBasicBlock * * D.23874;
  struct MonoBasicBlock * D.23875;
  int D.23878;
  short unsigned int D.23883;
  short unsigned int D.23885;
  short unsigned int D.23887;
  short unsigned int D.23890;
  _Bool D.23891;
  long int D.23892;
  long int D.23893;
  long int D.23896;
  unsigned char D.23899;
  unsigned char D.23900;
  unsigned char D.23902;
  unsigned char D.23904;
  struct MonoBasicBlock * D.23907;
  short unsigned int D.23911;
  short unsigned int D.23913;
  short unsigned int D.23915;
  unsigned char D.23916;
  int D.23917;
  int D.23918;
  struct MonoBasicBlock * * D.23921;
  struct MonoBasicBlock * D.23922;
  int D.23924;
  struct MonoBasicBlock * * D.23927;
  struct MonoBasicBlock * D.23928;
  const char * spec;

  D.23654 = ins->opcode;
  D.23655 = (int) D.23654;
  D.23656 = D.23655 + -313;
  D.23657 = D.23656 * 4;
  spec = &ins_info[D.23657];
  D.23654 = ins->opcode;
  if (D.23654 == 316) goto <D.23658>; else goto <D.23659>;
  <D.23658>:
  return;
  <D.23659>:
  D.23660 = cfg->verbose_level;
  if (D.23660 > 1) goto <D.23661>; else goto <D.23662>;
  <D.23661>:
  mono_print_ins (ins);
  <D.23662>:
  D.23654 = ins->opcode;
  D.23663 = D.23654 + 65217;
  if (D.23663 <= 2) goto <D.23664>; else goto <D.23665>;
  <D.23664>:
  {
    struct MonoMethodVar * info;
    struct MonoInst * c0;
    int j;

    D.23666 = cfg->vars;
    D.23668 = ins->dreg;
    D.23669 = (unsigned int) D.23668;
    D.23670 = cfg->vreg_to_inst_len;
    if (D.23669 < D.23670) goto <D.23671>; else goto <D.23672>;
    <D.23671>:
    D.23673 = cfg->vreg_to_inst;
    D.23668 = ins->dreg;
    D.23674 = (long unsigned int) D.23668;
    D.23675 = D.23674 * 8;
    D.23676 = D.23673 + D.23675;
    iftmp.28 = *D.23676;
    goto <D.23677>;
    <D.23672>:
    iftmp.28 = 0B;
    <D.23677>:
    D.23678 = iftmp.28->data.op[0].const_val;
    D.23679 = (long unsigned int) D.23678;
    D.23680 = D.23679 * 80;
    info = D.23666 + D.23680;
    c0 = 0B;
    j = 1;
    goto <D.22640>;
    <D.22639>:
    {
      struct MonoInst * var;
      struct MonoMethodVar * mv;
      struct MonoInst * src;

      D.23682 = ins->data.op[1].phi_args;
      D.23683 = (long unsigned int) j;
      D.23684 = D.23683 * 4;
      D.23685 = D.23682 + D.23684;
      D.23686 = *D.23685;
      D.23687 = (unsigned int) D.23686;
      D.23670 = cfg->vreg_to_inst_len;
      if (D.23687 < D.23670) goto <D.23688>; else goto <D.23689>;
      <D.23688>:
      D.23673 = cfg->vreg_to_inst;
      D.23682 = ins->data.op[1].phi_args;
      D.23683 = (long unsigned int) j;
      D.23684 = D.23683 * 4;
      D.23685 = D.23682 + D.23684;
      D.23686 = *D.23685;
      D.23690 = (long unsigned int) D.23686;
      D.23691 = D.23690 * 8;
      D.23692 = D.23673 + D.23691;
      iftmp.29 = *D.23692;
      goto <D.23693>;
      <D.23689>:
      iftmp.29 = 0B;
      <D.23693>:
      var = iftmp.29;
      D.23666 = cfg->vars;
      D.23694 = var->data.op[0].const_val;
      D.23695 = (long unsigned int) D.23694;
      D.23696 = D.23695 * 80;
      mv = D.23666 + D.23696;
      src = mv->def;
      D.23697 = mv->def_bb;
      if (D.23697 != 0B) goto <D.23698>; else goto <D.23699>;
      <D.23698>:
      D.23697 = mv->def_bb;
      D.23700 = D.23697->flags;
      D.23701 = D.23700 & 2;
      if (D.23701 == 0) goto <D.23702>; else goto <D.23703>;
      <D.23702>:
      // predicted unlikely by continue predictor.
      goto <D.22637>;
      <D.23703>:
      <D.23699>:
      D.23706 = mv->def;
      if (D.23706 == 0B) goto <D.23704>; else goto <D.23707>;
      <D.23707>:
      if (src == 0B) goto <D.23704>; else goto <D.23708>;
      <D.23708>:
      D.23709 = mv->cpstate;
      if (D.23709 == 2) goto <D.23704>; else goto <D.23705>;
      <D.23704>:
      change_varstate (cfg, cvars, info, 2, 0B, carray);
      goto <D.22638>;
      <D.23705>:
      D.23709 = mv->cpstate;
      if (D.23709 == 0) goto <D.23710>; else goto <D.23711>;
      <D.23710>:
      // predicted unlikely by continue predictor.
      goto <D.22637>;
      <D.23711>:
      D.23712 = var->dreg;
      D.23713 = (long unsigned int) D.23712;
      D.23714 = D.23713 * 8;
      D.23715 = carray + D.23714;
      D.23716 = *D.23715;
      D.23717 = D.23716 == 0B;
      D.23718 = (long int) D.23717;
      D.23719 = __builtin_expect (D.23718, 0);
      if (D.23719 != 0) goto <D.23720>; else goto <D.23721>;
      <D.23720>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 873, "carray [var->dreg]");
      <D.23721>:
      if (c0 == 0B) goto <D.23722>; else goto <D.23723>;
      <D.23722>:
      D.23712 = var->dreg;
      D.23713 = (long unsigned int) D.23712;
      D.23714 = D.23713 * 8;
      D.23715 = carray + D.23714;
      c0 = *D.23715;
      <D.23723>:
      D.23724 = c0->opcode;
      if (D.23724 != 362) goto <D.23725>; else goto <D.23726>;
      <D.23725>:
      change_varstate (cfg, cvars, info, 2, 0B, carray);
      goto <D.22638>;
      <D.23726>:
      D.23712 = var->dreg;
      D.23713 = (long unsigned int) D.23712;
      D.23714 = D.23713 * 8;
      D.23715 = carray + D.23714;
      D.23716 = *D.23715;
      D.23727 = D.23716->data.op[0].const_val;
      D.23728 = c0->data.op[0].const_val;
      if (D.23727 != D.23728) goto <D.23729>; else goto <D.23730>;
      <D.23729>:
      change_varstate (cfg, cvars, info, 2, 0B, carray);
      goto <D.22638>;
      <D.23730>:
    }
    <D.22637>:
    j = j + 1;
    <D.22640>:
    D.23682 = ins->data.op[1].phi_args;
    D.23731 = *D.23682;
    if (D.23731 >= j) goto <D.22639>; else goto <D.22638>;
    <D.22638>:
    if (c0 != 0B) goto <D.23732>; else goto <D.23733>;
    <D.23732>:
    D.23734 = info->cpstate;
    if (D.23734 == 0) goto <D.23735>; else goto <D.23736>;
    <D.23735>:
    change_varstate (cfg, cvars, info, 1, c0, carray);
    D.23724 = c0->opcode;
    D.23737 = D.23724 != 362;
    D.23738 = (long int) D.23737;
    D.23739 = __builtin_expect (D.23738, 0);
    if (D.23739 != 0) goto <D.23740>; else goto <D.23741>;
    <D.23740>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 893, "c0->opcode == OP_ICONST");
    <D.23741>:
    <D.23736>:
    <D.23733>:
  }
  goto <D.23742>;
  <D.23665>:
  D.23654 = ins->opcode;
  D.23746 = D.23654 + 65162;
  if (D.23746 > 13) goto <D.23747>; else goto <D.23743>;
  <D.23747>:
  D.23748 = spec + 1;
  D.23749 = *D.23748;
  if (D.23749 != 32) goto <D.23744>; else goto <D.23750>;
  <D.23750>:
  D.23751 = spec + 2;
  D.23752 = *D.23751;
  if (D.23752 != 32) goto <D.23744>; else goto <D.23753>;
  <D.23753>:
  D.23754 = *spec;
  if (D.23754 != 32) goto <D.23744>; else goto <D.23743>;
  <D.23744>:
  {
    struct MonoInst * var;
    struct MonoInst * c0;
    int state;

    try
      {
        D.23754 = *spec;
        if (D.23754 != 32) goto <D.23755>; else goto <D.23756>;
        <D.23755>:
        D.23668 = ins->dreg;
        D.23669 = (unsigned int) D.23668;
        D.23670 = cfg->vreg_to_inst_len;
        if (D.23669 < D.23670) goto <D.23758>; else goto <D.23759>;
        <D.23758>:
        D.23673 = cfg->vreg_to_inst;
        D.23668 = ins->dreg;
        D.23674 = (long unsigned int) D.23668;
        D.23675 = D.23674 * 8;
        D.23676 = D.23673 + D.23675;
        iftmp.30 = *D.23676;
        goto <D.23760>;
        <D.23759>:
        iftmp.30 = 0B;
        <D.23760>:
        var = iftmp.30;
        goto <D.23761>;
        <D.23756>:
        var = 0B;
        <D.23761>:
        c0 = 0B;
        state = evaluate_ins (cfg, ins, &c0, carray);
        if (var != 0B) goto <D.23764>; else goto <D.23762>;
        <D.23764>:
        D.23765 = var->flags;
        D.23766 = (int) D.23765;
        D.23767 = D.23766 & 20;
        if (D.23767 == 0) goto <D.23768>; else goto <D.23762>;
        <D.23768>:
        {
          struct MonoMethodVar * info;

          D.23666 = cfg->vars;
          D.23769 = var->data.op[0].const_val;
          D.23770 = (long unsigned int) D.23769;
          D.23771 = D.23770 * 80;
          info = D.23666 + D.23771;
          D.23772 = info->cpstate;
          if (D.23772 <= 1) goto <D.23773>; else goto <D.23774>;
          <D.23773>:
          if (state == 1) goto <D.23775>; else goto <D.23776>;
          <D.23775>:
          c0.31 = c0;
          change_varstate (cfg, cvars, info, 1, c0.31, carray);
          goto <D.23778>;
          <D.23776>:
          if (state == 2) goto <D.23779>; else goto <D.23780>;
          <D.23779>:
          change_varstate (cfg, cvars, info, 2, 0B, carray);
          <D.23780>:
          <D.23778>:
          <D.23774>:
        }
        goto <D.23763>;
        <D.23762>:
        if (var == 0B) goto <D.23781>; else goto <D.23782>;
        <D.23781>:
        D.23668 = ins->dreg;
        if (D.23668 != -1) goto <D.23783>; else goto <D.23784>;
        <D.23783>:
        c0.31 = c0;
        if (c0.31 != 0B) goto <D.23785>; else goto <D.23786>;
        <D.23785>:
        D.23668 = ins->dreg;
        D.23674 = (long unsigned int) D.23668;
        D.23675 = D.23674 * 8;
        D.23787 = carray + D.23675;
        c0.31 = c0;
        *D.23787 = c0.31;
        goto <D.23788>;
        <D.23786>:
        D.23668 = ins->dreg;
        D.23674 = (long unsigned int) D.23668;
        D.23675 = D.23674 * 8;
        D.23787 = carray + D.23675;
        D.23789 = *D.23787;
        if (D.23789 != 0B) goto <D.23790>; else goto <D.23791>;
        <D.23790>:
        D.23668 = ins->dreg;
        D.23674 = (long unsigned int) D.23668;
        D.23675 = D.23674 * 8;
        D.23787 = carray + D.23675;
        *D.23787 = 0B;
        D.23792 = *bblist;
        D.23793 = monoeg_g_list_find (D.23792, bb);
        if (D.23793 == 0B) goto <D.23794>; else goto <D.23795>;
        <D.23794>:
        D.23792 = *bblist;
        D.23796 = monoeg_g_list_prepend (D.23792, bb);
        *bblist = D.23796;
        <D.23795>:
        <D.23791>:
        <D.23788>:
        <D.23784>:
        <D.23782>:
        <D.23763>:
        D.23654 = ins->opcode;
        if (D.23654 == 731) goto <D.23797>; else goto <D.23800>;
        <D.23800>:
        D.23654 = ins->opcode;
        if (D.23654 == 732) goto <D.23801>; else goto <D.23798>;
        <D.23801>:
        D.23802 = ins->data.op[1].src;
        if (D.23802 == 8B) goto <D.23797>; else goto <D.23798>;
        <D.23798>:
        D.23654 = ins->opcode;
        if (D.23654 == 370) goto <D.23797>; else goto <D.23803>;
        <D.23803>:
        D.23654 = ins->opcode;
        if (D.23654 == 734) goto <D.23804>; else goto <D.23799>;
        <D.23804>:
        D.23802 = ins->data.op[1].src;
        D.23805 = D.23802->data.op[1].src;
        if (D.23805 == 8B) goto <D.23797>; else goto <D.23799>;
        <D.23797>:
        {
          int i;
          struct MonoJumpInfoBBTable * table;

          D.23654 = ins->opcode;
          if (D.23654 == 731) goto <D.23807>; else goto <D.23808>;
          <D.23807>:
          iftmp.32 = ins->data.op[0].p;
          goto <D.23809>;
          <D.23808>:
          D.23654 = ins->opcode;
          if (D.23654 == 732) goto <D.23813>; else goto <D.23811>;
          <D.23813>:
          D.23802 = ins->data.op[1].src;
          if (D.23802 == 8B) goto <D.23814>; else goto <D.23811>;
          <D.23814>:
          iftmp.33 = ins->data.op[0].p;
          goto <D.23812>;
          <D.23811>:
          D.23654 = ins->opcode;
          if (D.23654 == 370) goto <D.23816>; else goto <D.23817>;
          <D.23816>:
          iftmp.34 = ins->data.op[0].p;
          goto <D.23818>;
          <D.23817>:
          D.23654 = ins->opcode;
          if (D.23654 == 734) goto <D.23822>; else goto <D.23820>;
          <D.23822>:
          D.23802 = ins->data.op[1].src;
          D.23805 = D.23802->data.op[1].src;
          if (D.23805 == 8B) goto <D.23823>; else goto <D.23820>;
          <D.23823>:
          D.23802 = ins->data.op[1].src;
          iftmp.35 = D.23802->data.op[0].p;
          goto <D.23821>;
          <D.23820>:
          iftmp.35 = 0B;
          <D.23821>:
          iftmp.34 = iftmp.35;
          <D.23818>:
          iftmp.33 = iftmp.34;
          <D.23812>:
          iftmp.32 = iftmp.33;
          <D.23809>:
          table = iftmp.32;
          D.23826 = ins->next;
          if (D.23826 == 0B) goto <D.23824>; else goto <D.23827>;
          <D.23827>:
          D.23826 = ins->next;
          D.23828 = D.23826->opcode;
          if (D.23828 != 479) goto <D.23824>; else goto <D.23825>;
          <D.23824>:
          i = 0;
          goto <D.22648>;
          <D.22647>:
          D.23829 = table->table;
          D.23830 = (long unsigned int) i;
          D.23831 = D.23830 * 8;
          D.23832 = D.23829 + D.23831;
          D.23833 = *D.23832;
          if (D.23833 != 0B) goto <D.23834>; else goto <D.23835>;
          <D.23834>:
          D.23829 = table->table;
          D.23830 = (long unsigned int) i;
          D.23831 = D.23830 * 8;
          D.23832 = D.23829 + D.23831;
          D.23833 = *D.23832;
          add_cprop_bb (cfg, D.23833, bblist);
          <D.23835>:
          i = i + 1;
          <D.22648>:
          D.23836 = table->table_size;
          if (D.23836 > i) goto <D.22647>; else goto <D.22649>;
          <D.22649>:
          return;
          <D.23825>:
          D.23826 = ins->next;
          D.23828 = D.23826->opcode;
          D.23837 = D.23828 != 479;
          D.23838 = (long int) D.23837;
          D.23839 = __builtin_expect (D.23838, 0);
          if (D.23839 != 0) goto <D.23840>; else goto <D.23841>;
          <D.23840>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 955, "ins->next->opcode == OP_PADD");
          <D.23841>:
          D.23826 = ins->next;
          D.23842 = D.23826->sreg1;
          D.23668 = ins->dreg;
          D.23843 = D.23842 != D.23668;
          D.23844 = (long int) D.23843;
          D.23845 = __builtin_expect (D.23844, 0);
          if (D.23845 != 0) goto <D.23846>; else goto <D.23847>;
          <D.23846>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 956, "ins->next->sreg1 == ins->dreg");
          <D.23847>:
          D.23826 = ins->next;
          D.23848 = D.23826->sreg2;
          D.23849 = (long unsigned int) D.23848;
          D.23850 = D.23849 * 8;
          D.23851 = carray + D.23850;
          D.23852 = *D.23851;
          if (D.23852 != 0B) goto <D.23853>; else goto <D.23854>;
          <D.23853>:
          {
            int idx;

            D.23826 = ins->next;
            D.23848 = D.23826->sreg2;
            D.23849 = (long unsigned int) D.23848;
            D.23850 = D.23849 * 8;
            D.23851 = carray + D.23850;
            D.23852 = *D.23851;
            D.23855 = D.23852->data.op[0].const_val;
            D.23856 = D.23855 >> 3;
            idx = (int) D.23856;
            if (idx < 0) goto <D.23857>; else goto <D.23859>;
            <D.23859>:
            D.23836 = table->table_size;
            if (D.23836 <= idx) goto <D.23857>; else goto <D.23858>;
            <D.23857>:
            return;
            <D.23858>:
            D.23829 = table->table;
            D.23860 = (long unsigned int) idx;
            D.23861 = D.23860 * 8;
            D.23862 = D.23829 + D.23861;
            D.23863 = *D.23862;
            if (D.23863 != 0B) goto <D.23864>; else goto <D.23865>;
            <D.23864>:
            D.23829 = table->table;
            D.23860 = (long unsigned int) idx;
            D.23861 = D.23860 * 8;
            D.23862 = D.23829 + D.23861;
            D.23863 = *D.23862;
            add_cprop_bb (cfg, D.23863, bblist);
            <D.23865>:
          }
          goto <D.23866>;
          <D.23854>:
          i = 0;
          goto <D.22652>;
          <D.22651>:
          D.23829 = table->table;
          D.23830 = (long unsigned int) i;
          D.23831 = D.23830 * 8;
          D.23832 = D.23829 + D.23831;
          D.23833 = *D.23832;
          if (D.23833 != 0B) goto <D.23867>; else goto <D.23868>;
          <D.23867>:
          D.23829 = table->table;
          D.23830 = (long unsigned int) i;
          D.23831 = D.23830 * 8;
          D.23832 = D.23829 + D.23831;
          D.23833 = *D.23832;
          add_cprop_bb (cfg, D.23833, bblist);
          <D.23868>:
          i = i + 1;
          <D.22652>:
          D.23836 = table->table_size;
          if (D.23836 > i) goto <D.22651>; else goto <D.22653>;
          <D.22653>:
          <D.23866>:
        }
        <D.23799>:
        D.23654 = ins->opcode;
        if (D.23654 == 370) goto <D.23869>; else goto <D.23870>;
        <D.23869>:
        {
          int i;
          struct MonoJumpInfoBBTable * table;

          table = ins->data.op[0].p;
          i = 0;
          goto <D.22657>;
          <D.22656>:
          D.23871 = table->table;
          D.23872 = (long unsigned int) i;
          D.23873 = D.23872 * 8;
          D.23874 = D.23871 + D.23873;
          D.23875 = *D.23874;
          if (D.23875 != 0B) goto <D.23876>; else goto <D.23877>;
          <D.23876>:
          D.23871 = table->table;
          D.23872 = (long unsigned int) i;
          D.23873 = D.23872 * 8;
          D.23874 = D.23871 + D.23873;
          D.23875 = *D.23874;
          add_cprop_bb (cfg, D.23875, bblist);
          <D.23877>:
          i = i + 1;
          <D.22657>:
          D.23878 = table->table_size;
          if (D.23878 > i) goto <D.22656>; else goto <D.22658>;
          <D.22658>:
        }
        <D.23870>:
        D.23826 = ins->next;
        if (D.23826 != 0B) goto <D.23881>; else goto <D.23882>;
        <D.23881>:
        D.23826 = ins->next;
        D.23828 = D.23826->opcode;
        D.23883 = D.23828 + 64985;
        if (D.23883 <= 9) goto <D.23879>; else goto <D.23884>;
        <D.23884>:
        D.23826 = ins->next;
        D.23828 = D.23826->opcode;
        D.23885 = D.23828 + 64878;
        if (D.23885 <= 9) goto <D.23879>; else goto <D.23886>;
        <D.23886>:
        D.23826 = ins->next;
        D.23828 = D.23826->opcode;
        D.23887 = D.23828 + 64888;
        if (D.23887 <= 9) goto <D.23879>; else goto <D.23880>;
        <D.23879>:
        c0.31 = c0;
        if (c0.31 != 0B) goto <D.23888>; else goto <D.23889>;
        <D.23888>:
        c0.31 = c0;
        D.23890 = c0.31->opcode;
        D.23891 = D.23890 != 362;
        D.23892 = (long int) D.23891;
        D.23893 = __builtin_expect (D.23892, 0);
        if (D.23893 != 0) goto <D.23894>; else goto <D.23895>;
        <D.23894>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 990, "c0->opcode == OP_ICONST");
        <D.23895>:
        c0.31 = c0;
        D.23896 = c0.31->data.op[0].const_val;
        if (D.23896 != 0) goto <D.23897>; else goto <D.23898>;
        <D.23897>:
        D.23826 = ins->next;
        D.23826 = ins->next;
        D.23899 = D.23826->flags;
        D.23900 = D.23899 | 8;
        D.23826->flags = D.23900;
        goto <D.23901>;
        <D.23898>:
        D.23826 = ins->next;
        D.23826 = ins->next;
        D.23899 = D.23826->flags;
        D.23902 = D.23899 | 16;
        D.23826->flags = D.23902;
        <D.23901>:
        goto <D.23903>;
        <D.23889>:
        D.23826 = ins->next;
        D.23826 = ins->next;
        D.23899 = D.23826->flags;
        D.23904 = D.23899 & 231;
        D.23826->flags = D.23904;
        <D.23903>:
        D.23826 = ins->next;
        visit_inst (cfg, bb, D.23826, cvars, bblist, carray);
        <D.23880>:
        <D.23882>:
      }
    finally
      {
        c0 = {CLOBBER};
      }
  }
  goto <D.23745>;
  <D.23743>:
  D.23654 = ins->opcode;
  if (D.23654 == 442) goto <D.23905>; else goto <D.23906>;
  <D.23905>:
  D.23907 = ins->data.op[0].target_block;
  add_cprop_bb (cfg, D.23907, bblist);
  goto <D.23908>;
  <D.23906>:
  D.23654 = ins->opcode;
  D.23911 = D.23654 + 64985;
  if (D.23911 <= 9) goto <D.23909>; else goto <D.23912>;
  <D.23912>:
  D.23654 = ins->opcode;
  D.23913 = D.23654 + 64878;
  if (D.23913 <= 9) goto <D.23909>; else goto <D.23914>;
  <D.23914>:
  D.23654 = ins->opcode;
  D.23915 = D.23654 + 64888;
  if (D.23915 <= 9) goto <D.23909>; else goto <D.23910>;
  <D.23909>:
  D.23916 = ins->flags;
  D.23917 = (int) D.23916;
  D.23918 = D.23917 & 8;
  if (D.23918 != 0) goto <D.23919>; else goto <D.23920>;
  <D.23919>:
  D.23921 = ins->data.op[1].many_blocks;
  D.23922 = *D.23921;
  add_cprop_bb (cfg, D.23922, bblist);
  goto <D.23923>;
  <D.23920>:
  D.23916 = ins->flags;
  D.23917 = (int) D.23916;
  D.23924 = D.23917 & 16;
  if (D.23924 != 0) goto <D.23925>; else goto <D.23926>;
  <D.23925>:
  D.23921 = ins->data.op[1].many_blocks;
  D.23927 = D.23921 + 8;
  D.23928 = *D.23927;
  if (D.23928 != 0B) goto <D.23929>; else goto <D.23930>;
  <D.23929>:
  D.23921 = ins->data.op[1].many_blocks;
  D.23927 = D.23921 + 8;
  D.23928 = *D.23927;
  add_cprop_bb (cfg, D.23928, bblist);
  <D.23930>:
  goto <D.23931>;
  <D.23926>:
  D.23921 = ins->data.op[1].many_blocks;
  D.23922 = *D.23921;
  add_cprop_bb (cfg, D.23922, bblist);
  D.23921 = ins->data.op[1].many_blocks;
  D.23927 = D.23921 + 8;
  D.23928 = *D.23927;
  if (D.23928 != 0B) goto <D.23932>; else goto <D.23933>;
  <D.23932>:
  D.23921 = ins->data.op[1].many_blocks;
  D.23927 = D.23921 + 8;
  D.23928 = *D.23927;
  add_cprop_bb (cfg, D.23928, bblist);
  <D.23933>:
  <D.23931>:
  <D.23923>:
  <D.23910>:
  <D.23908>:
  <D.23745>:
  <D.23742>:
}


evaluate_ins (struct MonoCompile * cfg, struct MonoInst * ins, struct MonoInst * * res, struct MonoInst * * carray)
{
  short unsigned int D.23937;
  int D.23938;
  int D.23939;
  int D.23940;
  int D.23943;
  int D.23946;
  int D.23947;
  int D.23948;
  signed char D.23949;
  struct MonoInst * iftmp.36;
  int D.23951;
  unsigned int D.23952;
  unsigned int D.23953;
  struct MonoInst * * D.23956;
  long unsigned int D.23957;
  long unsigned int D.23958;
  struct MonoInst * * D.23959;
  struct MonoInst * * D.23961;
  struct MonoInst * D.23962;
  struct MonoInst * D.23963;
  unsigned char D.23969;
  int D.23970;
  int D.23971;
  struct MonoMethodVar * D.23974;
  long int D.23975;
  long unsigned int D.23976;
  long unsigned int D.23977;
  struct MonoMethodVar * D.23978;
  char D.23979;
  int D.23980;
  int D.23981;
  _Bool D.23988;
  long int D.23989;
  long int D.23990;
  char D.23993;
  int D.23996;
  long unsigned int D.23997;
  long unsigned int D.23998;
  struct MonoInst * * D.23999;
  struct MonoInst * D.24000;
  struct MonoInst * D.24003;
  struct MonoInst * D.24004;
  unsigned int D.24007;
  _Bool D.24008;
  long int D.24009;
  long int D.24010;
  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.23937 = ins->opcode;
      D.23938 = (int) D.23937;
      D.23939 = D.23938 + -313;
      D.23940 = D.23939 * 4;
      spec = &ins_info[D.23940];
      D.23937 = ins->opcode;
      if (D.23937 == 362) goto <D.23941>; else goto <D.23942>;
      <D.23941>:
      *res = ins;
      D.23943 = 1;
      return D.23943;
      <D.23942>:
      D.23937 = ins->opcode;
      if (D.23937 == 316) goto <D.23944>; else goto <D.23945>;
      <D.23944>:
      D.23943 = 2;
      return D.23943;
      <D.23945>:
      D.23946 = ins->sreg1;
      sregs[0] = D.23946;
      D.23947 = ins->sreg2;
      sregs[1] = D.23947;
      D.23948 = ins->sreg3;
      sregs[2] = D.23948;
      D.23937 = ins->opcode;
      D.23938 = (int) D.23937;
      D.23939 = D.23938 + -313;
      D.23949 = ins_sreg_counts[D.23939];
      num_sregs = (int) D.23949;
      i = 0;
      goto <D.22600>;
      <D.22599>:
      args[i] = 0B;
      i = i + 1;
      <D.22600>:
      if (i <= 2) goto <D.22599>; else goto <D.22601>;
      <D.22601>:
      i = 0;
      goto <D.22604>;
      <D.22603>:
      {
        struct MonoInst * var;

        D.23951 = sregs[i];
        D.23952 = (unsigned int) D.23951;
        D.23953 = cfg->vreg_to_inst_len;
        if (D.23952 < D.23953) goto <D.23954>; else goto <D.23955>;
        <D.23954>:
        D.23956 = cfg->vreg_to_inst;
        D.23951 = sregs[i];
        D.23957 = (long unsigned int) D.23951;
        D.23958 = D.23957 * 8;
        D.23959 = D.23956 + D.23958;
        iftmp.36 = *D.23959;
        goto <D.23960>;
        <D.23955>:
        iftmp.36 = 0B;
        <D.23960>:
        var = iftmp.36;
        rs[i] = 2;
        D.23951 = sregs[i];
        D.23957 = (long unsigned int) D.23951;
        D.23958 = D.23957 * 8;
        D.23961 = carray + D.23958;
        D.23962 = *D.23961;
        args[i] = D.23962;
        D.23963 = args[i];
        if (D.23963 != 0B) goto <D.23964>; else goto <D.23965>;
        <D.23964>:
        rs[i] = 1;
        goto <D.23966>;
        <D.23965>:
        if (var != 0B) goto <D.23967>; else goto <D.23968>;
        <D.23967>:
        D.23969 = var->flags;
        D.23970 = (int) D.23969;
        D.23971 = D.23970 & 20;
        if (D.23971 == 0) goto <D.23972>; else goto <D.23973>;
        <D.23972>:
        D.23974 = cfg->vars;
        D.23975 = var->data.op[0].const_val;
        D.23976 = (long unsigned int) D.23975;
        D.23977 = D.23976 * 80;
        D.23978 = D.23974 + D.23977;
        D.23979 = D.23978->cpstate;
        D.23980 = (int) D.23979;
        rs[i] = D.23980;
        <D.23973>:
        <D.23968>:
        <D.23966>:
        D.23981 = rs[i];
        if (D.23981 != 1) goto <D.23982>; else goto <D.23983>;
        <D.23982>:
        const_args = 0;
        <D.23983>:
      }
      i = i + 1;
      <D.22604>:
      if (i < num_sregs) goto <D.22603>; else goto <D.22605>;
      <D.22605>:
      c0 = 0B;
      if (num_sregs > 0) goto <D.23984>; else goto <D.23985>;
      <D.23984>:
      if (const_args != 0) goto <D.23986>; else goto <D.23987>;
      <D.23986>:
      D.23988 = num_sregs > 2;
      D.23989 = (long int) D.23988;
      D.23990 = __builtin_expect (D.23989, 0);
      if (D.23990 != 0) goto <D.23991>; else goto <D.23992>;
      <D.23991>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 776, "num_sregs <= 2");
      <D.23992>:
      D.23993 = *spec;
      if (D.23993 != 32) goto <D.23994>; else goto <D.23995>;
      <D.23994>:
      D.23996 = ins->dreg;
      D.23997 = (long unsigned int) D.23996;
      D.23998 = D.23997 * 8;
      D.23999 = carray + D.23998;
      D.24000 = *D.23999;
      if (D.24000 != 0B) goto <D.24001>; else goto <D.24002>;
      <D.24001>:
      D.23996 = ins->dreg;
      D.23997 = (long unsigned int) D.23996;
      D.23998 = D.23997 * 8;
      D.23999 = carray + D.23998;
      D.24000 = *D.23999;
      *res = D.24000;
      D.23943 = 1;
      return D.23943;
      <D.24002>:
      <D.23995>:
      D.24003 = args[0];
      D.24004 = args[1];
      c0 = mono_constant_fold_ins (cfg, ins, D.24003, D.24004, 0);
      if (c0 != 0B) goto <D.24005>; else goto <D.24006>;
      <D.24005>:
      D.24007 = cfg->verbose_level;
      D.24008 = D.24007 > 1;
      D.24009 = (long int) D.24008;
      D.24010 = __builtin_expect (D.24009, 0);
      if (D.24010 != 0) goto <D.24011>; else goto <D.24012>;
      <D.24011>:
      printf ("\t cfold -> ");
      mono_print_ins (c0);
      <D.24012>:
      *res = c0;
      D.23943 = 1;
      return D.23943;
      <D.24006>:
      D.23943 = 2;
      return D.23943;
      <D.23987>:
      <D.23985>:
      if (num_sregs == 0) goto <D.24013>; else goto <D.24014>;
      <D.24013>:
      D.23943 = 2;
      return D.23943;
      <D.24014>:
      i = 0;
      goto <D.22607>;
      <D.22606>:
      D.23981 = rs[i];
      if (D.23981 == 2) goto <D.24015>; else goto <D.24016>;
      <D.24015>:
      D.23943 = 2;
      return D.23943;
      <D.24016>:
      i = i + 1;
      <D.22607>:
      if (i < num_sregs) goto <D.22606>; else goto <D.22608>;
      <D.22608>:
      D.23943 = 0;
      return D.23943;
    }
  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.24019;
  int D.24020;
  char D.24023;
  unsigned int D.24024;
  _Bool D.24025;
  long int D.24026;
  long int D.24027;
  struct MonoInst * * D.24030;
  unsigned int D.24031;
  long unsigned int D.24032;
  long unsigned int D.24033;
  struct MonoInst * * D.24034;
  struct MonoInst * D.24035;
  int D.24036;
  _Bool D.24039;
  long int D.24040;
  long int D.24041;
  long unsigned int D.24044;
  long unsigned int D.24045;
  struct MonoInst * * D.24046;
  struct GList * D.24047;
  struct GList * D.24048;
  struct GList * D.24051;

  D.24019 = info->cpstate;
  D.24020 = (int) D.24019;
  if (D.24020 >= state) goto <D.24021>; else goto <D.24022>;
  <D.24021>:
  return;
  <D.24022>:
  D.24023 = (char) state;
  info->cpstate = D.24023;
  D.24024 = cfg->verbose_level;
  D.24025 = D.24024 > 1;
  D.24026 = (long int) D.24025;
  D.24027 = __builtin_expect (D.24026, 0);
  if (D.24027 != 0) goto <D.24028>; else goto <D.24029>;
  <D.24028>:
  D.24030 = cfg->varinfo;
  D.24031 = info->idx;
  D.24032 = (long unsigned int) D.24031;
  D.24033 = D.24032 * 8;
  D.24034 = D.24030 + D.24033;
  D.24035 = *D.24034;
  D.24036 = D.24035->dreg;
  D.24019 = info->cpstate;
  D.24020 = (int) D.24019;
  printf ("\tState of R%d set to %d\n", D.24036, D.24020);
  <D.24029>:
  if (state == 1) goto <D.24037>; else goto <D.24038>;
  <D.24037>:
  D.24039 = c0 == 0B;
  D.24040 = (long int) D.24039;
  D.24041 = __builtin_expect (D.24040, 0);
  if (D.24041 != 0) goto <D.24042>; else goto <D.24043>;
  <D.24042>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 817, "c0");
  <D.24043>:
  <D.24038>:
  D.24030 = cfg->varinfo;
  D.24031 = info->idx;
  D.24032 = (long unsigned int) D.24031;
  D.24033 = D.24032 * 8;
  D.24034 = D.24030 + D.24033;
  D.24035 = *D.24034;
  D.24036 = D.24035->dreg;
  D.24044 = (long unsigned int) D.24036;
  D.24045 = D.24044 * 8;
  D.24046 = carray + D.24045;
  *D.24046 = c0;
  D.24047 = *cvars;
  D.24048 = monoeg_g_list_find (D.24047, info);
  if (D.24048 == 0B) goto <D.24049>; else goto <D.24050>;
  <D.24049>:
  D.24047 = *cvars;
  D.24051 = monoeg_g_list_prepend (D.24047, info);
  *cvars = D.24051;
  <D.24050>:
}


fold_ins (struct MonoCompile * cfg, struct MonoBasicBlock * bb, struct MonoInst * ins, struct MonoInst * * carray)
{
  short unsigned int D.24053;
  int D.24054;
  int D.24055;
  int D.24056;
  signed char D.24057;
  int D.24061;
  short unsigned int D.24063;
  long unsigned int D.24067;
  long unsigned int D.24068;
  struct MonoInst * * D.24069;
  struct MonoInst * D.24070;
  char D.24072;
  short unsigned int D.24075;
  _Bool D.24076;
  long int D.24077;
  long int D.24078;
  long int D.24081;
  int D.24082;
  int D.24083;
  long unsigned int D.24086;
  long unsigned int D.24087;
  struct MonoInst * * D.24088;
  struct MonoInst * D.24089;
  short unsigned int D.24094;
  long int D.24095;
  long int D.24101;
  const void * D.24102;
  struct MonoInst * D.24109;
  struct MonoInst * D.24112;
  struct MonoJumpInfoBBTable * iftmp.37;
  struct MonoJumpInfoBBTable * iftmp.38;
  struct MonoJumpInfoBBTable * iftmp.39;
  struct MonoJumpInfoBBTable * iftmp.40;
  struct MonoInst * D.24133;
  short unsigned int D.24135;
  _Bool D.24136;
  long int D.24137;
  long int D.24138;
  int D.24141;
  _Bool D.24142;
  long int D.24143;
  long int D.24144;
  struct MonoInst * D.24147;
  short unsigned int D.24148;
  _Bool D.24149;
  long int D.24150;
  long int D.24151;
  int D.24154;
  long unsigned int D.24155;
  long unsigned int D.24156;
  struct MonoInst * * D.24157;
  struct MonoInst * D.24158;
  long int D.24161;
  long int D.24162;
  int D.24166;
  struct MonoBasicBlock * * D.24167;
  long unsigned int D.24168;
  long unsigned int D.24169;
  struct MonoBasicBlock * * D.24170;
  struct MonoBasicBlock * D.24171;
  int D.24172;
  int D.24173;
  int D.24174;
  struct MonoInst * D.24175;
  int D.24178;
  int D.24179;
  short unsigned int D.24183;
  unsigned int D.24184;
  _Bool D.24185;
  long int D.24186;
  long int D.24187;
  long unsigned int D.24192;
  long unsigned int D.24193;
  struct MonoBasicBlock * * D.24194;
  struct MonoBasicBlock * D.24195;
  short unsigned int D.24200;
  short unsigned int D.24202;
  short unsigned int D.24204;
  unsigned char D.24205;
  int D.24206;
  int D.24207;
  struct MonoBasicBlock * * D.24210;
  struct MonoBasicBlock * * D.24211;
  struct MonoBasicBlock * D.24212;
  struct MonoBasicBlock * D.24213;
  int D.24215;
  struct MonoBasicBlock * D.24218;
  const char * spec;
  int opcode2;
  int num_sregs;

  D.24053 = ins->opcode;
  D.24054 = (int) D.24053;
  D.24055 = D.24054 + -313;
  D.24056 = D.24055 * 4;
  spec = &ins_info[D.24056];
  D.24053 = ins->opcode;
  D.24054 = (int) D.24053;
  D.24055 = D.24054 + -313;
  D.24057 = ins_sreg_counts[D.24055];
  num_sregs = (int) D.24057;
  D.24053 = ins->opcode;
  if (D.24053 != 316) goto <D.24060>; else goto <D.24058>;
  <D.24060>:
  D.24061 = ins->dreg;
  if (D.24061 != -1) goto <D.24062>; else goto <D.24058>;
  <D.24062>:
  D.24053 = ins->opcode;
  D.24063 = D.24053 + 65162;
  if (D.24063 > 13) goto <D.24064>; else goto <D.24058>;
  <D.24064>:
  D.24061 = ins->dreg;
  D.24067 = (long unsigned int) D.24061;
  D.24068 = D.24067 * 8;
  D.24069 = carray + D.24068;
  D.24070 = *D.24069;
  if (D.24070 != 0B) goto <D.24071>; else goto <D.24065>;
  <D.24071>:
  D.24072 = *spec;
  if (D.24072 == 105) goto <D.24073>; else goto <D.24065>;
  <D.24073>:
  D.24061 = ins->dreg;
  if (D.24061 > 31) goto <D.24074>; else goto <D.24065>;
  <D.24074>:
  D.24061 = ins->dreg;
  D.24067 = (long unsigned int) D.24061;
  D.24068 = D.24067 * 8;
  D.24069 = carray + D.24068;
  D.24070 = *D.24069;
  D.24075 = D.24070->opcode;
  D.24076 = D.24075 != 362;
  D.24077 = (long int) D.24076;
  D.24078 = __builtin_expect (D.24077, 0);
  if (D.24078 != 0) goto <D.24079>; else goto <D.24080>;
  <D.24079>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 1035, "carray [ins->dreg]->opcode == OP_ICONST");
  <D.24080>:
  ins->opcode = 362;
  D.24061 = ins->dreg;
  D.24067 = (long unsigned int) D.24061;
  D.24068 = D.24067 * 8;
  D.24069 = carray + D.24068;
  D.24070 = *D.24069;
  D.24081 = D.24070->data.op[0].const_val;
  ins->data.op[0].const_val = D.24081;
  ins->sreg3 = -1;
  D.24082 = ins->sreg3;
  ins->sreg2 = D.24082;
  D.24083 = ins->sreg2;
  ins->sreg1 = D.24083;
  goto <D.24066>;
  <D.24065>:
  if (num_sregs == 2) goto <D.24084>; else goto <D.24085>;
  <D.24084>:
  D.24083 = ins->sreg2;
  D.24086 = (long unsigned int) D.24083;
  D.24087 = D.24086 * 8;
  D.24088 = carray + D.24087;
  D.24089 = *D.24088;
  if (D.24089 != 0B) goto <D.24090>; else goto <D.24091>;
  <D.24090>:
  D.24053 = ins->opcode;
  D.24054 = (int) D.24053;
  opcode2 = mono_op_to_op_imm (D.24054);
  if (opcode2 != -1) goto <D.24092>; else goto <D.24093>;
  <D.24092>:
  D.24094 = (short unsigned int) opcode2;
  ins->opcode = D.24094;
  D.24083 = ins->sreg2;
  D.24086 = (long unsigned int) D.24083;
  D.24087 = D.24086 * 8;
  D.24088 = carray + D.24087;
  D.24089 = *D.24088;
  D.24095 = D.24089->data.op[0].const_val;
  ins->data.op[1].const_val = D.24095;
  ins->sreg2 = -1;
  if (opcode2 == 343) goto <D.24096>; else goto <D.24098>;
  <D.24098>:
  if (opcode2 == 346) goto <D.24096>; else goto <D.24099>;
  <D.24099>:
  if (opcode2 == 352) goto <D.24096>; else goto <D.24100>;
  <D.24100>:
  if (opcode2 == 349) goto <D.24096>; else goto <D.24097>;
  <D.24096>:
  D.24101 = ins->data.op[1].const_val;
  D.24102 = (const void *) D.24101;
  MEM[(struct MonoCallInst *)ins].fptr = D.24102;
  <D.24097>:
  <D.24093>:
  goto <D.24103>;
  <D.24091>:
  <D.24103>:
  <D.24085>:
  <D.24066>:
  D.24053 = ins->opcode;
  if (D.24053 == 731) goto <D.24104>; else goto <D.24107>;
  <D.24107>:
  D.24053 = ins->opcode;
  if (D.24053 == 732) goto <D.24108>; else goto <D.24105>;
  <D.24108>:
  D.24109 = ins->data.op[1].src;
  if (D.24109 == 8B) goto <D.24104>; else goto <D.24105>;
  <D.24105>:
  D.24053 = ins->opcode;
  if (D.24053 == 370) goto <D.24104>; else goto <D.24110>;
  <D.24110>:
  D.24053 = ins->opcode;
  if (D.24053 == 734) goto <D.24111>; else goto <D.24106>;
  <D.24111>:
  D.24109 = ins->data.op[1].src;
  D.24112 = D.24109->data.op[1].src;
  if (D.24112 == 8B) goto <D.24104>; else goto <D.24106>;
  <D.24104>:
  {
    int i;
    struct MonoJumpInfoBBTable * table;

    D.24053 = ins->opcode;
    if (D.24053 == 731) goto <D.24114>; else goto <D.24115>;
    <D.24114>:
    iftmp.37 = ins->data.op[0].p;
    goto <D.24116>;
    <D.24115>:
    D.24053 = ins->opcode;
    if (D.24053 == 732) goto <D.24120>; else goto <D.24118>;
    <D.24120>:
    D.24109 = ins->data.op[1].src;
    if (D.24109 == 8B) goto <D.24121>; else goto <D.24118>;
    <D.24121>:
    iftmp.38 = ins->data.op[0].p;
    goto <D.24119>;
    <D.24118>:
    D.24053 = ins->opcode;
    if (D.24053 == 370) goto <D.24123>; else goto <D.24124>;
    <D.24123>:
    iftmp.39 = ins->data.op[0].p;
    goto <D.24125>;
    <D.24124>:
    D.24053 = ins->opcode;
    if (D.24053 == 734) goto <D.24129>; else goto <D.24127>;
    <D.24129>:
    D.24109 = ins->data.op[1].src;
    D.24112 = D.24109->data.op[1].src;
    if (D.24112 == 8B) goto <D.24130>; else goto <D.24127>;
    <D.24130>:
    D.24109 = ins->data.op[1].src;
    iftmp.40 = D.24109->data.op[0].p;
    goto <D.24128>;
    <D.24127>:
    iftmp.40 = 0B;
    <D.24128>:
    iftmp.39 = iftmp.40;
    <D.24125>:
    iftmp.38 = iftmp.39;
    <D.24119>:
    iftmp.37 = iftmp.38;
    <D.24116>:
    table = iftmp.37;
    D.24133 = ins->next;
    if (D.24133 == 0B) goto <D.24131>; else goto <D.24134>;
    <D.24134>:
    D.24133 = ins->next;
    D.24135 = D.24133->opcode;
    if (D.24135 != 479) goto <D.24131>; else goto <D.24132>;
    <D.24131>:
    return;
    <D.24132>:
    D.24133 = ins->next;
    D.24135 = D.24133->opcode;
    D.24136 = D.24135 != 479;
    D.24137 = (long int) D.24136;
    D.24138 = __builtin_expect (D.24137, 0);
    if (D.24138 != 0) goto <D.24139>; else goto <D.24140>;
    <D.24139>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 1064, "ins->next->opcode == OP_PADD");
    <D.24140>:
    D.24133 = ins->next;
    D.24141 = D.24133->sreg1;
    D.24061 = ins->dreg;
    D.24142 = D.24141 != D.24061;
    D.24143 = (long int) D.24142;
    D.24144 = __builtin_expect (D.24143, 0);
    if (D.24144 != 0) goto <D.24145>; else goto <D.24146>;
    <D.24145>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 1065, "ins->next->sreg1 == ins->dreg");
    <D.24146>:
    D.24133 = ins->next;
    D.24147 = D.24133->next;
    D.24148 = D.24147->opcode;
    D.24149 = D.24148 != 388;
    D.24150 = (long int) D.24149;
    D.24151 = __builtin_expect (D.24150, 0);
    if (D.24151 != 0) goto <D.24152>; else goto <D.24153>;
    <D.24152>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 1066, "ins->next->next->opcode == OP_LOAD_MEMBASE");
    <D.24153>:
    D.24133 = ins->next;
    D.24154 = D.24133->sreg2;
    D.24155 = (long unsigned int) D.24154;
    D.24156 = D.24155 * 8;
    D.24157 = carray + D.24156;
    D.24158 = *D.24157;
    if (D.24158 != 0B) goto <D.24159>; else goto <D.24160>;
    <D.24159>:
    {
      int idx;

      D.24133 = ins->next;
      D.24154 = D.24133->sreg2;
      D.24155 = (long unsigned int) D.24154;
      D.24156 = D.24155 * 8;
      D.24157 = carray + D.24156;
      D.24158 = *D.24157;
      D.24161 = D.24158->data.op[0].const_val;
      D.24162 = D.24161 >> 3;
      idx = (int) D.24162;
      if (idx < 0) goto <D.24163>; else goto <D.24165>;
      <D.24165>:
      D.24166 = table->table_size;
      if (D.24166 <= idx) goto <D.24163>; else goto <D.24164>;
      <D.24163>:
      i = 0;
      goto <D.22672>;
      <D.22671>:
      D.24167 = table->table;
      D.24168 = (long unsigned int) i;
      D.24169 = D.24168 * 8;
      D.24170 = D.24167 + D.24169;
      D.24171 = *D.24170;
      remove_bb_from_phis (cfg, bb, D.24171);
      D.24167 = table->table;
      D.24168 = (long unsigned int) i;
      D.24169 = D.24168 * 8;
      D.24170 = D.24167 + D.24169;
      D.24171 = *D.24170;
      mono_unlink_bblock (cfg, bb, D.24171);
      i = i + 1;
      <D.22672>:
      D.24166 = table->table_size;
      if (D.24166 > i) goto <D.22671>; else goto <D.22673>;
      <D.22673>:
      ins->opcode = 316;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.24082 = ins->sreg3;
      ins->sreg2 = D.24082;
      D.24083 = ins->sreg2;
      ins->sreg1 = D.24083;
      D.24133 = ins->next;
      D.24133->opcode = 316;
      D.24133 = ins->next;
      D.24133->dreg = -1;
      D.24133 = ins->next;
      D.24133 = ins->next;
      D.24133 = ins->next;
      D.24133->sreg3 = -1;
      D.24172 = D.24133->sreg3;
      D.24133->sreg2 = D.24172;
      D.24154 = D.24133->sreg2;
      D.24133->sreg1 = D.24154;
      D.24133 = ins->next;
      D.24147 = D.24133->next;
      D.24147->opcode = 316;
      D.24133 = ins->next;
      D.24147 = D.24133->next;
      D.24147->dreg = -1;
      D.24133 = ins->next;
      D.24147 = D.24133->next;
      D.24133 = ins->next;
      D.24147 = D.24133->next;
      D.24133 = ins->next;
      D.24147 = D.24133->next;
      D.24147->sreg3 = -1;
      D.24173 = D.24147->sreg3;
      D.24147->sreg2 = D.24173;
      D.24174 = D.24147->sreg2;
      D.24147->sreg1 = D.24174;
      D.24133 = ins->next;
      D.24147 = D.24133->next;
      D.24175 = D.24147->next;
      if (D.24175 != 0B) goto <D.24176>; else goto <D.24177>;
      <D.24176>:
      D.24133 = ins->next;
      D.24147 = D.24133->next;
      D.24175 = D.24147->next;
      D.24175->opcode = 316;
      D.24133 = ins->next;
      D.24147 = D.24133->next;
      D.24175 = D.24147->next;
      D.24175->dreg = -1;
      D.24133 = ins->next;
      D.24147 = D.24133->next;
      D.24175 = D.24147->next;
      D.24133 = ins->next;
      D.24147 = D.24133->next;
      D.24175 = D.24147->next;
      D.24133 = ins->next;
      D.24147 = D.24133->next;
      D.24175 = D.24147->next;
      D.24175->sreg3 = -1;
      D.24178 = D.24175->sreg3;
      D.24175->sreg2 = D.24178;
      D.24179 = D.24175->sreg2;
      D.24175->sreg1 = D.24179;
      <D.24177>:
      return;
      <D.24164>:
      D.24133 = ins->next;
      D.24147 = D.24133->next;
      D.24175 = D.24147->next;
      if (D.24175 == 0B) goto <D.24180>; else goto <D.24182>;
      <D.24182>:
      D.24133 = ins->next;
      D.24147 = D.24133->next;
      D.24175 = D.24147->next;
      D.24183 = D.24175->opcode;
      if (D.24183 != 759) goto <D.24180>; else goto <D.24181>;
      <D.24180>:
      D.24184 = cfg->verbose_level;
      D.24185 = D.24184 > 1;
      D.24186 = (long int) D.24185;
      D.24187 = __builtin_expect (D.24186, 0);
      if (D.24187 != 0) goto <D.24188>; else goto <D.24189>;
      <D.24188>:
      printf ("\tNo cfold on ");
      mono_print_ins (ins);
      <D.24189>:
      return;
      <D.24181>:
      D.24184 = cfg->verbose_level;
      D.24185 = D.24184 > 1;
      D.24186 = (long int) D.24185;
      D.24187 = __builtin_expect (D.24186, 0);
      if (D.24187 != 0) goto <D.24190>; else goto <D.24191>;
      <D.24190>:
      printf ("\tcfold on ");
      mono_print_ins (ins);
      <D.24191>:
      i = 0;
      goto <D.22675>;
      <D.22674>:
      D.24167 = table->table;
      D.24168 = (long unsigned int) i;
      D.24169 = D.24168 * 8;
      D.24170 = D.24167 + D.24169;
      D.24171 = *D.24170;
      D.24167 = table->table;
      D.24192 = (long unsigned int) idx;
      D.24193 = D.24192 * 8;
      D.24194 = D.24167 + D.24193;
      D.24195 = *D.24194;
      if (D.24171 != D.24195) goto <D.24196>; else goto <D.24197>;
      <D.24196>:
      D.24167 = table->table;
      D.24168 = (long unsigned int) i;
      D.24169 = D.24168 * 8;
      D.24170 = D.24167 + D.24169;
      D.24171 = *D.24170;
      remove_bb_from_phis (cfg, bb, D.24171);
      D.24167 = table->table;
      D.24168 = (long unsigned int) i;
      D.24169 = D.24168 * 8;
      D.24170 = D.24167 + D.24169;
      D.24171 = *D.24170;
      mono_unlink_bblock (cfg, bb, D.24171);
      <D.24197>:
      i = i + 1;
      <D.22675>:
      D.24166 = table->table_size;
      if (D.24166 > i) goto <D.22674>; else goto <D.22676>;
      <D.22676>:
      D.24133 = ins->next;
      D.24147 = D.24133->next;
      D.24175 = D.24147->next;
      D.24175->opcode = 442;
      D.24133 = ins->next;
      D.24147 = D.24133->next;
      D.24175 = D.24147->next;
      D.24167 = table->table;
      D.24192 = (long unsigned int) idx;
      D.24193 = D.24192 * 8;
      D.24194 = D.24167 + D.24193;
      D.24195 = *D.24194;
      D.24175->data.op[0].target_block = D.24195;
      D.24133 = ins->next;
      D.24147 = D.24133->next;
      D.24175 = D.24147->next;
      D.24175->sreg1 = -1;
      ins->opcode = 316;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.24082 = ins->sreg3;
      ins->sreg2 = D.24082;
      D.24083 = ins->sreg2;
      ins->sreg1 = D.24083;
      D.24133 = ins->next;
      D.24133->opcode = 316;
      D.24133 = ins->next;
      D.24133->dreg = -1;
      D.24133 = ins->next;
      D.24133 = ins->next;
      D.24133 = ins->next;
      D.24133->sreg3 = -1;
      D.24172 = D.24133->sreg3;
      D.24133->sreg2 = D.24172;
      D.24154 = D.24133->sreg2;
      D.24133->sreg1 = D.24154;
      D.24133 = ins->next;
      D.24147 = D.24133->next;
      D.24147->opcode = 316;
      D.24133 = ins->next;
      D.24147 = D.24133->next;
      D.24147->dreg = -1;
      D.24133 = ins->next;
      D.24147 = D.24133->next;
      D.24133 = ins->next;
      D.24147 = D.24133->next;
      D.24133 = ins->next;
      D.24147 = D.24133->next;
      D.24147->sreg3 = -1;
      D.24173 = D.24147->sreg3;
      D.24147->sreg2 = D.24173;
      D.24174 = D.24147->sreg2;
      D.24147->sreg1 = D.24174;
    }
    <D.24160>:
  }
  <D.24106>:
  goto <D.24059>;
  <D.24058>:
  D.24053 = ins->opcode;
  D.24200 = D.24053 + 64985;
  if (D.24200 <= 9) goto <D.24198>; else goto <D.24201>;
  <D.24201>:
  D.24053 = ins->opcode;
  D.24202 = D.24053 + 64878;
  if (D.24202 <= 9) goto <D.24198>; else goto <D.24203>;
  <D.24203>:
  D.24053 = ins->opcode;
  D.24204 = D.24053 + 64888;
  if (D.24204 <= 9) goto <D.24198>; else goto <D.24199>;
  <D.24198>:
  D.24205 = ins->flags;
  D.24206 = (int) D.24205;
  D.24207 = D.24206 & 8;
  if (D.24207 != 0) goto <D.24208>; else goto <D.24209>;
  <D.24208>:
  D.24210 = ins->data.op[1].many_blocks;
  D.24211 = D.24210 + 8;
  D.24212 = *D.24211;
  remove_bb_from_phis (cfg, bb, D.24212);
  D.24210 = ins->data.op[1].many_blocks;
  D.24211 = D.24210 + 8;
  D.24212 = *D.24211;
  mono_unlink_bblock (cfg, bb, D.24212);
  ins->opcode = 442;
  D.24210 = ins->data.op[1].many_blocks;
  D.24213 = *D.24210;
  ins->data.op[0].target_block = D.24213;
  goto <D.24214>;
  <D.24209>:
  D.24205 = ins->flags;
  D.24206 = (int) D.24205;
  D.24215 = D.24206 & 16;
  if (D.24215 != 0) goto <D.24216>; else goto <D.24217>;
  <D.24216>:
  D.24210 = ins->data.op[1].many_blocks;
  D.24213 = *D.24210;
  remove_bb_from_phis (cfg, bb, D.24213);
  D.24210 = ins->data.op[1].many_blocks;
  D.24213 = *D.24210;
  mono_unlink_bblock (cfg, bb, D.24213);
  ins->opcode = 442;
  D.24210 = ins->data.op[1].many_blocks;
  D.24218 = MEM[(struct MonoBasicBlock * *)D.24210 + 8B];
  ins->data.op[0].target_block = D.24218;
  <D.24217>:
  <D.24214>:
  <D.24199>:
  <D.24059>:
}


remove_bb_from_phis (struct MonoCompile * cfg, struct MonoBasicBlock * bb, struct MonoBasicBlock * target)
{
  struct MonoBasicBlock * * D.24220;
  long unsigned int D.24221;
  long unsigned int D.24222;
  struct MonoBasicBlock * * D.24223;
  struct MonoBasicBlock * D.24224;
  short int D.24226;
  int D.24227;
  _Bool D.24228;
  long int D.24229;
  long int D.24230;
  short unsigned int D.24233;
  short unsigned int D.24234;
  int * D.24236;
  sizetype D.24237;
  sizetype D.24238;
  sizetype D.24239;
  int * D.24240;
  sizetype D.24241;
  sizetype D.24242;
  int * D.24243;
  int D.24244;
  int D.24245;
  int D.24246;
  struct MonoInst * ins;
  int i;
  int j;

  i = 0;
  goto <D.22350>;
  <D.22349>:
  D.24220 = target->in_bb;
  D.24221 = (long unsigned int) i;
  D.24222 = D.24221 * 8;
  D.24223 = D.24220 + D.24222;
  D.24224 = *D.24223;
  if (D.24224 == bb) goto <D.22348>; else goto <D.24225>;
  <D.24225>:
  i = i + 1;
  <D.22350>:
  D.24226 = target->in_count;
  D.24227 = (int) D.24226;
  if (D.24227 > i) goto <D.22349>; else goto <D.22348>;
  <D.22348>:
  D.24226 = target->in_count;
  D.24227 = (int) D.24226;
  D.24228 = D.24227 <= i;
  D.24229 = (long int) D.24228;
  D.24230 = __builtin_expect (D.24229, 0);
  if (D.24230 != 0) goto <D.24231>; else goto <D.24232>;
  <D.24231>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 111, "i < target->in_count");
  <D.24232>:
  ins = target->code;
  goto <D.22356>;
  <D.22355>:
  D.24233 = ins->opcode;
  D.24234 = D.24233 + 65217;
  if (D.24234 <= 2) goto <D.24235>; else goto <D.22354>;
  <D.24235>:
  j = i;
  goto <D.22352>;
  <D.22351>:
  D.24236 = ins->data.op[1].phi_args;
  D.24237 = (sizetype) j;
  D.24238 = D.24237 + 1;
  D.24239 = D.24238 * 4;
  D.24240 = D.24236 + D.24239;
  D.24236 = ins->data.op[1].phi_args;
  D.24237 = (sizetype) j;
  D.24241 = D.24237 + 2;
  D.24242 = D.24241 * 4;
  D.24243 = D.24236 + D.24242;
  D.24244 = *D.24243;
  *D.24240 = D.24244;
  j = j + 1;
  <D.22352>:
  D.24236 = ins->data.op[1].phi_args;
  D.24245 = *D.24236;
  D.24246 = D.24245 + -1;
  if (D.24246 > j) goto <D.22351>; else goto <D.22353>;
  <D.22353>:
  D.24236 = ins->data.op[1].phi_args;
  D.24245 = *D.24236;
  D.24246 = D.24245 + -1;
  *D.24236 = D.24246;
  ins = ins->next;
  <D.22356>:
  if (ins != 0B) goto <D.22355>; else goto <D.22354>;
  <D.22354>:
}


mono_ssa_deadce (struct MonoCompile * cfg)
{
  unsigned int D.24247;
  unsigned int D.24248;
  _Bool D.24249;
  long int D.24250;
  long int D.24251;
  unsigned int D.24254;
  struct MonoMethodVar * D.24257;
  long unsigned int D.24258;
  long unsigned int D.24259;
  struct MonoMemPool * D.24260;
  struct GList * work_list.41;
  struct GList * work_list.42;
  unsigned int i.43;
  unsigned int D.24264;
  struct GList * work_list.44;
  struct MonoInst * D.24268;
  struct GList * D.24271;
  struct GList * D.24273;
  void * D.24275;
  struct MonoInst * D.24276;
  short unsigned int D.24280;
  struct MonoInst * iftmp.45;
  int D.24284;
  unsigned int D.24285;
  unsigned int D.24286;
  struct MonoInst * * D.24289;
  long unsigned int D.24290;
  long unsigned int D.24291;
  struct MonoInst * * D.24292;
  unsigned char D.24296;
  int D.24297;
  int D.24298;
  long int D.24301;
  long unsigned int D.24302;
  long unsigned int D.24303;
  struct MonoMethodVar * D.24304;
  int D.24305;
  short unsigned int D.24309;
  short unsigned int D.24311;
  int * D.24314;
  struct MonoInst * iftmp.46;
  long unsigned int D.24316;
  long unsigned int D.24317;
  int * D.24318;
  int D.24319;
  unsigned int D.24320;
  long unsigned int D.24323;
  long unsigned int D.24324;
  struct MonoInst * * D.24325;
  long int D.24327;
  long unsigned int D.24328;
  long unsigned int D.24329;
  int i;
  struct GList * work_list;

  try
    {
      D.24247 = cfg->comp_done;
      D.24248 = D.24247 & 32;
      D.24249 = D.24248 == 0;
      D.24250 = (long int) D.24249;
      D.24251 = __builtin_expect (D.24250, 0);
      if (D.24251 != 0) goto <D.24252>; else goto <D.24253>;
      <D.24252>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 1259, "cfg->comp_done & MONO_COMP_SSA");
      <D.24253>:
      D.24247 = cfg->comp_done;
      D.24254 = D.24247 & 64;
      if (D.24254 == 0) goto <D.24255>; else goto <D.24256>;
      <D.24255>:
      mono_ssa_create_def_use (cfg);
      <D.24256>:
      mono_ssa_copyprop (cfg);
      work_list = 0B;
      i = 0;
      goto <D.22741>;
      <D.22740>:
      {
        struct MonoMethodVar * info;

        D.24257 = cfg->vars;
        D.24258 = (long unsigned int) i;
        D.24259 = D.24258 * 80;
        info = D.24257 + D.24259;
        D.24260 = cfg->mempool;
        work_list.41 = work_list;
        work_list.42 = g_list_prepend_mempool (D.24260, work_list.41, info);
        work_list = work_list.42;
      }
      i = i + 1;
      <D.22741>:
      i.43 = (unsigned int) i;
      D.24264 = cfg->num_varinfo;
      if (i.43 < D.24264) goto <D.22740>; else goto <D.22742>;
      <D.22742>:
      goto <D.22752>;
      <D.22751>:
      {
        struct MonoMethodVar * info;

        work_list.41 = work_list;
        info = work_list.41->data;
        work_list.41 = work_list;
        work_list.41 = work_list;
        work_list.44 = monoeg_g_list_remove_link (work_list.41, work_list.41);
        work_list = work_list.44;
        D.24268 = info->def;
        if (D.24268 != 0B) goto <D.24269>; else goto <D.24270>;
        <D.24269>:
        D.24271 = info->uses;
        if (D.24271 == 0B) goto <D.24266>; else goto <D.24272>;
        <D.24272>:
        D.24271 = info->uses;
        D.24273 = D.24271->next;
        if (D.24273 == 0B) goto <D.24274>; else goto <D.24267>;
        <D.24274>:
        D.24271 = info->uses;
        D.24275 = D.24271->data;
        D.24276 = MEM[(struct MonoVarUsageInfo *)D.24275].inst;
        D.24268 = info->def;
        if (D.24276 == D.24268) goto <D.24266>; else goto <D.24267>;
        <D.24266>:
        {
          struct MonoInst * def;

          def = info->def;
          D.24280 = def->opcode;
          if (D.24280 == 424) goto <D.24277>; else goto <D.24281>;
          <D.24281>:
          D.24280 = def->opcode;
          if (D.24280 == 426) goto <D.24277>; else goto <D.24282>;
          <D.24282>:
          D.24280 = def->opcode;
          if (D.24280 == 427) goto <D.24277>; else goto <D.24278>;
          <D.24277>:
          {
            struct MonoInst * src_var;

            D.24284 = def->sreg1;
            D.24285 = (unsigned int) D.24284;
            D.24286 = cfg->vreg_to_inst_len;
            if (D.24285 < D.24286) goto <D.24287>; else goto <D.24288>;
            <D.24287>:
            D.24289 = cfg->vreg_to_inst;
            D.24284 = def->sreg1;
            D.24290 = (long unsigned int) D.24284;
            D.24291 = D.24290 * 8;
            D.24292 = D.24289 + D.24291;
            iftmp.45 = *D.24292;
            goto <D.24293>;
            <D.24288>:
            iftmp.45 = 0B;
            <D.24293>:
            src_var = iftmp.45;
            if (src_var != 0B) goto <D.24294>; else goto <D.24295>;
            <D.24294>:
            D.24296 = src_var->flags;
            D.24297 = (int) D.24296;
            D.24298 = D.24297 & 20;
            if (D.24298 == 0) goto <D.24299>; else goto <D.24300>;
            <D.24299>:
            D.24257 = cfg->vars;
            D.24301 = src_var->data.op[0].const_val;
            D.24302 = (long unsigned int) D.24301;
            D.24303 = D.24302 * 80;
            D.24304 = D.24257 + D.24303;
            add_to_dce_worklist (cfg, info, D.24304, &work_list);
            <D.24300>:
            <D.24295>:
            def->opcode = 316;
            def->sreg2 = -1;
            D.24305 = def->sreg2;
            def->sreg1 = D.24305;
            D.24284 = def->sreg1;
            def->dreg = D.24284;
            info->reg = -1;
          }
          goto <D.24279>;
          <D.24278>:
          D.24280 = def->opcode;
          D.24309 = D.24280 + 65174;
          if (D.24309 <= 1) goto <D.24306>; else goto <D.24310>;
          <D.24310>:
          D.24280 = def->opcode;
          if (D.24280 == 428) goto <D.24306>; else goto <D.24307>;
          <D.24306>:
          def->opcode = 316;
          def->sreg2 = -1;
          D.24305 = def->sreg2;
          def->sreg1 = D.24305;
          D.24284 = def->sreg1;
          def->dreg = D.24284;
          info->reg = -1;
          goto <D.24308>;
          <D.24307>:
          D.24280 = def->opcode;
          D.24311 = D.24280 + 65217;
          if (D.24311 <= 2) goto <D.24312>; else goto <D.24313>;
          <D.24312>:
          {
            int j;

            D.24314 = def->data.op[1].phi_args;
            j = *D.24314;
            goto <D.22749>;
            <D.22748>:
            {
              struct MonoMethodVar * u;

              D.24257 = cfg->vars;
              D.24314 = def->data.op[1].phi_args;
              D.24316 = (long unsigned int) j;
              D.24317 = D.24316 * 4;
              D.24318 = D.24314 + D.24317;
              D.24319 = *D.24318;
              D.24320 = (unsigned int) D.24319;
              D.24286 = cfg->vreg_to_inst_len;
              if (D.24320 < D.24286) goto <D.24321>; else goto <D.24322>;
              <D.24321>:
              D.24289 = cfg->vreg_to_inst;
              D.24314 = def->data.op[1].phi_args;
              D.24316 = (long unsigned int) j;
              D.24317 = D.24316 * 4;
              D.24318 = D.24314 + D.24317;
              D.24319 = *D.24318;
              D.24323 = (long unsigned int) D.24319;
              D.24324 = D.24323 * 8;
              D.24325 = D.24289 + D.24324;
              iftmp.46 = *D.24325;
              goto <D.24326>;
              <D.24322>:
              iftmp.46 = 0B;
              <D.24326>:
              D.24327 = iftmp.46->data.op[0].const_val;
              D.24328 = (long unsigned int) D.24327;
              D.24329 = D.24328 * 80;
              u = D.24257 + D.24329;
              add_to_dce_worklist (cfg, info, u, &work_list);
            }
            j = j + -1;
            <D.22749>:
            if (j > 0) goto <D.22748>; else goto <D.22750>;
            <D.22750>:
            def->opcode = 316;
            def->sreg2 = -1;
            D.24305 = def->sreg2;
            def->sreg1 = D.24305;
            D.24284 = def->sreg1;
            def->dreg = D.24284;
            info->reg = -1;
          }
          goto <D.24330>;
          <D.24313>:
          D.24280 = def->opcode;
          if (D.24280 == 316) goto <D.24331>; else goto <D.24332>;
          <D.24331>:
          <D.24332>:
          <D.24330>:
          <D.24308>:
          <D.24279>:
        }
        <D.24267>:
        <D.24270>:
      }
      <D.22752>:
      work_list.41 = work_list;
      if (work_list.41 != 0B) goto <D.22751>; else goto <D.22753>;
      <D.22753>:
    }
  finally
    {
      work_list = {CLOBBER};
    }
}


mono_ssa_copyprop (struct MonoCompile * cfg)
{
  unsigned int D.24333;
  unsigned int D.24334;
  _Bool D.24335;
  long int D.24336;
  long int D.24337;
  struct MonoInst * * D.24340;
  long unsigned int D.24341;
  long unsigned int D.24342;
  struct MonoInst * * D.24343;
  struct MonoMethodVar * D.24344;
  long unsigned int D.24345;
  struct MonoInst * D.24348;
  short unsigned int D.24351;
  struct MonoInst * iftmp.47;
  int D.24355;
  unsigned int D.24356;
  unsigned int D.24357;
  struct MonoInst * * D.24360;
  long unsigned int D.24361;
  long unsigned int D.24362;
  struct MonoInst * * D.24363;
  unsigned char D.24367;
  int D.24368;
  int D.24369;
  long int D.24372;
  long unsigned int D.24373;
  long unsigned int D.24374;
  struct MonoMethodVar * D.24375;
  struct MonoInst * D.24376;
  short unsigned int D.24379;
  short unsigned int D.24380;
  int D.24383;
  int D.24384;
  int D.24385;
  short unsigned int D.24386;
  int D.24387;
  int D.24388;
  signed char D.24389;
  int D.24390;
  _Bool D.24394;
  long int D.24395;
  long int D.24396;
  short unsigned int D.24402;
  int D.24404;
  short unsigned int D.24406;
  int * D.24409;
  long unsigned int D.24410;
  long unsigned int D.24411;
  int * D.24412;
  int D.24413;
  _Bool D.24415;
  long int D.24416;
  long int D.24417;
  struct MonoBasicBlock * D.24421;
  unsigned int index.48;
  unsigned int D.24423;
  unsigned int D.24424;
  int i;
  int index;
  struct GList * l;

  D.24333 = cfg->comp_done;
  D.24334 = D.24333 & 64;
  D.24335 = D.24334 == 0;
  D.24336 = (long int) D.24335;
  D.24337 = __builtin_expect (D.24336, 0);
  if (D.24337 != 0) goto <D.24338>; else goto <D.24339>;
  <D.24338>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 674, "(cfg->comp_done & MONO_COMP_SSA_DEF_USE)");
  <D.24339>:
  index = 0;
  goto <D.22579>;
  <D.22578>:
  {
    struct MonoInst * var;
    struct MonoMethodVar * info;

    D.24340 = cfg->varinfo;
    D.24341 = (long unsigned int) index;
    D.24342 = D.24341 * 8;
    D.24343 = D.24340 + D.24342;
    var = *D.24343;
    D.24344 = cfg->vars;
    D.24341 = (long unsigned int) index;
    D.24345 = D.24341 * 80;
    info = D.24344 + D.24345;
    D.24348 = info->def;
    if (D.24348 != 0B) goto <D.24349>; else goto <D.24350>;
    <D.24349>:
    D.24348 = info->def;
    D.24351 = D.24348->opcode;
    if (D.24351 == 424) goto <D.24346>; else goto <D.24352>;
    <D.24352>:
    D.24348 = info->def;
    D.24351 = D.24348->opcode;
    if (D.24351 == 426) goto <D.24346>; else goto <D.24353>;
    <D.24353>:
    D.24348 = info->def;
    D.24351 = D.24348->opcode;
    if (D.24351 == 427) goto <D.24346>; else goto <D.24347>;
    <D.24346>:
    {
      struct MonoInst * var2;

      D.24348 = info->def;
      D.24355 = D.24348->sreg1;
      D.24356 = (unsigned int) D.24355;
      D.24357 = cfg->vreg_to_inst_len;
      if (D.24356 < D.24357) goto <D.24358>; else goto <D.24359>;
      <D.24358>:
      D.24360 = cfg->vreg_to_inst;
      D.24348 = info->def;
      D.24355 = D.24348->sreg1;
      D.24361 = (long unsigned int) D.24355;
      D.24362 = D.24361 * 8;
      D.24363 = D.24360 + D.24362;
      iftmp.47 = *D.24363;
      goto <D.24364>;
      <D.24359>:
      iftmp.47 = 0B;
      <D.24364>:
      var2 = iftmp.47;
      if (var2 != 0B) goto <D.24365>; else goto <D.24366>;
      <D.24365>:
      D.24367 = var2->flags;
      D.24368 = (int) D.24367;
      D.24369 = D.24368 & 20;
      if (D.24369 == 0) goto <D.24370>; else goto <D.24371>;
      <D.24370>:
      D.24344 = cfg->vars;
      D.24372 = var2->data.op[0].const_val;
      D.24373 = (long unsigned int) D.24372;
      D.24374 = D.24373 * 80;
      D.24375 = D.24344 + D.24374;
      D.24376 = D.24375->def;
      if (D.24376 != 0B) goto <D.24377>; else goto <D.24378>;
      <D.24377>:
      D.24344 = cfg->vars;
      D.24372 = var2->data.op[0].const_val;
      D.24373 = (long unsigned int) D.24372;
      D.24374 = D.24373 * 80;
      D.24375 = D.24344 + D.24374;
      D.24376 = D.24375->def;
      D.24379 = D.24376->opcode;
      D.24380 = D.24379 + 65217;
      if (D.24380 > 2) goto <D.24381>; else goto <D.24382>;
      <D.24381>:
      {
        int dreg;
        int sreg1;

        dreg = var->dreg;
        sreg1 = var2->dreg;
        l = info->uses;
        goto <D.22576>;
        <D.22575>:
        {
          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.24383 = ins->sreg1;
              sregs[0] = D.24383;
              D.24384 = ins->sreg2;
              sregs[1] = D.24384;
              D.24385 = ins->sreg3;
              sregs[2] = D.24385;
              D.24386 = ins->opcode;
              D.24387 = (int) D.24386;
              D.24388 = D.24387 + -313;
              D.24389 = ins_sreg_counts[D.24388];
              num_sregs = (int) D.24389;
              i = 0;
              goto <D.22570>;
              <D.22569>:
              D.24390 = sregs[i];
              if (D.24390 == dreg) goto <D.22568>; else goto <D.24391>;
              <D.24391>:
              i = i + 1;
              <D.22570>:
              if (i < num_sregs) goto <D.22569>; else goto <D.22568>;
              <D.22568>:
              if (i < num_sregs) goto <D.24392>; else goto <D.24393>;
              <D.24392>:
              D.24390 = sregs[i];
              D.24394 = D.24390 != dreg;
              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", 702, "sregs [i] == dreg");
              <D.24398>:
              sregs[i] = sreg1;
              mono_inst_set_src_registers (ins, &sregs);
              goto <D.24399>;
              <D.24393>:
              D.24386 = ins->opcode;
              D.24402 = D.24386 + 65162;
              if (D.24402 <= 13) goto <D.24403>; else goto <D.24400>;
              <D.24403>:
              D.24404 = ins->dreg;
              if (D.24404 == dreg) goto <D.24405>; else goto <D.24400>;
              <D.24405>:
              ins->dreg = sreg1;
              goto <D.24401>;
              <D.24400>:
              D.24386 = ins->opcode;
              D.24406 = D.24386 + 65217;
              if (D.24406 <= 2) goto <D.24407>; else goto <D.24408>;
              <D.24407>:
              D.24409 = ins->data.op[1].phi_args;
              i = *D.24409;
              goto <D.22574>;
              <D.22573>:
              {
                int sreg;

                D.24409 = ins->data.op[1].phi_args;
                D.24410 = (long unsigned int) i;
                D.24411 = D.24410 * 4;
                D.24412 = D.24409 + D.24411;
                sreg = *D.24412;
                D.24413 = var->dreg;
                if (D.24413 == sreg) goto <D.22572>; else goto <D.24414>;
                <D.24414>:
              }
              i = i + -1;
              <D.22574>:
              if (i > 0) goto <D.22573>; else goto <D.22572>;
              <D.22572>:
              D.24415 = i <= 0;
              D.24416 = (long int) D.24415;
              D.24417 = __builtin_expect (D.24416, 0);
              if (D.24417 != 0) goto <D.24418>; else goto <D.24419>;
              <D.24418>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 713, "i > 0");
              <D.24419>:
              D.24409 = ins->data.op[1].phi_args;
              D.24410 = (long unsigned int) i;
              D.24411 = D.24410 * 4;
              D.24412 = D.24409 + D.24411;
              *D.24412 = sreg1;
              goto <D.24420>;
              <D.24408>:
              monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "ssa.c", 717);
              <D.24420>:
              <D.24401>:
              <D.24399>:
              D.24421 = u->bb;
              record_use (cfg, var2, D.24421, ins);
              l = next;
            }
          finally
            {
              sregs = {CLOBBER};
            }
        }
        <D.22576>:
        if (l != 0B) goto <D.22575>; else goto <D.22577>;
        <D.22577>:
        info->uses = 0B;
      }
      <D.24382>:
      <D.24378>:
      <D.24371>:
      <D.24366>:
    }
    <D.24347>:
    <D.24350>:
  }
  index = index + 1;
  <D.22579>:
  index.48 = (unsigned int) index;
  D.24423 = cfg->num_varinfo;
  if (index.48 < D.24423) goto <D.22578>; else goto <D.22580>;
  <D.22580>:
  D.24424 = cfg->verbose_level;
  if (D.24424 > 3) goto <D.24425>; else goto <D.24426>;
  <D.24425>:
  {
    struct MonoBasicBlock * bb;

    bb = cfg->bb_entry;
    goto <D.22583>;
    <D.22582>:
    mono_print_bb (bb, "AFTER SSA COPYPROP");
    bb = bb->next_bb;
    <D.22583>:
    if (bb != 0B) goto <D.22582>; else goto <D.22584>;
    <D.22584>:
  }
  <D.24426>:
}


add_to_dce_worklist (struct MonoCompile * cfg, struct MonoMethodVar * var, struct MonoMethodVar * use, struct GList * * wl)
{
  struct MonoMemPool * D.24427;
  struct GList * D.24428;
  struct GList * D.24429;
  struct MonoInst * D.24430;
  struct MonoInst * D.24431;
  struct GList * D.24434;
  struct GList * D.24435;
  struct GList * tmp;

  D.24427 = cfg->mempool;
  D.24428 = *wl;
  D.24429 = g_list_prepend_mempool (D.24427, D.24428, use);
  *wl = D.24429;
  tmp = use->uses;
  goto <D.22733>;
  <D.22732>:
  {
    struct MonoVarUsageInfo * ui;

    ui = tmp->data;
    D.24430 = ui->inst;
    D.24431 = var->def;
    if (D.24430 == D.24431) goto <D.24432>; else goto <D.24433>;
    <D.24432>:
    D.24434 = use->uses;
    D.24435 = monoeg_g_list_remove_link (D.24434, tmp);
    use->uses = D.24435;
    goto <D.22731>;
    <D.24433>:
  }
  tmp = tmp->next;
  <D.22733>:
  if (tmp != 0B) goto <D.22732>; else goto <D.22731>;
  <D.22731>:
}


mono_ssa_loop_invariant_code_motion (struct MonoCompile * cfg)
{
  unsigned int D.24436;
  unsigned int D.24437;
  _Bool D.24438;
  long int D.24439;
  long int D.24440;
  long unsigned int D.24443;
  long unsigned int D.24444;
  struct MonoBasicBlock * D.24447;
  struct MonoInst * iftmp.49;
  short unsigned int D.24456;
  long unsigned int D.24459;
  long unsigned int D.24460;
  <unnamed type> D.24463;
  struct MonoInst * D.24475;
  short unsigned int D.24477;
  struct MonoBasicBlock * D.24479;
  signed char D.24481;
  short unsigned int D.24483;
  short unsigned int D.24553;
  int D.24554;
  int D.24555;
  int D.24556;
  int D.24559;
  char D.24562;
  unsigned int D.24569;
  int D.24572;
  struct MonoInst * D.24573;
  struct MonoInst * D.24576;
  struct MonoInst * D.24579;
  struct MonoInst * D.24582;
  struct MonoInst * iftmp.50;
  unsigned int D.24592;
  struct MonoMethodVar * D.24593;
  long unsigned int D.24594;
  long unsigned int D.24595;
  unsigned int i.51;
  unsigned int D.24597;
  struct MonoBasicBlock * bb;
  struct MonoBasicBlock * h;
  struct MonoBasicBlock * idom;
  struct MonoInst * ins;
  struct MonoInst * n;
  struct MonoInst * tins;
  int i;

  D.24436 = cfg->comp_done;
  D.24437 = D.24436 & 32;
  D.24438 = D.24437 == 0;
  D.24439 = (long int) D.24438;
  D.24440 = __builtin_expect (D.24439, 0);
  if (D.24440 != 0) goto <D.24441>; else goto <D.24442>;
  <D.24441>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 1360, "cfg->comp_done & MONO_COMP_SSA");
  <D.24442>:
  D.24443 = BIT_FIELD_REF <*cfg, 64, 5376>;
  D.24444 = D.24443 & 1374389534720;
  if (D.24444 != 1374389534720) goto <D.24445>; else goto <D.24446>;
  <D.24445>:
  return;
  <D.24446>:
  D.24447 = cfg->bb_entry;
  bb = D.24447->next_bb;
  goto <D.22784>;
  <D.22783>:
  {
    struct GList * lp;

    lp = bb->loop_blocks;
    if (lp == 0B) goto <D.24448>; else goto <D.24449>;
    <D.24448>:
    // predicted unlikely by continue predictor.
    goto <D.22765>;
    <D.24449>:
    h = lp->data;
    if (bb != h) goto <D.24450>; else goto <D.24451>;
    <D.24450>:
    // predicted unlikely by continue predictor.
    goto <D.22765>;
    <D.24451>:
    ins = bb->code;
    if (ins != 0B) goto <D.24453>; else goto <D.24454>;
    <D.24453>:
    iftmp.49 = ins->next;
    goto <D.24455>;
    <D.24454>:
    iftmp.49 = 0B;
    <D.24455>:
    n = iftmp.49;
    goto <D.22781>;
    <D.22780>:
    {
      gboolean is_class_init;

      is_class_init = 0;
      D.24456 = ins->opcode;
      if (D.24456 == 343) goto <D.24457>; else goto <D.24458>;
      <D.24457>:
      {
        struct MonoCallInst * call;

        call = ins;
        D.24459 = BIT_FIELD_REF <*call, 64, 1088>;
        D.24460 = D.24459 & 4;
        if (D.24460 != 0) goto <D.24461>; else goto <D.24462>;
        <D.24461>:
        {
          struct MonoJumpInfo * ji;

          ji = call->fptr;
          D.24463 = ji->type;
          if (D.24463 == 15) goto <D.24464>; else goto <D.24465>;
          <D.24464>:
          is_class_init = 1;
          <D.24465>:
        }
        <D.24462>:
      }
      <D.24458>:
      D.24456 = ins->opcode;
      if (D.24456 == 783) goto <D.24466>; else goto <D.24468>;
      <D.24468>:
      D.24456 = ins->opcode;
      if (D.24456 == 781) goto <D.24466>; else goto <D.24469>;
      <D.24469>:
      D.24456 = ins->opcode;
      if (D.24456 == 340) goto <D.24466>; else goto <D.24470>;
      <D.24470>:
      D.24456 = ins->opcode;
      if (D.24456 == 732) goto <D.24466>; else goto <D.24471>;
      <D.24471>:
      if (is_class_init != 0) goto <D.24466>; else goto <D.24467>;
      <D.24466>:
      {
        gboolean skip;
        int sreg;

        idom = h->idom;
        if (idom == 0B) goto <D.24472>; else goto <D.24474>;
        <D.24474>:
        D.24475 = idom->last_ins;
        if (D.24475 == 0B) goto <D.24472>; else goto <D.24476>;
        <D.24476>:
        D.24475 = idom->last_ins;
        D.24477 = D.24475->opcode;
        if (D.24477 != 442) goto <D.24472>; else goto <D.24478>;
        <D.24478>:
        D.24475 = idom->last_ins;
        D.24479 = D.24475->data.op[0].target_block;
        if (D.24479 != h) goto <D.24472>; else goto <D.24480>;
        <D.24480>:
        D.24481 = h->nesting;
        if (D.24481 != 1) goto <D.24472>; else goto <D.24473>;
        <D.24472>:
        // predicted unlikely by continue predictor.
        goto <D.22771>;
        <D.24473>:
        skip = 0;
        tins = bb->code;
        goto <D.22774>;
        <D.22773>:
        if (tins == ins) goto <D.22772>; else goto <D.24482>;
        <D.24482>:
        D.24483 = tins->opcode;
        if (D.24483 != 424) goto <D.24484>; else goto <D.24485>;
        <D.24484>:
        D.24483 = tins->opcode;
        if (D.24483 != 426) goto <D.24486>; else goto <D.24487>;
        <D.24486>:
        D.24483 = tins->opcode;
        if (D.24483 != 427) goto <D.24488>; else goto <D.24489>;
        <D.24488>:
        D.24483 = tins->opcode;
        if (D.24483 != 362) goto <D.24490>; else goto <D.24491>;
        <D.24490>:
        D.24483 = tins->opcode;
        if (D.24483 != 363) goto <D.24492>; else goto <D.24493>;
        <D.24492>:
        D.24483 = tins->opcode;
        if (D.24483 != 428) goto <D.24494>; else goto <D.24495>;
        <D.24494>:
        D.24483 = tins->opcode;
        if (D.24483 != 429) goto <D.24496>; else goto <D.24497>;
        <D.24496>:
        D.24483 = tins->opcode;
        if (D.24483 != 365) goto <D.24498>; else goto <D.24499>;
        <D.24498>:
        D.24483 = tins->opcode;
        if (D.24483 != 538) goto <D.24500>; else goto <D.24501>;
        <D.24500>:
        D.24483 = tins->opcode;
        if (D.24483 != 626) goto <D.24502>; else goto <D.24503>;
        <D.24502>:
        D.24483 = tins->opcode;
        if (D.24483 != 625) goto <D.24504>; else goto <D.24505>;
        <D.24504>:
        D.24483 = tins->opcode;
        if (D.24483 != 492) goto <D.24506>; else goto <D.24507>;
        <D.24506>:
        D.24483 = tins->opcode;
        if (D.24483 != 566) goto <D.24508>; else goto <D.24509>;
        <D.24508>:
        D.24483 = tins->opcode;
        if (D.24483 != 817) goto <D.24510>; else goto <D.24511>;
        <D.24510>:
        D.24483 = tins->opcode;
        if (D.24483 != 635) goto <D.24512>; else goto <D.24513>;
        <D.24512>:
        D.24483 = tins->opcode;
        if (D.24483 != 636) goto <D.24514>; else goto <D.24515>;
        <D.24514>:
        D.24483 = tins->opcode;
        if (D.24483 != 637) goto <D.24516>; else goto <D.24517>;
        <D.24516>:
        D.24483 = tins->opcode;
        if (D.24483 != 632) goto <D.24518>; else goto <D.24519>;
        <D.24518>:
        D.24483 = tins->opcode;
        if (D.24483 != 591) goto <D.24520>; else goto <D.24521>;
        <D.24520>:
        D.24483 = tins->opcode;
        if (D.24483 != 580) goto <D.24522>; else goto <D.24523>;
        <D.24522>:
        D.24483 = tins->opcode;
        if (D.24483 != 762) goto <D.24524>; else goto <D.24525>;
        <D.24524>:
        D.24483 = tins->opcode;
        if (D.24483 != 503) goto <D.24526>; else goto <D.24527>;
        <D.24526>:
        D.24483 = tins->opcode;
        if (D.24483 != 590) goto <D.24528>; else goto <D.24529>;
        <D.24528>:
        D.24483 = tins->opcode;
        if (D.24483 != 581) goto <D.24530>; else goto <D.24531>;
        <D.24530>:
        D.24483 = tins->opcode;
        if (D.24483 != 495) goto <D.24532>; else goto <D.24533>;
        <D.24532>:
        D.24483 = tins->opcode;
        if (D.24483 != 314) goto <D.24534>; else goto <D.24535>;
        <D.24534>:
        D.24483 = tins->opcode;
        if (D.24483 != 319) goto <D.24536>; else goto <D.24537>;
        <D.24536>:
        D.24483 = tins->opcode;
        if (D.24483 != 316) goto <D.24538>; else goto <D.24539>;
        <D.24538>:
        D.24483 = tins->opcode;
        if (D.24483 != 765) goto <D.24540>; else goto <D.24541>;
        <D.24540>:
        D.24483 = tins->opcode;
        if (D.24483 != 799) goto <D.24542>; else goto <D.24543>;
        <D.24542>:
        skip = 1;
        goto <D.22772>;
        <D.24543>:
        <D.24541>:
        <D.24539>:
        <D.24537>:
        <D.24535>:
        <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>:
        tins = tins->next;
        <D.22774>:
        if (tins != 0B) goto <D.22773>; else goto <D.22772>;
        <D.22772>:
        if (skip != 0) goto <D.24544>; else goto <D.24545>;
        <D.24544>:
        // predicted unlikely by continue predictor.
        goto <D.22771>;
        <D.24545>:
        D.24456 = ins->opcode;
        if (D.24456 == 783) goto <D.24546>; else goto <D.24549>;
        <D.24549>:
        D.24456 = ins->opcode;
        if (D.24456 == 781) goto <D.24546>; else goto <D.24550>;
        <D.24550>:
        D.24456 = ins->opcode;
        if (D.24456 == 340) goto <D.24546>; else goto <D.24547>;
        <D.24546>:
        sreg = ins->sreg1;
        goto <D.24548>;
        <D.24547>:
        sreg = -1;
        <D.24548>:
        if (sreg != -1) goto <D.24551>; else goto <D.24552>;
        <D.24551>:
        {
          struct MonoInst * tins;

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

            D.24553 = tins->opcode;
            D.24554 = (int) D.24553;
            D.24555 = D.24554 + -313;
            D.24556 = D.24555 * 4;
            spec = &ins_info[D.24556];
            D.24553 = tins->opcode;
            if (D.24553 == 424) goto <D.24557>; else goto <D.24558>;
            <D.24557>:
            D.24559 = tins->dreg;
            if (D.24559 == sreg) goto <D.24560>; else goto <D.24561>;
            <D.24560>:
            sreg = tins->sreg1;
            <D.24561>:
            <D.24558>:
            D.24562 = *spec;
            if (D.24562 != 32) goto <D.24563>; else goto <D.24564>;
            <D.24563>:
            D.24559 = tins->dreg;
            if (D.24559 == sreg) goto <D.24565>; else goto <D.24566>;
            <D.24565>:
            skip = 1;
            goto <D.22777>;
            <D.24566>:
            <D.24564>:
          }
          tins = tins->prev;
          <D.22779>:
          if (tins != 0B) goto <D.22778>; else goto <D.22777>;
          <D.22777>:
          if (skip != 0) goto <D.24567>; else goto <D.24568>;
          <D.24567>:
          // predicted unlikely by continue predictor.
          goto <D.22771>;
          <D.24568>:
          ins->sreg1 = sreg;
        }
        <D.24552>:
        D.24569 = cfg->verbose_level;
        if (D.24569 > 1) goto <D.24570>; else goto <D.24571>;
        <D.24570>:
        D.24572 = bb->block_num;
        printf ("licm in BB%d on ", D.24572);
        mono_print_ins (ins);
        <D.24571>:
        D.24573 = ins->prev;
        if (D.24573 != 0B) goto <D.24574>; else goto <D.24575>;
        <D.24574>:
        D.24573 = ins->prev;
        D.24576 = ins->next;
        D.24573->next = D.24576;
        <D.24575>:
        D.24576 = ins->next;
        if (D.24576 != 0B) goto <D.24577>; else goto <D.24578>;
        <D.24577>:
        D.24576 = ins->next;
        D.24573 = ins->prev;
        D.24576->prev = D.24573;
        <D.24578>:
        D.24579 = bb->code;
        if (D.24579 == ins) goto <D.24580>; else goto <D.24581>;
        <D.24580>:
        D.24576 = ins->next;
        bb->code = D.24576;
        <D.24581>:
        D.24582 = bb->last_ins;
        if (D.24582 == ins) goto <D.24583>; else goto <D.24584>;
        <D.24583>:
        D.24573 = ins->prev;
        bb->last_ins = D.24573;
        <D.24584>:
        D.24475 = idom->last_ins;
        mono_bblock_insert_before_ins (idom, D.24475, ins);
        D.24456 = ins->opcode;
        if (D.24456 == 783) goto <D.24585>; else goto <D.24587>;
        <D.24587>:
        D.24456 = ins->opcode;
        if (D.24456 == 781) goto <D.24585>; else goto <D.24586>;
        <D.24585>:
        idom->has_array_access = 1;
        <D.24586>:
      }
      <D.24467>:
    }
    <D.22771>:
    ins = n;
    if (ins != 0B) goto <D.24589>; else goto <D.24590>;
    <D.24589>:
    iftmp.50 = ins->next;
    goto <D.24591>;
    <D.24590>:
    iftmp.50 = 0B;
    <D.24591>:
    n = iftmp.50;
    <D.22781>:
    if (ins != 0B) goto <D.22780>; else goto <D.22782>;
    <D.22782>:
  }
  <D.22765>:
  bb = bb->next_bb;
  <D.22784>:
  if (bb != 0B) goto <D.22783>; else goto <D.22785>;
  <D.22785>:
  D.24436 = cfg->comp_done;
  D.24592 = D.24436 & 4294967231;
  cfg->comp_done = D.24592;
  i = 0;
  goto <D.22788>;
  <D.22787>:
  {
    struct MonoMethodVar * info;

    D.24593 = cfg->vars;
    D.24594 = (long unsigned int) i;
    D.24595 = D.24594 * 80;
    info = D.24593 + D.24595;
    info->def = 0B;
    info->uses = 0B;
  }
  i = i + 1;
  <D.22788>:
  i.51 = (unsigned int) i;
  D.24597 = cfg->num_varinfo;
  if (i.51 < D.24597) goto <D.22787>; else goto <D.22789>;
  <D.22789>:
}