__attribute__((visibility ("hidden")))
mono_ssa_compute (struct MonoCompile * cfg)
{
  unsigned int D.22621;
  long unsigned int D.22622;
  long unsigned int D.22623;
  unsigned int D.22624;
  unsigned int D.22625;
  _Bool D.22626;
  long int D.22627;
  long int D.22628;
  long unsigned int D.22631;
  long unsigned int D.22632;
  _Bool D.22633;
  long int D.22634;
  long int D.22635;
  unsigned int D.22638;
  unsigned int D.22641;
  unsigned int D.22642;
  unsigned int D.22645;
  unsigned int D.22646;
  unsigned int D.22647;
  unsigned int D.22648;
  long unsigned int D.22649;
  long unsigned int D.22650;
  long unsigned int D.22651;
  struct MonoMethodVar * D.22652;
  struct MonoBitSet * D.22653;
  sizetype D.22654;
  unsigned int i.0;
  struct MonoInst * * D.22656;
  long unsigned int D.22657;
  struct MonoInst * * D.22658;
  struct MonoInst * D.22659;
  short unsigned int D.22660;
  struct MonoBitSet * D.22663;
  long unsigned int D.22664;
  long unsigned int D.22665;
  struct MonoBasicBlock * * D.22666;
  struct MonoBasicBlock * * D.22667;
  struct MonoBasicBlock * D.22668;
  short unsigned int D.22669;
  short unsigned int D.22672;
  int D.22675;
  unsigned int D.22676;
  unsigned int D.22677;
  struct MonoInst * * D.22680;
  long unsigned int D.22681;
  long unsigned int D.22682;
  struct MonoInst * * D.22683;
  struct MonoInst * D.22684;
  struct MonoInst * iftmp.1;
  long int D.22691;
  long unsigned int D.22692;
  long unsigned int D.22693;
  struct MonoMethodVar * D.22694;
  struct MonoBitSet * D.22695;
  long unsigned int D.22696;
  struct MonoInst * iftmp.2;
  long int D.22701;
  long unsigned int D.22702;
  long unsigned int D.22703;
  struct MonoMethodVar * D.22704;
  struct MonoBitSet * D.22705;
  long unsigned int D.22706;
  unsigned int i.3;
  unsigned int D.22708;
  long unsigned int D.22709;
  long unsigned int D.22710;
  unsigned char D.22711;
  int D.22712;
  int D.22713;
  unsigned int D.22716;
  unsigned int D.22721;
  int D.22724;
  long unsigned int D.22725;
  long unsigned int D.22726;
  struct MonoBasicBlock * * D.22727;
  struct MonoBasicBlock * D.22728;
  struct MonoBitSet * D.22733;
  long unsigned int D.22734;
  long unsigned int D.22735;
  long unsigned int D.22736;
  long unsigned int D.22737;
  struct MonoMemPool * D.22740;
  long int D.22741;
  int D.22742;
  int D.22743;
  unsigned char D.22744;
  int D.22745;
  struct MonoType * D.22747;
  long unsigned int D.22748;
  long unsigned int D.22749;
  struct MonoClass * D.22752;
  struct MonoClass * D.22754;
  struct MonoBasicBlock * D.22755;
  short int D.22756;
  int D.22757;
  int D.22758;
  long unsigned int D.22759;
  unsigned int D.22760;
  unsigned int D.22761;
  void * D.22762;
  int * D.22763;
  sizetype D.22764;
  sizetype D.22765;
  sizetype D.22766;
  int * D.22767;
  int D.22768;
  struct MonoInst * D.22769;
  unsigned int idx.4;
  long unsigned int D.22772;
  long unsigned int D.22773;
  long unsigned int D.22774;
  long unsigned int D.22775;
  long unsigned int D.22776;
  long unsigned int D.22777;
  int D.22778;
  struct MonoBasicBlock * D.22779;
  unsigned int D.22782;
  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.22621 = cfg->num_varinfo;
  D.22622 = (long unsigned int) D.22621;
  D.22623 = D.22622 * 80;
  vinfo = monoeg_malloc0 (D.22623);
  D.22624 = cfg->comp_done;
  D.22625 = D.22624 & 32;
  D.22626 = D.22625 != 0;
  D.22627 = (long int) D.22626;
  D.22628 = __builtin_expect (D.22627, 0);
  if (D.22628 != 0) goto <D.22629>; else goto <D.22630>;
  <D.22629>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 342, "!(cfg->comp_done & MONO_COMP_SSA)");
  <D.22630>:
  D.22631 = BIT_FIELD_REF <*cfg, 64, 5568>;
  D.22632 = D.22631 & 1073741824;
  D.22633 = D.22632 != 0;
  D.22634 = (long int) D.22633;
  D.22635 = __builtin_expect (D.22634, 0);
  if (D.22635 != 0) goto <D.22636>; else goto <D.22637>;
  <D.22636>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 344, "!cfg->disable_ssa");
  <D.22637>:
  D.22638 = cfg->verbose_level;
  if (D.22638 > 3) goto <D.22639>; else goto <D.22640>;
  <D.22639>:
  D.22621 = cfg->num_varinfo;
  D.22641 = cfg->next_vreg;
  printf ("\nCOMPUTE SSA %d (R%d-)\n\n", D.22621, D.22641);
  <D.22640>:
  D.22624 = cfg->comp_done;
  D.22642 = D.22624 & 16;
  if (D.22642 == 0) goto <D.22643>; else goto <D.22644>;
  <D.22643>:
  mono_analyze_liveness (cfg);
  <D.22644>:
  mono_compile_dominator_info (cfg, 7);
  D.22645 = cfg->num_bblocks;
  D.22646 = mono_bitset_alloc_size (D.22645, 0);
  bitsize = (int) D.22646;
  D.22645 = cfg->num_bblocks;
  D.22647 = mono_bitset_alloc_size (D.22645, 0);
  D.22621 = cfg->num_varinfo;
  D.22648 = D.22647 * D.22621;
  D.22649 = (long unsigned int) D.22648;
  buf_start = monoeg_malloc0 (D.22649);
  buf = buf_start;
  i = 0;
  goto <D.22276>;
  <D.22275>:
  D.22650 = (long unsigned int) i;
  D.22651 = D.22650 * 80;
  D.22652 = vinfo + D.22651;
  D.22645 = cfg->num_bblocks;
  D.22653 = mono_bitset_mem_new (buf, D.22645, 0);
  D.22652->def_in = D.22653;
  D.22654 = (sizetype) bitsize;
  buf = buf + D.22654;
  D.22650 = (long unsigned int) i;
  D.22651 = D.22650 * 80;
  D.22652 = vinfo + D.22651;
  i.0 = (unsigned int) i;
  D.22652->idx = i.0;
  D.22656 = cfg->varinfo;
  D.22650 = (long unsigned int) i;
  D.22657 = D.22650 * 8;
  D.22658 = D.22656 + D.22657;
  D.22659 = *D.22658;
  D.22660 = D.22659->opcode;
  if (D.22660 == 330) goto <D.22661>; else goto <D.22662>;
  <D.22661>:
  D.22650 = (long unsigned int) i;
  D.22651 = D.22650 * 80;
  D.22652 = vinfo + D.22651;
  D.22663 = D.22652->def_in;
  D.22650 = (long unsigned int) i;
  D.22651 = D.22650 * 80;
  D.22652 = vinfo + D.22651;
  D.22663 = D.22652->def_in;
  D.22664 = D.22663->data[0];
  D.22665 = D.22664 | 1;
  D.22663->data[0] = D.22665;
  <D.22662>:
  i = i + 1;
  <D.22276>:
  D.22621 = cfg->num_varinfo;
  i.0 = (unsigned int) i;
  if (D.22621 > i.0) goto <D.22275>; else goto <D.22277>;
  <D.22277>:
  i = 0;
  goto <D.22283>;
  <D.22282>:
  D.22666 = cfg->bblocks;
  D.22650 = (long unsigned int) i;
  D.22657 = D.22650 * 8;
  D.22667 = D.22666 + D.22657;
  D.22668 = *D.22667;
  ins = D.22668->code;
  goto <D.22280>;
  <D.22279>:
  D.22669 = ins->opcode;
  if (D.22669 == 316) goto <D.22670>; else goto <D.22671>;
  <D.22670>:
  // predicted unlikely by continue predictor.
  goto <D.22278>;
  <D.22671>:
  D.22669 = ins->opcode;
  D.22672 = D.22669 + 65162;
  if (D.22672 > 13) goto <D.22673>; else goto <D.22674>;
  <D.22673>:
  D.22675 = ins->dreg;
  D.22676 = (unsigned int) D.22675;
  D.22677 = cfg->vreg_to_inst_len;
  if (D.22676 < D.22677) goto <D.22678>; else goto <D.22679>;
  <D.22678>:
  D.22680 = cfg->vreg_to_inst;
  D.22675 = ins->dreg;
  D.22681 = (long unsigned int) D.22675;
  D.22682 = D.22681 * 8;
  D.22683 = D.22680 + D.22682;
  D.22684 = *D.22683;
  if (D.22684 != 0B) goto <D.22685>; else goto <D.22686>;
  <D.22685>:
  D.22675 = ins->dreg;
  D.22676 = (unsigned int) D.22675;
  D.22677 = cfg->vreg_to_inst_len;
  if (D.22676 < D.22677) goto <D.22688>; else goto <D.22689>;
  <D.22688>:
  D.22680 = cfg->vreg_to_inst;
  D.22675 = ins->dreg;
  D.22681 = (long unsigned int) D.22675;
  D.22682 = D.22681 * 8;
  D.22683 = D.22680 + D.22682;
  iftmp.1 = *D.22683;
  goto <D.22690>;
  <D.22689>:
  iftmp.1 = 0B;
  <D.22690>:
  D.22691 = iftmp.1->data.op[0].const_val;
  D.22692 = (long unsigned int) D.22691;
  D.22693 = D.22692 * 80;
  D.22694 = vinfo + D.22693;
  D.22695 = D.22694->def_in;
  D.22650 = (long unsigned int) i;
  D.22696 = D.22650 / 64;
  D.22675 = ins->dreg;
  D.22676 = (unsigned int) D.22675;
  D.22677 = cfg->vreg_to_inst_len;
  if (D.22676 < D.22677) goto <D.22698>; else goto <D.22699>;
  <D.22698>:
  D.22680 = cfg->vreg_to_inst;
  D.22675 = ins->dreg;
  D.22681 = (long unsigned int) D.22675;
  D.22682 = D.22681 * 8;
  D.22683 = D.22680 + D.22682;
  iftmp.2 = *D.22683;
  goto <D.22700>;
  <D.22699>:
  iftmp.2 = 0B;
  <D.22700>:
  D.22701 = iftmp.2->data.op[0].const_val;
  D.22702 = (long unsigned int) D.22701;
  D.22703 = D.22702 * 80;
  D.22704 = vinfo + D.22703;
  D.22705 = D.22704->def_in;
  D.22706 = D.22705->data[D.22696];
  i.3 = (unsigned int) i;
  D.22708 = i.3 & 63;
  D.22709 = 1 << D.22708;
  D.22710 = D.22706 | D.22709;
  D.22695->data[D.22696] = D.22710;
  <D.22686>:
  <D.22679>:
  <D.22674>:
  <D.22278>:
  ins = ins->next;
  <D.22280>:
  if (ins != 0B) goto <D.22279>; else goto <D.22281>;
  <D.22281>:
  i = i + 1;
  <D.22283>:
  D.22645 = cfg->num_bblocks;
  i.0 = (unsigned int) i;
  if (D.22645 > i.0) goto <D.22282>; else goto <D.22284>;
  <D.22284>:
  i = 0;
  goto <D.22304>;
  <D.22303>:
  {
    struct MonoInst * var;

    D.22656 = cfg->varinfo;
    D.22650 = (long unsigned int) i;
    D.22657 = D.22650 * 8;
    D.22658 = D.22656 + D.22657;
    var = *D.22658;
    D.22711 = var->flags;
    D.22712 = (int) D.22711;
    D.22713 = D.22712 & 20;
    if (D.22713 != 0) goto <D.22714>; else goto <D.22715>;
    <D.22714>:
    // predicted unlikely by continue predictor.
    goto <D.22286>;
    <D.22715>:
    D.22650 = (long unsigned int) i;
    D.22651 = D.22650 * 80;
    D.22652 = vinfo + D.22651;
    D.22663 = D.22652->def_in;
    D.22716 = mono_bitset_count (D.22663);
    if (D.22716 <= 1) goto <D.22717>; else goto <D.22718>;
    <D.22717>:
    // predicted unlikely by continue predictor.
    goto <D.22286>;
    <D.22718>:
    D.22650 = (long unsigned int) i;
    D.22651 = D.22650 * 80;
    D.22652 = vinfo + D.22651;
    D.22663 = D.22652->def_in;
    set = mono_compile_iterated_dfrontier (cfg, D.22663);
    D.22638 = cfg->verbose_level;
    if (D.22638 > 3) goto <D.22719>; else goto <D.22720>;
    <D.22719>:
    D.22721 = mono_bitset_count (set);
    if (D.22721 != 0) goto <D.22722>; else goto <D.22723>;
    <D.22722>:
    D.22724 = var->dreg;
    printf ("\tR%d needs PHI functions in ", D.22724);
    mono_blockset_print (cfg, set, "", 4294967295);
    <D.22723>:
    <D.22720>:
    idx = mono_bitset_find_start (set);
    goto <D.22301>;
    <D.22300>:
    {
      struct MonoBasicBlock * bb;

      D.22666 = cfg->bblocks;
      D.22725 = (long unsigned int) idx;
      D.22726 = D.22725 * 8;
      D.22727 = D.22666 + D.22726;
      bb = *D.22727;
      D.22728 = cfg->bb_exit;
      if (D.22728 == bb) goto <D.22729>; else goto <D.22730>;
      <D.22729>:
      // predicted unlikely by continue predictor.
      goto <D.22288>;
      <D.22730>:
      D.22624 = cfg->comp_done;
      D.22642 = D.22624 & 16;
      if (D.22642 != 0) goto <D.22731>; else goto <D.22732>;
      <D.22731>:
      D.22733 = bb->live_in_set;
      D.22650 = (long unsigned int) i;
      D.22734 = D.22650 / 64;
      D.22735 = D.22733->data[D.22734];
      i.3 = (unsigned int) i;
      D.22708 = i.3 & 63;
      D.22736 = D.22735 >> D.22708;
      D.22737 = D.22736 & 1;
      if (D.22737 == 0) goto <D.22738>; else goto <D.22739>;
      <D.22738>:
      // predicted unlikely by continue predictor.
      goto <D.22288>;
      <D.22739>:
      <D.22732>:
      D.22740 = cfg->mempool;
      ins = mono_mempool_alloc0 (D.22740, 80);
      ins->opcode = 319;
      D.22741 = (long int) i;
      ins->data.op[0].const_val = D.22741;
      ins->sreg2 = -1;
      D.22742 = ins->sreg2;
      ins->sreg1 = D.22742;
      D.22743 = ins->sreg1;
      ins->dreg = D.22743;
      D.22744 = var->type;
      D.22745 = (int) D.22744;
      switch (D.22745) <default: <D.22746>, case 1: <D.22289>, case 2: <D.22290>, case 3: <D.22291>, case 4: <D.22295>, case 5: <D.22292>, case 6: <D.22293>, case 7: <D.22296>>
      <D.22289>:
      <D.22290>:
      <D.22291>:
      <D.22292>:
      <D.22293>:
      ins->opcode = 319;
      goto <D.22294>;
      <D.22295>:
      ins->opcode = 320;
      goto <D.22294>;
      <D.22296>:
      ins->opcode = 321;
      goto <D.22294>;
      <D.22746>:
      <D.22294>:
      D.22747 = var->data.op[1].vtype;
      D.22748 = BIT_FIELD_REF <*D.22747, 64, 64>;
      D.22749 = D.22748 & 8589934592;
      if (D.22749 != 0) goto <D.22750>; else goto <D.22751>;
      <D.22750>:
      D.22752 = mono_defaults.int_class;
      ins->klass = D.22752;
      goto <D.22753>;
      <D.22751>:
      D.22754 = var->klass;
      ins->klass = D.22754;
      <D.22753>:
      D.22740 = cfg->mempool;
      D.22666 = cfg->bblocks;
      D.22725 = (long unsigned int) idx;
      D.22726 = D.22725 * 8;
      D.22727 = D.22666 + D.22726;
      D.22755 = *D.22727;
      D.22756 = D.22755->in_count;
      D.22757 = (int) D.22756;
      D.22758 = D.22757 + 1;
      D.22759 = (long unsigned int) D.22758;
      D.22760 = (unsigned int) D.22759;
      D.22761 = D.22760 * 4;
      D.22762 = mono_mempool_alloc0 (D.22740, D.22761);
      ins->data.op[1].phi_args = D.22762;
      D.22763 = ins->data.op[1].phi_args;
      D.22666 = cfg->bblocks;
      D.22725 = (long unsigned int) idx;
      D.22726 = D.22725 * 8;
      D.22727 = D.22666 + D.22726;
      D.22755 = *D.22727;
      D.22756 = D.22755->in_count;
      D.22757 = (int) D.22756;
      *D.22763 = D.22757;
      j = 0;
      goto <D.22298>;
      <D.22297>:
      D.22763 = ins->data.op[1].phi_args;
      D.22764 = (sizetype) j;
      D.22765 = D.22764 + 1;
      D.22766 = D.22765 * 4;
      D.22767 = D.22763 + D.22766;
      *D.22767 = -1;
      j = j + 1;
      <D.22298>:
      D.22666 = cfg->bblocks;
      D.22725 = (long unsigned int) idx;
      D.22726 = D.22725 * 8;
      D.22727 = D.22666 + D.22726;
      D.22755 = *D.22727;
      D.22756 = D.22755->in_count;
      D.22757 = (int) D.22756;
      if (D.22757 > j) goto <D.22297>; else goto <D.22299>;
      <D.22299>:
      D.22656 = cfg->varinfo;
      D.22650 = (long unsigned int) i;
      D.22657 = D.22650 * 8;
      D.22658 = D.22656 + D.22657;
      D.22659 = *D.22658;
      D.22768 = D.22659->dreg;
      ins->dreg = D.22768;
      D.22769 = bb->code;
      mono_bblock_insert_before_ins (bb, D.22769, ins);
    }
    <D.22288>:
    idx = mono_bitset_find_first (set, idx);
    <D.22301>:
    D.22645 = cfg->num_bblocks;
    idx.4 = (unsigned int) idx;
    if (D.22645 > idx.4) goto <D.22771>; else goto <D.22302>;
    <D.22771>:
    if (idx >= 0) goto <D.22300>; else goto <D.22302>;
    <D.22302>:
  }
  <D.22286>:
  i = i + 1;
  <D.22304>:
  D.22621 = cfg->num_varinfo;
  i.0 = (unsigned int) i;
  if (D.22621 > i.0) goto <D.22303>; else goto <D.22305>;
  <D.22305>:
  monoeg_g_free (vinfo);
  monoeg_g_free (buf_start);
  D.22621 = cfg->num_varinfo;
  D.22622 = (long unsigned int) D.22621;
  D.22772 = D.22622 * 8;
  stack = __builtin_alloca (D.22772);
  D.22621 = cfg->num_varinfo;
  D.22622 = (long unsigned int) D.22621;
  D.22772 = D.22622 * 8;
  memset (stack, 0, D.22772);
  D.22641 = cfg->next_vreg;
  D.22773 = (long unsigned int) D.22641;
  D.22774 = D.22773 * 4;
  lvreg_stack = monoeg_malloc0 (D.22774);
  D.22641 = cfg->next_vreg;
  D.22773 = (long unsigned int) D.22641;
  D.22774 = D.22773 * 4;
  lvreg_defined = monoeg_malloc0 (D.22774);
  stack_history_size = 10240;
  D.22775 = (long unsigned int) stack_history_size;
  D.22776 = D.22775 * 16;
  stack_history = monoeg_malloc (D.22776);
  D.22621 = cfg->num_varinfo;
  D.22622 = (long unsigned int) D.22621;
  D.22777 = D.22622 * 4;
  originals = monoeg_malloc0 (D.22777);
  D.22621 = cfg->num_varinfo;
  D.22778 = (int) D.22621;
  D.22779 = cfg->bb_entry;
  mono_ssa_rename_vars (cfg, D.22778, D.22779, 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.22638 = cfg->verbose_level;
  if (D.22638 > 3) goto <D.22780>; else goto <D.22781>;
  <D.22780>:
  printf ("\nEND COMPUTE SSA.\n\n");
  <D.22781>:
  D.22624 = cfg->comp_done;
  D.22782 = D.22624 | 32;
  cfg->comp_done = D.22782;
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
memset (void * __dest, int __ch, size_t __len)
{
  void * D.22783;
  long unsigned int D.22784;

  D.22784 = __builtin_object_size (__dest, 0);
  D.22783 = __builtin___memset_chk (__dest, __ch, __len, D.22784);
  return D.22783;
}


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.22786;
  int D.22789;
  short unsigned int D.22790;
  int D.22791;
  int D.22792;
  int D.22793;
  int D.22796;
  int D.22797;
  int D.22798;
  signed char D.22799;
  int D.22800;
  sizetype D.22801;
  const char * D.22802;
  char D.22803;
  struct MonoInst * iftmp.5;
  int D.22807;
  unsigned int D.22808;
  unsigned int D.22809;
  struct MonoInst * * D.22812;
  long unsigned int D.22813;
  long unsigned int D.22814;
  struct MonoInst * * D.22815;
  unsigned char D.22820;
  int D.22821;
  int D.22822;
  long int D.22824;
  long unsigned int D.22825;
  long unsigned int D.22826;
  struct MonoInst * * D.22827;
  struct MonoInst * D.22828;
  short unsigned int D.22831;
  _Bool D.22834;
  long int D.22835;
  long int D.22836;
  int D.22839;
  int iftmp.6;
  long unsigned int D.22845;
  guint32 * D.22846;
  unsigned int D.22847;
  _Bool D.22849;
  long int D.22850;
  long int D.22851;
  int D.22854;
  short unsigned int D.22855;
  struct MonoInst * iftmp.7;
  int D.22859;
  unsigned int D.22860;
  long unsigned int D.22863;
  long unsigned int D.22864;
  struct MonoInst * * D.22865;
  unsigned char D.22870;
  int D.22871;
  int D.22872;
  long int D.22874;
  long unsigned int D.22875;
  long unsigned int D.22876;
  struct MonoInst * * D.22877;
  struct MonoInst * D.22878;
  short unsigned int D.22881;
  _Bool D.22884;
  long int D.22885;
  long int D.22886;
  int D.22889;
  int iftmp.8;
  long unsigned int D.22895;
  guint32 * D.22896;
  unsigned int D.22897;
  _Bool D.22899;
  long int D.22900;
  long int D.22901;
  int D.22904;
  char D.22905;
  struct MonoInst * iftmp.9;
  unsigned char D.22917;
  int D.22918;
  int D.22919;
  long int D.22921;
  _Bool D.22922;
  long int D.22923;
  long int D.22924;
  short unsigned int D.22927;
  long unsigned int D.22930;
  long unsigned int D.22931;
  gboolean * D.22932;
  _Bool D.22933;
  long int D.22934;
  long int D.22935;
  long unsigned int D.22938;
  long unsigned int D.22939;
  struct RenameInfo * D.22940;
  long unsigned int D.22941;
  struct MonoInst * * D.22942;
  struct MonoInst * D.22943;
  int D.22944;
  struct MonoType * D.22947;
  struct MonoMethodVar * D.22948;
  long int D.22949;
  long unsigned int D.22950;
  long unsigned int D.22951;
  struct MonoMethodVar * D.22952;
  int D.22955;
  int D.22956;
  long unsigned int D.22958;
  long unsigned int D.22959;
  int iftmp.10;
  gboolean * D.22964;
  int D.22965;
  _Bool D.22968;
  long int D.22969;
  long int D.22970;
  guint32 iftmp.11;
  unsigned int D.22976;
  gboolean * D.22978;
  gboolean * D.22979;
  int D.22980;
  struct MonoBasicBlock * * D.22983;
  long unsigned int D.22984;
  long unsigned int D.22985;
  struct MonoBasicBlock * * D.22986;
  struct MonoBasicBlock * * D.22987;
  long unsigned int D.22988;
  long unsigned int D.22989;
  struct MonoBasicBlock * * D.22990;
  struct MonoBasicBlock * D.22991;
  short int D.22993;
  int D.22994;
  short unsigned int D.22995;
  long int D.22997;
  struct MonoInst * * D.23001;
  struct MonoInst * * D.23002;
  int * D.23003;
  sizetype D.23004;
  sizetype D.23005;
  sizetype D.23006;
  int * D.23007;
  _Bool D.23008;
  long int D.23009;
  long int D.23010;
  int D.23013;
  short int D.23014;
  int D.23015;
  struct GSList * D.23016;
  void * D.23019;
  int D.23020;
  long unsigned int D.23021;
  struct RenameInfo * D.23022;
  int D.23023;
  long unsigned int D.23024;
  long unsigned int D.23025;
  struct MonoInst * * D.23026;
  struct MonoInst * D.23027;
  unsigned int D.23028;
  unsigned int D.23029;
  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.22786 = cfg->verbose_level;
  if (D.22786 > 3) goto <D.22787>; else goto <D.22788>;
  <D.22787>:
  D.22789 = bb->block_num;
  printf ("\nRENAME VARS BLOCK %d:\n", D.22789);
  <D.22788>:
  ins = bb->code;
  goto <D.22239>;
  <D.22238>:
  {
    const char * spec;
    int num_sregs;
    int sregs[3];

    try
      {
        D.22790 = ins->opcode;
        D.22791 = (int) D.22790;
        D.22792 = D.22791 + -313;
        D.22793 = D.22792 * 4;
        spec = &ins_info[D.22793];
        D.22790 = ins->opcode;
        if (D.22790 == 316) goto <D.22794>; else goto <D.22795>;
        <D.22794>:
        // predicted unlikely by continue predictor.
        goto <D.22228>;
        <D.22795>:
        D.22796 = ins->sreg1;
        sregs[0] = D.22796;
        D.22797 = ins->sreg2;
        sregs[1] = D.22797;
        D.22798 = ins->sreg3;
        sregs[2] = D.22798;
        D.22790 = ins->opcode;
        D.22791 = (int) D.22790;
        D.22792 = D.22791 + -313;
        D.22799 = ins_sreg_counts[D.22792];
        num_sregs = (int) D.22799;
        i = 0;
        goto <D.22232>;
        <D.22231>:
        D.22800 = i + 1;
        D.22801 = (sizetype) D.22800;
        D.22802 = spec + D.22801;
        D.22803 = *D.22802;
        if (D.22803 != 32) goto <D.22804>; else goto <D.22805>;
        <D.22804>:
        {
          struct MonoInst * var;

          D.22807 = sregs[i];
          D.22808 = (unsigned int) D.22807;
          D.22809 = cfg->vreg_to_inst_len;
          if (D.22808 < D.22809) goto <D.22810>; else goto <D.22811>;
          <D.22810>:
          D.22812 = cfg->vreg_to_inst;
          D.22807 = sregs[i];
          D.22813 = (long unsigned int) D.22807;
          D.22814 = D.22813 * 8;
          D.22815 = D.22812 + D.22814;
          iftmp.5 = *D.22815;
          goto <D.22816>;
          <D.22811>:
          iftmp.5 = 0B;
          <D.22816>:
          var = iftmp.5;
          if (var != 0B) goto <D.22819>; else goto <D.22817>;
          <D.22819>:
          D.22820 = var->flags;
          D.22821 = (int) D.22820;
          D.22822 = D.22821 & 20;
          if (D.22822 == 0) goto <D.22823>; else goto <D.22817>;
          <D.22823>:
          {
            int idx;

            D.22824 = var->data.op[0].const_val;
            idx = (int) D.22824;
            D.22825 = (long unsigned int) idx;
            D.22826 = D.22825 * 8;
            D.22827 = stack + D.22826;
            D.22828 = *D.22827;
            if (D.22828 != 0B) goto <D.22829>; else goto <D.22830>;
            <D.22829>:
            D.22831 = var->opcode;
            if (D.22831 != 330) goto <D.22832>; else goto <D.22833>;
            <D.22832>:
            D.22825 = (long unsigned int) idx;
            D.22826 = D.22825 * 8;
            D.22827 = stack + D.22826;
            D.22828 = *D.22827;
            D.22834 = D.22828 == 0B;
            D.22835 = (long int) D.22834;
            D.22836 = __builtin_expect (D.22835, 0);
            if (D.22836 != 0) goto <D.22837>; else goto <D.22838>;
            <D.22837>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 200, "stack [idx]");
            <D.22838>:
            <D.22833>:
            D.22825 = (long unsigned int) idx;
            D.22826 = D.22825 * 8;
            D.22827 = stack + D.22826;
            D.22828 = *D.22827;
            D.22839 = D.22828->dreg;
            sregs[i] = D.22839;
            D.22825 = (long unsigned int) idx;
            D.22826 = D.22825 * 8;
            D.22827 = stack + D.22826;
            D.22828 = *D.22827;
            record_use (cfg, D.22828, bb, ins);
            goto <D.22840>;
            <D.22830>:
            record_use (cfg, var, bb, ins);
            <D.22840>:
          }
          goto <D.22818>;
          <D.22817>:
          if (var == 0B) goto <D.22844>; else goto <D.22842>;
          <D.22844>:
          D.22807 = sregs[i];
          D.22813 = (long unsigned int) D.22807;
          D.22845 = D.22813 * 4;
          D.22846 = lvreg_stack + D.22845;
          D.22847 = *D.22846;
          if (D.22847 != 0) goto <D.22848>; else goto <D.22842>;
          <D.22848>:
          iftmp.6 = 1;
          goto <D.22843>;
          <D.22842>:
          iftmp.6 = 0;
          <D.22843>:
          D.22849 = iftmp.6 != 0;
          D.22850 = (long int) D.22849;
          D.22851 = __builtin_expect (D.22850, 0);
          if (D.22851 != 0) goto <D.22852>; else goto <D.22853>;
          <D.22852>:
          D.22807 = sregs[i];
          D.22813 = (long unsigned int) D.22807;
          D.22845 = D.22813 * 4;
          D.22846 = lvreg_stack + D.22845;
          D.22847 = *D.22846;
          D.22854 = (int) D.22847;
          sregs[i] = D.22854;
          <D.22853>:
          <D.22818>:
        }
        <D.22805>:
        i = i + 1;
        <D.22232>:
        if (i < num_sregs) goto <D.22231>; else goto <D.22233>;
        <D.22233>:
        mono_inst_set_src_registers (ins, &sregs);
        D.22790 = ins->opcode;
        D.22855 = D.22790 + 65162;
        if (D.22855 <= 13) goto <D.22856>; else goto <D.22857>;
        <D.22856>:
        {
          struct MonoInst * var;

          D.22859 = ins->dreg;
          D.22860 = (unsigned int) D.22859;
          D.22809 = cfg->vreg_to_inst_len;
          if (D.22860 < D.22809) goto <D.22861>; else goto <D.22862>;
          <D.22861>:
          D.22812 = cfg->vreg_to_inst;
          D.22859 = ins->dreg;
          D.22863 = (long unsigned int) D.22859;
          D.22864 = D.22863 * 8;
          D.22865 = D.22812 + D.22864;
          iftmp.7 = *D.22865;
          goto <D.22866>;
          <D.22862>:
          iftmp.7 = 0B;
          <D.22866>:
          var = iftmp.7;
          if (var != 0B) goto <D.22869>; else goto <D.22867>;
          <D.22869>:
          D.22870 = var->flags;
          D.22871 = (int) D.22870;
          D.22872 = D.22871 & 20;
          if (D.22872 == 0) goto <D.22873>; else goto <D.22867>;
          <D.22873>:
          {
            int idx;

            D.22874 = var->data.op[0].const_val;
            idx = (int) D.22874;
            D.22875 = (long unsigned int) idx;
            D.22876 = D.22875 * 8;
            D.22877 = stack + D.22876;
            D.22878 = *D.22877;
            if (D.22878 != 0B) goto <D.22879>; else goto <D.22880>;
            <D.22879>:
            D.22881 = var->opcode;
            if (D.22881 != 330) goto <D.22882>; else goto <D.22883>;
            <D.22882>:
            D.22875 = (long unsigned int) idx;
            D.22876 = D.22875 * 8;
            D.22877 = stack + D.22876;
            D.22878 = *D.22877;
            D.22884 = D.22878 == 0B;
            D.22885 = (long int) D.22884;
            D.22886 = __builtin_expect (D.22885, 0);
            if (D.22886 != 0) goto <D.22887>; else goto <D.22888>;
            <D.22887>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 219, "stack [idx]");
            <D.22888>:
            <D.22883>:
            D.22875 = (long unsigned int) idx;
            D.22876 = D.22875 * 8;
            D.22877 = stack + D.22876;
            D.22878 = *D.22877;
            D.22889 = D.22878->dreg;
            ins->dreg = D.22889;
            D.22875 = (long unsigned int) idx;
            D.22876 = D.22875 * 8;
            D.22877 = stack + D.22876;
            D.22878 = *D.22877;
            record_use (cfg, D.22878, bb, ins);
            goto <D.22890>;
            <D.22880>:
            record_use (cfg, var, bb, ins);
            <D.22890>:
          }
          goto <D.22868>;
          <D.22867>:
          if (var == 0B) goto <D.22894>; else goto <D.22892>;
          <D.22894>:
          D.22859 = ins->dreg;
          D.22863 = (long unsigned int) D.22859;
          D.22895 = D.22863 * 4;
          D.22896 = lvreg_stack + D.22895;
          D.22897 = *D.22896;
          if (D.22897 != 0) goto <D.22898>; else goto <D.22892>;
          <D.22898>:
          iftmp.8 = 1;
          goto <D.22893>;
          <D.22892>:
          iftmp.8 = 0;
          <D.22893>:
          D.22899 = iftmp.8 != 0;
          D.22900 = (long int) D.22899;
          D.22901 = __builtin_expect (D.22900, 0);
          if (D.22901 != 0) goto <D.22902>; else goto <D.22903>;
          <D.22902>:
          D.22859 = ins->dreg;
          D.22863 = (long unsigned int) D.22859;
          D.22895 = D.22863 * 4;
          D.22896 = lvreg_stack + D.22895;
          D.22897 = *D.22896;
          D.22904 = (int) D.22897;
          ins->dreg = D.22904;
          <D.22903>:
          <D.22868>:
        }
        <D.22857>:
        D.22905 = *spec;
        if (D.22905 != 32) goto <D.22906>; else goto <D.22907>;
        <D.22906>:
        D.22790 = ins->opcode;
        D.22855 = D.22790 + 65162;
        if (D.22855 > 13) goto <D.22908>; else goto <D.22909>;
        <D.22908>:
        {
          struct MonoInst * var;
          struct MonoMethodVar * info;

          D.22859 = ins->dreg;
          D.22860 = (unsigned int) D.22859;
          D.22809 = cfg->vreg_to_inst_len;
          if (D.22860 < D.22809) goto <D.22911>; else goto <D.22912>;
          <D.22911>:
          D.22812 = cfg->vreg_to_inst;
          D.22859 = ins->dreg;
          D.22863 = (long unsigned int) D.22859;
          D.22864 = D.22863 * 8;
          D.22865 = D.22812 + D.22864;
          iftmp.9 = *D.22865;
          goto <D.22913>;
          <D.22912>:
          iftmp.9 = 0B;
          <D.22913>:
          var = iftmp.9;
          if (var != 0B) goto <D.22916>; else goto <D.22914>;
          <D.22916>:
          D.22917 = var->flags;
          D.22918 = (int) D.22917;
          D.22919 = D.22918 & 20;
          if (D.22919 == 0) goto <D.22920>; else goto <D.22914>;
          <D.22920>:
          D.22921 = var->data.op[0].const_val;
          idx = (int) D.22921;
          D.22922 = idx >= max_vars;
          D.22923 = (long int) D.22922;
          D.22924 = __builtin_expect (D.22923, 0);
          if (D.22924 != 0) goto <D.22925>; else goto <D.22926>;
          <D.22925>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 237, "idx < max_vars");
          <D.22926>:
          D.22927 = var->opcode;
          if (D.22927 == 330) goto <D.22928>; else goto <D.22929>;
          <D.22928>:
          D.22930 = (long unsigned int) idx;
          D.22931 = D.22930 * 4;
          D.22932 = originals_used + D.22931;
          *D.22932 = 1;
          <D.22929>:
          D.22933 = stack_history_len >= stack_history_size;
          D.22934 = (long int) D.22933;
          D.22935 = __builtin_expect (D.22934, 0);
          if (D.22935 != 0) goto <D.22936>; else goto <D.22937>;
          <D.22936>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 243, "stack_history_len < stack_history_size");
          <D.22937>:
          D.22938 = (long unsigned int) stack_history_len;
          D.22939 = D.22938 * 16;
          D.22940 = stack_history + D.22939;
          D.22930 = (long unsigned int) idx;
          D.22941 = D.22930 * 8;
          D.22942 = stack + D.22941;
          D.22943 = *D.22942;
          D.22940->var = D.22943;
          D.22938 = (long unsigned int) stack_history_len;
          D.22939 = D.22938 * 16;
          D.22940 = stack_history + D.22939;
          D.22940->idx = idx;
          stack_history_len = stack_history_len + 1;
          D.22930 = (long unsigned int) idx;
          D.22931 = D.22930 * 4;
          D.22932 = originals_used + D.22931;
          D.22944 = *D.22932;
          if (D.22944 != 0) goto <D.22945>; else goto <D.22946>;
          <D.22945>:
          D.22947 = var->data.op[1].vtype;
          new_var = mono_compile_create_var (cfg, D.22947, 329);
          D.22917 = var->flags;
          new_var->flags = D.22917;
          D.22948 = cfg->vars;
          D.22949 = new_var->data.op[0].const_val;
          D.22950 = (long unsigned int) D.22949;
          D.22951 = D.22950 * 80;
          D.22952 = D.22948 + D.22951;
          D.22952->reg = idx;
          D.22786 = cfg->verbose_level;
          if (D.22786 > 3) goto <D.22953>; else goto <D.22954>;
          <D.22953>:
          D.22955 = var->dreg;
          D.22956 = new_var->dreg;
          printf ("  R%d -> R%d\n", D.22955, D.22956);
          <D.22954>:
          D.22930 = (long unsigned int) idx;
          D.22941 = D.22930 * 8;
          D.22942 = stack + D.22941;
          *D.22942 = new_var;
          D.22956 = new_var->dreg;
          ins->dreg = D.22956;
          var = new_var;
          goto <D.22957>;
          <D.22946>:
          D.22930 = (long unsigned int) idx;
          D.22941 = D.22930 * 8;
          D.22942 = stack + D.22941;
          *D.22942 = var;
          D.22930 = (long unsigned int) idx;
          D.22931 = D.22930 * 4;
          D.22932 = originals_used + D.22931;
          *D.22932 = 1;
          <D.22957>:
          D.22948 = cfg->vars;
          D.22921 = var->data.op[0].const_val;
          D.22958 = (long unsigned int) D.22921;
          D.22959 = D.22958 * 80;
          info = D.22948 + D.22959;
          info->def = ins;
          info->def_bb = bb;
          goto <D.22915>;
          <D.22914>:
          if (var == 0B) goto <D.22963>; else goto <D.22961>;
          <D.22963>:
          D.22859 = ins->dreg;
          D.22863 = (long unsigned int) D.22859;
          D.22895 = D.22863 * 4;
          D.22964 = lvreg_defined + D.22895;
          D.22965 = *D.22964;
          if (D.22965 != 0) goto <D.22966>; else goto <D.22961>;
          <D.22966>:
          D.22859 = ins->dreg;
          if (D.22859 > 15) goto <D.22967>; else goto <D.22961>;
          <D.22967>:
          iftmp.10 = 1;
          goto <D.22962>;
          <D.22961>:
          iftmp.10 = 0;
          <D.22962>:
          D.22968 = iftmp.10 != 0;
          D.22969 = (long int) D.22968;
          D.22970 = __builtin_expect (D.22969, 0);
          if (D.22970 != 0) goto <D.22971>; else goto <D.22972>;
          <D.22971>:
          D.22859 = ins->dreg;
          D.22863 = (long unsigned int) D.22859;
          D.22895 = D.22863 * 4;
          D.22896 = lvreg_stack + D.22895;
          D.22859 = ins->dreg;
          D.22860 = (unsigned int) D.22859;
          D.22976 = cfg->vreg_is_ref_len;
          if (D.22860 < D.22976) goto <D.22977>; else goto <D.22974>;
          <D.22977>:
          D.22978 = cfg->vreg_is_ref;
          D.22859 = ins->dreg;
          D.22863 = (long unsigned int) D.22859;
          D.22895 = D.22863 * 4;
          D.22979 = D.22978 + D.22895;
          D.22980 = *D.22979;
          if (D.22980 != 0) goto <D.22981>; else goto <D.22974>;
          <D.22981>:
          iftmp.11 = mono_alloc_ireg_ref (cfg);
          goto <D.22975>;
          <D.22974>:
          iftmp.11 = mono_alloc_preg (cfg);
          <D.22975>:
          *D.22896 = iftmp.11;
          D.22859 = ins->dreg;
          D.22863 = (long unsigned int) D.22859;
          D.22895 = D.22863 * 4;
          D.22896 = lvreg_stack + D.22895;
          D.22897 = *D.22896;
          D.22904 = (int) D.22897;
          ins->dreg = D.22904;
          goto <D.22982>;
          <D.22972>:
          D.22859 = ins->dreg;
          D.22863 = (long unsigned int) D.22859;
          D.22895 = D.22863 * 4;
          D.22964 = lvreg_defined + D.22895;
          *D.22964 = 1;
          <D.22982>:
          <D.22915>:
        }
        <D.22909>:
        <D.22907>:
      }
    finally
      {
        sregs = {CLOBBER};
      }
  }
  <D.22228>:
  ins = ins->next;
  <D.22239>:
  if (ins != 0B) goto <D.22238>; else goto <D.22240>;
  <D.22240>:
  i = 0;
  goto <D.22249>;
  <D.22248>:
  {
    struct MonoBasicBlock * n;

    D.22983 = bb->out_bb;
    D.22984 = (long unsigned int) i;
    D.22985 = D.22984 * 8;
    D.22986 = D.22983 + D.22985;
    n = *D.22986;
    j = 0;
    goto <D.22244>;
    <D.22243>:
    D.22987 = n->in_bb;
    D.22988 = (long unsigned int) j;
    D.22989 = D.22988 * 8;
    D.22990 = D.22987 + D.22989;
    D.22991 = *D.22990;
    if (D.22991 == bb) goto <D.22242>; else goto <D.22992>;
    <D.22992>:
    j = j + 1;
    <D.22244>:
    D.22993 = n->in_count;
    D.22994 = (int) D.22993;
    if (D.22994 > j) goto <D.22243>; else goto <D.22242>;
    <D.22242>:
    ins = n->code;
    goto <D.22247>;
    <D.22246>:
    D.22790 = ins->opcode;
    D.22995 = D.22790 + 65217;
    if (D.22995 <= 2) goto <D.22996>; else goto <D.22245>;
    <D.22996>:
    D.22997 = ins->data.op[0].const_val;
    idx = (int) D.22997;
    D.22930 = (long unsigned int) idx;
    D.22941 = D.22930 * 8;
    D.22942 = stack + D.22941;
    D.22943 = *D.22942;
    if (D.22943 != 0B) goto <D.22998>; else goto <D.22999>;
    <D.22998>:
    D.22930 = (long unsigned int) idx;
    D.22941 = D.22930 * 8;
    D.22942 = stack + D.22941;
    new_var = *D.22942;
    goto <D.23000>;
    <D.22999>:
    D.23001 = cfg->varinfo;
    D.22930 = (long unsigned int) idx;
    D.22941 = D.22930 * 8;
    D.23002 = D.23001 + D.22941;
    new_var = *D.23002;
    <D.23000>:
    D.23003 = ins->data.op[1].phi_args;
    D.23004 = (sizetype) j;
    D.23005 = D.23004 + 1;
    D.23006 = D.23005 * 4;
    D.23007 = D.23003 + D.23006;
    D.22956 = new_var->dreg;
    *D.23007 = D.22956;
    record_use (cfg, new_var, n, ins);
    D.22786 = cfg->verbose_level;
    D.23008 = D.22786 > 3;
    D.23009 = (long int) D.23008;
    D.23010 = __builtin_expect (D.23009, 0);
    if (D.23010 != 0) goto <D.23011>; else goto <D.23012>;
    <D.23011>:
    D.22859 = ins->dreg;
    D.22956 = new_var->dreg;
    D.23013 = n->block_num;
    printf ("\tAdd PHI R%d <- R%d to BB%d\n", D.22859, D.22956, D.23013);
    <D.23012>:
    ins = ins->next;
    <D.22247>:
    if (ins != 0B) goto <D.22246>; else goto <D.22245>;
    <D.22245>:
  }
  i = i + 1;
  <D.22249>:
  D.23014 = bb->out_count;
  D.23015 = (int) D.23014;
  if (D.23015 > i) goto <D.22248>; else goto <D.22250>;
  <D.22250>:
  D.23016 = bb->dominated;
  if (D.23016 != 0B) goto <D.23017>; else goto <D.23018>;
  <D.23017>:
  tmp = bb->dominated;
  goto <D.22252>;
  <D.22251>:
  D.23019 = tmp->data;
  D.22938 = (long unsigned int) stack_history_len;
  D.22939 = D.22938 * 16;
  D.22940 = stack_history + D.22939;
  D.23020 = stack_history_size - stack_history_len;
  mono_ssa_rename_vars (cfg, max_vars, D.23019, originals_used, stack, lvreg_stack, lvreg_defined, D.22940, D.23020);
  tmp = tmp->next;
  <D.22252>:
  if (tmp != 0B) goto <D.22251>; else goto <D.22253>;
  <D.22253>:
  <D.23018>:
  i = stack_history_len + -1;
  goto <D.22255>;
  <D.22254>:
  D.22984 = (long unsigned int) i;
  D.23021 = D.22984 * 16;
  D.23022 = stack_history + D.23021;
  D.23023 = D.23022->idx;
  D.23024 = (long unsigned int) D.23023;
  D.23025 = D.23024 * 8;
  D.23026 = stack + D.23025;
  D.22984 = (long unsigned int) i;
  D.23021 = D.22984 * 16;
  D.23022 = stack_history + D.23021;
  D.23027 = D.23022->var;
  *D.23026 = D.23027;
  i = i + -1;
  <D.22255>:
  if (i >= 0) goto <D.22254>; else goto <D.22256>;
  <D.22256>:
  D.23028 = cfg->comp_done;
  D.23029 = D.23028 | 64;
  cfg->comp_done = D.23029;
}


