mono_regname_full (int reg, int bank)
{
  _Bool D.23839;
  long int D.23840;
  long int D.23841;
  const char * D.23846;
  unsigned int bank.0;
  unsigned int D.23848;
  _Bool D.23851;
  long int D.23852;
  long int D.23853;

  D.23839 = bank != 0;
  D.23840 = (long int) D.23839;
  D.23841 = __builtin_expect (D.23840, 0);
  if (D.23841 != 0) goto <D.23842>; else goto <D.23843>;
  <D.23842>:
  if (bank == 4) goto <D.23844>; else goto <D.23845>;
  <D.23844>:
  D.23846 = mono_arch_xregname (reg);
  return D.23846;
  <D.23845>:
  bank.0 = (unsigned int) bank;
  D.23848 = bank.0 + 4294967294;
  if (D.23848 <= 1) goto <D.23849>; else goto <D.23850>;
  <D.23849>:
  D.23846 = mono_arch_regname (reg);
  return D.23846;
  <D.23850>:
  D.23851 = bank != 1;
  D.23852 = (long int) D.23851;
  D.23853 = __builtin_expect (D.23852, 0);
  if (D.23853 != 0) goto <D.23854>; else goto <D.23855>;
  <D.23854>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 248, "bank == MONO_REG_DOUBLE");
  <D.23855>:
  D.23846 = mono_arch_fregname (reg);
  return D.23846;
  <D.23843>:
  D.23846 = mono_arch_regname (reg);
  return D.23846;
}


mono_call_inst_add_outarg_reg (struct MonoCompile * cfg, struct MonoCallInst * call, int vreg, int hreg, int bank)
{
  unsigned int hreg.1;
  unsigned int D.23858;
  unsigned int vreg.2;
  _Bool D.23860;
  long int D.23861;
  long int D.23862;
  int D.23865;
  _Bool D.23866;
  long int D.23867;
  long int D.23868;
  _Bool D.23871;
  long int D.23872;
  long int D.23873;
  unsigned int D.23876;
  int D.23877;
  unsigned int D.23878;
  unsigned int D.23879;
  void * regpair.3;
  struct GSList * D.23881;
  struct MonoMemPool * D.23882;
  struct GSList * D.23883;
  _Bool D.23885;
  long int D.23886;
  long int D.23887;
  _Bool D.23890;
  long int D.23891;
  long int D.23892;
  unsigned int D.23895;
  unsigned int D.23896;
  struct GSList * D.23897;
  struct GSList * D.23898;
  guint32 regpair;

  hreg.1 = (unsigned int) hreg;
  D.23858 = hreg.1 << 24;
  vreg.2 = (unsigned int) vreg;
  regpair = D.23858 + vreg.2;
  D.23860 = bank != 0;
  D.23861 = (long int) D.23860;
  D.23862 = __builtin_expect (D.23861, 0);
  if (D.23862 != 0) goto <D.23863>; else goto <D.23864>;
  <D.23863>:
  D.23865 = regbank_size[bank];
  D.23866 = D.23865 > vreg;
  D.23867 = (long int) D.23866;
  D.23868 = __builtin_expect (D.23867, 0);
  if (D.23868 != 0) goto <D.23869>; else goto <D.23870>;
  <D.23869>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 262, "vreg >= regbank_size [bank]");
  <D.23870>:
  D.23865 = regbank_size[bank];
  D.23871 = D.23865 <= hreg;
  D.23872 = (long int) D.23871;
  D.23873 = __builtin_expect (D.23872, 0);
  if (D.23873 != 0) goto <D.23874>; else goto <D.23875>;
  <D.23874>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 263, "hreg < regbank_size [bank]");
  <D.23875>:
  D.23876 = call->used_fregs;
  D.23877 = 1 << hreg;
  D.23878 = (unsigned int) D.23877;
  D.23879 = D.23876 | D.23878;
  call->used_fregs = D.23879;
  regpair.3 = (void *) regpair;
  D.23881 = call->out_freg_args;
  D.23882 = cfg->mempool;
  D.23883 = g_slist_append_mempool (D.23882, D.23881, regpair.3);
  call->out_freg_args = D.23883;
  goto <D.23884>;
  <D.23864>:
  D.23885 = vreg <= 7;
  D.23886 = (long int) D.23885;
  D.23887 = __builtin_expect (D.23886, 0);
  if (D.23887 != 0) goto <D.23888>; else goto <D.23889>;
  <D.23888>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 267, "vreg >= MONO_MAX_IREGS");
  <D.23889>:
  D.23890 = hreg > 7;
  D.23891 = (long int) D.23890;
  D.23892 = __builtin_expect (D.23891, 0);
  if (D.23892 != 0) goto <D.23893>; else goto <D.23894>;
  <D.23893>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 268, "hreg < MONO_MAX_IREGS");
  <D.23894>:
  D.23895 = call->used_iregs;
  D.23877 = 1 << hreg;
  D.23878 = (unsigned int) D.23877;
  D.23896 = D.23895 | D.23878;
  call->used_iregs = D.23896;
  regpair.3 = (void *) regpair;
  D.23897 = call->out_ireg_args;
  D.23882 = cfg->mempool;
  D.23898 = g_slist_append_mempool (D.23882, D.23897, regpair.3);
  call->out_ireg_args = D.23898;
  <D.23884>:
}


g_slist_append_mempool (struct MonoMemPool * mp, struct GSList * list, void * data)
{
  struct GSList * D.23901;
  struct GSList * D.23902;
  struct GSList * new_list;
  struct GSList * last;

  new_list = mono_mempool_alloc (mp, 8);
  new_list->data = data;
  new_list->next = 0B;
  if (list != 0B) goto <D.23899>; else goto <D.23900>;
  <D.23899>:
  last = list;
  goto <D.8372>;
  <D.8371>:
  last = last->next;
  <D.8372>:
  D.23901 = last->next;
  if (D.23901 != 0B) goto <D.8371>; else goto <D.8373>;
  <D.8373>:
  last->next = new_list;
  D.23902 = list;
  return D.23902;
  <D.23900>:
  D.23902 = new_list;
  return D.23902;
}


mono_call_inst_add_outarg_vt (struct MonoCompile * cfg, struct MonoCallInst * call, struct MonoInst * outarg_vt)
{
  struct GSList * D.23904;
  struct MonoMemPool * D.23905;
  struct GSList * D.23906;

  D.23904 = call->outarg_vts;
  D.23905 = cfg->mempool;
  D.23906 = g_slist_append_mempool (D.23905, D.23904, outarg_vt);
  call->outarg_vts = D.23906;
}


mono_print_ji (const struct MonoJumpInfo * ji)
{
  <unnamed type> D.23907;
  struct MonoJumpInfo * D.23908;
  <unnamed type> D.23909;
  const char * D.23910;
  struct MonoMethod * D.23911;
  const char * D.23912;

  D.23907 = ji->type;
  switch (D.23907) <default: <D.23120>, case 6: <D.23118>, case 35: <D.23115>>
  <D.23115>:
  {
    struct MonoJumpInfoRgctxEntry * entry;

    entry = ji->data.rgctx_entry;
    printf ("[RGCTX_FETCH ");
    D.23908 = entry->data;
    mono_print_ji (D.23908);
    D.23909 = entry->info_type;
    D.23910 = mono_rgctx_info_type_to_str (D.23909);
    printf (" - %s]", D.23910);
    goto <D.23117>;
  }
  <D.23118>:
  {
    char * s;

    D.23911 = ji->data.method;
    s = mono_method_full_name (D.23911, 1);
    printf ("[METHODCONST - %s]", s);
    monoeg_g_free (s);
    goto <D.23117>;
  }
  <D.23120>:
  D.23907 = ji->type;
  D.23912 = patch_info_str[D.23907];
  printf ("[%s]", D.23912);
  goto <D.23117>;
  <D.23117>:
}


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

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


mono_print_ins_index (int i, struct MonoInst * ins)
{
  short unsigned int D.23915;
  int D.23916;
  int D.23917;
  short unsigned int D.23918;
  sizetype D.23919;
  const char * D.23922;
  const char * D.23924;
  int D.23927;
  int D.23932;
  int D.23934;
  int D.23937;
  int D.23940;
  struct MonoBasicBlock * * D.23943;
  struct MonoBasicBlock * * D.23944;
  struct MonoBasicBlock * D.23945;
  struct MonoBasicBlock * D.23948;
  int D.23949;
  int D.23951;
  int * D.23954;
  sizetype i.4;
  sizetype D.23956;
  sizetype D.23957;
  int * D.23958;
  int D.23959;
  int D.23960;
  void * D.23961;
  int D.23962;
  char D.23963;
  int iftmp.5;
  _Bool D.23967;
  long int D.23968;
  long int D.23969;
  int iftmp.6;
  _Bool D.23973;
  long int D.23974;
  long int D.23975;
  _Bool iftmp.7;
  _Bool D.23981;
  long int D.23982;
  long int D.23983;
  int iftmp.8;
  int D.23991;
  const char * D.24006;
  const char * D.24008;
  const char * D.24010;
  const char * D.24011;
  char D.24012;
  int iftmp.9;
  _Bool D.24016;
  long int D.24017;
  long int D.24018;
  int iftmp.10;
  _Bool D.24022;
  long int D.24023;
  long int D.24024;
  _Bool iftmp.11;
  _Bool D.24030;
  long int D.24031;
  long int D.24032;
  int iftmp.12;
  int D.24040;
  const char * D.24050;
  const char * D.24052;
  signed char D.24053;
  int iftmp.13;
  int D.24055;
  sizetype D.24056;
  const char * D.24057;
  char D.24058;
  _Bool D.24059;
  long int D.24060;
  long int D.24061;
  int iftmp.14;
  _Bool D.24065;
  long int D.24066;
  long int D.24067;
  _Bool iftmp.15;
  _Bool D.24073;
  long int D.24074;
  long int D.24075;
  int iftmp.16;
  int D.24082;
  int D.24084;
  const char * D.24089;
  int D.24090;
  void * D.24091;
  int D.24092;
  long long int D.24093;
  double D.24094;
  float D.24095;
  double D.24096;
  short unsigned int D.24097;
  struct MonoMethod * D.24102;
  unsigned char D.24106;
  unsigned char D.24107;
  const void * D.24111;
  const char * D.24116;
  void * D.24117;
  unsigned int D.24118;
  int regpair.17;
  const char * D.24120;
  struct GSList * iftmp.18;
  struct MonoBasicBlock * D.24125;
  int D.24126;
  const char * D.24130;
  char D.24131;
  int D.24134;
  const char * spec;
  int num_sregs;
  int j;
  int sregs[3];

  try
    {
      D.23915 = ins->opcode;
      D.23916 = (int) D.23915;
      D.23917 = D.23916 + -313;
      D.23918 = x86_desc_idx[D.23917];
      D.23919 = (sizetype) D.23918;
      spec = &x86_desc + D.23919;
      if (i != -1) goto <D.23920>; else goto <D.23921>;
      <D.23920>:
      D.23915 = ins->opcode;
      D.23916 = (int) D.23915;
      D.23922 = mono_inst_name (D.23916);
      printf ("\t%-2d %s", i, D.23922);
      goto <D.23923>;
      <D.23921>:
      D.23915 = ins->opcode;
      D.23916 = (int) D.23915;
      D.23924 = mono_inst_name (D.23916);
      printf (" %s", D.23924);
      <D.23923>:
      if (spec == &x86_desc) goto <D.23925>; else goto <D.23926>;
      <D.23925>:
      {
        gboolean dest_base;

        dest_base = 0;
        D.23915 = ins->opcode;
        D.23916 = (int) D.23915;
        switch (D.23916) <default: <D.23132>, case 390: <D.23130>>
        <D.23130>:
        dest_base = 1;
        goto <D.23131>;
        <D.23132>:
        goto <D.23131>;
        <D.23131>:
        D.23927 = ins->dreg;
        if (D.23927 != -1) goto <D.23928>; else goto <D.23929>;
        <D.23928>:
        if (dest_base != 0) goto <D.23930>; else goto <D.23931>;
        <D.23930>:
        D.23932 = ins->data.op[0].const_val;
        D.23927 = ins->dreg;
        printf (" [R%d + 0x%lx] <-", D.23927, D.23932);
        goto <D.23933>;
        <D.23931>:
        D.23927 = ins->dreg;
        printf (" R%d <-", D.23927);
        <D.23933>:
        <D.23929>:
        D.23934 = ins->sreg1;
        if (D.23934 != -1) goto <D.23935>; else goto <D.23936>;
        <D.23935>:
        D.23934 = ins->sreg1;
        printf (" R%d", D.23934);
        <D.23936>:
        D.23937 = ins->sreg2;
        if (D.23937 != -1) goto <D.23938>; else goto <D.23939>;
        <D.23938>:
        D.23937 = ins->sreg2;
        printf (" R%d", D.23937);
        <D.23939>:
        D.23940 = ins->sreg3;
        if (D.23940 != -1) goto <D.23941>; else goto <D.23942>;
        <D.23941>:
        D.23940 = ins->sreg3;
        printf (" R%d", D.23940);
        <D.23942>:
        D.23915 = ins->opcode;
        D.23916 = (int) D.23915;
        switch (D.23916) <default: <D.23156>, case 314: <D.23152>, case 319: <D.23144>, case 320: <D.23147>, case 321: <D.23145>, case 332: <D.23155>, case 334: <D.23153>, case 367: <D.23154>, case 555: <D.23134>, case 556: <D.23139>, case 557: <D.23137>, case 558: <D.23141>, case 559: <D.23135>, case 560: <D.23133>, case 561: <D.23140>, case 562: <D.23138>, case 563: <D.23142>, case 564: <D.23136>, case 964: <D.23146>>
        <D.23133>:
        <D.23134>:
        <D.23135>:
        <D.23136>:
        <D.23137>:
        <D.23138>:
        <D.23139>:
        <D.23140>:
        <D.23141>:
        <D.23142>:
        D.23943 = ins->data.op[1].many_blocks;
        D.23944 = D.23943 + 4;
        D.23945 = *D.23944;
        if (D.23945 == 0B) goto <D.23946>; else goto <D.23947>;
        <D.23946>:
        D.23943 = ins->data.op[1].many_blocks;
        D.23948 = *D.23943;
        D.23949 = D.23948->block_num;
        printf (" [B%d]", D.23949);
        goto <D.23950>;
        <D.23947>:
        D.23943 = ins->data.op[1].many_blocks;
        D.23944 = D.23943 + 4;
        D.23945 = *D.23944;
        D.23951 = D.23945->block_num;
        D.23943 = ins->data.op[1].many_blocks;
        D.23948 = *D.23943;
        D.23949 = D.23948->block_num;
        printf (" [B%dB%d]", D.23949, D.23951);
        <D.23950>:
        goto <D.23143>;
        <D.23144>:
        <D.23145>:
        <D.23146>:
        <D.23147>:
        {
          int i;

          D.23932 = ins->data.op[0].const_val;
          printf (" [%d (", D.23932);
          i = 0;
          goto <D.23150>;
          <D.23149>:
          if (i != 0) goto <D.23952>; else goto <D.23953>;
          <D.23952>:
          printf (", ");
          <D.23953>:
          D.23954 = ins->data.op[1].phi_args;
          i.4 = (sizetype) i;
          D.23956 = i.4 + 1;
          D.23957 = D.23956 * 4;
          D.23958 = D.23954 + D.23957;
          D.23959 = *D.23958;
          printf ("R%d", D.23959);
          i = i + 1;
          <D.23150>:
          D.23954 = ins->data.op[1].phi_args;
          D.23960 = *D.23954;
          if (D.23960 > i) goto <D.23149>; else goto <D.23151>;
          <D.23151>:
          printf (")]");
          goto <D.23143>;
        }
        <D.23152>:
        <D.23153>:
        D.23961 = ins->data.op[0].p;
        D.23962 = MEM[(struct MonoInst *)D.23961].dreg;
        printf (" R%d", D.23962);
        goto <D.23143>;
        <D.23154>:
        <D.23155>:
        D.23932 = ins->data.op[0].const_val;
        printf (" + 0x%lx", D.23932);
        goto <D.23143>;
        <D.23156>:
        goto <D.23143>;
        <D.23143>:
        printf ("\n");
        return;
      }
      <D.23926>:
      D.23963 = *spec;
      if (D.23963 != 0) goto <D.23964>; else goto <D.23965>;
      <D.23964>:
      {
        int bank;

        D.23963 = *spec;
        D.23967 = D.23963 == 102;
        D.23968 = (long int) D.23967;
        D.23969 = __builtin_expect (D.23968, 0);
        if (D.23969 == 0) goto <D.23970>; else goto <D.23971>;
        <D.23970>:
        D.23963 = *spec;
        D.23973 = D.23963 == 120;
        D.23974 = (long int) D.23973;
        D.23975 = __builtin_expect (D.23974, 0);
        if (D.23975 != 0) goto <D.23976>; else goto <D.23977>;
        <D.23976>:
        iftmp.6 = 4;
        goto <D.23978>;
        <D.23977>:
        iftmp.6 = 0;
        <D.23978>:
        iftmp.5 = iftmp.6;
        goto <D.23979>;
        <D.23971>:
        iftmp.5 = 1;
        <D.23979>:
        bank = iftmp.5;
        D.23981 = bank != 0;
        D.23982 = (long int) D.23981;
        D.23983 = __builtin_expect (D.23982, 0);
        if (D.23983 != 0) goto <D.23984>; else goto <D.23985>;
        <D.23984>:
        D.23927 = ins->dreg;
        if (D.23927 < 0) goto <D.23987>; else goto <D.23990>;
        <D.23990>:
        D.23927 = ins->dreg;
        D.23991 = regbank_size[bank];
        if (D.23927 >= D.23991) goto <D.23987>; else goto <D.23988>;
        <D.23987>:
        iftmp.8 = 1;
        goto <D.23989>;
        <D.23988>:
        iftmp.8 = 0;
        <D.23989>:
        iftmp.7 = (_Bool) iftmp.8;
        goto <D.23992>;
        <D.23985>:
        D.23927 = ins->dreg;
        iftmp.7 = D.23927 > 7;
        <D.23992>:
        if (iftmp.7 != 0) goto <D.23993>; else goto <D.23994>;
        <D.23993>:
        D.23963 = *spec;
        if (D.23963 == 98) goto <D.23995>; else goto <D.23996>;
        <D.23995>:
        D.23932 = ins->data.op[0].const_val;
        if (D.23932 == 0) goto <D.23997>; else goto <D.23998>;
        <D.23997>:
        D.23927 = ins->dreg;
        printf (" [R%d] <-", D.23927);
        goto <D.23999>;
        <D.23998>:
        D.23932 = ins->data.op[0].const_val;
        D.23927 = ins->dreg;
        printf (" [R%d + 0x%lx] <-", D.23927, D.23932);
        <D.23999>:
        goto <D.24000>;
        <D.23996>:
        D.23927 = ins->dreg;
        printf (" R%d <-", D.23927);
        <D.24000>:
        goto <D.24001>;
        <D.23994>:
        D.23963 = *spec;
        if (D.23963 == 98) goto <D.24002>; else goto <D.24003>;
        <D.24002>:
        D.23932 = ins->data.op[0].const_val;
        if (D.23932 == 0) goto <D.24004>; else goto <D.24005>;
        <D.24004>:
        D.23927 = ins->dreg;
        D.24006 = mono_arch_regname (D.23927);
        printf (" [%s] <-", D.24006);
        goto <D.24007>;
        <D.24005>:
        D.23932 = ins->data.op[0].const_val;
        D.23927 = ins->dreg;
        D.24008 = mono_arch_regname (D.23927);
        printf (" [%s + 0x%lx] <-", D.24008, D.23932);
        <D.24007>:
        goto <D.24009>;
        <D.24003>:
        D.23927 = ins->dreg;
        D.24010 = mono_regname_full (D.23927, bank);
        printf (" %s <-", D.24010);
        <D.24009>:
        <D.24001>:
      }
      <D.23965>:
      D.24011 = spec + 1;
      D.24012 = *D.24011;
      if (D.24012 != 0) goto <D.24013>; else goto <D.24014>;
      <D.24013>:
      {
        int bank;

        D.24011 = spec + 1;
        D.24012 = *D.24011;
        D.24016 = D.24012 == 102;
        D.24017 = (long int) D.24016;
        D.24018 = __builtin_expect (D.24017, 0);
        if (D.24018 == 0) goto <D.24019>; else goto <D.24020>;
        <D.24019>:
        D.24011 = spec + 1;
        D.24012 = *D.24011;
        D.24022 = D.24012 == 120;
        D.24023 = (long int) D.24022;
        D.24024 = __builtin_expect (D.24023, 0);
        if (D.24024 != 0) goto <D.24025>; else goto <D.24026>;
        <D.24025>:
        iftmp.10 = 4;
        goto <D.24027>;
        <D.24026>:
        iftmp.10 = 0;
        <D.24027>:
        iftmp.9 = iftmp.10;
        goto <D.24028>;
        <D.24020>:
        iftmp.9 = 1;
        <D.24028>:
        bank = iftmp.9;
        D.24030 = bank != 0;
        D.24031 = (long int) D.24030;
        D.24032 = __builtin_expect (D.24031, 0);
        if (D.24032 != 0) goto <D.24033>; else goto <D.24034>;
        <D.24033>:
        D.23934 = ins->sreg1;
        if (D.23934 < 0) goto <D.24036>; else goto <D.24039>;
        <D.24039>:
        D.23934 = ins->sreg1;
        D.24040 = regbank_size[bank];
        if (D.23934 >= D.24040) goto <D.24036>; else goto <D.24037>;
        <D.24036>:
        iftmp.12 = 1;
        goto <D.24038>;
        <D.24037>:
        iftmp.12 = 0;
        <D.24038>:
        iftmp.11 = (_Bool) iftmp.12;
        goto <D.24041>;
        <D.24034>:
        D.23934 = ins->sreg1;
        iftmp.11 = D.23934 > 7;
        <D.24041>:
        if (iftmp.11 != 0) goto <D.24042>; else goto <D.24043>;
        <D.24042>:
        D.24011 = spec + 1;
        D.24012 = *D.24011;
        if (D.24012 == 98) goto <D.24044>; else goto <D.24045>;
        <D.24044>:
        D.23932 = ins->data.op[0].const_val;
        D.23934 = ins->sreg1;
        printf (" [R%d + 0x%lx]", D.23934, D.23932);
        goto <D.24046>;
        <D.24045>:
        D.23934 = ins->sreg1;
        printf (" R%d", D.23934);
        <D.24046>:
        goto <D.24047>;
        <D.24043>:
        D.24011 = spec + 1;
        D.24012 = *D.24011;
        if (D.24012 == 98) goto <D.24048>; else goto <D.24049>;
        <D.24048>:
        D.23932 = ins->data.op[0].const_val;
        D.23934 = ins->sreg1;
        D.24050 = mono_arch_regname (D.23934);
        printf (" [%s + 0x%lx]", D.24050, D.23932);
        goto <D.24051>;
        <D.24049>:
        D.23934 = ins->sreg1;
        D.24052 = mono_regname_full (D.23934, bank);
        printf (" %s", D.24052);
        <D.24051>:
        <D.24047>:
      }
      <D.24014>:
      D.23934 = ins->sreg1;
      sregs[0] = D.23934;
      D.23937 = ins->sreg2;
      sregs[1] = D.23937;
      D.23940 = ins->sreg3;
      sregs[2] = D.23940;
      D.23915 = ins->opcode;
      D.23916 = (int) D.23915;
      D.23917 = D.23916 + -313;
      D.24053 = ins_sreg_counts[D.23917];
      num_sregs = (int) D.24053;
      j = 1;
      goto <D.23161>;
      <D.23160>:
      {
        int bank;

        D.24055 = j + 1;
        D.24056 = (sizetype) D.24055;
        D.24057 = spec + D.24056;
        D.24058 = *D.24057;
        D.24059 = D.24058 == 102;
        D.24060 = (long int) D.24059;
        D.24061 = __builtin_expect (D.24060, 0);
        if (D.24061 == 0) goto <D.24062>; else goto <D.24063>;
        <D.24062>:
        D.24055 = j + 1;
        D.24056 = (sizetype) D.24055;
        D.24057 = spec + D.24056;
        D.24058 = *D.24057;
        D.24065 = D.24058 == 120;
        D.24066 = (long int) D.24065;
        D.24067 = __builtin_expect (D.24066, 0);
        if (D.24067 != 0) goto <D.24068>; else goto <D.24069>;
        <D.24068>:
        iftmp.14 = 4;
        goto <D.24070>;
        <D.24069>:
        iftmp.14 = 0;
        <D.24070>:
        iftmp.13 = iftmp.14;
        goto <D.24071>;
        <D.24063>:
        iftmp.13 = 1;
        <D.24071>:
        bank = iftmp.13;
        D.24073 = bank != 0;
        D.24074 = (long int) D.24073;
        D.24075 = __builtin_expect (D.24074, 0);
        if (D.24075 != 0) goto <D.24076>; else goto <D.24077>;
        <D.24076>:
        D.24082 = sregs[j];
        if (D.24082 < 0) goto <D.24079>; else goto <D.24083>;
        <D.24083>:
        D.24082 = sregs[j];
        D.24084 = regbank_size[bank];
        if (D.24082 >= D.24084) goto <D.24079>; else goto <D.24080>;
        <D.24079>:
        iftmp.16 = 1;
        goto <D.24081>;
        <D.24080>:
        iftmp.16 = 0;
        <D.24081>:
        iftmp.15 = (_Bool) iftmp.16;
        goto <D.24085>;
        <D.24077>:
        D.24082 = sregs[j];
        iftmp.15 = D.24082 > 7;
        <D.24085>:
        if (iftmp.15 != 0) goto <D.24086>; else goto <D.24087>;
        <D.24086>:
        D.24082 = sregs[j];
        printf (" R%d", D.24082);
        goto <D.24088>;
        <D.24087>:
        D.24082 = sregs[j];
        D.24089 = mono_regname_full (D.24082, bank);
        printf (" %s", D.24089);
        <D.24088>:
      }
      j = j + 1;
      <D.23161>:
      if (j < num_sregs) goto <D.23160>; else goto <D.23162>;
      <D.23162>:
      D.23915 = ins->opcode;
      D.23916 = (int) D.23915;
      switch (D.23916) <default: <D.23231>, case 323: <D.23167>, case 327: <D.23166>, case 341: <D.23230>, case 343: <D.23190>, case 345: <D.23191>, case 346: <D.23179>, case 347: <D.23181>, case 348: <D.23180>, case 349: <D.23182>, case 352: <D.23183>, case 355: <D.23184>, case 356: <D.23185>, case 357: <D.23186>, case 358: <D.23187>, case 359: <D.23188>, case 360: <D.23189>, case 362: <D.23163>, case 363: <D.23176>, case 364: <D.23178>, case 365: <D.23177>, case 433: <D.23174>, case 434: <D.23173>, case 446: <D.23204>, case 448: <D.23192>, case 542: <D.23175>, case 555: <D.23217>, case 556: <D.23222>, case 557: <D.23220>, case 558: <D.23224>, case 559: <D.23218>, case 560: <D.23216>, case 561: <D.23223>, case 562: <D.23221>, case 563: <D.23225>, case 564: <D.23219>, case 629: <D.23168>, case 630: <D.23169>, case 636: <D.23170>, case 637: <D.23171>, case 638: <D.23172>, case 652: <D.23207>, case 653: <D.23212>, case 654: <D.23210>, case 655: <D.23214>, case 656: <D.23208>, case 657: <D.23206>, case 658: <D.23213>, case 659: <D.23211>, case 660: <D.23215>, case 661: <D.23209>, case 739: <D.23205>, case 998: <D.23226>, case 999: <D.23227>, case 1000: <D.23228>, case 1001: <D.23229>, case 1033: <D.23165>>
      <D.23163>:
      D.23932 = ins->data.op[0].const_val;
      printf (" [%d]", D.23932);
      goto <D.23164>;
      <D.23165>:
      <D.23166>:
      <D.23167>:
      <D.23168>:
      <D.23169>:
      <D.23170>:
      <D.23171>:
      <D.23172>:
      <D.23173>:
      D.24090 = ins->data.op[1].const_val;
      printf (" [%d]", D.24090);
      goto <D.23164>;
      <D.23174>:
      <D.23175>:
      D.24091 = ins->data.op[1].p;
      D.24092 = (int) D.24091;
      printf (" [%d]", D.24092);
      goto <D.23164>;
      <D.23176>:
      D.24093 = ins->data.i8const;
      printf (" [%lld]", D.24093);
      goto <D.23164>;
      <D.23177>:
      D.23961 = ins->data.op[0].p;
      D.24094 = MEM[(double *)D.23961];
      printf (" [%f]", D.24094);
      goto <D.23164>;
      <D.23178>:
      D.23961 = ins->data.op[0].p;
      D.24095 = MEM[(float *)D.23961];
      D.24096 = (double) D.24095;
      printf (" [%f]", D.24096);
      goto <D.23164>;
      <D.23179>:
      <D.23180>:
      <D.23181>:
      <D.23182>:
      <D.23183>:
      <D.23184>:
      <D.23185>:
      <D.23186>:
      <D.23187>:
      <D.23188>:
      <D.23189>:
      <D.23190>:
      <D.23191>:
      <D.23192>:
      {
        struct MonoCallInst * call;
        struct GSList * list;

        call = ins;
        D.23915 = ins->opcode;
        D.24097 = D.23915 + 65181;
        if (D.24097 <= 2) goto <D.24098>; else goto <D.24099>;
        <D.24098>:
        D.23927 = ins->dreg;
        if (D.23927 != -1) goto <D.24100>; else goto <D.24101>;
        <D.24100>:
        D.23927 = ins->dreg;
        printf (" R%d <-", D.23927);
        <D.24101>:
        <D.24099>:
        D.24102 = call->method;
        if (D.24102 != 0B) goto <D.24103>; else goto <D.24104>;
        <D.24103>:
        {
          char * full_name;

          D.24102 = call->method;
          full_name = mono_method_full_name (D.24102, 1);
          printf (" [%s]", full_name);
          monoeg_g_free (full_name);
        }
        goto <D.24105>;
        <D.24104>:
        D.24106 = BIT_FIELD_REF <*call, 8, 640>;
        D.24107 = D.24106 & 4;
        if (D.24107 != 0) goto <D.24108>; else goto <D.24109>;
        <D.24108>:
        {
          struct MonoJumpInfo * ji;

          ji = call->fptr;
          printf (" ");
          mono_print_ji (ji);
        }
        goto <D.24110>;
        <D.24109>:
        D.24111 = call->fptr;
        if (D.24111 != 0B) goto <D.24112>; else goto <D.24113>;
        <D.24112>:
        {
          struct MonoJitICallInfo * info;

          D.24111 = call->fptr;
          info = mono_find_jit_icall_by_addr (D.24111);
          if (info != 0B) goto <D.24114>; else goto <D.24115>;
          <D.24114>:
          D.24116 = info->name;
          printf (" [%s]", D.24116);
          <D.24115>:
        }
        <D.24113>:
        <D.24110>:
        <D.24105>:
        list = call->out_ireg_args;
        goto <D.23202>;
        <D.23201>:
        {
          guint32 regpair;
          int reg;
          int hreg;

          D.24117 = list->data;
          regpair = (guint32) D.24117;
          D.24118 = regpair >> 24;
          hreg = (int) D.24118;
          regpair.17 = (int) regpair;
          reg = regpair.17 & 16777215;
          D.24120 = mono_arch_regname (hreg);
          printf (" [%s <- R%d]", D.24120, reg);
          if (list != 0B) goto <D.24122>; else goto <D.24123>;
          <D.24122>:
          iftmp.18 = list->next;
          goto <D.24124>;
          <D.24123>:
          iftmp.18 = 0B;
          <D.24124>:
          list = iftmp.18;
        }
        <D.23202>:
        if (list != 0B) goto <D.23201>; else goto <D.23203>;
        <D.23203>:
        goto <D.23164>;
      }
      <D.23204>:
      <D.23205>:
      D.24125 = ins->data.op[0].target_block;
      D.24126 = D.24125->block_num;
      printf (" [B%d]", D.24126);
      goto <D.23164>;
      <D.23206>:
      <D.23207>:
      <D.23208>:
      <D.23209>:
      <D.23210>:
      <D.23211>:
      <D.23212>:
      <D.23213>:
      <D.23214>:
      <D.23215>:
      <D.23216>:
      <D.23217>:
      <D.23218>:
      <D.23219>:
      <D.23220>:
      <D.23221>:
      <D.23222>:
      <D.23223>:
      <D.23224>:
      <D.23225>:
      D.23943 = ins->data.op[1].many_blocks;
      D.23944 = D.23943 + 4;
      D.23945 = *D.23944;
      if (D.23945 == 0B) goto <D.24127>; else goto <D.24128>;
      <D.24127>:
      D.23943 = ins->data.op[1].many_blocks;
      D.23948 = *D.23943;
      D.23949 = D.23948->block_num;
      printf (" [B%d]", D.23949);
      goto <D.24129>;
      <D.24128>:
      D.23943 = ins->data.op[1].many_blocks;
      D.23944 = D.23943 + 4;
      D.23945 = *D.23944;
      D.23951 = D.23945->block_num;
      D.23943 = ins->data.op[1].many_blocks;
      D.23948 = *D.23943;
      D.23949 = D.23948->block_num;
      printf (" [B%dB%d]", D.23949, D.23951);
      <D.24129>:
      goto <D.23164>;
      <D.23226>:
      <D.23227>:
      <D.23228>:
      <D.23229>:
      D.24090 = ins->data.op[1].const_val;
      printf (" R%d", D.24090);
      goto <D.23164>;
      <D.23230>:
      D.24090 = ins->data.op[1].const_val;
      printf (" il: %x", D.24090);
      goto <D.23164>;
      <D.23231>:
      goto <D.23164>;
      <D.23164>:
      D.24130 = spec + 5;
      D.24131 = *D.24130;
      if (D.24131 != 0) goto <D.24132>; else goto <D.24133>;
      <D.24132>:
      D.24130 = spec + 5;
      D.24131 = *D.24130;
      D.24134 = (int) D.24131;
      printf (" clobbers: %c", D.24134);
      <D.24133>:
      printf ("\n");
    }
  finally
    {
      sregs = {CLOBBER};
    }
}


mono_print_ins (struct MonoInst * ins)
{
  mono_print_ins_index (-1, ins);
}


