mono_ssa_compute (struct MonoCompile * cfg)
{
  unsigned int D.24777;
  unsigned int D.24778;
  unsigned int D.24779;
  unsigned int D.24780;
  _Bool D.24781;
  long int D.24782;
  long int D.24783;
  unsigned char D.24786;
  unsigned char D.24787;
  _Bool D.24788;
  long int D.24789;
  long int D.24790;
  unsigned int D.24793;
  unsigned int D.24796;
  unsigned int D.24797;
  unsigned int D.24800;
  unsigned int D.24801;
  unsigned int D.24802;
  unsigned int D.24803;
  unsigned int i.0;
  unsigned int D.24805;
  struct MonoMethodVar * D.24806;
  struct MonoBitSet * D.24807;
  sizetype bitsize.1;
  unsigned int i.2;
  struct MonoInst * * D.24810;
  unsigned int D.24811;
  struct MonoInst * * D.24812;
  struct MonoInst * D.24813;
  short unsigned int D.24814;
  struct MonoBitSet * D.24817;
  unsigned int D.24818;
  unsigned int D.24819;
  struct MonoBasicBlock * * D.24820;
  struct MonoBasicBlock * * D.24821;
  struct MonoBasicBlock * D.24822;
  short unsigned int D.24823;
  short unsigned int D.24826;
  int D.24829;
  unsigned int D.24830;
  unsigned int D.24831;
  struct MonoInst * * D.24834;
  unsigned int D.24835;
  unsigned int D.24836;
  struct MonoInst * * D.24837;
  struct MonoInst * D.24838;
  struct MonoInst * iftmp.3;
  int D.24845;
  unsigned int D.24846;
  unsigned int D.24847;
  struct MonoMethodVar * D.24848;
  struct MonoBitSet * D.24849;
  unsigned int D.24850;
  struct MonoInst * iftmp.4;
  int D.24855;
  unsigned int D.24856;
  unsigned int D.24857;
  struct MonoMethodVar * D.24858;
  struct MonoBitSet * D.24859;
  unsigned int D.24860;
  int D.24861;
  unsigned int D.24862;
  unsigned int D.24863;
  unsigned char D.24864;
  unsigned char D.24867;
  int D.24868;
  int D.24869;
  unsigned int D.24872;
  unsigned int D.24877;
  int D.24880;
  unsigned int idx.5;
  unsigned int D.24882;
  struct MonoBasicBlock * * D.24883;
  struct MonoBasicBlock * D.24884;
  struct MonoBitSet * D.24889;
  unsigned int D.24890;
  unsigned int D.24891;
  unsigned int D.24892;
  struct MonoMemPool * D.24895;
  int D.24896;
  int D.24897;
  int D.24898;
  struct MonoType * D.24900;
  unsigned char D.24901;
  unsigned char D.24902;
  struct MonoClass * D.24905;
  struct MonoClass * D.24907;
  struct MonoBasicBlock * D.24908;
  short int D.24909;
  int D.24910;
  int D.24911;
  unsigned int D.24912;
  unsigned int D.24913;
  void * D.24914;
  int * D.24915;
  sizetype j.6;
  sizetype D.24917;
  sizetype D.24918;
  int * D.24919;
  int D.24920;
  struct MonoInst * D.24921;
  unsigned int idx.7;
  unsigned int D.24924;
  unsigned int D.24925;
  unsigned int stack_history_size.8;
  unsigned int D.24927;
  int D.24928;
  struct MonoBasicBlock * D.24929;
  unsigned int D.24932;
  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.24777 = cfg->num_varinfo;
  D.24778 = D.24777 * 56;
  vinfo = monoeg_malloc0 (D.24778);
  D.24779 = cfg->comp_done;
  D.24780 = D.24779 & 32;
  D.24781 = D.24780 != 0;
  D.24782 = (long int) D.24781;
  D.24783 = __builtin_expect (D.24782, 0);
  if (D.24783 != 0) goto <D.24784>; else goto <D.24785>;
  <D.24784>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 342, "!(cfg->comp_done & MONO_COMP_SSA)");
  <D.24785>:
  D.24786 = BIT_FIELD_REF <*cfg, 8, 3392>;
  D.24787 = D.24786 & 2;
  D.24788 = D.24787 != 0;
  D.24789 = (long int) D.24788;
  D.24790 = __builtin_expect (D.24789, 0);
  if (D.24790 != 0) goto <D.24791>; else goto <D.24792>;
  <D.24791>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 344, "!cfg->disable_ssa");
  <D.24792>:
  D.24793 = cfg->verbose_level;
  if (D.24793 > 3) goto <D.24794>; else goto <D.24795>;
  <D.24794>:
  D.24777 = cfg->num_varinfo;
  D.24796 = cfg->next_vreg;
  printf ("\nCOMPUTE SSA %d (R%d-)\n\n", D.24777, D.24796);
  <D.24795>:
  D.24779 = cfg->comp_done;
  D.24797 = D.24779 & 16;
  if (D.24797 == 0) goto <D.24798>; else goto <D.24799>;
  <D.24798>:
  mono_analyze_liveness (cfg);
  <D.24799>:
  mono_compile_dominator_info (cfg, 7);
  D.24800 = cfg->num_bblocks;
  D.24801 = mono_bitset_alloc_size (D.24800, 0);
  bitsize = (int) D.24801;
  D.24800 = cfg->num_bblocks;
  D.24802 = mono_bitset_alloc_size (D.24800, 0);
  D.24777 = cfg->num_varinfo;
  D.24803 = D.24802 * D.24777;
  buf_start = monoeg_malloc0 (D.24803);
  buf = buf_start;
  i = 0;
  goto <D.24430>;
  <D.24429>:
  i.0 = (unsigned int) i;
  D.24805 = i.0 * 56;
  D.24806 = vinfo + D.24805;
  D.24800 = cfg->num_bblocks;
  D.24807 = mono_bitset_mem_new (buf, D.24800, 0);
  D.24806->def_in = D.24807;
  bitsize.1 = (sizetype) bitsize;
  buf = buf + bitsize.1;
  i.0 = (unsigned int) i;
  D.24805 = i.0 * 56;
  D.24806 = vinfo + D.24805;
  i.2 = (unsigned int) i;
  D.24806->idx = i.2;
  D.24810 = cfg->varinfo;
  i.0 = (unsigned int) i;
  D.24811 = i.0 * 4;
  D.24812 = D.24810 + D.24811;
  D.24813 = *D.24812;
  D.24814 = D.24813->opcode;
  if (D.24814 == 330) goto <D.24815>; else goto <D.24816>;
  <D.24815>:
  i.0 = (unsigned int) i;
  D.24805 = i.0 * 56;
  D.24806 = vinfo + D.24805;
  D.24817 = D.24806->def_in;
  i.0 = (unsigned int) i;
  D.24805 = i.0 * 56;
  D.24806 = vinfo + D.24805;
  D.24817 = D.24806->def_in;
  D.24818 = D.24817->data[0];
  D.24819 = D.24818 | 1;
  D.24817->data[0] = D.24819;
  <D.24816>:
  i = i + 1;
  <D.24430>:
  i.2 = (unsigned int) i;
  D.24777 = cfg->num_varinfo;
  if (i.2 < D.24777) goto <D.24429>; else goto <D.24431>;
  <D.24431>:
  i = 0;
  goto <D.24437>;
  <D.24436>:
  D.24820 = cfg->bblocks;
  i.0 = (unsigned int) i;
  D.24811 = i.0 * 4;
  D.24821 = D.24820 + D.24811;
  D.24822 = *D.24821;
  ins = D.24822->code;
  goto <D.24434>;
  <D.24433>:
  D.24823 = ins->opcode;
  if (D.24823 == 316) goto <D.24824>; else goto <D.24825>;
  <D.24824>:
  // predicted unlikely by continue predictor.
  goto <D.24432>;
  <D.24825>:
  D.24823 = ins->opcode;
  D.24826 = D.24823 + 65162;
  if (D.24826 > 13) goto <D.24827>; else goto <D.24828>;
  <D.24827>:
  D.24829 = ins->dreg;
  D.24830 = (unsigned int) D.24829;
  D.24831 = cfg->vreg_to_inst_len;
  if (D.24830 < D.24831) goto <D.24832>; else goto <D.24833>;
  <D.24832>:
  D.24834 = cfg->vreg_to_inst;
  D.24829 = ins->dreg;
  D.24835 = (unsigned int) D.24829;
  D.24836 = D.24835 * 4;
  D.24837 = D.24834 + D.24836;
  D.24838 = *D.24837;
  if (D.24838 != 0B) goto <D.24839>; else goto <D.24840>;
  <D.24839>:
  D.24829 = ins->dreg;
  D.24830 = (unsigned int) D.24829;
  D.24831 = cfg->vreg_to_inst_len;
  if (D.24830 < D.24831) goto <D.24842>; else goto <D.24843>;
  <D.24842>:
  D.24834 = cfg->vreg_to_inst;
  D.24829 = ins->dreg;
  D.24835 = (unsigned int) D.24829;
  D.24836 = D.24835 * 4;
  D.24837 = D.24834 + D.24836;
  iftmp.3 = *D.24837;
  goto <D.24844>;
  <D.24843>:
  iftmp.3 = 0B;
  <D.24844>:
  D.24845 = iftmp.3->data.op[0].const_val;
  D.24846 = (unsigned int) D.24845;
  D.24847 = D.24846 * 56;
  D.24848 = vinfo + D.24847;
  D.24849 = D.24848->def_in;
  i.0 = (unsigned int) i;
  D.24850 = i.0 / 32;
  D.24829 = ins->dreg;
  D.24830 = (unsigned int) D.24829;
  D.24831 = cfg->vreg_to_inst_len;
  if (D.24830 < D.24831) goto <D.24852>; else goto <D.24853>;
  <D.24852>:
  D.24834 = cfg->vreg_to_inst;
  D.24829 = ins->dreg;
  D.24835 = (unsigned int) D.24829;
  D.24836 = D.24835 * 4;
  D.24837 = D.24834 + D.24836;
  iftmp.4 = *D.24837;
  goto <D.24854>;
  <D.24853>:
  iftmp.4 = 0B;
  <D.24854>:
  D.24855 = iftmp.4->data.op[0].const_val;
  D.24856 = (unsigned int) D.24855;
  D.24857 = D.24856 * 56;
  D.24858 = vinfo + D.24857;
  D.24859 = D.24858->def_in;
  D.24860 = D.24859->data[D.24850];
  D.24861 = i & 31;
  D.24862 = 1 << D.24861;
  D.24863 = D.24860 | D.24862;
  D.24849->data[D.24850] = D.24863;
  <D.24840>:
  <D.24833>:
  <D.24828>:
  <D.24432>:
  ins = ins->next;
  <D.24434>:
  if (ins != 0B) goto <D.24433>; else goto <D.24435>;
  <D.24435>:
  i = i + 1;
  <D.24437>:
  i.2 = (unsigned int) i;
  D.24800 = cfg->num_bblocks;
  if (i.2 < D.24800) goto <D.24436>; else goto <D.24438>;
  <D.24438>:
  i = 0;
  goto <D.24458>;
  <D.24457>:
  {
    struct MonoInst * var;

    D.24810 = cfg->varinfo;
    i.0 = (unsigned int) i;
    D.24811 = i.0 * 4;
    D.24812 = D.24810 + D.24811;
    var = *D.24812;
    D.24864 = var->type;
    if (D.24864 == 2) goto <D.24865>; else goto <D.24866>;
    <D.24865>:
    // predicted unlikely by continue predictor.
    goto <D.24440>;
    <D.24866>:
    D.24867 = var->flags;
    D.24868 = (int) D.24867;
    D.24869 = D.24868 & 20;
    if (D.24869 != 0) goto <D.24870>; else goto <D.24871>;
    <D.24870>:
    // predicted unlikely by continue predictor.
    goto <D.24440>;
    <D.24871>:
    i.0 = (unsigned int) i;
    D.24805 = i.0 * 56;
    D.24806 = vinfo + D.24805;
    D.24817 = D.24806->def_in;
    D.24872 = mono_bitset_count (D.24817);
    if (D.24872 <= 1) goto <D.24873>; else goto <D.24874>;
    <D.24873>:
    // predicted unlikely by continue predictor.
    goto <D.24440>;
    <D.24874>:
    i.0 = (unsigned int) i;
    D.24805 = i.0 * 56;
    D.24806 = vinfo + D.24805;
    D.24817 = D.24806->def_in;
    set = mono_compile_iterated_dfrontier (cfg, D.24817);
    D.24793 = cfg->verbose_level;
    if (D.24793 > 3) goto <D.24875>; else goto <D.24876>;
    <D.24875>:
    D.24877 = mono_bitset_count (set);
    if (D.24877 != 0) goto <D.24878>; else goto <D.24879>;
    <D.24878>:
    D.24880 = var->dreg;
    printf ("\tR%d needs PHI functions in ", D.24880);
    mono_blockset_print (cfg, set, "", 4294967295);
    <D.24879>:
    <D.24876>:
    idx = mono_bitset_find_start (set);
    goto <D.24455>;
    <D.24454>:
    {
      struct MonoBasicBlock * bb;

      D.24820 = cfg->bblocks;
      idx.5 = (unsigned int) idx;
      D.24882 = idx.5 * 4;
      D.24883 = D.24820 + D.24882;
      bb = *D.24883;
      D.24884 = cfg->bb_exit;
      if (D.24884 == bb) goto <D.24885>; else goto <D.24886>;
      <D.24885>:
      // predicted unlikely by continue predictor.
      goto <D.24442>;
      <D.24886>:
      D.24779 = cfg->comp_done;
      D.24797 = D.24779 & 16;
      if (D.24797 != 0) goto <D.24887>; else goto <D.24888>;
      <D.24887>:
      D.24889 = bb->live_in_set;
      i.0 = (unsigned int) i;
      D.24890 = i.0 / 32;
      D.24891 = D.24889->data[D.24890];
      D.24861 = i & 31;
      D.24862 = 1 << D.24861;
      D.24892 = D.24891 & D.24862;
      if (D.24892 == 0) goto <D.24893>; else goto <D.24894>;
      <D.24893>:
      // predicted unlikely by continue predictor.
      goto <D.24442>;
      <D.24894>:
      <D.24888>:
      D.24895 = cfg->mempool;
      ins = mono_mempool_alloc0 (D.24895, 56);
      ins->opcode = 319;
      ins->data.op[0].const_val = i;
      ins->sreg2 = -1;
      D.24896 = ins->sreg2;
      ins->sreg1 = D.24896;
      D.24897 = ins->sreg1;
      ins->dreg = D.24897;
      D.24864 = var->type;
      D.24898 = (int) D.24864;
      switch (D.24898) <default: <D.24899>, case 1: <D.24443>, case 2: <D.24444>, case 3: <D.24445>, case 4: <D.24449>, case 5: <D.24446>, case 6: <D.24447>, case 7: <D.24450>>
      <D.24443>:
      <D.24444>:
      <D.24445>:
      <D.24446>:
      <D.24447>:
      ins->opcode = 319;
      goto <D.24448>;
      <D.24449>:
      ins->opcode = 320;
      goto <D.24448>;
      <D.24450>:
      ins->opcode = 321;
      goto <D.24448>;
      <D.24899>:
      <D.24448>:
      D.24900 = var->data.op[1].vtype;
      D.24901 = BIT_FIELD_REF <*D.24900, 8, 56>;
      D.24902 = D.24901 & 64;
      if (D.24902 != 0) goto <D.24903>; else goto <D.24904>;
      <D.24903>:
      D.24905 = mono_defaults.int_class;
      ins->klass = D.24905;
      goto <D.24906>;
      <D.24904>:
      D.24907 = var->klass;
      ins->klass = D.24907;
      <D.24906>:
      D.24895 = cfg->mempool;
      D.24820 = cfg->bblocks;
      idx.5 = (unsigned int) idx;
      D.24882 = idx.5 * 4;
      D.24883 = D.24820 + D.24882;
      D.24908 = *D.24883;
      D.24909 = D.24908->in_count;
      D.24910 = (int) D.24909;
      D.24911 = D.24910 + 1;
      D.24912 = (unsigned int) D.24911;
      D.24913 = D.24912 * 4;
      D.24914 = mono_mempool_alloc0 (D.24895, D.24913);
      ins->data.op[1].phi_args = D.24914;
      D.24915 = ins->data.op[1].phi_args;
      D.24820 = cfg->bblocks;
      idx.5 = (unsigned int) idx;
      D.24882 = idx.5 * 4;
      D.24883 = D.24820 + D.24882;
      D.24908 = *D.24883;
      D.24909 = D.24908->in_count;
      D.24910 = (int) D.24909;
      *D.24915 = D.24910;
      j = 0;
      goto <D.24452>;
      <D.24451>:
      D.24915 = ins->data.op[1].phi_args;
      j.6 = (sizetype) j;
      D.24917 = j.6 + 1;
      D.24918 = D.24917 * 4;
      D.24919 = D.24915 + D.24918;
      *D.24919 = -1;
      j = j + 1;
      <D.24452>:
      D.24820 = cfg->bblocks;
      idx.5 = (unsigned int) idx;
      D.24882 = idx.5 * 4;
      D.24883 = D.24820 + D.24882;
      D.24908 = *D.24883;
      D.24909 = D.24908->in_count;
      D.24910 = (int) D.24909;
      if (D.24910 > j) goto <D.24451>; else goto <D.24453>;
      <D.24453>:
      D.24810 = cfg->varinfo;
      i.0 = (unsigned int) i;
      D.24811 = i.0 * 4;
      D.24812 = D.24810 + D.24811;
      D.24813 = *D.24812;
      D.24920 = D.24813->dreg;
      ins->dreg = D.24920;
      D.24921 = bb->code;
      mono_bblock_insert_before_ins (bb, D.24921, ins);
    }
    <D.24442>:
    idx = mono_bitset_find_first (set, idx);
    <D.24455>:
    idx.7 = (unsigned int) idx;
    D.24800 = cfg->num_bblocks;
    if (idx.7 < D.24800) goto <D.24923>; else goto <D.24456>;
    <D.24923>:
    if (idx >= 0) goto <D.24454>; else goto <D.24456>;
    <D.24456>:
  }
  <D.24440>:
  i = i + 1;
  <D.24458>:
  i.2 = (unsigned int) i;
  D.24777 = cfg->num_varinfo;
  if (i.2 < D.24777) goto <D.24457>; else goto <D.24459>;
  <D.24459>:
  monoeg_g_free (vinfo);
  monoeg_g_free (buf_start);
  D.24777 = cfg->num_varinfo;
  D.24924 = D.24777 * 4;
  stack = __builtin_alloca (D.24924);
  D.24777 = cfg->num_varinfo;
  D.24924 = D.24777 * 4;
  memset (stack, 0, D.24924);
  D.24796 = cfg->next_vreg;
  D.24925 = D.24796 * 4;
  lvreg_stack = monoeg_malloc0 (D.24925);
  D.24796 = cfg->next_vreg;
  D.24925 = D.24796 * 4;
  lvreg_defined = monoeg_malloc0 (D.24925);
  stack_history_size = 10240;
  stack_history_size.8 = (unsigned int) stack_history_size;
  D.24927 = stack_history_size.8 * 8;
  stack_history = monoeg_malloc (D.24927);
  D.24777 = cfg->num_varinfo;
  D.24924 = D.24777 * 4;
  originals = monoeg_malloc0 (D.24924);
  D.24777 = cfg->num_varinfo;
  D.24928 = (int) D.24777;
  D.24929 = cfg->bb_entry;
  mono_ssa_rename_vars (cfg, D.24928, D.24929, 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.24793 = cfg->verbose_level;
  if (D.24793 > 3) goto <D.24930>; else goto <D.24931>;
  <D.24930>:
  printf ("\nEND COMPUTE SSA.\n\n");
  <D.24931>:
  D.24779 = cfg->comp_done;
  D.24932 = D.24779 | 32;
  cfg->comp_done = D.24932;
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.24935;
  int D.24940;
  void * D.24942;
  unsigned int D.24943;

  D.24935 = __builtin_constant_p (__len);
  if (D.24935 != 0) goto <D.24936>; else goto <D.24937>;
  <D.24936>:
  if (__len == 0) goto <D.24938>; else goto <D.24939>;
  <D.24938>:
  D.24940 = __builtin_constant_p (__ch);
  if (D.24940 == 0) goto <D.24933>; else goto <D.24941>;
  <D.24941>:
  if (__ch != 0) goto <D.24933>; else goto <D.24934>;
  <D.24933>:
  __warn_memset_zero_len ();
  D.24942 = __dest;
  return D.24942;
  <D.24934>:
  <D.24939>:
  <D.24937>:
  D.24943 = __builtin_object_size (__dest, 0);
  D.24942 = __builtin___memset_chk (__dest, __ch, __len, D.24943);
  return D.24942;
}


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.24945;
  int D.24948;
  short unsigned int D.24949;
  int D.24950;
  int D.24951;
  int D.24952;
  int D.24955;
  int D.24956;
  int D.24957;
  signed char D.24958;
  int D.24959;
  sizetype D.24960;
  const char * D.24961;
  char D.24962;
  struct MonoInst * iftmp.9;
  int D.24966;
  unsigned int D.24967;
  unsigned int D.24968;
  struct MonoInst * * D.24971;
  unsigned int D.24972;
  unsigned int D.24973;
  struct MonoInst * * D.24974;
  unsigned char D.24979;
  int D.24980;
  int D.24981;
  unsigned int idx.10;
  unsigned int D.24984;
  struct MonoInst * * D.24985;
  struct MonoInst * D.24986;
  short unsigned int D.24989;
  _Bool D.24992;
  long int D.24993;
  long int D.24994;
  int D.24997;
  int iftmp.11;
  guint32 * D.25003;
  unsigned int D.25004;
  _Bool D.25006;
  long int D.25007;
  long int D.25008;
  int D.25011;
  short unsigned int D.25012;
  struct MonoInst * iftmp.12;
  int D.25016;
  unsigned int D.25017;
  unsigned int D.25020;
  unsigned int D.25021;
  struct MonoInst * * D.25022;
  unsigned char D.25027;
  int D.25028;
  int D.25029;
  unsigned int idx.13;
  unsigned int D.25032;
  struct MonoInst * * D.25033;
  struct MonoInst * D.25034;
  short unsigned int D.25037;
  _Bool D.25040;
  long int D.25041;
  long int D.25042;
  int D.25045;
  int iftmp.14;
  guint32 * D.25051;
  unsigned int D.25052;
  _Bool D.25054;
  long int D.25055;
  long int D.25056;
  int D.25059;
  char D.25060;
  struct MonoInst * iftmp.15;
  unsigned char D.25072;
  int D.25073;
  int D.25074;
  _Bool D.25076;
  long int D.25077;
  long int D.25078;
  short unsigned int D.25081;
  unsigned int idx.16;
  unsigned int D.25085;
  gboolean * D.25086;
  _Bool D.25087;
  long int D.25088;
  long int D.25089;
  unsigned int stack_history_len.17;
  unsigned int D.25093;
  struct RenameInfo * D.25094;
  struct MonoInst * * D.25095;
  struct MonoInst * D.25096;
  int D.25097;
  struct MonoType * D.25100;
  struct MonoMethodVar * D.25101;
  int D.25102;
  unsigned int D.25103;
  unsigned int D.25104;
  struct MonoMethodVar * D.25105;
  int D.25108;
  int D.25109;
  int D.25111;
  unsigned int D.25112;
  unsigned int D.25113;
  int iftmp.18;
  gboolean * D.25118;
  int D.25119;
  _Bool D.25122;
  long int D.25123;
  long int D.25124;
  guint32 iftmp.19;
  unsigned int D.25130;
  gboolean * D.25132;
  gboolean * D.25133;
  int D.25134;
  struct MonoBasicBlock * * D.25137;
  unsigned int i.20;
  unsigned int D.25139;
  struct MonoBasicBlock * * D.25140;
  struct MonoBasicBlock * * D.25141;
  unsigned int j.21;
  unsigned int D.25143;
  struct MonoBasicBlock * * D.25144;
  struct MonoBasicBlock * D.25145;
  short int D.25147;
  int D.25148;
  short unsigned int D.25149;
  struct MonoInst * * D.25154;
  struct MonoInst * * D.25155;
  int * D.25156;
  sizetype j.22;
  sizetype D.25158;
  sizetype D.25159;
  int * D.25160;
  _Bool D.25161;
  long int D.25162;
  long int D.25163;
  int D.25166;
  short int D.25167;
  int D.25168;
  struct GSList * D.25169;
  void * D.25172;
  int D.25173;
  unsigned int D.25174;
  struct RenameInfo * D.25175;
  int D.25176;
  unsigned int D.25177;
  unsigned int D.25178;
  struct MonoInst * * D.25179;
  struct MonoInst * D.25180;
  unsigned int D.25181;
  unsigned int D.25182;
  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.24945 = cfg->verbose_level;
  if (D.24945 > 3) goto <D.24946>; else goto <D.24947>;
  <D.24946>:
  D.24948 = bb->block_num;
  printf ("\nRENAME VARS BLOCK %d:\n", D.24948);
  <D.24947>:
  ins = bb->code;
  goto <D.24393>;
  <D.24392>:
  {
    const char * spec;
    int num_sregs;
    int sregs[3];

    try
      {
        D.24949 = ins->opcode;
        D.24950 = (int) D.24949;
        D.24951 = D.24950 + -313;
        D.24952 = D.24951 * 4;
        spec = &ins_info[D.24952];
        D.24949 = ins->opcode;
        if (D.24949 == 316) goto <D.24953>; else goto <D.24954>;
        <D.24953>:
        // predicted unlikely by continue predictor.
        goto <D.24382>;
        <D.24954>:
        D.24955 = ins->sreg1;
        sregs[0] = D.24955;
        D.24956 = ins->sreg2;
        sregs[1] = D.24956;
        D.24957 = ins->sreg3;
        sregs[2] = D.24957;
        D.24949 = ins->opcode;
        D.24950 = (int) D.24949;
        D.24951 = D.24950 + -313;
        D.24958 = ins_sreg_counts[D.24951];
        num_sregs = (int) D.24958;
        i = 0;
        goto <D.24386>;
        <D.24385>:
        D.24959 = i + 1;
        D.24960 = (sizetype) D.24959;
        D.24961 = spec + D.24960;
        D.24962 = *D.24961;
        if (D.24962 != 32) goto <D.24963>; else goto <D.24964>;
        <D.24963>:
        {
          struct MonoInst * var;

          D.24966 = sregs[i];
          D.24967 = (unsigned int) D.24966;
          D.24968 = cfg->vreg_to_inst_len;
          if (D.24967 < D.24968) goto <D.24969>; else goto <D.24970>;
          <D.24969>:
          D.24971 = cfg->vreg_to_inst;
          D.24966 = sregs[i];
          D.24972 = (unsigned int) D.24966;
          D.24973 = D.24972 * 4;
          D.24974 = D.24971 + D.24973;
          iftmp.9 = *D.24974;
          goto <D.24975>;
          <D.24970>:
          iftmp.9 = 0B;
          <D.24975>:
          var = iftmp.9;
          if (var != 0B) goto <D.24978>; else goto <D.24976>;
          <D.24978>:
          D.24979 = var->flags;
          D.24980 = (int) D.24979;
          D.24981 = D.24980 & 20;
          if (D.24981 == 0) goto <D.24982>; else goto <D.24976>;
          <D.24982>:
          {
            int idx;

            idx = var->data.op[0].const_val;
            idx.10 = (unsigned int) idx;
            D.24984 = idx.10 * 4;
            D.24985 = stack + D.24984;
            D.24986 = *D.24985;
            if (D.24986 != 0B) goto <D.24987>; else goto <D.24988>;
            <D.24987>:
            D.24989 = var->opcode;
            if (D.24989 != 330) goto <D.24990>; else goto <D.24991>;
            <D.24990>:
            idx.10 = (unsigned int) idx;
            D.24984 = idx.10 * 4;
            D.24985 = stack + D.24984;
            D.24986 = *D.24985;
            D.24992 = D.24986 == 0B;
            D.24993 = (long int) D.24992;
            D.24994 = __builtin_expect (D.24993, 0);
            if (D.24994 != 0) goto <D.24995>; else goto <D.24996>;
            <D.24995>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 200, "stack [idx]");
            <D.24996>:
            <D.24991>:
            idx.10 = (unsigned int) idx;
            D.24984 = idx.10 * 4;
            D.24985 = stack + D.24984;
            D.24986 = *D.24985;
            D.24997 = D.24986->dreg;
            sregs[i] = D.24997;
            idx.10 = (unsigned int) idx;
            D.24984 = idx.10 * 4;
            D.24985 = stack + D.24984;
            D.24986 = *D.24985;
            record_use (cfg, D.24986, bb, ins);
            goto <D.24998>;
            <D.24988>:
            record_use (cfg, var, bb, ins);
            <D.24998>:
          }
          goto <D.24977>;
          <D.24976>:
          if (var == 0B) goto <D.25002>; else goto <D.25000>;
          <D.25002>:
          D.24966 = sregs[i];
          D.24972 = (unsigned int) D.24966;
          D.24973 = D.24972 * 4;
          D.25003 = lvreg_stack + D.24973;
          D.25004 = *D.25003;
          if (D.25004 != 0) goto <D.25005>; else goto <D.25000>;
          <D.25005>:
          iftmp.11 = 1;
          goto <D.25001>;
          <D.25000>:
          iftmp.11 = 0;
          <D.25001>:
          D.25006 = iftmp.11 != 0;
          D.25007 = (long int) D.25006;
          D.25008 = __builtin_expect (D.25007, 0);
          if (D.25008 != 0) goto <D.25009>; else goto <D.25010>;
          <D.25009>:
          D.24966 = sregs[i];
          D.24972 = (unsigned int) D.24966;
          D.24973 = D.24972 * 4;
          D.25003 = lvreg_stack + D.24973;
          D.25004 = *D.25003;
          D.25011 = (int) D.25004;
          sregs[i] = D.25011;
          <D.25010>:
          <D.24977>:
        }
        <D.24964>:
        i = i + 1;
        <D.24386>:
        if (i < num_sregs) goto <D.24385>; else goto <D.24387>;
        <D.24387>:
        mono_inst_set_src_registers (ins, &sregs);
        D.24949 = ins->opcode;
        D.25012 = D.24949 + 65162;
        if (D.25012 <= 13) goto <D.25013>; else goto <D.25014>;
        <D.25013>:
        {
          struct MonoInst * var;

          D.25016 = ins->dreg;
          D.25017 = (unsigned int) D.25016;
          D.24968 = cfg->vreg_to_inst_len;
          if (D.25017 < D.24968) goto <D.25018>; else goto <D.25019>;
          <D.25018>:
          D.24971 = cfg->vreg_to_inst;
          D.25016 = ins->dreg;
          D.25020 = (unsigned int) D.25016;
          D.25021 = D.25020 * 4;
          D.25022 = D.24971 + D.25021;
          iftmp.12 = *D.25022;
          goto <D.25023>;
          <D.25019>:
          iftmp.12 = 0B;
          <D.25023>:
          var = iftmp.12;
          if (var != 0B) goto <D.25026>; else goto <D.25024>;
          <D.25026>:
          D.25027 = var->flags;
          D.25028 = (int) D.25027;
          D.25029 = D.25028 & 20;
          if (D.25029 == 0) goto <D.25030>; else goto <D.25024>;
          <D.25030>:
          {
            int idx;

            idx = var->data.op[0].const_val;
            idx.13 = (unsigned int) idx;
            D.25032 = idx.13 * 4;
            D.25033 = stack + D.25032;
            D.25034 = *D.25033;
            if (D.25034 != 0B) goto <D.25035>; else goto <D.25036>;
            <D.25035>:
            D.25037 = var->opcode;
            if (D.25037 != 330) goto <D.25038>; else goto <D.25039>;
            <D.25038>:
            idx.13 = (unsigned int) idx;
            D.25032 = idx.13 * 4;
            D.25033 = stack + D.25032;
            D.25034 = *D.25033;
            D.25040 = D.25034 == 0B;
            D.25041 = (long int) D.25040;
            D.25042 = __builtin_expect (D.25041, 0);
            if (D.25042 != 0) goto <D.25043>; else goto <D.25044>;
            <D.25043>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 219, "stack [idx]");
            <D.25044>:
            <D.25039>:
            idx.13 = (unsigned int) idx;
            D.25032 = idx.13 * 4;
            D.25033 = stack + D.25032;
            D.25034 = *D.25033;
            D.25045 = D.25034->dreg;
            ins->dreg = D.25045;
            idx.13 = (unsigned int) idx;
            D.25032 = idx.13 * 4;
            D.25033 = stack + D.25032;
            D.25034 = *D.25033;
            record_use (cfg, D.25034, bb, ins);
            goto <D.25046>;
            <D.25036>:
            record_use (cfg, var, bb, ins);
            <D.25046>:
          }
          goto <D.25025>;
          <D.25024>:
          if (var == 0B) goto <D.25050>; else goto <D.25048>;
          <D.25050>:
          D.25016 = ins->dreg;
          D.25020 = (unsigned int) D.25016;
          D.25021 = D.25020 * 4;
          D.25051 = lvreg_stack + D.25021;
          D.25052 = *D.25051;
          if (D.25052 != 0) goto <D.25053>; else goto <D.25048>;
          <D.25053>:
          iftmp.14 = 1;
          goto <D.25049>;
          <D.25048>:
          iftmp.14 = 0;
          <D.25049>:
          D.25054 = iftmp.14 != 0;
          D.25055 = (long int) D.25054;
          D.25056 = __builtin_expect (D.25055, 0);
          if (D.25056 != 0) goto <D.25057>; else goto <D.25058>;
          <D.25057>:
          D.25016 = ins->dreg;
          D.25020 = (unsigned int) D.25016;
          D.25021 = D.25020 * 4;
          D.25051 = lvreg_stack + D.25021;
          D.25052 = *D.25051;
          D.25059 = (int) D.25052;
          ins->dreg = D.25059;
          <D.25058>:
          <D.25025>:
        }
        <D.25014>:
        D.25060 = *spec;
        if (D.25060 != 32) goto <D.25061>; else goto <D.25062>;
        <D.25061>:
        D.24949 = ins->opcode;
        D.25012 = D.24949 + 65162;
        if (D.25012 > 13) goto <D.25063>; else goto <D.25064>;
        <D.25063>:
        {
          struct MonoInst * var;
          struct MonoMethodVar * info;

          D.25016 = ins->dreg;
          D.25017 = (unsigned int) D.25016;
          D.24968 = cfg->vreg_to_inst_len;
          if (D.25017 < D.24968) goto <D.25066>; else goto <D.25067>;
          <D.25066>:
          D.24971 = cfg->vreg_to_inst;
          D.25016 = ins->dreg;
          D.25020 = (unsigned int) D.25016;
          D.25021 = D.25020 * 4;
          D.25022 = D.24971 + D.25021;
          iftmp.15 = *D.25022;
          goto <D.25068>;
          <D.25067>:
          iftmp.15 = 0B;
          <D.25068>:
          var = iftmp.15;
          if (var != 0B) goto <D.25071>; else goto <D.25069>;
          <D.25071>:
          D.25072 = var->flags;
          D.25073 = (int) D.25072;
          D.25074 = D.25073 & 20;
          if (D.25074 == 0) goto <D.25075>; else goto <D.25069>;
          <D.25075>:
          idx = var->data.op[0].const_val;
          D.25076 = idx >= max_vars;
          D.25077 = (long int) D.25076;
          D.25078 = __builtin_expect (D.25077, 0);
          if (D.25078 != 0) goto <D.25079>; else goto <D.25080>;
          <D.25079>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 237, "idx < max_vars");
          <D.25080>:
          D.25081 = var->opcode;
          if (D.25081 == 330) goto <D.25082>; else goto <D.25083>;
          <D.25082>:
          idx.16 = (unsigned int) idx;
          D.25085 = idx.16 * 4;
          D.25086 = originals_used + D.25085;
          *D.25086 = 1;
          <D.25083>:
          D.25087 = stack_history_len >= stack_history_size;
          D.25088 = (long int) D.25087;
          D.25089 = __builtin_expect (D.25088, 0);
          if (D.25089 != 0) goto <D.25090>; else goto <D.25091>;
          <D.25090>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 243, "stack_history_len < stack_history_size");
          <D.25091>:
          stack_history_len.17 = (unsigned int) stack_history_len;
          D.25093 = stack_history_len.17 * 8;
          D.25094 = stack_history + D.25093;
          idx.16 = (unsigned int) idx;
          D.25085 = idx.16 * 4;
          D.25095 = stack + D.25085;
          D.25096 = *D.25095;
          D.25094->var = D.25096;
          stack_history_len.17 = (unsigned int) stack_history_len;
          D.25093 = stack_history_len.17 * 8;
          D.25094 = stack_history + D.25093;
          D.25094->idx = idx;
          stack_history_len = stack_history_len + 1;
          idx.16 = (unsigned int) idx;
          D.25085 = idx.16 * 4;
          D.25086 = originals_used + D.25085;
          D.25097 = *D.25086;
          if (D.25097 != 0) goto <D.25098>; else goto <D.25099>;
          <D.25098>:
          D.25100 = var->data.op[1].vtype;
          new_var = mono_compile_create_var (cfg, D.25100, 329);
          D.25072 = var->flags;
          new_var->flags = D.25072;
          D.25101 = cfg->vars;
          D.25102 = new_var->data.op[0].const_val;
          D.25103 = (unsigned int) D.25102;
          D.25104 = D.25103 * 56;
          D.25105 = D.25101 + D.25104;
          D.25105->reg = idx;
          D.24945 = cfg->verbose_level;
          if (D.24945 > 3) goto <D.25106>; else goto <D.25107>;
          <D.25106>:
          D.25108 = var->dreg;
          D.25109 = new_var->dreg;
          printf ("  R%d -> R%d\n", D.25108, D.25109);
          <D.25107>:
          idx.16 = (unsigned int) idx;
          D.25085 = idx.16 * 4;
          D.25095 = stack + D.25085;
          *D.25095 = new_var;
          D.25109 = new_var->dreg;
          ins->dreg = D.25109;
          var = new_var;
          goto <D.25110>;
          <D.25099>:
          idx.16 = (unsigned int) idx;
          D.25085 = idx.16 * 4;
          D.25095 = stack + D.25085;
          *D.25095 = var;
          idx.16 = (unsigned int) idx;
          D.25085 = idx.16 * 4;
          D.25086 = originals_used + D.25085;
          *D.25086 = 1;
          <D.25110>:
          D.25101 = cfg->vars;
          D.25111 = var->data.op[0].const_val;
          D.25112 = (unsigned int) D.25111;
          D.25113 = D.25112 * 56;
          info = D.25101 + D.25113;
          info->def = ins;
          info->def_bb = bb;
          goto <D.25070>;
          <D.25069>:
          if (var == 0B) goto <D.25117>; else goto <D.25115>;
          <D.25117>:
          D.25016 = ins->dreg;
          D.25020 = (unsigned int) D.25016;
          D.25021 = D.25020 * 4;
          D.25118 = lvreg_defined + D.25021;
          D.25119 = *D.25118;
          if (D.25119 != 0) goto <D.25120>; else goto <D.25115>;
          <D.25120>:
          D.25016 = ins->dreg;
          if (D.25016 > 15) goto <D.25121>; else goto <D.25115>;
          <D.25121>:
          iftmp.18 = 1;
          goto <D.25116>;
          <D.25115>:
          iftmp.18 = 0;
          <D.25116>:
          D.25122 = iftmp.18 != 0;
          D.25123 = (long int) D.25122;
          D.25124 = __builtin_expect (D.25123, 0);
          if (D.25124 != 0) goto <D.25125>; else goto <D.25126>;
          <D.25125>:
          D.25016 = ins->dreg;
          D.25020 = (unsigned int) D.25016;
          D.25021 = D.25020 * 4;
          D.25051 = lvreg_stack + D.25021;
          D.25016 = ins->dreg;
          D.25017 = (unsigned int) D.25016;
          D.25130 = cfg->vreg_is_ref_len;
          if (D.25017 < D.25130) goto <D.25131>; else goto <D.25128>;
          <D.25131>:
          D.25132 = cfg->vreg_is_ref;
          D.25016 = ins->dreg;
          D.25020 = (unsigned int) D.25016;
          D.25021 = D.25020 * 4;
          D.25133 = D.25132 + D.25021;
          D.25134 = *D.25133;
          if (D.25134 != 0) goto <D.25135>; else goto <D.25128>;
          <D.25135>:
          iftmp.19 = mono_alloc_ireg_ref (cfg);
          goto <D.25129>;
          <D.25128>:
          iftmp.19 = mono_alloc_preg (cfg);
          <D.25129>:
          *D.25051 = iftmp.19;
          D.25016 = ins->dreg;
          D.25020 = (unsigned int) D.25016;
          D.25021 = D.25020 * 4;
          D.25051 = lvreg_stack + D.25021;
          D.25052 = *D.25051;
          D.25059 = (int) D.25052;
          ins->dreg = D.25059;
          goto <D.25136>;
          <D.25126>:
          D.25016 = ins->dreg;
          D.25020 = (unsigned int) D.25016;
          D.25021 = D.25020 * 4;
          D.25118 = lvreg_defined + D.25021;
          *D.25118 = 1;
          <D.25136>:
          <D.25070>:
        }
        <D.25064>:
        <D.25062>:
      }
    finally
      {
        sregs = {CLOBBER};
      }
  }
  <D.24382>:
  ins = ins->next;
  <D.24393>:
  if (ins != 0B) goto <D.24392>; else goto <D.24394>;
  <D.24394>:
  i = 0;
  goto <D.24403>;
  <D.24402>:
  {
    struct MonoBasicBlock * n;

    D.25137 = bb->out_bb;
    i.20 = (unsigned int) i;
    D.25139 = i.20 * 4;
    D.25140 = D.25137 + D.25139;
    n = *D.25140;
    j = 0;
    goto <D.24398>;
    <D.24397>:
    D.25141 = n->in_bb;
    j.21 = (unsigned int) j;
    D.25143 = j.21 * 4;
    D.25144 = D.25141 + D.25143;
    D.25145 = *D.25144;
    if (D.25145 == bb) goto <D.24396>; else goto <D.25146>;
    <D.25146>:
    j = j + 1;
    <D.24398>:
    D.25147 = n->in_count;
    D.25148 = (int) D.25147;
    if (D.25148 > j) goto <D.24397>; else goto <D.24396>;
    <D.24396>:
    ins = n->code;
    goto <D.24401>;
    <D.24400>:
    D.24949 = ins->opcode;
    D.25149 = D.24949 + 65217;
    if (D.25149 <= 2) goto <D.25150>; else goto <D.24399>;
    <D.25150>:
    idx = ins->data.op[0].const_val;
    idx.16 = (unsigned int) idx;
    D.25085 = idx.16 * 4;
    D.25095 = stack + D.25085;
    D.25096 = *D.25095;
    if (D.25096 != 0B) goto <D.25151>; else goto <D.25152>;
    <D.25151>:
    idx.16 = (unsigned int) idx;
    D.25085 = idx.16 * 4;
    D.25095 = stack + D.25085;
    new_var = *D.25095;
    goto <D.25153>;
    <D.25152>:
    D.25154 = cfg->varinfo;
    idx.16 = (unsigned int) idx;
    D.25085 = idx.16 * 4;
    D.25155 = D.25154 + D.25085;
    new_var = *D.25155;
    <D.25153>:
    D.25156 = ins->data.op[1].phi_args;
    j.22 = (sizetype) j;
    D.25158 = j.22 + 1;
    D.25159 = D.25158 * 4;
    D.25160 = D.25156 + D.25159;
    D.25109 = new_var->dreg;
    *D.25160 = D.25109;
    record_use (cfg, new_var, n, ins);
    D.24945 = cfg->verbose_level;
    D.25161 = D.24945 > 3;
    D.25162 = (long int) D.25161;
    D.25163 = __builtin_expect (D.25162, 0);
    if (D.25163 != 0) goto <D.25164>; else goto <D.25165>;
    <D.25164>:
    D.25016 = ins->dreg;
    D.25109 = new_var->dreg;
    D.25166 = n->block_num;
    printf ("\tAdd PHI R%d <- R%d to BB%d\n", D.25016, D.25109, D.25166);
    <D.25165>:
    ins = ins->next;
    <D.24401>:
    if (ins != 0B) goto <D.24400>; else goto <D.24399>;
    <D.24399>:
  }
  i = i + 1;
  <D.24403>:
  D.25167 = bb->out_count;
  D.25168 = (int) D.25167;
  if (D.25168 > i) goto <D.24402>; else goto <D.24404>;
  <D.24404>:
  D.25169 = bb->dominated;
  if (D.25169 != 0B) goto <D.25170>; else goto <D.25171>;
  <D.25170>:
  tmp = bb->dominated;
  goto <D.24406>;
  <D.24405>:
  D.25172 = tmp->data;
  stack_history_len.17 = (unsigned int) stack_history_len;
  D.25093 = stack_history_len.17 * 8;
  D.25094 = stack_history + D.25093;
  D.25173 = stack_history_size - stack_history_len;
  mono_ssa_rename_vars (cfg, max_vars, D.25172, originals_used, stack, lvreg_stack, lvreg_defined, D.25094, D.25173);
  tmp = tmp->next;
  <D.24406>:
  if (tmp != 0B) goto <D.24405>; else goto <D.24407>;
  <D.24407>:
  <D.25171>:
  i = stack_history_len + -1;
  goto <D.24409>;
  <D.24408>:
  i.20 = (unsigned int) i;
  D.25174 = i.20 * 8;
  D.25175 = stack_history + D.25174;
  D.25176 = D.25175->idx;
  D.25177 = (unsigned int) D.25176;
  D.25178 = D.25177 * 4;
  D.25179 = stack + D.25178;
  i.20 = (unsigned int) i;
  D.25174 = i.20 * 8;
  D.25175 = stack_history + D.25174;
  D.25180 = D.25175->var;
  *D.25179 = D.25180;
  i = i + -1;
  <D.24409>:
  if (i >= 0) goto <D.24408>; else goto <D.24410>;
  <D.24410>:
  D.25181 = cfg->comp_done;
  D.25182 = D.25181 | 64;
  cfg->comp_done = D.25182;
}