record_use (struct MonoCompile * cfg, struct MonoInst * var, struct MonoBasicBlock * bb, struct MonoInst * ins)
{
  struct MonoMemPool * D.23032;
  struct MonoMethodVar * D.23033;
  long int D.23034;
  long unsigned int D.23035;
  long unsigned int D.23036;
  struct GList * D.23037;
  struct GList * D.23038;
  struct MonoMethodVar * info;
  struct MonoVarUsageInfo * ui;

  D.23032 = cfg->mempool;
  ui = mono_mempool_alloc (D.23032, 16);
  D.23033 = cfg->vars;
  D.23034 = var->data.op[0].const_val;
  D.23035 = (long unsigned int) D.23034;
  D.23036 = D.23035 * 80;
  info = D.23033 + D.23036;
  ui->bb = bb;
  ui->inst = ins;
  D.23032 = cfg->mempool;
  D.23037 = info->uses;
  D.23038 = g_list_prepend_mempool (D.23032, D.23037, ui);
  info->uses = D.23038;
}


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

  new_list = mono_mempool_alloc (mp, 24);
  new_list->data = data;
  if (list != 0B) goto <D.23040>; else goto <D.23041>;
  <D.23040>:
  iftmp.12 = list->prev;
  goto <D.23042>;
  <D.23041>:
  iftmp.12 = 0B;
  <D.23042>:
  new_list->prev = iftmp.12;
  new_list->next = list;
  D.23043 = new_list->prev;
  if (D.23043 != 0B) goto <D.23044>; else goto <D.23045>;
  <D.23044>:
  D.23043 = new_list->prev;
  D.23043->next = new_list;
  <D.23045>:
  if (list != 0B) goto <D.23046>; else goto <D.23047>;
  <D.23046>:
  list->prev = new_list;
  <D.23047>:
  D.23048 = new_list;
  return D.23048;
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__))
printf (const char * restrict __fmt)
{
  int D.23050;

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


__attribute__((visibility ("hidden")))
mono_ssa_remove (struct MonoCompile * cfg)
{
  unsigned int D.23052;
  unsigned int D.23053;
  _Bool D.23054;
  long int D.23055;
  long int D.23056;
  struct MonoBasicBlock * * D.23059;
  long unsigned int D.23060;
  long unsigned int D.23061;
  struct MonoBasicBlock * * D.23062;
  unsigned int D.23063;
  int D.23066;
  short unsigned int D.23067;
  short unsigned int D.23068;
  int * D.23071;
  int D.23072;
  short int D.23073;
  int D.23074;
  _Bool D.23075;
  long int D.23076;
  long int D.23077;
  struct MonoInst * iftmp.13;
  int D.23081;
  unsigned int D.23082;
  unsigned int D.23083;
  struct MonoInst * * D.23086;
  long unsigned int D.23087;
  long unsigned int D.23088;
  struct MonoInst * * D.23089;
  sizetype D.23091;
  sizetype D.23092;
  sizetype D.23093;
  int * D.23094;
  int D.23095;
  int D.23101;
  int D.23102;
  short unsigned int D.23103;
  struct MonoClass * D.23106;
  _Bool D.23107;
  long int D.23108;
  long int D.23109;
  struct MonoBasicBlock * * D.23112;
  long unsigned int D.23113;
  long unsigned int D.23114;
  struct MonoBasicBlock * * D.23115;
  int D.23118;
  int D.23119;
  struct MonoMemPool * D.23122;
  int D.23123;
  short unsigned int D.23124;
  int D.23125;
  int D.23126;
  const unsigned char * D.23127;
  short unsigned int D.23128;
  unsigned int D.23133;
  unsigned int i.14;
  long unsigned int D.23137;
  long unsigned int D.23138;
  struct MonoBasicBlock * * D.23139;
  int D.23140;
  int D.23141;
  char D.23144;
  struct MonoInst * iftmp.15;
  struct MonoMethodVar * D.23153;
  long int D.23154;
  long unsigned int D.23155;
  long unsigned int D.23156;
  int D.23157;
  unsigned int D.23160;
  unsigned int D.23161;
  long unsigned int D.23164;
  long unsigned int D.23165;
  struct MonoMethodVar * D.23166;
  int D.23167;
  struct MonoInst * * D.23170;
  long unsigned int D.23171;
  struct MonoInst * * D.23172;
  struct MonoInst * D.23173;
  int D.23174;
  int D.23175;
  int D.23176;
  int D.23177;
  signed char D.23178;
  struct MonoInst * iftmp.16;
  int D.23180;
  unsigned int D.23181;
  long unsigned int D.23184;
  long unsigned int D.23185;
  struct MonoInst * * D.23186;
  long int D.23190;
  long unsigned int D.23191;
  long unsigned int D.23192;
  int D.23193;
  unsigned int D.23196;
  unsigned int D.23197;
  long unsigned int D.23200;
  long unsigned int D.23201;
  struct MonoMethodVar * D.23202;
  int D.23203;
  long unsigned int D.23206;
  struct MonoInst * * D.23207;
  struct MonoInst * D.23208;
  int D.23209;
  unsigned int bbindex.17;
  long unsigned int D.23211;
  struct MonoMethodVar * D.23212;
  unsigned int D.23213;
  unsigned int D.23214;
  unsigned int D.23217;
  unsigned int D.23218;
  struct MonoInst * ins;
  struct MonoInst * var;
  struct MonoInst * move;
  int bbindex;
  int i;
  int j;
  int first;

  D.23052 = cfg->comp_done;
  D.23053 = D.23052 & 32;
  D.23054 = D.23053 == 0;
  D.23055 = (long int) D.23054;
  D.23056 = __builtin_expect (D.23055, 0);
  if (D.23056 != 0) goto <D.23057>; else goto <D.23058>;
  <D.23057>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 489, "cfg->comp_done & MONO_COMP_SSA");
  <D.23058>:
  i = 0;
  goto <D.22329>;
  <D.22328>:
  {
    struct MonoBasicBlock * bb;

    D.23059 = cfg->bblocks;
    D.23060 = (long unsigned int) i;
    D.23061 = D.23060 * 8;
    D.23062 = D.23059 + D.23061;
    bb = *D.23062;
    D.23063 = cfg->verbose_level;
    if (D.23063 > 3) goto <D.23064>; else goto <D.23065>;
    <D.23064>:
    D.23066 = bb->block_num;
    printf ("\nREMOVE SSA %d:\n", D.23066);
    <D.23065>:
    ins = bb->code;
    goto <D.22326>;
    <D.22325>:
    D.23067 = ins->opcode;
    D.23068 = D.23067 + 65217;
    if (D.23068 <= 2) goto <D.23069>; else goto <D.23070>;
    <D.23069>:
    D.23071 = ins->data.op[1].phi_args;
    D.23072 = *D.23071;
    D.23073 = bb->in_count;
    D.23074 = (int) D.23073;
    D.23075 = D.23072 != D.23074;
    D.23076 = (long int) D.23075;
    D.23077 = __builtin_expect (D.23076, 0);
    if (D.23077 != 0) goto <D.23078>; else goto <D.23079>;
    <D.23078>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 499, "ins->inst_phi_args [0] == bb->in_count");
    <D.23079>:
    D.23081 = ins->dreg;
    D.23082 = (unsigned int) D.23081;
    D.23083 = cfg->vreg_to_inst_len;
    if (D.23082 < D.23083) goto <D.23084>; else goto <D.23085>;
    <D.23084>:
    D.23086 = cfg->vreg_to_inst;
    D.23081 = ins->dreg;
    D.23087 = (long unsigned int) D.23081;
    D.23088 = D.23087 * 8;
    D.23089 = D.23086 + D.23088;
    iftmp.13 = *D.23089;
    goto <D.23090>;
    <D.23085>:
    iftmp.13 = 0B;
    <D.23090>:
    var = iftmp.13;
    D.23071 = ins->data.op[1].phi_args;
    first = MEM[(int *)D.23071 + 4B];
    j = 1;
    goto <D.22319>;
    <D.22318>:
    D.23071 = ins->data.op[1].phi_args;
    D.23091 = (sizetype) j;
    D.23092 = D.23091 + 1;
    D.23093 = D.23092 * 4;
    D.23094 = D.23071 + D.23093;
    D.23095 = *D.23094;
    if (D.23095 != first) goto <D.22317>; else goto <D.23096>;
    <D.23096>:
    j = j + 1;
    <D.22319>:
    D.23073 = bb->in_count;
    D.23074 = (int) D.23073;
    if (D.23074 > j) goto <D.22318>; else goto <D.22317>;
    <D.22317>:
    D.23073 = bb->in_count;
    if (D.23073 > 1) goto <D.23099>; else goto <D.23097>;
    <D.23099>:
    D.23073 = bb->in_count;
    D.23074 = (int) D.23073;
    if (D.23074 == j) goto <D.23100>; else goto <D.23097>;
    <D.23100>:
    D.23067 = ins->opcode;
    D.23101 = (int) D.23067;
    D.23102 = op_phi_to_move (D.23101);
    D.23103 = (short unsigned int) D.23102;
    ins->opcode = D.23103;
    D.23067 = ins->opcode;
    if (D.23067 == 427) goto <D.23104>; else goto <D.23105>;
    <D.23104>:
    D.23106 = ins->klass;
    D.23107 = D.23106 == 0B;
    D.23108 = (long int) D.23107;
    D.23109 = __builtin_expect (D.23108, 0);
    if (D.23109 != 0) goto <D.23110>; else goto <D.23111>;
    <D.23110>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 512, "ins->klass");
    <D.23111>:
    <D.23105>:
    ins->sreg1 = first;
    goto <D.23098>;
    <D.23097>:
    j = 0;
    goto <D.22323>;
    <D.22322>:
    {
      struct MonoBasicBlock * pred;
      int sreg;

      D.23112 = bb->in_bb;
      D.23113 = (long unsigned int) j;
      D.23114 = D.23113 * 8;
      D.23115 = D.23112 + D.23114;
      pred = *D.23115;
      D.23071 = ins->data.op[1].phi_args;
      D.23091 = (sizetype) j;
      D.23092 = D.23091 + 1;
      D.23093 = D.23092 * 4;
      D.23094 = D.23071 + D.23093;
      sreg = *D.23094;
      D.23063 = cfg->verbose_level;
      if (D.23063 > 3) goto <D.23116>; else goto <D.23117>;
      <D.23116>:
      D.23118 = var->dreg;
      D.23119 = pred->block_num;
      printf ("\tADD R%d <- R%d in BB%d\n", D.23118, sreg, D.23119);
      <D.23117>:
      D.23118 = var->dreg;
      if (D.23118 != sreg) goto <D.23120>; else goto <D.23121>;
      <D.23120>:
      D.23122 = cfg->mempool;
      move = mono_mempool_alloc0 (D.23122, 80);
      D.23067 = ins->opcode;
      D.23101 = (int) D.23067;
      D.23123 = op_phi_to_move (D.23101);
      D.23124 = (short unsigned int) D.23123;
      move->opcode = D.23124;
      move->dreg = -1;
      move->sreg3 = -1;
      D.23125 = move->sreg3;
      move->sreg2 = D.23125;
      D.23126 = move->sreg2;
      move->sreg1 = D.23126;
      D.23127 = cfg->ip;
      move->cil_code = D.23127;
      D.23128 = move->opcode;
      if (D.23128 == 427) goto <D.23129>; else goto <D.23130>;
      <D.23129>:
      D.23106 = ins->klass;
      D.23107 = D.23106 == 0B;
      D.23108 = (long int) D.23107;
      D.23109 = __builtin_expect (D.23108, 0);
      if (D.23109 != 0) goto <D.23131>; else goto <D.23132>;
      <D.23131>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 524, "ins->klass");
      <D.23132>:
      D.23106 = ins->klass;
      move->klass = D.23106;
      <D.23130>:
      D.23118 = var->dreg;
      move->dreg = D.23118;
      move->sreg1 = sreg;
      mono_add_ins_to_end (pred, move);
      <D.23121>:
    }
    j = j + 1;
    <D.22323>:
    D.23073 = bb->in_count;
    D.23074 = (int) D.23073;
    if (D.23074 > j) goto <D.22322>; else goto <D.22324>;
    <D.22324>:
    ins->opcode = 316;
    ins->dreg = -1;
    <D.23098>:
    <D.23070>:
    ins = ins->next;
    <D.22326>:
    if (ins != 0B) goto <D.22325>; else goto <D.22327>;
    <D.22327>:
  }
  i = i + 1;
  <D.22329>:
  D.23133 = cfg->num_bblocks;
  i.14 = (unsigned int) i;
  if (D.23133 > i.14) goto <D.22328>; else goto <D.22330>;
  <D.22330>:
  D.23063 = cfg->verbose_level;
  if (D.23063 > 3) goto <D.23135>; else goto <D.23136>;
  <D.23135>:
  i = 0;
  goto <D.22333>;
  <D.22332>:
  {
    struct MonoBasicBlock * bb;

    D.23059 = cfg->bblocks;
    D.23060 = (long unsigned int) i;
    D.23061 = D.23060 * 8;
    D.23062 = D.23059 + D.23061;
    bb = *D.23062;
    mono_print_bb (bb, "AFTER REMOVE SSA:");
  }
  i = i + 1;
  <D.22333>:
  D.23133 = cfg->num_bblocks;
  i.14 = (unsigned int) i;
  if (D.23133 > i.14) goto <D.22332>; else goto <D.22334>;
  <D.22334>:
  <D.23136>:
  bbindex = 0;
  goto <D.22351>;
  <D.22350>:
  {
    struct MonoBasicBlock * bb;

    D.23059 = cfg->bblocks;
    D.23137 = (long unsigned int) bbindex;
    D.23138 = D.23137 * 8;
    D.23139 = D.23059 + D.23138;
    bb = *D.23139;
    ins = bb->code;
    goto <D.22348>;
    <D.22347>:
    {
      const char * spec;
      int num_sregs;
      int sregs[3];

      try
        {
          D.23067 = ins->opcode;
          D.23101 = (int) D.23067;
          D.23140 = D.23101 + -313;
          D.23141 = D.23140 * 4;
          spec = &ins_info[D.23141];
          D.23067 = ins->opcode;
          if (D.23067 == 316) goto <D.23142>; else goto <D.23143>;
          <D.23142>:
          // predicted unlikely by continue predictor.
          goto <D.22339>;
          <D.23143>:
          D.23144 = *spec;
          if (D.23144 != 32) goto <D.23145>; else goto <D.23146>;
          <D.23145>:
          {
            struct MonoInst * var;

            D.23081 = ins->dreg;
            D.23082 = (unsigned int) D.23081;
            D.23083 = cfg->vreg_to_inst_len;
            if (D.23082 < D.23083) goto <D.23148>; else goto <D.23149>;
            <D.23148>:
            D.23086 = cfg->vreg_to_inst;
            D.23081 = ins->dreg;
            D.23087 = (long unsigned int) D.23081;
            D.23088 = D.23087 * 8;
            D.23089 = D.23086 + D.23088;
            iftmp.15 = *D.23089;
            goto <D.23150>;
            <D.23149>:
            iftmp.15 = 0B;
            <D.23150>:
            var = iftmp.15;
            if (var != 0B) goto <D.23151>; else goto <D.23152>;
            <D.23151>:
            {
              struct MonoMethodVar * vmv;

              D.23153 = cfg->vars;
              D.23154 = var->data.op[0].const_val;
              D.23155 = (long unsigned int) D.23154;
              D.23156 = D.23155 * 80;
              vmv = D.23153 + D.23156;
              D.23157 = vmv->reg;
              if (D.23157 != -1) goto <D.23158>; else goto <D.23159>;
              <D.23158>:
              D.23160 = vmv->idx;
              D.23157 = vmv->reg;
              D.23161 = (unsigned int) D.23157;
              if (D.23160 != D.23161) goto <D.23162>; else goto <D.23163>;
              <D.23162>:
              D.23153 = cfg->vars;
              D.23157 = vmv->reg;
              D.23164 = (long unsigned int) D.23157;
              D.23165 = D.23164 * 80;
              D.23166 = D.23153 + D.23165;
              D.23167 = D.23166->reg;
              if (D.23167 != -1) goto <D.23168>; else goto <D.23169>;
              <D.23168>:
              D.23081 = ins->dreg;
              D.23170 = cfg->varinfo;
              D.23157 = vmv->reg;
              D.23164 = (long unsigned int) D.23157;
              D.23171 = D.23164 * 8;
              D.23172 = D.23170 + D.23171;
              D.23173 = *D.23172;
              D.23174 = D.23173->dreg;
              printf ("COALESCE: R%d -> R%d\n", D.23081, D.23174);
              D.23170 = cfg->varinfo;
              D.23157 = vmv->reg;
              D.23164 = (long unsigned int) D.23157;
              D.23171 = D.23164 * 8;
              D.23172 = D.23170 + D.23171;
              D.23173 = *D.23172;
              D.23174 = D.23173->dreg;
              ins->dreg = D.23174;
              <D.23169>:
              <D.23163>:
              <D.23159>:
            }
            <D.23152>:
          }
          <D.23146>:
          D.23175 = ins->sreg1;
          sregs[0] = D.23175;
          D.23176 = ins->sreg2;
          sregs[1] = D.23176;
          D.23177 = ins->sreg3;
          sregs[2] = D.23177;
          D.23067 = ins->opcode;
          D.23101 = (int) D.23067;
          D.23140 = D.23101 + -313;
          D.23178 = ins_sreg_counts[D.23140];
          num_sregs = (int) D.23178;
          i = 0;
          goto <D.22345>;
          <D.22344>:
          {
            struct MonoInst * var;

            D.23180 = sregs[i];
            D.23181 = (unsigned int) D.23180;
            D.23083 = cfg->vreg_to_inst_len;
            if (D.23181 < D.23083) goto <D.23182>; else goto <D.23183>;
            <D.23182>:
            D.23086 = cfg->vreg_to_inst;
            D.23180 = sregs[i];
            D.23184 = (long unsigned int) D.23180;
            D.23185 = D.23184 * 8;
            D.23186 = D.23086 + D.23185;
            iftmp.16 = *D.23186;
            goto <D.23187>;
            <D.23183>:
            iftmp.16 = 0B;
            <D.23187>:
            var = iftmp.16;
            if (var != 0B) goto <D.23188>; else goto <D.23189>;
            <D.23188>:
            {
              struct MonoMethodVar * vmv;

              D.23153 = cfg->vars;
              D.23190 = var->data.op[0].const_val;
              D.23191 = (long unsigned int) D.23190;
              D.23192 = D.23191 * 80;
              vmv = D.23153 + D.23192;
              D.23193 = vmv->reg;
              if (D.23193 != -1) goto <D.23194>; else goto <D.23195>;
              <D.23194>:
              D.23196 = vmv->idx;
              D.23193 = vmv->reg;
              D.23197 = (unsigned int) D.23193;
              if (D.23196 != D.23197) goto <D.23198>; else goto <D.23199>;
              <D.23198>:
              D.23153 = cfg->vars;
              D.23193 = vmv->reg;
              D.23200 = (long unsigned int) D.23193;
              D.23201 = D.23200 * 80;
              D.23202 = D.23153 + D.23201;
              D.23203 = D.23202->reg;
              if (D.23203 != -1) goto <D.23204>; else goto <D.23205>;
              <D.23204>:
              D.23180 = sregs[i];
              D.23170 = cfg->varinfo;
              D.23193 = vmv->reg;
              D.23200 = (long unsigned int) D.23193;
              D.23206 = D.23200 * 8;
              D.23207 = D.23170 + D.23206;
              D.23208 = *D.23207;
              D.23209 = D.23208->dreg;
              printf ("COALESCE: R%d -> R%d\n", D.23180, D.23209);
              D.23170 = cfg->varinfo;
              D.23193 = vmv->reg;
              D.23200 = (long unsigned int) D.23193;
              D.23206 = D.23200 * 8;
              D.23207 = D.23170 + D.23206;
              D.23208 = *D.23207;
              D.23209 = D.23208->dreg;
              sregs[i] = D.23209;
              <D.23205>:
              <D.23199>:
              <D.23195>:
            }
            <D.23189>:
          }
          i = i + 1;
          <D.22345>:
          if (i < num_sregs) goto <D.22344>; else goto <D.22346>;
          <D.22346>:
          mono_inst_set_src_registers (ins, &sregs);
        }
      finally
        {
          sregs = {CLOBBER};
        }
    }
    <D.22339>:
    ins = ins->next;
    <D.22348>:
    if (ins != 0B) goto <D.22347>; else goto <D.22349>;
    <D.22349>:
  }
  bbindex = bbindex + 1;
  <D.22351>:
  D.23133 = cfg->num_bblocks;
  bbindex.17 = (unsigned int) bbindex;
  if (D.23133 > bbindex.17) goto <D.22350>; else goto <D.22352>;
  <D.22352>:
  i = 0;
  goto <D.22354>;
  <D.22353>:
  D.23153 = cfg->vars;
  D.23060 = (long unsigned int) i;
  D.23211 = D.23060 * 80;
  D.23212 = D.23153 + D.23211;
  D.23212->reg = -1;
  i = i + 1;
  <D.22354>:
  D.23213 = cfg->num_varinfo;
  i.14 = (unsigned int) i;
  if (D.23213 > i.14) goto <D.22353>; else goto <D.22355>;
  <D.22355>:
  D.23052 = cfg->comp_done;
  D.23214 = D.23052 & 128;
  if (D.23214 != 0) goto <D.23215>; else goto <D.23216>;
  <D.23215>:
  unlink_unused_bblocks (cfg);
  <D.23216>:
  D.23052 = cfg->comp_done;
  D.23217 = D.23052 & 4294967279;
  cfg->comp_done = D.23217;
  D.23052 = cfg->comp_done;
  D.23218 = D.23052 & 4294967263;
  cfg->comp_done = D.23218;
}