mono_local_regalloc (struct MonoCompile * cfg, struct MonoBasicBlock * bb)
{
  struct MonoInst * D.24141;
  int desc_to_fixed_reg_inited.19;
  gint8 iftmp.20;
  _Bool D.24148;
  _Bool D.24149;
  _Bool D.24150;
  gint8 iftmp.21;
  gint8 iftmp.22;
  gint8 iftmp.23;
  gint8 iftmp.24;
  int D.24170;
  short unsigned int D.24171;
  sizetype D.24172;
  int D.24173;
  char D.24174;
  char D.24177;
  const char * D.24180;
  const char * D.24181;
  char D.24182;
  const char * D.24185;
  char D.24186;
  const char * D.24189;
  const char * D.24190;
  char D.24191;
  const char * D.24194;
  char D.24195;
  const char * D.24198;
  unsigned int D.24199;
  int D.24200;
  unsigned int D.24201;
  void * D.24202;
  int D.24205;
  int D.24210;
  int D.24211;
  unsigned int D.24212;
  unsigned int D.24213;
  struct MonoMemPool * D.24214;
  void * D.24215;
  int D.24217;
  _Bool D.24218;
  long int D.24219;
  long int D.24220;
  unsigned int D.24223;
  short unsigned int D.24226;
  int D.24227;
  int D.24228;
  short unsigned int D.24229;
  sizetype D.24230;
  int D.24231;
  unsigned int D.24236;
  unsigned int D.24237;
  void * D.24238;
  _Bool D.24239;
  _Bool D.24240;
  _Bool D.24241;
  int D.24244;
  sizetype D.24245;
  sizetype D.24246;
  sizetype D.24247;
  struct RegTrack * D.24248;
  int D.24249;
  int D.24250;
  int D.24251;
  signed char D.24252;
  int D.24253;
  _Bool D.24254;
  long int D.24255;
  long int D.24256;
  unsigned int D.24261;
  unsigned int D.24262;
  void * D.24263;
  int D.24264;
  sizetype D.24265;
  const char * D.24266;
  char D.24267;
  _Bool D.24268;
  _Bool D.24269;
  _Bool D.24270;
  int D.24273;
  sizetype D.24274;
  sizetype D.24275;
  sizetype D.24276;
  struct RegTrack * D.24277;
  _Bool D.24278;
  long int D.24279;
  long int D.24280;
  int D.24283;
  _Bool D.24284;
  long int D.24285;
  long int D.24286;
  const char * D.24289;
  int iftmp.25;
  _Bool D.24300;
  long int D.24301;
  long int D.24302;
  int iftmp.26;
  _Bool D.24306;
  long int D.24307;
  long int D.24308;
  _Bool D.24313;
  long int D.24314;
  long int D.24315;
  _Bool iftmp.27;
  _Bool D.24319;
  long int D.24320;
  long int D.24321;
  int iftmp.28;
  int D.24329;
  unsigned int sreg.29;
  unsigned int D.24334;
  struct RegTrack * D.24335;
  int D.24336;
  _Bool D.24337;
  long int D.24338;
  long int D.24339;
  gint32 * D.24342;
  unsigned int D.24343;
  gint32 * D.24344;
  _Bool D.24345;
  _Bool D.24346;
  _Bool D.24347;
  sizetype sreg.30;
  sizetype D.24351;
  sizetype D.24352;
  gint32 * D.24353;
  sizetype D.24356;
  struct RegTrack * D.24357;
  int D.24358;
  int iftmp.31;
  _Bool D.24364;
  long int D.24365;
  long int D.24366;
  int iftmp.32;
  _Bool D.24370;
  long int D.24371;
  long int D.24372;
  struct RegTrack * D.24379;
  _Bool D.24380;
  long int D.24381;
  long int D.24382;
  unsigned int D.24385;
  gint32 * D.24386;
  int D.24389;
  int D.24391;
  signed char D.24392;
  unsigned int D.24395;
  unsigned int D.24396;
  regmask_t iftmp.33;
  unsigned int D.24401;
  _Bool D.24402;
  _Bool D.24403;
  _Bool D.24404;
  sizetype D.24407;
  gint32 * D.24408;
  int D.24411;
  unsigned int iftmp.34;
  unsigned int iftmp.35;
  const char * D.24426;
  char D.24427;
  short unsigned int D.24430;
  short unsigned int D.24431;
  _Bool D.24432;
  short unsigned int D.24433;
  _Bool D.24434;
  _Bool D.24435;
  short unsigned int D.24437;
  short unsigned int D.24439;
  short unsigned int D.24441;
  short unsigned int D.24443;
  void * D.24447;
  unsigned int D.24448;
  int regpair.36;
  struct GSList * iftmp.37;
  unsigned int D.24456;
  int regpair.38;
  struct GSList * iftmp.39;
  struct MonoInst * iftmp.40;
  char spec_dest.41;
  int D.24469;
  int D.24470;
  unsigned int D.24471;
  signed char D.24472;
  int D.24473;
  regmask_t iftmp.42;
  int D.24482;
  signed char D.24483;
  unsigned int D.24484;
  regmask_t iftmp.43;
  unsigned int D.24493;
  unsigned int D.24496;
  unsigned int D.24497;
  unsigned int D.24498;
  int D.24501;
  unsigned int D.24504;
  unsigned int D.24505;
  gint32 * D.24506;
  int D.24507;
  unsigned int sreg.44;
  unsigned int D.24513;
  gint32 * D.24514;
  int D.24515;
  unsigned int D.24520;
  unsigned int D.24521;
  unsigned int sreg.45;
  unsigned int D.24528;
  unsigned int D.24529;
  unsigned int D.24533;
  unsigned int D.24534;
  const char * D.24539;
  unsigned int D.24545;
  unsigned int D.24546;
  unsigned int D.24550;
  unsigned int D.24551;
  _Bool D.24559;
  long int D.24560;
  long int D.24561;
  const char * D.24566;
  const char * D.24567;
  int iftmp.46;
  int iftmp.47;
  _Bool iftmp.48;
  int iftmp.49;
  int D.24609;
  unsigned int D.24612;
  unsigned int D.24613;
  int D.24614;
  unsigned int D.24617;
  unsigned int D.24618;
  _Bool iftmp.50;
  int iftmp.51;
  unsigned int D.24632;
  unsigned int D.24633;
  long int iftmp.52;
  int iftmp.53;
  _Bool D.24646;
  _Bool D.24648;
  long int D.24649;
  int D.24654;
  int D.24657;
  guint32 iftmp.54;
  unsigned int D.24664;
  gint32 * D.24665;
  int D.24666;
  unsigned int D.24667;
  int dest_dreg2.55;
  unsigned int D.24677;
  unsigned int D.24679;
  unsigned int D.24680;
  _Bool iftmp.56;
  int iftmp.57;
  const char * D.24703;
  _Bool D.24708;
  long int D.24709;
  long int D.24710;
  int iftmp.58;
  unsigned int prev_dreg.59;
  unsigned int D.24717;
  gint32 * D.24718;
  int D.24719;
  unsigned int D.24720;
  unsigned int D.24722;
  unsigned int D.24723;
  _Bool D.24725;
  long int D.24726;
  long int D.24727;
  unsigned int iftmp.60;
  unsigned int iftmp.61;
  unsigned int reg2.62;
  unsigned int D.24739;
  gint32 * D.24740;
  unsigned int D.24750;
  unsigned int D.24751;
  int D.24756;
  const char * D.24759;
  _Bool iftmp.63;
  _Bool iftmp.64;
  int iftmp.65;
  int iftmp.66;
  _Bool D.24776;
  unsigned int D.24780;
  unsigned int D.24781;
  unsigned int D.24782;
  int iftmp.67;
  unsigned int val.68;
  unsigned int D.24790;
  unsigned int D.24791;
  int iftmp.69;
  unsigned int D.24803;
  struct RegTrack * D.24804;
  int D.24805;
  const char * D.24810;
  _Bool iftmp.70;
  int iftmp.71;
  _Bool D.24826;
  long int D.24827;
  long int D.24828;
  unsigned int D.24833;
  struct RegTrack * D.24834;
  int D.24835;
  const char * D.24836;
  struct MonoRegState * D.24846;
  int * D.24847;
  unsigned int dest_dreg.72;
  unsigned int D.24849;
  int * D.24850;
  int D.24851;
  int D.24852;
  int D.24856;
  unsigned int D.24865;
  unsigned int D.24866;
  unsigned int D.24867;
  unsigned int D.24868;
  unsigned int D.24871;
  unsigned int D.24872;
  int D.24877;
  _Bool D.24885;
  long int D.24886;
  long int D.24887;
  _Bool D.24889;
  long int D.24890;
  long int D.24891;
  sizetype prev_dreg.73;
  sizetype D.24896;
  sizetype D.24897;
  gint32 * D.24898;
  unsigned int D.24900;
  long long unsigned int D.24901;
  long long unsigned int D.24902;
  unsigned int s.74;
  unsigned int D.24906;
  _Bool D.24911;
  _Bool D.24912;
  _Bool D.24913;
  int D.24917;
  unsigned int D.24920;
  unsigned int D.24921;
  gint32 * D.24922;
  unsigned int D.24923;
  unsigned int D.24924;
  unsigned int D.24936;
  int * D.24942;
  unsigned int j.75;
  unsigned int D.24944;
  int * D.24945;
  int D.24946;
  unsigned int D.24949;
  unsigned int D.24950;
  gint32 * D.24951;
  int D.24952;
  short unsigned int D.24957;
  short unsigned int D.24958;
  _Bool D.24959;
  short unsigned int D.24960;
  _Bool D.24961;
  _Bool D.24962;
  void * D.24970;
  unsigned int D.24971;
  int regpair.76;
  unsigned int D.24973;
  unsigned int D.24974;
  unsigned int D.24975;
  unsigned int D.24976;
  const char * D.24979;
  struct GSList * iftmp.77;
  unsigned int D.24986;
  int regpair.78;
  const char * D.24990;
  struct GSList * iftmp.79;
  int iftmp.80;
  _Bool D.24996;
  long int D.24997;
  long int D.24998;
  int iftmp.81;
  _Bool D.25002;
  long int D.25003;
  long int D.25004;
  long int iftmp.82;
  int iftmp.83;
  _Bool D.25021;
  _Bool D.25023;
  long int D.25024;
  _Bool D.25029;
  long int D.25030;
  long int D.25031;
  _Bool D.25034;
  long int D.25035;
  long int D.25036;
  unsigned int sreg1.84;
  unsigned int D.25040;
  gint32 * D.25041;
  int D.25042;
  const char * D.25049;
  unsigned int iftmp.85;
  unsigned int iftmp.86;
  unsigned int D.25058;
  unsigned int D.25059;
  _Bool D.25060;
  long int D.25061;
  long int D.25062;
  unsigned int D.25065;
  sizetype sreg1.87;
  sizetype D.25069;
  sizetype D.25070;
  gint32 * D.25071;
  int D.25072;
  int D.25077;
  const char * D.25080;
  unsigned int D.25081;
  int D.25088;
  unsigned int D.25089;
  unsigned int D.25091;
  unsigned int D.25092;
  unsigned int D.25096;
  unsigned int D.25099;
  unsigned int D.25100;
  gint32 * D.25101;
  int D.25102;
  unsigned int D.25105;
  _Bool iftmp.88;
  int iftmp.89;
  int D.25129;
  unsigned int D.25134;
  unsigned int D.25135;
  unsigned int D.25138;
  unsigned int D.25149;
  struct RegTrack * D.25150;
  const char * D.25153;
  int D.25156;
  unsigned int D.25162;
  unsigned int D.25164;
  unsigned int D.25165;
  unsigned int D.25166;
  _Bool D.25167;
  _Bool D.25168;
  _Bool D.25169;
  _Bool D.25176;
  long int D.25177;
  long int D.25178;
  int iftmp.90;
  unsigned int D.25184;
  unsigned int D.25185;
  gint32 * D.25186;
  int D.25187;
  unsigned int D.25188;
  unsigned int D.25190;
  unsigned int D.25191;
  _Bool D.25193;
  long int D.25194;
  long int D.25195;
  unsigned int iftmp.91;
  unsigned int iftmp.92;
  unsigned int reg2.93;
  unsigned int D.25207;
  gint32 * D.25208;
  const char * D.25222;
  int iftmp.94;
  _Bool D.25230;
  long int D.25231;
  long int D.25232;
  int iftmp.95;
  _Bool D.25236;
  long int D.25237;
  long int D.25238;
  int D.25243;
  const char * D.25248;
  const char * D.25249;
  _Bool D.25250;
  long int D.25251;
  long int D.25252;
  sizetype D.25258;
  sizetype D.25259;
  sizetype D.25260;
  gint32 * D.25261;
  int D.25262;
  _Bool D.25265;
  long int D.25266;
  long int D.25267;
  _Bool D.25270;
  long int D.25271;
  long int D.25272;
  const char * D.25277;
  const char * D.25278;
  unsigned int D.25281;
  unsigned int D.25282;
  int iftmp.96;
  int iftmp.97;
  unsigned int D.25296;
  unsigned int D.25298;
  unsigned int D.25299;
  _Bool iftmp.98;
  int iftmp.99;
  unsigned int D.25312;
  gint32 * D.25313;
  struct RegTrack * D.25324;
  const char * D.25327;
  unsigned int D.25330;
  unsigned int D.25331;
  unsigned int D.25332;
  unsigned int D.25333;
  _Bool D.25335;
  _Bool D.25336;
  _Bool D.25337;
  _Bool D.25340;
  long int D.25341;
  long int D.25342;
  int D.25347;
  _Bool D.25348;
  long int D.25349;
  long int D.25350;
  struct MonoInst * iftmp.100;
  _Bool D.25361;
  long int D.25362;
  long int D.25363;
  int D.25372;
  int D.25379;
  int D.25380;
  _Bool D.25383;
  long int D.25384;
  long int D.25385;
  _Bool D.25389;
  long int D.25390;
  long int D.25391;
  int D.25394;
  int D.25395;
  int D.25400;
  int D.25401;
  const unsigned char * D.25402;
  _Bool D.25407;
  long int D.25408;
  long int D.25409;
  int D.25412;
  _Bool D.25437;
  long int D.25438;
  long int D.25439;
  int sp.101;
  _Bool D.25443;
  long int D.25444;
  long int D.25445;
  const char * iftmp.102;
  struct MonoBasicBlock * D.25455;
  short int D.25458;
  struct MonoBasicBlock * * D.25460;
  struct MonoBasicBlock * D.25461;
  struct MonoInst * ins;
  struct MonoInst * prev;
  struct MonoInst * last;
  struct MonoInst * * tmp;
  struct MonoRegState * rs;
  int i;
  int j;
  int val;
  int max;
  struct RegTrack * reginfo;
  const char * spec;
  unsigned char spec_src1;
  unsigned char spec_dest;
  int bank;
  gboolean has_fp;
  int fpstack[8];
  int sp;
  int num_sregs;
  int sregs[3];

  try
    {
      rs = cfg->rs;
      bank = 0;
      has_fp = 0;
      sp = 0;
      num_sregs = 0;
      D.24141 = bb->code;
      if (D.24141 == 0B) goto <D.24142>; else goto <D.24143>;
      <D.24142>:
      return;
      <D.24143>:
      desc_to_fixed_reg_inited.19 = desc_to_fixed_reg_inited;
      if (desc_to_fixed_reg_inited.19 == 0) goto <D.24145>; else goto <D.24146>;
      <D.24145>:
      i = 0;
      goto <D.23408>;
      <D.23407>:
      D.24148 = i != 32;
      D.24149 = i != 105;
      D.24150 = D.24148 & D.24149;
      if (D.24150 != 0) goto <D.24151>; else goto <D.24152>;
      <D.24151>:
      if (i != 115) goto <D.24154>; else goto <D.24155>;
      <D.24154>:
      if (i != 97) goto <D.24157>; else goto <D.24158>;
      <D.24157>:
      if (i != 100) goto <D.24160>; else goto <D.24161>;
      <D.24160>:
      if (i == 108) goto <D.24163>; else goto <D.24164>;
      <D.24163>:
      iftmp.24 = 0;
      goto <D.24165>;
      <D.24164>:
      iftmp.24 = -1;
      <D.24165>:
      iftmp.23 = iftmp.24;
      goto <D.24166>;
      <D.24161>:
      iftmp.23 = 2;
      <D.24166>:
      iftmp.22 = iftmp.23;
      goto <D.24167>;
      <D.24158>:
      iftmp.22 = 0;
      <D.24167>:
      iftmp.21 = iftmp.22;
      goto <D.24168>;
      <D.24155>:
      iftmp.21 = 1;
      <D.24168>:
      iftmp.20 = iftmp.21;
      goto <D.24169>;
      <D.24152>:
      iftmp.20 = -1;
      <D.24169>:
      desc_to_fixed_reg[i] = iftmp.20;
      i = i + 1;
      <D.23408>:
      if (i <= 255) goto <D.23407>; else goto <D.23409>;
      <D.23409>:
      desc_to_fixed_reg_inited = 1;
      i = 313;
      goto <D.23412>;
      <D.23411>:
      {
        const char * ispec;

        D.24170 = i + -313;
        D.24171 = x86_desc_idx[D.24170];
        D.24172 = (sizetype) D.24171;
        spec = &x86_desc + D.24172;
        D.24170 = i + -313;
        D.24173 = D.24170 * 4;
        ispec = &ins_info[D.24173];
        D.24174 = *spec;
        if (D.24174 != 0) goto <D.24175>; else goto <D.24176>;
        <D.24175>:
        D.24177 = *ispec;
        if (D.24177 == 32) goto <D.24178>; else goto <D.24179>;
        <D.24178>:
        D.24180 = mono_inst_name (i);
        printf ("Instruction metadata for %s inconsistent.\n", D.24180);
        <D.24179>:
        <D.24176>:
        D.24181 = spec + 1;
        D.24182 = *D.24181;
        if (D.24182 != 0) goto <D.24183>; else goto <D.24184>;
        <D.24183>:
        D.24185 = ispec + 1;
        D.24186 = *D.24185;
        if (D.24186 == 32) goto <D.24187>; else goto <D.24188>;
        <D.24187>:
        D.24189 = mono_inst_name (i);
        printf ("Instruction metadata for %s inconsistent.\n", D.24189);
        <D.24188>:
        <D.24184>:
        D.24190 = spec + 2;
        D.24191 = *D.24190;
        if (D.24191 != 0) goto <D.24192>; else goto <D.24193>;
        <D.24192>:
        D.24194 = ispec + 2;
        D.24195 = *D.24194;
        if (D.24195 == 32) goto <D.24196>; else goto <D.24197>;
        <D.24196>:
        D.24198 = mono_inst_name (i);
        printf ("Instruction metadata for %s inconsistent.\n", D.24198);
        <D.24197>:
        <D.24193>:
      }
      i = i + 1;
      <D.23412>:
      if (i <= 1046) goto <D.23411>; else goto <D.23413>;
      <D.23413>:
      <D.24146>:
      D.24199 = bb->max_vreg;
      D.24200 = (int) D.24199;
      rs->next_vreg = D.24200;
      mono_regstate_assign (rs);
      rs->ifree_mask = 7;
      i = 0;
      goto <D.23415>;
      <D.23414>:
      D.24201 = regbank_callee_regs[i];
      rs->free_mask[i] = D.24201;
      i = i + 1;
      <D.23415>:
      if (i <= 4) goto <D.23414>; else goto <D.23416>;
      <D.23416>:
      max = rs->next_vreg;
      D.24202 = cfg->reginfo;
      if (D.24202 != 0B) goto <D.24203>; else goto <D.24204>;
      <D.24203>:
      D.24205 = cfg->reginfo_len;
      if (D.24205 < max) goto <D.24206>; else goto <D.24207>;
      <D.24206>:
      cfg->reginfo = 0B;
      <D.24207>:
      <D.24204>:
      reginfo = cfg->reginfo;
      if (reginfo == 0B) goto <D.24208>; else goto <D.24209>;
      <D.24208>:
      D.24210 = max * 2;
      D.24211 = MAX_EXPR <D.24210, 1024>;
      cfg->reginfo_len = D.24211;
      D.24205 = cfg->reginfo_len;
      D.24212 = (unsigned int) D.24205;
      D.24213 = D.24212 * 12;
      D.24214 = cfg->mempool;
      D.24215 = mono_mempool_alloc (D.24214, D.24213);
      cfg->reginfo = D.24215;
      reginfo = cfg->reginfo;
      goto <D.24216>;
      <D.24209>:
      D.24205 = cfg->reginfo_len;
      D.24217 = rs->next_vreg;
      D.24218 = D.24205 < D.24217;
      D.24219 = (long int) D.24218;
      D.24220 = __builtin_expect (D.24219, 0);
      if (D.24220 != 0) goto <D.24221>; else goto <D.24222>;
      <D.24221>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1160, "cfg->reginfo_len >= rs->next_vreg");
      <D.24222>:
      <D.24216>:
      D.24223 = cfg->verbose_level;
      if (D.24223 > 1) goto <D.24224>; else goto <D.24225>;
      <D.24224>:
      D.24205 = cfg->reginfo_len;
      D.24212 = (unsigned int) D.24205;
      D.24213 = D.24212 * 12;
      D.24202 = cfg->reginfo;
      memset (D.24202, 0, D.24213);
      <D.24225>:
      ins = bb->code;
      goto <D.23421>;
      <D.23420>:
      D.24226 = ins->opcode;
      D.24227 = (int) D.24226;
      D.24228 = D.24227 + -313;
      D.24229 = x86_desc_idx[D.24228];
      D.24230 = (sizetype) D.24229;
      spec = &x86_desc + D.24230;
      D.24231 = ins->dreg;
      if (D.24231 != -1) goto <D.24232>; else goto <D.24233>;
      <D.24232>:
      D.24231 = ins->dreg;
      if (D.24231 < max) goto <D.24234>; else goto <D.24235>;
      <D.24234>:
      D.24231 = ins->dreg;
      D.24236 = (unsigned int) D.24231;
      D.24237 = D.24236 * 12;
      D.24238 = reginfo + D.24237;
      memset (D.24238, 0, 12);
      D.24174 = *spec;
      D.24239 = D.24174 == 108;
      D.24174 = *spec;
      D.24240 = D.24174 == 76;
      D.24241 = D.24239 | D.24240;
      if (D.24241 != 0) goto <D.24242>; else goto <D.24243>;
      <D.24242>:
      D.24231 = ins->dreg;
      D.24244 = D.24231 + 1;
      ins->dreg = D.24244;
      D.24231 = ins->dreg;
      D.24245 = (sizetype) D.24231;
      D.24246 = D.24245 + 1;
      D.24247 = D.24246 * 12;
      D.24248 = reginfo + D.24247;
      memset (D.24248, 0, 12);
      <D.24243>:
      <D.24235>:
      <D.24233>:
      D.24249 = ins->sreg1;
      sregs[0] = D.24249;
      D.24250 = ins->sreg2;
      sregs[1] = D.24250;
      D.24251 = ins->sreg3;
      sregs[2] = D.24251;
      D.24226 = ins->opcode;
      D.24227 = (int) D.24226;
      D.24228 = D.24227 + -313;
      D.24252 = ins_sreg_counts[D.24228];
      num_sregs = (int) D.24252;
      j = 0;
      goto <D.23418>;
      <D.23417>:
      D.24253 = sregs[j];
      D.24254 = D.24253 == -1;
      D.24255 = (long int) D.24254;
      D.24256 = __builtin_expect (D.24255, 0);
      if (D.24256 != 0) goto <D.24257>; else goto <D.24258>;
      <D.24257>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1192, "sregs [j] != -1");
      <D.24258>:
      D.24253 = sregs[j];
      if (D.24253 < max) goto <D.24259>; else goto <D.24260>;
      <D.24259>:
      D.24253 = sregs[j];
      D.24261 = (unsigned int) D.24253;
      D.24262 = D.24261 * 12;
      D.24263 = reginfo + D.24262;
      memset (D.24263, 0, 12);
      D.24264 = j + 1;
      D.24265 = (sizetype) D.24264;
      D.24266 = spec + D.24265;
      D.24267 = *D.24266;
      D.24268 = D.24267 == 108;
      D.24264 = j + 1;
      D.24265 = (sizetype) D.24264;
      D.24266 = spec + D.24265;
      D.24267 = *D.24266;
      D.24269 = D.24267 == 76;
      D.24270 = D.24268 | D.24269;
      if (D.24270 != 0) goto <D.24271>; else goto <D.24272>;
      <D.24271>:
      D.24253 = sregs[j];
      D.24273 = D.24253 + 1;
      sregs[j] = D.24273;
      D.24253 = sregs[j];
      D.24274 = (sizetype) D.24253;
      D.24275 = D.24274 + 1;
      D.24276 = D.24275 * 12;
      D.24277 = reginfo + D.24276;
      memset (D.24277, 0, 12);
      <D.24272>:
      <D.24260>:
      j = j + 1;
      <D.23418>:
      if (j < num_sregs) goto <D.23417>; else goto <D.23419>;
      <D.23419>:
      mono_inst_set_src_registers (ins, &sregs);
      ins = ins->next;
      <D.23421>:
      if (ins != 0B) goto <D.23420>; else goto <D.23422>;
      <D.23422>:
      i = 1;
      D.24223 = cfg->verbose_level;
      D.24278 = D.24223 > 2;
      D.24279 = (long int) D.24278;
      D.24280 = __builtin_expect (D.24279, 0);
      if (D.24280 != 0) goto <D.24281>; else goto <D.24282>;
      <D.24281>:
      D.24283 = bb->block_num;
      printf ("\nLOCAL REGALLOC BLOCK %d:\n", D.24283);
      <D.24282>:
      ins = bb->code;
      goto <D.23448>;
      <D.23447>:
      D.24226 = ins->opcode;
      D.24227 = (int) D.24226;
      D.24228 = D.24227 + -313;
      D.24229 = x86_desc_idx[D.24228];
      D.24230 = (sizetype) D.24229;
      spec = &x86_desc + D.24230;
      D.24174 = *spec;
      spec_dest = (unsigned char) D.24174;
      D.24284 = spec == &x86_desc;
      D.24285 = (long int) D.24284;
      D.24286 = __builtin_expect (D.24285, 0);
      if (D.24286 != 0) goto <D.24287>; else goto <D.24288>;
      <D.24287>:
      D.24226 = ins->opcode;
      D.24227 = (int) D.24226;
      D.24289 = mono_inst_name (D.24227);
      monoeg_g_log (0B, 4, "Opcode \'%s\' missing from machine description file.", D.24289);
      <D.23423>:
      goto <D.23423>;
      <D.24288>:
      D.24223 = cfg->verbose_level;
      D.24278 = D.24223 > 2;
      D.24279 = (long int) D.24278;
      D.24280 = __builtin_expect (D.24279, 0);
      if (D.24280 != 0) goto <D.24290>; else goto <D.24291>;
      <D.24290>:
      mono_print_ins_index (i, ins);
      <D.24291>:
      D.24249 = ins->sreg1;
      sregs[0] = D.24249;
      D.24250 = ins->sreg2;
      sregs[1] = D.24250;
      D.24251 = ins->sreg3;
      sregs[2] = D.24251;
      D.24226 = ins->opcode;
      D.24227 = (int) D.24226;
      D.24228 = D.24227 + -313;
      D.24252 = ins_sreg_counts[D.24228];
      num_sregs = (int) D.24252;
      D.24174 = *spec;
      if (D.24174 == 102) goto <D.24292>; else goto <D.24293>;
      <D.24292>:
      has_fp = 1;
      goto <D.24294>;
      <D.24293>:
      j = 0;
      goto <D.23425>;
      <D.23424>:
      D.24264 = j + 1;
      D.24265 = (sizetype) D.24264;
      D.24266 = spec + D.24265;
      D.24267 = *D.24266;
      if (D.24267 == 102) goto <D.24295>; else goto <D.24296>;
      <D.24295>:
      has_fp = 1;
      <D.24296>:
      j = j + 1;
      <D.23425>:
      if (j < num_sregs) goto <D.23424>; else goto <D.23426>;
      <D.23426>:
      <D.24294>:
      j = 0;
      goto <D.23430>;
      <D.23429>:
      {
        int sreg;
        int sreg_spec;

        sreg = sregs[j];
        D.24264 = j + 1;
        D.24265 = (sizetype) D.24264;
        D.24266 = spec + D.24265;
        D.24267 = *D.24266;
        sreg_spec = (int) D.24267;
        if (sreg_spec != 0) goto <D.24297>; else goto <D.24298>;
        <D.24297>:
        D.24264 = j + 1;
        D.24265 = (sizetype) D.24264;
        D.24266 = spec + D.24265;
        D.24267 = *D.24266;
        D.24300 = D.24267 == 102;
        D.24301 = (long int) D.24300;
        D.24302 = __builtin_expect (D.24301, 0);
        if (D.24302 == 0) goto <D.24303>; else goto <D.24304>;
        <D.24303>:
        D.24264 = j + 1;
        D.24265 = (sizetype) D.24264;
        D.24266 = spec + D.24265;
        D.24267 = *D.24266;
        D.24306 = D.24267 == 120;
        D.24307 = (long int) D.24306;
        D.24308 = __builtin_expect (D.24307, 0);
        if (D.24308 != 0) goto <D.24309>; else goto <D.24310>;
        <D.24309>:
        iftmp.26 = 4;
        goto <D.24311>;
        <D.24310>:
        iftmp.26 = 0;
        <D.24311>:
        iftmp.25 = iftmp.26;
        goto <D.24312>;
        <D.24304>:
        iftmp.25 = 1;
        <D.24312>:
        bank = iftmp.25;
        D.24313 = sreg == -1;
        D.24314 = (long int) D.24313;
        D.24315 = __builtin_expect (D.24314, 0);
        if (D.24315 != 0) goto <D.24316>; else goto <D.24317>;
        <D.24316>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1240, "sreg != -1");
        <D.24317>:
        D.24319 = bank != 0;
        D.24320 = (long int) D.24319;
        D.24321 = __builtin_expect (D.24320, 0);
        if (D.24321 != 0) goto <D.24322>; else goto <D.24323>;
        <D.24322>:
        if (sreg < 0) goto <D.24325>; else goto <D.24328>;
        <D.24328>:
        D.24329 = regbank_size[bank];
        if (D.24329 <= sreg) goto <D.24325>; else goto <D.24326>;
        <D.24325>:
        iftmp.28 = 1;
        goto <D.24327>;
        <D.24326>:
        iftmp.28 = 0;
        <D.24327>:
        iftmp.27 = (_Bool) iftmp.28;
        goto <D.24330>;
        <D.24323>:
        iftmp.27 = sreg > 7;
        <D.24330>:
        if (iftmp.27 != 0) goto <D.24331>; else goto <D.24332>;
        <D.24331>:
        sreg.29 = (unsigned int) sreg;
        D.24334 = sreg.29 * 12;
        D.24335 = reginfo + D.24334;
        D.24336 = D.24335->born_in;
        D.24337 = D.24336 <= 0;
        D.24338 = (long int) D.24337;
        D.24339 = __builtin_expect (D.24338, 0);
        if (D.24339 != 0) goto <D.24340>; else goto <D.24341>;
        <D.24340>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1243, "reginfo [sreg].born_in > 0");
        <D.24341>:
        <D.24332>:
        D.24342 = rs->vassign;
        sreg.29 = (unsigned int) sreg;
        D.24343 = sreg.29 * 4;
        D.24344 = D.24342 + D.24343;
        *D.24344 = -1;
        D.24345 = sreg_spec == 108;
        D.24346 = sreg_spec == 76;
        D.24347 = D.24345 | D.24346;
        if (D.24347 != 0) goto <D.24348>; else goto <D.24349>;
        <D.24348>:
        D.24342 = rs->vassign;
        sreg.30 = (sizetype) sreg;
        D.24351 = sreg.30 + 1;
        D.24352 = D.24351 * 4;
        D.24353 = D.24342 + D.24352;
        *D.24353 = -1;
        sreg.30 = (sizetype) sreg;
        D.24351 = sreg.30 + 1;
        D.24356 = D.24351 * 12;
        D.24357 = reginfo + D.24356;
        D.24358 = D.24357->born_in;
        if (D.24358 == 0) goto <D.24354>; else goto <D.24359>;
        <D.24359>:
        sreg.30 = (sizetype) sreg;
        D.24351 = sreg.30 + 1;
        D.24356 = D.24351 * 12;
        D.24357 = reginfo + D.24356;
        D.24358 = D.24357->born_in;
        if (D.24358 > i) goto <D.24354>; else goto <D.24355>;
        <D.24354>:
        sreg.30 = (sizetype) sreg;
        D.24351 = sreg.30 + 1;
        D.24356 = D.24351 * 12;
        D.24357 = reginfo + D.24356;
        D.24357->born_in = i;
        <D.24355>:
        <D.24349>:
        goto <D.24360>;
        <D.24298>:
        sregs[j] = -1;
        <D.24360>:
      }
      j = j + 1;
      <D.23430>:
      if (j < num_sregs) goto <D.23429>; else goto <D.23431>;
      <D.23431>:
      mono_inst_set_src_registers (ins, &sregs);
      if (spec_dest != 0) goto <D.24361>; else goto <D.24362>;
      <D.24361>:
      {
        int dest_dreg;

        D.24174 = *spec;
        D.24364 = D.24174 == 102;
        D.24365 = (long int) D.24364;
        D.24366 = __builtin_expect (D.24365, 0);
        if (D.24366 == 0) goto <D.24367>; else goto <D.24368>;
        <D.24367>:
        D.24174 = *spec;
        D.24370 = D.24174 == 120;
        D.24371 = (long int) D.24370;
        D.24372 = __builtin_expect (D.24371, 0);
        if (D.24372 != 0) goto <D.24373>; else goto <D.24374>;
        <D.24373>:
        iftmp.32 = 4;
        goto <D.24375>;
        <D.24374>:
        iftmp.32 = 0;
        <D.24375>:
        iftmp.31 = iftmp.32;
        goto <D.24376>;
        <D.24368>:
        iftmp.31 = 1;
        <D.24376>:
        bank = iftmp.31;
        if (spec_dest != 98) goto <D.24377>; else goto <D.24378>;
        <D.24377>:
        D.24231 = ins->dreg;
        D.24236 = (unsigned int) D.24231;
        D.24237 = D.24236 * 12;
        D.24379 = reginfo + D.24237;
        D.24379->killed_in = i;
        <D.24378>:
        D.24231 = ins->dreg;
        D.24380 = D.24231 == -1;
        D.24381 = (long int) D.24380;
        D.24382 = __builtin_expect (D.24381, 0);
        if (D.24382 != 0) goto <D.24383>; else goto <D.24384>;
        <D.24383>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1267, "ins->dreg != -1");
        <D.24384>:
        D.24342 = rs->vassign;
        D.24231 = ins->dreg;
        D.24236 = (unsigned int) D.24231;
        D.24385 = D.24236 * 4;
        D.24386 = D.24342 + D.24385;
        *D.24386 = -1;
        D.24231 = ins->dreg;
        D.24236 = (unsigned int) D.24231;
        D.24237 = D.24236 * 12;
        D.24379 = reginfo + D.24237;
        D.24389 = D.24379->born_in;
        if (D.24389 == 0) goto <D.24387>; else goto <D.24390>;
        <D.24390>:
        D.24231 = ins->dreg;
        D.24236 = (unsigned int) D.24231;
        D.24237 = D.24236 * 12;
        D.24379 = reginfo + D.24237;
        D.24389 = D.24379->born_in;
        if (D.24389 > i) goto <D.24387>; else goto <D.24388>;
        <D.24387>:
        D.24231 = ins->dreg;
        D.24236 = (unsigned int) D.24231;
        D.24237 = D.24236 * 12;
        D.24379 = reginfo + D.24237;
        D.24379->born_in = i;
        <D.24388>:
        D.24391 = (int) spec_dest;
        D.24392 = desc_to_fixed_reg[D.24391];
        dest_dreg = (int) D.24392;
        if (dest_dreg != -1) goto <D.24393>; else goto <D.24394>;
        <D.24393>:
        D.24231 = ins->dreg;
        D.24236 = (unsigned int) D.24231;
        D.24237 = D.24236 * 12;
        D.24379 = reginfo + D.24237;
        D.24395 = 1 << dest_dreg;
        D.24379->preferred_mask = D.24395;
        <D.24394>:
        D.24231 = ins->dreg;
        D.24236 = (unsigned int) D.24231;
        D.24237 = D.24236 * 12;
        D.24379 = reginfo + D.24237;
        D.24231 = ins->dreg;
        D.24236 = (unsigned int) D.24231;
        D.24237 = D.24236 * 12;
        D.24379 = reginfo + D.24237;
        D.24396 = D.24379->preferred_mask;
        if (spec_dest == 121) goto <D.24398>; else goto <D.24399>;
        <D.24398>:
        iftmp.33 = 15;
        goto <D.24400>;
        <D.24399>:
        iftmp.33 = 0;
        <D.24400>:
        D.24401 = D.24396 | iftmp.33;
        D.24379->preferred_mask = D.24401;
        D.24402 = spec_dest == 108;
        D.24403 = spec_dest == 76;
        D.24404 = D.24402 | D.24403;
        if (D.24404 != 0) goto <D.24405>; else goto <D.24406>;
        <D.24405>:
        D.24342 = rs->vassign;
        D.24231 = ins->dreg;
        D.24245 = (sizetype) D.24231;
        D.24246 = D.24245 + 1;
        D.24407 = D.24246 * 4;
        D.24408 = D.24342 + D.24407;
        *D.24408 = -1;
        D.24231 = ins->dreg;
        D.24245 = (sizetype) D.24231;
        D.24246 = D.24245 + 1;
        D.24247 = D.24246 * 12;
        D.24248 = reginfo + D.24247;
        D.24411 = D.24248->born_in;
        if (D.24411 == 0) goto <D.24409>; else goto <D.24412>;
        <D.24412>:
        D.24231 = ins->dreg;
        D.24245 = (sizetype) D.24231;
        D.24246 = D.24245 + 1;
        D.24247 = D.24246 * 12;
        D.24248 = reginfo + D.24247;
        D.24411 = D.24248->born_in;
        if (D.24411 > i) goto <D.24409>; else goto <D.24410>;
        <D.24409>:
        D.24231 = ins->dreg;
        D.24245 = (sizetype) D.24231;
        D.24246 = D.24245 + 1;
        D.24247 = D.24246 * 12;
        D.24248 = reginfo + D.24247;
        D.24248->born_in = i;
        <D.24410>:
        if (spec_dest == 108) goto <D.24413>; else goto <D.24414>;
        <D.24413>:
        D.24231 = ins->dreg;
        D.24245 = (sizetype) D.24231;
        D.24246 = D.24245 + 1;
        D.24247 = D.24246 * 12;
        D.24248 = reginfo + D.24247;
        if (spec_dest == 108) goto <D.24416>; else goto <D.24417>;
        <D.24416>:
        if (spec_dest == 108) goto <D.24419>; else goto <D.24420>;
        <D.24419>:
        iftmp.35 = 4;
        goto <D.24421>;
        <D.24420>:
        iftmp.35 = 0;
        <D.24421>:
        iftmp.34 = iftmp.35;
        goto <D.24422>;
        <D.24417>:
        iftmp.34 = 7;
        <D.24422>:
        D.24248->preferred_mask = iftmp.34;
        <D.24414>:
        <D.24406>:
      }
      goto <D.24423>;
      <D.24362>:
      ins->dreg = -1;
      <D.24423>:
      D.24426 = spec + 5;
      D.24427 = *D.24426;
      if (D.24427 == 99) goto <D.24428>; else goto <D.24429>;
      <D.24428>:
      D.24430 = ins->opcode;
      D.24431 = D.24430 + 65193;
      D.24432 = D.24431 <= 2;
      D.24433 = D.24430 + 65187;
      D.24434 = D.24433 <= 2;
      D.24435 = D.24432 | D.24434;
      if (D.24435 != 0) goto <D.24424>; else goto <D.24436>;
      <D.24436>:
      D.24226 = ins->opcode;
      D.24437 = D.24226 + 65184;
      if (D.24437 <= 2) goto <D.24424>; else goto <D.24438>;
      <D.24438>:
      D.24226 = ins->opcode;
      D.24439 = D.24226 + 65181;
      if (D.24439 <= 2) goto <D.24424>; else goto <D.24440>;
      <D.24440>:
      D.24226 = ins->opcode;
      D.24441 = D.24226 + 65190;
      if (D.24441 <= 2) goto <D.24424>; else goto <D.24442>;
      <D.24442>:
      D.24226 = ins->opcode;
      D.24443 = D.24226 + 65178;
      if (D.24443 <= 2) goto <D.24424>; else goto <D.24444>;
      <D.24444>:
      D.24226 = ins->opcode;
      if (D.24226 == 448) goto <D.24424>; else goto <D.24425>;
      <D.24424>:
      {
        struct MonoCallInst * call;
        struct GSList * list;

        call = ins;
        list = call->out_ireg_args;
        if (list != 0B) goto <D.24445>; else goto <D.24446>;
        <D.24445>:
        goto <D.23439>;
        <D.23438>:
        {
          guint32 regpair;
          int reg;
          int hreg;

          D.24447 = list->data;
          regpair = (guint32) D.24447;
          D.24448 = regpair >> 24;
          hreg = (int) D.24448;
          regpair.36 = (int) regpair;
          reg = regpair.36 & 16777215;
          if (list != 0B) goto <D.24451>; else goto <D.24452>;
          <D.24451>:
          iftmp.37 = list->next;
          goto <D.24453>;
          <D.24452>:
          iftmp.37 = 0B;
          <D.24453>:
          list = iftmp.37;
        }
        <D.23439>:
        if (list != 0B) goto <D.23438>; else goto <D.23440>;
        <D.23440>:
        <D.24446>:
        list = call->out_freg_args;
        if (list != 0B) goto <D.24454>; else goto <D.24455>;
        <D.24454>:
        goto <D.23445>;
        <D.23444>:
        {
          guint32 regpair;
          int reg;
          int hreg;

          D.24447 = list->data;
          regpair = (guint32) D.24447;
          D.24456 = regpair >> 24;
          hreg = (int) D.24456;
          regpair.38 = (int) regpair;
          reg = regpair.38 & 16777215;
          if (list != 0B) goto <D.24459>; else goto <D.24460>;
          <D.24459>:
          iftmp.39 = list->next;
          goto <D.24461>;
          <D.24460>:
          iftmp.39 = 0B;
          <D.24461>:
          list = iftmp.39;
        }
        <D.23445>:
        if (list != 0B) goto <D.23444>; else goto <D.23446>;
        <D.23446>:
        <D.24455>:
      }
      <D.24425>:
      <D.24429>:
      i = i + 1;
      ins = ins->next;
      <D.23448>:
      if (ins != 0B) goto <D.23447>; else goto <D.23449>;
      <D.23449>:
      tmp = &last;
      D.24223 = cfg->verbose_level;
      D.24278 = D.24223 > 2;
      D.24279 = (long int) D.24278;
      D.24280 = __builtin_expect (D.24279, 0);
      if (D.24280 != 0) goto <D.24462>; else goto <D.24463>;
      <D.24462>:
      D.24217 = rs->next_vreg;
      print_regtrack (reginfo, D.24217);
      <D.24463>:
      ins = bb->last_ins;
      if (ins != 0B) goto <D.24465>; else goto <D.24466>;
      <D.24465>:
      iftmp.40 = ins->prev;
      goto <D.24467>;
      <D.24466>:
      iftmp.40 = 0B;
      <D.24467>:
      prev = iftmp.40;
      goto <D.23578>;
      <D.23577>:
      {
        int prev_dreg;
        int clob_dreg;
        int dest_dreg;
        int clob_reg;
        int dest_sregs[3];
        int prev_sregs[3];
        int dreg_high;
        int sreg1_high;
        regmask_t dreg_mask;
        regmask_t mask;
        regmask_t sreg_masks[3];
        regmask_t sreg_fixed_masks[3];
        regmask_t dreg_fixed_mask;
        const unsigned char * ip;

        try
          {
            i = i + -1;
            D.24226 = ins->opcode;
            D.24227 = (int) D.24226;
            D.24228 = D.24227 + -313;
            D.24229 = x86_desc_idx[D.24228];
            D.24230 = (sizetype) D.24229;
            spec = &x86_desc + D.24230;
            D.24181 = spec + 1;
            D.24182 = *D.24181;
            spec_src1 = (unsigned char) D.24182;
            D.24174 = *spec;
            spec_dest = (unsigned char) D.24174;
            prev_dreg = -1;
            clob_dreg = -1;
            clob_reg = -1;
            dest_dreg = -1;
            dreg_high = -1;
            sreg1_high = -1;
            spec_dest.41 = (char) spec_dest;
            D.24469 = (int) spec_dest.41;
            dreg_mask = get_callee_mask (D.24469);
            j = 0;
            goto <D.23465>;
            <D.23464>:
            prev_sregs[j] = -1;
            D.24264 = j + 1;
            D.24265 = (sizetype) D.24264;
            D.24266 = spec + D.24265;
            D.24267 = *D.24266;
            D.24470 = (int) D.24267;
            D.24471 = get_callee_mask (D.24470);
            sreg_masks[j] = D.24471;
            D.24264 = j + 1;
            D.24265 = (sizetype) D.24264;
            D.24266 = spec + D.24265;
            D.24267 = *D.24266;
            D.24470 = (int) D.24267;
            D.24472 = desc_to_fixed_reg[D.24470];
            D.24473 = (int) D.24472;
            dest_sregs[j] = D.24473;
            D.24264 = j + 1;
            D.24265 = (sizetype) D.24264;
            D.24266 = spec + D.24265;
            D.24267 = *D.24266;
            if (D.24267 == 121) goto <D.24475>; else goto <D.24476>;
            <D.24475>:
            iftmp.42 = 15;
            goto <D.24477>;
            <D.24476>:
            iftmp.42 = 0;
            <D.24477>:
            sreg_fixed_masks[j] = iftmp.42;
            j = j + 1;
            <D.23465>:
            if (j <= 2) goto <D.23464>; else goto <D.23466>;
            <D.23466>:
            D.24223 = cfg->verbose_level;
            D.24278 = D.24223 > 2;
            D.24279 = (long int) D.24278;
            D.24280 = __builtin_expect (D.24279, 0);
            if (D.24280 != 0) goto <D.24478>; else goto <D.24479>;
            <D.24478>:
            printf ("processing:");
            <D.24479>:
            D.24223 = cfg->verbose_level;
            D.24278 = D.24223 > 2;
            D.24279 = (long int) D.24278;
            D.24280 = __builtin_expect (D.24279, 0);
            if (D.24280 != 0) goto <D.24480>; else goto <D.24481>;
            <D.24480>:
            mono_print_ins_index (i, ins);
            <D.24481>:
            ip = ins->cil_code;
            last = ins;
            D.24391 = (int) spec_dest;
            D.24392 = desc_to_fixed_reg[D.24391];
            dest_dreg = (int) D.24392;
            D.24426 = spec + 5;
            D.24427 = *D.24426;
            D.24482 = (int) D.24427;
            D.24483 = desc_to_fixed_reg[D.24482];
            clob_reg = (int) D.24483;
            D.24484 = sreg_masks[1];
            sreg_masks[1] = D.24484;
            if (spec_dest == 121) goto <D.24486>; else goto <D.24487>;
            <D.24486>:
            iftmp.43 = 15;
            goto <D.24488>;
            <D.24487>:
            iftmp.43 = 0;
            <D.24488>:
            dreg_fixed_mask = iftmp.43;
            D.24249 = ins->sreg1;
            sregs[0] = D.24249;
            D.24250 = ins->sreg2;
            sregs[1] = D.24250;
            D.24251 = ins->sreg3;
            sregs[2] = D.24251;
            D.24226 = ins->opcode;
            D.24227 = (int) D.24226;
            D.24228 = D.24227 + -313;
            D.24252 = ins_sreg_counts[D.24228];
            num_sregs = (int) D.24252;
            j = 1;
            goto <D.23497>;
            <D.23496>:
            {
              int sreg;
              int dest_sreg;

              sreg = sregs[j];
              dest_sreg = dest_sregs[j];
              if (dest_sreg == -1) goto <D.24489>; else goto <D.24490>;
              <D.24489>:
              // predicted unlikely by continue predictor.
              goto <D.23469>;
              <D.24490>:
              if (j == 2) goto <D.24491>; else goto <D.24492>;
              <D.24491>:
              {
                int k;

                D.24493 = 1 << dest_sreg;
                sreg_masks[j] = D.24493;
                k = 0;
                goto <D.23472>;
                <D.23471>:
                if (k != j) goto <D.24494>; else goto <D.24495>;
                <D.24494>:
                D.24496 = sreg_masks[k];
                D.24493 = 1 << dest_sreg;
                D.24497 = ~D.24493;
                D.24498 = D.24496 & D.24497;
                sreg_masks[k] = D.24498;
                <D.24495>:
                k = k + 1;
                <D.23472>:
                if (k < num_sregs) goto <D.23471>; else goto <D.23473>;
                <D.23473>:
                k = 0;
                goto <D.23475>;
                <D.23474>:
                if (k != j) goto <D.24499>; else goto <D.24500>;
                <D.24499>:
                D.24501 = sregs[k];
                if (D.24501 > 7) goto <D.24502>; else goto <D.24503>;
                <D.24502>:
                D.24342 = rs->vassign;
                D.24501 = sregs[k];
                D.24504 = (unsigned int) D.24501;
                D.24505 = D.24504 * 4;
                D.24506 = D.24342 + D.24505;
                D.24507 = *D.24506;
                if (D.24507 == dest_sreg) goto <D.24508>; else goto <D.24509>;
                <D.24508>:
                free_up_hreg (cfg, bb, tmp, ins, dest_sreg, 0);
                <D.24509>:
                <D.24503>:
                <D.24500>:
                k = k + 1;
                <D.23475>:
                if (k < num_sregs) goto <D.23474>; else goto <D.23476>;
                <D.23476>:
                if (sreg > 7) goto <D.24510>; else goto <D.24511>;
                <D.24510>:
                D.24342 = rs->vassign;
                sreg.44 = (unsigned int) sreg;
                D.24513 = sreg.44 * 4;
                D.24514 = D.24342 + D.24513;
                D.24515 = *D.24514;
                if (D.24515 >= 0) goto <D.24516>; else goto <D.24517>;
                <D.24516>:
                D.24342 = rs->vassign;
                sreg.44 = (unsigned int) sreg;
                D.24513 = sreg.44 * 4;
                D.24514 = D.24342 + D.24513;
                D.24515 = *D.24514;
                if (D.24515 != dest_sreg) goto <D.24518>; else goto <D.24519>;
                <D.24518>:
                spill_vreg (cfg, bb, tmp, ins, sreg, 0);
                <D.24519>:
                <D.24517>:
                <D.24511>:
                // predicted unlikely by continue predictor.
                goto <D.23469>;
              }
              <D.24492>:
              D.24520 = rs->ifree_mask;
              D.24493 = 1 << dest_sreg;
              D.24521 = D.24520 & D.24493;
              if (D.24521 != 0) goto <D.24522>; else goto <D.24523>;
              <D.24522>:
              sreg.45 = (unsigned int) sreg;
              if (sreg.45 <= 7) goto <D.24527>; else goto <D.24524>;
              <D.24527>:
              D.24528 = 232 >> sreg;
              D.24529 = D.24528 & 1;
              if (D.24529 != 0) goto <D.24530>; else goto <D.24524>;
              <D.24530>:
              {
                int k;
                struct MonoInst * copy;

                copy = create_copy_ins (cfg, bb, tmp, dest_sreg, sreg, 0B, ip, 0);
                insert_before_ins (bb, ins, copy);
                k = 0;
                goto <D.23480>;
                <D.23479>:
                if (k != j) goto <D.24531>; else goto <D.24532>;
                <D.24531>:
                D.24533 = sreg_masks[k];
                D.24493 = 1 << dest_sreg;
                D.24497 = ~D.24493;
                D.24534 = D.24533 & D.24497;
                sreg_masks[k] = D.24534;
                <D.24532>:
                k = k + 1;
                <D.23480>:
                if (k < num_sregs) goto <D.23479>; else goto <D.23481>;
                <D.23481>:
              }
              goto <D.24525>;
              <D.24524>:
              D.24342 = rs->vassign;
              sreg.44 = (unsigned int) sreg;
              D.24513 = sreg.44 * 4;
              D.24514 = D.24342 + D.24513;
              val = *D.24514;
              if (val == -1) goto <D.24535>; else goto <D.24536>;
              <D.24535>:
              D.24223 = cfg->verbose_level;
              D.24278 = D.24223 > 2;
              D.24279 = (long int) D.24278;
              D.24280 = __builtin_expect (D.24279, 0);
              if (D.24280 != 0) goto <D.24537>; else goto <D.24538>;
              <D.24537>:
              D.24539 = mono_arch_regname (dest_sreg);
              printf ("\tshortcut assignment of R%d to %s\n", sreg, D.24539);
              <D.24538>:
              assign_reg (cfg, rs, sreg, dest_sreg, 0);
              goto <D.24540>;
              <D.24536>:
              if (val < -1) goto <D.24541>; else goto <D.24542>;
              <D.24541>:
              monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-codegen.c", 1459);
              <D.24542>:
              {
                struct MonoInst * copy;
                int k;

                copy = create_copy_ins (cfg, bb, tmp, dest_sreg, val, 0B, ip, 0);
                insert_before_ins (bb, ins, copy);
                k = 0;
                goto <D.23485>;
                <D.23484>:
                if (k != j) goto <D.24543>; else goto <D.24544>;
                <D.24543>:
                D.24545 = sreg_masks[k];
                D.24493 = 1 << dest_sreg;
                D.24497 = ~D.24493;
                D.24546 = D.24545 & D.24497;
                sreg_masks[k] = D.24546;
                <D.24544>:
                k = k + 1;
                <D.23485>:
                if (k < num_sregs) goto <D.23484>; else goto <D.23486>;
                <D.23486>:
                D.24493 = 1 << dest_sreg;
                D.24497 = ~D.24493;
                dreg_mask = D.24497 & dreg_mask;
              }
              <D.24540>:
              <D.24525>:
              goto <D.24547>;
              <D.24523>:
              {
                gboolean need_spill;
                gboolean need_assign;
                int k;

                need_spill = 1;
                need_assign = 1;
                D.24493 = 1 << dest_sreg;
                D.24497 = ~D.24493;
                dreg_mask = D.24497 & dreg_mask;
                k = 0;
                goto <D.23491>;
                <D.23490>:
                if (k != j) goto <D.24548>; else goto <D.24549>;
                <D.24548>:
                D.24550 = sreg_masks[k];
                D.24493 = 1 << dest_sreg;
                D.24497 = ~D.24493;
                D.24551 = D.24550 & D.24497;
                sreg_masks[k] = D.24551;
                <D.24549>:
                k = k + 1;
                <D.23491>:
                if (k < num_sregs) goto <D.23490>; else goto <D.23492>;
                <D.23492>:
                D.24174 = *spec;
                if (D.24174 != 0) goto <D.24552>; else goto <D.24553>;
                <D.24552>:
                D.24342 = rs->vassign;
                D.24231 = ins->dreg;
                D.24236 = (unsigned int) D.24231;
                D.24385 = D.24236 * 4;
                D.24386 = D.24342 + D.24385;
                val = *D.24386;
                goto <D.24554>;
                <D.24553>:
                val = -1;
                <D.24554>:
                if (val == dest_sreg) goto <D.24555>; else goto <D.24556>;
                <D.24555>:
                D.24231 = ins->dreg;
                if (D.24231 != sreg) goto <D.24557>; else goto <D.24558>;
                <D.24557>:
                {
                  int new_dest;

                  D.24231 = ins->dreg;
                  D.24236 = (unsigned int) D.24231;
                  D.24237 = D.24236 * 12;
                  D.24379 = reginfo + D.24237;
                  D.24231 = ins->dreg;
                  new_dest = alloc_int_reg (cfg, bb, tmp, ins, dreg_mask, D.24231, D.24379);
                  D.24559 = new_dest < 0;
                  D.24560 = (long int) D.24559;
                  D.24561 = __builtin_expect (D.24560, 0);
                  if (D.24561 != 0) goto <D.24562>; else goto <D.24563>;
                  <D.24562>:
                  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1505, "new_dest >= 0");
                  <D.24563>:
                  D.24223 = cfg->verbose_level;
                  D.24278 = D.24223 > 2;
                  D.24279 = (long int) D.24278;
                  D.24280 = __builtin_expect (D.24279, 0);
                  if (D.24280 != 0) goto <D.24564>; else goto <D.24565>;
                  <D.24564>:
                  D.24566 = mono_arch_regname (dest_sreg);
                  D.24567 = mono_arch_regname (new_dest);
                  D.24231 = ins->dreg;
                  printf ("\tchanging dreg R%d to %s from %s\n", D.24231, D.24567, D.24566);
                  <D.24565>:
                  prev_dreg = ins->dreg;
                  D.24231 = ins->dreg;
                  assign_reg (cfg, rs, D.24231, new_dest, 0);
                  clob_dreg = ins->dreg;
                  create_copy_ins (cfg, bb, tmp, dest_sreg, new_dest, ins, ip, 0);
                  mono_regstate_free_int (rs, dest_sreg);
                  need_spill = 0;
                }
                <D.24558>:
                <D.24556>:
                sreg.45 = (unsigned int) sreg;
                if (sreg.45 <= 7) goto <D.24570>; else goto <D.24568>;
                <D.24570>:
                D.24528 = 232 >> sreg;
                D.24529 = D.24528 & 1;
                if (D.24529 != 0) goto <D.24571>; else goto <D.24568>;
                <D.24571>:
                {
                  struct MonoInst * copy;

                  copy = create_copy_ins (cfg, bb, tmp, dest_sreg, sreg, 0B, ip, 0);
                  insert_before_ins (bb, ins, copy);
                  need_assign = 0;
                }
                goto <D.24569>;
                <D.24568>:
                D.24342 = rs->vassign;
                sreg.44 = (unsigned int) sreg;
                D.24513 = sreg.44 * 4;
                D.24514 = D.24342 + D.24513;
                val = *D.24514;
                if (val == dest_sreg) goto <D.24572>; else goto <D.24573>;
                <D.24572>:
                need_spill = 0;
                goto <D.24574>;
                <D.24573>:
                if (val < -1) goto <D.24575>; else goto <D.24576>;
                <D.24575>:
                goto <D.24577>;
                <D.24576>:
                if (val >= 0) goto <D.24578>; else goto <D.24579>;
                <D.24578>:
                free_up_hreg (cfg, bb, tmp, ins, val, 0);
                <D.24579>:
                <D.24577>:
                <D.24574>:
                <D.24569>:
                if (need_spill != 0) goto <D.24580>; else goto <D.24581>;
                <D.24580>:
                free_up_hreg (cfg, bb, tmp, ins, dest_sreg, 0);
                <D.24581>:
                if (need_assign != 0) goto <D.24582>; else goto <D.24583>;
                <D.24582>:
                D.24342 = rs->vassign;
                sreg.44 = (unsigned int) sreg;
                D.24513 = sreg.44 * 4;
                D.24514 = D.24342 + D.24513;
                D.24515 = *D.24514;
                if (D.24515 < -1) goto <D.24584>; else goto <D.24585>;
                <D.24584>:
                {
                  int spill;

                  D.24342 = rs->vassign;
                  sreg.44 = (unsigned int) sreg;
                  D.24513 = sreg.44 * 4;
                  D.24514 = D.24342 + D.24513;
                  D.24515 = *D.24514;
                  spill = ~D.24515;
                  create_spilled_store (cfg, bb, spill, dest_sreg, sreg, tmp, 0B, ins, bank);
                }
                <D.24585>:
                D.24253 = sregs[j];
                assign_reg (cfg, rs, D.24253, dest_sreg, 0);
                <D.24583>:
              }
              <D.24547>:
              sregs[j] = dest_sreg;
            }
            <D.23469>:
            j = j + 1;
            <D.23497>:
            if (j < num_sregs) goto <D.23496>; else goto <D.23498>;
            <D.23498>:
            mono_inst_set_src_registers (ins, &sregs);
            D.24174 = *spec;
            D.24364 = D.24174 == 102;
            D.24365 = (long int) D.24364;
            D.24366 = __builtin_expect (D.24365, 0);
            if (D.24366 == 0) goto <D.24587>; else goto <D.24588>;
            <D.24587>:
            D.24174 = *spec;
            D.24370 = D.24174 == 120;
            D.24371 = (long int) D.24370;
            D.24372 = __builtin_expect (D.24371, 0);
            if (D.24372 != 0) goto <D.24590>; else goto <D.24591>;
            <D.24590>:
            iftmp.47 = 4;
            goto <D.24592>;
            <D.24591>:
            iftmp.47 = 0;
            <D.24592>:
            iftmp.46 = iftmp.47;
            goto <D.24593>;
            <D.24588>:
            iftmp.46 = 1;
            <D.24593>:
            bank = iftmp.46;
            if (spec_dest != 0) goto <D.24594>; else goto <D.24595>;
            <D.24594>:
            D.24319 = bank != 0;
            D.24320 = (long int) D.24319;
            D.24321 = __builtin_expect (D.24320, 0);
            if (D.24321 != 0) goto <D.24597>; else goto <D.24598>;
            <D.24597>:
            D.24231 = ins->dreg;
            if (D.24231 < 0) goto <D.24600>; else goto <D.24603>;
            <D.24603>:
            D.24231 = ins->dreg;
            D.24329 = regbank_size[bank];
            if (D.24231 >= D.24329) goto <D.24600>; else goto <D.24601>;
            <D.24600>:
            iftmp.49 = 1;
            goto <D.24602>;
            <D.24601>:
            iftmp.49 = 0;
            <D.24602>:
            iftmp.48 = (_Bool) iftmp.49;
            goto <D.24604>;
            <D.24598>:
            D.24231 = ins->dreg;
            iftmp.48 = D.24231 > 7;
            <D.24604>:
            if (iftmp.48 != 0) goto <D.24605>; else goto <D.24606>;
            <D.24605>:
            prev_dreg = ins->dreg;
            <D.24606>:
            <D.24595>:
            if (spec_dest == 98) goto <D.24607>; else goto <D.24608>;
            <D.24607>:
            D.24609 = dest_sregs[0];
            if (D.24609 != -1) goto <D.24610>; else goto <D.24611>;
            <D.24610>:
            D.24609 = dest_sregs[0];
            D.24612 = 1 << D.24609;
            D.24613 = ~D.24612;
            dreg_mask = D.24613 & dreg_mask;
            <D.24611>:
            j = 1;
            goto <D.23500>;
            <D.23499>:
            D.24614 = dest_sregs[j];
            if (D.24614 != -1) goto <D.24615>; else goto <D.24616>;
            <D.24615>:
            D.24614 = dest_sregs[j];
            D.24617 = 1 << D.24614;
            D.24618 = ~D.24617;
            dreg_mask = D.24618 & dreg_mask;
            <D.24616>:
            j = j + 1;
            <D.23500>:
            if (j < num_sregs) goto <D.23499>; else goto <D.23501>;
            <D.23501>:
            D.24342 = rs->vassign;
            D.24231 = ins->dreg;
            D.24236 = (unsigned int) D.24231;
            D.24385 = D.24236 * 4;
            D.24386 = D.24342 + D.24385;
            val = *D.24386;
            D.24319 = bank != 0;
            D.24320 = (long int) D.24319;
            D.24321 = __builtin_expect (D.24320, 0);
            if (D.24321 != 0) goto <D.24620>; else goto <D.24621>;
            <D.24620>:
            D.24231 = ins->dreg;
            if (D.24231 < 0) goto <D.24623>; else goto <D.24626>;
            <D.24626>:
            D.24231 = ins->dreg;
            D.24329 = regbank_size[bank];
            if (D.24231 >= D.24329) goto <D.24623>; else goto <D.24624>;
            <D.24623>:
            iftmp.51 = 1;
            goto <D.24625>;
            <D.24624>:
            iftmp.51 = 0;
            <D.24625>:
            iftmp.50 = (_Bool) iftmp.51;
            goto <D.24627>;
            <D.24621>:
            D.24231 = ins->dreg;
            iftmp.50 = D.24231 > 7;
            <D.24627>:
            if (iftmp.50 != 0) goto <D.24628>; else goto <D.24629>;
            <D.24628>:
            if (val >= 0) goto <D.24630>; else goto <D.24631>;
            <D.24630>:
            D.24632 = dreg_mask >> val;
            D.24633 = D.24632 & 1;
            if (D.24633 == 0) goto <D.24634>; else goto <D.24635>;
            <D.24634>:
            D.24231 = ins->dreg;
            spill_vreg (cfg, bb, tmp, ins, D.24231, 0);
            <D.24635>:
            <D.24631>:
            <D.24629>:
            <D.24608>:
            D.24402 = spec_dest == 108;
            D.24403 = spec_dest == 76;
            D.24404 = D.24402 | D.24403;
            if (D.24404 != 0) goto <D.24636>; else goto <D.24637>;
            <D.24636>:
            {
              guint32 dreg2;
              guint32 dest_dreg2;

              D.24319 = bank != 0;
              D.24320 = (long int) D.24319;
              D.24321 = __builtin_expect (D.24320, 0);
              if (D.24321 != 0) goto <D.24639>; else goto <D.24640>;
              <D.24639>:
              D.24231 = ins->dreg;
              if (D.24231 >= 0) goto <D.24644>; else goto <D.24642>;
              <D.24644>:
              D.24231 = ins->dreg;
              D.24329 = regbank_size[bank];
              if (D.24231 < D.24329) goto <D.24645>; else goto <D.24642>;
              <D.24645>:
              iftmp.53 = 1;
              goto <D.24643>;
              <D.24642>:
              iftmp.53 = 0;
              <D.24643>:
              D.24646 = iftmp.53 != 0;
              iftmp.52 = (long int) D.24646;
              goto <D.24647>;
              <D.24640>:
              D.24231 = ins->dreg;
              D.24648 = D.24231 <= 7;
              iftmp.52 = (long int) D.24648;
              <D.24647>:
              D.24649 = __builtin_expect (iftmp.52, 0);
              if (D.24649 != 0) goto <D.24650>; else goto <D.24651>;
              <D.24650>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1594, "is_soft_reg (ins->dreg, bank)");
              <D.24651>:
              if (dest_dreg != -1) goto <D.24652>; else goto <D.24653>;
              <D.24652>:
              D.24342 = rs->vassign;
              D.24231 = ins->dreg;
              D.24236 = (unsigned int) D.24231;
              D.24385 = D.24236 * 4;
              D.24386 = D.24342 + D.24385;
              D.24654 = *D.24386;
              if (D.24654 != dest_dreg) goto <D.24655>; else goto <D.24656>;
              <D.24655>:
              free_up_hreg (cfg, bb, tmp, ins, dest_dreg, 0);
              <D.24656>:
              D.24231 = ins->dreg;
              D.24657 = D.24231 + 1;
              dreg2 = (guint32) D.24657;
              if (spec_dest == 108) goto <D.24659>; else goto <D.24660>;
              <D.24659>:
              iftmp.54 = 2;
              goto <D.24661>;
              <D.24660>:
              iftmp.54 = 4294967295;
              <D.24661>:
              dest_dreg2 = iftmp.54;
              if (dest_dreg2 != 4294967295) goto <D.24662>; else goto <D.24663>;
              <D.24662>:
              D.24342 = rs->vassign;
              D.24664 = dreg2 * 4;
              D.24665 = D.24342 + D.24664;
              D.24666 = *D.24665;
              D.24667 = (unsigned int) D.24666;
              if (D.24667 != dest_dreg2) goto <D.24668>; else goto <D.24669>;
              <D.24668>:
              dest_dreg2.55 = (int) dest_dreg2;
              free_up_hreg (cfg, bb, tmp, ins, dest_dreg2.55, 0);
              <D.24669>:
              <D.24663>:
              <D.24653>:
            }
            <D.24637>:
            if (dreg_fixed_mask != 0) goto <D.24671>; else goto <D.24672>;
            <D.24671>:
            D.24319 = bank != 0;
            D.24320 = (long int) D.24319;
            D.24321 = __builtin_expect (D.24320, 0);
            if (D.24321 != 0) goto <D.24673>; else goto <D.24674>;
            <D.24673>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1610, "!bank");
            <D.24674>:
            D.24231 = ins->dreg;
            D.24677 = (unsigned int) D.24231;
            if (D.24677 <= 7) goto <D.24678>; else goto <D.24675>;
            <D.24678>:
            D.24231 = ins->dreg;
            D.24679 = 232 >> D.24231;
            D.24680 = D.24679 & 1;
            if (D.24680 != 0) goto <D.24681>; else goto <D.24675>;
            <D.24681>:
            val = mono_regstate_alloc_int (rs, dreg_fixed_mask);
            if (val < 0) goto <D.24682>; else goto <D.24683>;
            <D.24682>:
            val = get_register_spilling (cfg, bb, tmp, ins, dreg_fixed_mask, -1, bank);
            <D.24683>:
            mono_regstate_free_int (rs, val);
            dest_dreg = val;
            goto <D.24676>;
            <D.24675>:
            dreg_mask = dreg_mask & dreg_fixed_mask;
            <D.24676>:
            <D.24672>:
            D.24319 = bank != 0;
            D.24320 = (long int) D.24319;
            D.24321 = __builtin_expect (D.24320, 0);
            if (D.24321 != 0) goto <D.24685>; else goto <D.24686>;
            <D.24685>:
            D.24231 = ins->dreg;
            if (D.24231 < 0) goto <D.24688>; else goto <D.24691>;
            <D.24691>:
            D.24231 = ins->dreg;
            D.24329 = regbank_size[bank];
            if (D.24231 >= D.24329) goto <D.24688>; else goto <D.24689>;
            <D.24688>:
            iftmp.57 = 1;
            goto <D.24690>;
            <D.24689>:
            iftmp.57 = 0;
            <D.24690>:
            iftmp.56 = (_Bool) iftmp.57;
            goto <D.24692>;
            <D.24686>:
            D.24231 = ins->dreg;
            iftmp.56 = D.24231 > 7;
            <D.24692>:
            if (iftmp.56 != 0) goto <D.24693>; else goto <D.24694>;
            <D.24693>:
            D.24342 = rs->vassign;
            D.24231 = ins->dreg;
            D.24236 = (unsigned int) D.24231;
            D.24385 = D.24236 * 4;
            D.24386 = D.24342 + D.24385;
            val = *D.24386;
            if (val < 0) goto <D.24695>; else goto <D.24696>;
            <D.24695>:
            {
              int spill;

              spill = 0;
              if (val < -1) goto <D.24697>; else goto <D.24698>;
              <D.24697>:
              spill = ~val;
              <D.24698>:
              D.24231 = ins->dreg;
              D.24236 = (unsigned int) D.24231;
              D.24237 = D.24236 * 12;
              D.24379 = reginfo + D.24237;
              D.24231 = ins->dreg;
              val = alloc_reg (cfg, bb, tmp, ins, dreg_mask, D.24231, D.24379, bank);
              D.24231 = ins->dreg;
              assign_reg (cfg, rs, D.24231, val, bank);
              if (spill != 0) goto <D.24699>; else goto <D.24700>;
              <D.24699>:
              create_spilled_store (cfg, bb, spill, val, prev_dreg, tmp, ins, 0B, bank);
              <D.24700>:
            }
            <D.24696>:
            D.24223 = cfg->verbose_level;
            D.24278 = D.24223 > 2;
            D.24279 = (long int) D.24278;
            D.24280 = __builtin_expect (D.24279, 0);
            if (D.24280 != 0) goto <D.24701>; else goto <D.24702>;
            <D.24701>:
            D.24231 = ins->dreg;
            D.24703 = mono_regname_full (val, bank);
            printf ("\tassigned dreg %s to dest R%d\n", D.24703, D.24231);
            <D.24702>:
            ins->dreg = val;
            <D.24694>:
            D.24402 = spec_dest == 108;
            D.24403 = spec_dest == 76;
            D.24404 = D.24402 | D.24403;
            if (D.24404 != 0) goto <D.24704>; else goto <D.24705>;
            <D.24704>:
            {
              int reg2;

              reg2 = prev_dreg + 1;
              D.24319 = bank != 0;
              D.24320 = (long int) D.24319;
              D.24321 = __builtin_expect (D.24320, 0);
              if (D.24321 != 0) goto <D.24706>; else goto <D.24707>;
              <D.24706>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1651, "!bank");
              <D.24707>:
              D.24708 = prev_dreg < 0;
              D.24709 = (long int) D.24708;
              D.24710 = __builtin_expect (D.24709, 0);
              if (D.24710 != 0) goto <D.24711>; else goto <D.24712>;
              <D.24711>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1652, "prev_dreg > -1");
              <D.24712>:
              D.24342 = rs->vassign;
              prev_dreg.59 = (unsigned int) prev_dreg;
              D.24717 = prev_dreg.59 * 4;
              D.24718 = D.24342 + D.24717;
              D.24719 = *D.24718;
              D.24720 = (unsigned int) D.24719;
              if (D.24720 <= 7) goto <D.24721>; else goto <D.24714>;
              <D.24721>:
              D.24342 = rs->vassign;
              prev_dreg.59 = (unsigned int) prev_dreg;
              D.24717 = prev_dreg.59 * 4;
              D.24718 = D.24342 + D.24717;
              D.24719 = *D.24718;
              D.24722 = 232 >> D.24719;
              D.24723 = D.24722 & 1;
              if (D.24723 != 0) goto <D.24724>; else goto <D.24714>;
              <D.24724>:
              iftmp.58 = 1;
              goto <D.24715>;
              <D.24714>:
              iftmp.58 = 0;
              <D.24715>:
              D.24725 = iftmp.58 != 0;
              D.24726 = (long int) D.24725;
              D.24727 = __builtin_expect (D.24726, 0);
              if (D.24727 != 0) goto <D.24728>; else goto <D.24729>;
              <D.24728>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1653, "!is_global_ireg (rs->vassign [prev_dreg])");
              <D.24729>:
              if (spec_dest == 108) goto <D.24731>; else goto <D.24732>;
              <D.24731>:
              if (spec_dest == 108) goto <D.24734>; else goto <D.24735>;
              <D.24734>:
              iftmp.61 = 4;
              goto <D.24736>;
              <D.24735>:
              iftmp.61 = 0;
              <D.24736>:
              iftmp.60 = iftmp.61;
              goto <D.24737>;
              <D.24732>:
              iftmp.60 = 7;
              <D.24737>:
              mask = iftmp.60;
              mask = mask & 4294967293;
              D.24342 = rs->vassign;
              reg2.62 = (unsigned int) reg2;
              D.24739 = reg2.62 * 4;
              D.24740 = D.24342 + D.24739;
              val = *D.24740;
              if (val < 0) goto <D.24741>; else goto <D.24742>;
              <D.24741>:
              {
                int spill;

                spill = 0;
                if (val < -1) goto <D.24743>; else goto <D.24744>;
                <D.24743>:
                spill = ~val;
                <D.24744>:
                val = mono_regstate_alloc_int (rs, mask);
                if (val < 0) goto <D.24745>; else goto <D.24746>;
                <D.24745>:
                val = get_register_spilling (cfg, bb, tmp, ins, mask, reg2, bank);
                <D.24746>:
                if (spill != 0) goto <D.24747>; else goto <D.24748>;
                <D.24747>:
                create_spilled_store (cfg, bb, spill, val, reg2, tmp, ins, 0B, bank);
                <D.24748>:
              }
              goto <D.24749>;
              <D.24742>:
              D.24750 = 1 << val;
              D.24751 = D.24750 & mask;
              if (D.24751 == 0) goto <D.24752>; else goto <D.24753>;
              <D.24752>:
              val = mono_regstate_alloc_int (rs, mask);
              if (val < 0) goto <D.24754>; else goto <D.24755>;
              <D.24754>:
              val = get_register_spilling (cfg, bb, tmp, ins, mask, reg2, bank);
              <D.24755>:
              D.24342 = rs->vassign;
              reg2.62 = (unsigned int) reg2;
              D.24739 = reg2.62 * 4;
              D.24740 = D.24342 + D.24739;
              D.24756 = *D.24740;
              create_copy_ins (cfg, bb, tmp, D.24756, val, ins, ip, bank);
              D.24342 = rs->vassign;
              reg2.62 = (unsigned int) reg2;
              D.24739 = reg2.62 * 4;
              D.24740 = D.24342 + D.24739;
              D.24756 = *D.24740;
              mono_regstate_free_int (rs, D.24756);
              <D.24753>:
              <D.24749>:
              D.24223 = cfg->verbose_level;
              D.24278 = D.24223 > 2;
              D.24279 = (long int) D.24278;
              D.24280 = __builtin_expect (D.24279, 0);
              if (D.24280 != 0) goto <D.24757>; else goto <D.24758>;
              <D.24757>:
              D.24759 = mono_arch_regname (val);
              printf ("\tassigned dreg-high %s to dest R%d\n", D.24759, reg2);
              <D.24758>:
              assign_reg (cfg, rs, reg2, val, bank);
              dreg_high = val;
              ins->backend.reg3 = val;
              D.24319 = bank != 0;
              D.24320 = (long int) D.24319;
              D.24321 = __builtin_expect (D.24320, 0);
              if (D.24321 != 0) goto <D.24761>; else goto <D.24762>;
              <D.24761>:
              D.24319 = bank != 0;
              D.24320 = (long int) D.24319;
              D.24321 = __builtin_expect (D.24320, 0);
              if (D.24321 != 0) goto <D.24764>; else goto <D.24765>;
              <D.24764>:
              D.24319 = bank != 0;
              D.24320 = (long int) D.24319;
              D.24321 = __builtin_expect (D.24320, 0);
              if (D.24321 != 0) goto <D.24769>; else goto <D.24770>;
              <D.24769>:
              if (val >= 0) goto <D.24774>; else goto <D.24772>;
              <D.24774>:
              D.24329 = regbank_size[bank];
              if (D.24329 > val) goto <D.24775>; else goto <D.24772>;
              <D.24775>:
              iftmp.66 = 1;
              goto <D.24773>;
              <D.24772>:
              iftmp.66 = 0;
              <D.24773>:
              D.24776 = (_Bool) iftmp.66;
              if (D.24776 != 0) goto <D.24777>; else goto <D.24767>;
              <D.24777>:
              goto <D.24778>;
              <D.24770>:
              if (val <= 7) goto <D.24779>; else goto <D.24767>;
              <D.24779>:
              <D.24778>:
              D.24780 = regbank_callee_regs[bank];
              D.24781 = D.24780 >> val;
              D.24782 = D.24781 & 1;
              if (D.24782 != 0) goto <D.24783>; else goto <D.24767>;
              <D.24783>:
              iftmp.65 = 1;
              goto <D.24768>;
              <D.24767>:
              iftmp.65 = 0;
              <D.24768>:
              iftmp.64 = (_Bool) iftmp.65;
              goto <D.24784>;
              <D.24765>:
              val.68 = (unsigned int) val;
              if (val.68 <= 7) goto <D.24789>; else goto <D.24786>;
              <D.24789>:
              D.24790 = 7 >> val;
              D.24791 = D.24790 & 1;
              if (D.24791 != 0) goto <D.24792>; else goto <D.24786>;
              <D.24792>:
              iftmp.67 = 1;
              goto <D.24787>;
              <D.24786>:
              iftmp.67 = 0;
              <D.24787>:
              iftmp.64 = (_Bool) iftmp.67;
              <D.24784>:
              iftmp.63 = iftmp.64;
              goto <D.24793>;
              <D.24762>:
              val.68 = (unsigned int) val;
              if (val.68 <= 7) goto <D.24797>; else goto <D.24795>;
              <D.24797>:
              D.24790 = 7 >> val;
              D.24791 = D.24790 & 1;
              if (D.24791 != 0) goto <D.24798>; else goto <D.24795>;
              <D.24798>:
              iftmp.69 = 1;
              goto <D.24796>;
              <D.24795>:
              iftmp.69 = 0;
              <D.24796>:
              iftmp.63 = (_Bool) iftmp.69;
              <D.24793>:
              if (iftmp.63 != 0) goto <D.24799>; else goto <D.24800>;
              <D.24799>:
              if (reg2 >= 0) goto <D.24801>; else goto <D.24802>;
              <D.24801>:
              reg2.62 = (unsigned int) reg2;
              D.24803 = reg2.62 * 12;
              D.24804 = reginfo + D.24803;
              D.24805 = D.24804->born_in;
              if (D.24805 >= i) goto <D.24806>; else goto <D.24807>;
              <D.24806>:
              D.24223 = cfg->verbose_level;
              D.24278 = D.24223 > 2;
              D.24279 = (long int) D.24278;
              D.24280 = __builtin_expect (D.24279, 0);
              if (D.24280 != 0) goto <D.24808>; else goto <D.24809>;
              <D.24808>:
              D.24810 = mono_arch_regname (val);
              printf ("\tfreeable %s (R%d)\n", D.24810, reg2);
              <D.24809>:
              mono_regstate_free_int (rs, val);
              <D.24807>:
              <D.24802>:
              <D.24800>:
            }
            <D.24705>:
            if (prev_dreg >= 0) goto <D.24811>; else goto <D.24812>;
            <D.24811>:
            D.24319 = bank != 0;
            D.24320 = (long int) D.24319;
            D.24321 = __builtin_expect (D.24320, 0);
            if (D.24321 != 0) goto <D.24814>; else goto <D.24815>;
            <D.24814>:
            if (prev_dreg < 0) goto <D.24817>; else goto <D.24820>;
            <D.24820>:
            D.24329 = regbank_size[bank];
            if (D.24329 <= prev_dreg) goto <D.24817>; else goto <D.24818>;
            <D.24817>:
            iftmp.71 = 1;
            goto <D.24819>;
            <D.24818>:
            iftmp.71 = 0;
            <D.24819>:
            iftmp.70 = (_Bool) iftmp.71;
            goto <D.24821>;
            <D.24815>:
            iftmp.70 = prev_dreg > 7;
            <D.24821>:
            if (iftmp.70 != 0) goto <D.24822>; else goto <D.24823>;
            <D.24822>:
            if (spec_dest != 98) goto <D.24824>; else goto <D.24825>;
            <D.24824>:
            {
              int dreg;

              D.24342 = rs->vassign;
              prev_dreg.59 = (unsigned int) prev_dreg;
              D.24717 = prev_dreg.59 * 4;
              D.24718 = D.24342 + D.24717;
              dreg = *D.24718;
              D.24826 = dreg < 0;
              D.24827 = (long int) D.24826;
              D.24828 = __builtin_expect (D.24827, 0);
              if (D.24828 != 0) goto <D.24829>; else goto <D.24830>;
              <D.24829>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1704, "dreg >= 0");
              <D.24830>:
              D.24223 = cfg->verbose_level;
              D.24278 = D.24223 > 2;
              D.24279 = (long int) D.24278;
              D.24280 = __builtin_expect (D.24279, 0);
              if (D.24280 != 0) goto <D.24831>; else goto <D.24832>;
              <D.24831>:
              prev_dreg.59 = (unsigned int) prev_dreg;
              D.24833 = prev_dreg.59 * 12;
              D.24834 = reginfo + D.24833;
              D.24835 = D.24834->born_in;
              D.24836 = mono_regname_full (dreg, bank);
              printf ("\tfreeable %s (R%d) (born in %d)\n", D.24836, prev_dreg, D.24835);
              <D.24832>:
              D.24319 = bank != 0;
              D.24320 = (long int) D.24319;
              D.24321 = __builtin_expect (D.24320, 0);
              if (D.24321 != 0) goto <D.24837>; else goto <D.24838>;
              <D.24837>:
              mono_regstate_free_general (rs, dreg, bank);
              goto <D.24839>;
              <D.24838>:
              mono_regstate_free_int (rs, dreg);
              <D.24839>:
              D.24342 = rs->vassign;
              prev_dreg.59 = (unsigned int) prev_dreg;
              D.24717 = prev_dreg.59 * 4;
              D.24718 = D.24342 + D.24717;
              *D.24718 = -1;
            }
            <D.24825>:
            <D.24823>:
            <D.24812>:
            if (dest_dreg != -1) goto <D.24840>; else goto <D.24841>;
            <D.24840>:
            D.24231 = ins->dreg;
            if (D.24231 != dest_dreg) goto <D.24842>; else goto <D.24843>;
            <D.24842>:
            D.24231 = ins->dreg;
            create_copy_ins (cfg, bb, tmp, D.24231, dest_dreg, ins, ip, bank);
            ins->dreg = dest_dreg;
            D.24319 = bank != 0;
            D.24320 = (long int) D.24319;
            D.24321 = __builtin_expect (D.24320, 0);
            if (D.24321 != 0) goto <D.24844>; else goto <D.24845>;
            <D.24844>:
            {
              int translated_bank;

              D.24846 = cfg->rs;
              translated_bank = translate_bank (D.24846, bank, dest_dreg);
              D.24847 = rs->symbolic[translated_bank];
              dest_dreg.72 = (unsigned int) dest_dreg;
              D.24849 = dest_dreg.72 * 4;
              D.24850 = D.24847 + D.24849;
              D.24851 = *D.24850;
              D.24852 = regbank_size[translated_bank];
              if (D.24851 >= D.24852) goto <D.24853>; else goto <D.24854>;
              <D.24853>:
              free_up_hreg (cfg, bb, tmp, ins, dest_dreg, translated_bank);
              <D.24854>:
            }
            goto <D.24855>;
            <D.24845>:
            D.24856 = rs->isymbolic[dest_dreg];
            if (D.24856 > 7) goto <D.24857>; else goto <D.24858>;
            <D.24857>:
            free_up_hreg (cfg, bb, tmp, ins, dest_dreg, bank);
            <D.24858>:
            <D.24855>:
            <D.24843>:
            <D.24841>:
            if (spec_dest == 98) goto <D.24859>; else goto <D.24860>;
            <D.24859>:
            j = 0;
            goto <D.23510>;
            <D.23509>:
            D.24264 = j + 1;
            D.24265 = (sizetype) D.24264;
            D.24266 = spec + D.24265;
            D.24267 = *D.24266;
            D.24300 = D.24267 == 102;
            D.24301 = (long int) D.24300;
            D.24302 = __builtin_expect (D.24301, 0);
            if (D.24302 == 0) goto <D.24861>; else goto <D.24862>;
            <D.24861>:
            D.24264 = j + 1;
            D.24265 = (sizetype) D.24264;
            D.24266 = spec + D.24265;
            D.24267 = *D.24266;
            D.24306 = D.24267 == 120;
            D.24307 = (long int) D.24306;
            D.24308 = __builtin_expect (D.24307, 0);
            if (D.24308 == 0) goto <D.24863>; else goto <D.24864>;
            <D.24863>:
            D.24865 = sreg_masks[j];
            D.24231 = ins->dreg;
            D.24866 = 1 << D.24231;
            D.24867 = ~D.24866;
            D.24868 = D.24865 & D.24867;
            sreg_masks[j] = D.24868;
            <D.24864>:
            <D.24862>:
            j = j + 1;
            <D.23510>:
            if (j < num_sregs) goto <D.23509>; else goto <D.23511>;
            <D.23511>:
            <D.24860>:
            if (clob_reg != -1) goto <D.24869>; else goto <D.24870>;
            <D.24869>:
            D.24520 = rs->ifree_mask;
            D.24871 = 1 << clob_reg;
            D.24872 = D.24520 & D.24871;
            if (D.24872 == 0) goto <D.24873>; else goto <D.24874>;
            <D.24873>:
            D.24223 = cfg->verbose_level;
            D.24278 = D.24223 > 2;
            D.24279 = (long int) D.24278;
            D.24280 = __builtin_expect (D.24279, 0);
            if (D.24280 != 0) goto <D.24875>; else goto <D.24876>;
            <D.24875>:
            D.24877 = rs->isymbolic[clob_reg];
            printf ("\tforced spill of clobbered reg R%d\n", D.24877);
            <D.24876>:
            free_up_hreg (cfg, bb, tmp, ins, clob_reg, 0);
            <D.24874>:
            <D.24870>:
            D.24426 = spec + 5;
            D.24427 = *D.24426;
            if (D.24427 == 99) goto <D.24878>; else goto <D.24879>;
            <D.24878>:
            {
              int j;
              int s;
              int dreg;
              int dreg2;
              int cur_bank;
              guint64 clob_mask;

              clob_mask = 7;
              D.24520 = rs->ifree_mask;
              if (D.24520 != 7) goto <D.24880>; else goto <D.24881>;
              <D.24880>:
              if (prev_dreg != -1) goto <D.24884>; else goto <D.24882>;
              <D.24884>:
              D.24885 = spec_dest == 102;
              D.24886 = (long int) D.24885;
              D.24887 = __builtin_expect (D.24886, 0);
              if (D.24887 == 0) goto <D.24888>; else goto <D.24882>;
              <D.24888>:
              D.24889 = spec_dest == 120;
              D.24890 = (long int) D.24889;
              D.24891 = __builtin_expect (D.24890, 0);
              if (D.24891 == 0) goto <D.24892>; else goto <D.24882>;
              <D.24892>:
              D.24342 = rs->vassign;
              prev_dreg.59 = (unsigned int) prev_dreg;
              D.24717 = prev_dreg.59 * 4;
              D.24718 = D.24342 + D.24717;
              dreg = *D.24718;
              goto <D.24883>;
              <D.24882>:
              dreg = -1;
              <D.24883>:
              D.24402 = spec_dest == 108;
              D.24403 = spec_dest == 76;
              D.24404 = D.24402 | D.24403;
              if (D.24404 != 0) goto <D.24893>; else goto <D.24894>;
              <D.24893>:
              D.24342 = rs->vassign;
              prev_dreg.73 = (sizetype) prev_dreg;
              D.24896 = prev_dreg.73 + 1;
              D.24897 = D.24896 * 4;
              D.24898 = D.24342 + D.24897;
              dreg2 = *D.24898;
              goto <D.24899>;
              <D.24894>:
              dreg2 = -1;
              <D.24899>:
              j = 0;
              goto <D.23519>;
              <D.23518>:
              D.24900 = 1 << j;
              s = (int) D.24900;
              D.24901 = (long long unsigned int) s;
              D.24902 = D.24901 & clob_mask;
              if (D.24902 != 0) goto <D.24903>; else goto <D.24904>;
              <D.24903>:
              D.24520 = rs->ifree_mask;
              s.74 = (unsigned int) s;
              D.24906 = D.24520 & s.74;
              if (D.24906 == 0) goto <D.24907>; else goto <D.24908>;
              <D.24907>:
              D.24249 = ins->sreg1;
              if (D.24249 != j) goto <D.24909>; else goto <D.24910>;
              <D.24909>:
              D.24911 = j != dreg;
              D.24912 = j != dreg2;
              D.24913 = D.24911 & D.24912;
              if (D.24913 != 0) goto <D.24914>; else goto <D.24915>;
              <D.24914>:
              free_up_hreg (cfg, bb, tmp, ins, j, 0);
              goto <D.24916>;
              <D.24915>:
              D.24917 = rs->isymbolic[j];
              if (D.24917 != 0) goto <D.24918>; else goto <D.24919>;
              <D.24918>:
              D.24342 = rs->vassign;
              D.24917 = rs->isymbolic[j];
              D.24920 = (unsigned int) D.24917;
              D.24921 = D.24920 * 4;
              D.24922 = D.24342 + D.24921;
              *D.24922 = -1;
              <D.24919>:
              <D.24916>:
              mono_regstate_free_int (rs, j);
              <D.24910>:
              <D.24908>:
              <D.24904>:
              j = j + 1;
              <D.23519>:
              if (j <= 7) goto <D.23518>; else goto <D.23520>;
              <D.23520>:
              <D.24881>:
              cur_bank = 1;
              goto <D.23526>;
              <D.23525>:
              D.24923 = rs->free_mask[cur_bank];
              D.24924 = regbank_callee_regs[cur_bank];
              if (D.24923 != D.24924) goto <D.24925>; else goto <D.24926>;
              <D.24925>:
              D.24924 = regbank_callee_regs[cur_bank];
              clob_mask = (guint64) D.24924;
              if (prev_dreg != -1) goto <D.24930>; else goto <D.24927>;
              <D.24930>:
              D.24885 = spec_dest == 102;
              D.24886 = (long int) D.24885;
              D.24887 = __builtin_expect (D.24886, 0);
              if (D.24887 != 0) goto <D.24928>; else goto <D.24931>;
              <D.24931>:
              D.24889 = spec_dest == 120;
              D.24890 = (long int) D.24889;
              D.24891 = __builtin_expect (D.24890, 0);
              if (D.24891 != 0) goto <D.24928>; else goto <D.24927>;
              <D.24928>:
              D.24342 = rs->vassign;
              prev_dreg.59 = (unsigned int) prev_dreg;
              D.24717 = prev_dreg.59 * 4;
              D.24718 = D.24342 + D.24717;
              dreg = *D.24718;
              goto <D.24929>;
              <D.24927>:
              dreg = -1;
              <D.24929>:
              j = 0;
              goto <D.23523>;
              <D.23522>:
              if (0 != 0) goto <D.24932>; else goto <D.24933>;
              <D.24932>:
              // predicted unlikely by continue predictor.
              goto <D.23521>;
              <D.24933>:
              D.24900 = 1 << j;
              s = (int) D.24900;
              D.24901 = (long long unsigned int) s;
              D.24902 = D.24901 & clob_mask;
              if (D.24902 != 0) goto <D.24934>; else goto <D.24935>;
              <D.24934>:
              D.24923 = rs->free_mask[cur_bank];
              s.74 = (unsigned int) s;
              D.24936 = D.24923 & s.74;
              if (D.24936 == 0) goto <D.24937>; else goto <D.24938>;
              <D.24937>:
              if (j != dreg) goto <D.24939>; else goto <D.24940>;
              <D.24939>:
              free_up_hreg (cfg, bb, tmp, ins, j, cur_bank);
              goto <D.24941>;
              <D.24940>:
              D.24942 = rs->symbolic[cur_bank];
              j.75 = (unsigned int) j;
              D.24944 = j.75 * 4;
              D.24945 = D.24942 + D.24944;
              D.24946 = *D.24945;
              if (D.24946 != 0) goto <D.24947>; else goto <D.24948>;
              <D.24947>:
              D.24342 = rs->vassign;
              D.24942 = rs->symbolic[cur_bank];
              j.75 = (unsigned int) j;
              D.24944 = j.75 * 4;
              D.24945 = D.24942 + D.24944;
              D.24946 = *D.24945;
              D.24949 = (unsigned int) D.24946;
              D.24950 = D.24949 * 4;
              D.24951 = D.24342 + D.24950;
              *D.24951 = -1;
              <D.24948>:
              <D.24941>:
              mono_regstate_free_general (rs, j, cur_bank);
              <D.24938>:
              <D.24935>:
              <D.23521>:
              j = j + 1;
              <D.23523>:
              D.24952 = regbank_size[cur_bank];
              if (D.24952 > j) goto <D.23522>; else goto <D.23524>;
              <D.23524>:
              <D.24926>:
              cur_bank = cur_bank + 1;
              <D.23526>:
              if (cur_bank <= 4) goto <D.23525>; else goto <D.23527>;
              <D.23527>:
            }
            <D.24879>:
            D.24426 = spec + 5;
            D.24427 = *D.24426;
            if (D.24427 == 99) goto <D.24955>; else goto <D.24956>;
            <D.24955>:
            D.24957 = ins->opcode;
            D.24958 = D.24957 + 65193;
            D.24959 = D.24958 <= 2;
            D.24960 = D.24957 + 65187;
            D.24961 = D.24960 <= 2;
            D.24962 = D.24959 | D.24961;
            if (D.24962 != 0) goto <D.24953>; else goto <D.24963>;
            <D.24963>:
            D.24226 = ins->opcode;
            D.24437 = D.24226 + 65184;
            if (D.24437 <= 2) goto <D.24953>; else goto <D.24964>;
            <D.24964>:
            D.24226 = ins->opcode;
            D.24439 = D.24226 + 65181;
            if (D.24439 <= 2) goto <D.24953>; else goto <D.24965>;
            <D.24965>:
            D.24226 = ins->opcode;
            D.24441 = D.24226 + 65190;
            if (D.24441 <= 2) goto <D.24953>; else goto <D.24966>;
            <D.24966>:
            D.24226 = ins->opcode;
            D.24443 = D.24226 + 65178;
            if (D.24443 <= 2) goto <D.24953>; else goto <D.24967>;
            <D.24967>:
            D.24226 = ins->opcode;
            if (D.24226 == 448) goto <D.24953>; else goto <D.24954>;
            <D.24953>:
            {
              struct MonoCallInst * call;
              struct GSList * list;

              call = ins;
              list = call->out_ireg_args;
              if (list != 0B) goto <D.24968>; else goto <D.24969>;
              <D.24968>:
              goto <D.23534>;
              <D.23533>:
              {
                guint32 regpair;
                int reg;
                int hreg;

                D.24970 = list->data;
                regpair = (guint32) D.24970;
                D.24971 = regpair >> 24;
                hreg = (int) D.24971;
                regpair.76 = (int) regpair;
                reg = regpair.76 & 16777215;
                assign_reg (cfg, rs, reg, hreg, 0);
                D.24973 = sreg_masks[0];
                D.24974 = 1 << hreg;
                D.24975 = ~D.24974;
                D.24976 = D.24973 & D.24975;
                sreg_masks[0] = D.24976;
                D.24223 = cfg->verbose_level;
                D.24278 = D.24223 > 2;
                D.24279 = (long int) D.24278;
                D.24280 = __builtin_expect (D.24279, 0);
                if (D.24280 != 0) goto <D.24977>; else goto <D.24978>;
                <D.24977>:
                D.24979 = mono_arch_regname (hreg);
                printf ("\tassigned arg reg %s to R%d\n", D.24979, reg);
                <D.24978>:
                if (list != 0B) goto <D.24981>; else goto <D.24982>;
                <D.24981>:
                iftmp.77 = list->next;
                goto <D.24983>;
                <D.24982>:
                iftmp.77 = 0B;
                <D.24983>:
                list = iftmp.77;
              }
              <D.23534>:
              if (list != 0B) goto <D.23533>; else goto <D.23535>;
              <D.23535>:
              <D.24969>:
              list = call->out_freg_args;
              if (list != 0B) goto <D.24984>; else goto <D.24985>;
              <D.24984>:
              goto <D.23540>;
              <D.23539>:
              {
                guint32 regpair;
                int reg;
                int hreg;

                D.24970 = list->data;
                regpair = (guint32) D.24970;
                D.24986 = regpair >> 24;
                hreg = (int) D.24986;
                regpair.78 = (int) regpair;
                reg = regpair.78 & 16777215;
                assign_reg (cfg, rs, reg, hreg, 1);
                D.24223 = cfg->verbose_level;
                D.24278 = D.24223 > 2;
                D.24279 = (long int) D.24278;
                D.24280 = __builtin_expect (D.24279, 0);
                if (D.24280 != 0) goto <D.24988>; else goto <D.24989>;
                <D.24988>:
                D.24990 = mono_regname_full (hreg, 1);
                printf ("\tassigned arg reg %s to R%d\n", D.24990, reg);
                <D.24989>:
                if (list != 0B) goto <D.24992>; else goto <D.24993>;
                <D.24992>:
                iftmp.79 = list->next;
                goto <D.24994>;
                <D.24993>:
                iftmp.79 = 0B;
                <D.24994>:
                list = iftmp.79;
              }
              <D.23540>:
              if (list != 0B) goto <D.23539>; else goto <D.23541>;
              <D.23541>:
              <D.24985>:
            }
            <D.24954>:
            <D.24956>:
            D.24181 = spec + 1;
            D.24182 = *D.24181;
            D.24996 = D.24182 == 102;
            D.24997 = (long int) D.24996;
            D.24998 = __builtin_expect (D.24997, 0);
            if (D.24998 == 0) goto <D.24999>; else goto <D.25000>;
            <D.24999>:
            D.24181 = spec + 1;
            D.24182 = *D.24181;
            D.25002 = D.24182 == 120;
            D.25003 = (long int) D.25002;
            D.25004 = __builtin_expect (D.25003, 0);
            if (D.25004 != 0) goto <D.25005>; else goto <D.25006>;
            <D.25005>:
            iftmp.81 = 4;
            goto <D.25007>;
            <D.25006>:
            iftmp.81 = 0;
            <D.25007>:
            iftmp.80 = iftmp.81;
            goto <D.25008>;
            <D.25000>:
            iftmp.80 = 1;
            <D.25008>:
            bank = iftmp.80;
            D.24402 = spec_dest == 108;
            D.24403 = spec_dest == 76;
            D.24404 = D.24402 | D.24403;
            if (D.24404 != 0) goto <D.25009>; else goto <D.25010>;
            <D.25009>:
            D.24426 = spec + 5;
            D.24427 = *D.24426;
            if (D.24427 == 49) goto <D.25011>; else goto <D.25012>;
            <D.25011>:
            {
              int sreg1;
              int dest_sreg1;

              sreg1 = sregs[0];
              dest_sreg1 = dest_sregs[0];
              D.24319 = bank != 0;
              D.24320 = (long int) D.24319;
              D.24321 = __builtin_expect (D.24320, 0);
              if (D.24321 != 0) goto <D.25014>; else goto <D.25015>;
              <D.25014>:
              if (sreg1 >= 0) goto <D.25019>; else goto <D.25017>;
              <D.25019>:
              D.24329 = regbank_size[bank];
              if (D.24329 > sreg1) goto <D.25020>; else goto <D.25017>;
              <D.25020>:
              iftmp.83 = 1;
              goto <D.25018>;
              <D.25017>:
              iftmp.83 = 0;
              <D.25018>:
              D.25021 = iftmp.83 != 0;
              iftmp.82 = (long int) D.25021;
              goto <D.25022>;
              <D.25015>:
              D.25023 = sreg1 <= 7;
              iftmp.82 = (long int) D.25023;
              <D.25022>:
              D.25024 = __builtin_expect (iftmp.82, 0);
              if (D.25024 != 0) goto <D.25025>; else goto <D.25026>;
              <D.25025>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1879, "is_soft_reg (sreg1, bank)");
              <D.25026>:
              if (dest_sreg1 != -1) goto <D.25027>; else goto <D.25028>;
              <D.25027>:
              D.24231 = ins->dreg;
              D.25029 = D.24231 != dest_sreg1;
              D.25030 = (long int) D.25029;
              D.25031 = __builtin_expect (D.25030, 0);
              if (D.25031 != 0) goto <D.25032>; else goto <D.25033>;
              <D.25032>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1883, "dest_sreg1 == ins->dreg");
              <D.25033>:
              <D.25028>:
              D.24231 = ins->dreg;
              D.24866 = 1 << D.24231;
              val = mono_regstate_alloc_int (rs, D.24866);
              D.25034 = val < 0;
              D.25035 = (long int) D.25034;
              D.25036 = __builtin_expect (D.25035, 0);
              if (D.25036 != 0) goto <D.25037>; else goto <D.25038>;
              <D.25037>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1885, "val >= 0");
              <D.25038>:
              D.24342 = rs->vassign;
              sreg1.84 = (unsigned int) sreg1;
              D.25040 = sreg1.84 * 4;
              D.25041 = D.24342 + D.25040;
              D.25042 = *D.25041;
              if (D.25042 >= 0) goto <D.25043>; else goto <D.25044>;
              <D.25043>:
              D.24342 = rs->vassign;
              sreg1.84 = (unsigned int) sreg1;
              D.25040 = sreg1.84 * 4;
              D.25041 = D.24342 + D.25040;
              D.25042 = *D.25041;
              if (D.25042 != val) goto <D.25045>; else goto <D.25046>;
              <D.25045>:
              monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-codegen.c", 1889);
              <D.25046>:
              <D.25044>:
              assign_reg (cfg, rs, sreg1, val, bank);
              D.24223 = cfg->verbose_level;
              D.24278 = D.24223 > 2;
              D.24279 = (long int) D.24278;
              D.24280 = __builtin_expect (D.24279, 0);
              if (D.24280 != 0) goto <D.25047>; else goto <D.25048>;
              <D.25047>:
              D.25049 = mono_regname_full (val, bank);
              printf ("\tassigned sreg1-low %s to R%d\n", D.25049, sreg1);
              <D.25048>:
              if (spec_src1 == 108) goto <D.25051>; else goto <D.25052>;
              <D.25051>:
              if (spec_src1 == 108) goto <D.25054>; else goto <D.25055>;
              <D.25054>:
              iftmp.86 = 4;
              goto <D.25056>;
              <D.25055>:
              iftmp.86 = 0;
              <D.25056>:
              iftmp.85 = iftmp.86;
              goto <D.25057>;
              <D.25052>:
              iftmp.85 = 7;
              <D.25057>:
              D.25058 = iftmp.85 >> dreg_high;
              D.25059 = D.25058 & 1;
              D.25060 = D.25059 == 0;
              D.25061 = (long int) D.25060;
              D.25062 = __builtin_expect (D.25061, 0);
              if (D.25062 != 0) goto <D.25063>; else goto <D.25064>;
              <D.25063>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1895, "(regmask (dreg_high)) & regpair_reg2_mask (spec_src1, ins->dreg)");
              <D.25064>:
              D.25065 = 1 << dreg_high;
              val = mono_regstate_alloc_int (rs, D.25065);
              D.25034 = val < 0;
              D.25035 = (long int) D.25034;
              D.25036 = __builtin_expect (D.25035, 0);
              if (D.25036 != 0) goto <D.25066>; else goto <D.25067>;
              <D.25066>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1897, "val >= 0");
              <D.25067>:
              D.24342 = rs->vassign;
              sreg1.87 = (sizetype) sreg1;
              D.25069 = sreg1.87 + 1;
              D.25070 = D.25069 * 4;
              D.25071 = D.24342 + D.25070;
              D.25072 = *D.25071;
              if (D.25072 >= 0) goto <D.25073>; else goto <D.25074>;
              <D.25073>:
              D.24342 = rs->vassign;
              sreg1.87 = (sizetype) sreg1;
              D.25069 = sreg1.87 + 1;
              D.25070 = D.25069 * 4;
              D.25071 = D.24342 + D.25070;
              D.25072 = *D.25071;
              if (D.25072 != val) goto <D.25075>; else goto <D.25076>;
              <D.25075>:
              monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-codegen.c", 1901);
              <D.25076>:
              <D.25074>:
              D.25077 = sreg1 + 1;
              assign_reg (cfg, rs, D.25077, val, bank);
              D.24223 = cfg->verbose_level;
              D.24278 = D.24223 > 2;
              D.24279 = (long int) D.24278;
              D.24280 = __builtin_expect (D.24279, 0);
              if (D.24280 != 0) goto <D.25078>; else goto <D.25079>;
              <D.25078>:
              D.25077 = sreg1 + 1;
              D.25080 = mono_regname_full (val, bank);
              printf ("\tassigned sreg1-high %s to R%d\n", D.25080, D.25077);
              <D.25079>:
              dest_sregs[0] = -1;
            }
            <D.25012>:
            <D.25010>:
            D.25081 = sreg_fixed_masks[0];
            if (D.25081 != 0) goto <D.25082>; else goto <D.25083>;
            <D.25082>:
            D.24319 = bank != 0;
            D.24320 = (long int) D.24319;
            D.24321 = __builtin_expect (D.24320, 0);
            if (D.24321 != 0) goto <D.25084>; else goto <D.25085>;
            <D.25084>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1912, "!bank");
            <D.25085>:
            D.25088 = sregs[0];
            D.25089 = (unsigned int) D.25088;
            if (D.25089 <= 7) goto <D.25090>; else goto <D.25086>;
            <D.25090>:
            D.25088 = sregs[0];
            D.25091 = 232 >> D.25088;
            D.25092 = D.25091 & 1;
            if (D.25092 != 0) goto <D.25093>; else goto <D.25086>;
            <D.25093>:
            D.25081 = sreg_fixed_masks[0];
            val = mono_regstate_alloc_int (rs, D.25081);
            if (val < 0) goto <D.25094>; else goto <D.25095>;
            <D.25094>:
            D.25081 = sreg_fixed_masks[0];
            val = get_register_spilling (cfg, bb, tmp, ins, D.25081, -1, bank);
            <D.25095>:
            mono_regstate_free_int (rs, val);
            dest_sregs[0] = val;
            goto <D.25087>;
            <D.25086>:
            D.24973 = sreg_masks[0];
            D.25081 = sreg_fixed_masks[0];
            D.25096 = D.24973 & D.25081;
            sreg_masks[0] = D.25096;
            <D.25087>:
            <D.25083>:
            D.24609 = dest_sregs[0];
            if (D.24609 != -1) goto <D.25097>; else goto <D.25098>;
            <D.25097>:
            D.24609 = dest_sregs[0];
            D.24612 = 1 << D.24609;
            sreg_masks[0] = D.24612;
            D.24342 = rs->vassign;
            D.25088 = sregs[0];
            D.25099 = (unsigned int) D.25088;
            D.25100 = D.25099 * 4;
            D.25101 = D.24342 + D.25100;
            D.25102 = *D.25101;
            D.24609 = dest_sregs[0];
            if (D.25102 != D.24609) goto <D.25103>; else goto <D.25104>;
            <D.25103>:
            D.24520 = rs->ifree_mask;
            D.24609 = dest_sregs[0];
            D.24612 = 1 << D.24609;
            D.25105 = D.24520 & D.24612;
            if (D.25105 == 0) goto <D.25106>; else goto <D.25107>;
            <D.25106>:
            D.24609 = dest_sregs[0];
            free_up_hreg (cfg, bb, tmp, ins, D.24609, 0);
            <D.25107>:
            <D.25104>:
            D.25088 = sregs[0];
            D.25089 = (unsigned int) D.25088;
            if (D.25089 <= 7) goto <D.25108>; else goto <D.25109>;
            <D.25108>:
            D.25088 = sregs[0];
            D.25091 = 232 >> D.25088;
            D.25092 = D.25091 & 1;
            if (D.25092 != 0) goto <D.25110>; else goto <D.25111>;
            <D.25110>:
            {
              struct MonoInst * copy;

              D.25088 = sregs[0];
              D.24609 = dest_sregs[0];
              copy = create_copy_ins (cfg, bb, tmp, D.24609, D.25088, 0B, ip, 0);
              insert_before_ins (bb, ins, copy);
              D.24609 = dest_sregs[0];
              sregs[0] = D.24609;
            }
            <D.25111>:
            <D.25109>:
            <D.25098>:
            D.24319 = bank != 0;
            D.24320 = (long int) D.24319;
            D.24321 = __builtin_expect (D.24320, 0);
            if (D.24321 != 0) goto <D.25113>; else goto <D.25114>;
            <D.25113>:
            D.25088 = sregs[0];
            if (D.25088 < 0) goto <D.25116>; else goto <D.25119>;
            <D.25119>:
            D.25088 = sregs[0];
            D.24329 = regbank_size[bank];
            if (D.25088 >= D.24329) goto <D.25116>; else goto <D.25117>;
            <D.25116>:
            iftmp.89 = 1;
            goto <D.25118>;
            <D.25117>:
            iftmp.89 = 0;
            <D.25118>:
            iftmp.88 = (_Bool) iftmp.89;
            goto <D.25120>;
            <D.25114>:
            D.25088 = sregs[0];
            iftmp.88 = D.25088 > 7;
            <D.25120>:
            if (iftmp.88 != 0) goto <D.25121>; else goto <D.25122>;
            <D.25121>:
            D.24342 = rs->vassign;
            D.25088 = sregs[0];
            D.25099 = (unsigned int) D.25088;
            D.25100 = D.25099 * 4;
            D.25101 = D.24342 + D.25100;
            val = *D.25101;
            D.25088 = sregs[0];
            prev_sregs[0] = D.25088;
            if (val < 0) goto <D.25123>; else goto <D.25124>;
            <D.25123>:
            {
              int spill;

              spill = 0;
              if (val < -1) goto <D.25125>; else goto <D.25126>;
              <D.25125>:
              spill = ~val;
              <D.25126>:
              D.24226 = ins->opcode;
              if (D.24226 == 428) goto <D.25127>; else goto <D.25128>;
              <D.25127>:
              D.25129 = spill | bank;
              if (D.25129 == 0) goto <D.25130>; else goto <D.25131>;
              <D.25130>:
              D.24231 = ins->dreg;
              D.24677 = (unsigned int) D.24231;
              if (D.24677 <= 7) goto <D.25132>; else goto <D.25133>;
              <D.25132>:
              D.24231 = ins->dreg;
              D.25134 = 7 >> D.24231;
              D.25135 = D.25134 & 1;
              if (D.25135 != 0) goto <D.25136>; else goto <D.25137>;
              <D.25136>:
              D.24520 = rs->ifree_mask;
              D.24231 = ins->dreg;
              D.24866 = 1 << D.24231;
              D.25138 = D.24520 & D.24866;
              if (D.25138 != 0) goto <D.25139>; else goto <D.25140>;
              <D.25139>:
              D.24231 = ins->dreg;
              D.24866 = 1 << D.24231;
              sreg_masks[0] = D.24866;
              <D.25140>:
              <D.25137>:
              <D.25133>:
              <D.25131>:
              <D.25128>:
              D.24426 = spec + 5;
              D.24427 = *D.24426;
              if (D.24427 == 49) goto <D.25141>; else goto <D.25142>;
              <D.25141>:
              D.24174 = *spec;
              D.24364 = D.24174 == 102;
              D.24365 = (long int) D.24364;
              D.24366 = __builtin_expect (D.24365, 0);
              if (D.24366 == 0) goto <D.25143>; else goto <D.25144>;
              <D.25143>:
              D.24174 = *spec;
              D.24370 = D.24174 == 120;
              D.24371 = (long int) D.24370;
              D.24372 = __builtin_expect (D.24371, 0);
              if (D.24372 == 0) goto <D.25145>; else goto <D.25146>;
              <D.25145>:
              D.24520 = rs->ifree_mask;
              D.24231 = ins->dreg;
              D.24866 = 1 << D.24231;
              D.25138 = D.24520 & D.24866;
              if (D.25138 != 0) goto <D.25147>; else goto <D.25148>;
              <D.25147>:
              D.24231 = ins->dreg;
              D.24866 = 1 << D.24231;
              sreg_masks[0] = D.24866;
              <D.25148>:
              <D.25146>:
              <D.25144>:
              <D.25142>:
              D.25088 = sregs[0];
              D.25099 = (unsigned int) D.25088;
              D.25149 = D.25099 * 12;
              D.25150 = reginfo + D.25149;
              D.25088 = sregs[0];
              D.24973 = sreg_masks[0];
              val = alloc_reg (cfg, bb, tmp, ins, D.24973, D.25088, D.25150, bank);
              D.25088 = sregs[0];
              assign_reg (cfg, rs, D.25088, val, bank);
              D.24223 = cfg->verbose_level;
              D.24278 = D.24223 > 2;
              D.24279 = (long int) D.24278;
              D.24280 = __builtin_expect (D.24279, 0);
              if (D.24280 != 0) goto <D.25151>; else goto <D.25152>;
              <D.25151>:
              D.25088 = sregs[0];
              D.25153 = mono_regname_full (val, bank);
              printf ("\tassigned sreg1 %s to R%d\n", D.25153, D.25088);
              <D.25152>:
              if (spill != 0) goto <D.25154>; else goto <D.25155>;
              <D.25154>:
              D.25156 = prev_sregs[0];
              create_spilled_store (cfg, bb, spill, val, D.25156, tmp, 0B, ins, bank);
              <D.25155>:
            }
            goto <D.25157>;
            <D.25124>:
            D.24609 = dest_sregs[0];
            if (D.24609 != -1) goto <D.25158>; else goto <D.25159>;
            <D.25158>:
            D.24609 = dest_sregs[0];
            if (D.24609 != val) goto <D.25160>; else goto <D.25161>;
            <D.25160>:
            {
              struct MonoInst * copy;

              D.24609 = dest_sregs[0];
              copy = create_copy_ins (cfg, bb, tmp, D.24609, val, 0B, ip, bank);
              insert_before_ins (bb, ins, copy);
              j = 1;
              goto <D.23548>;
              <D.23547>:
              D.24865 = sreg_masks[j];
              D.24609 = dest_sregs[0];
              D.24612 = 1 << D.24609;
              D.24613 = ~D.24612;
              D.25162 = D.24865 & D.24613;
              sreg_masks[j] = D.25162;
              j = j + 1;
              <D.23548>:
              if (j < num_sregs) goto <D.23547>; else goto <D.23549>;
              <D.23549>:
              val = dest_sregs[0];
            }
            <D.25161>:
            <D.25159>:
            <D.25157>:
            sregs[0] = val;
            goto <D.25163>;
            <D.25122>:
            prev_sregs[0] = -1;
            <D.25163>:
            mono_inst_set_src_registers (ins, &sregs);
            j = 1;
            goto <D.23551>;
            <D.23550>:
            D.24865 = sreg_masks[j];
            D.25088 = sregs[0];
            D.25164 = 1 << D.25088;
            D.25165 = ~D.25164;
            D.25166 = D.24865 & D.25165;
            sreg_masks[j] = D.25166;
            j = j + 1;
            <D.23551>:
            if (j < num_sregs) goto <D.23550>; else goto <D.23552>;
            <D.23552>:
            D.25167 = spec_src1 == 108;
            D.25168 = spec_src1 == 76;
            D.25169 = D.25167 | D.25168;
            if (D.25169 != 0) goto <D.25170>; else goto <D.25171>;
            <D.25170>:
            D.24426 = spec + 5;
            D.24427 = *D.24426;
            if (D.24427 != 49) goto <D.25172>; else goto <D.25173>;
            <D.25172>:
            {
              int reg2;

              D.25156 = prev_sregs[0];
              reg2 = D.25156 + 1;
              D.24319 = bank != 0;
              D.24320 = (long int) D.24319;
              D.24321 = __builtin_expect (D.24320, 0);
              if (D.24321 != 0) goto <D.25174>; else goto <D.25175>;
              <D.25174>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 2000, "!bank");
              <D.25175>:
              D.25156 = prev_sregs[0];
              D.25176 = D.25156 < 0;
              D.25177 = (long int) D.25176;
              D.25178 = __builtin_expect (D.25177, 0);
              if (D.25178 != 0) goto <D.25179>; else goto <D.25180>;
              <D.25179>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 2001, "prev_sregs [0] > -1");
              <D.25180>:
              D.24342 = rs->vassign;
              D.25156 = prev_sregs[0];
              D.25184 = (unsigned int) D.25156;
              D.25185 = D.25184 * 4;
              D.25186 = D.24342 + D.25185;
              D.25187 = *D.25186;
              D.25188 = (unsigned int) D.25187;
              if (D.25188 <= 7) goto <D.25189>; else goto <D.25182>;
              <D.25189>:
              D.24342 = rs->vassign;
              D.25156 = prev_sregs[0];
              D.25184 = (unsigned int) D.25156;
              D.25185 = D.25184 * 4;
              D.25186 = D.24342 + D.25185;
              D.25187 = *D.25186;
              D.25190 = 232 >> D.25187;
              D.25191 = D.25190 & 1;
              if (D.25191 != 0) goto <D.25192>; else goto <D.25182>;
              <D.25192>:
              iftmp.90 = 1;
              goto <D.25183>;
              <D.25182>:
              iftmp.90 = 0;
              <D.25183>:
              D.25193 = iftmp.90 != 0;
              D.25194 = (long int) D.25193;
              D.25195 = __builtin_expect (D.25194, 0);
              if (D.25195 != 0) goto <D.25196>; else goto <D.25197>;
              <D.25196>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 2002, "!is_global_ireg (rs->vassign [prev_sregs [0]])");
              <D.25197>:
              if (spec_src1 == 108) goto <D.25199>; else goto <D.25200>;
              <D.25199>:
              if (spec_src1 == 108) goto <D.25202>; else goto <D.25203>;
              <D.25202>:
              iftmp.92 = 4;
              goto <D.25204>;
              <D.25203>:
              iftmp.92 = 0;
              <D.25204>:
              iftmp.91 = iftmp.92;
              goto <D.25205>;
              <D.25200>:
              iftmp.91 = 7;
              <D.25205>:
              mask = iftmp.91;
              D.24342 = rs->vassign;
              reg2.93 = (unsigned int) reg2;
              D.25207 = reg2.93 * 4;
              D.25208 = D.24342 + D.25207;
              val = *D.25208;
              if (val < 0) goto <D.25209>; else goto <D.25210>;
              <D.25209>:
              {
                int spill;

                spill = 0;
                if (val < -1) goto <D.25211>; else goto <D.25212>;
                <D.25211>:
                spill = ~val;
                <D.25212>:
                val = mono_regstate_alloc_int (rs, mask);
                if (val < 0) goto <D.25213>; else goto <D.25214>;
                <D.25213>:
                val = get_register_spilling (cfg, bb, tmp, ins, mask, reg2, bank);
                <D.25214>:
                if (spill != 0) goto <D.25215>; else goto <D.25216>;
                <D.25215>:
                monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-codegen.c", 2015);
                <D.25216>:
              }
              goto <D.25217>;
              <D.25210>:
              D.24750 = 1 << val;
              D.24751 = D.24750 & mask;
              if (D.24751 == 0) goto <D.25218>; else goto <D.25219>;
              <D.25218>:
              monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-codegen.c", 2021);
              <D.25219>:
              <D.25217>:
              sreg1_high = val;
              D.24223 = cfg->verbose_level;
              D.24278 = D.24223 > 2;
              D.24279 = (long int) D.24278;
              D.24280 = __builtin_expect (D.24279, 0);
              if (D.24280 != 0) goto <D.25220>; else goto <D.25221>;
              <D.25220>:
              D.25222 = mono_arch_regname (val);
              printf ("\tassigned sreg1 hreg %s to dest R%d\n", D.25222, reg2);
              <D.25221>:
              assign_reg (cfg, rs, reg2, val, bank);
            }
            <D.25173>:
            <D.25171>:
            D.24174 = *spec;
            if (D.24174 == 102) goto <D.25226>; else goto <D.25223>;
            <D.25226>:
            D.24181 = spec + 1;
            D.24182 = *D.24181;
            if (D.24182 == 102) goto <D.25224>; else goto <D.25223>;
            <D.25223>:
            D.24426 = spec + 5;
            D.24427 = *D.24426;
            if (D.24427 == 49) goto <D.25224>; else goto <D.25225>;
            <D.25224>:
            D.24231 = ins->dreg;
            D.25088 = sregs[0];
            if (D.24231 != D.25088) goto <D.25227>; else goto <D.25228>;
            <D.25227>:
            {
              struct MonoInst * sreg2_copy;
              struct MonoInst * copy;
              int bank;

              sreg2_copy = 0B;
              D.25230 = spec_src1 == 102;
              D.25231 = (long int) D.25230;
              D.25232 = __builtin_expect (D.25231, 0);
              if (D.25232 == 0) goto <D.25233>; else goto <D.25234>;
              <D.25233>:
              D.25236 = spec_src1 == 120;
              D.25237 = (long int) D.25236;
              D.25238 = __builtin_expect (D.25237, 0);
              if (D.25238 != 0) goto <D.25239>; else goto <D.25240>;
              <D.25239>:
              iftmp.95 = 4;
              goto <D.25241>;
              <D.25240>:
              iftmp.95 = 0;
              <D.25241>:
              iftmp.94 = iftmp.95;
              goto <D.25242>;
              <D.25234>:
              iftmp.94 = 1;
              <D.25242>:
              bank = iftmp.94;
              D.24231 = ins->dreg;
              D.25243 = sregs[1];
              if (D.24231 == D.25243) goto <D.25244>; else goto <D.25245>;
              <D.25244>:
              {
                int reg2;

                D.25243 = sregs[1];
                reg2 = alloc_reg (cfg, bb, tmp, ins, dreg_mask, D.25243, 0B, bank);
                D.24223 = cfg->verbose_level;
                D.24278 = D.24223 > 2;
                D.24279 = (long int) D.24278;
                D.24280 = __builtin_expect (D.24279, 0);
                if (D.24280 != 0) goto <D.25246>; else goto <D.25247>;
                <D.25246>:
                D.25248 = mono_regname_full (reg2, bank);
                D.25243 = sregs[1];
                D.25249 = mono_regname_full (D.25243, bank);
                printf ("\tneed to copy sreg2 %s to reg %s\n", D.25249, D.25248);
                <D.25247>:
                D.25243 = sregs[1];
                sreg2_copy = create_copy_ins (cfg, bb, tmp, reg2, D.25243, 0B, ip, bank);
                sregs[1] = reg2;
                D.25243 = sregs[1];
                prev_sregs[1] = D.25243;
                D.25250 = bank != 0;
                D.25251 = (long int) D.25250;
                D.25252 = __builtin_expect (D.25251, 0);
                if (D.25252 != 0) goto <D.25253>; else goto <D.25254>;
                <D.25253>:
                mono_regstate_free_general (rs, reg2, bank);
                goto <D.25255>;
                <D.25254>:
                mono_regstate_free_int (rs, reg2);
                <D.25255>:
              }
              <D.25245>:
              D.25167 = spec_src1 == 108;
              D.25168 = spec_src1 == 76;
              D.25169 = D.25167 | D.25168;
              if (D.25169 != 0) goto <D.25256>; else goto <D.25257>;
              <D.25256>:
              D.24342 = rs->vassign;
              D.25156 = prev_sregs[0];
              D.25258 = (sizetype) D.25156;
              D.25259 = D.25258 + 1;
              D.25260 = D.25259 * 4;
              D.25261 = D.24342 + D.25260;
              D.25262 = *D.25261;
              D.25243 = sregs[1];
              if (D.25262 == D.25243) goto <D.25263>; else goto <D.25264>;
              <D.25263>:
              monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-codegen.c", 2067);
              <D.25264>:
              D.25088 = sregs[0];
              D.24231 = ins->dreg;
              D.25265 = D.25088 != D.24231;
              D.25266 = (long int) D.25265;
              D.25267 = __builtin_expect (D.25266, 0);
              if (D.25267 != 0) goto <D.25268>; else goto <D.25269>;
              <D.25268>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 2073, "sregs [0] == ins->dreg");
              <D.25269>:
              D.25270 = dreg_high != sreg1_high;
              D.25271 = (long int) D.25270;
              D.25272 = __builtin_expect (D.25271, 0);
              if (D.25272 != 0) goto <D.25273>; else goto <D.25274>;
              <D.25273>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 2074, "dreg_high == sreg1_high");
              <D.25274>:
              <D.25257>:
              D.24223 = cfg->verbose_level;
              D.24278 = D.24223 > 2;
              D.24279 = (long int) D.24278;
              D.24280 = __builtin_expect (D.24279, 0);
              if (D.24280 != 0) goto <D.25275>; else goto <D.25276>;
              <D.25275>:
              D.24231 = ins->dreg;
              D.25277 = mono_regname_full (D.24231, bank);
              D.25088 = sregs[0];
              D.25278 = mono_regname_full (D.25088, bank);
              printf ("\tneed to copy sreg1 %s to dreg %s\n", D.25278, D.25277);
              <D.25276>:
              D.25088 = sregs[0];
              D.24231 = ins->dreg;
              copy = create_copy_ins (cfg, bb, tmp, D.24231, D.25088, 0B, ip, bank);
              insert_before_ins (bb, ins, copy);
              if (sreg2_copy != 0B) goto <D.25279>; else goto <D.25280>;
              <D.25279>:
              insert_before_ins (bb, copy, sreg2_copy);
              <D.25280>:
              D.24484 = sreg_masks[1];
              D.25088 = sregs[0];
              D.25164 = 1 << D.25088;
              D.25165 = ~D.25164;
              D.25281 = D.24484 & D.25165;
              sreg_masks[1] = D.25281;
              D.24231 = ins->dreg;
              sregs[0] = D.24231;
              D.25088 = sregs[0];
              prev_sregs[0] = D.25088;
              D.24484 = sreg_masks[1];
              D.24231 = ins->dreg;
              D.24866 = 1 << D.24231;
              D.24867 = ~D.24866;
              D.25282 = D.24484 & D.24867;
              sreg_masks[1] = D.25282;
            }
            <D.25228>:
            <D.25225>:
            mono_inst_set_src_registers (ins, &sregs);
            j = 1;
            goto <D.23566>;
            <D.23565>:
            {
              int k;

              D.24264 = j + 1;
              D.24265 = (sizetype) D.24264;
              D.24266 = spec + D.24265;
              D.24267 = *D.24266;
              D.24300 = D.24267 == 102;
              D.24301 = (long int) D.24300;
              D.24302 = __builtin_expect (D.24301, 0);
              if (D.24302 == 0) goto <D.25284>; else goto <D.25285>;
              <D.25284>:
              D.24264 = j + 1;
              D.24265 = (sizetype) D.24264;
              D.24266 = spec + D.24265;
              D.24267 = *D.24266;
              D.24306 = D.24267 == 120;
              D.24307 = (long int) D.24306;
              D.24308 = __builtin_expect (D.24307, 0);
              if (D.24308 != 0) goto <D.25287>; else goto <D.25288>;
              <D.25287>:
              iftmp.97 = 4;
              goto <D.25289>;
              <D.25288>:
              iftmp.97 = 0;
              <D.25289>:
              iftmp.96 = iftmp.97;
              goto <D.25290>;
              <D.25285>:
              iftmp.96 = 1;
              <D.25290>:
              bank = iftmp.96;
              D.24264 = j + 1;
              D.24265 = (sizetype) D.24264;
              D.24266 = spec + D.24265;
              D.24267 = *D.24266;
              D.24268 = D.24267 == 108;
              D.24264 = j + 1;
              D.24265 = (sizetype) D.24264;
              D.24266 = spec + D.24265;
              D.24267 = *D.24266;
              D.24269 = D.24267 == 76;
              D.24270 = D.24268 | D.24269;
              if (D.24270 != 0) goto <D.25291>; else goto <D.25292>;
              <D.25291>:
              monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-codegen.c", 2103);
              <D.25292>:
              D.24614 = dest_sregs[j];
              if (D.24614 != -1) goto <D.25295>; else goto <D.25293>;
              <D.25295>:
              D.24253 = sregs[j];
              D.25296 = (unsigned int) D.24253;
              if (D.25296 <= 7) goto <D.25297>; else goto <D.25293>;
              <D.25297>:
              D.24253 = sregs[j];
              D.25298 = 232 >> D.24253;
              D.25299 = D.25298 & 1;
              if (D.25299 != 0) goto <D.25300>; else goto <D.25293>;
              <D.25300>:
              {
                struct MonoInst * copy;

                D.24253 = sregs[j];
                D.24614 = dest_sregs[j];
                copy = create_copy_ins (cfg, bb, tmp, D.24614, D.24253, 0B, ip, 0);
                insert_before_ins (bb, ins, copy);
                D.24614 = dest_sregs[j];
                sregs[j] = D.24614;
              }
              goto <D.25294>;
              <D.25293>:
              D.24319 = bank != 0;
              D.24320 = (long int) D.24319;
              D.24321 = __builtin_expect (D.24320, 0);
              if (D.24321 != 0) goto <D.25302>; else goto <D.25303>;
              <D.25302>:
              D.24253 = sregs[j];
              if (D.24253 < 0) goto <D.25305>; else goto <D.25308>;
              <D.25308>:
              D.24253 = sregs[j];
              D.24329 = regbank_size[bank];
              if (D.24253 >= D.24329) goto <D.25305>; else goto <D.25306>;
              <D.25305>:
              iftmp.99 = 1;
              goto <D.25307>;
              <D.25306>:
              iftmp.99 = 0;
              <D.25307>:
              iftmp.98 = (_Bool) iftmp.99;
              goto <D.25309>;
              <D.25303>:
              D.24253 = sregs[j];
              iftmp.98 = D.24253 > 7;
              <D.25309>:
              if (iftmp.98 != 0) goto <D.25310>; else goto <D.25311>;
              <D.25310>:
              D.24342 = rs->vassign;
              D.24253 = sregs[j];
              D.24261 = (unsigned int) D.24253;
              D.25312 = D.24261 * 4;
              D.25313 = D.24342 + D.25312;
              val = *D.25313;
              D.24614 = dest_sregs[j];
              if (D.24614 != -1) goto <D.25314>; else goto <D.25315>;
              <D.25314>:
              if (val >= 0) goto <D.25316>; else goto <D.25317>;
              <D.25316>:
              D.24614 = dest_sregs[j];
              if (D.24614 != val) goto <D.25318>; else goto <D.25319>;
              <D.25318>:
              D.24253 = sregs[j];
              spill_vreg (cfg, bb, tmp, ins, D.24253, 0);
              D.24342 = rs->vassign;
              D.24253 = sregs[j];
              D.24261 = (unsigned int) D.24253;
              D.25312 = D.24261 * 4;
              D.25313 = D.24342 + D.25312;
              val = *D.25313;
              <D.25319>:
              <D.25317>:
              <D.25315>:
              if (val < 0) goto <D.25320>; else goto <D.25321>;
              <D.25320>:
              {
                int spill;

                spill = 0;
                if (val < -1) goto <D.25322>; else goto <D.25323>;
                <D.25322>:
                spill = ~val;
                <D.25323>:
                D.24253 = sregs[j];
                D.24261 = (unsigned int) D.24253;
                D.24262 = D.24261 * 12;
                D.25324 = reginfo + D.24262;
                D.24253 = sregs[j];
                D.24865 = sreg_masks[j];
                val = alloc_reg (cfg, bb, tmp, ins, D.24865, D.24253, D.25324, bank);
                D.24253 = sregs[j];
                assign_reg (cfg, rs, D.24253, val, bank);
                D.24223 = cfg->verbose_level;
                D.24278 = D.24223 > 2;
                D.24279 = (long int) D.24278;
                D.24280 = __builtin_expect (D.24279, 0);
                if (D.24280 != 0) goto <D.25325>; else goto <D.25326>;
                <D.25325>:
                D.24253 = sregs[j];
                D.25327 = mono_regname_full (val, bank);
                D.24264 = j + 1;
                printf ("\tassigned sreg%d %s to R%d\n", D.24264, D.25327, D.24253);
                <D.25326>:
                if (spill != 0) goto <D.25328>; else goto <D.25329>;
                <D.25328>:
                D.24253 = sregs[j];
                create_spilled_store (cfg, bb, spill, val, D.24253, tmp, 0B, ins, bank);
                <D.25329>:
              }
              <D.25321>:
              sregs[j] = val;
              k = j + 1;
              goto <D.23563>;
              <D.23562>:
              D.25330 = sreg_masks[k];
              D.24253 = sregs[j];
              D.25331 = 1 << D.24253;
              D.25332 = ~D.25331;
              D.25333 = D.25330 & D.25332;
              sreg_masks[k] = D.25333;
              k = k + 1;
              <D.23563>:
              if (k < num_sregs) goto <D.23562>; else goto <D.23564>;
              <D.23564>:
              goto <D.25334>;
              <D.25311>:
              prev_sregs[j] = -1;
              <D.25334>:
              <D.25294>:
            }
            j = j + 1;
            <D.23566>:
            if (j < num_sregs) goto <D.23565>; else goto <D.23567>;
            <D.23567>:
            mono_inst_set_src_registers (ins, &sregs);
            j = 1;
            goto <D.23575>;
            <D.23574>:
            {
              int sreg;
              int dest_sreg;

              sreg = sregs[j];
              dest_sreg = dest_sregs[j];
              D.25335 = j == 2;
              D.25336 = dest_sreg != -1;
              D.25337 = D.25335 & D.25336;
              if (D.25337 != 0) goto <D.25338>; else goto <D.25339>;
              <D.25338>:
              {
                int k;

                D.25340 = sreg != dest_sreg;
                D.25341 = (long int) D.25340;
                D.25342 = __builtin_expect (D.25341, 0);
                if (D.25342 != 0) goto <D.25343>; else goto <D.25344>;
                <D.25343>:
                monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 2163, "sreg == dest_sreg");
                <D.25344>:
                k = 0;
                goto <D.23572>;
                <D.23571>:
                if (k != j) goto <D.25345>; else goto <D.25346>;
                <D.25345>:
                D.25347 = sregs[k];
                D.25348 = D.25347 == dest_sreg;
                D.25349 = (long int) D.25348;
                D.25350 = __builtin_expect (D.25349, 0);
                if (D.25350 != 0) goto <D.25351>; else goto <D.25352>;
                <D.25351>:
                monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 2167, "sregs [k] != dest_sreg");
                <D.25352>:
                <D.25346>:
                k = k + 1;
                <D.23572>:
                if (k < num_sregs) goto <D.23571>; else goto <D.23573>;
                <D.23573>:
              }
              <D.25339>:
            }
            j = j + 1;
            <D.23575>:
            if (j < num_sregs) goto <D.23574>; else goto <D.23576>;
            <D.23576>:
            D.24223 = cfg->verbose_level;
            D.24278 = D.24223 > 2;
            D.24279 = (long int) D.24278;
            D.24280 = __builtin_expect (D.24279, 0);
            if (D.24280 != 0) goto <D.25353>; else goto <D.25354>;
            <D.25353>:
            mono_print_ins_index (i, ins);
            <D.25354>:
          }
        finally
          {
            dest_sregs = {CLOBBER};
            prev_sregs = {CLOBBER};
            sreg_masks = {CLOBBER};
            sreg_fixed_masks = {CLOBBER};
          }
      }
      ins = prev;
      if (ins != 0B) goto <D.25356>; else goto <D.25357>;
      <D.25356>:
      iftmp.100 = ins->prev;
      goto <D.25358>;
      <D.25357>:
      iftmp.100 = 0B;
      <D.25358>:
      prev = iftmp.100;
      <D.23578>:
      if (ins != 0B) goto <D.23577>; else goto <D.23579>;
      <D.23579>:
      if (has_fp != 0) goto <D.25359>; else goto <D.25360>;
      <D.25359>:
      {
        struct MonoInst * prev;
        struct MonoInst * fxch;
        int tmp;

        prev = 0B;
        D.25361 = num_sregs > 2;
        D.25362 = (long int) D.25361;
        D.25363 = __builtin_expect (D.25362, 0);
        if (D.25363 != 0) goto <D.25364>; else goto <D.25365>;
        <D.25364>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 2196, "num_sregs <= 2");
        <D.25365>:
        ins = bb->code;
        goto <D.23600>;
        <D.23599>:
        D.24226 = ins->opcode;
        D.24227 = (int) D.24226;
        D.24228 = D.24227 + -313;
        D.24229 = x86_desc_idx[D.24228];
        D.24230 = (sizetype) D.24229;
        spec = &x86_desc + D.24230;
        D.24223 = cfg->verbose_level;
        D.24278 = D.24223 > 2;
        D.24279 = (long int) D.24278;
        D.24280 = __builtin_expect (D.24279, 0);
        if (D.24280 != 0) goto <D.25366>; else goto <D.25367>;
        <D.25366>:
        printf ("processing:");
        <D.25367>:
        D.24223 = cfg->verbose_level;
        D.24278 = D.24223 > 2;
        D.24279 = (long int) D.24278;
        D.24280 = __builtin_expect (D.24279, 0);
        if (D.24280 != 0) goto <D.25368>; else goto <D.25369>;
        <D.25368>:
        mono_print_ins_index (0, ins);
        <D.25369>:
        D.24226 = ins->opcode;
        if (D.24226 == 430) goto <D.25370>; else goto <D.25371>;
        <D.25370>:
        i = 0;
        goto <D.23584>;
        <D.23583>:
        D.25372 = fpstack[i];
        D.24249 = ins->sreg1;
        if (D.25372 == D.24249) goto <D.25373>; else goto <D.25374>;
        <D.25373>:
        D.24231 = ins->dreg;
        fpstack[i] = D.24231;
        <D.25374>:
        i = i + 1;
        <D.23584>:
        if (i < sp) goto <D.23583>; else goto <D.23585>;
        <D.23585>:
        prev = ins;
        // predicted unlikely by continue predictor.
        goto <D.23586>;
        <D.25371>:
        D.24181 = spec + 1;
        D.24182 = *D.24181;
        if (D.24182 == 102) goto <D.25375>; else goto <D.25376>;
        <D.25375>:
        D.24190 = spec + 2;
        D.24191 = *D.24190;
        if (D.24191 == 102) goto <D.25377>; else goto <D.25378>;
        <D.25377>:
        D.25379 = sp + -2;
        D.25380 = fpstack[D.25379];
        D.24249 = ins->sreg1;
        if (D.25380 != D.24249) goto <D.25381>; else goto <D.25382>;
        <D.25381>:
        D.25383 = prev == 0B;
        D.25384 = (long int) D.25383;
        D.25385 = __builtin_expect (D.25384, 0);
        if (D.25385 != 0) goto <D.25386>; else goto <D.25387>;
        <D.25386>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 2216, "prev");
        <D.25387>:
        i = 0;
        goto <D.23588>;
        <D.23587>:
        i = i + 1;
        <D.23588>:
        if (i < sp) goto <D.25388>; else goto <D.23589>;
        <D.25388>:
        D.25372 = fpstack[i];
        D.24249 = ins->sreg1;
        if (D.25372 != D.24249) goto <D.23587>; else goto <D.23589>;
        <D.23589>:
        D.25389 = i >= sp;
        D.25390 = (long int) D.25389;
        D.25391 = __builtin_expect (D.25390, 0);
        if (D.25391 != 0) goto <D.25392>; else goto <D.25393>;
        <D.25392>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 2221, "i < sp");
        <D.25393>:
        D.25394 = sp + -1;
        D.25395 = D.25394 - i;
        if (D.25395 > 0) goto <D.25396>; else goto <D.25397>;
        <D.25396>:
        D.24223 = cfg->verbose_level;
        D.24278 = D.24223 > 2;
        D.24279 = (long int) D.24278;
        D.24280 = __builtin_expect (D.24279, 0);
        if (D.24280 != 0) goto <D.25398>; else goto <D.25399>;
        <D.25398>:
        D.25394 = sp + -1;
        D.25395 = D.25394 - i;
        printf ("\tswap %%st(0) and %%st(%d)\n", D.25395);
        <D.25399>:
        D.24214 = cfg->mempool;
        fxch = mono_mempool_alloc0 (D.24214, 48);
        fxch->opcode = 1045;
        fxch->dreg = -1;
        fxch->sreg3 = -1;
        D.25400 = fxch->sreg3;
        fxch->sreg2 = D.25400;
        D.25401 = fxch->sreg2;
        fxch->sreg1 = D.25401;
        D.25402 = cfg->ip;
        fxch->cil_code = D.25402;
        D.25394 = sp + -1;
        D.25395 = D.25394 - i;
        fxch->data.op[1].const_val = D.25395;
        mono_bblock_insert_after_ins (bb, prev, fxch);
        prev = fxch;
        D.25394 = sp + -1;
        tmp = fpstack[D.25394];
        D.25394 = sp + -1;
        D.25372 = fpstack[i];
        fpstack[D.25394] = D.25372;
        fpstack[i] = tmp;
        <D.25397>:
        D.24223 = cfg->verbose_level;
        D.24278 = D.24223 > 2;
        D.24279 = (long int) D.24278;
        D.24280 = __builtin_expect (D.24279, 0);
        if (D.24280 != 0) goto <D.25403>; else goto <D.25404>;
        <D.25403>:
        printf ("\tswap %%st(0) and %%st(1)\n");
        <D.25404>:
        D.24214 = cfg->mempool;
        fxch = mono_mempool_alloc0 (D.24214, 48);
        fxch->opcode = 1045;
        fxch->dreg = -1;
        fxch->sreg3 = -1;
        D.25400 = fxch->sreg3;
        fxch->sreg2 = D.25400;
        D.25401 = fxch->sreg2;
        fxch->sreg1 = D.25401;
        D.25402 = cfg->ip;
        fxch->cil_code = D.25402;
        fxch->data.op[1].const_val = 1;
        mono_bblock_insert_after_ins (bb, prev, fxch);
        prev = fxch;
        D.25394 = sp + -1;
        tmp = fpstack[D.25394];
        D.25394 = sp + -1;
        D.25379 = sp + -2;
        D.25380 = fpstack[D.25379];
        fpstack[D.25394] = D.25380;
        D.25379 = sp + -2;
        fpstack[D.25379] = tmp;
        <D.25382>:
        <D.25378>:
        <D.25376>:
        D.24190 = spec + 2;
        D.24191 = *D.24190;
        if (D.24191 == 102) goto <D.25405>; else goto <D.25406>;
        <D.25405>:
        D.25407 = sp <= 0;
        D.25408 = (long int) D.25407;
        D.25409 = __builtin_expect (D.25408, 0);
        if (D.25409 != 0) goto <D.25410>; else goto <D.25411>;
        <D.25410>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 2253, "sp > 0");
        <D.25411>:
        D.25394 = sp + -1;
        D.25412 = fpstack[D.25394];
        D.24250 = ins->sreg2;
        if (D.25412 != D.24250) goto <D.25413>; else goto <D.25414>;
        <D.25413>:
        D.25383 = prev == 0B;
        D.25384 = (long int) D.25383;
        D.25385 = __builtin_expect (D.25384, 0);
        if (D.25385 != 0) goto <D.25415>; else goto <D.25416>;
        <D.25415>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 2256, "prev");
        <D.25416>:
        i = 0;
        goto <D.23591>;
        <D.23590>:
        i = i + 1;
        <D.23591>:
        if (i < sp) goto <D.25417>; else goto <D.23592>;
        <D.25417>:
        D.25372 = fpstack[i];
        D.24250 = ins->sreg2;
        if (D.25372 != D.24250) goto <D.23590>; else goto <D.23592>;
        <D.23592>:
        D.25389 = i >= sp;
        D.25390 = (long int) D.25389;
        D.25391 = __builtin_expect (D.25390, 0);
        if (D.25391 != 0) goto <D.25418>; else goto <D.25419>;
        <D.25418>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 2261, "i < sp");
        <D.25419>:
        D.24223 = cfg->verbose_level;
        D.24278 = D.24223 > 2;
        D.24279 = (long int) D.24278;
        D.24280 = __builtin_expect (D.24279, 0);
        if (D.24280 != 0) goto <D.25420>; else goto <D.25421>;
        <D.25420>:
        D.25394 = sp + -1;
        D.25395 = D.25394 - i;
        printf ("\tswap %%st(0) and %%st(%d)\n", D.25395);
        <D.25421>:
        D.24214 = cfg->mempool;
        fxch = mono_mempool_alloc0 (D.24214, 48);
        fxch->opcode = 1045;
        fxch->dreg = -1;
        fxch->sreg3 = -1;
        D.25400 = fxch->sreg3;
        fxch->sreg2 = D.25400;
        D.25401 = fxch->sreg2;
        fxch->sreg1 = D.25401;
        D.25402 = cfg->ip;
        fxch->cil_code = D.25402;
        D.25394 = sp + -1;
        D.25395 = D.25394 - i;
        fxch->data.op[1].const_val = D.25395;
        mono_bblock_insert_after_ins (bb, prev, fxch);
        prev = fxch;
        D.25394 = sp + -1;
        tmp = fpstack[D.25394];
        D.25394 = sp + -1;
        D.25372 = fpstack[i];
        fpstack[D.25394] = D.25372;
        fpstack[i] = tmp;
        <D.25414>:
        sp = sp + -1;
        <D.25406>:
        D.24181 = spec + 1;
        D.24182 = *D.24181;
        if (D.24182 == 102) goto <D.25422>; else goto <D.25423>;
        <D.25422>:
        D.25407 = sp <= 0;
        D.25408 = (long int) D.25407;
        D.25409 = __builtin_expect (D.25408, 0);
        if (D.25409 != 0) goto <D.25424>; else goto <D.25425>;
        <D.25424>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 2280, "sp > 0");
        <D.25425>:
        D.25394 = sp + -1;
        D.25412 = fpstack[D.25394];
        D.24249 = ins->sreg1;
        if (D.25412 != D.24249) goto <D.25426>; else goto <D.25427>;
        <D.25426>:
        D.25383 = prev == 0B;
        D.25384 = (long int) D.25383;
        D.25385 = __builtin_expect (D.25384, 0);
        if (D.25385 != 0) goto <D.25428>; else goto <D.25429>;
        <D.25428>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 2283, "prev");
        <D.25429>:
        i = 0;
        goto <D.23594>;
        <D.23593>:
        i = i + 1;
        <D.23594>:
        if (i < sp) goto <D.25430>; else goto <D.23595>;
        <D.25430>:
        D.25372 = fpstack[i];
        D.24249 = ins->sreg1;
        if (D.25372 != D.24249) goto <D.23593>; else goto <D.23595>;
        <D.23595>:
        D.25389 = i >= sp;
        D.25390 = (long int) D.25389;
        D.25391 = __builtin_expect (D.25390, 0);
        if (D.25391 != 0) goto <D.25431>; else goto <D.25432>;
        <D.25431>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 2288, "i < sp");
        <D.25432>:
        D.24223 = cfg->verbose_level;
        D.24278 = D.24223 > 2;
        D.24279 = (long int) D.24278;
        D.24280 = __builtin_expect (D.24279, 0);
        if (D.24280 != 0) goto <D.25433>; else goto <D.25434>;
        <D.25433>:
        D.25394 = sp + -1;
        D.25395 = D.25394 - i;
        printf ("\tswap %%st(0) and %%st(%d)\n", D.25395);
        <D.25434>:
        D.24214 = cfg->mempool;
        fxch = mono_mempool_alloc0 (D.24214, 48);
        fxch->opcode = 1045;
        fxch->dreg = -1;
        fxch->sreg3 = -1;
        D.25400 = fxch->sreg3;
        fxch->sreg2 = D.25400;
        D.25401 = fxch->sreg2;
        fxch->sreg1 = D.25401;
        D.25402 = cfg->ip;
        fxch->cil_code = D.25402;
        D.25394 = sp + -1;
        D.25395 = D.25394 - i;
        fxch->data.op[1].const_val = D.25395;
        mono_bblock_insert_after_ins (bb, prev, fxch);
        prev = fxch;
        D.25394 = sp + -1;
        tmp = fpstack[D.25394];
        D.25394 = sp + -1;
        D.25372 = fpstack[i];
        fpstack[D.25394] = D.25372;
        fpstack[i] = tmp;
        <D.25427>:
        sp = sp + -1;
        <D.25423>:
        D.24174 = *spec;
        if (D.24174 == 102) goto <D.25435>; else goto <D.25436>;
        <D.25435>:
        D.25437 = sp > 7;
        D.25438 = (long int) D.25437;
        D.25439 = __builtin_expect (D.25438, 0);
        if (D.25439 != 0) goto <D.25440>; else goto <D.25441>;
        <D.25440>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 2307, "sp < 8");
        <D.25441>:
        sp.101 = sp;
        sp = sp.101 + 1;
        D.24231 = ins->dreg;
        fpstack[sp.101] = D.24231;
        <D.25436>:
        D.24223 = cfg->verbose_level;
        D.25443 = D.24223 > 1;
        D.25444 = (long int) D.25443;
        D.25445 = __builtin_expect (D.25444, 0);
        if (D.25445 != 0) goto <D.25446>; else goto <D.25447>;
        <D.25446>:
        printf ("\t[");
        i = 0;
        goto <D.23597>;
        <D.23596>:
        D.25372 = fpstack[i];
        if (i > 0) goto <D.25449>; else goto <D.25450>;
        <D.25449>:
        iftmp.102 = ", ";
        goto <D.25451>;
        <D.25450>:
        iftmp.102 = "";
        <D.25451>:
        printf ("%s%%fr%d", iftmp.102, D.25372);
        i = i + 1;
        <D.23597>:
        if (i < sp) goto <D.23596>; else goto <D.23598>;
        <D.23598>:
        printf ("]\n");
        <D.25447>:
        prev = ins;
        <D.23586>:
        ins = ins->next;
        <D.23600>:
        if (ins != 0B) goto <D.23599>; else goto <D.23601>;
        <D.23601>:
        if (sp != 0) goto <D.25453>; else goto <D.25454>;
        <D.25453>:
        D.25455 = cfg->bb_exit;
        if (D.25455 != bb) goto <D.25456>; else goto <D.25457>;
        <D.25456>:
        D.25458 = bb->out_count;
        if (D.25458 != 1) goto <D.25452>; else goto <D.25459>;
        <D.25459>:
        D.25460 = bb->out_bb;
        D.25461 = *D.25460;
        D.25455 = cfg->bb_exit;
        if (D.25461 != D.25455) goto <D.25452>; else goto <D.23604>;
        <D.25452>:
        goto <D.23603>;
        <D.23602>:
        D.24214 = cfg->mempool;
        ins = mono_mempool_alloc0 (D.24214, 48);
        ins->opcode = 1040;
        ins->dreg = -1;
        ins->sreg3 = -1;
        D.24251 = ins->sreg3;
        ins->sreg2 = D.24251;
        D.24250 = ins->sreg2;
        ins->sreg1 = D.24250;
        D.25402 = cfg->ip;
        ins->cil_code = D.25402;
        mono_add_ins_to_end (bb, ins);
        sp = sp + -1;
        <D.23603>:
        if (sp != 0) goto <D.23602>; else goto <D.23604>;
        <D.23604>:
        <D.25457>:
        <D.25454>:
      }
      <D.25360>:
    }
  finally
    {
      last = {CLOBBER};
      fpstack = {CLOBBER};
      sregs = {CLOBBER};
    }
}