record_use (struct MonoCompile * cfg, struct MonoInst * var, struct MonoBasicBlock * bb, struct MonoInst * ins)
{
  struct MonoMemPool * D.25185;
  struct MonoMethodVar * D.25186;
  int D.25187;
  unsigned int D.25188;
  unsigned int D.25189;
  struct GList * D.25190;
  struct GList * D.25191;
  struct MonoMethodVar * info;
  struct MonoVarUsageInfo * ui;

  D.25185 = cfg->mempool;
  ui = mono_mempool_alloc (D.25185, 8);
  D.25186 = cfg->vars;
  D.25187 = var->data.op[0].const_val;
  D.25188 = (unsigned int) D.25187;
  D.25189 = D.25188 * 56;
  info = D.25186 + D.25189;
  ui->bb = bb;
  ui->inst = ins;
  D.25185 = cfg->mempool;
  D.25190 = info->uses;
  D.25191 = g_list_prepend_mempool (D.25185, D.25190, ui);
  info->uses = D.25191;
}


g_list_prepend_mempool (struct MonoMemPool * mp, struct GList * list, void * data)
{
  struct GList * iftmp.23;
  struct GList * D.25196;
  struct GList * D.25201;
  struct GList * new_list;

  new_list = mono_mempool_alloc (mp, 12);
  new_list->data = data;
  if (list != 0B) goto <D.25193>; else goto <D.25194>;
  <D.25193>:
  iftmp.23 = list->prev;
  goto <D.25195>;
  <D.25194>:
  iftmp.23 = 0B;
  <D.25195>:
  new_list->prev = iftmp.23;
  new_list->next = list;
  D.25196 = new_list->prev;
  if (D.25196 != 0B) goto <D.25197>; else goto <D.25198>;
  <D.25197>:
  D.25196 = new_list->prev;
  D.25196->next = new_list;
  <D.25198>:
  if (list != 0B) goto <D.25199>; else goto <D.25200>;
  <D.25199>:
  list->prev = new_list;
  <D.25200>:
  D.25201 = new_list;
  return D.25201;
}


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

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