op_phi_to_move (int opcode)
{
  int D.23221;

  switch (opcode) <default: <D.22194>, case 319: <D.22190>, case 320: <D.22191>, case 321: <D.22192>, case 802: <D.22193>>
  <D.22190>:
  D.23221 = 424;
  return D.23221;
  <D.22191>:
  D.23221 = 426;
  return D.23221;
  <D.22192>:
  D.23221 = 427;
  return D.23221;
  <D.22193>:
  D.23221 = 800;
  return D.23221;
  <D.22194>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "ssa.c", 137);
  D.23221 = -1;
  return D.23221;
}


unlink_unused_bblocks (struct MonoCompile * cfg)
{
  unsigned int D.23223;
  unsigned int D.23224;
  _Bool D.23225;
  long int D.23226;
  long int D.23227;
  unsigned int D.23230;
  _Bool D.23231;
  long int D.23232;
  long int D.23233;
  struct MonoBasicBlock * D.23236;
  unsigned int D.23237;
  unsigned int D.23238;
  struct MonoBasicBlock * D.23241;
  struct MonoBasicBlock * * D.23244;
  long unsigned int D.23245;
  long unsigned int D.23246;
  struct MonoBasicBlock * * D.23247;
  unsigned int D.23248;
  unsigned int D.23249;
  struct MonoBasicBlock * * D.23252;
  long unsigned int D.23253;
  long unsigned int D.23254;
  struct MonoBasicBlock * * D.23255;
  struct MonoBasicBlock * D.23256;
  short int D.23257;
  int D.23258;
  struct MonoBasicBlock * * D.23259;
  struct MonoBasicBlock * * D.23260;
  struct MonoBasicBlock * D.23261;
  short int D.23262;
  int D.23263;
  int D.23266;
  unsigned int D.23267;
  unsigned int i.18;
  int i;
  int j;
  struct MonoBasicBlock * bb;

  D.23223 = cfg->comp_done;
  D.23224 = D.23223 & 128;
  D.23225 = D.23224 == 0;
  D.23226 = (long int) D.23225;
  D.23227 = __builtin_expect (D.23226, 0);
  if (D.23227 != 0) goto <D.23228>; else goto <D.23229>;
  <D.23228>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 66, "cfg->comp_done & MONO_COMP_REACHABILITY");
  <D.23229>:
  D.23230 = cfg->verbose_level;
  D.23231 = D.23230 > 1;
  D.23232 = (long int) D.23231;
  D.23233 = __builtin_expect (D.23232, 0);
  if (D.23233 != 0) goto <D.23234>; else goto <D.23235>;
  <D.23234>:
  printf ("\nUNLINK UNUSED BBLOCKS:\n");
  <D.23235>:
  bb = cfg->bb_entry;
  goto <D.22159>;
  <D.22158>:
  D.23236 = bb->next_bb;
  D.23237 = D.23236->flags;
  D.23238 = D.23237 & 2;
  if (D.23238 == 0) goto <D.23239>; else goto <D.23240>;
  <D.23239>:
  D.23236 = bb->next_bb;
  D.23241 = D.23236->next_bb;
  bb->next_bb = D.23241;
  goto <D.23242>;
  <D.23240>:
  bb = bb->next_bb;
  <D.23242>:
  <D.22159>:
  if (bb != 0B) goto <D.23243>; else goto <D.22160>;
  <D.23243>:
  D.23236 = bb->next_bb;
  if (D.23236 != 0B) goto <D.22158>; else goto <D.22160>;
  <D.22160>:
  i = 1;
  goto <D.22168>;
  <D.22167>:
  D.23244 = cfg->bblocks;
  D.23245 = (long unsigned int) i;
  D.23246 = D.23245 * 8;
  D.23247 = D.23244 + D.23246;
  bb = *D.23247;
  D.23248 = bb->flags;
  D.23249 = D.23248 & 2;
  if (D.23249 == 0) goto <D.23250>; else goto <D.23251>;
  <D.23250>:
  j = 0;
  goto <D.22162>;
  <D.22161>:
  D.23252 = bb->in_bb;
  D.23253 = (long unsigned int) j;
  D.23254 = D.23253 * 8;
  D.23255 = D.23252 + D.23254;
  D.23256 = *D.23255;
  unlink_target (D.23256, bb);
  j = j + 1;
  <D.22162>:
  D.23257 = bb->in_count;
  D.23258 = (int) D.23257;
  if (D.23258 > j) goto <D.22161>; else goto <D.22163>;
  <D.22163>:
  j = 0;
  goto <D.22165>;
  <D.22164>:
  D.23259 = bb->out_bb;
  D.23253 = (long unsigned int) j;
  D.23254 = D.23253 * 8;
  D.23260 = D.23259 + D.23254;
  D.23261 = *D.23260;
  unlink_target (bb, D.23261);
  j = j + 1;
  <D.22165>:
  D.23262 = bb->out_count;
  D.23263 = (int) D.23262;
  if (D.23263 > j) goto <D.22164>; else goto <D.22166>;
  <D.22166>:
  D.23230 = cfg->verbose_level;
  D.23231 = D.23230 > 1;
  D.23232 = (long int) D.23231;
  D.23233 = __builtin_expect (D.23232, 0);
  if (D.23233 != 0) goto <D.23264>; else goto <D.23265>;
  <D.23264>:
  D.23266 = bb->block_num;
  printf ("\tUnlinked BB%d\n", D.23266);
  <D.23265>:
  <D.23251>:
  i = i + 1;
  <D.22168>:
  D.23267 = cfg->num_bblocks;
  i.18 = (unsigned int) i;
  if (D.23267 > i.18) goto <D.22167>; else goto <D.22169>;
  <D.22169>:
}