mono_regstate_assign (struct MonoRegState * rs)
{
  int D.25465;
  int D.25466;
  gint32 * D.25469;
  int D.25470;
  unsigned int D.25471;
  unsigned int D.25472;
  void * D.25473;
  int[8] * D.25474;
  int[8] * D.25475;
  int[8] * D.25476;

  D.25465 = rs->next_vreg;
  D.25466 = rs->vassign_size;
  if (D.25465 > D.25466) goto <D.25467>; else goto <D.25468>;
  <D.25467>:
  D.25469 = rs->vassign;
  monoeg_g_free (D.25469);
  D.25465 = rs->next_vreg;
  D.25470 = MAX_EXPR <D.25465, 256>;
  rs->vassign_size = D.25470;
  D.25466 = rs->vassign_size;
  D.25471 = (unsigned int) D.25466;
  D.25472 = D.25471 * 4;
  D.25473 = monoeg_malloc (D.25472);
  rs->vassign = D.25473;
  <D.25468>:
  D.25474 = &rs->isymbolic;
  memset (D.25474, 0, 32);
  D.25475 = &rs->fsymbolic;
  memset (D.25475, 0, 32);
  D.25474 = &rs->isymbolic;
  rs->symbolic[0] = D.25474;
  D.25475 = &rs->fsymbolic;
  rs->symbolic[1] = D.25475;
  D.25476 = &rs->xsymbolic;
  memset (D.25476, 0, 32);
  D.25476 = &rs->xsymbolic;
  rs->symbolic[4] = D.25476;
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.25479;
  int D.25484;
  void * D.25486;
  unsigned int D.25487;

  D.25479 = __builtin_constant_p (__len);
  if (D.25479 != 0) goto <D.25480>; else goto <D.25481>;
  <D.25480>:
  if (__len == 0) goto <D.25482>; else goto <D.25483>;
  <D.25482>:
  D.25484 = __builtin_constant_p (__ch);
  if (D.25484 == 0) goto <D.25477>; else goto <D.25485>;
  <D.25485>:
  if (__ch != 0) goto <D.25477>; else goto <D.25478>;
  <D.25477>:
  __warn_memset_zero_len ();
  D.25486 = __dest;
  return D.25486;
  <D.25478>:
  <D.25483>:
  <D.25481>:
  D.25487 = __builtin_object_size (__dest, 0);
  D.25486 = __builtin___memset_chk (__dest, __ch, __len, D.25487);
  return D.25486;
}