mono_ssa_remove (struct MonoCompile * cfg)
{
  unsigned int D.25205;
  unsigned int D.25206;
  _Bool D.25207;
  long int D.25208;
  long int D.25209;
  struct MonoBasicBlock * * D.25212;
  unsigned int i.24;
  unsigned int D.25214;
  struct MonoBasicBlock * * D.25215;
  unsigned int D.25216;
  int D.25219;
  short unsigned int D.25220;
  short unsigned int D.25221;
  int * D.25224;
  int D.25225;
  short int D.25226;
  int D.25227;
  _Bool D.25228;
  long int D.25229;
  long int D.25230;
  struct MonoInst * iftmp.25;
  int D.25234;
  unsigned int D.25235;
  unsigned int D.25236;
  struct MonoInst * * D.25239;
  unsigned int D.25240;
  unsigned int D.25241;
  struct MonoInst * * D.25242;
  sizetype j.26;
  sizetype D.25245;
  sizetype D.25246;
  int * D.25247;
  int D.25248;
  int D.25254;
  int D.25255;
  short unsigned int D.25256;
  struct MonoClass * D.25259;
  _Bool D.25260;
  long int D.25261;
  long int D.25262;
  struct MonoBasicBlock * * D.25265;
  unsigned int j.27;
  unsigned int D.25267;
  struct MonoBasicBlock * * D.25268;
  int D.25271;
  int D.25272;
  struct MonoMemPool * D.25275;
  int D.25276;
  short unsigned int D.25277;
  int D.25278;
  int D.25279;
  const unsigned char * D.25280;
  short unsigned int D.25281;
  unsigned int i.28;
  unsigned int D.25287;
  unsigned int bbindex.29;
  unsigned int D.25291;
  struct MonoBasicBlock * * D.25292;
  int D.25293;
  int D.25294;
  char D.25297;
  struct MonoInst * iftmp.30;
  struct MonoMethodVar * D.25306;
  int D.25307;
  unsigned int D.25308;
  unsigned int D.25309;
  int D.25310;
  unsigned int D.25313;
  unsigned int D.25314;
  unsigned int D.25317;
  unsigned int D.25318;
  struct MonoMethodVar * D.25319;
  int D.25320;
  struct MonoInst * * D.25323;
  unsigned int D.25324;
  struct MonoInst * * D.25325;
  struct MonoInst * D.25326;
  int D.25327;
  int D.25328;
  int D.25329;
  int D.25330;
  signed char D.25331;
  struct MonoInst * iftmp.31;
  int D.25333;
  unsigned int D.25334;
  unsigned int D.25337;
  unsigned int D.25338;
  struct MonoInst * * D.25339;
  int D.25343;
  unsigned int D.25344;
  unsigned int D.25345;
  int D.25346;
  unsigned int D.25349;
  unsigned int D.25350;
  unsigned int D.25353;
  unsigned int D.25354;
  struct MonoMethodVar * D.25355;
  int D.25356;
  unsigned int D.25359;
  struct MonoInst * * D.25360;
  struct MonoInst * D.25361;
  int D.25362;
  unsigned int bbindex.32;
  unsigned int D.25364;
  struct MonoMethodVar * D.25365;
  unsigned int D.25366;
  unsigned int D.25367;
  unsigned int D.25370;
  unsigned int D.25371;
  struct MonoInst * ins;
  struct MonoInst * var;
  struct MonoInst * move;
  int bbindex;
  int i;
  int j;
  int first;

  D.25205 = cfg->comp_done;
  D.25206 = D.25205 & 32;
  D.25207 = D.25206 == 0;
  D.25208 = (long int) D.25207;
  D.25209 = __builtin_expect (D.25208, 0);
  if (D.25209 != 0) goto <D.25210>; else goto <D.25211>;
  <D.25210>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 489, "cfg->comp_done & MONO_COMP_SSA");
  <D.25211>:
  i = 0;
  goto <D.24483>;
  <D.24482>:
  {
    struct MonoBasicBlock * bb;

    D.25212 = cfg->bblocks;
    i.24 = (unsigned int) i;
    D.25214 = i.24 * 4;
    D.25215 = D.25212 + D.25214;
    bb = *D.25215;
    D.25216 = cfg->verbose_level;
    if (D.25216 > 3) goto <D.25217>; else goto <D.25218>;
    <D.25217>:
    D.25219 = bb->block_num;
    printf ("\nREMOVE SSA %d:\n", D.25219);
    <D.25218>:
    ins = bb->code;
    goto <D.24480>;
    <D.24479>:
    D.25220 = ins->opcode;
    D.25221 = D.25220 + 65217;
    if (D.25221 <= 2) goto <D.25222>; else goto <D.25223>;
    <D.25222>:
    D.25224 = ins->data.op[1].phi_args;
    D.25225 = *D.25224;
    D.25226 = bb->in_count;
    D.25227 = (int) D.25226;
    D.25228 = D.25225 != D.25227;
    D.25229 = (long int) D.25228;
    D.25230 = __builtin_expect (D.25229, 0);
    if (D.25230 != 0) goto <D.25231>; else goto <D.25232>;
    <D.25231>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 499, "ins->inst_phi_args [0] == bb->in_count");
    <D.25232>:
    D.25234 = ins->dreg;
    D.25235 = (unsigned int) D.25234;
    D.25236 = cfg->vreg_to_inst_len;
    if (D.25235 < D.25236) goto <D.25237>; else goto <D.25238>;
    <D.25237>:
    D.25239 = cfg->vreg_to_inst;
    D.25234 = ins->dreg;
    D.25240 = (unsigned int) D.25234;
    D.25241 = D.25240 * 4;
    D.25242 = D.25239 + D.25241;
    iftmp.25 = *D.25242;
    goto <D.25243>;
    <D.25238>:
    iftmp.25 = 0B;
    <D.25243>:
    var = iftmp.25;
    D.25224 = ins->data.op[1].phi_args;
    first = MEM[(int *)D.25224 + 4B];
    j = 1;
    goto <D.24473>;
    <D.24472>:
    D.25224 = ins->data.op[1].phi_args;
    j.26 = (sizetype) j;
    D.25245 = j.26 + 1;
    D.25246 = D.25245 * 4;
    D.25247 = D.25224 + D.25246;
    D.25248 = *D.25247;
    if (D.25248 != first) goto <D.24471>; else goto <D.25249>;
    <D.25249>:
    j = j + 1;
    <D.24473>:
    D.25226 = bb->in_count;
    D.25227 = (int) D.25226;
    if (D.25227 > j) goto <D.24472>; else goto <D.24471>;
    <D.24471>:
    D.25226 = bb->in_count;
    if (D.25226 > 1) goto <D.25252>; else goto <D.25250>;
    <D.25252>:
    D.25226 = bb->in_count;
    D.25227 = (int) D.25226;
    if (D.25227 == j) goto <D.25253>; else goto <D.25250>;
    <D.25253>:
    D.25220 = ins->opcode;
    D.25254 = (int) D.25220;
    D.25255 = op_phi_to_move (D.25254);
    D.25256 = (short unsigned int) D.25255;
    ins->opcode = D.25256;
    D.25220 = ins->opcode;
    if (D.25220 == 427) goto <D.25257>; else goto <D.25258>;
    <D.25257>:
    D.25259 = ins->klass;
    D.25260 = D.25259 == 0B;
    D.25261 = (long int) D.25260;
    D.25262 = __builtin_expect (D.25261, 0);
    if (D.25262 != 0) goto <D.25263>; else goto <D.25264>;
    <D.25263>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 512, "ins->klass");
    <D.25264>:
    <D.25258>:
    ins->sreg1 = first;
    goto <D.25251>;
    <D.25250>:
    j = 0;
    goto <D.24477>;
    <D.24476>:
    {
      struct MonoBasicBlock * pred;
      int sreg;

      D.25265 = bb->in_bb;
      j.27 = (unsigned int) j;
      D.25267 = j.27 * 4;
      D.25268 = D.25265 + D.25267;
      pred = *D.25268;
      D.25224 = ins->data.op[1].phi_args;
      j.26 = (sizetype) j;
      D.25245 = j.26 + 1;
      D.25246 = D.25245 * 4;
      D.25247 = D.25224 + D.25246;
      sreg = *D.25247;
      D.25216 = cfg->verbose_level;
      if (D.25216 > 3) goto <D.25269>; else goto <D.25270>;
      <D.25269>:
      D.25271 = var->dreg;
      D.25272 = pred->block_num;
      printf ("\tADD R%d <- R%d in BB%d\n", D.25271, sreg, D.25272);
      <D.25270>:
      D.25271 = var->dreg;
      if (D.25271 != sreg) goto <D.25273>; else goto <D.25274>;
      <D.25273>:
      D.25275 = cfg->mempool;
      move = mono_mempool_alloc0 (D.25275, 56);
      D.25220 = ins->opcode;
      D.25254 = (int) D.25220;
      D.25276 = op_phi_to_move (D.25254);
      D.25277 = (short unsigned int) D.25276;
      move->opcode = D.25277;
      move->dreg = -1;
      move->sreg3 = -1;
      D.25278 = move->sreg3;
      move->sreg2 = D.25278;
      D.25279 = move->sreg2;
      move->sreg1 = D.25279;
      D.25280 = cfg->ip;
      move->cil_code = D.25280;
      D.25281 = move->opcode;
      if (D.25281 == 427) goto <D.25282>; else goto <D.25283>;
      <D.25282>:
      D.25259 = ins->klass;
      D.25260 = D.25259 == 0B;
      D.25261 = (long int) D.25260;
      D.25262 = __builtin_expect (D.25261, 0);
      if (D.25262 != 0) goto <D.25284>; else goto <D.25285>;
      <D.25284>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 524, "ins->klass");
      <D.25285>:
      D.25259 = ins->klass;
      move->klass = D.25259;
      <D.25283>:
      D.25271 = var->dreg;
      move->dreg = D.25271;
      move->sreg1 = sreg;
      mono_add_ins_to_end (pred, move);
      <D.25274>:
    }
    j = j + 1;
    <D.24477>:
    D.25226 = bb->in_count;
    D.25227 = (int) D.25226;
    if (D.25227 > j) goto <D.24476>; else goto <D.24478>;
    <D.24478>:
    ins->opcode = 316;
    ins->dreg = -1;
    <D.25251>:
    <D.25223>:
    ins = ins->next;
    <D.24480>:
    if (ins != 0B) goto <D.24479>; else goto <D.24481>;
    <D.24481>:
  }
  i = i + 1;
  <D.24483>:
  i.28 = (unsigned int) i;
  D.25287 = cfg->num_bblocks;
  if (i.28 < D.25287) goto <D.24482>; else goto <D.24484>;
  <D.24484>:
  D.25216 = cfg->verbose_level;
  if (D.25216 > 3) goto <D.25288>; else goto <D.25289>;
  <D.25288>:
  i = 0;
  goto <D.24487>;
  <D.24486>:
  {
    struct MonoBasicBlock * bb;

    D.25212 = cfg->bblocks;
    i.24 = (unsigned int) i;
    D.25214 = i.24 * 4;
    D.25215 = D.25212 + D.25214;
    bb = *D.25215;
    mono_print_bb (bb, "AFTER REMOVE SSA:");
  }
  i = i + 1;
  <D.24487>:
  i.28 = (unsigned int) i;
  D.25287 = cfg->num_bblocks;
  if (i.28 < D.25287) goto <D.24486>; else goto <D.24488>;
  <D.24488>:
  <D.25289>:
  bbindex = 0;
  goto <D.24505>;
  <D.24504>:
  {
    struct MonoBasicBlock * bb;

    D.25212 = cfg->bblocks;
    bbindex.29 = (unsigned int) bbindex;
    D.25291 = bbindex.29 * 4;
    D.25292 = D.25212 + D.25291;
    bb = *D.25292;
    ins = bb->code;
    goto <D.24502>;
    <D.24501>:
    {
      const char * spec;
      int num_sregs;
      int sregs[3];

      try
        {
          D.25220 = ins->opcode;
          D.25254 = (int) D.25220;
          D.25293 = D.25254 + -313;
          D.25294 = D.25293 * 4;
          spec = &ins_info[D.25294];
          D.25220 = ins->opcode;
          if (D.25220 == 316) goto <D.25295>; else goto <D.25296>;
          <D.25295>:
          // predicted unlikely by continue predictor.
          goto <D.24493>;
          <D.25296>:
          D.25297 = *spec;
          if (D.25297 != 32) goto <D.25298>; else goto <D.25299>;
          <D.25298>:
          {
            struct MonoInst * var;

            D.25234 = ins->dreg;
            D.25235 = (unsigned int) D.25234;
            D.25236 = cfg->vreg_to_inst_len;
            if (D.25235 < D.25236) goto <D.25301>; else goto <D.25302>;
            <D.25301>:
            D.25239 = cfg->vreg_to_inst;
            D.25234 = ins->dreg;
            D.25240 = (unsigned int) D.25234;
            D.25241 = D.25240 * 4;
            D.25242 = D.25239 + D.25241;
            iftmp.30 = *D.25242;
            goto <D.25303>;
            <D.25302>:
            iftmp.30 = 0B;
            <D.25303>:
            var = iftmp.30;
            if (var != 0B) goto <D.25304>; else goto <D.25305>;
            <D.25304>:
            {
              struct MonoMethodVar * vmv;

              D.25306 = cfg->vars;
              D.25307 = var->data.op[0].const_val;
              D.25308 = (unsigned int) D.25307;
              D.25309 = D.25308 * 56;
              vmv = D.25306 + D.25309;
              D.25310 = vmv->reg;
              if (D.25310 != -1) goto <D.25311>; else goto <D.25312>;
              <D.25311>:
              D.25313 = vmv->idx;
              D.25310 = vmv->reg;
              D.25314 = (unsigned int) D.25310;
              if (D.25313 != D.25314) goto <D.25315>; else goto <D.25316>;
              <D.25315>:
              D.25306 = cfg->vars;
              D.25310 = vmv->reg;
              D.25317 = (unsigned int) D.25310;
              D.25318 = D.25317 * 56;
              D.25319 = D.25306 + D.25318;
              D.25320 = D.25319->reg;
              if (D.25320 != -1) goto <D.25321>; else goto <D.25322>;
              <D.25321>:
              D.25234 = ins->dreg;
              D.25323 = cfg->varinfo;
              D.25310 = vmv->reg;
              D.25317 = (unsigned int) D.25310;
              D.25324 = D.25317 * 4;
              D.25325 = D.25323 + D.25324;
              D.25326 = *D.25325;
              D.25327 = D.25326->dreg;
              printf ("COALESCE: R%d -> R%d\n", D.25234, D.25327);
              D.25323 = cfg->varinfo;
              D.25310 = vmv->reg;
              D.25317 = (unsigned int) D.25310;
              D.25324 = D.25317 * 4;
              D.25325 = D.25323 + D.25324;
              D.25326 = *D.25325;
              D.25327 = D.25326->dreg;
              ins->dreg = D.25327;
              <D.25322>:
              <D.25316>:
              <D.25312>:
            }
            <D.25305>:
          }
          <D.25299>:
          D.25328 = ins->sreg1;
          sregs[0] = D.25328;
          D.25329 = ins->sreg2;
          sregs[1] = D.25329;
          D.25330 = ins->sreg3;
          sregs[2] = D.25330;
          D.25220 = ins->opcode;
          D.25254 = (int) D.25220;
          D.25293 = D.25254 + -313;
          D.25331 = ins_sreg_counts[D.25293];
          num_sregs = (int) D.25331;
          i = 0;
          goto <D.24499>;
          <D.24498>:
          {
            struct MonoInst * var;

            D.25333 = sregs[i];
            D.25334 = (unsigned int) D.25333;
            D.25236 = cfg->vreg_to_inst_len;
            if (D.25334 < D.25236) goto <D.25335>; else goto <D.25336>;
            <D.25335>:
            D.25239 = cfg->vreg_to_inst;
            D.25333 = sregs[i];
            D.25337 = (unsigned int) D.25333;
            D.25338 = D.25337 * 4;
            D.25339 = D.25239 + D.25338;
            iftmp.31 = *D.25339;
            goto <D.25340>;
            <D.25336>:
            iftmp.31 = 0B;
            <D.25340>:
            var = iftmp.31;
            if (var != 0B) goto <D.25341>; else goto <D.25342>;
            <D.25341>:
            {
              struct MonoMethodVar * vmv;

              D.25306 = cfg->vars;
              D.25343 = var->data.op[0].const_val;
              D.25344 = (unsigned int) D.25343;
              D.25345 = D.25344 * 56;
              vmv = D.25306 + D.25345;
              D.25346 = vmv->reg;
              if (D.25346 != -1) goto <D.25347>; else goto <D.25348>;
              <D.25347>:
              D.25349 = vmv->idx;
              D.25346 = vmv->reg;
              D.25350 = (unsigned int) D.25346;
              if (D.25349 != D.25350) goto <D.25351>; else goto <D.25352>;
              <D.25351>:
              D.25306 = cfg->vars;
              D.25346 = vmv->reg;
              D.25353 = (unsigned int) D.25346;
              D.25354 = D.25353 * 56;
              D.25355 = D.25306 + D.25354;
              D.25356 = D.25355->reg;
              if (D.25356 != -1) goto <D.25357>; else goto <D.25358>;
              <D.25357>:
              D.25333 = sregs[i];
              D.25323 = cfg->varinfo;
              D.25346 = vmv->reg;
              D.25353 = (unsigned int) D.25346;
              D.25359 = D.25353 * 4;
              D.25360 = D.25323 + D.25359;
              D.25361 = *D.25360;
              D.25362 = D.25361->dreg;
              printf ("COALESCE: R%d -> R%d\n", D.25333, D.25362);
              D.25323 = cfg->varinfo;
              D.25346 = vmv->reg;
              D.25353 = (unsigned int) D.25346;
              D.25359 = D.25353 * 4;
              D.25360 = D.25323 + D.25359;
              D.25361 = *D.25360;
              D.25362 = D.25361->dreg;
              sregs[i] = D.25362;
              <D.25358>:
              <D.25352>:
              <D.25348>:
            }
            <D.25342>:
          }
          i = i + 1;
          <D.24499>:
          if (i < num_sregs) goto <D.24498>; else goto <D.24500>;
          <D.24500>:
          mono_inst_set_src_registers (ins, &sregs);
        }
      finally
        {
          sregs = {CLOBBER};
        }
    }
    <D.24493>:
    ins = ins->next;
    <D.24502>:
    if (ins != 0B) goto <D.24501>; else goto <D.24503>;
    <D.24503>:
  }
  bbindex = bbindex + 1;
  <D.24505>:
  bbindex.32 = (unsigned int) bbindex;
  D.25287 = cfg->num_bblocks;
  if (bbindex.32 < D.25287) goto <D.24504>; else goto <D.24506>;
  <D.24506>:
  i = 0;
  goto <D.24508>;
  <D.24507>:
  D.25306 = cfg->vars;
  i.24 = (unsigned int) i;
  D.25364 = i.24 * 56;
  D.25365 = D.25306 + D.25364;
  D.25365->reg = -1;
  i = i + 1;
  <D.24508>:
  i.28 = (unsigned int) i;
  D.25366 = cfg->num_varinfo;
  if (i.28 < D.25366) goto <D.24507>; else goto <D.24509>;
  <D.24509>:
  D.25205 = cfg->comp_done;
  D.25367 = D.25205 & 128;
  if (D.25367 != 0) goto <D.25368>; else goto <D.25369>;
  <D.25368>:
  unlink_unused_bblocks (cfg);
  <D.25369>:
  D.25205 = cfg->comp_done;
  D.25370 = D.25205 & 4294967279;
  cfg->comp_done = D.25370;
  D.25205 = cfg->comp_done;
  D.25371 = D.25205 & 4294967263;
  cfg->comp_done = D.25371;
}


op_phi_to_move (int opcode)
{
  int D.25374;

  switch (opcode) <default: <D.24348>, case 319: <D.24344>, case 320: <D.24345>, case 321: <D.24346>, case 802: <D.24347>>
  <D.24344>:
  D.25374 = 424;
  return D.25374;
  <D.24345>:
  D.25374 = 426;
  return D.25374;
  <D.24346>:
  D.25374 = 427;
  return D.25374;
  <D.24347>:
  D.25374 = 800;
  return D.25374;
  <D.24348>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "ssa.c", 137);
  D.25374 = -1;
  return D.25374;
}


unlink_unused_bblocks (struct MonoCompile * cfg)
{
  unsigned int D.25376;
  unsigned int D.25377;
  _Bool D.25378;
  long int D.25379;
  long int D.25380;
  unsigned int D.25383;
  _Bool D.25384;
  long int D.25385;
  long int D.25386;
  struct MonoBasicBlock * D.25389;
  unsigned int D.25390;
  unsigned int D.25391;
  struct MonoBasicBlock * D.25394;
  struct MonoBasicBlock * * D.25397;
  unsigned int i.33;
  unsigned int D.25399;
  struct MonoBasicBlock * * D.25400;
  unsigned int D.25401;
  unsigned int D.25402;
  struct MonoBasicBlock * * D.25405;
  unsigned int j.34;
  unsigned int D.25407;
  struct MonoBasicBlock * * D.25408;
  struct MonoBasicBlock * D.25409;
  short int D.25410;
  int D.25411;
  struct MonoBasicBlock * * D.25412;
  struct MonoBasicBlock * * D.25413;
  struct MonoBasicBlock * D.25414;
  short int D.25415;
  int D.25416;
  int D.25419;
  unsigned int i.35;
  unsigned int D.25421;
  int i;
  int j;
  struct MonoBasicBlock * bb;

  D.25376 = cfg->comp_done;
  D.25377 = D.25376 & 128;
  D.25378 = D.25377 == 0;
  D.25379 = (long int) D.25378;
  D.25380 = __builtin_expect (D.25379, 0);
  if (D.25380 != 0) goto <D.25381>; else goto <D.25382>;
  <D.25381>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 66, "cfg->comp_done & MONO_COMP_REACHABILITY");
  <D.25382>:
  D.25383 = cfg->verbose_level;
  D.25384 = D.25383 > 1;
  D.25385 = (long int) D.25384;
  D.25386 = __builtin_expect (D.25385, 0);
  if (D.25386 != 0) goto <D.25387>; else goto <D.25388>;
  <D.25387>:
  printf ("\nUNLINK UNUSED BBLOCKS:\n");
  <D.25388>:
  bb = cfg->bb_entry;
  goto <D.24313>;
  <D.24312>:
  D.25389 = bb->next_bb;
  D.25390 = D.25389->flags;
  D.25391 = D.25390 & 2;
  if (D.25391 == 0) goto <D.25392>; else goto <D.25393>;
  <D.25392>:
  D.25389 = bb->next_bb;
  D.25394 = D.25389->next_bb;
  bb->next_bb = D.25394;
  goto <D.25395>;
  <D.25393>:
  bb = bb->next_bb;
  <D.25395>:
  <D.24313>:
  if (bb != 0B) goto <D.25396>; else goto <D.24314>;
  <D.25396>:
  D.25389 = bb->next_bb;
  if (D.25389 != 0B) goto <D.24312>; else goto <D.24314>;
  <D.24314>:
  i = 1;
  goto <D.24322>;
  <D.24321>:
  D.25397 = cfg->bblocks;
  i.33 = (unsigned int) i;
  D.25399 = i.33 * 4;
  D.25400 = D.25397 + D.25399;
  bb = *D.25400;
  D.25401 = bb->flags;
  D.25402 = D.25401 & 2;
  if (D.25402 == 0) goto <D.25403>; else goto <D.25404>;
  <D.25403>:
  j = 0;
  goto <D.24316>;
  <D.24315>:
  D.25405 = bb->in_bb;
  j.34 = (unsigned int) j;
  D.25407 = j.34 * 4;
  D.25408 = D.25405 + D.25407;
  D.25409 = *D.25408;
  unlink_target (D.25409, bb);
  j = j + 1;
  <D.24316>:
  D.25410 = bb->in_count;
  D.25411 = (int) D.25410;
  if (D.25411 > j) goto <D.24315>; else goto <D.24317>;
  <D.24317>:
  j = 0;
  goto <D.24319>;
  <D.24318>:
  D.25412 = bb->out_bb;
  j.34 = (unsigned int) j;
  D.25407 = j.34 * 4;
  D.25413 = D.25412 + D.25407;
  D.25414 = *D.25413;
  unlink_target (bb, D.25414);
  j = j + 1;
  <D.24319>:
  D.25415 = bb->out_count;
  D.25416 = (int) D.25415;
  if (D.25416 > j) goto <D.24318>; else goto <D.24320>;
  <D.24320>:
  D.25383 = cfg->verbose_level;
  D.25384 = D.25383 > 1;
  D.25385 = (long int) D.25384;
  D.25386 = __builtin_expect (D.25385, 0);
  if (D.25386 != 0) goto <D.25417>; else goto <D.25418>;
  <D.25417>:
  D.25419 = bb->block_num;
  printf ("\tUnlinked BB%d\n", D.25419);
  <D.25418>:
  <D.25404>:
  i = i + 1;
  <D.24322>:
  i.35 = (unsigned int) i;
  D.25421 = cfg->num_bblocks;
  if (i.35 < D.25421) goto <D.24321>; else goto <D.24323>;
  <D.24323>:
}