unlink_target (struct MonoBasicBlock * bb, struct MonoBasicBlock * target)
{
  struct MonoBasicBlock * * D.23269;
  long unsigned int D.23270;
  long unsigned int D.23271;
  struct MonoBasicBlock * * D.23272;
  struct MonoBasicBlock * D.23273;
  short int D.23276;
  unsigned short D.23277;
  unsigned short D.23278;
  short int D.23279;
  long unsigned int D.23280;
  long unsigned int D.23281;
  struct MonoBasicBlock * * D.23282;
  struct MonoBasicBlock * D.23283;
  int D.23284;
  struct MonoBasicBlock * * D.23285;
  struct MonoBasicBlock * * D.23286;
  struct MonoBasicBlock * D.23287;
  short int D.23290;
  unsigned short D.23291;
  unsigned short D.23292;
  short int D.23293;
  long unsigned int D.23294;
  long unsigned int D.23295;
  struct MonoBasicBlock * * D.23296;
  struct MonoBasicBlock * D.23297;
  int D.23298;
  int i;

  i = 0;
  goto <D.22148>;
  <D.22147>:
  D.23269 = bb->out_bb;
  D.23270 = (long unsigned int) i;
  D.23271 = D.23270 * 8;
  D.23272 = D.23269 + D.23271;
  D.23273 = *D.23272;
  if (D.23273 == target) goto <D.23274>; else goto <D.23275>;
  <D.23274>:
  D.23269 = bb->out_bb;
  D.23270 = (long unsigned int) i;
  D.23271 = D.23270 * 8;
  D.23272 = D.23269 + D.23271;
  D.23269 = bb->out_bb;
  D.23276 = bb->out_count;
  D.23277 = (unsigned short) D.23276;
  D.23278 = D.23277 + 65535;
  D.23279 = (short int) D.23278;
  bb->out_count = D.23279;
  D.23276 = bb->out_count;
  D.23280 = (long unsigned int) D.23276;
  D.23281 = D.23280 * 8;
  D.23282 = D.23269 + D.23281;
  D.23283 = *D.23282;
  *D.23272 = D.23283;
  goto <D.22146>;
  <D.23275>:
  i = i + 1;
  <D.22148>:
  D.23276 = bb->out_count;
  D.23284 = (int) D.23276;
  if (D.23284 > i) goto <D.22147>; else goto <D.22146>;
  <D.22146>:
  i = 0;
  goto <D.22151>;
  <D.22150>:
  D.23285 = target->in_bb;
  D.23270 = (long unsigned int) i;
  D.23271 = D.23270 * 8;
  D.23286 = D.23285 + D.23271;
  D.23287 = *D.23286;
  if (D.23287 == bb) goto <D.23288>; else goto <D.23289>;
  <D.23288>:
  D.23285 = target->in_bb;
  D.23270 = (long unsigned int) i;
  D.23271 = D.23270 * 8;
  D.23286 = D.23285 + D.23271;
  D.23285 = target->in_bb;
  D.23290 = target->in_count;
  D.23291 = (unsigned short) D.23290;
  D.23292 = D.23291 + 65535;
  D.23293 = (short int) D.23292;
  target->in_count = D.23293;
  D.23290 = target->in_count;
  D.23294 = (long unsigned int) D.23290;
  D.23295 = D.23294 * 8;
  D.23296 = D.23285 + D.23295;
  D.23297 = *D.23296;
  *D.23286 = D.23297;
  goto <D.22149>;
  <D.23289>:
  i = i + 1;
  <D.22151>:
  D.23290 = target->in_count;
  D.23298 = (int) D.23290;
  if (D.23298 > i) goto <D.22150>; else goto <D.22149>;
  <D.22149>:
}


__attribute__((visibility ("hidden")))
mono_ssa_cprop (struct MonoCompile * cfg)
{
  unsigned int D.23299;
  long unsigned int D.23300;
  long unsigned int D.23301;
  unsigned int D.23302;
  unsigned int D.23303;
  struct MonoBasicBlock * D.23306;
  struct GList * bblock_list.19;
  unsigned int D.23308;
  unsigned int D.23309;
  unsigned int D.23310;
  long unsigned int D.23311;
  long unsigned int D.23312;
  struct MonoMethodVar * D.23313;
  long unsigned int D.23314;
  long unsigned int D.23315;
  struct MonoInst * D.23316;
  unsigned int i.20;
  unsigned int D.23320;
  struct GList * bblock_list.21;
  struct GList * bblock_list.22;
  unsigned int D.23325;
  unsigned int D.23326;
  _Bool D.23327;
  long int D.23328;
  long int D.23329;
  struct MonoInst * D.23333;
  short unsigned int D.23335;
  short unsigned int D.23336;
  short unsigned int D.23338;
  short unsigned int D.23340;
  struct MonoBasicBlock * * D.23344;
  long unsigned int D.23345;
  struct MonoBasicBlock * * D.23346;
  struct MonoBasicBlock * D.23347;
  short int D.23348;
  int D.23349;
  unsigned int D.23350;
  int D.23353;
  struct GList * cvars.23;
  struct GList * cvars.24;
  struct MonoBasicBlock * D.23356;
  unsigned int D.23357;
  unsigned int D.23358;
  struct MonoInst * D.23361;
  unsigned int D.23362;
  unsigned int D.23363;
  struct MonoInst * * carray;
  struct MonoBasicBlock * bb;
  struct GList * bblock_list;
  struct GList * cvars;
  struct GList * tmp;
  int i;

  try
    {
      D.23299 = cfg->next_vreg;
      D.23300 = (long unsigned int) D.23299;
      D.23301 = D.23300 * 8;
      carray = monoeg_malloc0 (D.23301);
      D.23302 = cfg->comp_done;
      D.23303 = D.23302 & 64;
      if (D.23303 == 0) goto <D.23304>; else goto <D.23305>;
      <D.23304>:
      mono_ssa_create_def_use (cfg);
      <D.23305>:
      D.23306 = cfg->bb_entry;
      bblock_list.19 = monoeg_g_list_prepend (0B, D.23306);
      bblock_list = bblock_list.19;
      D.23306 = cfg->bb_entry;
      D.23306 = cfg->bb_entry;
      D.23308 = D.23306->flags;
      D.23309 = D.23308 | 2;
      D.23306->flags = D.23309;
      D.23310 = cfg->num_varinfo;
      D.23311 = (long unsigned int) D.23310;
      D.23312 = D.23311 * 8;
      memset (carray, 0, D.23312);
      i = 0;
      goto <D.22518>;
      <D.22517>:
      {
        struct MonoMethodVar * info;

        D.23313 = cfg->vars;
        D.23314 = (long unsigned int) i;
        D.23315 = D.23314 * 80;
        info = D.23313 + D.23315;
        D.23316 = info->def;
        if (D.23316 == 0B) goto <D.23317>; else goto <D.23318>;
        <D.23317>:
        info->cpstate = 2;
        <D.23318>:
      }
      i = i + 1;
      <D.22518>:
      D.23310 = cfg->num_varinfo;
      i.20 = (unsigned int) i;
      if (D.23310 > i.20) goto <D.22517>; else goto <D.22519>;
      <D.22519>:
      D.23306 = cfg->bb_entry;
      bb = D.23306->next_bb;
      goto <D.22521>;
      <D.22520>:
      D.23320 = bb->region;
      if (D.23320 != 0) goto <D.23321>; else goto <D.23322>;
      <D.23321>:
      add_cprop_bb (cfg, bb, &bblock_list);
      <D.23322>:
      bb = bb->next_bb;
      <D.22521>:
      if (bb != 0B) goto <D.22520>; else goto <D.22522>;
      <D.22522>:
      cvars = 0B;
      goto <D.22540>;
      <D.22539>:
      {
        struct MonoInst * inst;

        bblock_list.21 = bblock_list;
        bb = bblock_list.21->data;
        bblock_list.21 = bblock_list;
        bblock_list.21 = bblock_list;
        bblock_list.22 = monoeg_g_list_delete_link (bblock_list.21, bblock_list.21);
        bblock_list = bblock_list.22;
        D.23325 = bb->flags;
        D.23326 = D.23325 & 2;
        D.23327 = D.23326 == 0;
        D.23328 = (long int) D.23327;
        D.23329 = __builtin_expect (D.23328, 0);
        if (D.23329 != 0) goto <D.23330>; else goto <D.23331>;
        <D.23330>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 1185, "bb->flags & BB_REACHABLE");
        <D.23331>:
        D.23333 = bb->last_ins;
        if (D.23333 == 0B) goto <D.23332>; else goto <D.23334>;
        <D.23334>:
        D.23333 = bb->last_ins;
        D.23335 = D.23333->opcode;
        D.23336 = D.23335 + 64985;
        if (D.23336 > 9) goto <D.23337>; else goto <D.22526>;
        <D.23337>:
        D.23333 = bb->last_ins;
        D.23335 = D.23333->opcode;
        D.23338 = D.23335 + 64878;
        if (D.23338 > 9) goto <D.23339>; else goto <D.22526>;
        <D.23339>:
        D.23333 = bb->last_ins;
        D.23335 = D.23333->opcode;
        D.23340 = D.23335 + 64888;
        if (D.23340 > 9) goto <D.23341>; else goto <D.22526>;
        <D.23341>:
        D.23333 = bb->last_ins;
        D.23335 = D.23333->opcode;
        if (D.23335 != 442) goto <D.23342>; else goto <D.22526>;
        <D.23342>:
        D.23333 = bb->last_ins;
        D.23335 = D.23333->opcode;
        if (D.23335 != 759) goto <D.23343>; else goto <D.22526>;
        <D.23343>:
        D.23333 = bb->last_ins;
        D.23335 = D.23333->opcode;
        if (D.23335 != 370) goto <D.23332>; else goto <D.22526>;
        <D.23332>:
        i = 0;
        goto <D.22525>;
        <D.22524>:
        D.23344 = bb->out_bb;
        D.23314 = (long unsigned int) i;
        D.23345 = D.23314 * 8;
        D.23346 = D.23344 + D.23345;
        D.23347 = *D.23346;
        add_cprop_bb (cfg, D.23347, &bblock_list);
        i = i + 1;
        <D.22525>:
        D.23348 = bb->out_count;
        D.23349 = (int) D.23348;
        if (D.23349 > i) goto <D.22524>; else goto <D.22526>;
        <D.22526>:
        D.23350 = cfg->verbose_level;
        if (D.23350 > 1) goto <D.23351>; else goto <D.23352>;
        <D.23351>:
        D.23353 = bb->block_num;
        printf ("\nSSA CONSPROP BB%d:\n", D.23353);
        <D.23352>:
        inst = bb->code;
        goto <D.22528>;
        <D.22527>:
        visit_inst (cfg, bb, inst, &cvars, &bblock_list, carray);
        inst = inst->next;
        <D.22528>:
        if (inst != 0B) goto <D.22527>; else goto <D.22529>;
        <D.22529>:
        goto <D.22537>;
        <D.22536>:
        {
          struct MonoMethodVar * info;

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

            ui = tmp->data;
            D.23356 = ui->bb;
            D.23357 = D.23356->flags;
            D.23358 = D.23357 & 2;
            if (D.23358 == 0) goto <D.23359>; else goto <D.23360>;
            <D.23359>:
            // predicted unlikely by continue predictor.
            goto <D.22532>;
            <D.23360>:
            D.23356 = ui->bb;
            D.23361 = ui->inst;
            visit_inst (cfg, D.23356, D.23361, &cvars, &bblock_list, carray);
          }
          <D.22532>:
          tmp = tmp->next;
          <D.22534>:
          if (tmp != 0B) goto <D.22533>; else goto <D.22535>;
          <D.22535>:
        }
        <D.22537>:
        cvars.23 = cvars;
        if (cvars.23 != 0B) goto <D.22536>; else goto <D.22538>;
        <D.22538>:
      }
      <D.22540>:
      bblock_list.21 = bblock_list;
      if (bblock_list.21 != 0B) goto <D.22539>; else goto <D.22541>;
      <D.22541>:
      D.23306 = cfg->bb_entry;
      bb = D.23306->next_bb;
      goto <D.22547>;
      <D.22546>:
      {
        struct MonoInst * inst;

        inst = bb->code;
        goto <D.22544>;
        <D.22543>:
        fold_ins (cfg, bb, inst, carray);
        inst = inst->next;
        <D.22544>:
        if (inst != 0B) goto <D.22543>; else goto <D.22545>;
        <D.22545>:
      }
      bb = bb->next_bb;
      <D.22547>:
      if (bb != 0B) goto <D.22546>; else goto <D.22548>;
      <D.22548>:
      monoeg_g_free (carray);
      D.23302 = cfg->comp_done;
      D.23362 = D.23302 | 128;
      cfg->comp_done = D.23362;
      D.23302 = cfg->comp_done;
      D.23363 = D.23302 & 4294967231;
      cfg->comp_done = D.23363;
      i = 0;
      goto <D.22551>;
      <D.22550>:
      {
        struct MonoMethodVar * info;

        D.23313 = cfg->vars;
        D.23314 = (long unsigned int) i;
        D.23315 = D.23314 * 80;
        info = D.23313 + D.23315;
        info->def = 0B;
        info->uses = 0B;
      }
      i = i + 1;
      <D.22551>:
      D.23310 = cfg->num_varinfo;
      i.20 = (unsigned int) i;
      if (D.23310 > i.20) goto <D.22550>; else goto <D.22552>;
      <D.22552>:
    }
  finally
    {
      bblock_list = {CLOBBER};
      cvars = {CLOBBER};
    }
}


mono_ssa_create_def_use (struct MonoCompile * cfg)
{
  unsigned int D.23364;
  unsigned int D.23365;
  _Bool D.23366;
  long int D.23367;
  long int D.23368;
  short unsigned int D.23371;
  int D.23372;
  int D.23373;
  int D.23374;
  int D.23377;
  int D.23378;
  int D.23379;
  signed char D.23380;
  struct MonoInst * iftmp.25;
  int D.23382;
  unsigned int D.23383;
  unsigned int D.23384;
  struct MonoInst * * D.23387;
  long unsigned int D.23388;
  long unsigned int D.23389;
  struct MonoInst * * D.23390;
  unsigned char D.23394;
  int D.23395;
  int D.23396;
  short unsigned int D.23399;
  struct MonoInst * iftmp.26;
  int D.23403;
  unsigned int D.23404;
  long unsigned int D.23407;
  long unsigned int D.23408;
  struct MonoInst * * D.23409;
  unsigned char D.23413;
  int D.23414;
  int D.23415;
  short unsigned int D.23418;
  int * D.23421;
  long unsigned int D.23422;
  long unsigned int D.23423;
  int * D.23424;
  int D.23425;
  _Bool D.23426;
  long int D.23427;
  long int D.23428;
  struct MonoInst * iftmp.27;
  unsigned int D.23432;
  long unsigned int D.23435;
  long unsigned int D.23436;
  struct MonoInst * * D.23437;
  char D.23439;
  struct MonoInst * iftmp.28;
  unsigned char D.23450;
  int D.23451;
  int D.23452;
  struct MonoMethodVar * D.23455;
  long int D.23456;
  long unsigned int D.23457;
  long unsigned int D.23458;
  unsigned int D.23459;
  struct MonoBasicBlock * bb;
  struct MonoInst * ins;
  int i;

  D.23364 = cfg->comp_done;
  D.23365 = D.23364 & 64;
  D.23366 = D.23365 != 0;
  D.23367 = (long int) D.23366;
  D.23368 = __builtin_expect (D.23367, 0);
  if (D.23368 != 0) goto <D.23369>; else goto <D.23370>;
  <D.23369>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 619, "!(cfg->comp_done & MONO_COMP_SSA_DEF_USE)");
  <D.23370>:
  bb = cfg->bb_entry;
  goto <D.22380>;
  <D.22379>:
  ins = bb->code;
  goto <D.22377>;
  <D.22376>:
  {
    const char * spec;
    struct MonoMethodVar * info;
    int num_sregs;
    int sregs[3];

    try
      {
        D.23371 = ins->opcode;
        D.23372 = (int) D.23371;
        D.23373 = D.23372 + -313;
        D.23374 = D.23373 * 4;
        spec = &ins_info[D.23374];
        D.23371 = ins->opcode;
        if (D.23371 == 316) goto <D.23375>; else goto <D.23376>;
        <D.23375>:
        // predicted unlikely by continue predictor.
        goto <D.22366>;
        <D.23376>:
        D.23377 = ins->sreg1;
        sregs[0] = D.23377;
        D.23378 = ins->sreg2;
        sregs[1] = D.23378;
        D.23379 = ins->sreg3;
        sregs[2] = D.23379;
        D.23371 = ins->opcode;
        D.23372 = (int) D.23371;
        D.23373 = D.23372 + -313;
        D.23380 = ins_sreg_counts[D.23373];
        num_sregs = (int) D.23380;
        i = 0;
        goto <D.22369>;
        <D.22368>:
        {
          struct MonoInst * var;

          D.23382 = sregs[i];
          D.23383 = (unsigned int) D.23382;
          D.23384 = cfg->vreg_to_inst_len;
          if (D.23383 < D.23384) goto <D.23385>; else goto <D.23386>;
          <D.23385>:
          D.23387 = cfg->vreg_to_inst;
          D.23382 = sregs[i];
          D.23388 = (long unsigned int) D.23382;
          D.23389 = D.23388 * 8;
          D.23390 = D.23387 + D.23389;
          iftmp.25 = *D.23390;
          goto <D.23391>;
          <D.23386>:
          iftmp.25 = 0B;
          <D.23391>:
          var = iftmp.25;
          if (var != 0B) goto <D.23392>; else goto <D.23393>;
          <D.23392>:
          D.23394 = var->flags;
          D.23395 = (int) D.23394;
          D.23396 = D.23395 & 20;
          if (D.23396 == 0) goto <D.23397>; else goto <D.23398>;
          <D.23397>:
          record_use (cfg, var, bb, ins);
          <D.23398>:
          <D.23393>:
        }
        i = i + 1;
        <D.22369>:
        if (i < num_sregs) goto <D.22368>; else goto <D.22370>;
        <D.22370>:
        D.23371 = ins->opcode;
        D.23399 = D.23371 + 65162;
        if (D.23399 <= 13) goto <D.23400>; else goto <D.23401>;
        <D.23400>:
        {
          struct MonoInst * var;

          D.23403 = ins->dreg;
          D.23404 = (unsigned int) D.23403;
          D.23384 = cfg->vreg_to_inst_len;
          if (D.23404 < D.23384) goto <D.23405>; else goto <D.23406>;
          <D.23405>:
          D.23387 = cfg->vreg_to_inst;
          D.23403 = ins->dreg;
          D.23407 = (long unsigned int) D.23403;
          D.23408 = D.23407 * 8;
          D.23409 = D.23387 + D.23408;
          iftmp.26 = *D.23409;
          goto <D.23410>;
          <D.23406>:
          iftmp.26 = 0B;
          <D.23410>:
          var = iftmp.26;
          if (var != 0B) goto <D.23411>; else goto <D.23412>;
          <D.23411>:
          D.23413 = var->flags;
          D.23414 = (int) D.23413;
          D.23415 = D.23414 & 20;
          if (D.23415 == 0) goto <D.23416>; else goto <D.23417>;
          <D.23416>:
          record_use (cfg, var, bb, ins);
          <D.23417>:
          <D.23412>:
        }
        <D.23401>:
        D.23371 = ins->opcode;
        D.23418 = D.23371 + 65217;
        if (D.23418 <= 2) goto <D.23419>; else goto <D.23420>;
        <D.23419>:
        D.23421 = ins->data.op[1].phi_args;
        i = *D.23421;
        goto <D.22373>;
        <D.22372>:
        D.23421 = ins->data.op[1].phi_args;
        D.23422 = (long unsigned int) i;
        D.23423 = D.23422 * 4;
        D.23424 = D.23421 + D.23423;
        D.23425 = *D.23424;
        D.23426 = D.23425 == -1;
        D.23427 = (long int) D.23426;
        D.23428 = __builtin_expect (D.23427, 0);
        if (D.23428 != 0) goto <D.23429>; else goto <D.23430>;
        <D.23429>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 647, "ins->inst_phi_args [i] != -1");
        <D.23430>:
        D.23421 = ins->data.op[1].phi_args;
        D.23422 = (long unsigned int) i;
        D.23423 = D.23422 * 4;
        D.23424 = D.23421 + D.23423;
        D.23425 = *D.23424;
        D.23432 = (unsigned int) D.23425;
        D.23384 = cfg->vreg_to_inst_len;
        if (D.23432 < D.23384) goto <D.23433>; else goto <D.23434>;
        <D.23433>:
        D.23387 = cfg->vreg_to_inst;
        D.23421 = ins->data.op[1].phi_args;
        D.23422 = (long unsigned int) i;
        D.23423 = D.23422 * 4;
        D.23424 = D.23421 + D.23423;
        D.23425 = *D.23424;
        D.23435 = (long unsigned int) D.23425;
        D.23436 = D.23435 * 8;
        D.23437 = D.23387 + D.23436;
        iftmp.27 = *D.23437;
        goto <D.23438>;
        <D.23434>:
        iftmp.27 = 0B;
        <D.23438>:
        record_use (cfg, iftmp.27, bb, ins);
        i = i + -1;
        <D.22373>:
        if (i > 0) goto <D.22372>; else goto <D.22374>;
        <D.22374>:
        <D.23420>:
        D.23439 = *spec;
        if (D.23439 != 32) goto <D.23440>; else goto <D.23441>;
        <D.23440>:
        D.23371 = ins->opcode;
        D.23399 = D.23371 + 65162;
        if (D.23399 > 13) goto <D.23442>; else goto <D.23443>;
        <D.23442>:
        {
          struct MonoInst * var;

          D.23403 = ins->dreg;
          D.23404 = (unsigned int) D.23403;
          D.23384 = cfg->vreg_to_inst_len;
          if (D.23404 < D.23384) goto <D.23445>; else goto <D.23446>;
          <D.23445>:
          D.23387 = cfg->vreg_to_inst;
          D.23403 = ins->dreg;
          D.23407 = (long unsigned int) D.23403;
          D.23408 = D.23407 * 8;
          D.23409 = D.23387 + D.23408;
          iftmp.28 = *D.23409;
          goto <D.23447>;
          <D.23446>:
          iftmp.28 = 0B;
          <D.23447>:
          var = iftmp.28;
          if (var != 0B) goto <D.23448>; else goto <D.23449>;
          <D.23448>:
          D.23450 = var->flags;
          D.23451 = (int) D.23450;
          D.23452 = D.23451 & 20;
          if (D.23452 == 0) goto <D.23453>; else goto <D.23454>;
          <D.23453>:
          D.23455 = cfg->vars;
          D.23456 = var->data.op[0].const_val;
          D.23457 = (long unsigned int) D.23456;
          D.23458 = D.23457 * 80;
          info = D.23455 + D.23458;
          info->def = ins;
          info->def_bb = bb;
          <D.23454>:
          <D.23449>:
        }
        <D.23443>:
        <D.23441>:
      }
    finally
      {
        sregs = {CLOBBER};
      }
  }
  <D.22366>:
  ins = ins->next;
  <D.22377>:
  if (ins != 0B) goto <D.22376>; else goto <D.22378>;
  <D.22378>:
  bb = bb->next_bb;
  <D.22380>:
  if (bb != 0B) goto <D.22379>; else goto <D.22381>;
  <D.22381>:
  D.23364 = cfg->comp_done;
  D.23459 = D.23364 | 64;
  cfg->comp_done = D.23459;
}


add_cprop_bb (struct MonoCompile * cfg, struct MonoBasicBlock * bb, struct GList * * bblist)
{
  unsigned int D.23462;
  _Bool D.23463;
  long int D.23464;
  long int D.23465;
  int D.23468;
  unsigned int D.23469;
  unsigned int D.23470;
  unsigned int D.23473;
  struct GList * D.23474;
  struct GList * D.23475;

  D.23462 = cfg->verbose_level;
  D.23463 = D.23462 > 1;
  D.23464 = (long int) D.23463;
  D.23465 = __builtin_expect (D.23464, 0);
  if (D.23465 != 0) goto <D.23466>; else goto <D.23467>;
  <D.23466>:
  D.23468 = bb->block_num;
  printf ("\tAdd BB%d to worklist\n", D.23468);
  <D.23467>:
  D.23469 = bb->flags;
  D.23470 = D.23469 & 2;
  if (D.23470 == 0) goto <D.23471>; else goto <D.23472>;
  <D.23471>:
  D.23469 = bb->flags;
  D.23473 = D.23469 | 2;
  bb->flags = D.23473;
  D.23474 = *bblist;
  D.23475 = monoeg_g_list_prepend (D.23474, bb);
  *bblist = D.23475;
  <D.23472>:
}