print_regtrack (struct RegTrack * t, int num)
{
  unsigned int i.103;
  unsigned int D.25490;
  struct RegTrack * D.25491;
  int D.25492;
  int D.25498;
  int i;
  char buf[32];
  const char * r;

  try
    {
      i = 0;
      goto <D.23241>;
      <D.23240>:
      i.103 = (unsigned int) i;
      D.25490 = i.103 * 12;
      D.25491 = t + D.25490;
      D.25492 = D.25491->born_in;
      if (D.25492 == 0) goto <D.25493>; else goto <D.25494>;
      <D.25493>:
      // predicted unlikely by continue predictor.
      goto <D.23239>;
      <D.25494>:
      if (i > 7) goto <D.25495>; else goto <D.25496>;
      <D.25495>:
      monoeg_g_snprintf (&buf, 32, "R%d", i);
      r = &buf;
      goto <D.25497>;
      <D.25496>:
      r = mono_arch_regname (i);
      <D.25497>:
      i.103 = (unsigned int) i;
      D.25490 = i.103 * 12;
      D.25491 = t + D.25490;
      D.25498 = D.25491->killed_in;
      i.103 = (unsigned int) i;
      D.25490 = i.103 * 12;
      D.25491 = t + D.25490;
      D.25492 = D.25491->born_in;
      printf ("liveness: %s [%d - %d]\n", r, D.25492, D.25498);
      <D.23239>:
      i = i + 1;
      <D.23241>:
      if (i < num) goto <D.23240>; else goto <D.23242>;
      <D.23242>:
    }
  finally
    {
      buf = {CLOBBER};
    }
}