unlink_target (struct MonoBasicBlock * bb, struct MonoBasicBlock * target)
{
  struct MonoBasicBlock * * D.25422;
  unsigned int i.36;
  unsigned int D.25424;
  struct MonoBasicBlock * * D.25425;
  struct MonoBasicBlock * D.25426;
  short int D.25429;
  unsigned short D.25430;
  unsigned short D.25431;
  short int D.25432;
  unsigned int D.25433;
  unsigned int D.25434;
  struct MonoBasicBlock * * D.25435;
  struct MonoBasicBlock * D.25436;
  int D.25437;
  struct MonoBasicBlock * * D.25438;
  struct MonoBasicBlock * * D.25439;
  struct MonoBasicBlock * D.25440;
  short int D.25443;
  unsigned short D.25444;
  unsigned short D.25445;
  short int D.25446;
  unsigned int D.25447;
  unsigned int D.25448;
  struct MonoBasicBlock * * D.25449;
  struct MonoBasicBlock * D.25450;
  int D.25451;
  int i;

  i = 0;
  goto <D.24302>;
  <D.24301>:
  D.25422 = bb->out_bb;
  i.36 = (unsigned int) i;
  D.25424 = i.36 * 4;
  D.25425 = D.25422 + D.25424;
  D.25426 = *D.25425;
  if (D.25426 == target) goto <D.25427>; else goto <D.25428>;
  <D.25427>:
  D.25422 = bb->out_bb;
  i.36 = (unsigned int) i;
  D.25424 = i.36 * 4;
  D.25425 = D.25422 + D.25424;
  D.25422 = bb->out_bb;
  D.25429 = bb->out_count;
  D.25430 = (unsigned short) D.25429;
  D.25431 = D.25430 + 65535;
  D.25432 = (short int) D.25431;
  bb->out_count = D.25432;
  D.25429 = bb->out_count;
  D.25433 = (unsigned int) D.25429;
  D.25434 = D.25433 * 4;
  D.25435 = D.25422 + D.25434;
  D.25436 = *D.25435;
  *D.25425 = D.25436;
  goto <D.24300>;
  <D.25428>:
  i = i + 1;
  <D.24302>:
  D.25429 = bb->out_count;
  D.25437 = (int) D.25429;
  if (D.25437 > i) goto <D.24301>; else goto <D.24300>;
  <D.24300>:
  i = 0;
  goto <D.24305>;
  <D.24304>:
  D.25438 = target->in_bb;
  i.36 = (unsigned int) i;
  D.25424 = i.36 * 4;
  D.25439 = D.25438 + D.25424;
  D.25440 = *D.25439;
  if (D.25440 == bb) goto <D.25441>; else goto <D.25442>;
  <D.25441>:
  D.25438 = target->in_bb;
  i.36 = (unsigned int) i;
  D.25424 = i.36 * 4;
  D.25439 = D.25438 + D.25424;
  D.25438 = target->in_bb;
  D.25443 = target->in_count;
  D.25444 = (unsigned short) D.25443;
  D.25445 = D.25444 + 65535;
  D.25446 = (short int) D.25445;
  target->in_count = D.25446;
  D.25443 = target->in_count;
  D.25447 = (unsigned int) D.25443;
  D.25448 = D.25447 * 4;
  D.25449 = D.25438 + D.25448;
  D.25450 = *D.25449;
  *D.25439 = D.25450;
  goto <D.24303>;
  <D.25442>:
  i = i + 1;
  <D.24305>:
  D.25443 = target->in_count;
  D.25451 = (int) D.25443;
  if (D.25451 > i) goto <D.24304>; else goto <D.24303>;
  <D.24303>:
}


mono_ssa_cprop (struct MonoCompile * cfg)
{
  unsigned int D.25452;
  unsigned int D.25453;
  unsigned int D.25454;
  unsigned int D.25455;
  struct MonoBasicBlock * D.25458;
  struct GList * bblock_list.37;
  unsigned int D.25460;
  unsigned int D.25461;
  unsigned int D.25462;
  unsigned int D.25463;
  struct MonoMethodVar * D.25464;
  unsigned int i.38;
  unsigned int D.25466;
  struct MonoInst * D.25467;
  unsigned int i.39;
  unsigned int D.25471;
  struct GList * bblock_list.40;
  struct GList * bblock_list.41;
  unsigned int D.25476;
  unsigned int D.25477;
  _Bool D.25478;
  long int D.25479;
  long int D.25480;
  struct MonoInst * D.25484;
  short unsigned int D.25486;
  short unsigned int D.25487;
  _Bool D.25488;
  short unsigned int D.25489;
  _Bool D.25490;
  _Bool D.25491;
  short unsigned int D.25493;
  short unsigned int D.25494;
  struct MonoBasicBlock * * D.25498;
  unsigned int D.25499;
  struct MonoBasicBlock * * D.25500;
  struct MonoBasicBlock * D.25501;
  short int D.25502;
  int D.25503;
  unsigned int D.25504;
  int D.25507;
  struct GList * cvars.42;
  struct GList * cvars.43;
  struct MonoBasicBlock * D.25510;
  unsigned int D.25511;
  unsigned int D.25512;
  struct MonoInst * D.25515;
  unsigned int D.25516;
  unsigned int D.25517;
  struct MonoInst * * carray;
  struct MonoBasicBlock * bb;
  struct GList * bblock_list;
  struct GList * cvars;
  struct GList * tmp;
  int i;

  try
    {
      D.25452 = cfg->next_vreg;
      D.25453 = D.25452 * 4;
      carray = monoeg_malloc0 (D.25453);
      D.25454 = cfg->comp_done;
      D.25455 = D.25454 & 64;
      if (D.25455 == 0) goto <D.25456>; else goto <D.25457>;
      <D.25456>:
      mono_ssa_create_def_use (cfg);
      <D.25457>:
      D.25458 = cfg->bb_entry;
      bblock_list.37 = monoeg_g_list_prepend (0B, D.25458);
      bblock_list = bblock_list.37;
      D.25458 = cfg->bb_entry;
      D.25458 = cfg->bb_entry;
      D.25460 = D.25458->flags;
      D.25461 = D.25460 | 2;
      D.25458->flags = D.25461;
      D.25462 = cfg->num_varinfo;
      D.25463 = D.25462 * 4;
      memset (carray, 0, D.25463);
      i = 0;
      goto <D.24672>;
      <D.24671>:
      {
        struct MonoMethodVar * info;

        D.25464 = cfg->vars;
        i.38 = (unsigned int) i;
        D.25466 = i.38 * 56;
        info = D.25464 + D.25466;
        D.25467 = info->def;
        if (D.25467 == 0B) goto <D.25468>; else goto <D.25469>;
        <D.25468>:
        info->cpstate = 2;
        <D.25469>:
      }
      i = i + 1;
      <D.24672>:
      i.39 = (unsigned int) i;
      D.25462 = cfg->num_varinfo;
      if (i.39 < D.25462) goto <D.24671>; else goto <D.24673>;
      <D.24673>:
      D.25458 = cfg->bb_entry;
      bb = D.25458->next_bb;
      goto <D.24675>;
      <D.24674>:
      D.25471 = bb->region;
      if (D.25471 != 0) goto <D.25472>; else goto <D.25473>;
      <D.25472>:
      add_cprop_bb (cfg, bb, &bblock_list);
      <D.25473>:
      bb = bb->next_bb;
      <D.24675>:
      if (bb != 0B) goto <D.24674>; else goto <D.24676>;
      <D.24676>:
      cvars = 0B;
      goto <D.24694>;
      <D.24693>:
      {
        struct MonoInst * inst;

        bblock_list.40 = bblock_list;
        bb = bblock_list.40->data;
        bblock_list.40 = bblock_list;
        bblock_list.40 = bblock_list;
        bblock_list.41 = monoeg_g_list_delete_link (bblock_list.40, bblock_list.40);
        bblock_list = bblock_list.41;
        D.25476 = bb->flags;
        D.25477 = D.25476 & 2;
        D.25478 = D.25477 == 0;
        D.25479 = (long int) D.25478;
        D.25480 = __builtin_expect (D.25479, 0);
        if (D.25480 != 0) goto <D.25481>; else goto <D.25482>;
        <D.25481>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 1185, "bb->flags & BB_REACHABLE");
        <D.25482>:
        D.25484 = bb->last_ins;
        if (D.25484 == 0B) goto <D.25483>; else goto <D.25485>;
        <D.25485>:
        D.25484 = bb->last_ins;
        D.25486 = D.25484->opcode;
        D.25487 = D.25486 + 64985;
        D.25488 = D.25487 > 9;
        D.25489 = D.25486 + 64878;
        D.25490 = D.25489 > 9;
        D.25491 = D.25488 & D.25490;
        if (D.25491 != 0) goto <D.25492>; else goto <D.24680>;
        <D.25492>:
        D.25484 = bb->last_ins;
        D.25493 = D.25484->opcode;
        D.25494 = D.25493 + 64888;
        if (D.25494 > 9) goto <D.25495>; else goto <D.24680>;
        <D.25495>:
        D.25484 = bb->last_ins;
        D.25493 = D.25484->opcode;
        if (D.25493 != 442) goto <D.25496>; else goto <D.24680>;
        <D.25496>:
        D.25484 = bb->last_ins;
        D.25493 = D.25484->opcode;
        if (D.25493 != 759) goto <D.25497>; else goto <D.24680>;
        <D.25497>:
        D.25484 = bb->last_ins;
        D.25493 = D.25484->opcode;
        if (D.25493 != 370) goto <D.25483>; else goto <D.24680>;
        <D.25483>:
        i = 0;
        goto <D.24679>;
        <D.24678>:
        D.25498 = bb->out_bb;
        i.38 = (unsigned int) i;
        D.25499 = i.38 * 4;
        D.25500 = D.25498 + D.25499;
        D.25501 = *D.25500;
        add_cprop_bb (cfg, D.25501, &bblock_list);
        i = i + 1;
        <D.24679>:
        D.25502 = bb->out_count;
        D.25503 = (int) D.25502;
        if (D.25503 > i) goto <D.24678>; else goto <D.24680>;
        <D.24680>:
        D.25504 = cfg->verbose_level;
        if (D.25504 > 1) goto <D.25505>; else goto <D.25506>;
        <D.25505>:
        D.25507 = bb->block_num;
        printf ("\nSSA CONSPROP BB%d:\n", D.25507);
        <D.25506>:
        inst = bb->code;
        goto <D.24682>;
        <D.24681>:
        visit_inst (cfg, bb, inst, &cvars, &bblock_list, carray);
        inst = inst->next;
        <D.24682>:
        if (inst != 0B) goto <D.24681>; else goto <D.24683>;
        <D.24683>:
        goto <D.24691>;
        <D.24690>:
        {
          struct MonoMethodVar * info;

          cvars.42 = cvars;
          info = cvars.42->data;
          cvars.42 = cvars;
          cvars.42 = cvars;
          cvars.43 = monoeg_g_list_delete_link (cvars.42, cvars.42);
          cvars = cvars.43;
          tmp = info->uses;
          goto <D.24688>;
          <D.24687>:
          {
            struct MonoVarUsageInfo * ui;

            ui = tmp->data;
            D.25510 = ui->bb;
            D.25511 = D.25510->flags;
            D.25512 = D.25511 & 2;
            if (D.25512 == 0) goto <D.25513>; else goto <D.25514>;
            <D.25513>:
            // predicted unlikely by continue predictor.
            goto <D.24686>;
            <D.25514>:
            D.25510 = ui->bb;
            D.25515 = ui->inst;
            visit_inst (cfg, D.25510, D.25515, &cvars, &bblock_list, carray);
          }
          <D.24686>:
          tmp = tmp->next;
          <D.24688>:
          if (tmp != 0B) goto <D.24687>; else goto <D.24689>;
          <D.24689>:
        }
        <D.24691>:
        cvars.42 = cvars;
        if (cvars.42 != 0B) goto <D.24690>; else goto <D.24692>;
        <D.24692>:
      }
      <D.24694>:
      bblock_list.40 = bblock_list;
      if (bblock_list.40 != 0B) goto <D.24693>; else goto <D.24695>;
      <D.24695>:
      D.25458 = cfg->bb_entry;
      bb = D.25458->next_bb;
      goto <D.24701>;
      <D.24700>:
      {
        struct MonoInst * inst;

        inst = bb->code;
        goto <D.24698>;
        <D.24697>:
        fold_ins (cfg, bb, inst, carray);
        inst = inst->next;
        <D.24698>:
        if (inst != 0B) goto <D.24697>; else goto <D.24699>;
        <D.24699>:
      }
      bb = bb->next_bb;
      <D.24701>:
      if (bb != 0B) goto <D.24700>; else goto <D.24702>;
      <D.24702>:
      monoeg_g_free (carray);
      D.25454 = cfg->comp_done;
      D.25516 = D.25454 | 128;
      cfg->comp_done = D.25516;
      D.25454 = cfg->comp_done;
      D.25517 = D.25454 & 4294967231;
      cfg->comp_done = D.25517;
      i = 0;
      goto <D.24705>;
      <D.24704>:
      {
        struct MonoMethodVar * info;

        D.25464 = cfg->vars;
        i.38 = (unsigned int) i;
        D.25466 = i.38 * 56;
        info = D.25464 + D.25466;
        info->def = 0B;
        info->uses = 0B;
      }
      i = i + 1;
      <D.24705>:
      i.39 = (unsigned int) i;
      D.25462 = cfg->num_varinfo;
      if (i.39 < D.25462) goto <D.24704>; else goto <D.24706>;
      <D.24706>:
    }
  finally
    {
      bblock_list = {CLOBBER};
      cvars = {CLOBBER};
    }
}


mono_ssa_create_def_use (struct MonoCompile * cfg)
{
  unsigned int D.25518;
  unsigned int D.25519;
  _Bool D.25520;
  long int D.25521;
  long int D.25522;
  short unsigned int D.25525;
  int D.25526;
  int D.25527;
  int D.25528;
  int D.25531;
  int D.25532;
  int D.25533;
  signed char D.25534;
  struct MonoInst * iftmp.44;
  int D.25536;
  unsigned int D.25537;
  unsigned int D.25538;
  struct MonoInst * * D.25541;
  unsigned int D.25542;
  unsigned int D.25543;
  struct MonoInst * * D.25544;
  unsigned char D.25548;
  int D.25549;
  int D.25550;
  short unsigned int D.25553;
  struct MonoInst * iftmp.45;
  int D.25557;
  unsigned int D.25558;
  unsigned int D.25561;
  unsigned int D.25562;
  struct MonoInst * * D.25563;
  unsigned char D.25567;
  int D.25568;
  int D.25569;
  short unsigned int D.25572;
  int * D.25575;
  unsigned int i.46;
  unsigned int D.25577;
  int * D.25578;
  int D.25579;
  _Bool D.25580;
  long int D.25581;
  long int D.25582;
  struct MonoInst * iftmp.47;
  unsigned int D.25586;
  unsigned int D.25589;
  unsigned int D.25590;
  struct MonoInst * * D.25591;
  char D.25593;
  struct MonoInst * iftmp.48;
  unsigned char D.25604;
  int D.25605;
  int D.25606;
  struct MonoMethodVar * D.25609;
  int D.25610;
  unsigned int D.25611;
  unsigned int D.25612;
  unsigned int D.25613;
  struct MonoBasicBlock * bb;
  struct MonoInst * ins;
  int i;

  D.25518 = cfg->comp_done;
  D.25519 = D.25518 & 64;
  D.25520 = D.25519 != 0;
  D.25521 = (long int) D.25520;
  D.25522 = __builtin_expect (D.25521, 0);
  if (D.25522 != 0) goto <D.25523>; else goto <D.25524>;
  <D.25523>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 619, "!(cfg->comp_done & MONO_COMP_SSA_DEF_USE)");
  <D.25524>:
  bb = cfg->bb_entry;
  goto <D.24534>;
  <D.24533>:
  ins = bb->code;
  goto <D.24531>;
  <D.24530>:
  {
    const char * spec;
    struct MonoMethodVar * info;
    int num_sregs;
    int sregs[3];

    try
      {
        D.25525 = ins->opcode;
        D.25526 = (int) D.25525;
        D.25527 = D.25526 + -313;
        D.25528 = D.25527 * 4;
        spec = &ins_info[D.25528];
        D.25525 = ins->opcode;
        if (D.25525 == 316) goto <D.25529>; else goto <D.25530>;
        <D.25529>:
        // predicted unlikely by continue predictor.
        goto <D.24520>;
        <D.25530>:
        D.25531 = ins->sreg1;
        sregs[0] = D.25531;
        D.25532 = ins->sreg2;
        sregs[1] = D.25532;
        D.25533 = ins->sreg3;
        sregs[2] = D.25533;
        D.25525 = ins->opcode;
        D.25526 = (int) D.25525;
        D.25527 = D.25526 + -313;
        D.25534 = ins_sreg_counts[D.25527];
        num_sregs = (int) D.25534;
        i = 0;
        goto <D.24523>;
        <D.24522>:
        {
          struct MonoInst * var;

          D.25536 = sregs[i];
          D.25537 = (unsigned int) D.25536;
          D.25538 = cfg->vreg_to_inst_len;
          if (D.25537 < D.25538) goto <D.25539>; else goto <D.25540>;
          <D.25539>:
          D.25541 = cfg->vreg_to_inst;
          D.25536 = sregs[i];
          D.25542 = (unsigned int) D.25536;
          D.25543 = D.25542 * 4;
          D.25544 = D.25541 + D.25543;
          iftmp.44 = *D.25544;
          goto <D.25545>;
          <D.25540>:
          iftmp.44 = 0B;
          <D.25545>:
          var = iftmp.44;
          if (var != 0B) goto <D.25546>; else goto <D.25547>;
          <D.25546>:
          D.25548 = var->flags;
          D.25549 = (int) D.25548;
          D.25550 = D.25549 & 20;
          if (D.25550 == 0) goto <D.25551>; else goto <D.25552>;
          <D.25551>:
          record_use (cfg, var, bb, ins);
          <D.25552>:
          <D.25547>:
        }
        i = i + 1;
        <D.24523>:
        if (i < num_sregs) goto <D.24522>; else goto <D.24524>;
        <D.24524>:
        D.25525 = ins->opcode;
        D.25553 = D.25525 + 65162;
        if (D.25553 <= 13) goto <D.25554>; else goto <D.25555>;
        <D.25554>:
        {
          struct MonoInst * var;

          D.25557 = ins->dreg;
          D.25558 = (unsigned int) D.25557;
          D.25538 = cfg->vreg_to_inst_len;
          if (D.25558 < D.25538) goto <D.25559>; else goto <D.25560>;
          <D.25559>:
          D.25541 = cfg->vreg_to_inst;
          D.25557 = ins->dreg;
          D.25561 = (unsigned int) D.25557;
          D.25562 = D.25561 * 4;
          D.25563 = D.25541 + D.25562;
          iftmp.45 = *D.25563;
          goto <D.25564>;
          <D.25560>:
          iftmp.45 = 0B;
          <D.25564>:
          var = iftmp.45;
          if (var != 0B) goto <D.25565>; else goto <D.25566>;
          <D.25565>:
          D.25567 = var->flags;
          D.25568 = (int) D.25567;
          D.25569 = D.25568 & 20;
          if (D.25569 == 0) goto <D.25570>; else goto <D.25571>;
          <D.25570>:
          record_use (cfg, var, bb, ins);
          <D.25571>:
          <D.25566>:
        }
        <D.25555>:
        D.25525 = ins->opcode;
        D.25572 = D.25525 + 65217;
        if (D.25572 <= 2) goto <D.25573>; else goto <D.25574>;
        <D.25573>:
        D.25575 = ins->data.op[1].phi_args;
        i = *D.25575;
        goto <D.24527>;
        <D.24526>:
        D.25575 = ins->data.op[1].phi_args;
        i.46 = (unsigned int) i;
        D.25577 = i.46 * 4;
        D.25578 = D.25575 + D.25577;
        D.25579 = *D.25578;
        D.25580 = D.25579 == -1;
        D.25581 = (long int) D.25580;
        D.25582 = __builtin_expect (D.25581, 0);
        if (D.25582 != 0) goto <D.25583>; else goto <D.25584>;
        <D.25583>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 647, "ins->inst_phi_args [i] != -1");
        <D.25584>:
        D.25575 = ins->data.op[1].phi_args;
        i.46 = (unsigned int) i;
        D.25577 = i.46 * 4;
        D.25578 = D.25575 + D.25577;
        D.25579 = *D.25578;
        D.25586 = (unsigned int) D.25579;
        D.25538 = cfg->vreg_to_inst_len;
        if (D.25586 < D.25538) goto <D.25587>; else goto <D.25588>;
        <D.25587>:
        D.25541 = cfg->vreg_to_inst;
        D.25575 = ins->data.op[1].phi_args;
        i.46 = (unsigned int) i;
        D.25577 = i.46 * 4;
        D.25578 = D.25575 + D.25577;
        D.25579 = *D.25578;
        D.25589 = (unsigned int) D.25579;
        D.25590 = D.25589 * 4;
        D.25591 = D.25541 + D.25590;
        iftmp.47 = *D.25591;
        goto <D.25592>;
        <D.25588>:
        iftmp.47 = 0B;
        <D.25592>:
        record_use (cfg, iftmp.47, bb, ins);
        i = i + -1;
        <D.24527>:
        if (i > 0) goto <D.24526>; else goto <D.24528>;
        <D.24528>:
        <D.25574>:
        D.25593 = *spec;
        if (D.25593 != 32) goto <D.25594>; else goto <D.25595>;
        <D.25594>:
        D.25525 = ins->opcode;
        D.25553 = D.25525 + 65162;
        if (D.25553 > 13) goto <D.25596>; else goto <D.25597>;
        <D.25596>:
        {
          struct MonoInst * var;

          D.25557 = ins->dreg;
          D.25558 = (unsigned int) D.25557;
          D.25538 = cfg->vreg_to_inst_len;
          if (D.25558 < D.25538) goto <D.25599>; else goto <D.25600>;
          <D.25599>:
          D.25541 = cfg->vreg_to_inst;
          D.25557 = ins->dreg;
          D.25561 = (unsigned int) D.25557;
          D.25562 = D.25561 * 4;
          D.25563 = D.25541 + D.25562;
          iftmp.48 = *D.25563;
          goto <D.25601>;
          <D.25600>:
          iftmp.48 = 0B;
          <D.25601>:
          var = iftmp.48;
          if (var != 0B) goto <D.25602>; else goto <D.25603>;
          <D.25602>:
          D.25604 = var->flags;
          D.25605 = (int) D.25604;
          D.25606 = D.25605 & 20;
          if (D.25606 == 0) goto <D.25607>; else goto <D.25608>;
          <D.25607>:
          D.25609 = cfg->vars;
          D.25610 = var->data.op[0].const_val;
          D.25611 = (unsigned int) D.25610;
          D.25612 = D.25611 * 56;
          info = D.25609 + D.25612;
          info->def = ins;
          info->def_bb = bb;
          <D.25608>:
          <D.25603>:
        }
        <D.25597>:
        <D.25595>:
      }
    finally
      {
        sregs = {CLOBBER};
      }
  }
  <D.24520>:
  ins = ins->next;
  <D.24531>:
  if (ins != 0B) goto <D.24530>; else goto <D.24532>;
  <D.24532>:
  bb = bb->next_bb;
  <D.24534>:
  if (bb != 0B) goto <D.24533>; else goto <D.24535>;
  <D.24535>:
  D.25518 = cfg->comp_done;
  D.25613 = D.25518 | 64;
  cfg->comp_done = D.25613;
}


add_cprop_bb (struct MonoCompile * cfg, struct MonoBasicBlock * bb, struct GList * * bblist)
{
  unsigned int D.25616;
  _Bool D.25617;
  long int D.25618;
  long int D.25619;
  int D.25622;
  unsigned int D.25623;
  unsigned int D.25624;
  unsigned int D.25627;
  struct GList * D.25628;
  struct GList * D.25629;

  D.25616 = cfg->verbose_level;
  D.25617 = D.25616 > 1;
  D.25618 = (long int) D.25617;
  D.25619 = __builtin_expect (D.25618, 0);
  if (D.25619 != 0) goto <D.25620>; else goto <D.25621>;
  <D.25620>:
  D.25622 = bb->block_num;
  printf ("\tAdd BB%d to worklist\n", D.25622);
  <D.25621>:
  D.25623 = bb->flags;
  D.25624 = D.25623 & 2;
  if (D.25624 == 0) goto <D.25625>; else goto <D.25626>;
  <D.25625>:
  D.25623 = bb->flags;
  D.25627 = D.25623 | 2;
  bb->flags = D.25627;
  D.25628 = *bblist;
  D.25629 = monoeg_g_list_prepend (D.25628, bb);
  *bblist = D.25629;
  <D.25626>:
}