visit_inst (struct MonoCompile * cfg, struct MonoBasicBlock * bb, struct MonoInst * ins, struct GList * * cvars, struct GList * * bblist, struct MonoInst * * carray)
{
  short unsigned int D.23476;
  int D.23477;
  int D.23478;
  int D.23479;
  unsigned int D.23482;
  short unsigned int D.23485;
  struct MonoMethodVar * D.23488;
  struct MonoInst * iftmp.29;
  int D.23490;
  unsigned int D.23491;
  unsigned int D.23492;
  struct MonoInst * * D.23495;
  long unsigned int D.23496;
  long unsigned int D.23497;
  struct MonoInst * * D.23498;
  long int D.23500;
  long unsigned int D.23501;
  long unsigned int D.23502;
  struct MonoInst * iftmp.30;
  int * D.23504;
  long unsigned int D.23505;
  long unsigned int D.23506;
  int * D.23507;
  int D.23508;
  unsigned int D.23509;
  long unsigned int D.23512;
  long unsigned int D.23513;
  struct MonoInst * * D.23514;
  long int D.23516;
  long unsigned int D.23517;
  long unsigned int D.23518;
  struct MonoBasicBlock * D.23519;
  unsigned int D.23522;
  unsigned int D.23523;
  struct MonoInst * D.23528;
  char D.23531;
  int D.23534;
  long unsigned int D.23535;
  long unsigned int D.23536;
  struct MonoInst * * D.23537;
  struct MonoInst * D.23538;
  _Bool D.23539;
  long int D.23540;
  long int D.23541;
  short unsigned int D.23546;
  long int D.23549;
  long int D.23550;
  int D.23553;
  char D.23556;
  _Bool D.23559;
  long int D.23560;
  long int D.23561;
  short unsigned int D.23568;
  const char * D.23570;
  char D.23571;
  const char * D.23573;
  char D.23574;
  char D.23576;
  struct MonoInst * iftmp.31;
  unsigned char D.23587;
  int D.23588;
  int D.23589;
  long int D.23591;
  long unsigned int D.23592;
  long unsigned int D.23593;
  char D.23594;
  struct MonoInst * c0.32;
  struct MonoInst * * D.23609;
  struct MonoInst * D.23611;
  struct GList * D.23614;
  struct GList * D.23615;
  struct GList * D.23618;
  struct MonoInst * D.23624;
  struct MonoInst * D.23627;
  struct MonoJumpInfoBBTable * iftmp.33;
  struct MonoJumpInfoBBTable * iftmp.34;
  struct MonoJumpInfoBBTable * iftmp.35;
  struct MonoJumpInfoBBTable * iftmp.36;
  struct MonoInst * D.23648;
  short unsigned int D.23650;
  struct MonoBasicBlock * * D.23651;
  long unsigned int D.23652;
  long unsigned int D.23653;
  struct MonoBasicBlock * * D.23654;
  struct MonoBasicBlock * D.23655;
  int D.23658;
  _Bool D.23659;
  long int D.23660;
  long int D.23661;
  int D.23664;
  _Bool D.23665;
  long int D.23666;
  long int D.23667;
  int D.23670;
  long unsigned int D.23671;
  long unsigned int D.23672;
  struct MonoInst * * D.23673;
  struct MonoInst * D.23674;
  long int D.23677;
  long int D.23678;
  long unsigned int D.23682;
  long unsigned int D.23683;
  struct MonoBasicBlock * * D.23684;
  struct MonoBasicBlock * D.23685;
  struct MonoBasicBlock * * D.23693;
  long unsigned int D.23694;
  long unsigned int D.23695;
  struct MonoBasicBlock * * D.23696;
  struct MonoBasicBlock * D.23697;
  int D.23700;
  short unsigned int D.23705;
  short unsigned int D.23707;
  short unsigned int D.23709;
  short unsigned int D.23712;
  _Bool D.23713;
  long int D.23714;
  long int D.23715;
  long int D.23718;
  unsigned char D.23721;
  unsigned char D.23722;
  unsigned char D.23724;
  unsigned char D.23726;
  struct MonoBasicBlock * D.23729;
  short unsigned int D.23733;
  short unsigned int D.23735;
  short unsigned int D.23737;
  unsigned char D.23738;
  int D.23739;
  int D.23740;
  struct MonoBasicBlock * * D.23743;
  struct MonoBasicBlock * D.23744;
  int D.23746;
  struct MonoBasicBlock * * D.23749;
  struct MonoBasicBlock * D.23750;
  const char * spec;

  D.23476 = ins->opcode;
  D.23477 = (int) D.23476;
  D.23478 = D.23477 + -313;
  D.23479 = D.23478 * 4;
  spec = &ins_info[D.23479];
  D.23476 = ins->opcode;
  if (D.23476 == 316) goto <D.23480>; else goto <D.23481>;
  <D.23480>:
  return;
  <D.23481>:
  D.23482 = cfg->verbose_level;
  if (D.23482 > 1) goto <D.23483>; else goto <D.23484>;
  <D.23483>:
  mono_print_ins (ins);
  <D.23484>:
  D.23476 = ins->opcode;
  D.23485 = D.23476 + 65217;
  if (D.23485 <= 2) goto <D.23486>; else goto <D.23487>;
  <D.23486>:
  {
    struct MonoMethodVar * info;
    struct MonoInst * c0;
    int j;

    D.23488 = cfg->vars;
    D.23490 = ins->dreg;
    D.23491 = (unsigned int) D.23490;
    D.23492 = cfg->vreg_to_inst_len;
    if (D.23491 < D.23492) goto <D.23493>; else goto <D.23494>;
    <D.23493>:
    D.23495 = cfg->vreg_to_inst;
    D.23490 = ins->dreg;
    D.23496 = (long unsigned int) D.23490;
    D.23497 = D.23496 * 8;
    D.23498 = D.23495 + D.23497;
    iftmp.29 = *D.23498;
    goto <D.23499>;
    <D.23494>:
    iftmp.29 = 0B;
    <D.23499>:
    D.23500 = iftmp.29->data.op[0].const_val;
    D.23501 = (long unsigned int) D.23500;
    D.23502 = D.23501 * 80;
    info = D.23488 + D.23502;
    c0 = 0B;
    j = 1;
    goto <D.22470>;
    <D.22469>:
    {
      struct MonoInst * var;
      struct MonoMethodVar * mv;
      struct MonoInst * src;

      D.23504 = ins->data.op[1].phi_args;
      D.23505 = (long unsigned int) j;
      D.23506 = D.23505 * 4;
      D.23507 = D.23504 + D.23506;
      D.23508 = *D.23507;
      D.23509 = (unsigned int) D.23508;
      D.23492 = cfg->vreg_to_inst_len;
      if (D.23509 < D.23492) goto <D.23510>; else goto <D.23511>;
      <D.23510>:
      D.23495 = cfg->vreg_to_inst;
      D.23504 = ins->data.op[1].phi_args;
      D.23505 = (long unsigned int) j;
      D.23506 = D.23505 * 4;
      D.23507 = D.23504 + D.23506;
      D.23508 = *D.23507;
      D.23512 = (long unsigned int) D.23508;
      D.23513 = D.23512 * 8;
      D.23514 = D.23495 + D.23513;
      iftmp.30 = *D.23514;
      goto <D.23515>;
      <D.23511>:
      iftmp.30 = 0B;
      <D.23515>:
      var = iftmp.30;
      D.23488 = cfg->vars;
      D.23516 = var->data.op[0].const_val;
      D.23517 = (long unsigned int) D.23516;
      D.23518 = D.23517 * 80;
      mv = D.23488 + D.23518;
      src = mv->def;
      D.23519 = mv->def_bb;
      if (D.23519 != 0B) goto <D.23520>; else goto <D.23521>;
      <D.23520>:
      D.23519 = mv->def_bb;
      D.23522 = D.23519->flags;
      D.23523 = D.23522 & 2;
      if (D.23523 == 0) goto <D.23524>; else goto <D.23525>;
      <D.23524>:
      // predicted unlikely by continue predictor.
      goto <D.22467>;
      <D.23525>:
      <D.23521>:
      D.23528 = mv->def;
      if (D.23528 == 0B) goto <D.23526>; else goto <D.23529>;
      <D.23529>:
      if (src == 0B) goto <D.23526>; else goto <D.23530>;
      <D.23530>:
      D.23531 = mv->cpstate;
      if (D.23531 == 2) goto <D.23526>; else goto <D.23527>;
      <D.23526>:
      change_varstate (cfg, cvars, info, 2, 0B, carray);
      goto <D.22468>;
      <D.23527>:
      D.23531 = mv->cpstate;
      if (D.23531 == 0) goto <D.23532>; else goto <D.23533>;
      <D.23532>:
      // predicted unlikely by continue predictor.
      goto <D.22467>;
      <D.23533>:
      D.23534 = var->dreg;
      D.23535 = (long unsigned int) D.23534;
      D.23536 = D.23535 * 8;
      D.23537 = carray + D.23536;
      D.23538 = *D.23537;
      D.23539 = D.23538 == 0B;
      D.23540 = (long int) D.23539;
      D.23541 = __builtin_expect (D.23540, 0);
      if (D.23541 != 0) goto <D.23542>; else goto <D.23543>;
      <D.23542>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 873, "carray [var->dreg]");
      <D.23543>:
      if (c0 == 0B) goto <D.23544>; else goto <D.23545>;
      <D.23544>:
      D.23534 = var->dreg;
      D.23535 = (long unsigned int) D.23534;
      D.23536 = D.23535 * 8;
      D.23537 = carray + D.23536;
      c0 = *D.23537;
      <D.23545>:
      D.23546 = c0->opcode;
      if (D.23546 != 362) goto <D.23547>; else goto <D.23548>;
      <D.23547>:
      change_varstate (cfg, cvars, info, 2, 0B, carray);
      goto <D.22468>;
      <D.23548>:
      D.23534 = var->dreg;
      D.23535 = (long unsigned int) D.23534;
      D.23536 = D.23535 * 8;
      D.23537 = carray + D.23536;
      D.23538 = *D.23537;
      D.23549 = D.23538->data.op[0].const_val;
      D.23550 = c0->data.op[0].const_val;
      if (D.23549 != D.23550) goto <D.23551>; else goto <D.23552>;
      <D.23551>:
      change_varstate (cfg, cvars, info, 2, 0B, carray);
      goto <D.22468>;
      <D.23552>:
    }
    <D.22467>:
    j = j + 1;
    <D.22470>:
    D.23504 = ins->data.op[1].phi_args;
    D.23553 = *D.23504;
    if (D.23553 >= j) goto <D.22469>; else goto <D.22468>;
    <D.22468>:
    if (c0 != 0B) goto <D.23554>; else goto <D.23555>;
    <D.23554>:
    D.23556 = info->cpstate;
    if (D.23556 == 0) goto <D.23557>; else goto <D.23558>;
    <D.23557>:
    change_varstate (cfg, cvars, info, 1, c0, carray);
    D.23546 = c0->opcode;
    D.23559 = D.23546 != 362;
    D.23560 = (long int) D.23559;
    D.23561 = __builtin_expect (D.23560, 0);
    if (D.23561 != 0) goto <D.23562>; else goto <D.23563>;
    <D.23562>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 893, "c0->opcode == OP_ICONST");
    <D.23563>:
    <D.23558>:
    <D.23555>:
  }
  goto <D.23564>;
  <D.23487>:
  D.23476 = ins->opcode;
  D.23568 = D.23476 + 65162;
  if (D.23568 > 13) goto <D.23569>; else goto <D.23565>;
  <D.23569>:
  D.23570 = spec + 1;
  D.23571 = *D.23570;
  if (D.23571 != 32) goto <D.23566>; else goto <D.23572>;
  <D.23572>:
  D.23573 = spec + 2;
  D.23574 = *D.23573;
  if (D.23574 != 32) goto <D.23566>; else goto <D.23575>;
  <D.23575>:
  D.23576 = *spec;
  if (D.23576 != 32) goto <D.23566>; else goto <D.23565>;
  <D.23566>:
  {
    struct MonoInst * var;
    struct MonoInst * c0;
    int state;

    try
      {
        D.23576 = *spec;
        if (D.23576 != 32) goto <D.23577>; else goto <D.23578>;
        <D.23577>:
        D.23490 = ins->dreg;
        D.23491 = (unsigned int) D.23490;
        D.23492 = cfg->vreg_to_inst_len;
        if (D.23491 < D.23492) goto <D.23580>; else goto <D.23581>;
        <D.23580>:
        D.23495 = cfg->vreg_to_inst;
        D.23490 = ins->dreg;
        D.23496 = (long unsigned int) D.23490;
        D.23497 = D.23496 * 8;
        D.23498 = D.23495 + D.23497;
        iftmp.31 = *D.23498;
        goto <D.23582>;
        <D.23581>:
        iftmp.31 = 0B;
        <D.23582>:
        var = iftmp.31;
        goto <D.23583>;
        <D.23578>:
        var = 0B;
        <D.23583>:
        c0 = 0B;
        state = evaluate_ins (cfg, ins, &c0, carray);
        if (var != 0B) goto <D.23586>; else goto <D.23584>;
        <D.23586>:
        D.23587 = var->flags;
        D.23588 = (int) D.23587;
        D.23589 = D.23588 & 20;
        if (D.23589 == 0) goto <D.23590>; else goto <D.23584>;
        <D.23590>:
        {
          struct MonoMethodVar * info;

          D.23488 = cfg->vars;
          D.23591 = var->data.op[0].const_val;
          D.23592 = (long unsigned int) D.23591;
          D.23593 = D.23592 * 80;
          info = D.23488 + D.23593;
          D.23594 = info->cpstate;
          if (D.23594 <= 1) goto <D.23595>; else goto <D.23596>;
          <D.23595>:
          if (state == 1) goto <D.23597>; else goto <D.23598>;
          <D.23597>:
          c0.32 = c0;
          change_varstate (cfg, cvars, info, 1, c0.32, carray);
          goto <D.23600>;
          <D.23598>:
          if (state == 2) goto <D.23601>; else goto <D.23602>;
          <D.23601>:
          change_varstate (cfg, cvars, info, 2, 0B, carray);
          <D.23602>:
          <D.23600>:
          <D.23596>:
        }
        goto <D.23585>;
        <D.23584>:
        if (var == 0B) goto <D.23603>; else goto <D.23604>;
        <D.23603>:
        D.23490 = ins->dreg;
        if (D.23490 != -1) goto <D.23605>; else goto <D.23606>;
        <D.23605>:
        c0.32 = c0;
        if (c0.32 != 0B) goto <D.23607>; else goto <D.23608>;
        <D.23607>:
        D.23490 = ins->dreg;
        D.23496 = (long unsigned int) D.23490;
        D.23497 = D.23496 * 8;
        D.23609 = carray + D.23497;
        c0.32 = c0;
        *D.23609 = c0.32;
        goto <D.23610>;
        <D.23608>:
        D.23490 = ins->dreg;
        D.23496 = (long unsigned int) D.23490;
        D.23497 = D.23496 * 8;
        D.23609 = carray + D.23497;
        D.23611 = *D.23609;
        if (D.23611 != 0B) goto <D.23612>; else goto <D.23613>;
        <D.23612>:
        D.23490 = ins->dreg;
        D.23496 = (long unsigned int) D.23490;
        D.23497 = D.23496 * 8;
        D.23609 = carray + D.23497;
        *D.23609 = 0B;
        D.23614 = *bblist;
        D.23615 = monoeg_g_list_find (D.23614, bb);
        if (D.23615 == 0B) goto <D.23616>; else goto <D.23617>;
        <D.23616>:
        D.23614 = *bblist;
        D.23618 = monoeg_g_list_prepend (D.23614, bb);
        *bblist = D.23618;
        <D.23617>:
        <D.23613>:
        <D.23610>:
        <D.23606>:
        <D.23604>:
        <D.23585>:
        D.23476 = ins->opcode;
        if (D.23476 == 731) goto <D.23619>; else goto <D.23622>;
        <D.23622>:
        D.23476 = ins->opcode;
        if (D.23476 == 732) goto <D.23623>; else goto <D.23620>;
        <D.23623>:
        D.23624 = ins->data.op[1].src;
        if (D.23624 == 8B) goto <D.23619>; else goto <D.23620>;
        <D.23620>:
        D.23476 = ins->opcode;
        if (D.23476 == 370) goto <D.23619>; else goto <D.23625>;
        <D.23625>:
        D.23476 = ins->opcode;
        if (D.23476 == 734) goto <D.23626>; else goto <D.23621>;
        <D.23626>:
        D.23624 = ins->data.op[1].src;
        D.23627 = D.23624->data.op[1].src;
        if (D.23627 == 8B) goto <D.23619>; else goto <D.23621>;
        <D.23619>:
        {
          int i;
          struct MonoJumpInfoBBTable * table;

          D.23476 = ins->opcode;
          if (D.23476 == 731) goto <D.23629>; else goto <D.23630>;
          <D.23629>:
          iftmp.33 = ins->data.op[0].p;
          goto <D.23631>;
          <D.23630>:
          D.23476 = ins->opcode;
          if (D.23476 == 732) goto <D.23635>; else goto <D.23633>;
          <D.23635>:
          D.23624 = ins->data.op[1].src;
          if (D.23624 == 8B) goto <D.23636>; else goto <D.23633>;
          <D.23636>:
          iftmp.34 = ins->data.op[0].p;
          goto <D.23634>;
          <D.23633>:
          D.23476 = ins->opcode;
          if (D.23476 == 370) goto <D.23638>; else goto <D.23639>;
          <D.23638>:
          iftmp.35 = ins->data.op[0].p;
          goto <D.23640>;
          <D.23639>:
          D.23476 = ins->opcode;
          if (D.23476 == 734) goto <D.23644>; else goto <D.23642>;
          <D.23644>:
          D.23624 = ins->data.op[1].src;
          D.23627 = D.23624->data.op[1].src;
          if (D.23627 == 8B) goto <D.23645>; else goto <D.23642>;
          <D.23645>:
          D.23624 = ins->data.op[1].src;
          iftmp.36 = D.23624->data.op[0].p;
          goto <D.23643>;
          <D.23642>:
          iftmp.36 = 0B;
          <D.23643>:
          iftmp.35 = iftmp.36;
          <D.23640>:
          iftmp.34 = iftmp.35;
          <D.23634>:
          iftmp.33 = iftmp.34;
          <D.23631>:
          table = iftmp.33;
          D.23648 = ins->next;
          if (D.23648 == 0B) goto <D.23646>; else goto <D.23649>;
          <D.23649>:
          D.23648 = ins->next;
          D.23650 = D.23648->opcode;
          if (D.23650 != 479) goto <D.23646>; else goto <D.23647>;
          <D.23646>:
          i = 0;
          goto <D.22478>;
          <D.22477>:
          D.23651 = table->table;
          D.23652 = (long unsigned int) i;
          D.23653 = D.23652 * 8;
          D.23654 = D.23651 + D.23653;
          D.23655 = *D.23654;
          if (D.23655 != 0B) goto <D.23656>; else goto <D.23657>;
          <D.23656>:
          D.23651 = table->table;
          D.23652 = (long unsigned int) i;
          D.23653 = D.23652 * 8;
          D.23654 = D.23651 + D.23653;
          D.23655 = *D.23654;
          add_cprop_bb (cfg, D.23655, bblist);
          <D.23657>:
          i = i + 1;
          <D.22478>:
          D.23658 = table->table_size;
          if (D.23658 > i) goto <D.22477>; else goto <D.22479>;
          <D.22479>:
          return;
          <D.23647>:
          D.23648 = ins->next;
          D.23650 = D.23648->opcode;
          D.23659 = D.23650 != 479;
          D.23660 = (long int) D.23659;
          D.23661 = __builtin_expect (D.23660, 0);
          if (D.23661 != 0) goto <D.23662>; else goto <D.23663>;
          <D.23662>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 955, "ins->next->opcode == OP_PADD");
          <D.23663>:
          D.23648 = ins->next;
          D.23664 = D.23648->sreg1;
          D.23490 = ins->dreg;
          D.23665 = D.23664 != D.23490;
          D.23666 = (long int) D.23665;
          D.23667 = __builtin_expect (D.23666, 0);
          if (D.23667 != 0) goto <D.23668>; else goto <D.23669>;
          <D.23668>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 956, "ins->next->sreg1 == ins->dreg");
          <D.23669>:
          D.23648 = ins->next;
          D.23670 = D.23648->sreg2;
          D.23671 = (long unsigned int) D.23670;
          D.23672 = D.23671 * 8;
          D.23673 = carray + D.23672;
          D.23674 = *D.23673;
          if (D.23674 != 0B) goto <D.23675>; else goto <D.23676>;
          <D.23675>:
          {
            int idx;

            D.23648 = ins->next;
            D.23670 = D.23648->sreg2;
            D.23671 = (long unsigned int) D.23670;
            D.23672 = D.23671 * 8;
            D.23673 = carray + D.23672;
            D.23674 = *D.23673;
            D.23677 = D.23674->data.op[0].const_val;
            D.23678 = D.23677 >> 3;
            idx = (int) D.23678;
            if (idx < 0) goto <D.23679>; else goto <D.23681>;
            <D.23681>:
            D.23658 = table->table_size;
            if (D.23658 <= idx) goto <D.23679>; else goto <D.23680>;
            <D.23679>:
            return;
            <D.23680>:
            D.23651 = table->table;
            D.23682 = (long unsigned int) idx;
            D.23683 = D.23682 * 8;
            D.23684 = D.23651 + D.23683;
            D.23685 = *D.23684;
            if (D.23685 != 0B) goto <D.23686>; else goto <D.23687>;
            <D.23686>:
            D.23651 = table->table;
            D.23682 = (long unsigned int) idx;
            D.23683 = D.23682 * 8;
            D.23684 = D.23651 + D.23683;
            D.23685 = *D.23684;
            add_cprop_bb (cfg, D.23685, bblist);
            <D.23687>:
          }
          goto <D.23688>;
          <D.23676>:
          i = 0;
          goto <D.22482>;
          <D.22481>:
          D.23651 = table->table;
          D.23652 = (long unsigned int) i;
          D.23653 = D.23652 * 8;
          D.23654 = D.23651 + D.23653;
          D.23655 = *D.23654;
          if (D.23655 != 0B) goto <D.23689>; else goto <D.23690>;
          <D.23689>:
          D.23651 = table->table;
          D.23652 = (long unsigned int) i;
          D.23653 = D.23652 * 8;
          D.23654 = D.23651 + D.23653;
          D.23655 = *D.23654;
          add_cprop_bb (cfg, D.23655, bblist);
          <D.23690>:
          i = i + 1;
          <D.22482>:
          D.23658 = table->table_size;
          if (D.23658 > i) goto <D.22481>; else goto <D.22483>;
          <D.22483>:
          <D.23688>:
        }
        <D.23621>:
        D.23476 = ins->opcode;
        if (D.23476 == 370) goto <D.23691>; else goto <D.23692>;
        <D.23691>:
        {
          int i;
          struct MonoJumpInfoBBTable * table;

          table = ins->data.op[0].p;
          i = 0;
          goto <D.22487>;
          <D.22486>:
          D.23693 = table->table;
          D.23694 = (long unsigned int) i;
          D.23695 = D.23694 * 8;
          D.23696 = D.23693 + D.23695;
          D.23697 = *D.23696;
          if (D.23697 != 0B) goto <D.23698>; else goto <D.23699>;
          <D.23698>:
          D.23693 = table->table;
          D.23694 = (long unsigned int) i;
          D.23695 = D.23694 * 8;
          D.23696 = D.23693 + D.23695;
          D.23697 = *D.23696;
          add_cprop_bb (cfg, D.23697, bblist);
          <D.23699>:
          i = i + 1;
          <D.22487>:
          D.23700 = table->table_size;
          if (D.23700 > i) goto <D.22486>; else goto <D.22488>;
          <D.22488>:
        }
        <D.23692>:
        D.23648 = ins->next;
        if (D.23648 != 0B) goto <D.23703>; else goto <D.23704>;
        <D.23703>:
        D.23648 = ins->next;
        D.23650 = D.23648->opcode;
        D.23705 = D.23650 + 64985;
        if (D.23705 <= 9) goto <D.23701>; else goto <D.23706>;
        <D.23706>:
        D.23648 = ins->next;
        D.23650 = D.23648->opcode;
        D.23707 = D.23650 + 64878;
        if (D.23707 <= 9) goto <D.23701>; else goto <D.23708>;
        <D.23708>:
        D.23648 = ins->next;
        D.23650 = D.23648->opcode;
        D.23709 = D.23650 + 64888;
        if (D.23709 <= 9) goto <D.23701>; else goto <D.23702>;
        <D.23701>:
        c0.32 = c0;
        if (c0.32 != 0B) goto <D.23710>; else goto <D.23711>;
        <D.23710>:
        c0.32 = c0;
        D.23712 = c0.32->opcode;
        D.23713 = D.23712 != 362;
        D.23714 = (long int) D.23713;
        D.23715 = __builtin_expect (D.23714, 0);
        if (D.23715 != 0) goto <D.23716>; else goto <D.23717>;
        <D.23716>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 990, "c0->opcode == OP_ICONST");
        <D.23717>:
        c0.32 = c0;
        D.23718 = c0.32->data.op[0].const_val;
        if (D.23718 != 0) goto <D.23719>; else goto <D.23720>;
        <D.23719>:
        D.23648 = ins->next;
        D.23648 = ins->next;
        D.23721 = D.23648->flags;
        D.23722 = D.23721 | 8;
        D.23648->flags = D.23722;
        goto <D.23723>;
        <D.23720>:
        D.23648 = ins->next;
        D.23648 = ins->next;
        D.23721 = D.23648->flags;
        D.23724 = D.23721 | 16;
        D.23648->flags = D.23724;
        <D.23723>:
        goto <D.23725>;
        <D.23711>:
        D.23648 = ins->next;
        D.23648 = ins->next;
        D.23721 = D.23648->flags;
        D.23726 = D.23721 & 231;
        D.23648->flags = D.23726;
        <D.23725>:
        D.23648 = ins->next;
        visit_inst (cfg, bb, D.23648, cvars, bblist, carray);
        <D.23702>:
        <D.23704>:
      }
    finally
      {
        c0 = {CLOBBER};
      }
  }
  goto <D.23567>;
  <D.23565>:
  D.23476 = ins->opcode;
  if (D.23476 == 442) goto <D.23727>; else goto <D.23728>;
  <D.23727>:
  D.23729 = ins->data.op[0].target_block;
  add_cprop_bb (cfg, D.23729, bblist);
  goto <D.23730>;
  <D.23728>:
  D.23476 = ins->opcode;
  D.23733 = D.23476 + 64985;
  if (D.23733 <= 9) goto <D.23731>; else goto <D.23734>;
  <D.23734>:
  D.23476 = ins->opcode;
  D.23735 = D.23476 + 64878;
  if (D.23735 <= 9) goto <D.23731>; else goto <D.23736>;
  <D.23736>:
  D.23476 = ins->opcode;
  D.23737 = D.23476 + 64888;
  if (D.23737 <= 9) goto <D.23731>; else goto <D.23732>;
  <D.23731>:
  D.23738 = ins->flags;
  D.23739 = (int) D.23738;
  D.23740 = D.23739 & 8;
  if (D.23740 != 0) goto <D.23741>; else goto <D.23742>;
  <D.23741>:
  D.23743 = ins->data.op[1].many_blocks;
  D.23744 = *D.23743;
  add_cprop_bb (cfg, D.23744, bblist);
  goto <D.23745>;
  <D.23742>:
  D.23738 = ins->flags;
  D.23739 = (int) D.23738;
  D.23746 = D.23739 & 16;
  if (D.23746 != 0) goto <D.23747>; else goto <D.23748>;
  <D.23747>:
  D.23743 = ins->data.op[1].many_blocks;
  D.23749 = D.23743 + 8;
  D.23750 = *D.23749;
  if (D.23750 != 0B) goto <D.23751>; else goto <D.23752>;
  <D.23751>:
  D.23743 = ins->data.op[1].many_blocks;
  D.23749 = D.23743 + 8;
  D.23750 = *D.23749;
  add_cprop_bb (cfg, D.23750, bblist);
  <D.23752>:
  goto <D.23753>;
  <D.23748>:
  D.23743 = ins->data.op[1].many_blocks;
  D.23744 = *D.23743;
  add_cprop_bb (cfg, D.23744, bblist);
  D.23743 = ins->data.op[1].many_blocks;
  D.23749 = D.23743 + 8;
  D.23750 = *D.23749;
  if (D.23750 != 0B) goto <D.23754>; else goto <D.23755>;
  <D.23754>:
  D.23743 = ins->data.op[1].many_blocks;
  D.23749 = D.23743 + 8;
  D.23750 = *D.23749;
  add_cprop_bb (cfg, D.23750, bblist);
  <D.23755>:
  <D.23753>:
  <D.23745>:
  <D.23732>:
  <D.23730>:
  <D.23567>:
  <D.23564>:
}