get_callee_mask (const char spec)
{
  _Bool D.25501;
  long int D.25502;
  long int D.25503;
  _Bool D.25509;
  long int D.25510;
  long int D.25511;
  regmask_t D.25514;
  int iftmp.104;
  int iftmp.105;

  D.25501 = spec == 102;
  D.25502 = (long int) D.25501;
  D.25503 = __builtin_expect (D.25502, 0);
  if (D.25503 != 0) goto <D.25504>; else goto <D.25505>;
  <D.25504>:
  if (1 != 0) goto <D.25499>; else goto <D.25506>;
  <D.25506>:
  goto <D.25507>;
  <D.25505>:
  if (0 != 0) goto <D.25499>; else goto <D.25508>;
  <D.25508>:
  <D.25507>:
  D.25509 = spec == 120;
  D.25510 = (long int) D.25509;
  D.25511 = __builtin_expect (D.25510, 0);
  if (D.25511 != 0) goto <D.25512>; else goto <D.25513>;
  <D.25512>:
  if (1 != 0) goto <D.25499>; else goto <D.25500>;
  <D.25513>:
  if (0 != 0) goto <D.25499>; else goto <D.25500>;
  <D.25499>:
  D.25501 = spec == 102;
  D.25502 = (long int) D.25501;
  D.25503 = __builtin_expect (D.25502, 0);
  if (D.25503 == 0) goto <D.25516>; else goto <D.25517>;
  <D.25516>:
  D.25509 = spec == 120;
  D.25510 = (long int) D.25509;
  D.25511 = __builtin_expect (D.25510, 0);
  if (D.25511 != 0) goto <D.25519>; else goto <D.25520>;
  <D.25519>:
  iftmp.105 = 4;
  goto <D.25521>;
  <D.25520>:
  iftmp.105 = 0;
  <D.25521>:
  iftmp.104 = iftmp.105;
  goto <D.25522>;
  <D.25517>:
  iftmp.104 = 1;
  <D.25522>:
  D.25514 = regbank_callee_regs[iftmp.104];
  return D.25514;
  <D.25500>:
  D.25514 = 7;
  return D.25514;
}