visit_inst (struct MonoCompile * cfg, struct MonoBasicBlock * bb, struct MonoInst * ins, struct GList * * cvars, struct GList * * bblist, struct MonoInst * * carray)
{
  short unsigned int D.25630;
  int D.25631;
  int D.25632;
  int D.25633;
  unsigned int D.25636;
  short unsigned int D.25639;
  struct MonoMethodVar * D.25642;
  struct MonoInst * iftmp.49;
  int D.25644;
  unsigned int D.25645;
  unsigned int D.25646;
  struct MonoInst * * D.25649;
  unsigned int D.25650;
  unsigned int D.25651;
  struct MonoInst * * D.25652;
  int D.25654;
  unsigned int D.25655;
  unsigned int D.25656;
  struct MonoInst * iftmp.50;
  int * D.25658;
  unsigned int j.51;
  unsigned int D.25660;
  int * D.25661;
  int D.25662;
  unsigned int D.25663;
  unsigned int D.25666;
  unsigned int D.25667;
  struct MonoInst * * D.25668;
  int D.25670;
  unsigned int D.25671;
  unsigned int D.25672;
  struct MonoBasicBlock * D.25673;
  unsigned int D.25676;
  unsigned int D.25677;
  struct MonoInst * D.25682;
  char D.25685;
  int D.25688;
  unsigned int D.25689;
  unsigned int D.25690;
  struct MonoInst * * D.25691;
  struct MonoInst * D.25692;
  _Bool D.25693;
  long int D.25694;
  long int D.25695;
  short unsigned int D.25700;
  int D.25703;
  int D.25704;
  int D.25707;
  char D.25710;
  _Bool D.25713;
  long int D.25714;
  long int D.25715;
  short unsigned int D.25722;
  const char * D.25724;
  char D.25725;
  const char * D.25727;
  char D.25728;
  char D.25730;
  struct MonoInst * iftmp.52;
  unsigned char D.25741;
  int D.25742;
  int D.25743;
  int D.25745;
  unsigned int D.25746;
  unsigned int D.25747;
  char D.25748;
  struct MonoInst * c0.53;
  struct MonoInst * * D.25763;
  struct MonoInst * D.25765;
  struct GList * D.25768;
  struct GList * D.25769;
  struct GList * D.25772;
  struct MonoInst * D.25778;
  struct MonoInst * D.25781;
  struct MonoJumpInfoBBTable * iftmp.54;
  struct MonoJumpInfoBBTable * iftmp.55;
  struct MonoJumpInfoBBTable * iftmp.56;
  struct MonoJumpInfoBBTable * iftmp.57;
  struct MonoInst * D.25802;
  short unsigned int D.25804;
  struct MonoBasicBlock * * D.25805;
  unsigned int i.58;
  unsigned int D.25807;
  struct MonoBasicBlock * * D.25808;
  struct MonoBasicBlock * D.25809;
  int D.25812;
  _Bool D.25813;
  long int D.25814;
  long int D.25815;
  int D.25818;
  _Bool D.25819;
  long int D.25820;
  long int D.25821;
  int D.25824;
  unsigned int D.25825;
  unsigned int D.25826;
  struct MonoInst * * D.25827;
  struct MonoInst * D.25828;
  int D.25831;
  unsigned int idx.59;
  unsigned int D.25836;
  struct MonoBasicBlock * * D.25837;
  struct MonoBasicBlock * D.25838;
  struct MonoBasicBlock * * D.25846;
  unsigned int i.60;
  unsigned int D.25848;
  struct MonoBasicBlock * * D.25849;
  struct MonoBasicBlock * D.25850;
  int D.25853;
  short unsigned int D.25858;
  short unsigned int D.25859;
  _Bool D.25860;
  short unsigned int D.25861;
  _Bool D.25862;
  _Bool D.25863;
  short unsigned int D.25865;
  short unsigned int D.25868;
  _Bool D.25869;
  long int D.25870;
  long int D.25871;
  int D.25874;
  unsigned char D.25877;
  unsigned char D.25878;
  unsigned char D.25880;
  unsigned char D.25882;
  struct MonoBasicBlock * D.25885;
  short unsigned int D.25889;
  short unsigned int D.25890;
  _Bool D.25891;
  short unsigned int D.25892;
  _Bool D.25893;
  _Bool D.25894;
  short unsigned int D.25896;
  unsigned char D.25897;
  int D.25898;
  int D.25899;
  struct MonoBasicBlock * * D.25902;
  struct MonoBasicBlock * D.25903;
  int D.25905;
  struct MonoBasicBlock * * D.25908;
  struct MonoBasicBlock * D.25909;
  const char * spec;

  D.25630 = ins->opcode;
  D.25631 = (int) D.25630;
  D.25632 = D.25631 + -313;
  D.25633 = D.25632 * 4;
  spec = &ins_info[D.25633];
  D.25630 = ins->opcode;
  if (D.25630 == 316) goto <D.25634>; else goto <D.25635>;
  <D.25634>:
  return;
  <D.25635>:
  D.25636 = cfg->verbose_level;
  if (D.25636 > 1) goto <D.25637>; else goto <D.25638>;
  <D.25637>:
  mono_print_ins (ins);
  <D.25638>:
  D.25630 = ins->opcode;
  D.25639 = D.25630 + 65217;
  if (D.25639 <= 2) goto <D.25640>; else goto <D.25641>;
  <D.25640>:
  {
    struct MonoMethodVar * info;
    struct MonoInst * c0;
    int j;

    D.25642 = cfg->vars;
    D.25644 = ins->dreg;
    D.25645 = (unsigned int) D.25644;
    D.25646 = cfg->vreg_to_inst_len;
    if (D.25645 < D.25646) goto <D.25647>; else goto <D.25648>;
    <D.25647>:
    D.25649 = cfg->vreg_to_inst;
    D.25644 = ins->dreg;
    D.25650 = (unsigned int) D.25644;
    D.25651 = D.25650 * 4;
    D.25652 = D.25649 + D.25651;
    iftmp.49 = *D.25652;
    goto <D.25653>;
    <D.25648>:
    iftmp.49 = 0B;
    <D.25653>:
    D.25654 = iftmp.49->data.op[0].const_val;
    D.25655 = (unsigned int) D.25654;
    D.25656 = D.25655 * 56;
    info = D.25642 + D.25656;
    c0 = 0B;
    j = 1;
    goto <D.24624>;
    <D.24623>:
    {
      struct MonoInst * var;
      struct MonoMethodVar * mv;
      struct MonoInst * src;

      D.25658 = ins->data.op[1].phi_args;
      j.51 = (unsigned int) j;
      D.25660 = j.51 * 4;
      D.25661 = D.25658 + D.25660;
      D.25662 = *D.25661;
      D.25663 = (unsigned int) D.25662;
      D.25646 = cfg->vreg_to_inst_len;
      if (D.25663 < D.25646) goto <D.25664>; else goto <D.25665>;
      <D.25664>:
      D.25649 = cfg->vreg_to_inst;
      D.25658 = ins->data.op[1].phi_args;
      j.51 = (unsigned int) j;
      D.25660 = j.51 * 4;
      D.25661 = D.25658 + D.25660;
      D.25662 = *D.25661;
      D.25666 = (unsigned int) D.25662;
      D.25667 = D.25666 * 4;
      D.25668 = D.25649 + D.25667;
      iftmp.50 = *D.25668;
      goto <D.25669>;
      <D.25665>:
      iftmp.50 = 0B;
      <D.25669>:
      var = iftmp.50;
      D.25642 = cfg->vars;
      D.25670 = var->data.op[0].const_val;
      D.25671 = (unsigned int) D.25670;
      D.25672 = D.25671 * 56;
      mv = D.25642 + D.25672;
      src = mv->def;
      D.25673 = mv->def_bb;
      if (D.25673 != 0B) goto <D.25674>; else goto <D.25675>;
      <D.25674>:
      D.25673 = mv->def_bb;
      D.25676 = D.25673->flags;
      D.25677 = D.25676 & 2;
      if (D.25677 == 0) goto <D.25678>; else goto <D.25679>;
      <D.25678>:
      // predicted unlikely by continue predictor.
      goto <D.24621>;
      <D.25679>:
      <D.25675>:
      D.25682 = mv->def;
      if (D.25682 == 0B) goto <D.25680>; else goto <D.25683>;
      <D.25683>:
      if (src == 0B) goto <D.25680>; else goto <D.25684>;
      <D.25684>:
      D.25685 = mv->cpstate;
      if (D.25685 == 2) goto <D.25680>; else goto <D.25681>;
      <D.25680>:
      change_varstate (cfg, cvars, info, 2, 0B, carray);
      goto <D.24622>;
      <D.25681>:
      D.25685 = mv->cpstate;
      if (D.25685 == 0) goto <D.25686>; else goto <D.25687>;
      <D.25686>:
      // predicted unlikely by continue predictor.
      goto <D.24621>;
      <D.25687>:
      D.25688 = var->dreg;
      D.25689 = (unsigned int) D.25688;
      D.25690 = D.25689 * 4;
      D.25691 = carray + D.25690;
      D.25692 = *D.25691;
      D.25693 = D.25692 == 0B;
      D.25694 = (long int) D.25693;
      D.25695 = __builtin_expect (D.25694, 0);
      if (D.25695 != 0) goto <D.25696>; else goto <D.25697>;
      <D.25696>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 873, "carray [var->dreg]");
      <D.25697>:
      if (c0 == 0B) goto <D.25698>; else goto <D.25699>;
      <D.25698>:
      D.25688 = var->dreg;
      D.25689 = (unsigned int) D.25688;
      D.25690 = D.25689 * 4;
      D.25691 = carray + D.25690;
      c0 = *D.25691;
      <D.25699>:
      D.25700 = c0->opcode;
      if (D.25700 != 362) goto <D.25701>; else goto <D.25702>;
      <D.25701>:
      change_varstate (cfg, cvars, info, 2, 0B, carray);
      goto <D.24622>;
      <D.25702>:
      D.25688 = var->dreg;
      D.25689 = (unsigned int) D.25688;
      D.25690 = D.25689 * 4;
      D.25691 = carray + D.25690;
      D.25692 = *D.25691;
      D.25703 = D.25692->data.op[0].const_val;
      D.25704 = c0->data.op[0].const_val;
      if (D.25703 != D.25704) goto <D.25705>; else goto <D.25706>;
      <D.25705>:
      change_varstate (cfg, cvars, info, 2, 0B, carray);
      goto <D.24622>;
      <D.25706>:
    }
    <D.24621>:
    j = j + 1;
    <D.24624>:
    D.25658 = ins->data.op[1].phi_args;
    D.25707 = *D.25658;
    if (D.25707 >= j) goto <D.24623>; else goto <D.24622>;
    <D.24622>:
    if (c0 != 0B) goto <D.25708>; else goto <D.25709>;
    <D.25708>:
    D.25710 = info->cpstate;
    if (D.25710 == 0) goto <D.25711>; else goto <D.25712>;
    <D.25711>:
    change_varstate (cfg, cvars, info, 1, c0, carray);
    D.25700 = c0->opcode;
    D.25713 = D.25700 != 362;
    D.25714 = (long int) D.25713;
    D.25715 = __builtin_expect (D.25714, 0);
    if (D.25715 != 0) goto <D.25716>; else goto <D.25717>;
    <D.25716>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 893, "c0->opcode == OP_ICONST");
    <D.25717>:
    <D.25712>:
    <D.25709>:
  }
  goto <D.25718>;
  <D.25641>:
  D.25630 = ins->opcode;
  D.25722 = D.25630 + 65162;
  if (D.25722 > 13) goto <D.25723>; else goto <D.25719>;
  <D.25723>:
  D.25724 = spec + 1;
  D.25725 = *D.25724;
  if (D.25725 != 32) goto <D.25720>; else goto <D.25726>;
  <D.25726>:
  D.25727 = spec + 2;
  D.25728 = *D.25727;
  if (D.25728 != 32) goto <D.25720>; else goto <D.25729>;
  <D.25729>:
  D.25730 = *spec;
  if (D.25730 != 32) goto <D.25720>; else goto <D.25719>;
  <D.25720>:
  {
    struct MonoInst * var;
    struct MonoInst * c0;
    int state;

    try
      {
        D.25730 = *spec;
        if (D.25730 != 32) goto <D.25731>; else goto <D.25732>;
        <D.25731>:
        D.25644 = ins->dreg;
        D.25645 = (unsigned int) D.25644;
        D.25646 = cfg->vreg_to_inst_len;
        if (D.25645 < D.25646) goto <D.25734>; else goto <D.25735>;
        <D.25734>:
        D.25649 = cfg->vreg_to_inst;
        D.25644 = ins->dreg;
        D.25650 = (unsigned int) D.25644;
        D.25651 = D.25650 * 4;
        D.25652 = D.25649 + D.25651;
        iftmp.52 = *D.25652;
        goto <D.25736>;
        <D.25735>:
        iftmp.52 = 0B;
        <D.25736>:
        var = iftmp.52;
        goto <D.25737>;
        <D.25732>:
        var = 0B;
        <D.25737>:
        c0 = 0B;
        state = evaluate_ins (cfg, ins, &c0, carray);
        if (var != 0B) goto <D.25740>; else goto <D.25738>;
        <D.25740>:
        D.25741 = var->flags;
        D.25742 = (int) D.25741;
        D.25743 = D.25742 & 20;
        if (D.25743 == 0) goto <D.25744>; else goto <D.25738>;
        <D.25744>:
        {
          struct MonoMethodVar * info;

          D.25642 = cfg->vars;
          D.25745 = var->data.op[0].const_val;
          D.25746 = (unsigned int) D.25745;
          D.25747 = D.25746 * 56;
          info = D.25642 + D.25747;
          D.25748 = info->cpstate;
          if (D.25748 <= 1) goto <D.25749>; else goto <D.25750>;
          <D.25749>:
          if (state == 1) goto <D.25751>; else goto <D.25752>;
          <D.25751>:
          c0.53 = c0;
          change_varstate (cfg, cvars, info, 1, c0.53, carray);
          goto <D.25754>;
          <D.25752>:
          if (state == 2) goto <D.25755>; else goto <D.25756>;
          <D.25755>:
          change_varstate (cfg, cvars, info, 2, 0B, carray);
          <D.25756>:
          <D.25754>:
          <D.25750>:
        }
        goto <D.25739>;
        <D.25738>:
        if (var == 0B) goto <D.25757>; else goto <D.25758>;
        <D.25757>:
        D.25644 = ins->dreg;
        if (D.25644 != -1) goto <D.25759>; else goto <D.25760>;
        <D.25759>:
        c0.53 = c0;
        if (c0.53 != 0B) goto <D.25761>; else goto <D.25762>;
        <D.25761>:
        D.25644 = ins->dreg;
        D.25650 = (unsigned int) D.25644;
        D.25651 = D.25650 * 4;
        D.25763 = carray + D.25651;
        c0.53 = c0;
        *D.25763 = c0.53;
        goto <D.25764>;
        <D.25762>:
        D.25644 = ins->dreg;
        D.25650 = (unsigned int) D.25644;
        D.25651 = D.25650 * 4;
        D.25763 = carray + D.25651;
        D.25765 = *D.25763;
        if (D.25765 != 0B) goto <D.25766>; else goto <D.25767>;
        <D.25766>:
        D.25644 = ins->dreg;
        D.25650 = (unsigned int) D.25644;
        D.25651 = D.25650 * 4;
        D.25763 = carray + D.25651;
        *D.25763 = 0B;
        D.25768 = *bblist;
        D.25769 = monoeg_g_list_find (D.25768, bb);
        if (D.25769 == 0B) goto <D.25770>; else goto <D.25771>;
        <D.25770>:
        D.25768 = *bblist;
        D.25772 = monoeg_g_list_prepend (D.25768, bb);
        *bblist = D.25772;
        <D.25771>:
        <D.25767>:
        <D.25764>:
        <D.25760>:
        <D.25758>:
        <D.25739>:
        D.25630 = ins->opcode;
        if (D.25630 == 731) goto <D.25773>; else goto <D.25776>;
        <D.25776>:
        D.25630 = ins->opcode;
        if (D.25630 == 732) goto <D.25777>; else goto <D.25774>;
        <D.25777>:
        D.25778 = ins->data.op[1].src;
        if (D.25778 == 8B) goto <D.25773>; else goto <D.25774>;
        <D.25774>:
        D.25630 = ins->opcode;
        if (D.25630 == 370) goto <D.25773>; else goto <D.25779>;
        <D.25779>:
        D.25630 = ins->opcode;
        if (D.25630 == 734) goto <D.25780>; else goto <D.25775>;
        <D.25780>:
        D.25778 = ins->data.op[1].src;
        D.25781 = D.25778->data.op[1].src;
        if (D.25781 == 8B) goto <D.25773>; else goto <D.25775>;
        <D.25773>:
        {
          int i;
          struct MonoJumpInfoBBTable * table;

          D.25630 = ins->opcode;
          if (D.25630 == 731) goto <D.25783>; else goto <D.25784>;
          <D.25783>:
          iftmp.54 = ins->data.op[0].p;
          goto <D.25785>;
          <D.25784>:
          D.25630 = ins->opcode;
          if (D.25630 == 732) goto <D.25789>; else goto <D.25787>;
          <D.25789>:
          D.25778 = ins->data.op[1].src;
          if (D.25778 == 8B) goto <D.25790>; else goto <D.25787>;
          <D.25790>:
          iftmp.55 = ins->data.op[0].p;
          goto <D.25788>;
          <D.25787>:
          D.25630 = ins->opcode;
          if (D.25630 == 370) goto <D.25792>; else goto <D.25793>;
          <D.25792>:
          iftmp.56 = ins->data.op[0].p;
          goto <D.25794>;
          <D.25793>:
          D.25630 = ins->opcode;
          if (D.25630 == 734) goto <D.25798>; else goto <D.25796>;
          <D.25798>:
          D.25778 = ins->data.op[1].src;
          D.25781 = D.25778->data.op[1].src;
          if (D.25781 == 8B) goto <D.25799>; else goto <D.25796>;
          <D.25799>:
          D.25778 = ins->data.op[1].src;
          iftmp.57 = D.25778->data.op[0].p;
          goto <D.25797>;
          <D.25796>:
          iftmp.57 = 0B;
          <D.25797>:
          iftmp.56 = iftmp.57;
          <D.25794>:
          iftmp.55 = iftmp.56;
          <D.25788>:
          iftmp.54 = iftmp.55;
          <D.25785>:
          table = iftmp.54;
          D.25802 = ins->next;
          if (D.25802 == 0B) goto <D.25800>; else goto <D.25803>;
          <D.25803>:
          D.25802 = ins->next;
          D.25804 = D.25802->opcode;
          if (D.25804 != 565) goto <D.25800>; else goto <D.25801>;
          <D.25800>:
          i = 0;
          goto <D.24632>;
          <D.24631>:
          D.25805 = table->table;
          i.58 = (unsigned int) i;
          D.25807 = i.58 * 4;
          D.25808 = D.25805 + D.25807;
          D.25809 = *D.25808;
          if (D.25809 != 0B) goto <D.25810>; else goto <D.25811>;
          <D.25810>:
          D.25805 = table->table;
          i.58 = (unsigned int) i;
          D.25807 = i.58 * 4;
          D.25808 = D.25805 + D.25807;
          D.25809 = *D.25808;
          add_cprop_bb (cfg, D.25809, bblist);
          <D.25811>:
          i = i + 1;
          <D.24632>:
          D.25812 = table->table_size;
          if (D.25812 > i) goto <D.24631>; else goto <D.24633>;
          <D.24633>:
          return;
          <D.25801>:
          D.25802 = ins->next;
          D.25804 = D.25802->opcode;
          D.25813 = D.25804 != 565;
          D.25814 = (long int) D.25813;
          D.25815 = __builtin_expect (D.25814, 0);
          if (D.25815 != 0) goto <D.25816>; else goto <D.25817>;
          <D.25816>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 955, "ins->next->opcode == OP_PADD");
          <D.25817>:
          D.25802 = ins->next;
          D.25818 = D.25802->sreg1;
          D.25644 = ins->dreg;
          D.25819 = D.25818 != D.25644;
          D.25820 = (long int) D.25819;
          D.25821 = __builtin_expect (D.25820, 0);
          if (D.25821 != 0) goto <D.25822>; else goto <D.25823>;
          <D.25822>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 956, "ins->next->sreg1 == ins->dreg");
          <D.25823>:
          D.25802 = ins->next;
          D.25824 = D.25802->sreg2;
          D.25825 = (unsigned int) D.25824;
          D.25826 = D.25825 * 4;
          D.25827 = carray + D.25826;
          D.25828 = *D.25827;
          if (D.25828 != 0B) goto <D.25829>; else goto <D.25830>;
          <D.25829>:
          {
            int idx;

            D.25802 = ins->next;
            D.25824 = D.25802->sreg2;
            D.25825 = (unsigned int) D.25824;
            D.25826 = D.25825 * 4;
            D.25827 = carray + D.25826;
            D.25828 = *D.25827;
            D.25831 = D.25828->data.op[0].const_val;
            idx = D.25831 >> 2;
            if (idx < 0) goto <D.25832>; else goto <D.25834>;
            <D.25834>:
            D.25812 = table->table_size;
            if (D.25812 <= idx) goto <D.25832>; else goto <D.25833>;
            <D.25832>:
            return;
            <D.25833>:
            D.25805 = table->table;
            idx.59 = (unsigned int) idx;
            D.25836 = idx.59 * 4;
            D.25837 = D.25805 + D.25836;
            D.25838 = *D.25837;
            if (D.25838 != 0B) goto <D.25839>; else goto <D.25840>;
            <D.25839>:
            D.25805 = table->table;
            idx.59 = (unsigned int) idx;
            D.25836 = idx.59 * 4;
            D.25837 = D.25805 + D.25836;
            D.25838 = *D.25837;
            add_cprop_bb (cfg, D.25838, bblist);
            <D.25840>:
          }
          goto <D.25841>;
          <D.25830>:
          i = 0;
          goto <D.24636>;
          <D.24635>:
          D.25805 = table->table;
          i.58 = (unsigned int) i;
          D.25807 = i.58 * 4;
          D.25808 = D.25805 + D.25807;
          D.25809 = *D.25808;
          if (D.25809 != 0B) goto <D.25842>; else goto <D.25843>;
          <D.25842>:
          D.25805 = table->table;
          i.58 = (unsigned int) i;
          D.25807 = i.58 * 4;
          D.25808 = D.25805 + D.25807;
          D.25809 = *D.25808;
          add_cprop_bb (cfg, D.25809, bblist);
          <D.25843>:
          i = i + 1;
          <D.24636>:
          D.25812 = table->table_size;
          if (D.25812 > i) goto <D.24635>; else goto <D.24637>;
          <D.24637>:
          <D.25841>:
        }
        <D.25775>:
        D.25630 = ins->opcode;
        if (D.25630 == 370) goto <D.25844>; else goto <D.25845>;
        <D.25844>:
        {
          int i;
          struct MonoJumpInfoBBTable * table;

          table = ins->data.op[0].p;
          i = 0;
          goto <D.24641>;
          <D.24640>:
          D.25846 = table->table;
          i.60 = (unsigned int) i;
          D.25848 = i.60 * 4;
          D.25849 = D.25846 + D.25848;
          D.25850 = *D.25849;
          if (D.25850 != 0B) goto <D.25851>; else goto <D.25852>;
          <D.25851>:
          D.25846 = table->table;
          i.60 = (unsigned int) i;
          D.25848 = i.60 * 4;
          D.25849 = D.25846 + D.25848;
          D.25850 = *D.25849;
          add_cprop_bb (cfg, D.25850, bblist);
          <D.25852>:
          i = i + 1;
          <D.24641>:
          D.25853 = table->table_size;
          if (D.25853 > i) goto <D.24640>; else goto <D.24642>;
          <D.24642>:
        }
        <D.25845>:
        D.25802 = ins->next;
        if (D.25802 != 0B) goto <D.25856>; else goto <D.25857>;
        <D.25856>:
        D.25802 = ins->next;
        D.25858 = D.25802->opcode;
        D.25859 = D.25858 + 64985;
        D.25860 = D.25859 <= 9;
        D.25861 = D.25858 + 64878;
        D.25862 = D.25861 <= 9;
        D.25863 = D.25860 | D.25862;
        if (D.25863 != 0) goto <D.25854>; else goto <D.25864>;
        <D.25864>:
        D.25802 = ins->next;
        D.25804 = D.25802->opcode;
        D.25865 = D.25804 + 64888;
        if (D.25865 <= 9) goto <D.25854>; else goto <D.25855>;
        <D.25854>:
        c0.53 = c0;
        if (c0.53 != 0B) goto <D.25866>; else goto <D.25867>;
        <D.25866>:
        c0.53 = c0;
        D.25868 = c0.53->opcode;
        D.25869 = D.25868 != 362;
        D.25870 = (long int) D.25869;
        D.25871 = __builtin_expect (D.25870, 0);
        if (D.25871 != 0) goto <D.25872>; else goto <D.25873>;
        <D.25872>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 990, "c0->opcode == OP_ICONST");
        <D.25873>:
        c0.53 = c0;
        D.25874 = c0.53->data.op[0].const_val;
        if (D.25874 != 0) goto <D.25875>; else goto <D.25876>;
        <D.25875>:
        D.25802 = ins->next;
        D.25802 = ins->next;
        D.25877 = D.25802->flags;
        D.25878 = D.25877 | 8;
        D.25802->flags = D.25878;
        goto <D.25879>;
        <D.25876>:
        D.25802 = ins->next;
        D.25802 = ins->next;
        D.25877 = D.25802->flags;
        D.25880 = D.25877 | 16;
        D.25802->flags = D.25880;
        <D.25879>:
        goto <D.25881>;
        <D.25867>:
        D.25802 = ins->next;
        D.25802 = ins->next;
        D.25877 = D.25802->flags;
        D.25882 = D.25877 & 231;
        D.25802->flags = D.25882;
        <D.25881>:
        D.25802 = ins->next;
        visit_inst (cfg, bb, D.25802, cvars, bblist, carray);
        <D.25855>:
        <D.25857>:
      }
    finally
      {
        c0 = {CLOBBER};
      }
  }
  goto <D.25721>;
  <D.25719>:
  D.25630 = ins->opcode;
  if (D.25630 == 442) goto <D.25883>; else goto <D.25884>;
  <D.25883>:
  D.25885 = ins->data.op[0].target_block;
  add_cprop_bb (cfg, D.25885, bblist);
  goto <D.25886>;
  <D.25884>:
  D.25889 = ins->opcode;
  D.25890 = D.25889 + 64985;
  D.25891 = D.25890 <= 9;
  D.25892 = D.25889 + 64878;
  D.25893 = D.25892 <= 9;
  D.25894 = D.25891 | D.25893;
  if (D.25894 != 0) goto <D.25887>; else goto <D.25895>;
  <D.25895>:
  D.25630 = ins->opcode;
  D.25896 = D.25630 + 64888;
  if (D.25896 <= 9) goto <D.25887>; else goto <D.25888>;
  <D.25887>:
  D.25897 = ins->flags;
  D.25898 = (int) D.25897;
  D.25899 = D.25898 & 8;
  if (D.25899 != 0) goto <D.25900>; else goto <D.25901>;
  <D.25900>:
  D.25902 = ins->data.op[1].many_blocks;
  D.25903 = *D.25902;
  add_cprop_bb (cfg, D.25903, bblist);
  goto <D.25904>;
  <D.25901>:
  D.25897 = ins->flags;
  D.25898 = (int) D.25897;
  D.25905 = D.25898 & 16;
  if (D.25905 != 0) goto <D.25906>; else goto <D.25907>;
  <D.25906>:
  D.25902 = ins->data.op[1].many_blocks;
  D.25908 = D.25902 + 4;
  D.25909 = *D.25908;
  if (D.25909 != 0B) goto <D.25910>; else goto <D.25911>;
  <D.25910>:
  D.25902 = ins->data.op[1].many_blocks;
  D.25908 = D.25902 + 4;
  D.25909 = *D.25908;
  add_cprop_bb (cfg, D.25909, bblist);
  <D.25911>:
  goto <D.25912>;
  <D.25907>:
  D.25902 = ins->data.op[1].many_blocks;
  D.25903 = *D.25902;
  add_cprop_bb (cfg, D.25903, bblist);
  D.25902 = ins->data.op[1].many_blocks;
  D.25908 = D.25902 + 4;
  D.25909 = *D.25908;
  if (D.25909 != 0B) goto <D.25913>; else goto <D.25914>;
  <D.25913>:
  D.25902 = ins->data.op[1].many_blocks;
  D.25908 = D.25902 + 4;
  D.25909 = *D.25908;
  add_cprop_bb (cfg, D.25909, bblist);
  <D.25914>:
  <D.25912>:
  <D.25904>:
  <D.25888>:
  <D.25886>:
  <D.25721>:
  <D.25718>:
}