evaluate_ins (struct MonoCompile * cfg, struct MonoInst * ins, struct MonoInst * * res, struct MonoInst * * carray)
{
  short unsigned int D.23759;
  int D.23760;
  int D.23761;
  int D.23762;
  int D.23765;
  int D.23768;
  int D.23769;
  int D.23770;
  signed char D.23771;
  struct MonoInst * iftmp.37;
  int D.23773;
  unsigned int D.23774;
  unsigned int D.23775;
  struct MonoInst * * D.23778;
  long unsigned int D.23779;
  long unsigned int D.23780;
  struct MonoInst * * D.23781;
  struct MonoInst * * D.23783;
  struct MonoInst * D.23784;
  struct MonoInst * D.23785;
  unsigned char D.23791;
  int D.23792;
  int D.23793;
  struct MonoMethodVar * D.23796;
  long int D.23797;
  long unsigned int D.23798;
  long unsigned int D.23799;
  struct MonoMethodVar * D.23800;
  char D.23801;
  int D.23802;
  int D.23803;
  _Bool D.23810;
  long int D.23811;
  long int D.23812;
  char D.23815;
  int D.23818;
  long unsigned int D.23819;
  long unsigned int D.23820;
  struct MonoInst * * D.23821;
  struct MonoInst * D.23822;
  struct MonoInst * D.23825;
  struct MonoInst * D.23826;
  unsigned int D.23829;
  _Bool D.23830;
  long int D.23831;
  long int D.23832;
  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.23759 = ins->opcode;
      D.23760 = (int) D.23759;
      D.23761 = D.23760 + -313;
      D.23762 = D.23761 * 4;
      spec = &ins_info[D.23762];
      D.23759 = ins->opcode;
      if (D.23759 == 362) goto <D.23763>; else goto <D.23764>;
      <D.23763>:
      *res = ins;
      D.23765 = 1;
      return D.23765;
      <D.23764>:
      D.23759 = ins->opcode;
      if (D.23759 == 316) goto <D.23766>; else goto <D.23767>;
      <D.23766>:
      D.23765 = 2;
      return D.23765;
      <D.23767>:
      D.23768 = ins->sreg1;
      sregs[0] = D.23768;
      D.23769 = ins->sreg2;
      sregs[1] = D.23769;
      D.23770 = ins->sreg3;
      sregs[2] = D.23770;
      D.23759 = ins->opcode;
      D.23760 = (int) D.23759;
      D.23761 = D.23760 + -313;
      D.23771 = ins_sreg_counts[D.23761];
      num_sregs = (int) D.23771;
      i = 0;
      goto <D.22430>;
      <D.22429>:
      args[i] = 0B;
      i = i + 1;
      <D.22430>:
      if (i <= 2) goto <D.22429>; else goto <D.22431>;
      <D.22431>:
      i = 0;
      goto <D.22434>;
      <D.22433>:
      {
        struct MonoInst * var;

        D.23773 = sregs[i];
        D.23774 = (unsigned int) D.23773;
        D.23775 = cfg->vreg_to_inst_len;
        if (D.23774 < D.23775) goto <D.23776>; else goto <D.23777>;
        <D.23776>:
        D.23778 = cfg->vreg_to_inst;
        D.23773 = sregs[i];
        D.23779 = (long unsigned int) D.23773;
        D.23780 = D.23779 * 8;
        D.23781 = D.23778 + D.23780;
        iftmp.37 = *D.23781;
        goto <D.23782>;
        <D.23777>:
        iftmp.37 = 0B;
        <D.23782>:
        var = iftmp.37;
        rs[i] = 2;
        D.23773 = sregs[i];
        D.23779 = (long unsigned int) D.23773;
        D.23780 = D.23779 * 8;
        D.23783 = carray + D.23780;
        D.23784 = *D.23783;
        args[i] = D.23784;
        D.23785 = args[i];
        if (D.23785 != 0B) goto <D.23786>; else goto <D.23787>;
        <D.23786>:
        rs[i] = 1;
        goto <D.23788>;
        <D.23787>:
        if (var != 0B) goto <D.23789>; else goto <D.23790>;
        <D.23789>:
        D.23791 = var->flags;
        D.23792 = (int) D.23791;
        D.23793 = D.23792 & 20;
        if (D.23793 == 0) goto <D.23794>; else goto <D.23795>;
        <D.23794>:
        D.23796 = cfg->vars;
        D.23797 = var->data.op[0].const_val;
        D.23798 = (long unsigned int) D.23797;
        D.23799 = D.23798 * 80;
        D.23800 = D.23796 + D.23799;
        D.23801 = D.23800->cpstate;
        D.23802 = (int) D.23801;
        rs[i] = D.23802;
        <D.23795>:
        <D.23790>:
        <D.23788>:
        D.23803 = rs[i];
        if (D.23803 != 1) goto <D.23804>; else goto <D.23805>;
        <D.23804>:
        const_args = 0;
        <D.23805>:
      }
      i = i + 1;
      <D.22434>:
      if (i < num_sregs) goto <D.22433>; else goto <D.22435>;
      <D.22435>:
      c0 = 0B;
      if (num_sregs > 0) goto <D.23806>; else goto <D.23807>;
      <D.23806>:
      if (const_args != 0) goto <D.23808>; else goto <D.23809>;
      <D.23808>:
      D.23810 = num_sregs > 2;
      D.23811 = (long int) D.23810;
      D.23812 = __builtin_expect (D.23811, 0);
      if (D.23812 != 0) goto <D.23813>; else goto <D.23814>;
      <D.23813>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 776, "num_sregs <= 2");
      <D.23814>:
      D.23815 = *spec;
      if (D.23815 != 32) goto <D.23816>; else goto <D.23817>;
      <D.23816>:
      D.23818 = ins->dreg;
      D.23819 = (long unsigned int) D.23818;
      D.23820 = D.23819 * 8;
      D.23821 = carray + D.23820;
      D.23822 = *D.23821;
      if (D.23822 != 0B) goto <D.23823>; else goto <D.23824>;
      <D.23823>:
      D.23818 = ins->dreg;
      D.23819 = (long unsigned int) D.23818;
      D.23820 = D.23819 * 8;
      D.23821 = carray + D.23820;
      D.23822 = *D.23821;
      *res = D.23822;
      D.23765 = 1;
      return D.23765;
      <D.23824>:
      <D.23817>:
      D.23825 = args[0];
      D.23826 = args[1];
      c0 = mono_constant_fold_ins (cfg, ins, D.23825, D.23826, 0);
      if (c0 != 0B) goto <D.23827>; else goto <D.23828>;
      <D.23827>:
      D.23829 = cfg->verbose_level;
      D.23830 = D.23829 > 1;
      D.23831 = (long int) D.23830;
      D.23832 = __builtin_expect (D.23831, 0);
      if (D.23832 != 0) goto <D.23833>; else goto <D.23834>;
      <D.23833>:
      printf ("\t cfold -> ");
      mono_print_ins (c0);
      <D.23834>:
      *res = c0;
      D.23765 = 1;
      return D.23765;
      <D.23828>:
      D.23765 = 2;
      return D.23765;
      <D.23809>:
      <D.23807>:
      if (num_sregs == 0) goto <D.23835>; else goto <D.23836>;
      <D.23835>:
      D.23765 = 2;
      return D.23765;
      <D.23836>:
      i = 0;
      goto <D.22437>;
      <D.22436>:
      D.23803 = rs[i];
      if (D.23803 == 2) goto <D.23837>; else goto <D.23838>;
      <D.23837>:
      D.23765 = 2;
      return D.23765;
      <D.23838>:
      i = i + 1;
      <D.22437>:
      if (i < num_sregs) goto <D.22436>; else goto <D.22438>;
      <D.22438>:
      D.23765 = 0;
      return D.23765;
    }
  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.23841;
  int D.23842;
  char D.23845;
  unsigned int D.23846;
  _Bool D.23847;
  long int D.23848;
  long int D.23849;
  struct MonoInst * * D.23852;
  unsigned int D.23853;
  long unsigned int D.23854;
  long unsigned int D.23855;
  struct MonoInst * * D.23856;
  struct MonoInst * D.23857;
  int D.23858;
  _Bool D.23861;
  long int D.23862;
  long int D.23863;
  long unsigned int D.23866;
  long unsigned int D.23867;
  struct MonoInst * * D.23868;
  struct GList * D.23869;
  struct GList * D.23870;
  struct GList * D.23873;

  D.23841 = info->cpstate;
  D.23842 = (int) D.23841;
  if (D.23842 >= state) goto <D.23843>; else goto <D.23844>;
  <D.23843>:
  return;
  <D.23844>:
  D.23845 = (char) state;
  info->cpstate = D.23845;
  D.23846 = cfg->verbose_level;
  D.23847 = D.23846 > 1;
  D.23848 = (long int) D.23847;
  D.23849 = __builtin_expect (D.23848, 0);
  if (D.23849 != 0) goto <D.23850>; else goto <D.23851>;
  <D.23850>:
  D.23852 = cfg->varinfo;
  D.23853 = info->idx;
  D.23854 = (long unsigned int) D.23853;
  D.23855 = D.23854 * 8;
  D.23856 = D.23852 + D.23855;
  D.23857 = *D.23856;
  D.23858 = D.23857->dreg;
  D.23841 = info->cpstate;
  D.23842 = (int) D.23841;
  printf ("\tState of R%d set to %d\n", D.23858, D.23842);
  <D.23851>:
  if (state == 1) goto <D.23859>; else goto <D.23860>;
  <D.23859>:
  D.23861 = c0 == 0B;
  D.23862 = (long int) D.23861;
  D.23863 = __builtin_expect (D.23862, 0);
  if (D.23863 != 0) goto <D.23864>; else goto <D.23865>;
  <D.23864>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 817, "c0");
  <D.23865>:
  <D.23860>:
  D.23852 = cfg->varinfo;
  D.23853 = info->idx;
  D.23854 = (long unsigned int) D.23853;
  D.23855 = D.23854 * 8;
  D.23856 = D.23852 + D.23855;
  D.23857 = *D.23856;
  D.23858 = D.23857->dreg;
  D.23866 = (long unsigned int) D.23858;
  D.23867 = D.23866 * 8;
  D.23868 = carray + D.23867;
  *D.23868 = c0;
  D.23869 = *cvars;
  D.23870 = monoeg_g_list_find (D.23869, info);
  if (D.23870 == 0B) goto <D.23871>; else goto <D.23872>;
  <D.23871>:
  D.23869 = *cvars;
  D.23873 = monoeg_g_list_prepend (D.23869, info);
  *cvars = D.23873;
  <D.23872>:
}


fold_ins (struct MonoCompile * cfg, struct MonoBasicBlock * bb, struct MonoInst * ins, struct MonoInst * * carray)
{
  short unsigned int D.23875;
  int D.23876;
  int D.23877;
  int D.23878;
  signed char D.23879;
  int D.23883;
  short unsigned int D.23885;
  long unsigned int D.23889;
  long unsigned int D.23890;
  struct MonoInst * * D.23891;
  struct MonoInst * D.23892;
  char D.23894;
  short unsigned int D.23897;
  _Bool D.23898;
  long int D.23899;
  long int D.23900;
  long int D.23903;
  int D.23904;
  int D.23905;
  long unsigned int D.23908;
  long unsigned int D.23909;
  struct MonoInst * * D.23910;
  struct MonoInst * D.23911;
  short unsigned int D.23916;
  long int D.23917;
  long int D.23923;
  const void * D.23924;
  struct MonoInst * D.23931;
  struct MonoInst * D.23934;
  struct MonoJumpInfoBBTable * iftmp.38;
  struct MonoJumpInfoBBTable * iftmp.39;
  struct MonoJumpInfoBBTable * iftmp.40;
  struct MonoJumpInfoBBTable * iftmp.41;
  struct MonoInst * D.23955;
  short unsigned int D.23957;
  _Bool D.23958;
  long int D.23959;
  long int D.23960;
  int D.23963;
  _Bool D.23964;
  long int D.23965;
  long int D.23966;
  struct MonoInst * D.23969;
  short unsigned int D.23970;
  _Bool D.23971;
  long int D.23972;
  long int D.23973;
  int D.23976;
  long unsigned int D.23977;
  long unsigned int D.23978;
  struct MonoInst * * D.23979;
  struct MonoInst * D.23980;
  long int D.23983;
  long int D.23984;
  int D.23988;
  struct MonoBasicBlock * * D.23989;
  long unsigned int D.23990;
  long unsigned int D.23991;
  struct MonoBasicBlock * * D.23992;
  struct MonoBasicBlock * D.23993;
  int D.23994;
  int D.23995;
  int D.23996;
  struct MonoInst * D.23997;
  int D.24000;
  int D.24001;
  short unsigned int D.24005;
  unsigned int D.24006;
  _Bool D.24007;
  long int D.24008;
  long int D.24009;
  long unsigned int D.24014;
  long unsigned int D.24015;
  struct MonoBasicBlock * * D.24016;
  struct MonoBasicBlock * D.24017;
  short unsigned int D.24022;
  short unsigned int D.24024;
  short unsigned int D.24026;
  unsigned char D.24027;
  int D.24028;
  int D.24029;
  struct MonoBasicBlock * * D.24032;
  struct MonoBasicBlock * * D.24033;
  struct MonoBasicBlock * D.24034;
  struct MonoBasicBlock * D.24035;
  int D.24037;
  struct MonoBasicBlock * D.24040;
  const char * spec;
  int opcode2;
  int num_sregs;

  D.23875 = ins->opcode;
  D.23876 = (int) D.23875;
  D.23877 = D.23876 + -313;
  D.23878 = D.23877 * 4;
  spec = &ins_info[D.23878];
  D.23875 = ins->opcode;
  D.23876 = (int) D.23875;
  D.23877 = D.23876 + -313;
  D.23879 = ins_sreg_counts[D.23877];
  num_sregs = (int) D.23879;
  D.23875 = ins->opcode;
  if (D.23875 != 316) goto <D.23882>; else goto <D.23880>;
  <D.23882>:
  D.23883 = ins->dreg;
  if (D.23883 != -1) goto <D.23884>; else goto <D.23880>;
  <D.23884>:
  D.23875 = ins->opcode;
  D.23885 = D.23875 + 65162;
  if (D.23885 > 13) goto <D.23886>; else goto <D.23880>;
  <D.23886>:
  D.23883 = ins->dreg;
  D.23889 = (long unsigned int) D.23883;
  D.23890 = D.23889 * 8;
  D.23891 = carray + D.23890;
  D.23892 = *D.23891;
  if (D.23892 != 0B) goto <D.23893>; else goto <D.23887>;
  <D.23893>:
  D.23894 = *spec;
  if (D.23894 == 105) goto <D.23895>; else goto <D.23887>;
  <D.23895>:
  D.23883 = ins->dreg;
  if (D.23883 > 15) goto <D.23896>; else goto <D.23887>;
  <D.23896>:
  D.23883 = ins->dreg;
  D.23889 = (long unsigned int) D.23883;
  D.23890 = D.23889 * 8;
  D.23891 = carray + D.23890;
  D.23892 = *D.23891;
  D.23897 = D.23892->opcode;
  D.23898 = D.23897 != 362;
  D.23899 = (long int) D.23898;
  D.23900 = __builtin_expect (D.23899, 0);
  if (D.23900 != 0) goto <D.23901>; else goto <D.23902>;
  <D.23901>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 1035, "carray [ins->dreg]->opcode == OP_ICONST");
  <D.23902>:
  ins->opcode = 362;
  D.23883 = ins->dreg;
  D.23889 = (long unsigned int) D.23883;
  D.23890 = D.23889 * 8;
  D.23891 = carray + D.23890;
  D.23892 = *D.23891;
  D.23903 = D.23892->data.op[0].const_val;
  ins->data.op[0].const_val = D.23903;
  ins->sreg3 = -1;
  D.23904 = ins->sreg3;
  ins->sreg2 = D.23904;
  D.23905 = ins->sreg2;
  ins->sreg1 = D.23905;
  goto <D.23888>;
  <D.23887>:
  if (num_sregs == 2) goto <D.23906>; else goto <D.23907>;
  <D.23906>:
  D.23905 = ins->sreg2;
  D.23908 = (long unsigned int) D.23905;
  D.23909 = D.23908 * 8;
  D.23910 = carray + D.23909;
  D.23911 = *D.23910;
  if (D.23911 != 0B) goto <D.23912>; else goto <D.23913>;
  <D.23912>:
  D.23875 = ins->opcode;
  D.23876 = (int) D.23875;
  opcode2 = mono_op_to_op_imm (D.23876);
  if (opcode2 != -1) goto <D.23914>; else goto <D.23915>;
  <D.23914>:
  D.23916 = (short unsigned int) opcode2;
  ins->opcode = D.23916;
  D.23905 = ins->sreg2;
  D.23908 = (long unsigned int) D.23905;
  D.23909 = D.23908 * 8;
  D.23910 = carray + D.23909;
  D.23911 = *D.23910;
  D.23917 = D.23911->data.op[0].const_val;
  ins->data.op[1].const_val = D.23917;
  ins->sreg2 = -1;
  if (opcode2 == 343) goto <D.23918>; else goto <D.23920>;
  <D.23920>:
  if (opcode2 == 346) goto <D.23918>; else goto <D.23921>;
  <D.23921>:
  if (opcode2 == 352) goto <D.23918>; else goto <D.23922>;
  <D.23922>:
  if (opcode2 == 349) goto <D.23918>; else goto <D.23919>;
  <D.23918>:
  D.23923 = ins->data.op[1].const_val;
  D.23924 = (const void *) D.23923;
  MEM[(struct MonoCallInst *)ins].fptr = D.23924;
  <D.23919>:
  <D.23915>:
  goto <D.23925>;
  <D.23913>:
  <D.23925>:
  <D.23907>:
  <D.23888>:
  D.23875 = ins->opcode;
  if (D.23875 == 731) goto <D.23926>; else goto <D.23929>;
  <D.23929>:
  D.23875 = ins->opcode;
  if (D.23875 == 732) goto <D.23930>; else goto <D.23927>;
  <D.23930>:
  D.23931 = ins->data.op[1].src;
  if (D.23931 == 8B) goto <D.23926>; else goto <D.23927>;
  <D.23927>:
  D.23875 = ins->opcode;
  if (D.23875 == 370) goto <D.23926>; else goto <D.23932>;
  <D.23932>:
  D.23875 = ins->opcode;
  if (D.23875 == 734) goto <D.23933>; else goto <D.23928>;
  <D.23933>:
  D.23931 = ins->data.op[1].src;
  D.23934 = D.23931->data.op[1].src;
  if (D.23934 == 8B) goto <D.23926>; else goto <D.23928>;
  <D.23926>:
  {
    int i;
    struct MonoJumpInfoBBTable * table;

    D.23875 = ins->opcode;
    if (D.23875 == 731) goto <D.23936>; else goto <D.23937>;
    <D.23936>:
    iftmp.38 = ins->data.op[0].p;
    goto <D.23938>;
    <D.23937>:
    D.23875 = ins->opcode;
    if (D.23875 == 732) goto <D.23942>; else goto <D.23940>;
    <D.23942>:
    D.23931 = ins->data.op[1].src;
    if (D.23931 == 8B) goto <D.23943>; else goto <D.23940>;
    <D.23943>:
    iftmp.39 = ins->data.op[0].p;
    goto <D.23941>;
    <D.23940>:
    D.23875 = ins->opcode;
    if (D.23875 == 370) goto <D.23945>; else goto <D.23946>;
    <D.23945>:
    iftmp.40 = ins->data.op[0].p;
    goto <D.23947>;
    <D.23946>:
    D.23875 = ins->opcode;
    if (D.23875 == 734) goto <D.23951>; else goto <D.23949>;
    <D.23951>:
    D.23931 = ins->data.op[1].src;
    D.23934 = D.23931->data.op[1].src;
    if (D.23934 == 8B) goto <D.23952>; else goto <D.23949>;
    <D.23952>:
    D.23931 = ins->data.op[1].src;
    iftmp.41 = D.23931->data.op[0].p;
    goto <D.23950>;
    <D.23949>:
    iftmp.41 = 0B;
    <D.23950>:
    iftmp.40 = iftmp.41;
    <D.23947>:
    iftmp.39 = iftmp.40;
    <D.23941>:
    iftmp.38 = iftmp.39;
    <D.23938>:
    table = iftmp.38;
    D.23955 = ins->next;
    if (D.23955 == 0B) goto <D.23953>; else goto <D.23956>;
    <D.23956>:
    D.23955 = ins->next;
    D.23957 = D.23955->opcode;
    if (D.23957 != 479) goto <D.23953>; else goto <D.23954>;
    <D.23953>:
    return;
    <D.23954>:
    D.23955 = ins->next;
    D.23957 = D.23955->opcode;
    D.23958 = D.23957 != 479;
    D.23959 = (long int) D.23958;
    D.23960 = __builtin_expect (D.23959, 0);
    if (D.23960 != 0) goto <D.23961>; else goto <D.23962>;
    <D.23961>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 1064, "ins->next->opcode == OP_PADD");
    <D.23962>:
    D.23955 = ins->next;
    D.23963 = D.23955->sreg1;
    D.23883 = ins->dreg;
    D.23964 = D.23963 != D.23883;
    D.23965 = (long int) D.23964;
    D.23966 = __builtin_expect (D.23965, 0);
    if (D.23966 != 0) goto <D.23967>; else goto <D.23968>;
    <D.23967>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 1065, "ins->next->sreg1 == ins->dreg");
    <D.23968>:
    D.23955 = ins->next;
    D.23969 = D.23955->next;
    D.23970 = D.23969->opcode;
    D.23971 = D.23970 != 388;
    D.23972 = (long int) D.23971;
    D.23973 = __builtin_expect (D.23972, 0);
    if (D.23973 != 0) goto <D.23974>; else goto <D.23975>;
    <D.23974>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 1066, "ins->next->next->opcode == OP_LOAD_MEMBASE");
    <D.23975>:
    D.23955 = ins->next;
    D.23976 = D.23955->sreg2;
    D.23977 = (long unsigned int) D.23976;
    D.23978 = D.23977 * 8;
    D.23979 = carray + D.23978;
    D.23980 = *D.23979;
    if (D.23980 != 0B) goto <D.23981>; else goto <D.23982>;
    <D.23981>:
    {
      int idx;

      D.23955 = ins->next;
      D.23976 = D.23955->sreg2;
      D.23977 = (long unsigned int) D.23976;
      D.23978 = D.23977 * 8;
      D.23979 = carray + D.23978;
      D.23980 = *D.23979;
      D.23983 = D.23980->data.op[0].const_val;
      D.23984 = D.23983 >> 3;
      idx = (int) D.23984;
      if (idx < 0) goto <D.23985>; else goto <D.23987>;
      <D.23987>:
      D.23988 = table->table_size;
      if (D.23988 <= idx) goto <D.23985>; else goto <D.23986>;
      <D.23985>:
      i = 0;
      goto <D.22502>;
      <D.22501>:
      D.23989 = table->table;
      D.23990 = (long unsigned int) i;
      D.23991 = D.23990 * 8;
      D.23992 = D.23989 + D.23991;
      D.23993 = *D.23992;
      remove_bb_from_phis (cfg, bb, D.23993);
      D.23989 = table->table;
      D.23990 = (long unsigned int) i;
      D.23991 = D.23990 * 8;
      D.23992 = D.23989 + D.23991;
      D.23993 = *D.23992;
      mono_unlink_bblock (cfg, bb, D.23993);
      i = i + 1;
      <D.22502>:
      D.23988 = table->table_size;
      if (D.23988 > i) goto <D.22501>; else goto <D.22503>;
      <D.22503>:
      ins->opcode = 316;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.23904 = ins->sreg3;
      ins->sreg2 = D.23904;
      D.23905 = ins->sreg2;
      ins->sreg1 = D.23905;
      D.23955 = ins->next;
      D.23955->opcode = 316;
      D.23955 = ins->next;
      D.23955->dreg = -1;
      D.23955 = ins->next;
      D.23955 = ins->next;
      D.23955 = ins->next;
      D.23955->sreg3 = -1;
      D.23994 = D.23955->sreg3;
      D.23955->sreg2 = D.23994;
      D.23976 = D.23955->sreg2;
      D.23955->sreg1 = D.23976;
      D.23955 = ins->next;
      D.23969 = D.23955->next;
      D.23969->opcode = 316;
      D.23955 = ins->next;
      D.23969 = D.23955->next;
      D.23969->dreg = -1;
      D.23955 = ins->next;
      D.23969 = D.23955->next;
      D.23955 = ins->next;
      D.23969 = D.23955->next;
      D.23955 = ins->next;
      D.23969 = D.23955->next;
      D.23969->sreg3 = -1;
      D.23995 = D.23969->sreg3;
      D.23969->sreg2 = D.23995;
      D.23996 = D.23969->sreg2;
      D.23969->sreg1 = D.23996;
      D.23955 = ins->next;
      D.23969 = D.23955->next;
      D.23997 = D.23969->next;
      if (D.23997 != 0B) goto <D.23998>; else goto <D.23999>;
      <D.23998>:
      D.23955 = ins->next;
      D.23969 = D.23955->next;
      D.23997 = D.23969->next;
      D.23997->opcode = 316;
      D.23955 = ins->next;
      D.23969 = D.23955->next;
      D.23997 = D.23969->next;
      D.23997->dreg = -1;
      D.23955 = ins->next;
      D.23969 = D.23955->next;
      D.23997 = D.23969->next;
      D.23955 = ins->next;
      D.23969 = D.23955->next;
      D.23997 = D.23969->next;
      D.23955 = ins->next;
      D.23969 = D.23955->next;
      D.23997 = D.23969->next;
      D.23997->sreg3 = -1;
      D.24000 = D.23997->sreg3;
      D.23997->sreg2 = D.24000;
      D.24001 = D.23997->sreg2;
      D.23997->sreg1 = D.24001;
      <D.23999>:
      return;
      <D.23986>:
      D.23955 = ins->next;
      D.23969 = D.23955->next;
      D.23997 = D.23969->next;
      if (D.23997 == 0B) goto <D.24002>; else goto <D.24004>;
      <D.24004>:
      D.23955 = ins->next;
      D.23969 = D.23955->next;
      D.23997 = D.23969->next;
      D.24005 = D.23997->opcode;
      if (D.24005 != 759) goto <D.24002>; else goto <D.24003>;
      <D.24002>:
      D.24006 = cfg->verbose_level;
      D.24007 = D.24006 > 1;
      D.24008 = (long int) D.24007;
      D.24009 = __builtin_expect (D.24008, 0);
      if (D.24009 != 0) goto <D.24010>; else goto <D.24011>;
      <D.24010>:
      printf ("\tNo cfold on ");
      mono_print_ins (ins);
      <D.24011>:
      return;
      <D.24003>:
      D.24006 = cfg->verbose_level;
      D.24007 = D.24006 > 1;
      D.24008 = (long int) D.24007;
      D.24009 = __builtin_expect (D.24008, 0);
      if (D.24009 != 0) goto <D.24012>; else goto <D.24013>;
      <D.24012>:
      printf ("\tcfold on ");
      mono_print_ins (ins);
      <D.24013>:
      i = 0;
      goto <D.22505>;
      <D.22504>:
      D.23989 = table->table;
      D.23990 = (long unsigned int) i;
      D.23991 = D.23990 * 8;
      D.23992 = D.23989 + D.23991;
      D.23993 = *D.23992;
      D.23989 = table->table;
      D.24014 = (long unsigned int) idx;
      D.24015 = D.24014 * 8;
      D.24016 = D.23989 + D.24015;
      D.24017 = *D.24016;
      if (D.23993 != D.24017) goto <D.24018>; else goto <D.24019>;
      <D.24018>:
      D.23989 = table->table;
      D.23990 = (long unsigned int) i;
      D.23991 = D.23990 * 8;
      D.23992 = D.23989 + D.23991;
      D.23993 = *D.23992;
      remove_bb_from_phis (cfg, bb, D.23993);
      D.23989 = table->table;
      D.23990 = (long unsigned int) i;
      D.23991 = D.23990 * 8;
      D.23992 = D.23989 + D.23991;
      D.23993 = *D.23992;
      mono_unlink_bblock (cfg, bb, D.23993);
      <D.24019>:
      i = i + 1;
      <D.22505>:
      D.23988 = table->table_size;
      if (D.23988 > i) goto <D.22504>; else goto <D.22506>;
      <D.22506>:
      D.23955 = ins->next;
      D.23969 = D.23955->next;
      D.23997 = D.23969->next;
      D.23997->opcode = 442;
      D.23955 = ins->next;
      D.23969 = D.23955->next;
      D.23997 = D.23969->next;
      D.23989 = table->table;
      D.24014 = (long unsigned int) idx;
      D.24015 = D.24014 * 8;
      D.24016 = D.23989 + D.24015;
      D.24017 = *D.24016;
      D.23997->data.op[0].target_block = D.24017;
      D.23955 = ins->next;
      D.23969 = D.23955->next;
      D.23997 = D.23969->next;
      D.23997->sreg1 = -1;
      ins->opcode = 316;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.23904 = ins->sreg3;
      ins->sreg2 = D.23904;
      D.23905 = ins->sreg2;
      ins->sreg1 = D.23905;
      D.23955 = ins->next;
      D.23955->opcode = 316;
      D.23955 = ins->next;
      D.23955->dreg = -1;
      D.23955 = ins->next;
      D.23955 = ins->next;
      D.23955 = ins->next;
      D.23955->sreg3 = -1;
      D.23994 = D.23955->sreg3;
      D.23955->sreg2 = D.23994;
      D.23976 = D.23955->sreg2;
      D.23955->sreg1 = D.23976;
      D.23955 = ins->next;
      D.23969 = D.23955->next;
      D.23969->opcode = 316;
      D.23955 = ins->next;
      D.23969 = D.23955->next;
      D.23969->dreg = -1;
      D.23955 = ins->next;
      D.23969 = D.23955->next;
      D.23955 = ins->next;
      D.23969 = D.23955->next;
      D.23955 = ins->next;
      D.23969 = D.23955->next;
      D.23969->sreg3 = -1;
      D.23995 = D.23969->sreg3;
      D.23969->sreg2 = D.23995;
      D.23996 = D.23969->sreg2;
      D.23969->sreg1 = D.23996;
    }
    <D.23982>:
  }
  <D.23928>:
  goto <D.23881>;
  <D.23880>:
  D.23875 = ins->opcode;
  D.24022 = D.23875 + 64985;
  if (D.24022 <= 9) goto <D.24020>; else goto <D.24023>;
  <D.24023>:
  D.23875 = ins->opcode;
  D.24024 = D.23875 + 64878;
  if (D.24024 <= 9) goto <D.24020>; else goto <D.24025>;
  <D.24025>:
  D.23875 = ins->opcode;
  D.24026 = D.23875 + 64888;
  if (D.24026 <= 9) goto <D.24020>; else goto <D.24021>;
  <D.24020>:
  D.24027 = ins->flags;
  D.24028 = (int) D.24027;
  D.24029 = D.24028 & 8;
  if (D.24029 != 0) goto <D.24030>; else goto <D.24031>;
  <D.24030>:
  D.24032 = ins->data.op[1].many_blocks;
  D.24033 = D.24032 + 8;
  D.24034 = *D.24033;
  remove_bb_from_phis (cfg, bb, D.24034);
  D.24032 = ins->data.op[1].many_blocks;
  D.24033 = D.24032 + 8;
  D.24034 = *D.24033;
  mono_unlink_bblock (cfg, bb, D.24034);
  ins->opcode = 442;
  D.24032 = ins->data.op[1].many_blocks;
  D.24035 = *D.24032;
  ins->data.op[0].target_block = D.24035;
  goto <D.24036>;
  <D.24031>:
  D.24027 = ins->flags;
  D.24028 = (int) D.24027;
  D.24037 = D.24028 & 16;
  if (D.24037 != 0) goto <D.24038>; else goto <D.24039>;
  <D.24038>:
  D.24032 = ins->data.op[1].many_blocks;
  D.24035 = *D.24032;
  remove_bb_from_phis (cfg, bb, D.24035);
  D.24032 = ins->data.op[1].many_blocks;
  D.24035 = *D.24032;
  mono_unlink_bblock (cfg, bb, D.24035);
  ins->opcode = 442;
  D.24032 = ins->data.op[1].many_blocks;
  D.24040 = MEM[(struct MonoBasicBlock * *)D.24032 + 8B];
  ins->data.op[0].target_block = D.24040;
  <D.24039>:
  <D.24036>:
  <D.24021>:
  <D.23881>:
}