alloc_int_reg (struct MonoCompile * cfg, struct MonoBasicBlock * bb, struct MonoInst * * last, struct MonoInst * ins, regmask_t dest_mask, int sym_reg, struct RegTrack * info)
{
  unsigned int D.25526;
  unsigned int D.25529;
  struct MonoRegState * D.25530;
  unsigned int D.25533;
  _Bool D.25534;
  long int D.25535;
  long int D.25536;
  const char * D.25539;
  int D.25540;
  int val;

  if (info != 0B) goto <D.25524>; else goto <D.25525>;
  <D.25524>:
  D.25526 = info->preferred_mask;
  if (D.25526 != 0) goto <D.25527>; else goto <D.25528>;
  <D.25527>:
  D.25526 = info->preferred_mask;
  D.25529 = D.25526 & dest_mask;
  D.25530 = cfg->rs;
  val = mono_regstate_alloc_int (D.25530, D.25529);
  if (val >= 0) goto <D.25531>; else goto <D.25532>;
  <D.25531>:
  D.25533 = cfg->verbose_level;
  D.25534 = D.25533 > 2;
  D.25535 = (long int) D.25534;
  D.25536 = __builtin_expect (D.25535, 0);
  if (D.25536 != 0) goto <D.25537>; else goto <D.25538>;
  <D.25537>:
  D.25539 = mono_arch_regname (val);
  printf ("\tallocated preferred reg R%d to %s\n", sym_reg, D.25539);
  <D.25538>:
  D.25540 = val;
  return D.25540;
  <D.25532>:
  <D.25528>:
  <D.25525>:
  D.25530 = cfg->rs;
  val = mono_regstate_alloc_int (D.25530, dest_mask);
  if (val < 0) goto <D.25541>; else goto <D.25542>;
  <D.25541>:
  val = get_register_spilling (cfg, bb, last, ins, dest_mask, sym_reg, 0);
  <D.25542>:
  D.25540 = val;
  return D.25540;
}


translate_bank (struct MonoRegState * rs, int bank, int hreg)
{
  int D.25544;

  D.25544 = bank;
  return D.25544;
}


free_up_hreg (struct MonoCompile * cfg, struct MonoBasicBlock * bb, struct MonoInst * * last, struct MonoInst * ins, int hreg, int bank)
{
  _Bool D.25546;
  long int D.25547;
  long int D.25548;
  struct MonoRegState * D.25551;
  unsigned int D.25552;
  unsigned int D.25553;
  unsigned int D.25554;
  unsigned int D.25557;
  _Bool D.25558;
  long int D.25559;
  long int D.25560;
  int * D.25563;
  unsigned int hreg.106;
  unsigned int D.25565;
  int * D.25566;
  int D.25567;
  unsigned int D.25569;
  unsigned int D.25570;
  int D.25575;

  D.25546 = bank != 0;
  D.25547 = (long int) D.25546;
  D.25548 = __builtin_expect (D.25547, 0);
  if (D.25548 != 0) goto <D.25549>; else goto <D.25550>;
  <D.25549>:
  D.25551 = cfg->rs;
  D.25552 = D.25551->free_mask[bank];
  D.25553 = 1 << hreg;
  D.25554 = D.25552 & D.25553;
  if (D.25554 == 0) goto <D.25555>; else goto <D.25556>;
  <D.25555>:
  D.25551 = cfg->rs;
  bank = translate_bank (D.25551, bank, hreg);
  D.25557 = cfg->verbose_level;
  D.25558 = D.25557 > 2;
  D.25559 = (long int) D.25558;
  D.25560 = __builtin_expect (D.25559, 0);
  if (D.25560 != 0) goto <D.25561>; else goto <D.25562>;
  <D.25561>:
  D.25551 = cfg->rs;
  D.25563 = D.25551->symbolic[bank];
  hreg.106 = (unsigned int) hreg;
  D.25565 = hreg.106 * 4;
  D.25566 = D.25563 + D.25565;
  D.25567 = *D.25566;
  printf ("\tforced spill of R%d\n", D.25567);
  <D.25562>:
  D.25551 = cfg->rs;
  D.25563 = D.25551->symbolic[bank];
  hreg.106 = (unsigned int) hreg;
  D.25565 = hreg.106 * 4;
  D.25566 = D.25563 + D.25565;
  D.25567 = *D.25566;
  spill_vreg (cfg, bb, last, ins, D.25567, bank);
  <D.25556>:
  goto <D.25568>;
  <D.25550>:
  D.25551 = cfg->rs;
  D.25569 = D.25551->ifree_mask;
  D.25553 = 1 << hreg;
  D.25570 = D.25569 & D.25553;
  if (D.25570 == 0) goto <D.25571>; else goto <D.25572>;
  <D.25571>:
  D.25557 = cfg->verbose_level;
  D.25558 = D.25557 > 2;
  D.25559 = (long int) D.25558;
  D.25560 = __builtin_expect (D.25559, 0);
  if (D.25560 != 0) goto <D.25573>; else goto <D.25574>;
  <D.25573>:
  D.25551 = cfg->rs;
  D.25575 = D.25551->isymbolic[hreg];
  printf ("\tforced spill of R%d\n", D.25575);
  <D.25574>:
  D.25551 = cfg->rs;
  D.25575 = D.25551->isymbolic[hreg];
  spill_vreg (cfg, bb, last, ins, D.25575, bank);
  <D.25572>:
  <D.25568>:
}


mono_regstate_alloc_int (struct MonoRegState * rs, regmask_t allow)
{
  unsigned int D.25576;
  unsigned int D.25577;
  unsigned int D.25578;
  unsigned int D.25581;
  unsigned int D.25582;
  int D.25583;
  regmask_t mask;
  int i;

  D.25576 = rs->ifree_mask;
  mask = D.25576 & allow;
  i = 0;
  goto <D.23044>;
  <D.23043>:
  D.25577 = 1 << i;
  D.25578 = D.25577 & mask;
  if (D.25578 != 0) goto <D.25579>; else goto <D.25580>;
  <D.25579>:
  D.25576 = rs->ifree_mask;
  D.25577 = 1 << i;
  D.25581 = ~D.25577;
  D.25582 = D.25576 & D.25581;
  rs->ifree_mask = D.25582;
  D.25583 = i;
  return D.25583;
  <D.25580>:
  i = i + 1;
  <D.23044>:
  if (i <= 7) goto <D.23043>; else goto <D.23045>;
  <D.23045>:
  D.25583 = -1;
  return D.25583;
}


get_register_spilling (struct MonoCompile * cfg, struct MonoBasicBlock * bb, struct MonoInst * * last, struct MonoInst * ins, regmask_t regmask, int reg, int bank)
{
  _Bool D.25585;
  long int D.25586;
  long int D.25587;
  unsigned int D.25590;
  _Bool D.25591;
  long int D.25592;
  long int D.25593;
  int D.25596;
  int D.25597;
  int D.25598;
  int D.25599;
  long long unsigned int D.25600;
  short unsigned int D.25601;
  int D.25602;
  int D.25603;
  signed char D.25604;
  int iftmp.107;
  short unsigned int D.25608;
  sizetype D.25609;
  sizetype i.108;
  sizetype D.25611;
  sizetype D.25612;
  const char * D.25613;
  char D.25614;
  _Bool D.25615;
  long int D.25616;
  long int D.25617;
  int iftmp.109;
  _Bool D.25621;
  long int D.25622;
  long int D.25623;
  int D.25630;
  _Bool D.25633;
  long int D.25634;
  long int D.25635;
  int iftmp.110;
  int iftmp.111;
  int D.25649;
  _Bool D.25651;
  unsigned int D.25655;
  unsigned int D.25656;
  unsigned int D.25657;
  _Bool D.25659;
  int iftmp.112;
  unsigned int D.25665;
  unsigned int D.25667;
  unsigned int D.25668;
  _Bool D.25670;
  int iftmp.113;
  _Bool D.25678;
  int iftmp.114;
  _Bool D.25687;
  gint32 * D.25691;
  unsigned int D.25692;
  unsigned int D.25693;
  gint32 * D.25694;
  int D.25695;
  _Bool iftmp.115;
  int iftmp.116;
  unsigned int D.25707;
  unsigned int D.25708;
  unsigned int D.25710;
  unsigned int D.25711;
  const char * D.25714;
  int D.25715;
  int iftmp.117;
  const char * D.25717;
  char D.25718;
  _Bool D.25719;
  long int D.25720;
  long int D.25721;
  int iftmp.118;
  _Bool D.25725;
  long int D.25726;
  long int D.25727;
  _Bool iftmp.119;
  _Bool iftmp.120;
  int iftmp.121;
  int iftmp.122;
  _Bool D.25752;
  unsigned int D.25756;
  unsigned int D.25757;
  int iftmp.123;
  unsigned int D.25763;
  unsigned int D.25765;
  unsigned int D.25766;
  int iftmp.124;
  unsigned int D.25776;
  unsigned int D.25777;
  const char * D.25780;
  _Bool D.25783;
  long int D.25784;
  long int D.25785;
  unsigned int D.25790;
  unsigned int D.25791;
  struct MonoRegState * D.25794;
  int * D.25797;
  unsigned int sel.125;
  unsigned int D.25799;
  int * D.25800;
  int D.25801;
  const char * D.25802;
  int D.25803;
  int D.25804;
  unsigned int i.126;
  unsigned int D.25806;
  gint32 * D.25807;
  int D.25808;
  int D.25814;
  const char * D.25815;
  struct MonoMemPool * D.25816;
  int D.25817;
  short unsigned int D.25818;
  int D.25819;
  int D.25820;
  const unsigned char * D.25821;
  unsigned int D.25822;
  int D.25823;
  int D.25824;
  int D.25825;
  const char * D.25828;
  int D.25829;
  unsigned int D.25832;
  _Bool D.25834;
  long int D.25835;
  long int D.25836;
  int D.25839;
  struct MonoInst * load;
  int i;
  int sel;
  int spill;
  int num_sregs;
  int sregs[3];
  int * symbolic;
  struct MonoRegState * rs;

  try
    {
      rs = cfg->rs;
      symbolic = rs->symbolic[bank];
      D.25585 = bank > 4;
      D.25586 = (long int) D.25585;
      D.25587 = __builtin_expect (D.25586, 0);
      if (D.25587 != 0) goto <D.25588>; else goto <D.25589>;
      <D.25588>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 831, "bank < MONO_NUM_REGBANKS");
      <D.25589>:
      D.25590 = cfg->verbose_level;
      D.25591 = D.25590 > 2;
      D.25592 = (long int) D.25591;
      D.25593 = __builtin_expect (D.25592, 0);
      if (D.25593 != 0) goto <D.25594>; else goto <D.25595>;
      <D.25594>:
      D.25596 = ins->sreg3;
      D.25597 = ins->sreg2;
      D.25598 = ins->sreg1;
      D.25599 = ins->dreg;
      D.25600 = (long long unsigned int) regmask;
      printf ("\tstart regmask to assign R%d: 0x%08llu (R%d <- R%d R%d R%d)\n", reg, D.25600, D.25599, D.25598, D.25597, D.25596);
      <D.25595>:
      D.25598 = ins->sreg1;
      sregs[0] = D.25598;
      D.25597 = ins->sreg2;
      sregs[1] = D.25597;
      D.25596 = ins->sreg3;
      sregs[2] = D.25596;
      D.25601 = ins->opcode;
      D.25602 = (int) D.25601;
      D.25603 = D.25602 + -313;
      D.25604 = ins_sreg_counts[D.25603];
      num_sregs = (int) D.25604;
      i = 0;
      goto <D.23294>;
      <D.23293>:
      D.25601 = ins->opcode;
      D.25602 = (int) D.25601;
      D.25603 = D.25602 + -313;
      D.25608 = x86_desc_idx[D.25603];
      D.25609 = (sizetype) D.25608;
      i.108 = (sizetype) i;
      D.25611 = D.25609 + i.108;
      D.25612 = D.25611 + 1;
      D.25613 = &x86_desc + D.25612;
      D.25614 = *D.25613;
      D.25615 = D.25614 == 102;
      D.25616 = (long int) D.25615;
      D.25617 = __builtin_expect (D.25616, 0);
      if (D.25617 == 0) goto <D.25618>; else goto <D.25619>;
      <D.25618>:
      D.25601 = ins->opcode;
      D.25602 = (int) D.25601;
      D.25603 = D.25602 + -313;
      D.25608 = x86_desc_idx[D.25603];
      D.25609 = (sizetype) D.25608;
      i.108 = (sizetype) i;
      D.25611 = D.25609 + i.108;
      D.25612 = D.25611 + 1;
      D.25613 = &x86_desc + D.25612;
      D.25614 = *D.25613;
      D.25621 = D.25614 == 120;
      D.25622 = (long int) D.25621;
      D.25623 = __builtin_expect (D.25622, 0);
      if (D.25623 != 0) goto <D.25624>; else goto <D.25625>;
      <D.25624>:
      iftmp.109 = 4;
      goto <D.25626>;
      <D.25625>:
      iftmp.109 = 0;
      <D.25626>:
      iftmp.107 = iftmp.109;
      goto <D.25627>;
      <D.25619>:
      iftmp.107 = 1;
      <D.25627>:
      if (iftmp.107 == bank) goto <D.25628>; else goto <D.25629>;
      <D.25628>:
      D.25630 = sregs[i];
      if (D.25630 != reg) goto <D.25631>; else goto <D.25632>;
      <D.25631>:
      D.25633 = bank != 0;
      D.25634 = (long int) D.25633;
      D.25635 = __builtin_expect (D.25634, 0);
      if (D.25635 != 0) goto <D.25636>; else goto <D.25637>;
      <D.25636>:
      D.25633 = bank != 0;
      D.25634 = (long int) D.25633;
      D.25635 = __builtin_expect (D.25634, 0);
      if (D.25635 != 0) goto <D.25638>; else goto <D.25639>;
      <D.25638>:
      D.25633 = bank != 0;
      D.25634 = (long int) D.25633;
      D.25635 = __builtin_expect (D.25634, 0);
      if (D.25635 != 0) goto <D.25643>; else goto <D.25644>;
      <D.25643>:
      D.25630 = sregs[i];
      if (D.25630 >= 0) goto <D.25648>; else goto <D.25646>;
      <D.25648>:
      D.25630 = sregs[i];
      D.25649 = regbank_size[bank];
      if (D.25630 < D.25649) goto <D.25650>; else goto <D.25646>;
      <D.25650>:
      iftmp.111 = 1;
      goto <D.25647>;
      <D.25646>:
      iftmp.111 = 0;
      <D.25647>:
      D.25651 = (_Bool) iftmp.111;
      if (D.25651 != 0) goto <D.25652>; else goto <D.25641>;
      <D.25652>:
      goto <D.25653>;
      <D.25644>:
      D.25630 = sregs[i];
      if (D.25630 <= 7) goto <D.25654>; else goto <D.25641>;
      <D.25654>:
      <D.25653>:
      D.25655 = regbank_callee_regs[bank];
      D.25630 = sregs[i];
      D.25656 = D.25655 >> D.25630;
      D.25657 = D.25656 & 1;
      if (D.25657 != 0) goto <D.25658>; else goto <D.25641>;
      <D.25658>:
      iftmp.110 = 1;
      goto <D.25642>;
      <D.25641>:
      iftmp.110 = 0;
      <D.25642>:
      D.25659 = (_Bool) iftmp.110;
      if (D.25659 != 0) goto <D.25605>; else goto <D.25660>;
      <D.25660>:
      goto <D.25661>;
      <D.25639>:
      D.25630 = sregs[i];
      D.25665 = (unsigned int) D.25630;
      if (D.25665 <= 7) goto <D.25666>; else goto <D.25663>;
      <D.25666>:
      D.25630 = sregs[i];
      D.25667 = 7 >> D.25630;
      D.25668 = D.25667 & 1;
      if (D.25668 != 0) goto <D.25669>; else goto <D.25663>;
      <D.25669>:
      iftmp.112 = 1;
      goto <D.25664>;
      <D.25663>:
      iftmp.112 = 0;
      <D.25664>:
      D.25670 = (_Bool) iftmp.112;
      if (D.25670 != 0) goto <D.25605>; else goto <D.25671>;
      <D.25671>:
      <D.25661>:
      goto <D.25672>;
      <D.25637>:
      D.25630 = sregs[i];
      D.25665 = (unsigned int) D.25630;
      if (D.25665 <= 7) goto <D.25676>; else goto <D.25674>;
      <D.25676>:
      D.25630 = sregs[i];
      D.25667 = 7 >> D.25630;
      D.25668 = D.25667 & 1;
      if (D.25668 != 0) goto <D.25677>; else goto <D.25674>;
      <D.25677>:
      iftmp.113 = 1;
      goto <D.25675>;
      <D.25674>:
      iftmp.113 = 0;
      <D.25675>:
      D.25678 = (_Bool) iftmp.113;
      if (D.25678 != 0) goto <D.25605>; else goto <D.25679>;
      <D.25679>:
      <D.25672>:
      D.25633 = bank != 0;
      D.25634 = (long int) D.25633;
      D.25635 = __builtin_expect (D.25634, 0);
      if (D.25635 != 0) goto <D.25680>; else goto <D.25681>;
      <D.25680>:
      D.25630 = sregs[i];
      if (D.25630 < 0) goto <D.25683>; else goto <D.25686>;
      <D.25686>:
      D.25630 = sregs[i];
      D.25649 = regbank_size[bank];
      if (D.25630 >= D.25649) goto <D.25683>; else goto <D.25684>;
      <D.25683>:
      iftmp.114 = 1;
      goto <D.25685>;
      <D.25684>:
      iftmp.114 = 0;
      <D.25685>:
      D.25687 = (_Bool) iftmp.114;
      if (D.25687 != 0) goto <D.25688>; else goto <D.25606>;
      <D.25688>:
      goto <D.25689>;
      <D.25681>:
      D.25630 = sregs[i];
      if (D.25630 > 7) goto <D.25690>; else goto <D.25606>;
      <D.25690>:
      <D.25689>:
      D.25691 = rs->vassign;
      D.25630 = sregs[i];
      D.25692 = (unsigned int) D.25630;
      D.25693 = D.25692 * 4;
      D.25694 = D.25691 + D.25693;
      D.25695 = *D.25694;
      if (D.25695 >= 0) goto <D.25605>; else goto <D.25606>;
      <D.25605>:
      D.25633 = bank != 0;
      D.25634 = (long int) D.25633;
      D.25635 = __builtin_expect (D.25634, 0);
      if (D.25635 != 0) goto <D.25697>; else goto <D.25698>;
      <D.25697>:
      D.25630 = sregs[i];
      if (D.25630 < 0) goto <D.25700>; else goto <D.25703>;
      <D.25703>:
      D.25630 = sregs[i];
      D.25649 = regbank_size[bank];
      if (D.25630 >= D.25649) goto <D.25700>; else goto <D.25701>;
      <D.25700>:
      iftmp.116 = 1;
      goto <D.25702>;
      <D.25701>:
      iftmp.116 = 0;
      <D.25702>:
      iftmp.115 = (_Bool) iftmp.116;
      goto <D.25704>;
      <D.25698>:
      D.25630 = sregs[i];
      iftmp.115 = D.25630 > 7;
      <D.25704>:
      if (iftmp.115 != 0) goto <D.25705>; else goto <D.25706>;
      <D.25705>:
      D.25691 = rs->vassign;
      D.25630 = sregs[i];
      D.25692 = (unsigned int) D.25630;
      D.25693 = D.25692 * 4;
      D.25694 = D.25691 + D.25693;
      D.25695 = *D.25694;
      D.25707 = 1 << D.25695;
      D.25708 = ~D.25707;
      regmask = D.25708 & regmask;
      goto <D.25709>;
      <D.25706>:
      D.25630 = sregs[i];
      D.25710 = 1 << D.25630;
      D.25711 = ~D.25710;
      regmask = D.25711 & regmask;
      <D.25709>:
      D.25590 = cfg->verbose_level;
      D.25591 = D.25590 > 2;
      D.25592 = (long int) D.25591;
      D.25593 = __builtin_expect (D.25592, 0);
      if (D.25593 != 0) goto <D.25712>; else goto <D.25713>;
      <D.25712>:
      D.25630 = sregs[i];
      D.25630 = sregs[i];
      D.25714 = mono_regname_full (D.25630, bank);
      D.25715 = i + 1;
      printf ("\t\texcluding sreg%d %s %d\n", D.25715, D.25714, D.25630);
      <D.25713>:
      <D.25606>:
      <D.25632>:
      <D.25629>:
      i = i + 1;
      <D.23294>:
      if (i < num_sregs) goto <D.23293>; else goto <D.23295>;
      <D.23295>:
      D.25601 = ins->opcode;
      D.25602 = (int) D.25601;
      D.25603 = D.25602 + -313;
      D.25608 = x86_desc_idx[D.25603];
      D.25609 = (sizetype) D.25608;
      D.25717 = &x86_desc + D.25609;
      D.25718 = *D.25717;
      D.25719 = D.25718 == 102;
      D.25720 = (long int) D.25719;
      D.25721 = __builtin_expect (D.25720, 0);
      if (D.25721 == 0) goto <D.25722>; else goto <D.25723>;
      <D.25722>:
      D.25601 = ins->opcode;
      D.25602 = (int) D.25601;
      D.25603 = D.25602 + -313;
      D.25608 = x86_desc_idx[D.25603];
      D.25609 = (sizetype) D.25608;
      D.25717 = &x86_desc + D.25609;
      D.25718 = *D.25717;
      D.25725 = D.25718 == 120;
      D.25726 = (long int) D.25725;
      D.25727 = __builtin_expect (D.25726, 0);
      if (D.25727 != 0) goto <D.25728>; else goto <D.25729>;
      <D.25728>:
      iftmp.118 = 4;
      goto <D.25730>;
      <D.25729>:
      iftmp.118 = 0;
      <D.25730>:
      iftmp.117 = iftmp.118;
      goto <D.25731>;
      <D.25723>:
      iftmp.117 = 1;
      <D.25731>:
      if (iftmp.117 == bank) goto <D.25732>; else goto <D.25733>;
      <D.25732>:
      D.25599 = ins->dreg;
      if (D.25599 != reg) goto <D.25734>; else goto <D.25735>;
      <D.25734>:
      D.25633 = bank != 0;
      D.25634 = (long int) D.25633;
      D.25635 = __builtin_expect (D.25634, 0);
      if (D.25635 != 0) goto <D.25737>; else goto <D.25738>;
      <D.25737>:
      D.25633 = bank != 0;
      D.25634 = (long int) D.25633;
      D.25635 = __builtin_expect (D.25634, 0);
      if (D.25635 != 0) goto <D.25740>; else goto <D.25741>;
      <D.25740>:
      D.25633 = bank != 0;
      D.25634 = (long int) D.25633;
      D.25635 = __builtin_expect (D.25634, 0);
      if (D.25635 != 0) goto <D.25745>; else goto <D.25746>;
      <D.25745>:
      D.25599 = ins->dreg;
      if (D.25599 >= 0) goto <D.25750>; else goto <D.25748>;
      <D.25750>:
      D.25599 = ins->dreg;
      D.25649 = regbank_size[bank];
      if (D.25599 < D.25649) goto <D.25751>; else goto <D.25748>;
      <D.25751>:
      iftmp.122 = 1;
      goto <D.25749>;
      <D.25748>:
      iftmp.122 = 0;
      <D.25749>:
      D.25752 = (_Bool) iftmp.122;
      if (D.25752 != 0) goto <D.25753>; else goto <D.25743>;
      <D.25753>:
      goto <D.25754>;
      <D.25746>:
      D.25599 = ins->dreg;
      if (D.25599 <= 7) goto <D.25755>; else goto <D.25743>;
      <D.25755>:
      <D.25754>:
      D.25655 = regbank_callee_regs[bank];
      D.25599 = ins->dreg;
      D.25756 = D.25655 >> D.25599;
      D.25757 = D.25756 & 1;
      if (D.25757 != 0) goto <D.25758>; else goto <D.25743>;
      <D.25758>:
      iftmp.121 = 1;
      goto <D.25744>;
      <D.25743>:
      iftmp.121 = 0;
      <D.25744>:
      iftmp.120 = (_Bool) iftmp.121;
      goto <D.25759>;
      <D.25741>:
      D.25599 = ins->dreg;
      D.25763 = (unsigned int) D.25599;
      if (D.25763 <= 7) goto <D.25764>; else goto <D.25761>;
      <D.25764>:
      D.25599 = ins->dreg;
      D.25765 = 7 >> D.25599;
      D.25766 = D.25765 & 1;
      if (D.25766 != 0) goto <D.25767>; else goto <D.25761>;
      <D.25767>:
      iftmp.123 = 1;
      goto <D.25762>;
      <D.25761>:
      iftmp.123 = 0;
      <D.25762>:
      iftmp.120 = (_Bool) iftmp.123;
      <D.25759>:
      iftmp.119 = iftmp.120;
      goto <D.25768>;
      <D.25738>:
      D.25599 = ins->dreg;
      D.25763 = (unsigned int) D.25599;
      if (D.25763 <= 7) goto <D.25772>; else goto <D.25770>;
      <D.25772>:
      D.25599 = ins->dreg;
      D.25765 = 7 >> D.25599;
      D.25766 = D.25765 & 1;
      if (D.25766 != 0) goto <D.25773>; else goto <D.25770>;
      <D.25773>:
      iftmp.124 = 1;
      goto <D.25771>;
      <D.25770>:
      iftmp.124 = 0;
      <D.25771>:
      iftmp.119 = (_Bool) iftmp.124;
      <D.25768>:
      if (iftmp.119 != 0) goto <D.25774>; else goto <D.25775>;
      <D.25774>:
      D.25599 = ins->dreg;
      D.25776 = 1 << D.25599;
      D.25777 = ~D.25776;
      regmask = D.25777 & regmask;
      D.25590 = cfg->verbose_level;
      D.25591 = D.25590 > 2;
      D.25592 = (long int) D.25591;
      D.25593 = __builtin_expect (D.25592, 0);
      if (D.25593 != 0) goto <D.25778>; else goto <D.25779>;
      <D.25778>:
      D.25599 = ins->dreg;
      D.25780 = mono_regname_full (D.25599, bank);
      printf ("\t\texcluding dreg %s\n", D.25780);
      <D.25779>:
      <D.25775>:
      <D.25735>:
      <D.25733>:
      D.25590 = cfg->verbose_level;
      D.25591 = D.25590 > 2;
      D.25592 = (long int) D.25591;
      D.25593 = __builtin_expect (D.25592, 0);
      if (D.25593 != 0) goto <D.25781>; else goto <D.25782>;
      <D.25781>:
      D.25600 = (long long unsigned int) regmask;
      printf ("\t\tavailable regmask: 0x%08llu\n", D.25600);
      <D.25782>:
      D.25783 = regmask == 0;
      D.25784 = (long int) D.25783;
      D.25785 = __builtin_expect (D.25784, 0);
      if (D.25785 != 0) goto <D.25786>; else goto <D.25787>;
      <D.25786>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 851, "regmask");
      <D.25787>:
      sel = 0;
      D.25633 = bank != 0;
      D.25634 = (long int) D.25633;
      D.25635 = __builtin_expect (D.25634, 0);
      if (D.25635 != 0) goto <D.25788>; else goto <D.25789>;
      <D.25788>:
      i = 0;
      goto <D.23298>;
      <D.23297>:
      D.25790 = 1 << i;
      D.25791 = D.25790 & regmask;
      if (D.25791 != 0) goto <D.25792>; else goto <D.25793>;
      <D.25792>:
      sel = i;
      D.25794 = cfg->rs;
      bank = translate_bank (D.25794, bank, sel);
      D.25590 = cfg->verbose_level;
      D.25591 = D.25590 > 2;
      D.25592 = (long int) D.25591;
      D.25593 = __builtin_expect (D.25592, 0);
      if (D.25593 != 0) goto <D.25795>; else goto <D.25796>;
      <D.25795>:
      D.25797 = rs->symbolic[bank];
      sel.125 = (unsigned int) sel;
      D.25799 = sel.125 * 4;
      D.25800 = D.25797 + D.25799;
      D.25801 = *D.25800;
      D.25802 = mono_regname_full (sel, bank);
      printf ("\t\tselected register %s has assignment %d\n", D.25802, D.25801);
      <D.25796>:
      goto <D.23296>;
      <D.25793>:
      i = i + 1;
      <D.23298>:
      D.25649 = regbank_size[bank];
      if (D.25649 > i) goto <D.23297>; else goto <D.23296>;
      <D.23296>:
      D.25797 = rs->symbolic[bank];
      sel.125 = (unsigned int) sel;
      D.25799 = sel.125 * 4;
      D.25800 = D.25797 + D.25799;
      i = *D.25800;
      D.25803 = cfg->spill_count;
      D.25804 = D.25803 + 1;
      cfg->spill_count = D.25804;
      spill = cfg->spill_count;
      D.25691 = rs->vassign;
      i.126 = (unsigned int) i;
      D.25806 = i.126 * 4;
      D.25807 = D.25691 + D.25806;
      D.25808 = ~spill;
      *D.25807 = D.25808;
      mono_regstate_free_general (rs, sel, bank);
      goto <D.25809>;
      <D.25789>:
      i = 0;
      goto <D.23301>;
      <D.23300>:
      D.25790 = 1 << i;
      D.25791 = D.25790 & regmask;
      if (D.25791 != 0) goto <D.25810>; else goto <D.25811>;
      <D.25810>:
      sel = i;
      D.25590 = cfg->verbose_level;
      D.25591 = D.25590 > 2;
      D.25592 = (long int) D.25591;
      D.25593 = __builtin_expect (D.25592, 0);
      if (D.25593 != 0) goto <D.25812>; else goto <D.25813>;
      <D.25812>:
      D.25814 = rs->isymbolic[sel];
      D.25815 = mono_arch_regname (sel);
      printf ("\t\tselected register %s has assignment %d\n", D.25815, D.25814);
      <D.25813>:
      goto <D.23299>;
      <D.25811>:
      i = i + 1;
      <D.23301>:
      if (i <= 7) goto <D.23300>; else goto <D.23299>;
      <D.23299>:
      i = rs->isymbolic[sel];
      D.25803 = cfg->spill_count;
      D.25804 = D.25803 + 1;
      cfg->spill_count = D.25804;
      spill = cfg->spill_count;
      D.25691 = rs->vassign;
      i.126 = (unsigned int) i;
      D.25806 = i.126 * 4;
      D.25807 = D.25691 + D.25806;
      D.25808 = ~spill;
      *D.25807 = D.25808;
      mono_regstate_free_int (rs, sel);
      <D.25809>:
      D.25816 = cfg->mempool;
      load = mono_mempool_alloc0 (D.25816, 48);
      D.25817 = regbank_load_ops[bank];
      D.25818 = (short unsigned int) D.25817;
      load->opcode = D.25818;
      load->dreg = -1;
      load->sreg3 = -1;
      D.25819 = load->sreg3;
      load->sreg2 = D.25819;
      D.25820 = load->sreg2;
      load->sreg1 = D.25820;
      D.25821 = cfg->ip;
      load->cil_code = D.25821;
      load->dreg = sel;
      D.25822 = cfg->frame_reg;
      D.25823 = (int) D.25822;
      load->sreg1 = D.25823;
      D.25824 = get_vreg_bank (cfg, i, bank);
      D.25825 = mono_spillvar_offset (cfg, spill, D.25824);
      load->data.op[0].const_val = D.25825;
      insert_after_ins (bb, ins, last, load);
      D.25590 = cfg->verbose_level;
      D.25591 = D.25590 > 2;
      D.25592 = (long int) D.25591;
      D.25593 = __builtin_expect (D.25592, 0);
      if (D.25593 != 0) goto <D.25826>; else goto <D.25827>;
      <D.25826>:
      D.25828 = mono_regname_full (sel, bank);
      D.25829 = load->data.op[0].const_val;
      printf ("\tSPILLED LOAD (%d at 0x%08lx(%%ebp)) R%d (freed %s)\n", spill, D.25829, i, D.25828);
      <D.25827>:
      D.25633 = bank != 0;
      D.25634 = (long int) D.25633;
      D.25635 = __builtin_expect (D.25634, 0);
      if (D.25635 != 0) goto <D.25830>; else goto <D.25831>;
      <D.25830>:
      D.25832 = 1 << sel;
      i = mono_regstate_alloc_general (rs, D.25832, bank);
      goto <D.25833>;
      <D.25831>:
      D.25832 = 1 << sel;
      i = mono_regstate_alloc_int (rs, D.25832);
      <D.25833>:
      D.25834 = i != sel;
      D.25835 = (long int) D.25834;
      D.25836 = __builtin_expect (D.25835, 0);
      if (D.25836 != 0) goto <D.25837>; else goto <D.25838>;
      <D.25837>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 898, "i == sel");
      <D.25838>:
      D.25839 = sel;
      return D.25839;
    }
  finally
    {
      sregs = {CLOBBER};
    }
}


get_vreg_bank (struct MonoCompile * cfg, int reg, int bank)
{
  unsigned int reg.127;
  unsigned int D.25844;
  gboolean * D.25846;
  unsigned int reg.128;
  unsigned int D.25848;
  gboolean * D.25849;
  int D.25850;
  int D.25852;
  unsigned int D.25854;
  gboolean * D.25856;
  gboolean * D.25857;
  int D.25858;

  reg.127 = (unsigned int) reg;
  D.25844 = cfg->vreg_is_ref_len;
  if (reg.127 < D.25844) goto <D.25845>; else goto <D.25842>;
  <D.25845>:
  D.25846 = cfg->vreg_is_ref;
  reg.128 = (unsigned int) reg;
  D.25848 = reg.128 * 4;
  D.25849 = D.25846 + D.25848;
  D.25850 = *D.25849;
  if (D.25850 != 0) goto <D.25851>; else goto <D.25842>;
  <D.25851>:
  D.25852 = 2;
  return D.25852;
  <D.25842>:
  reg.127 = (unsigned int) reg;
  D.25854 = cfg->vreg_is_mp_len;
  if (reg.127 < D.25854) goto <D.25855>; else goto <D.25853>;
  <D.25855>:
  D.25856 = cfg->vreg_is_mp;
  reg.128 = (unsigned int) reg;
  D.25848 = reg.128 * 4;
  D.25857 = D.25856 + D.25848;
  D.25858 = *D.25857;
  if (D.25858 != 0) goto <D.25859>; else goto <D.25853>;
  <D.25859>:
  D.25852 = 3;
  return D.25852;
  <D.25853>:
  D.25852 = bank;
  return D.25852;
}


mono_spillvar_offset (struct MonoCompile * cfg, int spillvar, int bank)
{
  int D.25861;
  _Bool D.25862;
  long int D.25863;
  long int D.25864;
  struct MonoSpillInfo * D.25867;
  unsigned int spillvar.129;
  unsigned int D.25869;
  int D.25870;
  int D.25873;
  unsigned int D.25874;
  unsigned int D.25875;
  int D.25876;
  int D.25877;
  _Bool D.25878;
  long int D.25879;
  long int D.25880;
  _Bool D.25883;
  long int D.25884;
  long int D.25885;
  unsigned int D.25889;
  unsigned int D.25890;
  int D.25893;
  int D.25894;
  int D.25895;
  int D.25896;
  int D.25897;
  int D.25899;
  int D.25900;
  struct MonoSpillInfo * info;
  int size;

  D.25861 = cfg->spill_info_len[bank];
  D.25862 = D.25861 <= spillvar;
  D.25863 = (long int) D.25862;
  D.25864 = __builtin_expect (D.25863, 0);
  if (D.25864 != 0) goto <D.25865>; else goto <D.25866>;
  <D.25865>:
  goto <D.23104>;
  <D.23103>:
  resize_spill_info (cfg, bank);
  <D.23104>:
  D.25861 = cfg->spill_info_len[bank];
  if (D.25861 <= spillvar) goto <D.23103>; else goto <D.23105>;
  <D.23105>:
  <D.25866>:
  D.25867 = cfg->spill_info[bank];
  spillvar.129 = (unsigned int) spillvar;
  D.25869 = spillvar.129 * 4;
  info = D.25867 + D.25869;
  D.25870 = info->offset;
  if (D.25870 == -1) goto <D.25871>; else goto <D.25872>;
  <D.25871>:
  D.25873 = cfg->stack_offset;
  D.25874 = (unsigned int) D.25873;
  D.25875 = D.25874 + 3;
  D.25876 = (int) D.25875;
  cfg->stack_offset = D.25876;
  D.25873 = cfg->stack_offset;
  D.25877 = D.25873 & -4;
  cfg->stack_offset = D.25877;
  D.25878 = bank > 4;
  D.25879 = (long int) D.25878;
  D.25880 = __builtin_expect (D.25879, 0);
  if (D.25880 != 0) goto <D.25881>; else goto <D.25882>;
  <D.25881>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 329, "bank < MONO_NUM_REGBANKS");
  <D.25882>:
  D.25883 = bank != 0;
  D.25884 = (long int) D.25883;
  D.25885 = __builtin_expect (D.25884, 0);
  if (D.25885 != 0) goto <D.25886>; else goto <D.25887>;
  <D.25886>:
  size = regbank_spill_var_size[bank];
  goto <D.25888>;
  <D.25887>:
  size = 4;
  <D.25888>:
  D.25889 = cfg->flags;
  D.25890 = D.25889 & 64;
  if (D.25890 != 0) goto <D.25891>; else goto <D.25892>;
  <D.25891>:
  D.25873 = cfg->stack_offset;
  D.25893 = size + -1;
  D.25894 = D.25873 + D.25893;
  cfg->stack_offset = D.25894;
  D.25873 = cfg->stack_offset;
  D.25895 = -size;
  D.25896 = D.25873 & D.25895;
  cfg->stack_offset = D.25896;
  D.25873 = cfg->stack_offset;
  info->offset = D.25873;
  D.25873 = cfg->stack_offset;
  D.25897 = D.25873 + size;
  cfg->stack_offset = D.25897;
  goto <D.25898>;
  <D.25892>:
  D.25873 = cfg->stack_offset;
  D.25893 = size + -1;
  D.25894 = D.25873 + D.25893;
  cfg->stack_offset = D.25894;
  D.25873 = cfg->stack_offset;
  D.25895 = -size;
  D.25896 = D.25873 & D.25895;
  cfg->stack_offset = D.25896;
  D.25873 = cfg->stack_offset;
  D.25897 = D.25873 + size;
  cfg->stack_offset = D.25897;
  D.25873 = cfg->stack_offset;
  D.25899 = -D.25873;
  info->offset = D.25899;
  <D.25898>:
  <D.25872>:
  D.25900 = info->offset;
  return D.25900;
}