evaluate_ins (struct MonoCompile * cfg, struct MonoInst * ins, struct MonoInst * * res, struct MonoInst * * carray)
{
  short unsigned int D.25918;
  int D.25919;
  int D.25920;
  int D.25921;
  int D.25924;
  int D.25927;
  int D.25928;
  int D.25929;
  signed char D.25930;
  struct MonoInst * iftmp.61;
  int D.25932;
  unsigned int D.25933;
  unsigned int D.25934;
  struct MonoInst * * D.25937;
  unsigned int D.25938;
  unsigned int D.25939;
  struct MonoInst * * D.25940;
  struct MonoInst * * D.25942;
  struct MonoInst * D.25943;
  struct MonoInst * D.25944;
  unsigned char D.25950;
  int D.25951;
  int D.25952;
  struct MonoMethodVar * D.25955;
  int D.25956;
  unsigned int D.25957;
  unsigned int D.25958;
  struct MonoMethodVar * D.25959;
  char D.25960;
  int D.25961;
  int D.25962;
  _Bool D.25965;
  _Bool D.25966;
  _Bool D.25967;
  _Bool D.25970;
  long int D.25971;
  long int D.25972;
  char D.25975;
  int D.25978;
  unsigned int D.25979;
  unsigned int D.25980;
  struct MonoInst * * D.25981;
  struct MonoInst * D.25982;
  struct MonoInst * D.25985;
  struct MonoInst * D.25986;
  unsigned int D.25989;
  _Bool D.25990;
  long int D.25991;
  long int D.25992;
  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.25918 = ins->opcode;
      D.25919 = (int) D.25918;
      D.25920 = D.25919 + -313;
      D.25921 = D.25920 * 4;
      spec = &ins_info[D.25921];
      D.25918 = ins->opcode;
      if (D.25918 == 362) goto <D.25922>; else goto <D.25923>;
      <D.25922>:
      *res = ins;
      D.25924 = 1;
      return D.25924;
      <D.25923>:
      D.25918 = ins->opcode;
      if (D.25918 == 316) goto <D.25925>; else goto <D.25926>;
      <D.25925>:
      D.25924 = 2;
      return D.25924;
      <D.25926>:
      D.25927 = ins->sreg1;
      sregs[0] = D.25927;
      D.25928 = ins->sreg2;
      sregs[1] = D.25928;
      D.25929 = ins->sreg3;
      sregs[2] = D.25929;
      D.25918 = ins->opcode;
      D.25919 = (int) D.25918;
      D.25920 = D.25919 + -313;
      D.25930 = ins_sreg_counts[D.25920];
      num_sregs = (int) D.25930;
      i = 0;
      goto <D.24584>;
      <D.24583>:
      args[i] = 0B;
      i = i + 1;
      <D.24584>:
      if (i <= 2) goto <D.24583>; else goto <D.24585>;
      <D.24585>:
      i = 0;
      goto <D.24588>;
      <D.24587>:
      {
        struct MonoInst * var;

        D.25932 = sregs[i];
        D.25933 = (unsigned int) D.25932;
        D.25934 = cfg->vreg_to_inst_len;
        if (D.25933 < D.25934) goto <D.25935>; else goto <D.25936>;
        <D.25935>:
        D.25937 = cfg->vreg_to_inst;
        D.25932 = sregs[i];
        D.25938 = (unsigned int) D.25932;
        D.25939 = D.25938 * 4;
        D.25940 = D.25937 + D.25939;
        iftmp.61 = *D.25940;
        goto <D.25941>;
        <D.25936>:
        iftmp.61 = 0B;
        <D.25941>:
        var = iftmp.61;
        rs[i] = 2;
        D.25932 = sregs[i];
        D.25938 = (unsigned int) D.25932;
        D.25939 = D.25938 * 4;
        D.25942 = carray + D.25939;
        D.25943 = *D.25942;
        args[i] = D.25943;
        D.25944 = args[i];
        if (D.25944 != 0B) goto <D.25945>; else goto <D.25946>;
        <D.25945>:
        rs[i] = 1;
        goto <D.25947>;
        <D.25946>:
        if (var != 0B) goto <D.25948>; else goto <D.25949>;
        <D.25948>:
        D.25950 = var->flags;
        D.25951 = (int) D.25950;
        D.25952 = D.25951 & 20;
        if (D.25952 == 0) goto <D.25953>; else goto <D.25954>;
        <D.25953>:
        D.25955 = cfg->vars;
        D.25956 = var->data.op[0].const_val;
        D.25957 = (unsigned int) D.25956;
        D.25958 = D.25957 * 56;
        D.25959 = D.25955 + D.25958;
        D.25960 = D.25959->cpstate;
        D.25961 = (int) D.25960;
        rs[i] = D.25961;
        <D.25954>:
        <D.25949>:
        <D.25947>:
        D.25962 = rs[i];
        if (D.25962 != 1) goto <D.25963>; else goto <D.25964>;
        <D.25963>:
        const_args = 0;
        <D.25964>:
      }
      i = i + 1;
      <D.24588>:
      if (i < num_sregs) goto <D.24587>; else goto <D.24589>;
      <D.24589>:
      c0 = 0B;
      D.25965 = num_sregs > 0;
      D.25966 = const_args != 0;
      D.25967 = D.25965 & D.25966;
      if (D.25967 != 0) goto <D.25968>; else goto <D.25969>;
      <D.25968>:
      D.25970 = num_sregs > 2;
      D.25971 = (long int) D.25970;
      D.25972 = __builtin_expect (D.25971, 0);
      if (D.25972 != 0) goto <D.25973>; else goto <D.25974>;
      <D.25973>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 776, "num_sregs <= 2");
      <D.25974>:
      D.25975 = *spec;
      if (D.25975 != 32) goto <D.25976>; else goto <D.25977>;
      <D.25976>:
      D.25978 = ins->dreg;
      D.25979 = (unsigned int) D.25978;
      D.25980 = D.25979 * 4;
      D.25981 = carray + D.25980;
      D.25982 = *D.25981;
      if (D.25982 != 0B) goto <D.25983>; else goto <D.25984>;
      <D.25983>:
      D.25978 = ins->dreg;
      D.25979 = (unsigned int) D.25978;
      D.25980 = D.25979 * 4;
      D.25981 = carray + D.25980;
      D.25982 = *D.25981;
      *res = D.25982;
      D.25924 = 1;
      return D.25924;
      <D.25984>:
      <D.25977>:
      D.25985 = args[0];
      D.25986 = args[1];
      c0 = mono_constant_fold_ins (cfg, ins, D.25985, D.25986, 0);
      if (c0 != 0B) goto <D.25987>; else goto <D.25988>;
      <D.25987>:
      D.25989 = cfg->verbose_level;
      D.25990 = D.25989 > 1;
      D.25991 = (long int) D.25990;
      D.25992 = __builtin_expect (D.25991, 0);
      if (D.25992 != 0) goto <D.25993>; else goto <D.25994>;
      <D.25993>:
      printf ("\t cfold -> ");
      mono_print_ins (c0);
      <D.25994>:
      *res = c0;
      D.25924 = 1;
      return D.25924;
      <D.25988>:
      D.25924 = 2;
      return D.25924;
      <D.25969>:
      if (num_sregs == 0) goto <D.25995>; else goto <D.25996>;
      <D.25995>:
      D.25924 = 2;
      return D.25924;
      <D.25996>:
      i = 0;
      goto <D.24591>;
      <D.24590>:
      D.25962 = rs[i];
      if (D.25962 == 2) goto <D.25997>; else goto <D.25998>;
      <D.25997>:
      D.25924 = 2;
      return D.25924;
      <D.25998>:
      i = i + 1;
      <D.24591>:
      if (i < num_sregs) goto <D.24590>; else goto <D.24592>;
      <D.24592>:
      D.25924 = 0;
      return D.25924;
    }
  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.26001;
  int D.26002;
  char D.26005;
  unsigned int D.26006;
  _Bool D.26007;
  long int D.26008;
  long int D.26009;
  struct MonoInst * * D.26012;
  unsigned int D.26013;
  unsigned int D.26014;
  struct MonoInst * * D.26015;
  struct MonoInst * D.26016;
  int D.26017;
  _Bool D.26020;
  long int D.26021;
  long int D.26022;
  unsigned int D.26025;
  unsigned int D.26026;
  struct MonoInst * * D.26027;
  struct GList * D.26028;
  struct GList * D.26029;
  struct GList * D.26032;

  D.26001 = info->cpstate;
  D.26002 = (int) D.26001;
  if (D.26002 >= state) goto <D.26003>; else goto <D.26004>;
  <D.26003>:
  return;
  <D.26004>:
  D.26005 = (char) state;
  info->cpstate = D.26005;
  D.26006 = cfg->verbose_level;
  D.26007 = D.26006 > 1;
  D.26008 = (long int) D.26007;
  D.26009 = __builtin_expect (D.26008, 0);
  if (D.26009 != 0) goto <D.26010>; else goto <D.26011>;
  <D.26010>:
  D.26012 = cfg->varinfo;
  D.26013 = info->idx;
  D.26014 = D.26013 * 4;
  D.26015 = D.26012 + D.26014;
  D.26016 = *D.26015;
  D.26017 = D.26016->dreg;
  D.26001 = info->cpstate;
  D.26002 = (int) D.26001;
  printf ("\tState of R%d set to %d\n", D.26017, D.26002);
  <D.26011>:
  if (state == 1) goto <D.26018>; else goto <D.26019>;
  <D.26018>:
  D.26020 = c0 == 0B;
  D.26021 = (long int) D.26020;
  D.26022 = __builtin_expect (D.26021, 0);
  if (D.26022 != 0) goto <D.26023>; else goto <D.26024>;
  <D.26023>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 817, "c0");
  <D.26024>:
  <D.26019>:
  D.26012 = cfg->varinfo;
  D.26013 = info->idx;
  D.26014 = D.26013 * 4;
  D.26015 = D.26012 + D.26014;
  D.26016 = *D.26015;
  D.26017 = D.26016->dreg;
  D.26025 = (unsigned int) D.26017;
  D.26026 = D.26025 * 4;
  D.26027 = carray + D.26026;
  *D.26027 = c0;
  D.26028 = *cvars;
  D.26029 = monoeg_g_list_find (D.26028, info);
  if (D.26029 == 0B) goto <D.26030>; else goto <D.26031>;
  <D.26030>:
  D.26028 = *cvars;
  D.26032 = monoeg_g_list_prepend (D.26028, info);
  *cvars = D.26032;
  <D.26031>:
}


fold_ins (struct MonoCompile * cfg, struct MonoBasicBlock * bb, struct MonoInst * ins, struct MonoInst * * carray)
{
  short unsigned int D.26034;
  int D.26035;
  int D.26036;
  int D.26037;
  signed char D.26038;
  int D.26042;
  short unsigned int D.26044;
  unsigned int D.26048;
  unsigned int D.26049;
  struct MonoInst * * D.26050;
  struct MonoInst * D.26051;
  char D.26053;
  short unsigned int D.26056;
  _Bool D.26057;
  long int D.26058;
  long int D.26059;
  int D.26062;
  int D.26063;
  int D.26064;
  unsigned int D.26067;
  unsigned int D.26068;
  struct MonoInst * * D.26069;
  struct MonoInst * D.26070;
  short unsigned int D.26075;
  int D.26076;
  _Bool D.26079;
  _Bool D.26080;
  _Bool D.26081;
  _Bool D.26083;
  _Bool D.26084;
  _Bool D.26085;
  int D.26086;
  const void * D.26087;
  struct MonoInst * D.26094;
  struct MonoInst * D.26097;
  struct MonoJumpInfoBBTable * iftmp.62;
  struct MonoJumpInfoBBTable * iftmp.63;
  struct MonoJumpInfoBBTable * iftmp.64;
  struct MonoJumpInfoBBTable * iftmp.65;
  struct MonoInst * D.26118;
  short unsigned int D.26120;
  _Bool D.26121;
  long int D.26122;
  long int D.26123;
  int D.26126;
  _Bool D.26127;
  long int D.26128;
  long int D.26129;
  struct MonoInst * D.26132;
  short unsigned int D.26133;
  _Bool D.26134;
  long int D.26135;
  long int D.26136;
  int D.26139;
  unsigned int D.26140;
  unsigned int D.26141;
  struct MonoInst * * D.26142;
  struct MonoInst * D.26143;
  int D.26146;
  int D.26150;
  struct MonoBasicBlock * * D.26151;
  unsigned int i.66;
  unsigned int D.26153;
  struct MonoBasicBlock * * D.26154;
  struct MonoBasicBlock * D.26155;
  int D.26156;
  int D.26157;
  int D.26158;
  struct MonoInst * D.26159;
  int D.26162;
  int D.26163;
  short unsigned int D.26167;
  unsigned int D.26168;
  _Bool D.26169;
  long int D.26170;
  long int D.26171;
  unsigned int idx.67;
  unsigned int D.26177;
  struct MonoBasicBlock * * D.26178;
  struct MonoBasicBlock * D.26179;
  short unsigned int D.26184;
  short unsigned int D.26185;
  _Bool D.26186;
  short unsigned int D.26187;
  _Bool D.26188;
  _Bool D.26189;
  short unsigned int D.26191;
  unsigned char D.26192;
  int D.26193;
  int D.26194;
  struct MonoBasicBlock * * D.26197;
  struct MonoBasicBlock * * D.26198;
  struct MonoBasicBlock * D.26199;
  struct MonoBasicBlock * D.26200;
  int D.26202;
  struct MonoBasicBlock * D.26205;
  const char * spec;
  int opcode2;
  int num_sregs;

  D.26034 = ins->opcode;
  D.26035 = (int) D.26034;
  D.26036 = D.26035 + -313;
  D.26037 = D.26036 * 4;
  spec = &ins_info[D.26037];
  D.26034 = ins->opcode;
  D.26035 = (int) D.26034;
  D.26036 = D.26035 + -313;
  D.26038 = ins_sreg_counts[D.26036];
  num_sregs = (int) D.26038;
  D.26034 = ins->opcode;
  if (D.26034 != 316) goto <D.26041>; else goto <D.26039>;
  <D.26041>:
  D.26042 = ins->dreg;
  if (D.26042 != -1) goto <D.26043>; else goto <D.26039>;
  <D.26043>:
  D.26034 = ins->opcode;
  D.26044 = D.26034 + 65162;
  if (D.26044 > 13) goto <D.26045>; else goto <D.26039>;
  <D.26045>:
  D.26042 = ins->dreg;
  D.26048 = (unsigned int) D.26042;
  D.26049 = D.26048 * 4;
  D.26050 = carray + D.26049;
  D.26051 = *D.26050;
  if (D.26051 != 0B) goto <D.26052>; else goto <D.26046>;
  <D.26052>:
  D.26053 = *spec;
  if (D.26053 == 105) goto <D.26054>; else goto <D.26046>;
  <D.26054>:
  D.26042 = ins->dreg;
  if (D.26042 > 15) goto <D.26055>; else goto <D.26046>;
  <D.26055>:
  D.26042 = ins->dreg;
  D.26048 = (unsigned int) D.26042;
  D.26049 = D.26048 * 4;
  D.26050 = carray + D.26049;
  D.26051 = *D.26050;
  D.26056 = D.26051->opcode;
  D.26057 = D.26056 != 362;
  D.26058 = (long int) D.26057;
  D.26059 = __builtin_expect (D.26058, 0);
  if (D.26059 != 0) goto <D.26060>; else goto <D.26061>;
  <D.26060>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 1035, "carray [ins->dreg]->opcode == OP_ICONST");
  <D.26061>:
  ins->opcode = 362;
  D.26042 = ins->dreg;
  D.26048 = (unsigned int) D.26042;
  D.26049 = D.26048 * 4;
  D.26050 = carray + D.26049;
  D.26051 = *D.26050;
  D.26062 = D.26051->data.op[0].const_val;
  ins->data.op[0].const_val = D.26062;
  ins->sreg3 = -1;
  D.26063 = ins->sreg3;
  ins->sreg2 = D.26063;
  D.26064 = ins->sreg2;
  ins->sreg1 = D.26064;
  goto <D.26047>;
  <D.26046>:
  if (num_sregs == 2) goto <D.26065>; else goto <D.26066>;
  <D.26065>:
  D.26064 = ins->sreg2;
  D.26067 = (unsigned int) D.26064;
  D.26068 = D.26067 * 4;
  D.26069 = carray + D.26068;
  D.26070 = *D.26069;
  if (D.26070 != 0B) goto <D.26071>; else goto <D.26072>;
  <D.26071>:
  D.26034 = ins->opcode;
  D.26035 = (int) D.26034;
  opcode2 = mono_op_to_op_imm (D.26035);
  if (opcode2 != -1) goto <D.26073>; else goto <D.26074>;
  <D.26073>:
  D.26075 = (short unsigned int) opcode2;
  ins->opcode = D.26075;
  D.26064 = ins->sreg2;
  D.26067 = (unsigned int) D.26064;
  D.26068 = D.26067 * 4;
  D.26069 = carray + D.26068;
  D.26070 = *D.26069;
  D.26076 = D.26070->data.op[0].const_val;
  ins->data.op[1].const_val = D.26076;
  ins->sreg2 = -1;
  D.26079 = opcode2 == 343;
  D.26080 = opcode2 == 346;
  D.26081 = D.26079 | D.26080;
  if (D.26081 != 0) goto <D.26077>; else goto <D.26082>;
  <D.26082>:
  D.26083 = opcode2 == 352;
  D.26084 = opcode2 == 349;
  D.26085 = D.26083 | D.26084;
  if (D.26085 != 0) goto <D.26077>; else goto <D.26078>;
  <D.26077>:
  D.26086 = ins->data.op[1].const_val;
  D.26087 = (const void *) D.26086;
  MEM[(struct MonoCallInst *)ins].fptr = D.26087;
  <D.26078>:
  <D.26074>:
  goto <D.26088>;
  <D.26072>:
  <D.26088>:
  <D.26066>:
  <D.26047>:
  D.26034 = ins->opcode;
  if (D.26034 == 731) goto <D.26089>; else goto <D.26092>;
  <D.26092>:
  D.26034 = ins->opcode;
  if (D.26034 == 732) goto <D.26093>; else goto <D.26090>;
  <D.26093>:
  D.26094 = ins->data.op[1].src;
  if (D.26094 == 8B) goto <D.26089>; else goto <D.26090>;
  <D.26090>:
  D.26034 = ins->opcode;
  if (D.26034 == 370) goto <D.26089>; else goto <D.26095>;
  <D.26095>:
  D.26034 = ins->opcode;
  if (D.26034 == 734) goto <D.26096>; else goto <D.26091>;
  <D.26096>:
  D.26094 = ins->data.op[1].src;
  D.26097 = D.26094->data.op[1].src;
  if (D.26097 == 8B) goto <D.26089>; else goto <D.26091>;
  <D.26089>:
  {
    int i;
    struct MonoJumpInfoBBTable * table;

    D.26034 = ins->opcode;
    if (D.26034 == 731) goto <D.26099>; else goto <D.26100>;
    <D.26099>:
    iftmp.62 = ins->data.op[0].p;
    goto <D.26101>;
    <D.26100>:
    D.26034 = ins->opcode;
    if (D.26034 == 732) goto <D.26105>; else goto <D.26103>;
    <D.26105>:
    D.26094 = ins->data.op[1].src;
    if (D.26094 == 8B) goto <D.26106>; else goto <D.26103>;
    <D.26106>:
    iftmp.63 = ins->data.op[0].p;
    goto <D.26104>;
    <D.26103>:
    D.26034 = ins->opcode;
    if (D.26034 == 370) goto <D.26108>; else goto <D.26109>;
    <D.26108>:
    iftmp.64 = ins->data.op[0].p;
    goto <D.26110>;
    <D.26109>:
    D.26034 = ins->opcode;
    if (D.26034 == 734) goto <D.26114>; else goto <D.26112>;
    <D.26114>:
    D.26094 = ins->data.op[1].src;
    D.26097 = D.26094->data.op[1].src;
    if (D.26097 == 8B) goto <D.26115>; else goto <D.26112>;
    <D.26115>:
    D.26094 = ins->data.op[1].src;
    iftmp.65 = D.26094->data.op[0].p;
    goto <D.26113>;
    <D.26112>:
    iftmp.65 = 0B;
    <D.26113>:
    iftmp.64 = iftmp.65;
    <D.26110>:
    iftmp.63 = iftmp.64;
    <D.26104>:
    iftmp.62 = iftmp.63;
    <D.26101>:
    table = iftmp.62;
    D.26118 = ins->next;
    if (D.26118 == 0B) goto <D.26116>; else goto <D.26119>;
    <D.26119>:
    D.26118 = ins->next;
    D.26120 = D.26118->opcode;
    if (D.26120 != 565) goto <D.26116>; else goto <D.26117>;
    <D.26116>:
    return;
    <D.26117>:
    D.26118 = ins->next;
    D.26120 = D.26118->opcode;
    D.26121 = D.26120 != 565;
    D.26122 = (long int) D.26121;
    D.26123 = __builtin_expect (D.26122, 0);
    if (D.26123 != 0) goto <D.26124>; else goto <D.26125>;
    <D.26124>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 1064, "ins->next->opcode == OP_PADD");
    <D.26125>:
    D.26118 = ins->next;
    D.26126 = D.26118->sreg1;
    D.26042 = ins->dreg;
    D.26127 = D.26126 != D.26042;
    D.26128 = (long int) D.26127;
    D.26129 = __builtin_expect (D.26128, 0);
    if (D.26129 != 0) goto <D.26130>; else goto <D.26131>;
    <D.26130>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 1065, "ins->next->sreg1 == ins->dreg");
    <D.26131>:
    D.26118 = ins->next;
    D.26132 = D.26118->next;
    D.26133 = D.26132->opcode;
    D.26134 = D.26133 != 388;
    D.26135 = (long int) D.26134;
    D.26136 = __builtin_expect (D.26135, 0);
    if (D.26136 != 0) goto <D.26137>; else goto <D.26138>;
    <D.26137>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 1066, "ins->next->next->opcode == OP_LOAD_MEMBASE");
    <D.26138>:
    D.26118 = ins->next;
    D.26139 = D.26118->sreg2;
    D.26140 = (unsigned int) D.26139;
    D.26141 = D.26140 * 4;
    D.26142 = carray + D.26141;
    D.26143 = *D.26142;
    if (D.26143 != 0B) goto <D.26144>; else goto <D.26145>;
    <D.26144>:
    {
      int idx;

      D.26118 = ins->next;
      D.26139 = D.26118->sreg2;
      D.26140 = (unsigned int) D.26139;
      D.26141 = D.26140 * 4;
      D.26142 = carray + D.26141;
      D.26143 = *D.26142;
      D.26146 = D.26143->data.op[0].const_val;
      idx = D.26146 >> 2;
      if (idx < 0) goto <D.26147>; else goto <D.26149>;
      <D.26149>:
      D.26150 = table->table_size;
      if (D.26150 <= idx) goto <D.26147>; else goto <D.26148>;
      <D.26147>:
      i = 0;
      goto <D.24656>;
      <D.24655>:
      D.26151 = table->table;
      i.66 = (unsigned int) i;
      D.26153 = i.66 * 4;
      D.26154 = D.26151 + D.26153;
      D.26155 = *D.26154;
      remove_bb_from_phis (cfg, bb, D.26155);
      D.26151 = table->table;
      i.66 = (unsigned int) i;
      D.26153 = i.66 * 4;
      D.26154 = D.26151 + D.26153;
      D.26155 = *D.26154;
      mono_unlink_bblock (cfg, bb, D.26155);
      i = i + 1;
      <D.24656>:
      D.26150 = table->table_size;
      if (D.26150 > i) goto <D.24655>; else goto <D.24657>;
      <D.24657>:
      ins->opcode = 316;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.26063 = ins->sreg3;
      ins->sreg2 = D.26063;
      D.26064 = ins->sreg2;
      ins->sreg1 = D.26064;
      D.26118 = ins->next;
      D.26118->opcode = 316;
      D.26118 = ins->next;
      D.26118->dreg = -1;
      D.26118 = ins->next;
      D.26118 = ins->next;
      D.26118 = ins->next;
      D.26118->sreg3 = -1;
      D.26156 = D.26118->sreg3;
      D.26118->sreg2 = D.26156;
      D.26139 = D.26118->sreg2;
      D.26118->sreg1 = D.26139;
      D.26118 = ins->next;
      D.26132 = D.26118->next;
      D.26132->opcode = 316;
      D.26118 = ins->next;
      D.26132 = D.26118->next;
      D.26132->dreg = -1;
      D.26118 = ins->next;
      D.26132 = D.26118->next;
      D.26118 = ins->next;
      D.26132 = D.26118->next;
      D.26118 = ins->next;
      D.26132 = D.26118->next;
      D.26132->sreg3 = -1;
      D.26157 = D.26132->sreg3;
      D.26132->sreg2 = D.26157;
      D.26158 = D.26132->sreg2;
      D.26132->sreg1 = D.26158;
      D.26118 = ins->next;
      D.26132 = D.26118->next;
      D.26159 = D.26132->next;
      if (D.26159 != 0B) goto <D.26160>; else goto <D.26161>;
      <D.26160>:
      D.26118 = ins->next;
      D.26132 = D.26118->next;
      D.26159 = D.26132->next;
      D.26159->opcode = 316;
      D.26118 = ins->next;
      D.26132 = D.26118->next;
      D.26159 = D.26132->next;
      D.26159->dreg = -1;
      D.26118 = ins->next;
      D.26132 = D.26118->next;
      D.26159 = D.26132->next;
      D.26118 = ins->next;
      D.26132 = D.26118->next;
      D.26159 = D.26132->next;
      D.26118 = ins->next;
      D.26132 = D.26118->next;
      D.26159 = D.26132->next;
      D.26159->sreg3 = -1;
      D.26162 = D.26159->sreg3;
      D.26159->sreg2 = D.26162;
      D.26163 = D.26159->sreg2;
      D.26159->sreg1 = D.26163;
      <D.26161>:
      return;
      <D.26148>:
      D.26118 = ins->next;
      D.26132 = D.26118->next;
      D.26159 = D.26132->next;
      if (D.26159 == 0B) goto <D.26164>; else goto <D.26166>;
      <D.26166>:
      D.26118 = ins->next;
      D.26132 = D.26118->next;
      D.26159 = D.26132->next;
      D.26167 = D.26159->opcode;
      if (D.26167 != 759) goto <D.26164>; else goto <D.26165>;
      <D.26164>:
      D.26168 = cfg->verbose_level;
      D.26169 = D.26168 > 1;
      D.26170 = (long int) D.26169;
      D.26171 = __builtin_expect (D.26170, 0);
      if (D.26171 != 0) goto <D.26172>; else goto <D.26173>;
      <D.26172>:
      printf ("\tNo cfold on ");
      mono_print_ins (ins);
      <D.26173>:
      return;
      <D.26165>:
      D.26168 = cfg->verbose_level;
      D.26169 = D.26168 > 1;
      D.26170 = (long int) D.26169;
      D.26171 = __builtin_expect (D.26170, 0);
      if (D.26171 != 0) goto <D.26174>; else goto <D.26175>;
      <D.26174>:
      printf ("\tcfold on ");
      mono_print_ins (ins);
      <D.26175>:
      i = 0;
      goto <D.24659>;
      <D.24658>:
      D.26151 = table->table;
      i.66 = (unsigned int) i;
      D.26153 = i.66 * 4;
      D.26154 = D.26151 + D.26153;
      D.26155 = *D.26154;
      D.26151 = table->table;
      idx.67 = (unsigned int) idx;
      D.26177 = idx.67 * 4;
      D.26178 = D.26151 + D.26177;
      D.26179 = *D.26178;
      if (D.26155 != D.26179) goto <D.26180>; else goto <D.26181>;
      <D.26180>:
      D.26151 = table->table;
      i.66 = (unsigned int) i;
      D.26153 = i.66 * 4;
      D.26154 = D.26151 + D.26153;
      D.26155 = *D.26154;
      remove_bb_from_phis (cfg, bb, D.26155);
      D.26151 = table->table;
      i.66 = (unsigned int) i;
      D.26153 = i.66 * 4;
      D.26154 = D.26151 + D.26153;
      D.26155 = *D.26154;
      mono_unlink_bblock (cfg, bb, D.26155);
      <D.26181>:
      i = i + 1;
      <D.24659>:
      D.26150 = table->table_size;
      if (D.26150 > i) goto <D.24658>; else goto <D.24660>;
      <D.24660>:
      D.26118 = ins->next;
      D.26132 = D.26118->next;
      D.26159 = D.26132->next;
      D.26159->opcode = 442;
      D.26118 = ins->next;
      D.26132 = D.26118->next;
      D.26159 = D.26132->next;
      D.26151 = table->table;
      idx.67 = (unsigned int) idx;
      D.26177 = idx.67 * 4;
      D.26178 = D.26151 + D.26177;
      D.26179 = *D.26178;
      D.26159->data.op[0].target_block = D.26179;
      D.26118 = ins->next;
      D.26132 = D.26118->next;
      D.26159 = D.26132->next;
      D.26159->sreg1 = -1;
      ins->opcode = 316;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.26063 = ins->sreg3;
      ins->sreg2 = D.26063;
      D.26064 = ins->sreg2;
      ins->sreg1 = D.26064;
      D.26118 = ins->next;
      D.26118->opcode = 316;
      D.26118 = ins->next;
      D.26118->dreg = -1;
      D.26118 = ins->next;
      D.26118 = ins->next;
      D.26118 = ins->next;
      D.26118->sreg3 = -1;
      D.26156 = D.26118->sreg3;
      D.26118->sreg2 = D.26156;
      D.26139 = D.26118->sreg2;
      D.26118->sreg1 = D.26139;
      D.26118 = ins->next;
      D.26132 = D.26118->next;
      D.26132->opcode = 316;
      D.26118 = ins->next;
      D.26132 = D.26118->next;
      D.26132->dreg = -1;
      D.26118 = ins->next;
      D.26132 = D.26118->next;
      D.26118 = ins->next;
      D.26132 = D.26118->next;
      D.26118 = ins->next;
      D.26132 = D.26118->next;
      D.26132->sreg3 = -1;
      D.26157 = D.26132->sreg3;
      D.26132->sreg2 = D.26157;
      D.26158 = D.26132->sreg2;
      D.26132->sreg1 = D.26158;
    }
    <D.26145>:
  }
  <D.26091>:
  goto <D.26040>;
  <D.26039>:
  D.26184 = ins->opcode;
  D.26185 = D.26184 + 64985;
  D.26186 = D.26185 <= 9;
  D.26187 = D.26184 + 64878;
  D.26188 = D.26187 <= 9;
  D.26189 = D.26186 | D.26188;
  if (D.26189 != 0) goto <D.26182>; else goto <D.26190>;
  <D.26190>:
  D.26034 = ins->opcode;
  D.26191 = D.26034 + 64888;
  if (D.26191 <= 9) goto <D.26182>; else goto <D.26183>;
  <D.26182>:
  D.26192 = ins->flags;
  D.26193 = (int) D.26192;
  D.26194 = D.26193 & 8;
  if (D.26194 != 0) goto <D.26195>; else goto <D.26196>;
  <D.26195>:
  D.26197 = ins->data.op[1].many_blocks;
  D.26198 = D.26197 + 4;
  D.26199 = *D.26198;
  remove_bb_from_phis (cfg, bb, D.26199);
  D.26197 = ins->data.op[1].many_blocks;
  D.26198 = D.26197 + 4;
  D.26199 = *D.26198;
  mono_unlink_bblock (cfg, bb, D.26199);
  ins->opcode = 442;
  D.26197 = ins->data.op[1].many_blocks;
  D.26200 = *D.26197;
  ins->data.op[0].target_block = D.26200;
  goto <D.26201>;
  <D.26196>:
  D.26192 = ins->flags;
  D.26193 = (int) D.26192;
  D.26202 = D.26193 & 16;
  if (D.26202 != 0) goto <D.26203>; else goto <D.26204>;
  <D.26203>:
  D.26197 = ins->data.op[1].many_blocks;
  D.26200 = *D.26197;
  remove_bb_from_phis (cfg, bb, D.26200);
  D.26197 = ins->data.op[1].many_blocks;
  D.26200 = *D.26197;
  mono_unlink_bblock (cfg, bb, D.26200);
  ins->opcode = 442;
  D.26197 = ins->data.op[1].many_blocks;
  D.26205 = MEM[(struct MonoBasicBlock * *)D.26197 + 4B];
  ins->data.op[0].target_block = D.26205;
  <D.26204>:
  <D.26201>:
  <D.26183>:
  <D.26040>:
}