remove_bb_from_phis (struct MonoCompile * cfg, struct MonoBasicBlock * bb, struct MonoBasicBlock * target)
{
  struct MonoBasicBlock * * D.24042;
  long unsigned int D.24043;
  long unsigned int D.24044;
  struct MonoBasicBlock * * D.24045;
  struct MonoBasicBlock * D.24046;
  short int D.24048;
  int D.24049;
  _Bool D.24050;
  long int D.24051;
  long int D.24052;
  short unsigned int D.24055;
  short unsigned int D.24056;
  int * D.24058;
  sizetype D.24059;
  sizetype D.24060;
  sizetype D.24061;
  int * D.24062;
  sizetype D.24063;
  sizetype D.24064;
  int * D.24065;
  int D.24066;
  int D.24067;
  int D.24068;
  struct MonoInst * ins;
  int i;
  int j;

  i = 0;
  goto <D.22180>;
  <D.22179>:
  D.24042 = target->in_bb;
  D.24043 = (long unsigned int) i;
  D.24044 = D.24043 * 8;
  D.24045 = D.24042 + D.24044;
  D.24046 = *D.24045;
  if (D.24046 == bb) goto <D.22178>; else goto <D.24047>;
  <D.24047>:
  i = i + 1;
  <D.22180>:
  D.24048 = target->in_count;
  D.24049 = (int) D.24048;
  if (D.24049 > i) goto <D.22179>; else goto <D.22178>;
  <D.22178>:
  D.24048 = target->in_count;
  D.24049 = (int) D.24048;
  D.24050 = D.24049 <= i;
  D.24051 = (long int) D.24050;
  D.24052 = __builtin_expect (D.24051, 0);
  if (D.24052 != 0) goto <D.24053>; else goto <D.24054>;
  <D.24053>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 111, "i < target->in_count");
  <D.24054>:
  ins = target->code;
  goto <D.22186>;
  <D.22185>:
  D.24055 = ins->opcode;
  D.24056 = D.24055 + 65217;
  if (D.24056 <= 2) goto <D.24057>; else goto <D.22184>;
  <D.24057>:
  j = i;
  goto <D.22182>;
  <D.22181>:
  D.24058 = ins->data.op[1].phi_args;
  D.24059 = (sizetype) j;
  D.24060 = D.24059 + 1;
  D.24061 = D.24060 * 4;
  D.24062 = D.24058 + D.24061;
  D.24058 = ins->data.op[1].phi_args;
  D.24059 = (sizetype) j;
  D.24063 = D.24059 + 2;
  D.24064 = D.24063 * 4;
  D.24065 = D.24058 + D.24064;
  D.24066 = *D.24065;
  *D.24062 = D.24066;
  j = j + 1;
  <D.22182>:
  D.24058 = ins->data.op[1].phi_args;
  D.24067 = *D.24058;
  D.24068 = D.24067 + -1;
  if (D.24068 > j) goto <D.22181>; else goto <D.22183>;
  <D.22183>:
  D.24058 = ins->data.op[1].phi_args;
  D.24067 = *D.24058;
  D.24068 = D.24067 + -1;
  *D.24058 = D.24068;
  ins = ins->next;
  <D.22186>:
  if (ins != 0B) goto <D.22185>; else goto <D.22184>;
  <D.22184>:
}


__attribute__((visibility ("hidden")))
mono_ssa_deadce (struct MonoCompile * cfg)
{
  unsigned int D.24069;
  unsigned int D.24070;
  _Bool D.24071;
  long int D.24072;
  long int D.24073;
  unsigned int D.24076;
  struct MonoMethodVar * D.24079;
  long unsigned int D.24080;
  long unsigned int D.24081;
  struct MonoMemPool * D.24082;
  struct GList * work_list.42;
  struct GList * work_list.43;
  unsigned int D.24085;
  unsigned int i.44;
  struct GList * work_list.45;
  struct MonoInst * D.24090;
  struct GList * D.24093;
  struct GList * D.24095;
  void * D.24097;
  struct MonoInst * D.24098;
  short unsigned int D.24102;
  struct MonoInst * iftmp.46;
  int D.24106;
  unsigned int D.24107;
  unsigned int D.24108;
  struct MonoInst * * D.24111;
  long unsigned int D.24112;
  long unsigned int D.24113;
  struct MonoInst * * D.24114;
  unsigned char D.24118;
  int D.24119;
  int D.24120;
  long int D.24123;
  long unsigned int D.24124;
  long unsigned int D.24125;
  struct MonoMethodVar * D.24126;
  int D.24127;
  short unsigned int D.24131;
  short unsigned int D.24133;
  int * D.24136;
  struct MonoInst * iftmp.47;
  long unsigned int D.24138;
  long unsigned int D.24139;
  int * D.24140;
  int D.24141;
  unsigned int D.24142;
  long unsigned int D.24145;
  long unsigned int D.24146;
  struct MonoInst * * D.24147;
  long int D.24149;
  long unsigned int D.24150;
  long unsigned int D.24151;
  int i;
  struct GList * work_list;

  try
    {
      D.24069 = cfg->comp_done;
      D.24070 = D.24069 & 32;
      D.24071 = D.24070 == 0;
      D.24072 = (long int) D.24071;
      D.24073 = __builtin_expect (D.24072, 0);
      if (D.24073 != 0) goto <D.24074>; else goto <D.24075>;
      <D.24074>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 1259, "cfg->comp_done & MONO_COMP_SSA");
      <D.24075>:
      D.24069 = cfg->comp_done;
      D.24076 = D.24069 & 64;
      if (D.24076 == 0) goto <D.24077>; else goto <D.24078>;
      <D.24077>:
      mono_ssa_create_def_use (cfg);
      <D.24078>:
      mono_ssa_copyprop (cfg);
      work_list = 0B;
      i = 0;
      goto <D.22571>;
      <D.22570>:
      {
        struct MonoMethodVar * info;

        D.24079 = cfg->vars;
        D.24080 = (long unsigned int) i;
        D.24081 = D.24080 * 80;
        info = D.24079 + D.24081;
        D.24082 = cfg->mempool;
        work_list.42 = work_list;
        work_list.43 = g_list_prepend_mempool (D.24082, work_list.42, info);
        work_list = work_list.43;
      }
      i = i + 1;
      <D.22571>:
      D.24085 = cfg->num_varinfo;
      i.44 = (unsigned int) i;
      if (D.24085 > i.44) goto <D.22570>; else goto <D.22572>;
      <D.22572>:
      goto <D.22582>;
      <D.22581>:
      {
        struct MonoMethodVar * info;

        work_list.42 = work_list;
        info = work_list.42->data;
        work_list.42 = work_list;
        work_list.42 = work_list;
        work_list.45 = monoeg_g_list_remove_link (work_list.42, work_list.42);
        work_list = work_list.45;
        D.24090 = info->def;
        if (D.24090 != 0B) goto <D.24091>; else goto <D.24092>;
        <D.24091>:
        D.24093 = info->uses;
        if (D.24093 == 0B) goto <D.24088>; else goto <D.24094>;
        <D.24094>:
        D.24093 = info->uses;
        D.24095 = D.24093->next;
        if (D.24095 == 0B) goto <D.24096>; else goto <D.24089>;
        <D.24096>:
        D.24093 = info->uses;
        D.24097 = D.24093->data;
        D.24098 = MEM[(struct MonoVarUsageInfo *)D.24097].inst;
        D.24090 = info->def;
        if (D.24098 == D.24090) goto <D.24088>; else goto <D.24089>;
        <D.24088>:
        {
          struct MonoInst * def;

          def = info->def;
          D.24102 = def->opcode;
          if (D.24102 == 424) goto <D.24099>; else goto <D.24103>;
          <D.24103>:
          D.24102 = def->opcode;
          if (D.24102 == 426) goto <D.24099>; else goto <D.24104>;
          <D.24104>:
          D.24102 = def->opcode;
          if (D.24102 == 427) goto <D.24099>; else goto <D.24100>;
          <D.24099>:
          {
            struct MonoInst * src_var;

            D.24106 = def->sreg1;
            D.24107 = (unsigned int) D.24106;
            D.24108 = cfg->vreg_to_inst_len;
            if (D.24107 < D.24108) goto <D.24109>; else goto <D.24110>;
            <D.24109>:
            D.24111 = cfg->vreg_to_inst;
            D.24106 = def->sreg1;
            D.24112 = (long unsigned int) D.24106;
            D.24113 = D.24112 * 8;
            D.24114 = D.24111 + D.24113;
            iftmp.46 = *D.24114;
            goto <D.24115>;
            <D.24110>:
            iftmp.46 = 0B;
            <D.24115>:
            src_var = iftmp.46;
            if (src_var != 0B) goto <D.24116>; else goto <D.24117>;
            <D.24116>:
            D.24118 = src_var->flags;
            D.24119 = (int) D.24118;
            D.24120 = D.24119 & 20;
            if (D.24120 == 0) goto <D.24121>; else goto <D.24122>;
            <D.24121>:
            D.24079 = cfg->vars;
            D.24123 = src_var->data.op[0].const_val;
            D.24124 = (long unsigned int) D.24123;
            D.24125 = D.24124 * 80;
            D.24126 = D.24079 + D.24125;
            add_to_dce_worklist (cfg, info, D.24126, &work_list);
            <D.24122>:
            <D.24117>:
            def->opcode = 316;
            def->sreg2 = -1;
            D.24127 = def->sreg2;
            def->sreg1 = D.24127;
            D.24106 = def->sreg1;
            def->dreg = D.24106;
            info->reg = -1;
          }
          goto <D.24101>;
          <D.24100>:
          D.24102 = def->opcode;
          D.24131 = D.24102 + 65174;
          if (D.24131 <= 1) goto <D.24128>; else goto <D.24132>;
          <D.24132>:
          D.24102 = def->opcode;
          if (D.24102 == 428) goto <D.24128>; else goto <D.24129>;
          <D.24128>:
          def->opcode = 316;
          def->sreg2 = -1;
          D.24127 = def->sreg2;
          def->sreg1 = D.24127;
          D.24106 = def->sreg1;
          def->dreg = D.24106;
          info->reg = -1;
          goto <D.24130>;
          <D.24129>:
          D.24102 = def->opcode;
          D.24133 = D.24102 + 65217;
          if (D.24133 <= 2) goto <D.24134>; else goto <D.24135>;
          <D.24134>:
          {
            int j;

            D.24136 = def->data.op[1].phi_args;
            j = *D.24136;
            goto <D.22579>;
            <D.22578>:
            {
              struct MonoMethodVar * u;

              D.24079 = cfg->vars;
              D.24136 = def->data.op[1].phi_args;
              D.24138 = (long unsigned int) j;
              D.24139 = D.24138 * 4;
              D.24140 = D.24136 + D.24139;
              D.24141 = *D.24140;
              D.24142 = (unsigned int) D.24141;
              D.24108 = cfg->vreg_to_inst_len;
              if (D.24142 < D.24108) goto <D.24143>; else goto <D.24144>;
              <D.24143>:
              D.24111 = cfg->vreg_to_inst;
              D.24136 = def->data.op[1].phi_args;
              D.24138 = (long unsigned int) j;
              D.24139 = D.24138 * 4;
              D.24140 = D.24136 + D.24139;
              D.24141 = *D.24140;
              D.24145 = (long unsigned int) D.24141;
              D.24146 = D.24145 * 8;
              D.24147 = D.24111 + D.24146;
              iftmp.47 = *D.24147;
              goto <D.24148>;
              <D.24144>:
              iftmp.47 = 0B;
              <D.24148>:
              D.24149 = iftmp.47->data.op[0].const_val;
              D.24150 = (long unsigned int) D.24149;
              D.24151 = D.24150 * 80;
              u = D.24079 + D.24151;
              add_to_dce_worklist (cfg, info, u, &work_list);
            }
            j = j + -1;
            <D.22579>:
            if (j > 0) goto <D.22578>; else goto <D.22580>;
            <D.22580>:
            def->opcode = 316;
            def->sreg2 = -1;
            D.24127 = def->sreg2;
            def->sreg1 = D.24127;
            D.24106 = def->sreg1;
            def->dreg = D.24106;
            info->reg = -1;
          }
          goto <D.24152>;
          <D.24135>:
          D.24102 = def->opcode;
          if (D.24102 == 316) goto <D.24153>; else goto <D.24154>;
          <D.24153>:
          <D.24154>:
          <D.24152>:
          <D.24130>:
          <D.24101>:
        }
        <D.24089>:
        <D.24092>:
      }
      <D.22582>:
      work_list.42 = work_list;
      if (work_list.42 != 0B) goto <D.22581>; else goto <D.22583>;
      <D.22583>:
    }
  finally
    {
      work_list = {CLOBBER};
    }
}