resize_spill_info (struct MonoCompile * cfg, int bank)
{
  int iftmp.130;
  _Bool D.25906;
  long int D.25907;
  long int D.25908;
  unsigned int new_len.131;
  unsigned int D.25912;
  struct MonoMemPool * D.25913;
  unsigned int orig_len.132;
  unsigned int D.25917;
  unsigned int i.133;
  unsigned int D.25919;
  struct MonoSpillInfo * D.25920;
  struct MonoSpillInfo * orig_info;
  int orig_len;
  int new_len;
  struct MonoSpillInfo * new_info;
  int i;

  orig_info = cfg->spill_info[bank];
  orig_len = cfg->spill_info_len[bank];
  if (orig_len != 0) goto <D.25903>; else goto <D.25904>;
  <D.25903>:
  iftmp.130 = orig_len * 2;
  goto <D.25905>;
  <D.25904>:
  iftmp.130 = 16;
  <D.25905>:
  new_len = iftmp.130;
  D.25906 = bank > 4;
  D.25907 = (long int) D.25906;
  D.25908 = __builtin_expect (D.25907, 0);
  if (D.25908 != 0) goto <D.25909>; else goto <D.25910>;
  <D.25909>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 294, "bank < MONO_NUM_REGBANKS");
  <D.25910>:
  new_len.131 = (unsigned int) new_len;
  D.25912 = new_len.131 * 4;
  D.25913 = cfg->mempool;
  new_info = mono_mempool_alloc0 (D.25913, D.25912);
  if (orig_info != 0B) goto <D.25914>; else goto <D.25915>;
  <D.25914>:
  orig_len.132 = (unsigned int) orig_len;
  D.25917 = orig_len.132 * 4;
  memcpy (new_info, orig_info, D.25917);
  <D.25915>:
  i = orig_len;
  goto <D.23094>;
  <D.23093>:
  i.133 = (unsigned int) i;
  D.25919 = i.133 * 4;
  D.25920 = new_info + D.25919;
  D.25920->offset = -1;
  i = i + 1;
  <D.23094>:
  if (i < new_len) goto <D.23093>; else goto <D.23095>;
  <D.23095>:
  cfg->spill_info[bank] = new_info;
  cfg->spill_info_len[bank] = new_len;
}


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

  D.25922 = __builtin_object_size (__dest, 0);
  D.25921 = __builtin___memcpy_chk (__dest, __src, __len, D.25922);
  return D.25921;
}


insert_after_ins (struct MonoBasicBlock * bb, struct MonoInst * ins, struct MonoInst * * last, struct MonoInst * to_insert)
{
  struct MonoInst * D.25924;

  D.25924 = *last;
  mono_bblock_insert_after_ins (bb, D.25924, to_insert);
  *last = to_insert;
}


mono_regstate_alloc_general (struct MonoRegState * rs, regmask_t allow, int bank)
{
  unsigned int D.25925;
  unsigned int D.25926;
  unsigned int D.25927;
  unsigned int D.25930;
  unsigned int D.25931;
  int D.25934;
  int D.25935;
  int i;
  int mirrored_bank;
  regmask_t mask;

  D.25925 = rs->free_mask[bank];
  mask = D.25925 & allow;
  i = 0;
  goto <D.23059>;
  <D.23058>:
  D.25926 = 1 << i;
  D.25927 = D.25926 & mask;
  if (D.25927 != 0) goto <D.25928>; else goto <D.25929>;
  <D.25928>:
  D.25925 = rs->free_mask[bank];
  D.25926 = 1 << i;
  D.25930 = ~D.25926;
  D.25931 = D.25925 & D.25930;
  rs->free_mask[bank] = D.25931;
  mirrored_bank = -1;
  if (mirrored_bank == -1) goto <D.25932>; else goto <D.25933>;
  <D.25932>:
  D.25934 = i;
  return D.25934;
  <D.25933>:
  D.25925 = rs->free_mask[bank];
  rs->free_mask[mirrored_bank] = D.25925;
  D.25934 = i;
  return D.25934;
  <D.25929>:
  i = i + 1;
  <D.23059>:
  D.25935 = regbank_size[bank];
  if (D.25935 > i) goto <D.23058>; else goto <D.23060>;
  <D.23060>:
  D.25934 = -1;
  return D.25934;
}


mono_regstate_free_general (struct MonoRegState * rs, int reg, int bank)
{
  unsigned int D.25939;
  unsigned int D.25940;
  unsigned int D.25941;
  int * D.25942;
  unsigned int reg.134;
  unsigned int D.25944;
  int * D.25945;
  int * D.25948;
  int * D.25949;
  int mirrored_bank;

  if (reg >= 0) goto <D.25937>; else goto <D.25938>;
  <D.25937>:
  D.25939 = rs->free_mask[bank];
  D.25940 = 1 << reg;
  D.25941 = D.25939 | D.25940;
  rs->free_mask[bank] = D.25941;
  D.25942 = rs->symbolic[bank];
  reg.134 = (unsigned int) reg;
  D.25944 = reg.134 * 4;
  D.25945 = D.25942 + D.25944;
  *D.25945 = 0;
  mirrored_bank = -1;
  if (mirrored_bank == -1) goto <D.25946>; else goto <D.25947>;
  <D.25946>:
  return;
  <D.25947>:
  D.25939 = rs->free_mask[bank];
  rs->free_mask[mirrored_bank] = D.25939;
  D.25948 = rs->symbolic[mirrored_bank];
  reg.134 = (unsigned int) reg;
  D.25944 = reg.134 * 4;
  D.25949 = D.25948 + D.25944;
  *D.25949 = 0;
  <D.25938>:
}


mono_regstate_free_int (struct MonoRegState * rs, int reg)
{
  unsigned int D.25953;
  unsigned int D.25954;
  unsigned int D.25955;

  if (reg >= 0) goto <D.25951>; else goto <D.25952>;
  <D.25951>:
  D.25953 = rs->ifree_mask;
  D.25954 = 1 << reg;
  D.25955 = D.25953 | D.25954;
  rs->ifree_mask = D.25955;
  rs->isymbolic[reg] = 0;
  <D.25952>:
}


create_copy_ins (struct MonoCompile * cfg, struct MonoBasicBlock * bb, struct MonoInst * * last, int dest, int src, struct MonoInst * ins, const unsigned char * ip, int bank)
{
  struct MonoMemPool * D.25956;
  int D.25957;
  short unsigned int D.25958;
  int D.25959;
  int D.25960;
  const unsigned char * D.25961;
  unsigned int D.25964;
  _Bool D.25965;
  long int D.25966;
  long int D.25967;
  const char * D.25970;
  const char * D.25971;
  struct MonoInst * D.25972;
  struct MonoInst * copy;

  D.25956 = cfg->mempool;
  copy = mono_mempool_alloc0 (D.25956, 48);
  D.25957 = regbank_move_ops[bank];
  D.25958 = (short unsigned int) D.25957;
  copy->opcode = D.25958;
  copy->dreg = -1;
  copy->sreg3 = -1;
  D.25959 = copy->sreg3;
  copy->sreg2 = D.25959;
  D.25960 = copy->sreg2;
  copy->sreg1 = D.25960;
  D.25961 = cfg->ip;
  copy->cil_code = D.25961;
  copy->dreg = dest;
  copy->sreg1 = src;
  copy->cil_code = ip;
  if (ins != 0B) goto <D.25962>; else goto <D.25963>;
  <D.25962>:
  mono_bblock_insert_after_ins (bb, ins, copy);
  *last = copy;
  <D.25963>:
  D.25964 = cfg->verbose_level;
  D.25965 = D.25964 > 2;
  D.25966 = (long int) D.25965;
  D.25967 = __builtin_expect (D.25966, 0);
  if (D.25967 != 0) goto <D.25968>; else goto <D.25969>;
  <D.25968>:
  D.25970 = mono_regname_full (dest, bank);
  D.25971 = mono_regname_full (src, bank);
  printf ("\tforced copy from %s to %s\n", D.25971, D.25970);
  <D.25969>:
  D.25972 = copy;
  return D.25972;
}


insert_before_ins (struct MonoBasicBlock * bb, struct MonoInst * ins, struct MonoInst * to_insert)
{
  mono_bblock_insert_before_ins (bb, ins, to_insert);
}


spill_vreg (struct MonoCompile * cfg, struct MonoBasicBlock * bb, struct MonoInst * * last, struct MonoInst * ins, int reg, int bank)
{
  gint32 * D.25974;
  unsigned int reg.135;
  unsigned int D.25976;
  gint32 * D.25977;
  struct MonoRegState * D.25978;
  int D.25979;
  int D.25980;
  unsigned int i.136;
  unsigned int D.25982;
  gint32 * D.25983;
  int D.25984;
  _Bool D.25985;
  long int D.25986;
  long int D.25987;
  struct MonoMemPool * D.25991;
  int D.25992;
  short unsigned int D.25993;
  int D.25994;
  int D.25995;
  const unsigned char * D.25996;
  unsigned int D.25997;
  int D.25998;
  int D.25999;
  int D.26000;
  unsigned int D.26001;
  _Bool D.26002;
  long int D.26003;
  long int D.26004;
  const char * D.26007;
  int D.26008;
  unsigned int D.26011;
  _Bool D.26013;
  long int D.26014;
  long int D.26015;
  struct MonoInst * load;
  int i;
  int sel;
  int spill;
  int * symbolic;
  struct MonoRegState * rs;

  rs = cfg->rs;
  symbolic = rs->symbolic[bank];
  D.25974 = rs->vassign;
  reg.135 = (unsigned int) reg;
  D.25976 = reg.135 * 4;
  D.25977 = D.25974 + D.25976;
  sel = *D.25977;
  D.25978 = cfg->rs;
  bank = translate_bank (D.25978, bank, sel);
  i = reg;
  D.25979 = cfg->spill_count;
  D.25980 = D.25979 + 1;
  cfg->spill_count = D.25980;
  spill = cfg->spill_count;
  D.25974 = rs->vassign;
  i.136 = (unsigned int) i;
  D.25982 = i.136 * 4;
  D.25983 = D.25974 + D.25982;
  D.25984 = ~spill;
  *D.25983 = D.25984;
  D.25985 = bank != 0;
  D.25986 = (long int) D.25985;
  D.25987 = __builtin_expect (D.25986, 0);
  if (D.25987 != 0) goto <D.25988>; else goto <D.25989>;
  <D.25988>:
  mono_regstate_free_general (rs, sel, bank);
  goto <D.25990>;
  <D.25989>:
  mono_regstate_free_int (rs, sel);
  <D.25990>:
  D.25991 = cfg->mempool;
  load = mono_mempool_alloc0 (D.25991, 48);
  D.25992 = regbank_load_ops[bank];
  D.25993 = (short unsigned int) D.25992;
  load->opcode = D.25993;
  load->dreg = -1;
  load->sreg3 = -1;
  D.25994 = load->sreg3;
  load->sreg2 = D.25994;
  D.25995 = load->sreg2;
  load->sreg1 = D.25995;
  D.25996 = cfg->ip;
  load->cil_code = D.25996;
  load->dreg = sel;
  D.25997 = cfg->frame_reg;
  D.25998 = (int) D.25997;
  load->sreg1 = D.25998;
  D.25999 = get_vreg_bank (cfg, reg, bank);
  D.26000 = mono_spillvar_offset (cfg, spill, D.25999);
  load->data.op[0].const_val = D.26000;
  insert_after_ins (bb, ins, last, load);
  D.26001 = cfg->verbose_level;
  D.26002 = D.26001 > 2;
  D.26003 = (long int) D.26002;
  D.26004 = __builtin_expect (D.26003, 0);
  if (D.26004 != 0) goto <D.26005>; else goto <D.26006>;
  <D.26005>:
  D.26007 = mono_regname_full (sel, bank);
  D.26008 = load->data.op[0].const_val;
  printf ("SPILLED LOAD (%d at 0x%08lx(%%ebp)) R%d (freed %s)\n", spill, D.26008, i, D.26007);
  <D.26006>:
  D.25985 = bank != 0;
  D.25986 = (long int) D.25985;
  D.25987 = __builtin_expect (D.25986, 0);
  if (D.25987 != 0) goto <D.26009>; else goto <D.26010>;
  <D.26009>:
  D.26011 = 1 << sel;
  i = mono_regstate_alloc_general (rs, D.26011, bank);
  goto <D.26012>;
  <D.26010>:
  D.26011 = 1 << sel;
  i = mono_regstate_alloc_int (rs, D.26011);
  <D.26012>:
  D.26013 = i != sel;
  D.26014 = (long int) D.26013;
  D.26015 = __builtin_expect (D.26014, 0);
  if (D.26015 != 0) goto <D.26016>; else goto <D.26017>;
  <D.26016>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 807, "i == sel");
  <D.26017>:
  D.25985 = bank != 0;
  D.25986 = (long int) D.25985;
  D.25987 = __builtin_expect (D.25986, 0);
  if (D.25987 != 0) goto <D.26018>; else goto <D.26019>;
  <D.26018>:
  mono_regstate_free_general (rs, sel, bank);
  goto <D.26020>;
  <D.26019>:
  mono_regstate_free_int (rs, sel);
  <D.26020>:
}


alloc_reg (struct MonoCompile * cfg, struct MonoBasicBlock * bb, struct MonoInst * * last, struct MonoInst * ins, regmask_t dest_mask, int sym_reg, struct RegTrack * info, int bank)
{
  _Bool D.26021;
  long int D.26022;
  long int D.26023;
  int D.26026;

  D.26021 = bank != 0;
  D.26022 = (long int) D.26021;
  D.26023 = __builtin_expect (D.26022, 0);
  if (D.26023 != 0) goto <D.26024>; else goto <D.26025>;
  <D.26024>:
  D.26026 = alloc_general_reg (cfg, bb, last, ins, dest_mask, sym_reg, bank);
  return D.26026;
  <D.26025>:
  D.26026 = alloc_int_reg (cfg, bb, last, ins, dest_mask, sym_reg, info);
  return D.26026;
}


alloc_general_reg (struct MonoCompile * cfg, struct MonoBasicBlock * bb, struct MonoInst * * last, struct MonoInst * ins, regmask_t dest_mask, int sym_reg, int bank)
{
  struct MonoRegState * D.26028;
  int D.26031;
  int val;

  D.26028 = cfg->rs;
  val = mono_regstate_alloc_general (D.26028, dest_mask, bank);
  if (val < 0) goto <D.26029>; else goto <D.26030>;
  <D.26029>:
  val = get_register_spilling (cfg, bb, last, ins, dest_mask, sym_reg, bank);
  <D.26030>:
  D.26031 = val;
  return D.26031;
}


assign_reg (struct MonoCompile * cfg, struct MonoRegState * rs, int reg, int hreg, int bank)
{
  _Bool D.26033;
  long int D.26034;
  long int D.26035;
  int D.26038;
  _Bool D.26039;
  long int D.26040;
  long int D.26041;
  _Bool D.26044;
  long int D.26045;
  long int D.26046;
  gint32 * D.26051;
  unsigned int reg.137;
  unsigned int D.26053;
  gint32 * D.26054;
  int * D.26055;
  unsigned int hreg.138;
  unsigned int D.26057;
  int * D.26058;
  unsigned int D.26059;
  unsigned int D.26060;
  unsigned int D.26061;
  unsigned int D.26062;
  int * D.26065;
  int * D.26066;
  _Bool D.26068;
  long int D.26069;
  long int D.26070;
  _Bool D.26073;
  long int D.26074;
  long int D.26075;
  int iftmp.139;
  unsigned int hreg.140;
  unsigned int D.26083;
  unsigned int D.26084;
  _Bool D.26086;
  long int D.26087;
  long int D.26088;
  unsigned int D.26091;
  unsigned int D.26092;

  D.26033 = bank != 0;
  D.26034 = (long int) D.26033;
  D.26035 = __builtin_expect (D.26034, 0);
  if (D.26035 != 0) goto <D.26036>; else goto <D.26037>;
  <D.26036>:
  {
    int mirrored_bank;

    D.26038 = regbank_size[bank];
    D.26039 = D.26038 > reg;
    D.26040 = (long int) D.26039;
    D.26041 = __builtin_expect (D.26040, 0);
    if (D.26041 != 0) goto <D.26042>; else goto <D.26043>;
    <D.26042>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1040, "reg >= regbank_size [bank]");
    <D.26043>:
    D.26038 = regbank_size[bank];
    D.26044 = D.26038 <= hreg;
    D.26045 = (long int) D.26044;
    D.26046 = __builtin_expect (D.26045, 0);
    if (D.26046 != 0) goto <D.26047>; else goto <D.26048>;
    <D.26047>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1041, "hreg < regbank_size [bank]");
    <D.26048>:
    if (0 != 0) goto <D.26049>; else goto <D.26050>;
    <D.26049>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1042, "! is_global_freg (hreg)");
    <D.26050>:
    D.26051 = rs->vassign;
    reg.137 = (unsigned int) reg;
    D.26053 = reg.137 * 4;
    D.26054 = D.26051 + D.26053;
    *D.26054 = hreg;
    D.26055 = rs->symbolic[bank];
    hreg.138 = (unsigned int) hreg;
    D.26057 = hreg.138 * 4;
    D.26058 = D.26055 + D.26057;
    *D.26058 = reg;
    D.26059 = rs->free_mask[bank];
    D.26060 = 1 << hreg;
    D.26061 = ~D.26060;
    D.26062 = D.26059 & D.26061;
    rs->free_mask[bank] = D.26062;
    mirrored_bank = -1;
    if (mirrored_bank == -1) goto <D.26063>; else goto <D.26064>;
    <D.26063>:
    return;
    <D.26064>:
    D.26059 = rs->free_mask[bank];
    rs->free_mask[mirrored_bank] = D.26059;
    D.26065 = rs->symbolic[mirrored_bank];
    hreg.138 = (unsigned int) hreg;
    D.26057 = hreg.138 * 4;
    D.26066 = D.26065 + D.26057;
    *D.26066 = -2;
  }
  goto <D.26067>;
  <D.26037>:
  D.26068 = reg <= 7;
  D.26069 = (long int) D.26068;
  D.26070 = __builtin_expect (D.26069, 0);
  if (D.26070 != 0) goto <D.26071>; else goto <D.26072>;
  <D.26071>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1064, "reg >= MONO_MAX_IREGS");
  <D.26072>:
  D.26073 = hreg > 7;
  D.26074 = (long int) D.26073;
  D.26075 = __builtin_expect (D.26074, 0);
  if (D.26075 != 0) goto <D.26076>; else goto <D.26077>;
  <D.26076>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1065, "hreg < MONO_MAX_IREGS");
  <D.26077>:
  hreg.140 = (unsigned int) hreg;
  if (hreg.140 <= 7) goto <D.26082>; else goto <D.26079>;
  <D.26082>:
  D.26083 = 232 >> hreg;
  D.26084 = D.26083 & 1;
  if (D.26084 != 0) goto <D.26085>; else goto <D.26079>;
  <D.26085>:
  iftmp.139 = 1;
  goto <D.26080>;
  <D.26079>:
  iftmp.139 = 0;
  <D.26080>:
  D.26086 = iftmp.139 != 0;
  D.26087 = (long int) D.26086;
  D.26088 = __builtin_expect (D.26087, 0);
  if (D.26088 != 0) goto <D.26089>; else goto <D.26090>;
  <D.26089>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1068, "! is_global_ireg (hreg)");
  <D.26090>:
  D.26051 = rs->vassign;
  reg.137 = (unsigned int) reg;
  D.26053 = reg.137 * 4;
  D.26054 = D.26051 + D.26053;
  *D.26054 = hreg;
  rs->isymbolic[hreg] = reg;
  D.26091 = rs->ifree_mask;
  D.26060 = 1 << hreg;
  D.26061 = ~D.26060;
  D.26092 = D.26091 & D.26061;
  rs->ifree_mask = D.26092;
  <D.26067>:
}


create_spilled_store (struct MonoCompile * cfg, struct MonoBasicBlock * bb, int spill, int reg, int prev_reg, struct MonoInst * * last, struct MonoInst * ins, struct MonoInst * insert_before, int bank)
{
  struct MonoMemPool * D.26094;
  int D.26095;
  short unsigned int D.26096;
  int D.26097;
  int D.26098;
  const unsigned char * D.26099;
  unsigned int D.26100;
  int D.26101;
  int D.26102;
  unsigned int D.26109;
  _Bool D.26110;
  long int D.26111;
  long int D.26112;
  const char * D.26115;
  int D.26116;
  const char * D.26117;
  unsigned int bank.141;
  unsigned int D.26119;
  unsigned char D.26122;
  unsigned char D.26123;
  _Bool D.26126;
  long int D.26127;
  long int D.26128;
  int D.26131;
  int D.26132;
  struct MonoInst * store;
  struct MonoInst * def;

  bank = get_vreg_bank (cfg, prev_reg, bank);
  D.26094 = cfg->mempool;
  store = mono_mempool_alloc0 (D.26094, 48);
  D.26095 = regbank_store_ops[bank];
  D.26096 = (short unsigned int) D.26095;
  store->opcode = D.26096;
  store->dreg = -1;
  store->sreg3 = -1;
  D.26097 = store->sreg3;
  store->sreg2 = D.26097;
  D.26098 = store->sreg2;
  store->sreg1 = D.26098;
  D.26099 = cfg->ip;
  store->cil_code = D.26099;
  store->sreg1 = reg;
  D.26100 = cfg->frame_reg;
  D.26101 = (int) D.26100;
  store->dreg = D.26101;
  D.26102 = mono_spillvar_offset (cfg, spill, bank);
  store->data.op[0].const_val = D.26102;
  if (ins != 0B) goto <D.26103>; else goto <D.26104>;
  <D.26103>:
  mono_bblock_insert_after_ins (bb, ins, store);
  *last = store;
  goto <D.26105>;
  <D.26104>:
  if (insert_before != 0B) goto <D.26106>; else goto <D.26107>;
  <D.26106>:
  insert_before_ins (bb, insert_before, store);
  goto <D.26108>;
  <D.26107>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-codegen.c", 972);
  <D.26108>:
  <D.26105>:
  D.26109 = cfg->verbose_level;
  D.26110 = D.26109 > 2;
  D.26111 = (long int) D.26110;
  D.26112 = __builtin_expect (D.26111, 0);
  if (D.26112 != 0) goto <D.26113>; else goto <D.26114>;
  <D.26113>:
  D.26115 = mono_regname_full (reg, bank);
  D.26116 = store->data.op[0].const_val;
  D.26117 = regbank_to_string (bank);
  printf ("\t%sSPILLED STORE (%d at 0x%08lx(%%ebp)) R%d (from %s)\n", D.26117, spill, D.26116, prev_reg, D.26115);
  <D.26114>:
  bank.141 = (unsigned int) bank;
  D.26119 = bank.141 + 4294967294;
  if (D.26119 <= 1) goto <D.26120>; else goto <D.26121>;
  <D.26120>:
  D.26122 = BIT_FIELD_REF <*cfg, 8, 3424>;
  D.26123 = D.26122 & 128;
  if (D.26123 != 0) goto <D.26124>; else goto <D.26125>;
  <D.26124>:
  D.26126 = prev_reg == -1;
  D.26127 = (long int) D.26126;
  D.26128 = __builtin_expect (D.26127, 0);
  if (D.26128 != 0) goto <D.26129>; else goto <D.26130>;
  <D.26129>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 977, "prev_reg != -1");
  <D.26130>:
  D.26094 = cfg->mempool;
  def = mono_mempool_alloc0 (D.26094, 48);
  def->opcode = 1002;
  def->dreg = -1;
  def->sreg3 = -1;
  D.26131 = def->sreg3;
  def->sreg2 = D.26131;
  D.26132 = def->sreg2;
  def->sreg1 = D.26132;
  D.26099 = cfg->ip;
  def->cil_code = D.26099;
  def->data.op[0].const_val = spill;
  def->data.op[1].const_val = bank;
  mono_bblock_insert_after_ins (bb, store, def);
  <D.26125>:
  <D.26121>:
}


regbank_to_string (int bank)
{
  const char * D.26135;

  if (bank == 2) goto <D.26133>; else goto <D.26134>;
  <D.26133>:
  D.26135 = "REF ";
  return D.26135;
  <D.26134>:
  if (bank == 3) goto <D.26136>; else goto <D.26137>;
  <D.26136>:
  D.26135 = "MP ";
  return D.26135;
  <D.26137>:
  D.26135 = "";
  return D.26135;
}


mono_opcode_to_cond (int opcode)
{
  CompRelation D.26139;
  const char * D.26140;

  switch (opcode) <default: <D.23700>, case 450: <D.23608>, case 451: <D.23653>, case 452: <D.23689>, case 453: <D.23642>, case 454: <D.23678>, case 455: <D.23615>, case 457: <D.23660>, case 459: <D.23649>, case 460: <D.23624>, case 462: <D.23696>, case 463: <D.23668>, case 464: <D.23685>, case 469: <D.23616>, case 471: <D.23661>, case 473: <D.23650>, case 474: <D.23625>, case 476: <D.23697>, case 477: <D.23669>, case 478: <D.23686>, case 535: <D.23612>, case 536: <D.23657>, case 537: <D.23693>, case 538: <D.23646>, case 539: <D.23682>, case 555: <D.23611>, case 556: <D.23638>, case 557: <D.23656>, case 558: <D.23631>, case 559: <D.23645>, case 560: <D.23622>, case 561: <D.23674>, case 562: <D.23692>, case 563: <D.23666>, case 564: <D.23681>, case 642: <D.23610>, case 643: <D.23655>, case 644: <D.23691>, case 645: <D.23644>, case 646: <D.23680>, case 647: <D.23620>, case 648: <D.23636>, case 649: <D.23629>, case 650: <D.23672>, case 651: <D.23664>, case 652: <D.23609>, case 653: <D.23637>, case 654: <D.23654>, case 655: <D.23630>, case 656: <D.23643>, case 657: <D.23621>, case 658: <D.23673>, case 659: <D.23690>, case 660: <D.23665>, case 661: <D.23679>, case 662: <D.23613>, case 663: <D.23639>, case 664: <D.23658>, case 665: <D.23632>, case 666: <D.23647>, case 667: <D.23623>, case 668: <D.23675>, case 669: <D.23695>, case 670: <D.23667>, case 671: <D.23683>, case 718: <D.23614>, case 719: <D.23659>, case 720: <D.23694>, case 721: <D.23648>, case 722: <D.23684>, case 723: <D.23619>, case 724: <D.23635>, case 725: <D.23628>, case 978: <D.23617>, case 979: <D.23640>, case 980: <D.23662>, case 981: <D.23633>, case 982: <D.23651>, case 983: <D.23626>, case 984: <D.23676>, case 985: <D.23698>, case 986: <D.23670>, case 987: <D.23687>, case 988: <D.23618>, case 989: <D.23641>, case 990: <D.23663>, case 991: <D.23634>, case 992: <D.23652>, case 993: <D.23627>, case 994: <D.23677>, case 995: <D.23699>, case 996: <D.23671>, case 997: <D.23688>>
  <D.23608>:
  <D.23609>:
  <D.23610>:
  <D.23611>:
  <D.23612>:
  <D.23613>:
  <D.23614>:
  <D.23615>:
  <D.23616>:
  <D.23617>:
  <D.23618>:
  D.26139 = 0;
  return D.26139;
  <D.23619>:
  <D.23620>:
  <D.23621>:
  <D.23622>:
  <D.23623>:
  <D.23624>:
  <D.23625>:
  <D.23626>:
  <D.23627>:
  D.26139 = 1;
  return D.26139;
  <D.23628>:
  <D.23629>:
  <D.23630>:
  <D.23631>:
  <D.23632>:
  <D.23633>:
  <D.23634>:
  D.26139 = 2;
  return D.26139;
  <D.23635>:
  <D.23636>:
  <D.23637>:
  <D.23638>:
  <D.23639>:
  <D.23640>:
  <D.23641>:
  D.26139 = 3;
  return D.26139;
  <D.23642>:
  <D.23643>:
  <D.23644>:
  <D.23645>:
  <D.23646>:
  <D.23647>:
  <D.23648>:
  <D.23649>:
  <D.23650>:
  <D.23651>:
  <D.23652>:
  D.26139 = 4;
  return D.26139;
  <D.23653>:
  <D.23654>:
  <D.23655>:
  <D.23656>:
  <D.23657>:
  <D.23658>:
  <D.23659>:
  <D.23660>:
  <D.23661>:
  <D.23662>:
  <D.23663>:
  D.26139 = 5;
  return D.26139;
  <D.23664>:
  <D.23665>:
  <D.23666>:
  <D.23667>:
  <D.23668>:
  <D.23669>:
  <D.23670>:
  <D.23671>:
  D.26139 = 6;
  return D.26139;
  <D.23672>:
  <D.23673>:
  <D.23674>:
  <D.23675>:
  <D.23676>:
  <D.23677>:
  D.26139 = 7;
  return D.26139;
  <D.23678>:
  <D.23679>:
  <D.23680>:
  <D.23681>:
  <D.23682>:
  <D.23683>:
  <D.23684>:
  <D.23685>:
  <D.23686>:
  <D.23687>:
  <D.23688>:
  D.26139 = 8;
  return D.26139;
  <D.23689>:
  <D.23690>:
  <D.23691>:
  <D.23692>:
  <D.23693>:
  <D.23694>:
  <D.23695>:
  <D.23696>:
  <D.23697>:
  <D.23698>:
  <D.23699>:
  D.26139 = 9;
  return D.26139;
  <D.23700>:
  D.26140 = mono_inst_name (opcode);
  printf ("%s\n", D.26140);
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-codegen.c", 2447);
  D.26139 = 0;
  return D.26139;
}


mono_negate_cond (CompRelation cond)
{
  CompRelation D.26142;

  switch (cond) <default: <D.23714>, case 0: <D.23704>, case 1: <D.23705>, case 2: <D.23706>, case 3: <D.23707>, case 4: <D.23708>, case 5: <D.23709>, case 6: <D.23710>, case 7: <D.23711>, case 8: <D.23712>, case 9: <D.23713>>
  <D.23704>:
  D.26142 = 1;
  return D.26142;
  <D.23705>:
  D.26142 = 0;
  return D.26142;
  <D.23706>:
  D.26142 = 5;
  return D.26142;
  <D.23707>:
  D.26142 = 4;
  return D.26142;
  <D.23708>:
  D.26142 = 3;
  return D.26142;
  <D.23709>:
  D.26142 = 2;
  return D.26142;
  <D.23710>:
  D.26142 = 9;
  return D.26142;
  <D.23711>:
  D.26142 = 8;
  return D.26142;
  <D.23712>:
  D.26142 = 7;
  return D.26142;
  <D.23713>:
  D.26142 = 6;
  return D.26142;
  <D.23714>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-codegen.c", 2477);
}


mono_opcode_to_type (int opcode, int cmp_opcode)
{
  unsigned int opcode.142;
  unsigned int D.26145;
  CompType D.26148;
  unsigned int D.26149;
  unsigned int D.26152;
  unsigned int D.26155;
  unsigned int D.26158;
  unsigned int D.26161;
  unsigned int D.26164;
  unsigned int D.26167;
  unsigned int D.26170;
  const char * D.26173;

  opcode.142 = (unsigned int) opcode;
  D.26145 = opcode.142 + 4294966846;
  if (D.26145 <= 4) goto <D.26146>; else goto <D.26147>;
  <D.26146>:
  D.26148 = 0;
  return D.26148;
  <D.26147>:
  opcode.142 = (unsigned int) opcode;
  D.26149 = opcode.142 + 4294966644;
  if (D.26149 <= 9) goto <D.26150>; else goto <D.26151>;
  <D.26150>:
  D.26148 = 1;
  return D.26148;
  <D.26151>:
  opcode.142 = (unsigned int) opcode;
  D.26152 = opcode.142 + 4294966654;
  if (D.26152 <= 4) goto <D.26153>; else goto <D.26154>;
  <D.26153>:
  D.26148 = 1;
  return D.26148;
  <D.26154>:
  opcode.142 = (unsigned int) opcode;
  D.26155 = opcode.142 + 4294966741;
  if (D.26155 <= 9) goto <D.26156>; else goto <D.26157>;
  <D.26156>:
  D.26148 = 0;
  return D.26148;
  <D.26157>:
  opcode.142 = (unsigned int) opcode;
  D.26158 = opcode.142 + 4294966761;
  if (D.26158 <= 4) goto <D.26159>; else goto <D.26160>;
  <D.26159>:
  D.26148 = 0;
  return D.26148;
  <D.26160>:
  opcode.142 = (unsigned int) opcode;
  D.26161 = opcode.142 + 4294966634;
  if (D.26161 <= 9) goto <D.26162>; else goto <D.26163>;
  <D.26162>:
  D.26148 = 2;
  return D.26148;
  <D.26163>:
  opcode.142 = (unsigned int) opcode;
  D.26164 = opcode.142 + 4294966578;
  if (D.26164 <= 4) goto <D.26165>; else goto <D.26166>;
  <D.26165>:
  D.26148 = 2;
  return D.26148;
  <D.26166>:
  opcode.142 = (unsigned int) opcode;
  D.26167 = opcode.142 + 4294966827;
  if (D.26167 <= 9) goto <D.26168>; else goto <D.26169>;
  <D.26168>:
  D.26148 = 1;
  return D.26148;
  <D.26169>:
  opcode.142 = (unsigned int) opcode;
  D.26170 = opcode.142 + 4294966841;
  if (D.26170 <= 9) goto <D.26171>; else goto <D.26172>;
  <D.26171>:
  switch (cmp_opcode) <default: <D.23721>, case 326: <D.23719>, case 327: <D.23720>>
  <D.23719>:
  <D.23720>:
  D.26148 = 1;
  return D.26148;
  <D.23721>:
  D.26148 = 0;
  return D.26148;
  <D.26172>:
  D.26173 = mono_inst_name (opcode);
  monoeg_g_log (0B, 4, "Unknown opcode \'%s\' in opcode_to_type", D.26173);
  <D.23722>:
  goto <D.23722>;
  D.26148 = 0;
  return D.26148;
}


mono_is_regsize_var (struct MonoType * t)
{
  unsigned char D.26175;
  unsigned char D.26176;
  gboolean D.26179;
  unsigned char D.26180;
  int D.26181;
  int D.26182;

  D.26175 = BIT_FIELD_REF <*t, 8, 56>;
  D.26176 = D.26175 & 64;
  if (D.26176 != 0) goto <D.26177>; else goto <D.26178>;
  <D.26177>:
  D.26179 = 1;
  return D.26179;
  <D.26178>:
  t = mono_type_get_underlying_type (t);
  D.26180 = t->type;
  D.26181 = (int) D.26180;
  switch (D.26181) <default: <D.23745>, case 2: <D.23726>, case 3: <D.23727>, case 4: <D.23728>, case 5: <D.23729>, case 6: <D.23730>, case 7: <D.23731>, case 8: <D.23732>, case 9: <D.23733>, case 14: <D.23739>, case 15: <D.23736>, case 17: <D.23744>, case 18: <D.23740>, case 20: <D.23742>, case 21: <D.23743>, case 24: <D.23734>, case 25: <D.23735>, case 27: <D.23737>, case 28: <D.23738>, case 29: <D.23741>>
  <D.23726>:
  <D.23727>:
  <D.23728>:
  <D.23729>:
  <D.23730>:
  <D.23731>:
  <D.23732>:
  <D.23733>:
  <D.23734>:
  <D.23735>:
  <D.23736>:
  <D.23737>:
  D.26179 = 1;
  return D.26179;
  <D.23738>:
  <D.23739>:
  <D.23740>:
  <D.23741>:
  <D.23742>:
  D.26179 = 1;
  return D.26179;
  <D.23743>:
  D.26182 = mono_type_generic_inst_is_valuetype (t);
  if (D.26182 == 0) goto <D.26183>; else goto <D.26184>;
  <D.26183>:
  D.26179 = 1;
  return D.26179;
  <D.26184>:
  D.26179 = 0;
  return D.26179;
  <D.23744>:
  D.26179 = 0;
  return D.26179;
  <D.23745>:
  D.26179 = 0;
  return D.26179;
}