remove_bb_from_phis (struct MonoCompile * cfg, struct MonoBasicBlock * bb, struct MonoBasicBlock * target)
{
  struct MonoBasicBlock * * D.26207;
  unsigned int i.68;
  unsigned int D.26209;
  struct MonoBasicBlock * * D.26210;
  struct MonoBasicBlock * D.26211;
  short int D.26213;
  int D.26214;
  _Bool D.26215;
  long int D.26216;
  long int D.26217;
  short unsigned int D.26220;
  short unsigned int D.26221;
  int * D.26223;
  sizetype j.69;
  sizetype D.26225;
  sizetype D.26226;
  int * D.26227;
  sizetype D.26228;
  sizetype D.26229;
  int * D.26230;
  int D.26231;
  int D.26232;
  int D.26233;
  struct MonoInst * ins;
  int i;
  int j;

  i = 0;
  goto <D.24334>;
  <D.24333>:
  D.26207 = target->in_bb;
  i.68 = (unsigned int) i;
  D.26209 = i.68 * 4;
  D.26210 = D.26207 + D.26209;
  D.26211 = *D.26210;
  if (D.26211 == bb) goto <D.24332>; else goto <D.26212>;
  <D.26212>:
  i = i + 1;
  <D.24334>:
  D.26213 = target->in_count;
  D.26214 = (int) D.26213;
  if (D.26214 > i) goto <D.24333>; else goto <D.24332>;
  <D.24332>:
  D.26213 = target->in_count;
  D.26214 = (int) D.26213;
  D.26215 = D.26214 <= i;
  D.26216 = (long int) D.26215;
  D.26217 = __builtin_expect (D.26216, 0);
  if (D.26217 != 0) goto <D.26218>; else goto <D.26219>;
  <D.26218>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 111, "i < target->in_count");
  <D.26219>:
  ins = target->code;
  goto <D.24340>;
  <D.24339>:
  D.26220 = ins->opcode;
  D.26221 = D.26220 + 65217;
  if (D.26221 <= 2) goto <D.26222>; else goto <D.24338>;
  <D.26222>:
  j = i;
  goto <D.24336>;
  <D.24335>:
  D.26223 = ins->data.op[1].phi_args;
  j.69 = (sizetype) j;
  D.26225 = j.69 + 1;
  D.26226 = D.26225 * 4;
  D.26227 = D.26223 + D.26226;
  D.26223 = ins->data.op[1].phi_args;
  j.69 = (sizetype) j;
  D.26228 = j.69 + 2;
  D.26229 = D.26228 * 4;
  D.26230 = D.26223 + D.26229;
  D.26231 = *D.26230;
  *D.26227 = D.26231;
  j = j + 1;
  <D.24336>:
  D.26223 = ins->data.op[1].phi_args;
  D.26232 = *D.26223;
  D.26233 = D.26232 + -1;
  if (D.26233 > j) goto <D.24335>; else goto <D.24337>;
  <D.24337>:
  D.26223 = ins->data.op[1].phi_args;
  D.26232 = *D.26223;
  D.26233 = D.26232 + -1;
  *D.26223 = D.26233;
  ins = ins->next;
  <D.24340>:
  if (ins != 0B) goto <D.24339>; else goto <D.24338>;
  <D.24338>:
}


mono_ssa_deadce (struct MonoCompile * cfg)
{
  unsigned int D.26234;
  unsigned int D.26235;
  _Bool D.26236;
  long int D.26237;
  long int D.26238;
  unsigned int D.26241;
  struct MonoMethodVar * D.26244;
  unsigned int i.70;
  unsigned int D.26246;
  struct MonoMemPool * D.26247;
  struct GList * work_list.71;
  struct GList * work_list.72;
  unsigned int i.73;
  unsigned int D.26251;
  struct GList * work_list.74;
  struct MonoInst * D.26255;
  struct GList * D.26258;
  struct GList * D.26260;
  void * D.26262;
  struct MonoInst * D.26263;
  short unsigned int D.26267;
  _Bool D.26268;
  _Bool D.26269;
  _Bool D.26270;
  short unsigned int D.26272;
  struct MonoInst * iftmp.75;
  int D.26275;
  unsigned int D.26276;
  unsigned int D.26277;
  struct MonoInst * * D.26280;
  unsigned int D.26281;
  unsigned int D.26282;
  struct MonoInst * * D.26283;
  unsigned char D.26287;
  int D.26288;
  int D.26289;
  int D.26292;
  unsigned int D.26293;
  unsigned int D.26294;
  struct MonoMethodVar * D.26295;
  int D.26296;
  short unsigned int D.26297;
  short unsigned int D.26298;
  _Bool D.26299;
  _Bool D.26300;
  _Bool D.26301;
  short unsigned int D.26305;
  int * D.26308;
  struct MonoInst * iftmp.76;
  unsigned int j.77;
  unsigned int D.26311;
  int * D.26312;
  int D.26313;
  unsigned int D.26314;
  unsigned int D.26317;
  unsigned int D.26318;
  struct MonoInst * * D.26319;
  int D.26321;
  unsigned int D.26322;
  unsigned int D.26323;
  int i;
  struct GList * work_list;

  try
    {
      D.26234 = cfg->comp_done;
      D.26235 = D.26234 & 32;
      D.26236 = D.26235 == 0;
      D.26237 = (long int) D.26236;
      D.26238 = __builtin_expect (D.26237, 0);
      if (D.26238 != 0) goto <D.26239>; else goto <D.26240>;
      <D.26239>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 1259, "cfg->comp_done & MONO_COMP_SSA");
      <D.26240>:
      D.26234 = cfg->comp_done;
      D.26241 = D.26234 & 64;
      if (D.26241 == 0) goto <D.26242>; else goto <D.26243>;
      <D.26242>:
      mono_ssa_create_def_use (cfg);
      <D.26243>:
      mono_ssa_copyprop (cfg);
      work_list = 0B;
      i = 0;
      goto <D.24725>;
      <D.24724>:
      {
        struct MonoMethodVar * info;

        D.26244 = cfg->vars;
        i.70 = (unsigned int) i;
        D.26246 = i.70 * 56;
        info = D.26244 + D.26246;
        D.26247 = cfg->mempool;
        work_list.71 = work_list;
        work_list.72 = g_list_prepend_mempool (D.26247, work_list.71, info);
        work_list = work_list.72;
      }
      i = i + 1;
      <D.24725>:
      i.73 = (unsigned int) i;
      D.26251 = cfg->num_varinfo;
      if (i.73 < D.26251) goto <D.24724>; else goto <D.24726>;
      <D.24726>:
      goto <D.24736>;
      <D.24735>:
      {
        struct MonoMethodVar * info;

        work_list.71 = work_list;
        info = work_list.71->data;
        work_list.71 = work_list;
        work_list.71 = work_list;
        work_list.74 = monoeg_g_list_remove_link (work_list.71, work_list.71);
        work_list = work_list.74;
        D.26255 = info->def;
        if (D.26255 != 0B) goto <D.26256>; else goto <D.26257>;
        <D.26256>:
        D.26258 = info->uses;
        if (D.26258 == 0B) goto <D.26253>; else goto <D.26259>;
        <D.26259>:
        D.26258 = info->uses;
        D.26260 = D.26258->next;
        if (D.26260 == 0B) goto <D.26261>; else goto <D.26254>;
        <D.26261>:
        D.26258 = info->uses;
        D.26262 = D.26258->data;
        D.26263 = MEM[(struct MonoVarUsageInfo *)D.26262].inst;
        D.26255 = info->def;
        if (D.26263 == D.26255) goto <D.26253>; else goto <D.26254>;
        <D.26253>:
        {
          struct MonoInst * def;

          def = info->def;
          D.26267 = def->opcode;
          D.26268 = D.26267 == 424;
          D.26269 = D.26267 == 426;
          D.26270 = D.26268 | D.26269;
          if (D.26270 != 0) goto <D.26264>; else goto <D.26271>;
          <D.26271>:
          D.26272 = def->opcode;
          if (D.26272 == 427) goto <D.26264>; else goto <D.26265>;
          <D.26264>:
          if (1 != 0) goto <D.26273>; else goto <D.26265>;
          <D.26273>:
          {
            struct MonoInst * src_var;

            D.26275 = def->sreg1;
            D.26276 = (unsigned int) D.26275;
            D.26277 = cfg->vreg_to_inst_len;
            if (D.26276 < D.26277) goto <D.26278>; else goto <D.26279>;
            <D.26278>:
            D.26280 = cfg->vreg_to_inst;
            D.26275 = def->sreg1;
            D.26281 = (unsigned int) D.26275;
            D.26282 = D.26281 * 4;
            D.26283 = D.26280 + D.26282;
            iftmp.75 = *D.26283;
            goto <D.26284>;
            <D.26279>:
            iftmp.75 = 0B;
            <D.26284>:
            src_var = iftmp.75;
            if (src_var != 0B) goto <D.26285>; else goto <D.26286>;
            <D.26285>:
            D.26287 = src_var->flags;
            D.26288 = (int) D.26287;
            D.26289 = D.26288 & 20;
            if (D.26289 == 0) goto <D.26290>; else goto <D.26291>;
            <D.26290>:
            D.26244 = cfg->vars;
            D.26292 = src_var->data.op[0].const_val;
            D.26293 = (unsigned int) D.26292;
            D.26294 = D.26293 * 56;
            D.26295 = D.26244 + D.26294;
            add_to_dce_worklist (cfg, info, D.26295, &work_list);
            <D.26291>:
            <D.26286>:
            def->opcode = 316;
            def->sreg2 = -1;
            D.26296 = def->sreg2;
            def->sreg1 = D.26296;
            D.26275 = def->sreg1;
            def->dreg = D.26275;
            info->reg = -1;
          }
          goto <D.26266>;
          <D.26265>:
          D.26297 = def->opcode;
          D.26298 = D.26297 + 65174;
          D.26299 = D.26298 <= 1;
          D.26300 = D.26297 == 428;
          D.26301 = D.26299 | D.26300;
          if (D.26301 != 0) goto <D.26302>; else goto <D.26303>;
          <D.26302>:
          def->opcode = 316;
          def->sreg2 = -1;
          D.26296 = def->sreg2;
          def->sreg1 = D.26296;
          D.26275 = def->sreg1;
          def->dreg = D.26275;
          info->reg = -1;
          goto <D.26304>;
          <D.26303>:
          D.26272 = def->opcode;
          D.26305 = D.26272 + 65217;
          if (D.26305 <= 2) goto <D.26306>; else goto <D.26307>;
          <D.26306>:
          {
            int j;

            D.26308 = def->data.op[1].phi_args;
            j = *D.26308;
            goto <D.24733>;
            <D.24732>:
            {
              struct MonoMethodVar * u;

              D.26244 = cfg->vars;
              D.26308 = def->data.op[1].phi_args;
              j.77 = (unsigned int) j;
              D.26311 = j.77 * 4;
              D.26312 = D.26308 + D.26311;
              D.26313 = *D.26312;
              D.26314 = (unsigned int) D.26313;
              D.26277 = cfg->vreg_to_inst_len;
              if (D.26314 < D.26277) goto <D.26315>; else goto <D.26316>;
              <D.26315>:
              D.26280 = cfg->vreg_to_inst;
              D.26308 = def->data.op[1].phi_args;
              j.77 = (unsigned int) j;
              D.26311 = j.77 * 4;
              D.26312 = D.26308 + D.26311;
              D.26313 = *D.26312;
              D.26317 = (unsigned int) D.26313;
              D.26318 = D.26317 * 4;
              D.26319 = D.26280 + D.26318;
              iftmp.76 = *D.26319;
              goto <D.26320>;
              <D.26316>:
              iftmp.76 = 0B;
              <D.26320>:
              D.26321 = iftmp.76->data.op[0].const_val;
              D.26322 = (unsigned int) D.26321;
              D.26323 = D.26322 * 56;
              u = D.26244 + D.26323;
              add_to_dce_worklist (cfg, info, u, &work_list);
            }
            j = j + -1;
            <D.24733>:
            if (j > 0) goto <D.24732>; else goto <D.24734>;
            <D.24734>:
            def->opcode = 316;
            def->sreg2 = -1;
            D.26296 = def->sreg2;
            def->sreg1 = D.26296;
            D.26275 = def->sreg1;
            def->dreg = D.26275;
            info->reg = -1;
          }
          goto <D.26324>;
          <D.26307>:
          D.26272 = def->opcode;
          if (D.26272 == 316) goto <D.26325>; else goto <D.26326>;
          <D.26325>:
          <D.26326>:
          <D.26324>:
          <D.26304>:
          <D.26266>:
        }
        <D.26254>:
        <D.26257>:
      }
      <D.24736>:
      work_list.71 = work_list;
      if (work_list.71 != 0B) goto <D.24735>; else goto <D.24737>;
      <D.24737>:
    }
  finally
    {
      work_list = {CLOBBER};
    }
}