mono_ssa_copyprop (struct MonoCompile * cfg)
{
  unsigned int D.24155;
  unsigned int D.24156;
  _Bool D.24157;
  long int D.24158;
  long int D.24159;
  struct MonoInst * * D.24162;
  long unsigned int D.24163;
  long unsigned int D.24164;
  struct MonoInst * * D.24165;
  struct MonoMethodVar * D.24166;
  long unsigned int D.24167;
  struct MonoInst * D.24170;
  short unsigned int D.24173;
  struct MonoInst * iftmp.48;
  int D.24177;
  unsigned int D.24178;
  unsigned int D.24179;
  struct MonoInst * * D.24182;
  long unsigned int D.24183;
  long unsigned int D.24184;
  struct MonoInst * * D.24185;
  unsigned char D.24189;
  int D.24190;
  int D.24191;
  long int D.24194;
  long unsigned int D.24195;
  long unsigned int D.24196;
  struct MonoMethodVar * D.24197;
  struct MonoInst * D.24198;
  short unsigned int D.24201;
  short unsigned int D.24202;
  int D.24205;
  int D.24206;
  int D.24207;
  short unsigned int D.24208;
  int D.24209;
  int D.24210;
  signed char D.24211;
  int D.24212;
  _Bool D.24216;
  long int D.24217;
  long int D.24218;
  short unsigned int D.24224;
  int D.24226;
  short unsigned int D.24228;
  int * D.24231;
  long unsigned int D.24232;
  long unsigned int D.24233;
  int * D.24234;
  int D.24235;
  _Bool D.24237;
  long int D.24238;
  long int D.24239;
  struct MonoBasicBlock * D.24243;
  unsigned int D.24244;
  unsigned int index.49;
  unsigned int D.24246;
  int i;
  int index;
  struct GList * l;

  D.24155 = cfg->comp_done;
  D.24156 = D.24155 & 64;
  D.24157 = D.24156 == 0;
  D.24158 = (long int) D.24157;
  D.24159 = __builtin_expect (D.24158, 0);
  if (D.24159 != 0) goto <D.24160>; else goto <D.24161>;
  <D.24160>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 674, "(cfg->comp_done & MONO_COMP_SSA_DEF_USE)");
  <D.24161>:
  index = 0;
  goto <D.22409>;
  <D.22408>:
  {
    struct MonoInst * var;
    struct MonoMethodVar * info;

    D.24162 = cfg->varinfo;
    D.24163 = (long unsigned int) index;
    D.24164 = D.24163 * 8;
    D.24165 = D.24162 + D.24164;
    var = *D.24165;
    D.24166 = cfg->vars;
    D.24163 = (long unsigned int) index;
    D.24167 = D.24163 * 80;
    info = D.24166 + D.24167;
    D.24170 = info->def;
    if (D.24170 != 0B) goto <D.24171>; else goto <D.24172>;
    <D.24171>:
    D.24170 = info->def;
    D.24173 = D.24170->opcode;
    if (D.24173 == 424) goto <D.24168>; else goto <D.24174>;
    <D.24174>:
    D.24170 = info->def;
    D.24173 = D.24170->opcode;
    if (D.24173 == 426) goto <D.24168>; else goto <D.24175>;
    <D.24175>:
    D.24170 = info->def;
    D.24173 = D.24170->opcode;
    if (D.24173 == 427) goto <D.24168>; else goto <D.24169>;
    <D.24168>:
    {
      struct MonoInst * var2;

      D.24170 = info->def;
      D.24177 = D.24170->sreg1;
      D.24178 = (unsigned int) D.24177;
      D.24179 = cfg->vreg_to_inst_len;
      if (D.24178 < D.24179) goto <D.24180>; else goto <D.24181>;
      <D.24180>:
      D.24182 = cfg->vreg_to_inst;
      D.24170 = info->def;
      D.24177 = D.24170->sreg1;
      D.24183 = (long unsigned int) D.24177;
      D.24184 = D.24183 * 8;
      D.24185 = D.24182 + D.24184;
      iftmp.48 = *D.24185;
      goto <D.24186>;
      <D.24181>:
      iftmp.48 = 0B;
      <D.24186>:
      var2 = iftmp.48;
      if (var2 != 0B) goto <D.24187>; else goto <D.24188>;
      <D.24187>:
      D.24189 = var2->flags;
      D.24190 = (int) D.24189;
      D.24191 = D.24190 & 20;
      if (D.24191 == 0) goto <D.24192>; else goto <D.24193>;
      <D.24192>:
      D.24166 = cfg->vars;
      D.24194 = var2->data.op[0].const_val;
      D.24195 = (long unsigned int) D.24194;
      D.24196 = D.24195 * 80;
      D.24197 = D.24166 + D.24196;
      D.24198 = D.24197->def;
      if (D.24198 != 0B) goto <D.24199>; else goto <D.24200>;
      <D.24199>:
      D.24166 = cfg->vars;
      D.24194 = var2->data.op[0].const_val;
      D.24195 = (long unsigned int) D.24194;
      D.24196 = D.24195 * 80;
      D.24197 = D.24166 + D.24196;
      D.24198 = D.24197->def;
      D.24201 = D.24198->opcode;
      D.24202 = D.24201 + 65217;
      if (D.24202 > 2) goto <D.24203>; else goto <D.24204>;
      <D.24203>:
      {
        int dreg;
        int sreg1;

        dreg = var->dreg;
        sreg1 = var2->dreg;
        l = info->uses;
        goto <D.22406>;
        <D.22405>:
        {
          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.24205 = ins->sreg1;
              sregs[0] = D.24205;
              D.24206 = ins->sreg2;
              sregs[1] = D.24206;
              D.24207 = ins->sreg3;
              sregs[2] = D.24207;
              D.24208 = ins->opcode;
              D.24209 = (int) D.24208;
              D.24210 = D.24209 + -313;
              D.24211 = ins_sreg_counts[D.24210];
              num_sregs = (int) D.24211;
              i = 0;
              goto <D.22400>;
              <D.22399>:
              D.24212 = sregs[i];
              if (D.24212 == dreg) goto <D.22398>; else goto <D.24213>;
              <D.24213>:
              i = i + 1;
              <D.22400>:
              if (i < num_sregs) goto <D.22399>; else goto <D.22398>;
              <D.22398>:
              if (i < num_sregs) goto <D.24214>; else goto <D.24215>;
              <D.24214>:
              D.24212 = sregs[i];
              D.24216 = D.24212 != dreg;
              D.24217 = (long int) D.24216;
              D.24218 = __builtin_expect (D.24217, 0);
              if (D.24218 != 0) goto <D.24219>; else goto <D.24220>;
              <D.24219>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 702, "sregs [i] == dreg");
              <D.24220>:
              sregs[i] = sreg1;
              mono_inst_set_src_registers (ins, &sregs);
              goto <D.24221>;
              <D.24215>:
              D.24208 = ins->opcode;
              D.24224 = D.24208 + 65162;
              if (D.24224 <= 13) goto <D.24225>; else goto <D.24222>;
              <D.24225>:
              D.24226 = ins->dreg;
              if (D.24226 == dreg) goto <D.24227>; else goto <D.24222>;
              <D.24227>:
              ins->dreg = sreg1;
              goto <D.24223>;
              <D.24222>:
              D.24208 = ins->opcode;
              D.24228 = D.24208 + 65217;
              if (D.24228 <= 2) goto <D.24229>; else goto <D.24230>;
              <D.24229>:
              D.24231 = ins->data.op[1].phi_args;
              i = *D.24231;
              goto <D.22404>;
              <D.22403>:
              {
                int sreg;

                D.24231 = ins->data.op[1].phi_args;
                D.24232 = (long unsigned int) i;
                D.24233 = D.24232 * 4;
                D.24234 = D.24231 + D.24233;
                sreg = *D.24234;
                D.24235 = var->dreg;
                if (D.24235 == sreg) goto <D.22402>; else goto <D.24236>;
                <D.24236>:
              }
              i = i + -1;
              <D.22404>:
              if (i > 0) goto <D.22403>; else goto <D.22402>;
              <D.22402>:
              D.24237 = i <= 0;
              D.24238 = (long int) D.24237;
              D.24239 = __builtin_expect (D.24238, 0);
              if (D.24239 != 0) goto <D.24240>; else goto <D.24241>;
              <D.24240>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 713, "i > 0");
              <D.24241>:
              D.24231 = ins->data.op[1].phi_args;
              D.24232 = (long unsigned int) i;
              D.24233 = D.24232 * 4;
              D.24234 = D.24231 + D.24233;
              *D.24234 = sreg1;
              goto <D.24242>;
              <D.24230>:
              monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "ssa.c", 717);
              <D.24242>:
              <D.24223>:
              <D.24221>:
              D.24243 = u->bb;
              record_use (cfg, var2, D.24243, ins);
              l = next;
            }
          finally
            {
              sregs = {CLOBBER};
            }
        }
        <D.22406>:
        if (l != 0B) goto <D.22405>; else goto <D.22407>;
        <D.22407>:
        info->uses = 0B;
      }
      <D.24204>:
      <D.24200>:
      <D.24193>:
      <D.24188>:
    }
    <D.24169>:
    <D.24172>:
  }
  index = index + 1;
  <D.22409>:
  D.24244 = cfg->num_varinfo;
  index.49 = (unsigned int) index;
  if (D.24244 > index.49) goto <D.22408>; else goto <D.22410>;
  <D.22410>:
  D.24246 = cfg->verbose_level;
  if (D.24246 > 3) goto <D.24247>; else goto <D.24248>;
  <D.24247>:
  {
    struct MonoBasicBlock * bb;

    bb = cfg->bb_entry;
    goto <D.22413>;
    <D.22412>:
    mono_print_bb (bb, "AFTER SSA COPYPROP");
    bb = bb->next_bb;
    <D.22413>:
    if (bb != 0B) goto <D.22412>; else goto <D.22414>;
    <D.22414>:
  }
  <D.24248>:
}


add_to_dce_worklist (struct MonoCompile * cfg, struct MonoMethodVar * var, struct MonoMethodVar * use, struct GList * * wl)
{
  struct MonoMemPool * D.24249;
  struct GList * D.24250;
  struct GList * D.24251;
  struct MonoInst * D.24252;
  struct MonoInst * D.24253;
  struct GList * D.24256;
  struct GList * D.24257;
  struct GList * tmp;

  D.24249 = cfg->mempool;
  D.24250 = *wl;
  D.24251 = g_list_prepend_mempool (D.24249, D.24250, use);
  *wl = D.24251;
  tmp = use->uses;
  goto <D.22563>;
  <D.22562>:
  {
    struct MonoVarUsageInfo * ui;

    ui = tmp->data;
    D.24252 = ui->inst;
    D.24253 = var->def;
    if (D.24252 == D.24253) goto <D.24254>; else goto <D.24255>;
    <D.24254>:
    D.24256 = use->uses;
    D.24257 = monoeg_g_list_remove_link (D.24256, tmp);
    use->uses = D.24257;
    goto <D.22561>;
    <D.24255>:
  }
  tmp = tmp->next;
  <D.22563>:
  if (tmp != 0B) goto <D.22562>; else goto <D.22561>;
  <D.22561>:
}


__attribute__((visibility ("hidden")))
mono_ssa_loop_invariant_code_motion (struct MonoCompile * cfg)
{
  unsigned int D.24258;
  unsigned int D.24259;
  _Bool D.24260;
  long int D.24261;
  long int D.24262;
  long unsigned int D.24265;
  long unsigned int D.24266;
  struct MonoBasicBlock * D.24269;
  struct MonoInst * iftmp.50;
  short unsigned int D.24278;
  long unsigned int D.24281;
  long unsigned int D.24282;
  <unnamed type> D.24285;
  struct MonoInst * D.24297;
  short unsigned int D.24299;
  struct MonoBasicBlock * D.24301;
  signed char D.24303;
  short unsigned int D.24305;
  short unsigned int D.24375;
  int D.24376;
  int D.24377;
  int D.24378;
  int D.24381;
  char D.24384;
  unsigned int D.24391;
  int D.24394;
  struct MonoInst * D.24395;
  struct MonoInst * D.24398;
  struct MonoInst * D.24401;
  struct MonoInst * D.24404;
  struct MonoInst * iftmp.51;
  unsigned int D.24414;
  struct MonoMethodVar * D.24415;
  long unsigned int D.24416;
  long unsigned int D.24417;
  unsigned int D.24418;
  unsigned int i.52;
  struct MonoBasicBlock * bb;
  struct MonoBasicBlock * h;
  struct MonoBasicBlock * idom;
  struct MonoInst * ins;
  struct MonoInst * n;
  struct MonoInst * tins;
  int i;

  D.24258 = cfg->comp_done;
  D.24259 = D.24258 & 32;
  D.24260 = D.24259 == 0;
  D.24261 = (long int) D.24260;
  D.24262 = __builtin_expect (D.24261, 0);
  if (D.24262 != 0) goto <D.24263>; else goto <D.24264>;
  <D.24263>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "ssa.c", 1360, "cfg->comp_done & MONO_COMP_SSA");
  <D.24264>:
  D.24265 = BIT_FIELD_REF <*cfg, 64, 5376>;
  D.24266 = D.24265 & 320;
  if (D.24266 != 320) goto <D.24267>; else goto <D.24268>;
  <D.24267>:
  return;
  <D.24268>:
  D.24269 = cfg->bb_entry;
  bb = D.24269->next_bb;
  goto <D.22614>;
  <D.22613>:
  {
    struct GList * lp;

    lp = bb->loop_blocks;
    if (lp == 0B) goto <D.24270>; else goto <D.24271>;
    <D.24270>:
    // predicted unlikely by continue predictor.
    goto <D.22595>;
    <D.24271>:
    h = lp->data;
    if (bb != h) goto <D.24272>; else goto <D.24273>;
    <D.24272>:
    // predicted unlikely by continue predictor.
    goto <D.22595>;
    <D.24273>:
    ins = bb->code;
    if (ins != 0B) goto <D.24275>; else goto <D.24276>;
    <D.24275>:
    iftmp.50 = ins->next;
    goto <D.24277>;
    <D.24276>:
    iftmp.50 = 0B;
    <D.24277>:
    n = iftmp.50;
    goto <D.22611>;
    <D.22610>:
    {
      gboolean is_class_init;

      is_class_init = 0;
      D.24278 = ins->opcode;
      if (D.24278 == 343) goto <D.24279>; else goto <D.24280>;
      <D.24279>:
      {
        struct MonoCallInst * call;

        call = ins;
        D.24281 = BIT_FIELD_REF <*call, 64, 1088>;
        D.24282 = D.24281 & 2305843009213693952;
        if (D.24282 != 0) goto <D.24283>; else goto <D.24284>;
        <D.24283>:
        {
          struct MonoJumpInfo * ji;

          ji = call->fptr;
          D.24285 = ji->type;
          if (D.24285 == 15) goto <D.24286>; else goto <D.24287>;
          <D.24286>:
          is_class_init = 1;
          <D.24287>:
        }
        <D.24284>:
      }
      <D.24280>:
      D.24278 = ins->opcode;
      if (D.24278 == 783) goto <D.24288>; else goto <D.24290>;
      <D.24290>:
      D.24278 = ins->opcode;
      if (D.24278 == 781) goto <D.24288>; else goto <D.24291>;
      <D.24291>:
      D.24278 = ins->opcode;
      if (D.24278 == 340) goto <D.24288>; else goto <D.24292>;
      <D.24292>:
      D.24278 = ins->opcode;
      if (D.24278 == 732) goto <D.24288>; else goto <D.24293>;
      <D.24293>:
      if (is_class_init != 0) goto <D.24288>; else goto <D.24289>;
      <D.24288>:
      {
        gboolean skip;
        int sreg;

        idom = h->idom;
        if (idom == 0B) goto <D.24294>; else goto <D.24296>;
        <D.24296>:
        D.24297 = idom->last_ins;
        if (D.24297 == 0B) goto <D.24294>; else goto <D.24298>;
        <D.24298>:
        D.24297 = idom->last_ins;
        D.24299 = D.24297->opcode;
        if (D.24299 != 442) goto <D.24294>; else goto <D.24300>;
        <D.24300>:
        D.24297 = idom->last_ins;
        D.24301 = D.24297->data.op[0].target_block;
        if (D.24301 != h) goto <D.24294>; else goto <D.24302>;
        <D.24302>:
        D.24303 = h->nesting;
        if (D.24303 != 1) goto <D.24294>; else goto <D.24295>;
        <D.24294>:
        // predicted unlikely by continue predictor.
        goto <D.22601>;
        <D.24295>:
        skip = 0;
        tins = bb->code;
        goto <D.22604>;
        <D.22603>:
        if (tins == ins) goto <D.22602>; else goto <D.24304>;
        <D.24304>:
        D.24305 = tins->opcode;
        if (D.24305 != 424) goto <D.24306>; else goto <D.24307>;
        <D.24306>:
        D.24305 = tins->opcode;
        if (D.24305 != 426) goto <D.24308>; else goto <D.24309>;
        <D.24308>:
        D.24305 = tins->opcode;
        if (D.24305 != 427) goto <D.24310>; else goto <D.24311>;
        <D.24310>:
        D.24305 = tins->opcode;
        if (D.24305 != 362) goto <D.24312>; else goto <D.24313>;
        <D.24312>:
        D.24305 = tins->opcode;
        if (D.24305 != 363) goto <D.24314>; else goto <D.24315>;
        <D.24314>:
        D.24305 = tins->opcode;
        if (D.24305 != 428) goto <D.24316>; else goto <D.24317>;
        <D.24316>:
        D.24305 = tins->opcode;
        if (D.24305 != 429) goto <D.24318>; else goto <D.24319>;
        <D.24318>:
        D.24305 = tins->opcode;
        if (D.24305 != 365) goto <D.24320>; else goto <D.24321>;
        <D.24320>:
        D.24305 = tins->opcode;
        if (D.24305 != 538) goto <D.24322>; else goto <D.24323>;
        <D.24322>:
        D.24305 = tins->opcode;
        if (D.24305 != 626) goto <D.24324>; else goto <D.24325>;
        <D.24324>:
        D.24305 = tins->opcode;
        if (D.24305 != 625) goto <D.24326>; else goto <D.24327>;
        <D.24326>:
        D.24305 = tins->opcode;
        if (D.24305 != 492) goto <D.24328>; else goto <D.24329>;
        <D.24328>:
        D.24305 = tins->opcode;
        if (D.24305 != 566) goto <D.24330>; else goto <D.24331>;
        <D.24330>:
        D.24305 = tins->opcode;
        if (D.24305 != 817) goto <D.24332>; else goto <D.24333>;
        <D.24332>:
        D.24305 = tins->opcode;
        if (D.24305 != 635) goto <D.24334>; else goto <D.24335>;
        <D.24334>:
        D.24305 = tins->opcode;
        if (D.24305 != 636) goto <D.24336>; else goto <D.24337>;
        <D.24336>:
        D.24305 = tins->opcode;
        if (D.24305 != 637) goto <D.24338>; else goto <D.24339>;
        <D.24338>:
        D.24305 = tins->opcode;
        if (D.24305 != 632) goto <D.24340>; else goto <D.24341>;
        <D.24340>:
        D.24305 = tins->opcode;
        if (D.24305 != 591) goto <D.24342>; else goto <D.24343>;
        <D.24342>:
        D.24305 = tins->opcode;
        if (D.24305 != 580) goto <D.24344>; else goto <D.24345>;
        <D.24344>:
        D.24305 = tins->opcode;
        if (D.24305 != 762) goto <D.24346>; else goto <D.24347>;
        <D.24346>:
        D.24305 = tins->opcode;
        if (D.24305 != 503) goto <D.24348>; else goto <D.24349>;
        <D.24348>:
        D.24305 = tins->opcode;
        if (D.24305 != 590) goto <D.24350>; else goto <D.24351>;
        <D.24350>:
        D.24305 = tins->opcode;
        if (D.24305 != 581) goto <D.24352>; else goto <D.24353>;
        <D.24352>:
        D.24305 = tins->opcode;
        if (D.24305 != 495) goto <D.24354>; else goto <D.24355>;
        <D.24354>:
        D.24305 = tins->opcode;
        if (D.24305 != 314) goto <D.24356>; else goto <D.24357>;
        <D.24356>:
        D.24305 = tins->opcode;
        if (D.24305 != 319) goto <D.24358>; else goto <D.24359>;
        <D.24358>:
        D.24305 = tins->opcode;
        if (D.24305 != 316) goto <D.24360>; else goto <D.24361>;
        <D.24360>:
        D.24305 = tins->opcode;
        if (D.24305 != 765) goto <D.24362>; else goto <D.24363>;
        <D.24362>:
        D.24305 = tins->opcode;
        if (D.24305 != 799) goto <D.24364>; else goto <D.24365>;
        <D.24364>:
        skip = 1;
        goto <D.22602>;
        <D.24365>:
        <D.24363>:
        <D.24361>:
        <D.24359>:
        <D.24357>:
        <D.24355>:
        <D.24353>:
        <D.24351>:
        <D.24349>:
        <D.24347>:
        <D.24345>:
        <D.24343>:
        <D.24341>:
        <D.24339>:
        <D.24337>:
        <D.24335>:
        <D.24333>:
        <D.24331>:
        <D.24329>:
        <D.24327>:
        <D.24325>:
        <D.24323>:
        <D.24321>:
        <D.24319>:
        <D.24317>:
        <D.24315>:
        <D.24313>:
        <D.24311>:
        <D.24309>:
        <D.24307>:
        tins = tins->next;
        <D.22604>:
        if (tins != 0B) goto <D.22603>; else goto <D.22602>;
        <D.22602>:
        if (skip != 0) goto <D.24366>; else goto <D.24367>;
        <D.24366>:
        // predicted unlikely by continue predictor.
        goto <D.22601>;
        <D.24367>:
        D.24278 = ins->opcode;
        if (D.24278 == 783) goto <D.24368>; else goto <D.24371>;
        <D.24371>:
        D.24278 = ins->opcode;
        if (D.24278 == 781) goto <D.24368>; else goto <D.24372>;
        <D.24372>:
        D.24278 = ins->opcode;
        if (D.24278 == 340) goto <D.24368>; else goto <D.24369>;
        <D.24368>:
        sreg = ins->sreg1;
        goto <D.24370>;
        <D.24369>:
        sreg = -1;
        <D.24370>:
        if (sreg != -1) goto <D.24373>; else goto <D.24374>;
        <D.24373>:
        {
          struct MonoInst * tins;

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

            D.24375 = tins->opcode;
            D.24376 = (int) D.24375;
            D.24377 = D.24376 + -313;
            D.24378 = D.24377 * 4;
            spec = &ins_info[D.24378];
            D.24375 = tins->opcode;
            if (D.24375 == 424) goto <D.24379>; else goto <D.24380>;
            <D.24379>:
            D.24381 = tins->dreg;
            if (D.24381 == sreg) goto <D.24382>; else goto <D.24383>;
            <D.24382>:
            sreg = tins->sreg1;
            <D.24383>:
            <D.24380>:
            D.24384 = *spec;
            if (D.24384 != 32) goto <D.24385>; else goto <D.24386>;
            <D.24385>:
            D.24381 = tins->dreg;
            if (D.24381 == sreg) goto <D.24387>; else goto <D.24388>;
            <D.24387>:
            skip = 1;
            goto <D.22607>;
            <D.24388>:
            <D.24386>:
          }
          tins = tins->prev;
          <D.22609>:
          if (tins != 0B) goto <D.22608>; else goto <D.22607>;
          <D.22607>:
          if (skip != 0) goto <D.24389>; else goto <D.24390>;
          <D.24389>:
          // predicted unlikely by continue predictor.
          goto <D.22601>;
          <D.24390>:
          ins->sreg1 = sreg;
        }
        <D.24374>:
        D.24391 = cfg->verbose_level;
        if (D.24391 > 1) goto <D.24392>; else goto <D.24393>;
        <D.24392>:
        D.24394 = bb->block_num;
        printf ("licm in BB%d on ", D.24394);
        mono_print_ins (ins);
        <D.24393>:
        D.24395 = ins->prev;
        if (D.24395 != 0B) goto <D.24396>; else goto <D.24397>;
        <D.24396>:
        D.24395 = ins->prev;
        D.24398 = ins->next;
        D.24395->next = D.24398;
        <D.24397>:
        D.24398 = ins->next;
        if (D.24398 != 0B) goto <D.24399>; else goto <D.24400>;
        <D.24399>:
        D.24398 = ins->next;
        D.24395 = ins->prev;
        D.24398->prev = D.24395;
        <D.24400>:
        D.24401 = bb->code;
        if (D.24401 == ins) goto <D.24402>; else goto <D.24403>;
        <D.24402>:
        D.24398 = ins->next;
        bb->code = D.24398;
        <D.24403>:
        D.24404 = bb->last_ins;
        if (D.24404 == ins) goto <D.24405>; else goto <D.24406>;
        <D.24405>:
        D.24395 = ins->prev;
        bb->last_ins = D.24395;
        <D.24406>:
        D.24297 = idom->last_ins;
        mono_bblock_insert_before_ins (idom, D.24297, ins);
        D.24278 = ins->opcode;
        if (D.24278 == 783) goto <D.24407>; else goto <D.24409>;
        <D.24409>:
        D.24278 = ins->opcode;
        if (D.24278 == 781) goto <D.24407>; else goto <D.24408>;
        <D.24407>:
        idom->has_array_access = 1;
        <D.24408>:
      }
      <D.24289>:
    }
    <D.22601>:
    ins = n;
    if (ins != 0B) goto <D.24411>; else goto <D.24412>;
    <D.24411>:
    iftmp.51 = ins->next;
    goto <D.24413>;
    <D.24412>:
    iftmp.51 = 0B;
    <D.24413>:
    n = iftmp.51;
    <D.22611>:
    if (ins != 0B) goto <D.22610>; else goto <D.22612>;
    <D.22612>:
  }
  <D.22595>:
  bb = bb->next_bb;
  <D.22614>:
  if (bb != 0B) goto <D.22613>; else goto <D.22615>;
  <D.22615>:
  D.24258 = cfg->comp_done;
  D.24414 = D.24258 & 4294967231;
  cfg->comp_done = D.24414;
  i = 0;
  goto <D.22618>;
  <D.22617>:
  {
    struct MonoMethodVar * info;

    D.24415 = cfg->vars;
    D.24416 = (long unsigned int) i;
    D.24417 = D.24416 * 80;
    info = D.24415 + D.24417;
    info->def = 0B;
    info->uses = 0B;
  }
  i = i + 1;
  <D.22618>:
  D.24418 = cfg->num_varinfo;
  i.52 = (unsigned int) i;
  if (D.24418 > i.52) goto <D.22617>; else goto <D.22619>;
  <D.22619>:
}