mono_peephole_ins (struct MonoBasicBlock * bb, struct MonoInst * ins)
{
  short unsigned int D.26186;
  int D.26187;
  int D.26188;
  int D.26191;
  int D.26192;
  struct MonoInst * D.26196;
  struct MonoInst * D.26199;
  struct MonoInst * D.26202;
  struct MonoInst * D.26205;
  int D.26208;
  int D.26209;
  short unsigned int D.26212;
  int D.26222;
  int D.26225;
  int D.26226;
  int D.26229;
  short unsigned int D.26242;
  _Bool D.26243;
  _Bool D.26244;
  _Bool D.26245;
  guint16 iftmp.143;
  guint16 iftmp.144;
  struct MonoInst * last_ins;

  last_ins = ins->prev;
  D.26186 = ins->opcode;
  D.26187 = (int) D.26186;
  switch (D.26187) <default: <D.26323>, case 316: <D.23761>, case 391: <D.23753>, case 392: <D.23755>, case 393: <D.23756>, case 394: <D.23757>, case 395: <D.23758>, case 396: <D.23754>, case 428: <D.23759>, case 430: <D.23760>, case 435: <D.23751>>
  <D.23751>:
  D.26188 = ins->data.op[1].const_val;
  if (D.26188 == 1) goto <D.26189>; else goto <D.26190>;
  <D.26189>:
  D.26191 = ins->dreg;
  D.26192 = ins->sreg1;
  if (D.26191 != D.26192) goto <D.26193>; else goto <D.26194>;
  <D.26193>:
  ins->opcode = 428;
  goto <D.26195>;
  <D.26194>:
  D.26196 = ins->prev;
  if (D.26196 != 0B) goto <D.26197>; else goto <D.26198>;
  <D.26197>:
  D.26196 = ins->prev;
  D.26199 = ins->next;
  D.26196->next = D.26199;
  <D.26198>:
  D.26199 = ins->next;
  if (D.26199 != 0B) goto <D.26200>; else goto <D.26201>;
  <D.26200>:
  D.26199 = ins->next;
  D.26196 = ins->prev;
  D.26199->prev = D.26196;
  <D.26201>:
  D.26202 = bb->code;
  if (D.26202 == ins) goto <D.26203>; else goto <D.26204>;
  <D.26203>:
  D.26199 = ins->next;
  bb->code = D.26199;
  <D.26204>:
  D.26205 = bb->last_ins;
  if (D.26205 == ins) goto <D.26206>; else goto <D.26207>;
  <D.26206>:
  D.26196 = ins->prev;
  bb->last_ins = D.26196;
  <D.26207>:
  ins->opcode = 316;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.26208 = ins->sreg3;
  ins->sreg2 = D.26208;
  D.26209 = ins->sreg2;
  ins->sreg1 = D.26209;
  <D.26195>:
  <D.26190>:
  goto <D.23752>;
  <D.23753>:
  <D.23754>:
  if (last_ins != 0B) goto <D.26210>; else goto <D.26211>;
  <D.26210>:
  D.26212 = last_ins->opcode;
  if (D.26212 == 1000) goto <D.26213>; else goto <D.26214>;
  <D.26213>:
  last_ins = last_ins->prev;
  <D.26214>:
  <D.26211>:
  if (last_ins != 0B) goto <D.26218>; else goto <D.26219>;
  <D.26218>:
  D.26186 = ins->opcode;
  if (D.26186 == 396) goto <D.26220>; else goto <D.26215>;
  <D.26220>:
  D.26212 = last_ins->opcode;
  if (D.26212 == 377) goto <D.26216>; else goto <D.26215>;
  <D.26215>:
  D.26186 = ins->opcode;
  if (D.26186 == 391) goto <D.26221>; else goto <D.26217>;
  <D.26221>:
  D.26212 = last_ins->opcode;
  if (D.26212 == 374) goto <D.26216>; else goto <D.26217>;
  <D.26216>:
  D.26192 = ins->sreg1;
  D.26222 = last_ins->dreg;
  if (D.26192 == D.26222) goto <D.26223>; else goto <D.26224>;
  <D.26223>:
  D.26225 = ins->data.op[0].const_val;
  D.26226 = last_ins->data.op[0].const_val;
  if (D.26225 == D.26226) goto <D.26227>; else goto <D.26228>;
  <D.26227>:
  D.26191 = ins->dreg;
  D.26229 = last_ins->sreg1;
  if (D.26191 == D.26229) goto <D.26230>; else goto <D.26231>;
  <D.26230>:
  D.26196 = ins->prev;
  if (D.26196 != 0B) goto <D.26232>; else goto <D.26233>;
  <D.26232>:
  D.26196 = ins->prev;
  D.26199 = ins->next;
  D.26196->next = D.26199;
  <D.26233>:
  D.26199 = ins->next;
  if (D.26199 != 0B) goto <D.26234>; else goto <D.26235>;
  <D.26234>:
  D.26199 = ins->next;
  D.26196 = ins->prev;
  D.26199->prev = D.26196;
  <D.26235>:
  D.26202 = bb->code;
  if (D.26202 == ins) goto <D.26236>; else goto <D.26237>;
  <D.26236>:
  D.26199 = ins->next;
  bb->code = D.26199;
  <D.26237>:
  D.26205 = bb->last_ins;
  if (D.26205 == ins) goto <D.26238>; else goto <D.26239>;
  <D.26238>:
  D.26196 = ins->prev;
  bb->last_ins = D.26196;
  <D.26239>:
  ins->opcode = 316;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.26208 = ins->sreg3;
  ins->sreg2 = D.26208;
  D.26209 = ins->sreg2;
  ins->sreg1 = D.26209;
  goto <D.23752>;
  <D.26231>:
  ins->opcode = 428;
  D.26229 = last_ins->sreg1;
  ins->sreg1 = D.26229;
  <D.26228>:
  <D.26224>:
  <D.26217>:
  <D.26219>:
  if (last_ins != 0B) goto <D.26240>; else goto <D.26241>;
  <D.26240>:
  D.26242 = last_ins->opcode;
  D.26243 = D.26242 == 396;
  D.26244 = D.26242 == 391;
  D.26245 = D.26243 | D.26244;
  if (D.26245 != 0) goto <D.26246>; else goto <D.26247>;
  <D.26246>:
  D.26192 = ins->sreg1;
  D.26222 = last_ins->dreg;
  if (D.26192 != D.26222) goto <D.26248>; else goto <D.26249>;
  <D.26248>:
  D.26192 = ins->sreg1;
  D.26229 = last_ins->sreg1;
  if (D.26192 == D.26229) goto <D.26250>; else goto <D.26251>;
  <D.26250>:
  D.26225 = ins->data.op[0].const_val;
  D.26226 = last_ins->data.op[0].const_val;
  if (D.26225 == D.26226) goto <D.26252>; else goto <D.26253>;
  <D.26252>:
  D.26191 = ins->dreg;
  D.26222 = last_ins->dreg;
  if (D.26191 == D.26222) goto <D.26254>; else goto <D.26255>;
  <D.26254>:
  D.26196 = ins->prev;
  if (D.26196 != 0B) goto <D.26256>; else goto <D.26257>;
  <D.26256>:
  D.26196 = ins->prev;
  D.26199 = ins->next;
  D.26196->next = D.26199;
  <D.26257>:
  D.26199 = ins->next;
  if (D.26199 != 0B) goto <D.26258>; else goto <D.26259>;
  <D.26258>:
  D.26199 = ins->next;
  D.26196 = ins->prev;
  D.26199->prev = D.26196;
  <D.26259>:
  D.26202 = bb->code;
  if (D.26202 == ins) goto <D.26260>; else goto <D.26261>;
  <D.26260>:
  D.26199 = ins->next;
  bb->code = D.26199;
  <D.26261>:
  D.26205 = bb->last_ins;
  if (D.26205 == ins) goto <D.26262>; else goto <D.26263>;
  <D.26262>:
  D.26196 = ins->prev;
  bb->last_ins = D.26196;
  <D.26263>:
  ins->opcode = 316;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.26208 = ins->sreg3;
  ins->sreg2 = D.26208;
  D.26209 = ins->sreg2;
  ins->sreg1 = D.26209;
  goto <D.26264>;
  <D.26255>:
  ins->opcode = 428;
  D.26222 = last_ins->dreg;
  ins->sreg1 = D.26222;
  <D.26264>:
  <D.26253>:
  <D.26251>:
  <D.26249>:
  <D.26247>:
  <D.26241>:
  goto <D.23752>;
  <D.23755>:
  <D.23756>:
  if (last_ins != 0B) goto <D.26265>; else goto <D.26266>;
  <D.26265>:
  D.26212 = last_ins->opcode;
  if (D.26212 == 375) goto <D.26267>; else goto <D.26268>;
  <D.26267>:
  D.26192 = ins->sreg1;
  D.26222 = last_ins->dreg;
  if (D.26192 == D.26222) goto <D.26269>; else goto <D.26270>;
  <D.26269>:
  D.26225 = ins->data.op[0].const_val;
  D.26226 = last_ins->data.op[0].const_val;
  if (D.26225 == D.26226) goto <D.26271>; else goto <D.26272>;
  <D.26271>:
  D.26186 = ins->opcode;
  if (D.26186 == 392) goto <D.26274>; else goto <D.26275>;
  <D.26274>:
  iftmp.143 = 584;
  goto <D.26276>;
  <D.26275>:
  iftmp.143 = 595;
  <D.26276>:
  ins->opcode = iftmp.143;
  D.26229 = last_ins->sreg1;
  ins->sreg1 = D.26229;
  <D.26272>:
  <D.26270>:
  <D.26268>:
  <D.26266>:
  goto <D.23752>;
  <D.23757>:
  <D.23758>:
  if (last_ins != 0B) goto <D.26277>; else goto <D.26278>;
  <D.26277>:
  D.26212 = last_ins->opcode;
  if (D.26212 == 376) goto <D.26279>; else goto <D.26280>;
  <D.26279>:
  D.26192 = ins->sreg1;
  D.26222 = last_ins->dreg;
  if (D.26192 == D.26222) goto <D.26281>; else goto <D.26282>;
  <D.26281>:
  D.26225 = ins->data.op[0].const_val;
  D.26226 = last_ins->data.op[0].const_val;
  if (D.26225 == D.26226) goto <D.26283>; else goto <D.26284>;
  <D.26283>:
  D.26186 = ins->opcode;
  if (D.26186 == 394) goto <D.26286>; else goto <D.26287>;
  <D.26286>:
  iftmp.144 = 585;
  goto <D.26288>;
  <D.26287>:
  iftmp.144 = 594;
  <D.26288>:
  ins->opcode = iftmp.144;
  D.26229 = last_ins->sreg1;
  ins->sreg1 = D.26229;
  <D.26284>:
  <D.26282>:
  <D.26280>:
  <D.26278>:
  goto <D.23752>;
  <D.23759>:
  <D.23760>:
  D.26191 = ins->dreg;
  D.26192 = ins->sreg1;
  if (D.26191 == D.26192) goto <D.26289>; else goto <D.26290>;
  <D.26289>:
  D.26196 = ins->prev;
  if (D.26196 != 0B) goto <D.26291>; else goto <D.26292>;
  <D.26291>:
  D.26196 = ins->prev;
  D.26199 = ins->next;
  D.26196->next = D.26199;
  <D.26292>:
  D.26199 = ins->next;
  if (D.26199 != 0B) goto <D.26293>; else goto <D.26294>;
  <D.26293>:
  D.26199 = ins->next;
  D.26196 = ins->prev;
  D.26199->prev = D.26196;
  <D.26294>:
  D.26202 = bb->code;
  if (D.26202 == ins) goto <D.26295>; else goto <D.26296>;
  <D.26295>:
  D.26199 = ins->next;
  bb->code = D.26199;
  <D.26296>:
  D.26205 = bb->last_ins;
  if (D.26205 == ins) goto <D.26297>; else goto <D.26298>;
  <D.26297>:
  D.26196 = ins->prev;
  bb->last_ins = D.26196;
  <D.26298>:
  ins->opcode = 316;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.26208 = ins->sreg3;
  ins->sreg2 = D.26208;
  D.26209 = ins->sreg2;
  ins->sreg1 = D.26209;
  goto <D.23752>;
  <D.26290>:
  if (last_ins != 0B) goto <D.26299>; else goto <D.26300>;
  <D.26299>:
  D.26212 = last_ins->opcode;
  D.26186 = ins->opcode;
  if (D.26212 == D.26186) goto <D.26301>; else goto <D.26302>;
  <D.26301>:
  D.26192 = ins->sreg1;
  D.26222 = last_ins->dreg;
  if (D.26192 == D.26222) goto <D.26303>; else goto <D.26304>;
  <D.26303>:
  D.26191 = ins->dreg;
  D.26229 = last_ins->sreg1;
  if (D.26191 == D.26229) goto <D.26305>; else goto <D.26306>;
  <D.26305>:
  D.26196 = ins->prev;
  if (D.26196 != 0B) goto <D.26307>; else goto <D.26308>;
  <D.26307>:
  D.26196 = ins->prev;
  D.26199 = ins->next;
  D.26196->next = D.26199;
  <D.26308>:
  D.26199 = ins->next;
  if (D.26199 != 0B) goto <D.26309>; else goto <D.26310>;
  <D.26309>:
  D.26199 = ins->next;
  D.26196 = ins->prev;
  D.26199->prev = D.26196;
  <D.26310>:
  D.26202 = bb->code;
  if (D.26202 == ins) goto <D.26311>; else goto <D.26312>;
  <D.26311>:
  D.26199 = ins->next;
  bb->code = D.26199;
  <D.26312>:
  D.26205 = bb->last_ins;
  if (D.26205 == ins) goto <D.26313>; else goto <D.26314>;
  <D.26313>:
  D.26196 = ins->prev;
  bb->last_ins = D.26196;
  <D.26314>:
  ins->opcode = 316;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.26208 = ins->sreg3;
  ins->sreg2 = D.26208;
  D.26209 = ins->sreg2;
  ins->sreg1 = D.26209;
  <D.26306>:
  <D.26304>:
  <D.26302>:
  <D.26300>:
  goto <D.23752>;
  <D.23761>:
  D.26196 = ins->prev;
  if (D.26196 != 0B) goto <D.26315>; else goto <D.26316>;
  <D.26315>:
  D.26196 = ins->prev;
  D.26199 = ins->next;
  D.26196->next = D.26199;
  <D.26316>:
  D.26199 = ins->next;
  if (D.26199 != 0B) goto <D.26317>; else goto <D.26318>;
  <D.26317>:
  D.26199 = ins->next;
  D.26196 = ins->prev;
  D.26199->prev = D.26196;
  <D.26318>:
  D.26202 = bb->code;
  if (D.26202 == ins) goto <D.26319>; else goto <D.26320>;
  <D.26319>:
  D.26199 = ins->next;
  bb->code = D.26199;
  <D.26320>:
  D.26205 = bb->last_ins;
  if (D.26205 == ins) goto <D.26321>; else goto <D.26322>;
  <D.26321>:
  D.26196 = ins->prev;
  bb->last_ins = D.26196;
  <D.26322>:
  ins->opcode = 316;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.26208 = ins->sreg3;
  ins->sreg2 = D.26208;
  D.26209 = ins->sreg2;
  ins->sreg1 = D.26209;
  goto <D.23752>;
  <D.26323>:
  <D.23752>:
}


mini_exception_id_by_name (const char * name)
{
  int D.23773;
  int iftmp.145;
  int D.23772;
  const char[25] * D.26327;
  unsigned char D.26328;
  int D.26329;
  unsigned char D.26330;
  int D.26331;
  _Bool D.26332;
  _Bool D.26333;
  _Bool D.26334;
  const unsigned char * D.26337;
  unsigned char D.26338;
  int D.26339;
  const unsigned char * D.26340;
  unsigned char D.26341;
  int D.26342;
  _Bool D.26343;
  _Bool D.26344;
  const unsigned char * D.26347;
  unsigned char D.26348;
  int D.26349;
  const unsigned char * D.26350;
  unsigned char D.26351;
  int D.26352;
  _Bool D.26353;
  _Bool D.26354;
  const unsigned char * D.26357;
  unsigned char D.26358;
  int D.26359;
  const unsigned char * D.26360;
  unsigned char D.26361;
  int D.26362;
  int D.26366;
  int D.23782;
  int iftmp.146;
  int D.23781;
  const char[18] * D.26370;
  unsigned char D.26371;
  int D.26372;
  unsigned char D.26373;
  int D.26374;
  _Bool D.26375;
  _Bool D.26376;
  _Bool D.26377;
  const unsigned char * D.26380;
  unsigned char D.26381;
  int D.26382;
  const unsigned char * D.26383;
  unsigned char D.26384;
  int D.26385;
  _Bool D.26386;
  _Bool D.26387;
  const unsigned char * D.26390;
  unsigned char D.26391;
  int D.26392;
  const unsigned char * D.26393;
  unsigned char D.26394;
  int D.26395;
  _Bool D.26396;
  _Bool D.26397;
  const unsigned char * D.26400;
  unsigned char D.26401;
  int D.26402;
  const unsigned char * D.26403;
  unsigned char D.26404;
  int D.26405;
  int D.23791;
  int iftmp.147;
  int D.23790;
  const char[20] * D.26412;
  unsigned char D.26413;
  int D.26414;
  unsigned char D.26415;
  int D.26416;
  _Bool D.26417;
  _Bool D.26418;
  _Bool D.26419;
  const unsigned char * D.26422;
  unsigned char D.26423;
  int D.26424;
  const unsigned char * D.26425;
  unsigned char D.26426;
  int D.26427;
  _Bool D.26428;
  _Bool D.26429;
  const unsigned char * D.26432;
  unsigned char D.26433;
  int D.26434;
  const unsigned char * D.26435;
  unsigned char D.26436;
  int D.26437;
  _Bool D.26438;
  _Bool D.26439;
  const unsigned char * D.26442;
  unsigned char D.26443;
  int D.26444;
  const unsigned char * D.26445;
  unsigned char D.26446;
  int D.26447;
  int D.23800;
  int iftmp.148;
  int D.23799;
  const char[22] * D.26454;
  unsigned char D.26455;
  int D.26456;
  unsigned char D.26457;
  int D.26458;
  _Bool D.26459;
  _Bool D.26460;
  _Bool D.26461;
  const unsigned char * D.26464;
  unsigned char D.26465;
  int D.26466;
  const unsigned char * D.26467;
  unsigned char D.26468;
  int D.26469;
  _Bool D.26470;
  _Bool D.26471;
  const unsigned char * D.26474;
  unsigned char D.26475;
  int D.26476;
  const unsigned char * D.26477;
  unsigned char D.26478;
  int D.26479;
  _Bool D.26480;
  _Bool D.26481;
  const unsigned char * D.26484;
  unsigned char D.26485;
  int D.26486;
  const unsigned char * D.26487;
  unsigned char D.26488;
  int D.26489;
  int D.23809;
  int iftmp.149;
  int D.23808;
  const char[21] * D.26496;
  unsigned char D.26497;
  int D.26498;
  unsigned char D.26499;
  int D.26500;
  _Bool D.26501;
  _Bool D.26502;
  _Bool D.26503;
  const unsigned char * D.26506;
  unsigned char D.26507;
  int D.26508;
  const unsigned char * D.26509;
  unsigned char D.26510;
  int D.26511;
  _Bool D.26512;
  _Bool D.26513;
  const unsigned char * D.26516;
  unsigned char D.26517;
  int D.26518;
  const unsigned char * D.26519;
  unsigned char D.26520;
  int D.26521;
  _Bool D.26522;
  _Bool D.26523;
  const unsigned char * D.26526;
  unsigned char D.26527;
  int D.26528;
  const unsigned char * D.26529;
  unsigned char D.26530;
  int D.26531;
  int D.23818;
  int iftmp.150;
  int D.23817;
  const char[23] * D.26538;
  unsigned char D.26539;
  int D.26540;
  unsigned char D.26541;
  int D.26542;
  _Bool D.26543;
  _Bool D.26544;
  _Bool D.26545;
  const unsigned char * D.26548;
  unsigned char D.26549;
  int D.26550;
  const unsigned char * D.26551;
  unsigned char D.26552;
  int D.26553;
  _Bool D.26554;
  _Bool D.26555;
  const unsigned char * D.26558;
  unsigned char D.26559;
  int D.26560;
  const unsigned char * D.26561;
  unsigned char D.26562;
  int D.26563;
  _Bool D.26564;
  _Bool D.26565;
  const unsigned char * D.26568;
  unsigned char D.26569;
  int D.26570;
  const unsigned char * D.26571;
  unsigned char D.26572;
  int D.26573;
  int D.23827;
  int iftmp.151;
  int D.23826;
  const char[27] * D.26580;
  unsigned char D.26581;
  int D.26582;
  unsigned char D.26583;
  int D.26584;
  _Bool D.26585;
  _Bool D.26586;
  _Bool D.26587;
  const unsigned char * D.26590;
  unsigned char D.26591;
  int D.26592;
  const unsigned char * D.26593;
  unsigned char D.26594;
  int D.26595;
  _Bool D.26596;
  _Bool D.26597;
  const unsigned char * D.26600;
  unsigned char D.26601;
  int D.26602;
  const unsigned char * D.26603;
  unsigned char D.26604;
  int D.26605;
  _Bool D.26606;
  _Bool D.26607;
  const unsigned char * D.26610;
  unsigned char D.26611;
  int D.26612;
  const unsigned char * D.26613;
  unsigned char D.26614;
  int D.26615;
  int D.23836;
  int iftmp.152;
  int D.23835;
  const char[18] * D.26622;
  unsigned char D.26623;
  int D.26624;
  unsigned char D.26625;
  int D.26626;
  _Bool D.26627;
  _Bool D.26628;
  _Bool D.26629;
  const unsigned char * D.26632;
  unsigned char D.26633;
  int D.26634;
  const unsigned char * D.26635;
  unsigned char D.26636;
  int D.26637;
  _Bool D.26638;
  _Bool D.26639;
  const unsigned char * D.26642;
  unsigned char D.26643;
  int D.26644;
  const unsigned char * D.26645;
  unsigned char D.26646;
  int D.26647;
  _Bool D.26648;
  _Bool D.26649;
  const unsigned char * D.26652;
  unsigned char D.26653;
  int D.26654;
  const unsigned char * D.26655;
  unsigned char D.26656;
  int D.26657;

  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 24;
    if (__s2_len <= 3) goto <D.26325>; else goto <D.26326>;
    <D.26325>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = name;
      D.26327 = "IndexOutOfRangeException";
      D.26328 = MEM[(const unsigned char *)D.26327];
      D.26329 = (int) D.26328;
      D.26330 = *__s2;
      D.26331 = (int) D.26330;
      __result = D.26329 - D.26331;
      {
        D.26332 = __s2_len != 0;
        D.26333 = __result == 0;
        D.26334 = D.26332 & D.26333;
        if (D.26334 != 0) goto <D.26335>; else goto <D.26336>;
        <D.26335>:
        D.26337 = &MEM[(void *)"IndexOutOfRangeException" + 1B];
        D.26338 = *D.26337;
        D.26339 = (int) D.26338;
        D.26340 = __s2 + 1;
        D.26341 = *D.26340;
        D.26342 = (int) D.26341;
        __result = D.26339 - D.26342;
        D.26343 = __s2_len > 1;
        D.26333 = __result == 0;
        D.26344 = D.26343 & D.26333;
        if (D.26344 != 0) goto <D.26345>; else goto <D.26346>;
        <D.26345>:
        D.26347 = &MEM[(void *)"IndexOutOfRangeException" + 2B];
        D.26348 = *D.26347;
        D.26349 = (int) D.26348;
        D.26350 = __s2 + 2;
        D.26351 = *D.26350;
        D.26352 = (int) D.26351;
        __result = D.26349 - D.26352;
        D.26353 = __s2_len > 2;
        D.26333 = __result == 0;
        D.26354 = D.26353 & D.26333;
        if (D.26354 != 0) goto <D.26355>; else goto <D.26356>;
        <D.26355>:
        D.26357 = &MEM[(void *)"IndexOutOfRangeException" + 3B];
        D.26358 = *D.26357;
        D.26359 = (int) D.26358;
        D.26360 = __s2 + 3;
        D.26361 = *D.26360;
        D.26362 = (int) D.26361;
        __result = D.26359 - D.26362;
        <D.26356>:
        <D.26346>:
        <D.26336>:
      }
      D.23772 = __result;
    }
    iftmp.145 = -D.23772;
    goto <D.26363>;
    <D.26326>:
    iftmp.145 = __builtin_strcmp (name, "IndexOutOfRangeException");
    <D.26363>:
    D.23773 = iftmp.145;
  }
  if (D.23773 == 0) goto <D.26364>; else goto <D.26365>;
  <D.26364>:
  D.26366 = 0;
  return D.26366;
  <D.26365>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 17;
    if (__s2_len <= 3) goto <D.26368>; else goto <D.26369>;
    <D.26368>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = name;
      D.26370 = "OverflowException";
      D.26371 = MEM[(const unsigned char *)D.26370];
      D.26372 = (int) D.26371;
      D.26373 = *__s2;
      D.26374 = (int) D.26373;
      __result = D.26372 - D.26374;
      {
        D.26375 = __s2_len != 0;
        D.26376 = __result == 0;
        D.26377 = D.26375 & D.26376;
        if (D.26377 != 0) goto <D.26378>; else goto <D.26379>;
        <D.26378>:
        D.26380 = &MEM[(void *)"OverflowException" + 1B];
        D.26381 = *D.26380;
        D.26382 = (int) D.26381;
        D.26383 = __s2 + 1;
        D.26384 = *D.26383;
        D.26385 = (int) D.26384;
        __result = D.26382 - D.26385;
        D.26386 = __s2_len > 1;
        D.26376 = __result == 0;
        D.26387 = D.26386 & D.26376;
        if (D.26387 != 0) goto <D.26388>; else goto <D.26389>;
        <D.26388>:
        D.26390 = &MEM[(void *)"OverflowException" + 2B];
        D.26391 = *D.26390;
        D.26392 = (int) D.26391;
        D.26393 = __s2 + 2;
        D.26394 = *D.26393;
        D.26395 = (int) D.26394;
        __result = D.26392 - D.26395;
        D.26396 = __s2_len > 2;
        D.26376 = __result == 0;
        D.26397 = D.26396 & D.26376;
        if (D.26397 != 0) goto <D.26398>; else goto <D.26399>;
        <D.26398>:
        D.26400 = &MEM[(void *)"OverflowException" + 3B];
        D.26401 = *D.26400;
        D.26402 = (int) D.26401;
        D.26403 = __s2 + 3;
        D.26404 = *D.26403;
        D.26405 = (int) D.26404;
        __result = D.26402 - D.26405;
        <D.26399>:
        <D.26389>:
        <D.26379>:
      }
      D.23781 = __result;
    }
    iftmp.146 = -D.23781;
    goto <D.26406>;
    <D.26369>:
    iftmp.146 = __builtin_strcmp (name, "OverflowException");
    <D.26406>:
    D.23782 = iftmp.146;
  }
  if (D.23782 == 0) goto <D.26407>; else goto <D.26408>;
  <D.26407>:
  D.26366 = 1;
  return D.26366;
  <D.26408>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 19;
    if (__s2_len <= 3) goto <D.26410>; else goto <D.26411>;
    <D.26410>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = name;
      D.26412 = "ArithmeticException";
      D.26413 = MEM[(const unsigned char *)D.26412];
      D.26414 = (int) D.26413;
      D.26415 = *__s2;
      D.26416 = (int) D.26415;
      __result = D.26414 - D.26416;
      {
        D.26417 = __s2_len != 0;
        D.26418 = __result == 0;
        D.26419 = D.26417 & D.26418;
        if (D.26419 != 0) goto <D.26420>; else goto <D.26421>;
        <D.26420>:
        D.26422 = &MEM[(void *)"ArithmeticException" + 1B];
        D.26423 = *D.26422;
        D.26424 = (int) D.26423;
        D.26425 = __s2 + 1;
        D.26426 = *D.26425;
        D.26427 = (int) D.26426;
        __result = D.26424 - D.26427;
        D.26428 = __s2_len > 1;
        D.26418 = __result == 0;
        D.26429 = D.26428 & D.26418;
        if (D.26429 != 0) goto <D.26430>; else goto <D.26431>;
        <D.26430>:
        D.26432 = &MEM[(void *)"ArithmeticException" + 2B];
        D.26433 = *D.26432;
        D.26434 = (int) D.26433;
        D.26435 = __s2 + 2;
        D.26436 = *D.26435;
        D.26437 = (int) D.26436;
        __result = D.26434 - D.26437;
        D.26438 = __s2_len > 2;
        D.26418 = __result == 0;
        D.26439 = D.26438 & D.26418;
        if (D.26439 != 0) goto <D.26440>; else goto <D.26441>;
        <D.26440>:
        D.26442 = &MEM[(void *)"ArithmeticException" + 3B];
        D.26443 = *D.26442;
        D.26444 = (int) D.26443;
        D.26445 = __s2 + 3;
        D.26446 = *D.26445;
        D.26447 = (int) D.26446;
        __result = D.26444 - D.26447;
        <D.26441>:
        <D.26431>:
        <D.26421>:
      }
      D.23790 = __result;
    }
    iftmp.147 = -D.23790;
    goto <D.26448>;
    <D.26411>:
    iftmp.147 = __builtin_strcmp (name, "ArithmeticException");
    <D.26448>:
    D.23791 = iftmp.147;
  }
  if (D.23791 == 0) goto <D.26449>; else goto <D.26450>;
  <D.26449>:
  D.26366 = 2;
  return D.26366;
  <D.26450>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 21;
    if (__s2_len <= 3) goto <D.26452>; else goto <D.26453>;
    <D.26452>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = name;
      D.26454 = "DivideByZeroException";
      D.26455 = MEM[(const unsigned char *)D.26454];
      D.26456 = (int) D.26455;
      D.26457 = *__s2;
      D.26458 = (int) D.26457;
      __result = D.26456 - D.26458;
      {
        D.26459 = __s2_len != 0;
        D.26460 = __result == 0;
        D.26461 = D.26459 & D.26460;
        if (D.26461 != 0) goto <D.26462>; else goto <D.26463>;
        <D.26462>:
        D.26464 = &MEM[(void *)"DivideByZeroException" + 1B];
        D.26465 = *D.26464;
        D.26466 = (int) D.26465;
        D.26467 = __s2 + 1;
        D.26468 = *D.26467;
        D.26469 = (int) D.26468;
        __result = D.26466 - D.26469;
        D.26470 = __s2_len > 1;
        D.26460 = __result == 0;
        D.26471 = D.26470 & D.26460;
        if (D.26471 != 0) goto <D.26472>; else goto <D.26473>;
        <D.26472>:
        D.26474 = &MEM[(void *)"DivideByZeroException" + 2B];
        D.26475 = *D.26474;
        D.26476 = (int) D.26475;
        D.26477 = __s2 + 2;
        D.26478 = *D.26477;
        D.26479 = (int) D.26478;
        __result = D.26476 - D.26479;
        D.26480 = __s2_len > 2;
        D.26460 = __result == 0;
        D.26481 = D.26480 & D.26460;
        if (D.26481 != 0) goto <D.26482>; else goto <D.26483>;
        <D.26482>:
        D.26484 = &MEM[(void *)"DivideByZeroException" + 3B];
        D.26485 = *D.26484;
        D.26486 = (int) D.26485;
        D.26487 = __s2 + 3;
        D.26488 = *D.26487;
        D.26489 = (int) D.26488;
        __result = D.26486 - D.26489;
        <D.26483>:
        <D.26473>:
        <D.26463>:
      }
      D.23799 = __result;
    }
    iftmp.148 = -D.23799;
    goto <D.26490>;
    <D.26453>:
    iftmp.148 = __builtin_strcmp (name, "DivideByZeroException");
    <D.26490>:
    D.23800 = iftmp.148;
  }
  if (D.23800 == 0) goto <D.26491>; else goto <D.26492>;
  <D.26491>:
  D.26366 = 3;
  return D.26366;
  <D.26492>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 20;
    if (__s2_len <= 3) goto <D.26494>; else goto <D.26495>;
    <D.26494>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = name;
      D.26496 = "InvalidCastException";
      D.26497 = MEM[(const unsigned char *)D.26496];
      D.26498 = (int) D.26497;
      D.26499 = *__s2;
      D.26500 = (int) D.26499;
      __result = D.26498 - D.26500;
      {
        D.26501 = __s2_len != 0;
        D.26502 = __result == 0;
        D.26503 = D.26501 & D.26502;
        if (D.26503 != 0) goto <D.26504>; else goto <D.26505>;
        <D.26504>:
        D.26506 = &MEM[(void *)"InvalidCastException" + 1B];
        D.26507 = *D.26506;
        D.26508 = (int) D.26507;
        D.26509 = __s2 + 1;
        D.26510 = *D.26509;
        D.26511 = (int) D.26510;
        __result = D.26508 - D.26511;
        D.26512 = __s2_len > 1;
        D.26502 = __result == 0;
        D.26513 = D.26512 & D.26502;
        if (D.26513 != 0) goto <D.26514>; else goto <D.26515>;
        <D.26514>:
        D.26516 = &MEM[(void *)"InvalidCastException" + 2B];
        D.26517 = *D.26516;
        D.26518 = (int) D.26517;
        D.26519 = __s2 + 2;
        D.26520 = *D.26519;
        D.26521 = (int) D.26520;
        __result = D.26518 - D.26521;
        D.26522 = __s2_len > 2;
        D.26502 = __result == 0;
        D.26523 = D.26522 & D.26502;
        if (D.26523 != 0) goto <D.26524>; else goto <D.26525>;
        <D.26524>:
        D.26526 = &MEM[(void *)"InvalidCastException" + 3B];
        D.26527 = *D.26526;
        D.26528 = (int) D.26527;
        D.26529 = __s2 + 3;
        D.26530 = *D.26529;
        D.26531 = (int) D.26530;
        __result = D.26528 - D.26531;
        <D.26525>:
        <D.26515>:
        <D.26505>:
      }
      D.23808 = __result;
    }
    iftmp.149 = -D.23808;
    goto <D.26532>;
    <D.26495>:
    iftmp.149 = __builtin_strcmp (name, "InvalidCastException");
    <D.26532>:
    D.23809 = iftmp.149;
  }
  if (D.23809 == 0) goto <D.26533>; else goto <D.26534>;
  <D.26533>:
  D.26366 = 4;
  return D.26366;
  <D.26534>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 22;
    if (__s2_len <= 3) goto <D.26536>; else goto <D.26537>;
    <D.26536>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = name;
      D.26538 = "NullReferenceException";
      D.26539 = MEM[(const unsigned char *)D.26538];
      D.26540 = (int) D.26539;
      D.26541 = *__s2;
      D.26542 = (int) D.26541;
      __result = D.26540 - D.26542;
      {
        D.26543 = __s2_len != 0;
        D.26544 = __result == 0;
        D.26545 = D.26543 & D.26544;
        if (D.26545 != 0) goto <D.26546>; else goto <D.26547>;
        <D.26546>:
        D.26548 = &MEM[(void *)"NullReferenceException" + 1B];
        D.26549 = *D.26548;
        D.26550 = (int) D.26549;
        D.26551 = __s2 + 1;
        D.26552 = *D.26551;
        D.26553 = (int) D.26552;
        __result = D.26550 - D.26553;
        D.26554 = __s2_len > 1;
        D.26544 = __result == 0;
        D.26555 = D.26554 & D.26544;
        if (D.26555 != 0) goto <D.26556>; else goto <D.26557>;
        <D.26556>:
        D.26558 = &MEM[(void *)"NullReferenceException" + 2B];
        D.26559 = *D.26558;
        D.26560 = (int) D.26559;
        D.26561 = __s2 + 2;
        D.26562 = *D.26561;
        D.26563 = (int) D.26562;
        __result = D.26560 - D.26563;
        D.26564 = __s2_len > 2;
        D.26544 = __result == 0;
        D.26565 = D.26564 & D.26544;
        if (D.26565 != 0) goto <D.26566>; else goto <D.26567>;
        <D.26566>:
        D.26568 = &MEM[(void *)"NullReferenceException" + 3B];
        D.26569 = *D.26568;
        D.26570 = (int) D.26569;
        D.26571 = __s2 + 3;
        D.26572 = *D.26571;
        D.26573 = (int) D.26572;
        __result = D.26570 - D.26573;
        <D.26567>:
        <D.26557>:
        <D.26547>:
      }
      D.23817 = __result;
    }
    iftmp.150 = -D.23817;
    goto <D.26574>;
    <D.26537>:
    iftmp.150 = __builtin_strcmp (name, "NullReferenceException");
    <D.26574>:
    D.23818 = iftmp.150;
  }
  if (D.23818 == 0) goto <D.26575>; else goto <D.26576>;
  <D.26575>:
  D.26366 = 5;
  return D.26366;
  <D.26576>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 26;
    if (__s2_len <= 3) goto <D.26578>; else goto <D.26579>;
    <D.26578>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = name;
      D.26580 = "ArrayTypeMismatchException";
      D.26581 = MEM[(const unsigned char *)D.26580];
      D.26582 = (int) D.26581;
      D.26583 = *__s2;
      D.26584 = (int) D.26583;
      __result = D.26582 - D.26584;
      {
        D.26585 = __s2_len != 0;
        D.26586 = __result == 0;
        D.26587 = D.26585 & D.26586;
        if (D.26587 != 0) goto <D.26588>; else goto <D.26589>;
        <D.26588>:
        D.26590 = &MEM[(void *)"ArrayTypeMismatchException" + 1B];
        D.26591 = *D.26590;
        D.26592 = (int) D.26591;
        D.26593 = __s2 + 1;
        D.26594 = *D.26593;
        D.26595 = (int) D.26594;
        __result = D.26592 - D.26595;
        D.26596 = __s2_len > 1;
        D.26586 = __result == 0;
        D.26597 = D.26596 & D.26586;
        if (D.26597 != 0) goto <D.26598>; else goto <D.26599>;
        <D.26598>:
        D.26600 = &MEM[(void *)"ArrayTypeMismatchException" + 2B];
        D.26601 = *D.26600;
        D.26602 = (int) D.26601;
        D.26603 = __s2 + 2;
        D.26604 = *D.26603;
        D.26605 = (int) D.26604;
        __result = D.26602 - D.26605;
        D.26606 = __s2_len > 2;
        D.26586 = __result == 0;
        D.26607 = D.26606 & D.26586;
        if (D.26607 != 0) goto <D.26608>; else goto <D.26609>;
        <D.26608>:
        D.26610 = &MEM[(void *)"ArrayTypeMismatchException" + 3B];
        D.26611 = *D.26610;
        D.26612 = (int) D.26611;
        D.26613 = __s2 + 3;
        D.26614 = *D.26613;
        D.26615 = (int) D.26614;
        __result = D.26612 - D.26615;
        <D.26609>:
        <D.26599>:
        <D.26589>:
      }
      D.23826 = __result;
    }
    iftmp.151 = -D.23826;
    goto <D.26616>;
    <D.26579>:
    iftmp.151 = __builtin_strcmp (name, "ArrayTypeMismatchException");
    <D.26616>:
    D.23827 = iftmp.151;
  }
  if (D.23827 == 0) goto <D.26617>; else goto <D.26618>;
  <D.26617>:
  D.26366 = 6;
  return D.26366;
  <D.26618>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 17;
    if (__s2_len <= 3) goto <D.26620>; else goto <D.26621>;
    <D.26620>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = name;
      D.26622 = "ArgumentException";
      D.26623 = MEM[(const unsigned char *)D.26622];
      D.26624 = (int) D.26623;
      D.26625 = *__s2;
      D.26626 = (int) D.26625;
      __result = D.26624 - D.26626;
      {
        D.26627 = __s2_len != 0;
        D.26628 = __result == 0;
        D.26629 = D.26627 & D.26628;
        if (D.26629 != 0) goto <D.26630>; else goto <D.26631>;
        <D.26630>:
        D.26632 = &MEM[(void *)"ArgumentException" + 1B];
        D.26633 = *D.26632;
        D.26634 = (int) D.26633;
        D.26635 = __s2 + 1;
        D.26636 = *D.26635;
        D.26637 = (int) D.26636;
        __result = D.26634 - D.26637;
        D.26638 = __s2_len > 1;
        D.26628 = __result == 0;
        D.26639 = D.26638 & D.26628;
        if (D.26639 != 0) goto <D.26640>; else goto <D.26641>;
        <D.26640>:
        D.26642 = &MEM[(void *)"ArgumentException" + 2B];
        D.26643 = *D.26642;
        D.26644 = (int) D.26643;
        D.26645 = __s2 + 2;
        D.26646 = *D.26645;
        D.26647 = (int) D.26646;
        __result = D.26644 - D.26647;
        D.26648 = __s2_len > 2;
        D.26628 = __result == 0;
        D.26649 = D.26648 & D.26628;
        if (D.26649 != 0) goto <D.26650>; else goto <D.26651>;
        <D.26650>:
        D.26652 = &MEM[(void *)"ArgumentException" + 3B];
        D.26653 = *D.26652;
        D.26654 = (int) D.26653;
        D.26655 = __s2 + 3;
        D.26656 = *D.26655;
        D.26657 = (int) D.26656;
        __result = D.26654 - D.26657;
        <D.26651>:
        <D.26641>:
        <D.26631>:
      }
      D.23835 = __result;
    }
    iftmp.152 = -D.23835;
    goto <D.26658>;
    <D.26621>:
    iftmp.152 = __builtin_strcmp (name, "ArgumentException");
    <D.26658>:
    D.23836 = iftmp.152;
  }
  if (D.23836 == 0) goto <D.26659>; else goto <D.26660>;
  <D.26659>:
  D.26366 = 7;
  return D.26366;
  <D.26660>:
  monoeg_g_log (0B, 4, "Unknown intrinsic exception %s\n", name);
  <D.23837>:
  goto <D.23837>;
  D.26366 = -1;
  return D.26366;
}