mono_ssa_copyprop (struct MonoCompile * cfg)
{
  unsigned int D.26327;
  unsigned int D.26328;
  _Bool D.26329;
  long int D.26330;
  long int D.26331;
  struct MonoInst * * D.26334;
  unsigned int index.78;
  unsigned int D.26336;
  struct MonoInst * * D.26337;
  struct MonoMethodVar * D.26338;
  unsigned int D.26339;
  struct MonoInst * D.26342;
  short unsigned int D.26345;
  _Bool D.26346;
  _Bool D.26347;
  _Bool D.26348;
  short unsigned int D.26350;
  struct MonoInst * iftmp.79;
  int D.26352;
  unsigned int D.26353;
  unsigned int D.26354;
  struct MonoInst * * D.26357;
  unsigned int D.26358;
  unsigned int D.26359;
  struct MonoInst * * D.26360;
  unsigned char D.26364;
  int D.26365;
  int D.26366;
  int D.26369;
  unsigned int D.26370;
  unsigned int D.26371;
  struct MonoMethodVar * D.26372;
  struct MonoInst * D.26373;
  short unsigned int D.26376;
  short unsigned int D.26377;
  int D.26380;
  int D.26381;
  int D.26382;
  short unsigned int D.26383;
  int D.26384;
  int D.26385;
  signed char D.26386;
  int D.26387;
  _Bool D.26391;
  long int D.26392;
  long int D.26393;
  short unsigned int D.26399;
  int D.26401;
  short unsigned int D.26403;
  int * D.26406;
  unsigned int i.80;
  unsigned int D.26408;
  int * D.26409;
  int D.26410;
  _Bool D.26412;
  long int D.26413;
  long int D.26414;
  struct MonoBasicBlock * D.26418;
  unsigned int index.81;
  unsigned int D.26420;
  unsigned int D.26421;
  int i;
  int index;
  struct GList * l;

  D.26327 = cfg->comp_done;
  D.26328 = D.26327 & 64;
  D.26329 = D.26328 == 0;
  D.26330 = (long int) D.26329;
  D.26331 = __builtin_expect (D.26330, 0);
  if (D.26331 != 0) goto <D.26332>; else goto <D.26333>;
  <D.26332>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 674, "(cfg->comp_done & MONO_COMP_SSA_DEF_USE)");
  <D.26333>:
  index = 0;
  goto <D.24563>;
  <D.24562>:
  {
    struct MonoInst * var;
    struct MonoMethodVar * info;

    D.26334 = cfg->varinfo;
    index.78 = (unsigned int) index;
    D.26336 = index.78 * 4;
    D.26337 = D.26334 + D.26336;
    var = *D.26337;
    D.26338 = cfg->vars;
    index.78 = (unsigned int) index;
    D.26339 = index.78 * 56;
    info = D.26338 + D.26339;
    D.26342 = info->def;
    if (D.26342 != 0B) goto <D.26343>; else goto <D.26344>;
    <D.26343>:
    D.26342 = info->def;
    D.26345 = D.26342->opcode;
    D.26346 = D.26345 == 424;
    D.26347 = D.26345 == 426;
    D.26348 = D.26346 | D.26347;
    if (D.26348 != 0) goto <D.26340>; else goto <D.26349>;
    <D.26349>:
    D.26342 = info->def;
    D.26350 = D.26342->opcode;
    if (D.26350 == 427) goto <D.26340>; else goto <D.26341>;
    <D.26340>:
    {
      struct MonoInst * var2;

      D.26342 = info->def;
      D.26352 = D.26342->sreg1;
      D.26353 = (unsigned int) D.26352;
      D.26354 = cfg->vreg_to_inst_len;
      if (D.26353 < D.26354) goto <D.26355>; else goto <D.26356>;
      <D.26355>:
      D.26357 = cfg->vreg_to_inst;
      D.26342 = info->def;
      D.26352 = D.26342->sreg1;
      D.26358 = (unsigned int) D.26352;
      D.26359 = D.26358 * 4;
      D.26360 = D.26357 + D.26359;
      iftmp.79 = *D.26360;
      goto <D.26361>;
      <D.26356>:
      iftmp.79 = 0B;
      <D.26361>:
      var2 = iftmp.79;
      if (var2 != 0B) goto <D.26362>; else goto <D.26363>;
      <D.26362>:
      D.26364 = var2->flags;
      D.26365 = (int) D.26364;
      D.26366 = D.26365 & 20;
      if (D.26366 == 0) goto <D.26367>; else goto <D.26368>;
      <D.26367>:
      D.26338 = cfg->vars;
      D.26369 = var2->data.op[0].const_val;
      D.26370 = (unsigned int) D.26369;
      D.26371 = D.26370 * 56;
      D.26372 = D.26338 + D.26371;
      D.26373 = D.26372->def;
      if (D.26373 != 0B) goto <D.26374>; else goto <D.26375>;
      <D.26374>:
      D.26338 = cfg->vars;
      D.26369 = var2->data.op[0].const_val;
      D.26370 = (unsigned int) D.26369;
      D.26371 = D.26370 * 56;
      D.26372 = D.26338 + D.26371;
      D.26373 = D.26372->def;
      D.26376 = D.26373->opcode;
      D.26377 = D.26376 + 65217;
      if (D.26377 > 2) goto <D.26378>; else goto <D.26379>;
      <D.26378>:
      {
        int dreg;
        int sreg1;

        dreg = var->dreg;
        sreg1 = var2->dreg;
        l = info->uses;
        goto <D.24560>;
        <D.24559>:
        {
          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.26380 = ins->sreg1;
              sregs[0] = D.26380;
              D.26381 = ins->sreg2;
              sregs[1] = D.26381;
              D.26382 = ins->sreg3;
              sregs[2] = D.26382;
              D.26383 = ins->opcode;
              D.26384 = (int) D.26383;
              D.26385 = D.26384 + -313;
              D.26386 = ins_sreg_counts[D.26385];
              num_sregs = (int) D.26386;
              i = 0;
              goto <D.24554>;
              <D.24553>:
              D.26387 = sregs[i];
              if (D.26387 == dreg) goto <D.24552>; else goto <D.26388>;
              <D.26388>:
              i = i + 1;
              <D.24554>:
              if (i < num_sregs) goto <D.24553>; else goto <D.24552>;
              <D.24552>:
              if (i < num_sregs) goto <D.26389>; else goto <D.26390>;
              <D.26389>:
              D.26387 = sregs[i];
              D.26391 = D.26387 != dreg;
              D.26392 = (long int) D.26391;
              D.26393 = __builtin_expect (D.26392, 0);
              if (D.26393 != 0) goto <D.26394>; else goto <D.26395>;
              <D.26394>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 702, "sregs [i] == dreg");
              <D.26395>:
              sregs[i] = sreg1;
              mono_inst_set_src_registers (ins, &sregs);
              goto <D.26396>;
              <D.26390>:
              D.26383 = ins->opcode;
              D.26399 = D.26383 + 65162;
              if (D.26399 <= 13) goto <D.26400>; else goto <D.26397>;
              <D.26400>:
              D.26401 = ins->dreg;
              if (D.26401 == dreg) goto <D.26402>; else goto <D.26397>;
              <D.26402>:
              ins->dreg = sreg1;
              goto <D.26398>;
              <D.26397>:
              D.26383 = ins->opcode;
              D.26403 = D.26383 + 65217;
              if (D.26403 <= 2) goto <D.26404>; else goto <D.26405>;
              <D.26404>:
              D.26406 = ins->data.op[1].phi_args;
              i = *D.26406;
              goto <D.24558>;
              <D.24557>:
              {
                int sreg;

                D.26406 = ins->data.op[1].phi_args;
                i.80 = (unsigned int) i;
                D.26408 = i.80 * 4;
                D.26409 = D.26406 + D.26408;
                sreg = *D.26409;
                D.26410 = var->dreg;
                if (D.26410 == sreg) goto <D.24556>; else goto <D.26411>;
                <D.26411>:
              }
              i = i + -1;
              <D.24558>:
              if (i > 0) goto <D.24557>; else goto <D.24556>;
              <D.24556>:
              D.26412 = i <= 0;
              D.26413 = (long int) D.26412;
              D.26414 = __builtin_expect (D.26413, 0);
              if (D.26414 != 0) goto <D.26415>; else goto <D.26416>;
              <D.26415>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 713, "i > 0");
              <D.26416>:
              D.26406 = ins->data.op[1].phi_args;
              i.80 = (unsigned int) i;
              D.26408 = i.80 * 4;
              D.26409 = D.26406 + D.26408;
              *D.26409 = sreg1;
              goto <D.26417>;
              <D.26405>:
              monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "ssa.c", 717);
              <D.26417>:
              <D.26398>:
              <D.26396>:
              D.26418 = u->bb;
              record_use (cfg, var2, D.26418, ins);
              l = next;
            }
          finally
            {
              sregs = {CLOBBER};
            }
        }
        <D.24560>:
        if (l != 0B) goto <D.24559>; else goto <D.24561>;
        <D.24561>:
        info->uses = 0B;
      }
      <D.26379>:
      <D.26375>:
      <D.26368>:
      <D.26363>:
    }
    <D.26341>:
    <D.26344>:
  }
  index = index + 1;
  <D.24563>:
  index.81 = (unsigned int) index;
  D.26420 = cfg->num_varinfo;
  if (index.81 < D.26420) goto <D.24562>; else goto <D.24564>;
  <D.24564>:
  D.26421 = cfg->verbose_level;
  if (D.26421 > 3) goto <D.26422>; else goto <D.26423>;
  <D.26422>:
  {
    struct MonoBasicBlock * bb;

    bb = cfg->bb_entry;
    goto <D.24567>;
    <D.24566>:
    mono_print_bb (bb, "AFTER SSA COPYPROP");
    bb = bb->next_bb;
    <D.24567>:
    if (bb != 0B) goto <D.24566>; else goto <D.24568>;
    <D.24568>:
  }
  <D.26423>:
}


add_to_dce_worklist (struct MonoCompile * cfg, struct MonoMethodVar * var, struct MonoMethodVar * use, struct GList * * wl)
{
  struct MonoMemPool * D.26424;
  struct GList * D.26425;
  struct GList * D.26426;
  struct MonoInst * D.26427;
  struct MonoInst * D.26428;
  struct GList * D.26431;
  struct GList * D.26432;
  struct GList * tmp;

  D.26424 = cfg->mempool;
  D.26425 = *wl;
  D.26426 = g_list_prepend_mempool (D.26424, D.26425, use);
  *wl = D.26426;
  tmp = use->uses;
  goto <D.24717>;
  <D.24716>:
  {
    struct MonoVarUsageInfo * ui;

    ui = tmp->data;
    D.26427 = ui->inst;
    D.26428 = var->def;
    if (D.26427 == D.26428) goto <D.26429>; else goto <D.26430>;
    <D.26429>:
    D.26431 = use->uses;
    D.26432 = monoeg_g_list_remove_link (D.26431, tmp);
    use->uses = D.26432;
    goto <D.24715>;
    <D.26430>:
  }
  tmp = tmp->next;
  <D.24717>:
  if (tmp != 0B) goto <D.24716>; else goto <D.24715>;
  <D.24715>:
}


mono_ssa_loop_invariant_code_motion (struct MonoCompile * cfg)
{
  unsigned int D.26433;
  unsigned int D.26434;
  _Bool D.26435;
  long int D.26436;
  long int D.26437;
  unsigned int D.26440;
  unsigned int D.26441;
  struct MonoBasicBlock * D.26444;
  struct MonoInst * iftmp.82;
  short unsigned int D.26453;
  unsigned char D.26456;
  unsigned char D.26457;
  <unnamed type> D.26460;
  short unsigned int D.26465;
  _Bool D.26466;
  _Bool D.26467;
  _Bool D.26468;
  struct MonoInst * D.26475;
  short unsigned int D.26477;
  struct MonoBasicBlock * D.26479;
  signed char D.26481;
  short unsigned int D.26483;
  _Bool D.26484;
  _Bool D.26485;
  _Bool D.26486;
  short unsigned int D.26489;
  short unsigned int D.26551;
  _Bool D.26552;
  _Bool D.26553;
  _Bool D.26554;
  short unsigned int D.26558;
  int D.26559;
  int D.26560;
  int D.26561;
  int D.26564;
  char D.26567;
  unsigned int D.26574;
  int D.26577;
  struct MonoInst * D.26578;
  struct MonoInst * D.26581;
  struct MonoInst * D.26584;
  struct MonoInst * D.26587;
  short unsigned int D.26590;
  _Bool D.26591;
  _Bool D.26592;
  _Bool D.26593;
  struct MonoInst * iftmp.83;
  unsigned int D.26600;
  struct MonoMethodVar * D.26601;
  unsigned int i.84;
  unsigned int D.26603;
  unsigned int i.85;
  unsigned int D.26605;
  struct MonoBasicBlock * bb;
  struct MonoBasicBlock * h;
  struct MonoBasicBlock * idom;
  struct MonoInst * ins;
  struct MonoInst * n;
  struct MonoInst * tins;
  int i;

  D.26433 = cfg->comp_done;
  D.26434 = D.26433 & 32;
  D.26435 = D.26434 == 0;
  D.26436 = (long int) D.26435;
  D.26437 = __builtin_expect (D.26436, 0);
  if (D.26437 != 0) goto <D.26438>; else goto <D.26439>;
  <D.26438>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 1360, "cfg->comp_done & MONO_COMP_SSA");
  <D.26439>:
  D.26440 = BIT_FIELD_REF <*cfg, 32, 3200>;
  D.26441 = D.26440 & 320;
  if (D.26441 != 320) goto <D.26442>; else goto <D.26443>;
  <D.26442>:
  return;
  <D.26443>:
  D.26444 = cfg->bb_entry;
  bb = D.26444->next_bb;
  goto <D.24768>;
  <D.24767>:
  {
    struct GList * lp;

    lp = bb->loop_blocks;
    if (lp == 0B) goto <D.26445>; else goto <D.26446>;
    <D.26445>:
    // predicted unlikely by continue predictor.
    goto <D.24749>;
    <D.26446>:
    h = lp->data;
    if (bb != h) goto <D.26447>; else goto <D.26448>;
    <D.26447>:
    // predicted unlikely by continue predictor.
    goto <D.24749>;
    <D.26448>:
    ins = bb->code;
    if (ins != 0B) goto <D.26450>; else goto <D.26451>;
    <D.26450>:
    iftmp.82 = ins->next;
    goto <D.26452>;
    <D.26451>:
    iftmp.82 = 0B;
    <D.26452>:
    n = iftmp.82;
    goto <D.24765>;
    <D.24764>:
    {
      gboolean is_class_init;

      is_class_init = 0;
      D.26453 = ins->opcode;
      if (D.26453 == 343) goto <D.26454>; else goto <D.26455>;
      <D.26454>:
      {
        struct MonoCallInst * call;

        call = ins;
        D.26456 = BIT_FIELD_REF <*call, 8, 704>;
        D.26457 = D.26456 & 4;
        if (D.26457 != 0) goto <D.26458>; else goto <D.26459>;
        <D.26458>:
        {
          struct MonoJumpInfo * ji;

          ji = call->fptr;
          D.26460 = ji->type;
          if (D.26460 == 15) goto <D.26461>; else goto <D.26462>;
          <D.26461>:
          is_class_init = 1;
          <D.26462>:
        }
        <D.26459>:
      }
      <D.26455>:
      D.26465 = ins->opcode;
      D.26466 = D.26465 == 783;
      D.26467 = D.26465 == 781;
      D.26468 = D.26466 | D.26467;
      if (D.26468 != 0) goto <D.26463>; else goto <D.26469>;
      <D.26469>:
      D.26453 = ins->opcode;
      if (D.26453 == 340) goto <D.26463>; else goto <D.26470>;
      <D.26470>:
      D.26453 = ins->opcode;
      if (D.26453 == 732) goto <D.26463>; else goto <D.26471>;
      <D.26471>:
      if (is_class_init != 0) goto <D.26463>; else goto <D.26464>;
      <D.26463>:
      {
        gboolean skip;
        int sreg;

        idom = h->idom;
        if (idom == 0B) goto <D.26472>; else goto <D.26474>;
        <D.26474>:
        D.26475 = idom->last_ins;
        if (D.26475 == 0B) goto <D.26472>; else goto <D.26476>;
        <D.26476>:
        D.26475 = idom->last_ins;
        D.26477 = D.26475->opcode;
        if (D.26477 != 442) goto <D.26472>; else goto <D.26478>;
        <D.26478>:
        D.26475 = idom->last_ins;
        D.26479 = D.26475->data.op[0].target_block;
        if (D.26479 != h) goto <D.26472>; else goto <D.26480>;
        <D.26480>:
        D.26481 = h->nesting;
        if (D.26481 != 1) goto <D.26472>; else goto <D.26473>;
        <D.26472>:
        // predicted unlikely by continue predictor.
        goto <D.24755>;
        <D.26473>:
        skip = 0;
        tins = bb->code;
        goto <D.24758>;
        <D.24757>:
        if (tins == ins) goto <D.24756>; else goto <D.26482>;
        <D.26482>:
        D.26483 = tins->opcode;
        D.26484 = D.26483 != 424;
        D.26485 = D.26483 != 426;
        D.26486 = D.26484 & D.26485;
        if (D.26486 != 0) goto <D.26487>; else goto <D.26488>;
        <D.26487>:
        D.26489 = tins->opcode;
        if (D.26489 != 427) goto <D.26490>; else goto <D.26491>;
        <D.26490>:
        D.26489 = tins->opcode;
        if (D.26489 != 362) goto <D.26492>; else goto <D.26493>;
        <D.26492>:
        D.26489 = tins->opcode;
        if (D.26489 != 363) goto <D.26494>; else goto <D.26495>;
        <D.26494>:
        D.26489 = tins->opcode;
        if (D.26489 != 428) goto <D.26496>; else goto <D.26497>;
        <D.26496>:
        D.26489 = tins->opcode;
        if (D.26489 != 429) goto <D.26498>; else goto <D.26499>;
        <D.26498>:
        D.26489 = tins->opcode;
        if (D.26489 != 365) goto <D.26500>; else goto <D.26501>;
        <D.26500>:
        D.26489 = tins->opcode;
        if (D.26489 != 538) goto <D.26502>; else goto <D.26503>;
        <D.26502>:
        D.26489 = tins->opcode;
        if (D.26489 != 626) goto <D.26504>; else goto <D.26505>;
        <D.26504>:
        D.26489 = tins->opcode;
        if (D.26489 != 625) goto <D.26506>; else goto <D.26507>;
        <D.26506>:
        D.26489 = tins->opcode;
        if (D.26489 != 492) goto <D.26508>; else goto <D.26509>;
        <D.26508>:
        D.26489 = tins->opcode;
        if (D.26489 != 566) goto <D.26510>; else goto <D.26511>;
        <D.26510>:
        D.26489 = tins->opcode;
        if (D.26489 != 817) goto <D.26512>; else goto <D.26513>;
        <D.26512>:
        D.26489 = tins->opcode;
        if (D.26489 != 635) goto <D.26514>; else goto <D.26515>;
        <D.26514>:
        D.26489 = tins->opcode;
        if (D.26489 != 636) goto <D.26516>; else goto <D.26517>;
        <D.26516>:
        D.26489 = tins->opcode;
        if (D.26489 != 637) goto <D.26518>; else goto <D.26519>;
        <D.26518>:
        D.26489 = tins->opcode;
        if (D.26489 != 632) goto <D.26520>; else goto <D.26521>;
        <D.26520>:
        D.26489 = tins->opcode;
        if (D.26489 != 591) goto <D.26522>; else goto <D.26523>;
        <D.26522>:
        D.26489 = tins->opcode;
        if (D.26489 != 580) goto <D.26524>; else goto <D.26525>;
        <D.26524>:
        D.26489 = tins->opcode;
        if (D.26489 != 762) goto <D.26526>; else goto <D.26527>;
        <D.26526>:
        D.26489 = tins->opcode;
        if (D.26489 != 503) goto <D.26528>; else goto <D.26529>;
        <D.26528>:
        D.26489 = tins->opcode;
        if (D.26489 != 590) goto <D.26530>; else goto <D.26531>;
        <D.26530>:
        D.26489 = tins->opcode;
        if (D.26489 != 581) goto <D.26532>; else goto <D.26533>;
        <D.26532>:
        D.26489 = tins->opcode;
        if (D.26489 != 495) goto <D.26534>; else goto <D.26535>;
        <D.26534>:
        D.26489 = tins->opcode;
        if (D.26489 != 314) goto <D.26536>; else goto <D.26537>;
        <D.26536>:
        D.26489 = tins->opcode;
        if (D.26489 != 319) goto <D.26538>; else goto <D.26539>;
        <D.26538>:
        D.26489 = tins->opcode;
        if (D.26489 != 316) goto <D.26540>; else goto <D.26541>;
        <D.26540>:
        D.26489 = tins->opcode;
        if (D.26489 != 765) goto <D.26542>; else goto <D.26543>;
        <D.26542>:
        D.26489 = tins->opcode;
        if (D.26489 != 799) goto <D.26544>; else goto <D.26545>;
        <D.26544>:
        skip = 1;
        goto <D.24756>;
        <D.26545>:
        <D.26543>:
        <D.26541>:
        <D.26539>:
        <D.26537>:
        <D.26535>:
        <D.26533>:
        <D.26531>:
        <D.26529>:
        <D.26527>:
        <D.26525>:
        <D.26523>:
        <D.26521>:
        <D.26519>:
        <D.26517>:
        <D.26515>:
        <D.26513>:
        <D.26511>:
        <D.26509>:
        <D.26507>:
        <D.26505>:
        <D.26503>:
        <D.26501>:
        <D.26499>:
        <D.26497>:
        <D.26495>:
        <D.26493>:
        <D.26491>:
        <D.26488>:
        tins = tins->next;
        <D.24758>:
        if (tins != 0B) goto <D.24757>; else goto <D.24756>;
        <D.24756>:
        if (skip != 0) goto <D.26546>; else goto <D.26547>;
        <D.26546>:
        // predicted unlikely by continue predictor.
        goto <D.24755>;
        <D.26547>:
        D.26551 = ins->opcode;
        D.26552 = D.26551 == 783;
        D.26553 = D.26551 == 781;
        D.26554 = D.26552 | D.26553;
        if (D.26554 != 0) goto <D.26548>; else goto <D.26555>;
        <D.26555>:
        D.26453 = ins->opcode;
        if (D.26453 == 340) goto <D.26548>; else goto <D.26549>;
        <D.26548>:
        sreg = ins->sreg1;
        goto <D.26550>;
        <D.26549>:
        sreg = -1;
        <D.26550>:
        if (sreg != -1) goto <D.26556>; else goto <D.26557>;
        <D.26556>:
        {
          struct MonoInst * tins;

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

            D.26558 = tins->opcode;
            D.26559 = (int) D.26558;
            D.26560 = D.26559 + -313;
            D.26561 = D.26560 * 4;
            spec = &ins_info[D.26561];
            D.26558 = tins->opcode;
            if (D.26558 == 424) goto <D.26562>; else goto <D.26563>;
            <D.26562>:
            D.26564 = tins->dreg;
            if (D.26564 == sreg) goto <D.26565>; else goto <D.26566>;
            <D.26565>:
            sreg = tins->sreg1;
            <D.26566>:
            <D.26563>:
            D.26567 = *spec;
            if (D.26567 != 32) goto <D.26568>; else goto <D.26569>;
            <D.26568>:
            D.26564 = tins->dreg;
            if (D.26564 == sreg) goto <D.26570>; else goto <D.26571>;
            <D.26570>:
            skip = 1;
            goto <D.24761>;
            <D.26571>:
            <D.26569>:
          }
          tins = tins->prev;
          <D.24763>:
          if (tins != 0B) goto <D.24762>; else goto <D.24761>;
          <D.24761>:
          if (skip != 0) goto <D.26572>; else goto <D.26573>;
          <D.26572>:
          // predicted unlikely by continue predictor.
          goto <D.24755>;
          <D.26573>:
          ins->sreg1 = sreg;
        }
        <D.26557>:
        D.26574 = cfg->verbose_level;
        if (D.26574 > 1) goto <D.26575>; else goto <D.26576>;
        <D.26575>:
        D.26577 = bb->block_num;
        printf ("licm in BB%d on ", D.26577);
        mono_print_ins (ins);
        <D.26576>:
        D.26578 = ins->prev;
        if (D.26578 != 0B) goto <D.26579>; else goto <D.26580>;
        <D.26579>:
        D.26578 = ins->prev;
        D.26581 = ins->next;
        D.26578->next = D.26581;
        <D.26580>:
        D.26581 = ins->next;
        if (D.26581 != 0B) goto <D.26582>; else goto <D.26583>;
        <D.26582>:
        D.26581 = ins->next;
        D.26578 = ins->prev;
        D.26581->prev = D.26578;
        <D.26583>:
        D.26584 = bb->code;
        if (D.26584 == ins) goto <D.26585>; else goto <D.26586>;
        <D.26585>:
        D.26581 = ins->next;
        bb->code = D.26581;
        <D.26586>:
        D.26587 = bb->last_ins;
        if (D.26587 == ins) goto <D.26588>; else goto <D.26589>;
        <D.26588>:
        D.26578 = ins->prev;
        bb->last_ins = D.26578;
        <D.26589>:
        D.26475 = idom->last_ins;
        mono_bblock_insert_before_ins (idom, D.26475, ins);
        D.26590 = ins->opcode;
        D.26591 = D.26590 == 783;
        D.26592 = D.26590 == 781;
        D.26593 = D.26591 | D.26592;
        if (D.26593 != 0) goto <D.26594>; else goto <D.26595>;
        <D.26594>:
        idom->has_array_access = 1;
        <D.26595>:
      }
      <D.26464>:
    }
    <D.24755>:
    ins = n;
    if (ins != 0B) goto <D.26597>; else goto <D.26598>;
    <D.26597>:
    iftmp.83 = ins->next;
    goto <D.26599>;
    <D.26598>:
    iftmp.83 = 0B;
    <D.26599>:
    n = iftmp.83;
    <D.24765>:
    if (ins != 0B) goto <D.24764>; else goto <D.24766>;
    <D.24766>:
  }
  <D.24749>:
  bb = bb->next_bb;
  <D.24768>:
  if (bb != 0B) goto <D.24767>; else goto <D.24769>;
  <D.24769>:
  D.26433 = cfg->comp_done;
  D.26600 = D.26433 & 4294967231;
  cfg->comp_done = D.26600;
  i = 0;
  goto <D.24772>;
  <D.24771>:
  {
    struct MonoMethodVar * info;

    D.26601 = cfg->vars;
    i.84 = (unsigned int) i;
    D.26603 = i.84 * 56;
    info = D.26601 + D.26603;
    info->def = 0B;
    info->uses = 0B;
  }
  i = i + 1;
  <D.24772>:
  i.85 = (unsigned int) i;
  D.26605 = cfg->num_varinfo;
  if (i.85 < D.26605) goto <D.24771>; else goto <D.24773>;
  <D.24773>:
}