mono_regname_full (int reg, int bank)
{
  _Bool D.24141;
  long int D.24142;
  long int D.24143;
  const char * D.24148;
  unsigned int bank.0;
  unsigned int D.24150;
  _Bool D.24153;
  long int D.24154;
  long int D.24155;

  D.24141 = bank != 0;
  D.24142 = (long int) D.24141;
  D.24143 = __builtin_expect (D.24142, 0);
  if (D.24143 != 0) goto <D.24144>; else goto <D.24145>;
  <D.24144>:
  if (bank == 4) goto <D.24146>; else goto <D.24147>;
  <D.24146>:
  D.24148 = mono_arch_xregname (reg);
  return D.24148;
  <D.24147>:
  bank.0 = (unsigned int) bank;
  D.24150 = bank.0 + 4294967294;
  if (D.24150 <= 1) goto <D.24151>; else goto <D.24152>;
  <D.24151>:
  D.24148 = mono_arch_regname (reg);
  return D.24148;
  <D.24152>:
  D.24153 = bank != 1;
  D.24154 = (long int) D.24153;
  D.24155 = __builtin_expect (D.24154, 0);
  if (D.24155 != 0) goto <D.24156>; else goto <D.24157>;
  <D.24156>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 248, "bank == MONO_REG_DOUBLE");
  <D.24157>:
  D.24148 = mono_arch_fregname (reg);
  return D.24148;
  <D.24145>:
  D.24148 = mono_arch_regname (reg);
  return D.24148;
}


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.24160;
  unsigned int vreg.2;
  _Bool D.24162;
  long int D.24163;
  long int D.24164;
  int D.24167;
  _Bool D.24168;
  long int D.24169;
  long int D.24170;
  _Bool D.24173;
  long int D.24174;
  long int D.24175;
  long unsigned int D.24178;
  int D.24179;
  long unsigned int D.24180;
  long unsigned int D.24181;
  long int D.24182;
  void * D.24183;
  struct GSList * D.24184;
  struct MonoMemPool * D.24185;
  struct GSList * D.24186;
  _Bool D.24188;
  long int D.24189;
  long int D.24190;
  _Bool D.24193;
  long int D.24194;
  long int D.24195;
  long unsigned int D.24198;
  long unsigned int D.24199;
  struct GSList * D.24200;
  struct GSList * D.24201;
  guint32 regpair;

  hreg.1 = (unsigned int) hreg;
  D.24160 = hreg.1 << 24;
  vreg.2 = (unsigned int) vreg;
  regpair = D.24160 + vreg.2;
  D.24162 = bank != 0;
  D.24163 = (long int) D.24162;
  D.24164 = __builtin_expect (D.24163, 0);
  if (D.24164 != 0) goto <D.24165>; else goto <D.24166>;
  <D.24165>:
  D.24167 = regbank_size[bank];
  D.24168 = D.24167 > vreg;
  D.24169 = (long int) D.24168;
  D.24170 = __builtin_expect (D.24169, 0);
  if (D.24170 != 0) goto <D.24171>; else goto <D.24172>;
  <D.24171>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 262, "vreg >= regbank_size [bank]");
  <D.24172>:
  D.24167 = regbank_size[bank];
  D.24173 = D.24167 <= hreg;
  D.24174 = (long int) D.24173;
  D.24175 = __builtin_expect (D.24174, 0);
  if (D.24175 != 0) goto <D.24176>; else goto <D.24177>;
  <D.24176>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 263, "hreg < regbank_size [bank]");
  <D.24177>:
  D.24178 = call->used_fregs;
  D.24179 = 1 << hreg;
  D.24180 = (long unsigned int) D.24179;
  D.24181 = D.24178 | D.24180;
  call->used_fregs = D.24181;
  D.24182 = (long int) regpair;
  D.24183 = (void *) D.24182;
  D.24184 = call->out_freg_args;
  D.24185 = cfg->mempool;
  D.24186 = g_slist_append_mempool (D.24185, D.24184, D.24183);
  call->out_freg_args = D.24186;
  goto <D.24187>;
  <D.24166>:
  D.24188 = vreg <= 15;
  D.24189 = (long int) D.24188;
  D.24190 = __builtin_expect (D.24189, 0);
  if (D.24190 != 0) goto <D.24191>; else goto <D.24192>;
  <D.24191>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 267, "vreg >= MONO_MAX_IREGS");
  <D.24192>:
  D.24193 = hreg > 15;
  D.24194 = (long int) D.24193;
  D.24195 = __builtin_expect (D.24194, 0);
  if (D.24195 != 0) goto <D.24196>; else goto <D.24197>;
  <D.24196>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 268, "hreg < MONO_MAX_IREGS");
  <D.24197>:
  D.24198 = call->used_iregs;
  D.24179 = 1 << hreg;
  D.24180 = (long unsigned int) D.24179;
  D.24199 = D.24198 | D.24180;
  call->used_iregs = D.24199;
  D.24182 = (long int) regpair;
  D.24183 = (void *) D.24182;
  D.24200 = call->out_ireg_args;
  D.24185 = cfg->mempool;
  D.24201 = g_slist_append_mempool (D.24185, D.24200, D.24183);
  call->out_ireg_args = D.24201;
  <D.24187>:
}


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

  new_list = mono_mempool_alloc (mp, 16);
  new_list->data = data;
  new_list->next = 0B;
  if (list != 0B) goto <D.24202>; else goto <D.24203>;
  <D.24202>:
  last = list;
  goto <D.8618>;
  <D.8617>:
  last = last->next;
  <D.8618>:
  D.24204 = last->next;
  if (D.24204 != 0B) goto <D.8617>; else goto <D.8619>;
  <D.8619>:
  last->next = new_list;
  D.24205 = list;
  return D.24205;
  <D.24203>:
  D.24205 = new_list;
  return D.24205;
}


mono_call_inst_add_outarg_vt (struct MonoCompile * cfg, struct MonoCallInst * call, struct MonoInst * outarg_vt)
{
  struct GSList * D.24207;
  struct MonoMemPool * D.24208;
  struct GSList * D.24209;

  D.24207 = call->outarg_vts;
  D.24208 = cfg->mempool;
  D.24209 = g_slist_append_mempool (D.24208, D.24207, outarg_vt);
  call->outarg_vts = D.24209;
}


mono_print_ji (const struct MonoJumpInfo * ji)
{
  <unnamed type> D.24210;
  struct MonoJumpInfo * D.24211;
  <unnamed type> D.24212;
  const char * D.24213;
  struct MonoMethod * D.24214;
  const char * D.24215;

  D.24210 = ji->type;
  switch (D.24210) <default: <D.23451>, case 6: <D.23449>, case 35: <D.23446>>
  <D.23446>:
  {
    struct MonoJumpInfoRgctxEntry * entry;

    entry = ji->data.rgctx_entry;
    printf ("[RGCTX_FETCH ");
    D.24211 = entry->data;
    mono_print_ji (D.24211);
    D.24212 = entry->info_type;
    D.24213 = mono_rgctx_info_type_to_str (D.24212);
    printf (" - %s]", D.24213);
    goto <D.23448>;
  }
  <D.23449>:
  {
    char * s;

    D.24214 = ji->data.method;
    s = mono_method_full_name (D.24214, 1);
    printf ("[METHODCONST - %s]", s);
    monoeg_g_free (s);
    goto <D.23448>;
  }
  <D.23451>:
  D.24210 = ji->type;
  D.24215 = patch_info_str[D.24210];
  printf ("[%s]", D.24215);
  goto <D.23448>;
  <D.23448>:
}


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

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


mono_print_ins_index (int i, struct MonoInst * ins)
{
  short unsigned int D.24218;
  int D.24219;
  int D.24220;
  short unsigned int D.24221;
  sizetype D.24222;
  const char * D.24225;
  const char * D.24227;
  int D.24230;
  long int D.24235;
  int D.24237;
  int D.24240;
  int D.24243;
  struct MonoBasicBlock * * D.24246;
  struct MonoBasicBlock * * D.24247;
  struct MonoBasicBlock * D.24248;
  struct MonoBasicBlock * D.24251;
  int D.24252;
  int D.24254;
  int D.24255;
  int * D.24258;
  sizetype D.24259;
  sizetype D.24260;
  sizetype D.24261;
  int * D.24262;
  int D.24263;
  int D.24264;
  void * D.24265;
  int D.24266;
  char D.24267;
  int iftmp.3;
  _Bool D.24271;
  long int D.24272;
  long int D.24273;
  int iftmp.4;
  _Bool D.24277;
  long int D.24278;
  long int D.24279;
  _Bool iftmp.5;
  _Bool D.24285;
  long int D.24286;
  long int D.24287;
  int iftmp.6;
  int D.24295;
  const char * D.24310;
  const char * D.24312;
  const char * D.24314;
  const char * D.24315;
  char D.24316;
  int iftmp.7;
  _Bool D.24320;
  long int D.24321;
  long int D.24322;
  int iftmp.8;
  _Bool D.24326;
  long int D.24327;
  long int D.24328;
  _Bool iftmp.9;
  _Bool D.24334;
  long int D.24335;
  long int D.24336;
  int iftmp.10;
  int D.24344;
  const char * D.24354;
  const char * D.24356;
  signed char D.24357;
  int iftmp.11;
  int D.24359;
  sizetype D.24360;
  const char * D.24361;
  char D.24362;
  _Bool D.24363;
  long int D.24364;
  long int D.24365;
  int iftmp.12;
  _Bool D.24369;
  long int D.24370;
  long int D.24371;
  _Bool iftmp.13;
  _Bool D.24377;
  long int D.24378;
  long int D.24379;
  int iftmp.14;
  int D.24386;
  int D.24388;
  const char * D.24393;
  long int D.24394;
  int D.24395;
  void * D.24396;
  long int D.24397;
  int D.24398;
  long int D.24399;
  double D.24400;
  float D.24401;
  double D.24402;
  short unsigned int D.24403;
  struct MonoMethod * D.24408;
  unsigned char D.24412;
  unsigned char D.24413;
  const void * D.24417;
  const char * D.24422;
  void * D.24423;
  long int D.24424;
  unsigned int D.24425;
  int regpair.15;
  const char * D.24427;
  struct GSList * iftmp.16;
  struct MonoBasicBlock * D.24432;
  int D.24433;
  const char * D.24437;
  char D.24438;
  int D.24441;
  const char * spec;
  int num_sregs;
  int j;
  int sregs[3];

  try
    {
      D.24218 = ins->opcode;
      D.24219 = (int) D.24218;
      D.24220 = D.24219 + -313;
      D.24221 = amd64_desc_idx[D.24220];
      D.24222 = (sizetype) D.24221;
      spec = &amd64_desc + D.24222;
      if (i != -1) goto <D.24223>; else goto <D.24224>;
      <D.24223>:
      D.24218 = ins->opcode;
      D.24219 = (int) D.24218;
      D.24225 = mono_inst_name (D.24219);
      printf ("\t%-2d %s", i, D.24225);
      goto <D.24226>;
      <D.24224>:
      D.24218 = ins->opcode;
      D.24219 = (int) D.24218;
      D.24227 = mono_inst_name (D.24219);
      printf (" %s", D.24227);
      <D.24226>:
      if (spec == &amd64_desc) goto <D.24228>; else goto <D.24229>;
      <D.24228>:
      {
        gboolean dest_base;

        dest_base = 0;
        D.24218 = ins->opcode;
        D.24219 = (int) D.24218;
        switch (D.24219) <default: <D.23463>, case 390: <D.23461>>
        <D.23461>:
        dest_base = 1;
        goto <D.23462>;
        <D.23463>:
        goto <D.23462>;
        <D.23462>:
        D.24230 = ins->dreg;
        if (D.24230 != -1) goto <D.24231>; else goto <D.24232>;
        <D.24231>:
        if (dest_base != 0) goto <D.24233>; else goto <D.24234>;
        <D.24233>:
        D.24235 = ins->data.op[0].const_val;
        D.24230 = ins->dreg;
        printf (" [R%d + 0x%lx] <-", D.24230, D.24235);
        goto <D.24236>;
        <D.24234>:
        D.24230 = ins->dreg;
        printf (" R%d <-", D.24230);
        <D.24236>:
        <D.24232>:
        D.24237 = ins->sreg1;
        if (D.24237 != -1) goto <D.24238>; else goto <D.24239>;
        <D.24238>:
        D.24237 = ins->sreg1;
        printf (" R%d", D.24237);
        <D.24239>:
        D.24240 = ins->sreg2;
        if (D.24240 != -1) goto <D.24241>; else goto <D.24242>;
        <D.24241>:
        D.24240 = ins->sreg2;
        printf (" R%d", D.24240);
        <D.24242>:
        D.24243 = ins->sreg3;
        if (D.24243 != -1) goto <D.24244>; else goto <D.24245>;
        <D.24244>:
        D.24243 = ins->sreg3;
        printf (" R%d", D.24243);
        <D.24245>:
        D.24218 = ins->opcode;
        D.24219 = (int) D.24218;
        switch (D.24219) <default: <D.23487>, case 314: <D.23483>, case 319: <D.23475>, case 320: <D.23478>, case 321: <D.23476>, case 332: <D.23486>, case 334: <D.23484>, case 367: <D.23485>, case 555: <D.23465>, case 556: <D.23470>, case 557: <D.23468>, case 558: <D.23472>, case 559: <D.23466>, case 560: <D.23464>, case 561: <D.23471>, case 562: <D.23469>, case 563: <D.23473>, case 564: <D.23467>, case 964: <D.23477>>
        <D.23464>:
        <D.23465>:
        <D.23466>:
        <D.23467>:
        <D.23468>:
        <D.23469>:
        <D.23470>:
        <D.23471>:
        <D.23472>:
        <D.23473>:
        D.24246 = ins->data.op[1].many_blocks;
        D.24247 = D.24246 + 8;
        D.24248 = *D.24247;
        if (D.24248 == 0B) goto <D.24249>; else goto <D.24250>;
        <D.24249>:
        D.24246 = ins->data.op[1].many_blocks;
        D.24251 = *D.24246;
        D.24252 = D.24251->block_num;
        printf (" [B%d]", D.24252);
        goto <D.24253>;
        <D.24250>:
        D.24246 = ins->data.op[1].many_blocks;
        D.24247 = D.24246 + 8;
        D.24248 = *D.24247;
        D.24254 = D.24248->block_num;
        D.24246 = ins->data.op[1].many_blocks;
        D.24251 = *D.24246;
        D.24252 = D.24251->block_num;
        printf (" [B%dB%d]", D.24252, D.24254);
        <D.24253>:
        goto <D.23474>;
        <D.23475>:
        <D.23476>:
        <D.23477>:
        <D.23478>:
        {
          int i;

          D.24235 = ins->data.op[0].const_val;
          D.24255 = (int) D.24235;
          printf (" [%d (", D.24255);
          i = 0;
          goto <D.23481>;
          <D.23480>:
          if (i != 0) goto <D.24256>; else goto <D.24257>;
          <D.24256>:
          printf (", ");
          <D.24257>:
          D.24258 = ins->data.op[1].phi_args;
          D.24259 = (sizetype) i;
          D.24260 = D.24259 + 1;
          D.24261 = D.24260 * 4;
          D.24262 = D.24258 + D.24261;
          D.24263 = *D.24262;
          printf ("R%d", D.24263);
          i = i + 1;
          <D.23481>:
          D.24258 = ins->data.op[1].phi_args;
          D.24264 = *D.24258;
          if (D.24264 > i) goto <D.23480>; else goto <D.23482>;
          <D.23482>:
          printf (")]");
          goto <D.23474>;
        }
        <D.23483>:
        <D.23484>:
        D.24265 = ins->data.op[0].p;
        D.24266 = MEM[(struct MonoInst *)D.24265].dreg;
        printf (" R%d", D.24266);
        goto <D.23474>;
        <D.23485>:
        <D.23486>:
        D.24235 = ins->data.op[0].const_val;
        printf (" + 0x%lx", D.24235);
        goto <D.23474>;
        <D.23487>:
        goto <D.23474>;
        <D.23474>:
        printf ("\n");
        return;
      }
      <D.24229>:
      D.24267 = *spec;
      if (D.24267 != 0) goto <D.24268>; else goto <D.24269>;
      <D.24268>:
      {
        int bank;

        D.24267 = *spec;
        D.24271 = D.24267 == 102;
        D.24272 = (long int) D.24271;
        D.24273 = __builtin_expect (D.24272, 0);
        if (D.24273 == 0) goto <D.24274>; else goto <D.24275>;
        <D.24274>:
        D.24267 = *spec;
        D.24277 = D.24267 == 120;
        D.24278 = (long int) D.24277;
        D.24279 = __builtin_expect (D.24278, 0);
        if (D.24279 != 0) goto <D.24280>; else goto <D.24281>;
        <D.24280>:
        iftmp.4 = 4;
        goto <D.24282>;
        <D.24281>:
        iftmp.4 = 0;
        <D.24282>:
        iftmp.3 = iftmp.4;
        goto <D.24283>;
        <D.24275>:
        iftmp.3 = 1;
        <D.24283>:
        bank = iftmp.3;
        D.24285 = bank != 0;
        D.24286 = (long int) D.24285;
        D.24287 = __builtin_expect (D.24286, 0);
        if (D.24287 != 0) goto <D.24288>; else goto <D.24289>;
        <D.24288>:
        D.24230 = ins->dreg;
        if (D.24230 < 0) goto <D.24291>; else goto <D.24294>;
        <D.24294>:
        D.24230 = ins->dreg;
        D.24295 = regbank_size[bank];
        if (D.24230 >= D.24295) goto <D.24291>; else goto <D.24292>;
        <D.24291>:
        iftmp.6 = 1;
        goto <D.24293>;
        <D.24292>:
        iftmp.6 = 0;
        <D.24293>:
        iftmp.5 = (_Bool) iftmp.6;
        goto <D.24296>;
        <D.24289>:
        D.24230 = ins->dreg;
        iftmp.5 = D.24230 > 15;
        <D.24296>:
        if (iftmp.5 != 0) goto <D.24297>; else goto <D.24298>;
        <D.24297>:
        D.24267 = *spec;
        if (D.24267 == 98) goto <D.24299>; else goto <D.24300>;
        <D.24299>:
        D.24235 = ins->data.op[0].const_val;
        if (D.24235 == 0) goto <D.24301>; else goto <D.24302>;
        <D.24301>:
        D.24230 = ins->dreg;
        printf (" [R%d] <-", D.24230);
        goto <D.24303>;
        <D.24302>:
        D.24235 = ins->data.op[0].const_val;
        D.24230 = ins->dreg;
        printf (" [R%d + 0x%lx] <-", D.24230, D.24235);
        <D.24303>:
        goto <D.24304>;
        <D.24300>:
        D.24230 = ins->dreg;
        printf (" R%d <-", D.24230);
        <D.24304>:
        goto <D.24305>;
        <D.24298>:
        D.24267 = *spec;
        if (D.24267 == 98) goto <D.24306>; else goto <D.24307>;
        <D.24306>:
        D.24235 = ins->data.op[0].const_val;
        if (D.24235 == 0) goto <D.24308>; else goto <D.24309>;
        <D.24308>:
        D.24230 = ins->dreg;
        D.24310 = mono_arch_regname (D.24230);
        printf (" [%s] <-", D.24310);
        goto <D.24311>;
        <D.24309>:
        D.24235 = ins->data.op[0].const_val;
        D.24230 = ins->dreg;
        D.24312 = mono_arch_regname (D.24230);
        printf (" [%s + 0x%lx] <-", D.24312, D.24235);
        <D.24311>:
        goto <D.24313>;
        <D.24307>:
        D.24230 = ins->dreg;
        D.24314 = mono_regname_full (D.24230, bank);
        printf (" %s <-", D.24314);
        <D.24313>:
        <D.24305>:
      }
      <D.24269>:
      D.24315 = spec + 1;
      D.24316 = *D.24315;
      if (D.24316 != 0) goto <D.24317>; else goto <D.24318>;
      <D.24317>:
      {
        int bank;

        D.24315 = spec + 1;
        D.24316 = *D.24315;
        D.24320 = D.24316 == 102;
        D.24321 = (long int) D.24320;
        D.24322 = __builtin_expect (D.24321, 0);
        if (D.24322 == 0) goto <D.24323>; else goto <D.24324>;
        <D.24323>:
        D.24315 = spec + 1;
        D.24316 = *D.24315;
        D.24326 = D.24316 == 120;
        D.24327 = (long int) D.24326;
        D.24328 = __builtin_expect (D.24327, 0);
        if (D.24328 != 0) goto <D.24329>; else goto <D.24330>;
        <D.24329>:
        iftmp.8 = 4;
        goto <D.24331>;
        <D.24330>:
        iftmp.8 = 0;
        <D.24331>:
        iftmp.7 = iftmp.8;
        goto <D.24332>;
        <D.24324>:
        iftmp.7 = 1;
        <D.24332>:
        bank = iftmp.7;
        D.24334 = bank != 0;
        D.24335 = (long int) D.24334;
        D.24336 = __builtin_expect (D.24335, 0);
        if (D.24336 != 0) goto <D.24337>; else goto <D.24338>;
        <D.24337>:
        D.24237 = ins->sreg1;
        if (D.24237 < 0) goto <D.24340>; else goto <D.24343>;
        <D.24343>:
        D.24237 = ins->sreg1;
        D.24344 = regbank_size[bank];
        if (D.24237 >= D.24344) goto <D.24340>; else goto <D.24341>;
        <D.24340>:
        iftmp.10 = 1;
        goto <D.24342>;
        <D.24341>:
        iftmp.10 = 0;
        <D.24342>:
        iftmp.9 = (_Bool) iftmp.10;
        goto <D.24345>;
        <D.24338>:
        D.24237 = ins->sreg1;
        iftmp.9 = D.24237 > 15;
        <D.24345>:
        if (iftmp.9 != 0) goto <D.24346>; else goto <D.24347>;
        <D.24346>:
        D.24315 = spec + 1;
        D.24316 = *D.24315;
        if (D.24316 == 98) goto <D.24348>; else goto <D.24349>;
        <D.24348>:
        D.24235 = ins->data.op[0].const_val;
        D.24237 = ins->sreg1;
        printf (" [R%d + 0x%lx]", D.24237, D.24235);
        goto <D.24350>;
        <D.24349>:
        D.24237 = ins->sreg1;
        printf (" R%d", D.24237);
        <D.24350>:
        goto <D.24351>;
        <D.24347>:
        D.24315 = spec + 1;
        D.24316 = *D.24315;
        if (D.24316 == 98) goto <D.24352>; else goto <D.24353>;
        <D.24352>:
        D.24235 = ins->data.op[0].const_val;
        D.24237 = ins->sreg1;
        D.24354 = mono_arch_regname (D.24237);
        printf (" [%s + 0x%lx]", D.24354, D.24235);
        goto <D.24355>;
        <D.24353>:
        D.24237 = ins->sreg1;
        D.24356 = mono_regname_full (D.24237, bank);
        printf (" %s", D.24356);
        <D.24355>:
        <D.24351>:
      }
      <D.24318>:
      D.24237 = ins->sreg1;
      sregs[0] = D.24237;
      D.24240 = ins->sreg2;
      sregs[1] = D.24240;
      D.24243 = ins->sreg3;
      sregs[2] = D.24243;
      D.24218 = ins->opcode;
      D.24219 = (int) D.24218;
      D.24220 = D.24219 + -313;
      D.24357 = ins_sreg_counts[D.24220];
      num_sregs = (int) D.24357;
      j = 1;
      goto <D.23492>;
      <D.23491>:
      {
        int bank;

        D.24359 = j + 1;
        D.24360 = (sizetype) D.24359;
        D.24361 = spec + D.24360;
        D.24362 = *D.24361;
        D.24363 = D.24362 == 102;
        D.24364 = (long int) D.24363;
        D.24365 = __builtin_expect (D.24364, 0);
        if (D.24365 == 0) goto <D.24366>; else goto <D.24367>;
        <D.24366>:
        D.24359 = j + 1;
        D.24360 = (sizetype) D.24359;
        D.24361 = spec + D.24360;
        D.24362 = *D.24361;
        D.24369 = D.24362 == 120;
        D.24370 = (long int) D.24369;
        D.24371 = __builtin_expect (D.24370, 0);
        if (D.24371 != 0) goto <D.24372>; else goto <D.24373>;
        <D.24372>:
        iftmp.12 = 4;
        goto <D.24374>;
        <D.24373>:
        iftmp.12 = 0;
        <D.24374>:
        iftmp.11 = iftmp.12;
        goto <D.24375>;
        <D.24367>:
        iftmp.11 = 1;
        <D.24375>:
        bank = iftmp.11;
        D.24377 = bank != 0;
        D.24378 = (long int) D.24377;
        D.24379 = __builtin_expect (D.24378, 0);
        if (D.24379 != 0) goto <D.24380>; else goto <D.24381>;
        <D.24380>:
        D.24386 = sregs[j];
        if (D.24386 < 0) goto <D.24383>; else goto <D.24387>;
        <D.24387>:
        D.24386 = sregs[j];
        D.24388 = regbank_size[bank];
        if (D.24386 >= D.24388) goto <D.24383>; else goto <D.24384>;
        <D.24383>:
        iftmp.14 = 1;
        goto <D.24385>;
        <D.24384>:
        iftmp.14 = 0;
        <D.24385>:
        iftmp.13 = (_Bool) iftmp.14;
        goto <D.24389>;
        <D.24381>:
        D.24386 = sregs[j];
        iftmp.13 = D.24386 > 15;
        <D.24389>:
        if (iftmp.13 != 0) goto <D.24390>; else goto <D.24391>;
        <D.24390>:
        D.24386 = sregs[j];
        printf (" R%d", D.24386);
        goto <D.24392>;
        <D.24391>:
        D.24386 = sregs[j];
        D.24393 = mono_regname_full (D.24386, bank);
        printf (" %s", D.24393);
        <D.24392>:
      }
      j = j + 1;
      <D.23492>:
      if (j < num_sregs) goto <D.23491>; else goto <D.23493>;
      <D.23493>:
      D.24218 = ins->opcode;
      D.24219 = (int) D.24218;
      switch (D.24219) <default: <D.23562>, case 323: <D.23498>, case 327: <D.23497>, case 341: <D.23561>, case 343: <D.23521>, case 345: <D.23522>, case 346: <D.23510>, case 347: <D.23512>, case 348: <D.23511>, case 349: <D.23513>, case 352: <D.23514>, case 355: <D.23515>, case 356: <D.23516>, case 357: <D.23517>, case 358: <D.23518>, case 359: <D.23519>, case 360: <D.23520>, case 362: <D.23494>, case 363: <D.23507>, case 364: <D.23509>, case 365: <D.23508>, case 433: <D.23505>, case 434: <D.23504>, case 446: <D.23535>, case 448: <D.23523>, case 542: <D.23506>, case 555: <D.23548>, case 556: <D.23553>, case 557: <D.23551>, case 558: <D.23555>, case 559: <D.23549>, case 560: <D.23547>, case 561: <D.23554>, case 562: <D.23552>, case 563: <D.23556>, case 564: <D.23550>, case 629: <D.23499>, case 630: <D.23500>, case 636: <D.23501>, case 637: <D.23502>, case 638: <D.23503>, case 652: <D.23538>, case 653: <D.23543>, case 654: <D.23541>, case 655: <D.23545>, case 656: <D.23539>, case 657: <D.23537>, case 658: <D.23544>, case 659: <D.23542>, case 660: <D.23546>, case 661: <D.23540>, case 739: <D.23536>, case 998: <D.23557>, case 999: <D.23558>, case 1000: <D.23559>, case 1001: <D.23560>, case 1033: <D.23496>>
      <D.23494>:
      D.24235 = ins->data.op[0].const_val;
      D.24255 = (int) D.24235;
      printf (" [%d]", D.24255);
      goto <D.23495>;
      <D.23496>:
      <D.23497>:
      <D.23498>:
      <D.23499>:
      <D.23500>:
      <D.23501>:
      <D.23502>:
      <D.23503>:
      <D.23504>:
      D.24394 = ins->data.op[1].const_val;
      D.24395 = (int) D.24394;
      printf (" [%d]", D.24395);
      goto <D.23495>;
      <D.23505>:
      <D.23506>:
      D.24396 = ins->data.op[1].p;
      D.24397 = (long int) D.24396;
      D.24398 = (int) D.24397;
      printf (" [%d]", D.24398);
      goto <D.23495>;
      <D.23507>:
      D.24399 = ins->data.i8const;
      printf (" [%lld]", D.24399);
      goto <D.23495>;
      <D.23508>:
      D.24265 = ins->data.op[0].p;
      D.24400 = MEM[(double *)D.24265];
      printf (" [%f]", D.24400);
      goto <D.23495>;
      <D.23509>:
      D.24265 = ins->data.op[0].p;
      D.24401 = MEM[(float *)D.24265];
      D.24402 = (double) D.24401;
      printf (" [%f]", D.24402);
      goto <D.23495>;
      <D.23510>:
      <D.23511>:
      <D.23512>:
      <D.23513>:
      <D.23514>:
      <D.23515>:
      <D.23516>:
      <D.23517>:
      <D.23518>:
      <D.23519>:
      <D.23520>:
      <D.23521>:
      <D.23522>:
      <D.23523>:
      {
        struct MonoCallInst * call;
        struct GSList * list;

        call = ins;
        D.24218 = ins->opcode;
        D.24403 = D.24218 + 65181;
        if (D.24403 <= 2) goto <D.24404>; else goto <D.24405>;
        <D.24404>:
        D.24230 = ins->dreg;
        if (D.24230 != -1) goto <D.24406>; else goto <D.24407>;
        <D.24406>:
        D.24230 = ins->dreg;
        printf (" R%d <-", D.24230);
        <D.24407>:
        <D.24405>:
        D.24408 = call->method;
        if (D.24408 != 0B) goto <D.24409>; else goto <D.24410>;
        <D.24409>:
        {
          char * full_name;

          D.24408 = call->method;
          full_name = mono_method_full_name (D.24408, 1);
          printf (" [%s]", full_name);
          monoeg_g_free (full_name);
        }
        goto <D.24411>;
        <D.24410>:
        D.24412 = BIT_FIELD_REF <*call, 8, 1088>;
        D.24413 = D.24412 & 4;
        if (D.24413 != 0) goto <D.24414>; else goto <D.24415>;
        <D.24414>:
        {
          struct MonoJumpInfo * ji;

          ji = call->fptr;
          printf (" ");
          mono_print_ji (ji);
        }
        goto <D.24416>;
        <D.24415>:
        D.24417 = call->fptr;
        if (D.24417 != 0B) goto <D.24418>; else goto <D.24419>;
        <D.24418>:
        {
          struct MonoJitICallInfo * info;

          D.24417 = call->fptr;
          info = mono_find_jit_icall_by_addr (D.24417);
          if (info != 0B) goto <D.24420>; else goto <D.24421>;
          <D.24420>:
          D.24422 = info->name;
          printf (" [%s]", D.24422);
          <D.24421>:
        }
        <D.24419>:
        <D.24416>:
        <D.24411>:
        list = call->out_ireg_args;
        goto <D.23533>;
        <D.23532>:
        {
          guint32 regpair;
          int reg;
          int hreg;

          D.24423 = list->data;
          D.24424 = (long int) D.24423;
          regpair = (guint32) D.24424;
          D.24425 = regpair >> 24;
          hreg = (int) D.24425;
          regpair.15 = (int) regpair;
          reg = regpair.15 & 16777215;
          D.24427 = mono_arch_regname (hreg);
          printf (" [%s <- R%d]", D.24427, reg);
          if (list != 0B) goto <D.24429>; else goto <D.24430>;
          <D.24429>:
          iftmp.16 = list->next;
          goto <D.24431>;
          <D.24430>:
          iftmp.16 = 0B;
          <D.24431>:
          list = iftmp.16;
        }
        <D.23533>:
        if (list != 0B) goto <D.23532>; else goto <D.23534>;
        <D.23534>:
        goto <D.23495>;
      }
      <D.23535>:
      <D.23536>:
      D.24432 = ins->data.op[0].target_block;
      D.24433 = D.24432->block_num;
      printf (" [B%d]", D.24433);
      goto <D.23495>;
      <D.23537>:
      <D.23538>:
      <D.23539>:
      <D.23540>:
      <D.23541>:
      <D.23542>:
      <D.23543>:
      <D.23544>:
      <D.23545>:
      <D.23546>:
      <D.23547>:
      <D.23548>:
      <D.23549>:
      <D.23550>:
      <D.23551>:
      <D.23552>:
      <D.23553>:
      <D.23554>:
      <D.23555>:
      <D.23556>:
      D.24246 = ins->data.op[1].many_blocks;
      D.24247 = D.24246 + 8;
      D.24248 = *D.24247;
      if (D.24248 == 0B) goto <D.24434>; else goto <D.24435>;
      <D.24434>:
      D.24246 = ins->data.op[1].many_blocks;
      D.24251 = *D.24246;
      D.24252 = D.24251->block_num;
      printf (" [B%d]", D.24252);
      goto <D.24436>;
      <D.24435>:
      D.24246 = ins->data.op[1].many_blocks;
      D.24247 = D.24246 + 8;
      D.24248 = *D.24247;
      D.24254 = D.24248->block_num;
      D.24246 = ins->data.op[1].many_blocks;
      D.24251 = *D.24246;
      D.24252 = D.24251->block_num;
      printf (" [B%dB%d]", D.24252, D.24254);
      <D.24436>:
      goto <D.23495>;
      <D.23557>:
      <D.23558>:
      <D.23559>:
      <D.23560>:
      D.24394 = ins->data.op[1].const_val;
      D.24395 = (int) D.24394;
      printf (" R%d", D.24395);
      goto <D.23495>;
      <D.23561>:
      D.24394 = ins->data.op[1].const_val;
      D.24395 = (int) D.24394;
      printf (" il: %x", D.24395);
      goto <D.23495>;
      <D.23562>:
      goto <D.23495>;
      <D.23495>:
      D.24437 = spec + 5;
      D.24438 = *D.24437;
      if (D.24438 != 0) goto <D.24439>; else goto <D.24440>;
      <D.24439>:
      D.24437 = spec + 5;
      D.24438 = *D.24437;
      D.24441 = (int) D.24438;
      printf (" clobbers: %c", D.24441);
      <D.24440>:
      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.24448;
  int desc_to_fixed_reg_inited.17;
  gint8 iftmp.18;
  gint8 iftmp.19;
  gint8 iftmp.20;
  gint8 iftmp.21;
  gint8 iftmp.22;
  int D.24474;
  short unsigned int D.24475;
  sizetype D.24476;
  int D.24477;
  char D.24478;
  char D.24481;
  const char * D.24484;
  const char * D.24485;
  char D.24486;
  const char * D.24489;
  char D.24490;
  const char * D.24493;
  const char * D.24494;
  char D.24495;
  const char * D.24498;
  char D.24499;
  const char * D.24502;
  unsigned int D.24503;
  int D.24504;
  long unsigned int D.24505;
  void * D.24506;
  int D.24509;
  int D.24514;
  int D.24515;
  long unsigned int D.24516;
  unsigned int D.24517;
  unsigned int D.24518;
  struct MonoMemPool * D.24519;
  void * D.24520;
  int D.24522;
  _Bool D.24523;
  long int D.24524;
  long int D.24525;
  unsigned int D.24528;
  long unsigned int D.24531;
  short unsigned int D.24532;
  int D.24533;
  int D.24534;
  short unsigned int D.24535;
  sizetype D.24536;
  int D.24537;
  long unsigned int D.24542;
  long unsigned int D.24543;
  void * D.24544;
  int D.24545;
  int D.24546;
  int D.24547;
  signed char D.24548;
  int D.24549;
  _Bool D.24550;
  long int D.24551;
  long int D.24552;
  long unsigned int D.24557;
  long unsigned int D.24558;
  void * D.24559;
  _Bool D.24560;
  long int D.24561;
  long int D.24562;
  int D.24565;
  _Bool D.24566;
  long int D.24567;
  long int D.24568;
  const char * D.24571;
  int D.24574;
  sizetype D.24575;
  const char * D.24576;
  char D.24577;
  int iftmp.23;
  _Bool D.24581;
  long int D.24582;
  long int D.24583;
  int iftmp.24;
  _Bool D.24587;
  long int D.24588;
  long int D.24589;
  _Bool D.24594;
  long int D.24595;
  long int D.24596;
  _Bool iftmp.25;
  _Bool D.24600;
  long int D.24601;
  long int D.24602;
  int iftmp.26;
  int D.24610;
  long unsigned int D.24614;
  long unsigned int D.24615;
  struct RegTrack * D.24616;
  int D.24617;
  _Bool D.24618;
  long int D.24619;
  long int D.24620;
  gint32 * D.24623;
  long unsigned int D.24624;
  gint32 * D.24625;
  sizetype D.24628;
  sizetype D.24629;
  sizetype D.24630;
  gint32 * D.24631;
  sizetype D.24634;
  struct RegTrack * D.24635;
  int D.24636;
  int iftmp.27;
  _Bool D.24642;
  long int D.24643;
  long int D.24644;
  int iftmp.28;
  _Bool D.24648;
  long int D.24649;
  long int D.24650;
  struct RegTrack * D.24657;
  _Bool D.24658;
  long int D.24659;
  long int D.24660;
  long unsigned int D.24663;
  gint32 * D.24664;
  int D.24667;
  int D.24669;
  signed char D.24670;
  long unsigned int D.24673;
  sizetype D.24676;
  sizetype D.24677;
  sizetype D.24678;
  gint32 * D.24679;
  sizetype D.24682;
  struct RegTrack * D.24683;
  int D.24684;
  const char * D.24691;
  char D.24692;
  short unsigned int D.24695;
  short unsigned int D.24696;
  _Bool D.24697;
  short unsigned int D.24698;
  _Bool D.24699;
  _Bool D.24700;
  short unsigned int D.24702;
  short unsigned int D.24704;
  short unsigned int D.24706;
  short unsigned int D.24708;
  void * D.24712;
  long int D.24713;
  unsigned int D.24714;
  int regpair.29;
  struct GSList * iftmp.30;
  unsigned int D.24722;
  int regpair.31;
  struct GSList * iftmp.32;
  struct MonoInst * iftmp.33;
  char spec_dest.34;
  int D.24735;
  int D.24736;
  long unsigned int D.24737;
  signed char D.24738;
  int D.24739;
  int D.24744;
  signed char D.24745;
  long unsigned int D.24746;
  regmask_t iftmp.35;
  _Bool D.24748;
  _Bool D.24749;
  _Bool D.24750;
  long unsigned int D.24754;
  long unsigned int D.24759;
  long unsigned int D.24762;
  long unsigned int D.24763;
  long unsigned int D.24764;
  int D.24767;
  long unsigned int D.24770;
  long unsigned int D.24771;
  gint32 * D.24772;
  int D.24773;
  long unsigned int D.24778;
  long unsigned int D.24779;
  gint32 * D.24780;
  int D.24781;
  long unsigned int D.24786;
  long unsigned int D.24787;
  long unsigned int D.24788;
  unsigned int sreg.36;
  long unsigned int D.24795;
  long unsigned int D.24796;
  long unsigned int D.24800;
  long unsigned int D.24801;
  const char * D.24806;
  long unsigned int D.24812;
  long unsigned int D.24813;
  long unsigned int D.24817;
  long unsigned int D.24818;
  _Bool D.24826;
  long int D.24827;
  long int D.24828;
  const char * D.24833;
  const char * D.24834;
  int iftmp.37;
  int iftmp.38;
  _Bool iftmp.39;
  int iftmp.40;
  int D.24876;
  long unsigned int D.24879;
  long unsigned int D.24880;
  int D.24881;
  long unsigned int D.24884;
  long unsigned int D.24885;
  _Bool iftmp.41;
  int iftmp.42;
  long unsigned int D.24899;
  long unsigned int D.24900;
  long int iftmp.43;
  int iftmp.44;
  _Bool D.24913;
  int D.24914;
  _Bool D.24916;
  int D.24917;
  long int D.24918;
  int D.24923;
  int D.24926;
  long unsigned int D.24929;
  long unsigned int D.24930;
  gint32 * D.24931;
  int D.24932;
  unsigned int D.24933;
  int dest_dreg2.45;
  unsigned int D.24943;
  long unsigned int D.24945;
  long unsigned int D.24946;
  _Bool iftmp.46;
  int iftmp.47;
  const char * D.24969;
  _Bool D.24974;
  long int D.24975;
  long int D.24976;
  int iftmp.48;
  long unsigned int D.24982;
  long unsigned int D.24983;
  gint32 * D.24984;
  int D.24985;
  unsigned int D.24986;
  long unsigned int D.24988;
  long unsigned int D.24989;
  _Bool D.24991;
  long int D.24992;
  long int D.24993;
  long unsigned int D.24996;
  long unsigned int D.24997;
  gint32 * D.24998;
  long unsigned int D.25008;
  long unsigned int D.25009;
  int D.25014;
  const char * D.25017;
  _Bool iftmp.49;
  _Bool iftmp.50;
  int iftmp.51;
  int iftmp.52;
  _Bool D.25034;
  long unsigned int D.25038;
  long unsigned int D.25039;
  long unsigned int D.25040;
  int iftmp.53;
  unsigned int val.54;
  long unsigned int D.25048;
  long unsigned int D.25049;
  int iftmp.55;
  long unsigned int D.25061;
  struct RegTrack * D.25062;
  int D.25063;
  const char * D.25068;
  _Bool iftmp.56;
  int iftmp.57;
  _Bool D.25084;
  long int D.25085;
  long int D.25086;
  long unsigned int D.25091;
  struct RegTrack * D.25092;
  int D.25093;
  const char * D.25094;
  struct MonoRegState * D.25104;
  int * D.25105;
  long unsigned int D.25106;
  long unsigned int D.25107;
  int * D.25108;
  int D.25109;
  int D.25110;
  int D.25114;
  long unsigned int D.25123;
  long unsigned int D.25124;
  long unsigned int D.25125;
  long unsigned int D.25126;
  long unsigned int D.25129;
  long unsigned int D.25130;
  int D.25135;
  _Bool D.25143;
  long int D.25144;
  long int D.25145;
  _Bool D.25147;
  long int D.25148;
  long int D.25149;
  sizetype D.25153;
  sizetype D.25154;
  sizetype D.25155;
  gint32 * D.25156;
  long unsigned int D.25158;
  long unsigned int D.25159;
  long unsigned int D.25160;
  long unsigned int D.25163;
  long unsigned int D.25164;
  _Bool D.25169;
  _Bool D.25170;
  _Bool D.25171;
  int D.25175;
  long unsigned int D.25178;
  long unsigned int D.25179;
  gint32 * D.25180;
  long unsigned int D.25181;
  long unsigned int D.25182;
  int * D.25190;
  long unsigned int D.25191;
  long unsigned int D.25192;
  int * D.25193;
  int D.25194;
  long unsigned int D.25199;
  long unsigned int D.25207;
  long unsigned int D.25208;
  gint32 * D.25209;
  int D.25210;
  short unsigned int D.25215;
  short unsigned int D.25216;
  _Bool D.25217;
  short unsigned int D.25218;
  _Bool D.25219;
  _Bool D.25220;
  void * D.25228;
  long int D.25229;
  unsigned int D.25230;
  int regpair.58;
  long unsigned int D.25232;
  long unsigned int D.25233;
  long unsigned int D.25234;
  long unsigned int D.25235;
  const char * D.25238;
  struct GSList * iftmp.59;
  unsigned int D.25245;
  int regpair.60;
  const char * D.25249;
  struct GSList * iftmp.61;
  int iftmp.62;
  _Bool D.25255;
  long int D.25256;
  long int D.25257;
  int iftmp.63;
  _Bool D.25261;
  long int D.25262;
  long int D.25263;
  long int iftmp.64;
  int iftmp.65;
  _Bool D.25278;
  int D.25279;
  _Bool D.25281;
  int D.25282;
  long int D.25283;
  _Bool D.25288;
  long int D.25289;
  long int D.25290;
  _Bool D.25293;
  long int D.25294;
  long int D.25295;
  long unsigned int D.25298;
  long unsigned int D.25299;
  gint32 * D.25300;
  int D.25301;
  const char * D.25308;
  long unsigned int D.25309;
  long unsigned int D.25310;
  _Bool D.25311;
  long int D.25312;
  long int D.25313;
  long unsigned int D.25316;
  sizetype D.25319;
  sizetype D.25320;
  sizetype D.25321;
  gint32 * D.25322;
  int D.25323;
  int D.25328;
  const char * D.25331;
  long unsigned int D.25332;
  int D.25339;
  unsigned int D.25340;
  long unsigned int D.25342;
  long unsigned int D.25343;
  long unsigned int D.25347;
  long unsigned int D.25350;
  long unsigned int D.25351;
  gint32 * D.25352;
  int D.25353;
  long unsigned int D.25356;
  long unsigned int D.25357;
  _Bool iftmp.66;
  int iftmp.67;
  int D.25381;
  long unsigned int D.25386;
  long unsigned int D.25387;
  long unsigned int D.25390;
  long unsigned int D.25391;
  long unsigned int D.25402;
  struct RegTrack * D.25403;
  const char * D.25406;
  int D.25409;
  long unsigned int D.25415;
  long unsigned int D.25417;
  long unsigned int D.25418;
  long unsigned int D.25419;
  _Bool D.25424;
  long int D.25425;
  long int D.25426;
  int iftmp.68;
  long unsigned int D.25432;
  long unsigned int D.25433;
  gint32 * D.25434;
  int D.25435;
  unsigned int D.25436;
  long unsigned int D.25438;
  long unsigned int D.25439;
  _Bool D.25441;
  long int D.25442;
  long int D.25443;
  long unsigned int D.25446;
  long unsigned int D.25447;
  gint32 * D.25448;
  const char * D.25462;
  int iftmp.69;
  _Bool D.25470;
  long int D.25471;
  long int D.25472;
  int iftmp.70;
  _Bool D.25476;
  long int D.25477;
  long int D.25478;
  int D.25483;
  const char * D.25488;
  const char * D.25489;
  _Bool D.25490;
  long int D.25491;
  long int D.25492;
  sizetype D.25498;
  sizetype D.25499;
  sizetype D.25500;
  gint32 * D.25501;
  int D.25502;
  _Bool D.25505;
  long int D.25506;
  long int D.25507;
  _Bool D.25510;
  long int D.25511;
  long int D.25512;
  const char * D.25517;
  const char * D.25518;
  long unsigned int D.25521;
  long unsigned int D.25522;
  int iftmp.71;
  int iftmp.72;
  unsigned int D.25536;
  long unsigned int D.25538;
  long unsigned int D.25539;
  _Bool iftmp.73;
  int iftmp.74;
  long unsigned int D.25552;
  gint32 * D.25553;
  struct RegTrack * D.25564;
  const char * D.25567;
  long unsigned int D.25570;
  long unsigned int D.25571;
  long unsigned int D.25572;
  long unsigned int D.25573;
  _Bool D.25575;
  _Bool D.25576;
  _Bool D.25577;
  _Bool D.25580;
  long int D.25581;
  long int D.25582;
  int D.25587;
  _Bool D.25588;
  long int D.25589;
  long int D.25590;
  struct MonoInst * iftmp.75;
  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;
  int num_sregs;
  int sregs[3];

  try
    {
      rs = cfg->rs;
      bank = 0;
      num_sregs = 0;
      D.24448 = bb->code;
      if (D.24448 == 0B) goto <D.24449>; else goto <D.24450>;
      <D.24449>:
      return;
      <D.24450>:
      desc_to_fixed_reg_inited.17 = desc_to_fixed_reg_inited;
      if (desc_to_fixed_reg_inited.17 == 0) goto <D.24452>; else goto <D.24453>;
      <D.24452>:
      i = 0;
      goto <D.23736>;
      <D.23735>:
      if (i != 0) goto <D.24455>; else goto <D.24456>;
      <D.24455>:
      if (i != 105) goto <D.24458>; else goto <D.24459>;
      <D.24458>:
      if (i != 97) goto <D.24461>; else goto <D.24462>;
      <D.24461>:
      if (i != 115) goto <D.24464>; else goto <D.24465>;
      <D.24464>:
      if (i == 100) goto <D.24467>; else goto <D.24468>;
      <D.24467>:
      iftmp.22 = 2;
      goto <D.24469>;
      <D.24468>:
      iftmp.22 = -1;
      <D.24469>:
      iftmp.21 = iftmp.22;
      goto <D.24470>;
      <D.24465>:
      iftmp.21 = 1;
      <D.24470>:
      iftmp.20 = iftmp.21;
      goto <D.24471>;
      <D.24462>:
      iftmp.20 = 0;
      <D.24471>:
      iftmp.19 = iftmp.20;
      goto <D.24472>;
      <D.24459>:
      iftmp.19 = -1;
      <D.24472>:
      iftmp.18 = iftmp.19;
      goto <D.24473>;
      <D.24456>:
      iftmp.18 = -1;
      <D.24473>:
      desc_to_fixed_reg[i] = iftmp.18;
      i = i + 1;
      <D.23736>:
      if (i <= 255) goto <D.23735>; else goto <D.23737>;
      <D.23737>:
      desc_to_fixed_reg_inited = 1;
      i = 313;
      goto <D.23740>;
      <D.23739>:
      {
        const char * ispec;

        D.24474 = i + -313;
        D.24475 = amd64_desc_idx[D.24474];
        D.24476 = (sizetype) D.24475;
        spec = &amd64_desc + D.24476;
        D.24474 = i + -313;
        D.24477 = D.24474 * 4;
        ispec = &ins_info[D.24477];
        D.24478 = *spec;
        if (D.24478 != 0) goto <D.24479>; else goto <D.24480>;
        <D.24479>:
        D.24481 = *ispec;
        if (D.24481 == 32) goto <D.24482>; else goto <D.24483>;
        <D.24482>:
        D.24484 = mono_inst_name (i);
        printf ("Instruction metadata for %s inconsistent.\n", D.24484);
        <D.24483>:
        <D.24480>:
        D.24485 = spec + 1;
        D.24486 = *D.24485;
        if (D.24486 != 0) goto <D.24487>; else goto <D.24488>;
        <D.24487>:
        D.24489 = ispec + 1;
        D.24490 = *D.24489;
        if (D.24490 == 32) goto <D.24491>; else goto <D.24492>;
        <D.24491>:
        D.24493 = mono_inst_name (i);
        printf ("Instruction metadata for %s inconsistent.\n", D.24493);
        <D.24492>:
        <D.24488>:
        D.24494 = spec + 2;
        D.24495 = *D.24494;
        if (D.24495 != 0) goto <D.24496>; else goto <D.24497>;
        <D.24496>:
        D.24498 = ispec + 2;
        D.24499 = *D.24498;
        if (D.24499 == 32) goto <D.24500>; else goto <D.24501>;
        <D.24500>:
        D.24502 = mono_inst_name (i);
        printf ("Instruction metadata for %s inconsistent.\n", D.24502);
        <D.24501>:
        <D.24497>:
      }
      i = i + 1;
      <D.23740>:
      if (i <= 1075) goto <D.23739>; else goto <D.23741>;
      <D.23741>:
      <D.24453>:
      D.24503 = bb->max_vreg;
      D.24504 = (int) D.24503;
      rs->next_vreg = D.24504;
      mono_regstate_assign (rs);
      rs->ifree_mask = 1991;
      i = 0;
      goto <D.23743>;
      <D.23742>:
      D.24505 = regbank_callee_regs[i];
      rs->free_mask[i] = D.24505;
      i = i + 1;
      <D.23743>:
      if (i <= 4) goto <D.23742>; else goto <D.23744>;
      <D.23744>:
      max = rs->next_vreg;
      D.24506 = cfg->reginfo;
      if (D.24506 != 0B) goto <D.24507>; else goto <D.24508>;
      <D.24507>:
      D.24509 = cfg->reginfo_len;
      if (D.24509 < max) goto <D.24510>; else goto <D.24511>;
      <D.24510>:
      cfg->reginfo = 0B;
      <D.24511>:
      <D.24508>:
      reginfo = cfg->reginfo;
      if (reginfo == 0B) goto <D.24512>; else goto <D.24513>;
      <D.24512>:
      D.24514 = max * 2;
      D.24515 = MAX_EXPR <D.24514, 1024>;
      cfg->reginfo_len = D.24515;
      D.24509 = cfg->reginfo_len;
      D.24516 = (long unsigned int) D.24509;
      D.24517 = (unsigned int) D.24516;
      D.24518 = D.24517 * 16;
      D.24519 = cfg->mempool;
      D.24520 = mono_mempool_alloc (D.24519, D.24518);
      cfg->reginfo = D.24520;
      reginfo = cfg->reginfo;
      goto <D.24521>;
      <D.24513>:
      D.24509 = cfg->reginfo_len;
      D.24522 = rs->next_vreg;
      D.24523 = D.24509 < D.24522;
      D.24524 = (long int) D.24523;
      D.24525 = __builtin_expect (D.24524, 0);
      if (D.24525 != 0) goto <D.24526>; else goto <D.24527>;
      <D.24526>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1160, "cfg->reginfo_len >= rs->next_vreg");
      <D.24527>:
      <D.24521>:
      D.24528 = cfg->verbose_level;
      if (D.24528 > 1) goto <D.24529>; else goto <D.24530>;
      <D.24529>:
      D.24509 = cfg->reginfo_len;
      D.24516 = (long unsigned int) D.24509;
      D.24531 = D.24516 * 16;
      D.24506 = cfg->reginfo;
      memset (D.24506, 0, D.24531);
      <D.24530>:
      ins = bb->code;
      goto <D.23749>;
      <D.23748>:
      D.24532 = ins->opcode;
      D.24533 = (int) D.24532;
      D.24534 = D.24533 + -313;
      D.24535 = amd64_desc_idx[D.24534];
      D.24536 = (sizetype) D.24535;
      spec = &amd64_desc + D.24536;
      D.24537 = ins->dreg;
      if (D.24537 != -1) goto <D.24538>; else goto <D.24539>;
      <D.24538>:
      D.24537 = ins->dreg;
      if (D.24537 < max) goto <D.24540>; else goto <D.24541>;
      <D.24540>:
      D.24537 = ins->dreg;
      D.24542 = (long unsigned int) D.24537;
      D.24543 = D.24542 * 16;
      D.24544 = reginfo + D.24543;
      memset (D.24544, 0, 16);
      <D.24541>:
      <D.24539>:
      D.24545 = ins->sreg1;
      sregs[0] = D.24545;
      D.24546 = ins->sreg2;
      sregs[1] = D.24546;
      D.24547 = ins->sreg3;
      sregs[2] = D.24547;
      D.24532 = ins->opcode;
      D.24533 = (int) D.24532;
      D.24534 = D.24533 + -313;
      D.24548 = ins_sreg_counts[D.24534];
      num_sregs = (int) D.24548;
      j = 0;
      goto <D.23746>;
      <D.23745>:
      D.24549 = sregs[j];
      D.24550 = D.24549 == -1;
      D.24551 = (long int) D.24550;
      D.24552 = __builtin_expect (D.24551, 0);
      if (D.24552 != 0) goto <D.24553>; else goto <D.24554>;
      <D.24553>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1192, "sregs [j] != -1");
      <D.24554>:
      D.24549 = sregs[j];
      if (D.24549 < max) goto <D.24555>; else goto <D.24556>;
      <D.24555>:
      D.24549 = sregs[j];
      D.24557 = (long unsigned int) D.24549;
      D.24558 = D.24557 * 16;
      D.24559 = reginfo + D.24558;
      memset (D.24559, 0, 16);
      <D.24556>:
      j = j + 1;
      <D.23746>:
      if (j < num_sregs) goto <D.23745>; else goto <D.23747>;
      <D.23747>:
      mono_inst_set_src_registers (ins, &sregs);
      ins = ins->next;
      <D.23749>:
      if (ins != 0B) goto <D.23748>; else goto <D.23750>;
      <D.23750>:
      i = 1;
      D.24528 = cfg->verbose_level;
      D.24560 = D.24528 > 2;
      D.24561 = (long int) D.24560;
      D.24562 = __builtin_expect (D.24561, 0);
      if (D.24562 != 0) goto <D.24563>; else goto <D.24564>;
      <D.24563>:
      D.24565 = bb->block_num;
      printf ("\nLOCAL REGALLOC BLOCK %d:\n", D.24565);
      <D.24564>:
      ins = bb->code;
      goto <D.23773>;
      <D.23772>:
      D.24532 = ins->opcode;
      D.24533 = (int) D.24532;
      D.24534 = D.24533 + -313;
      D.24535 = amd64_desc_idx[D.24534];
      D.24536 = (sizetype) D.24535;
      spec = &amd64_desc + D.24536;
      D.24478 = *spec;
      spec_dest = (unsigned char) D.24478;
      D.24566 = spec == &amd64_desc;
      D.24567 = (long int) D.24566;
      D.24568 = __builtin_expect (D.24567, 0);
      if (D.24568 != 0) goto <D.24569>; else goto <D.24570>;
      <D.24569>:
      D.24532 = ins->opcode;
      D.24533 = (int) D.24532;
      D.24571 = mono_inst_name (D.24533);
      monoeg_g_log (0B, 4, "Opcode \'%s\' missing from machine description file.", D.24571);
      <D.23751>:
      goto <D.23751>;
      <D.24570>:
      D.24528 = cfg->verbose_level;
      D.24560 = D.24528 > 2;
      D.24561 = (long int) D.24560;
      D.24562 = __builtin_expect (D.24561, 0);
      if (D.24562 != 0) goto <D.24572>; else goto <D.24573>;
      <D.24572>:
      mono_print_ins_index (i, ins);
      <D.24573>:
      D.24545 = ins->sreg1;
      sregs[0] = D.24545;
      D.24546 = ins->sreg2;
      sregs[1] = D.24546;
      D.24547 = ins->sreg3;
      sregs[2] = D.24547;
      D.24532 = ins->opcode;
      D.24533 = (int) D.24532;
      D.24534 = D.24533 + -313;
      D.24548 = ins_sreg_counts[D.24534];
      num_sregs = (int) D.24548;
      j = 0;
      goto <D.23755>;
      <D.23754>:
      {
        int sreg;
        int sreg_spec;

        sreg = sregs[j];
        D.24574 = j + 1;
        D.24575 = (sizetype) D.24574;
        D.24576 = spec + D.24575;
        D.24577 = *D.24576;
        sreg_spec = (int) D.24577;
        if (sreg_spec != 0) goto <D.24578>; else goto <D.24579>;
        <D.24578>:
        D.24574 = j + 1;
        D.24575 = (sizetype) D.24574;
        D.24576 = spec + D.24575;
        D.24577 = *D.24576;
        D.24581 = D.24577 == 102;
        D.24582 = (long int) D.24581;
        D.24583 = __builtin_expect (D.24582, 0);
        if (D.24583 == 0) goto <D.24584>; else goto <D.24585>;
        <D.24584>:
        D.24574 = j + 1;
        D.24575 = (sizetype) D.24574;
        D.24576 = spec + D.24575;
        D.24577 = *D.24576;
        D.24587 = D.24577 == 120;
        D.24588 = (long int) D.24587;
        D.24589 = __builtin_expect (D.24588, 0);
        if (D.24589 != 0) goto <D.24590>; else goto <D.24591>;
        <D.24590>:
        iftmp.24 = 4;
        goto <D.24592>;
        <D.24591>:
        iftmp.24 = 0;
        <D.24592>:
        iftmp.23 = iftmp.24;
        goto <D.24593>;
        <D.24585>:
        iftmp.23 = 1;
        <D.24593>:
        bank = iftmp.23;
        D.24594 = sreg == -1;
        D.24595 = (long int) D.24594;
        D.24596 = __builtin_expect (D.24595, 0);
        if (D.24596 != 0) goto <D.24597>; else goto <D.24598>;
        <D.24597>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1240, "sreg != -1");
        <D.24598>:
        D.24600 = bank != 0;
        D.24601 = (long int) D.24600;
        D.24602 = __builtin_expect (D.24601, 0);
        if (D.24602 != 0) goto <D.24603>; else goto <D.24604>;
        <D.24603>:
        if (sreg < 0) goto <D.24606>; else goto <D.24609>;
        <D.24609>:
        D.24610 = regbank_size[bank];
        if (D.24610 <= sreg) goto <D.24606>; else goto <D.24607>;
        <D.24606>:
        iftmp.26 = 1;
        goto <D.24608>;
        <D.24607>:
        iftmp.26 = 0;
        <D.24608>:
        iftmp.25 = (_Bool) iftmp.26;
        goto <D.24611>;
        <D.24604>:
        iftmp.25 = sreg > 15;
        <D.24611>:
        if (iftmp.25 != 0) goto <D.24612>; else goto <D.24613>;
        <D.24612>:
        D.24614 = (long unsigned int) sreg;
        D.24615 = D.24614 * 16;
        D.24616 = reginfo + D.24615;
        D.24617 = D.24616->born_in;
        D.24618 = D.24617 <= 0;
        D.24619 = (long int) D.24618;
        D.24620 = __builtin_expect (D.24619, 0);
        if (D.24620 != 0) goto <D.24621>; else goto <D.24622>;
        <D.24621>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1243, "reginfo [sreg].born_in > 0");
        <D.24622>:
        <D.24613>:
        D.24623 = rs->vassign;
        D.24614 = (long unsigned int) sreg;
        D.24624 = D.24614 * 4;
        D.24625 = D.24623 + D.24624;
        *D.24625 = -1;
        if (0 != 0) goto <D.24626>; else goto <D.24627>;
        <D.24626>:
        D.24623 = rs->vassign;
        D.24628 = (sizetype) sreg;
        D.24629 = D.24628 + 1;
        D.24630 = D.24629 * 4;
        D.24631 = D.24623 + D.24630;
        *D.24631 = -1;
        D.24628 = (sizetype) sreg;
        D.24629 = D.24628 + 1;
        D.24634 = D.24629 * 16;
        D.24635 = reginfo + D.24634;
        D.24636 = D.24635->born_in;
        if (D.24636 == 0) goto <D.24632>; else goto <D.24637>;
        <D.24637>:
        D.24628 = (sizetype) sreg;
        D.24629 = D.24628 + 1;
        D.24634 = D.24629 * 16;
        D.24635 = reginfo + D.24634;
        D.24636 = D.24635->born_in;
        if (D.24636 > i) goto <D.24632>; else goto <D.24633>;
        <D.24632>:
        D.24628 = (sizetype) sreg;
        D.24629 = D.24628 + 1;
        D.24634 = D.24629 * 16;
        D.24635 = reginfo + D.24634;
        D.24635->born_in = i;
        <D.24633>:
        <D.24627>:
        goto <D.24638>;
        <D.24579>:
        sregs[j] = -1;
        <D.24638>:
      }
      j = j + 1;
      <D.23755>:
      if (j < num_sregs) goto <D.23754>; else goto <D.23756>;
      <D.23756>:
      mono_inst_set_src_registers (ins, &sregs);
      if (spec_dest != 0) goto <D.24639>; else goto <D.24640>;
      <D.24639>:
      {
        int dest_dreg;

        D.24478 = *spec;
        D.24642 = D.24478 == 102;
        D.24643 = (long int) D.24642;
        D.24644 = __builtin_expect (D.24643, 0);
        if (D.24644 == 0) goto <D.24645>; else goto <D.24646>;
        <D.24645>:
        D.24478 = *spec;
        D.24648 = D.24478 == 120;
        D.24649 = (long int) D.24648;
        D.24650 = __builtin_expect (D.24649, 0);
        if (D.24650 != 0) goto <D.24651>; else goto <D.24652>;
        <D.24651>:
        iftmp.28 = 4;
        goto <D.24653>;
        <D.24652>:
        iftmp.28 = 0;
        <D.24653>:
        iftmp.27 = iftmp.28;
        goto <D.24654>;
        <D.24646>:
        iftmp.27 = 1;
        <D.24654>:
        bank = iftmp.27;
        if (spec_dest != 98) goto <D.24655>; else goto <D.24656>;
        <D.24655>:
        D.24537 = ins->dreg;
        D.24542 = (long unsigned int) D.24537;
        D.24543 = D.24542 * 16;
        D.24657 = reginfo + D.24543;
        D.24657->killed_in = i;
        <D.24656>:
        D.24537 = ins->dreg;
        D.24658 = D.24537 == -1;
        D.24659 = (long int) D.24658;
        D.24660 = __builtin_expect (D.24659, 0);
        if (D.24660 != 0) goto <D.24661>; else goto <D.24662>;
        <D.24661>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1267, "ins->dreg != -1");
        <D.24662>:
        D.24623 = rs->vassign;
        D.24537 = ins->dreg;
        D.24542 = (long unsigned int) D.24537;
        D.24663 = D.24542 * 4;
        D.24664 = D.24623 + D.24663;
        *D.24664 = -1;
        D.24537 = ins->dreg;
        D.24542 = (long unsigned int) D.24537;
        D.24543 = D.24542 * 16;
        D.24657 = reginfo + D.24543;
        D.24667 = D.24657->born_in;
        if (D.24667 == 0) goto <D.24665>; else goto <D.24668>;
        <D.24668>:
        D.24537 = ins->dreg;
        D.24542 = (long unsigned int) D.24537;
        D.24543 = D.24542 * 16;
        D.24657 = reginfo + D.24543;
        D.24667 = D.24657->born_in;
        if (D.24667 > i) goto <D.24665>; else goto <D.24666>;
        <D.24665>:
        D.24537 = ins->dreg;
        D.24542 = (long unsigned int) D.24537;
        D.24543 = D.24542 * 16;
        D.24657 = reginfo + D.24543;
        D.24657->born_in = i;
        <D.24666>:
        D.24669 = (int) spec_dest;
        D.24670 = desc_to_fixed_reg[D.24669];
        dest_dreg = (int) D.24670;
        if (dest_dreg != -1) goto <D.24671>; else goto <D.24672>;
        <D.24671>:
        D.24537 = ins->dreg;
        D.24542 = (long unsigned int) D.24537;
        D.24543 = D.24542 * 16;
        D.24657 = reginfo + D.24543;
        D.24673 = 1 << dest_dreg;
        D.24657->preferred_mask = D.24673;
        <D.24672>:
        if (0 != 0) goto <D.24674>; else goto <D.24675>;
        <D.24674>:
        D.24623 = rs->vassign;
        D.24537 = ins->dreg;
        D.24676 = (sizetype) D.24537;
        D.24677 = D.24676 + 1;
        D.24678 = D.24677 * 4;
        D.24679 = D.24623 + D.24678;
        *D.24679 = -1;
        D.24537 = ins->dreg;
        D.24676 = (sizetype) D.24537;
        D.24677 = D.24676 + 1;
        D.24682 = D.24677 * 16;
        D.24683 = reginfo + D.24682;
        D.24684 = D.24683->born_in;
        if (D.24684 == 0) goto <D.24680>; else goto <D.24685>;
        <D.24685>:
        D.24537 = ins->dreg;
        D.24676 = (sizetype) D.24537;
        D.24677 = D.24676 + 1;
        D.24682 = D.24677 * 16;
        D.24683 = reginfo + D.24682;
        D.24684 = D.24683->born_in;
        if (D.24684 > i) goto <D.24680>; else goto <D.24681>;
        <D.24680>:
        D.24537 = ins->dreg;
        D.24676 = (sizetype) D.24537;
        D.24677 = D.24676 + 1;
        D.24682 = D.24677 * 16;
        D.24683 = reginfo + D.24682;
        D.24683->born_in = i;
        <D.24681>:
        if (0 != 0) goto <D.24686>; else goto <D.24687>;
        <D.24686>:
        D.24537 = ins->dreg;
        D.24676 = (sizetype) D.24537;
        D.24677 = D.24676 + 1;
        D.24682 = D.24677 * 16;
        D.24683 = reginfo + D.24682;
        D.24683->preferred_mask = 1991;
        <D.24687>:
        <D.24675>:
      }
      goto <D.24688>;
      <D.24640>:
      ins->dreg = -1;
      <D.24688>:
      D.24691 = spec + 5;
      D.24692 = *D.24691;
      if (D.24692 == 99) goto <D.24693>; else goto <D.24694>;
      <D.24693>:
      D.24695 = ins->opcode;
      D.24696 = D.24695 + 65193;
      D.24697 = D.24696 <= 2;
      D.24698 = D.24695 + 65187;
      D.24699 = D.24698 <= 2;
      D.24700 = D.24697 | D.24699;
      if (D.24700 != 0) goto <D.24689>; else goto <D.24701>;
      <D.24701>:
      D.24532 = ins->opcode;
      D.24702 = D.24532 + 65184;
      if (D.24702 <= 2) goto <D.24689>; else goto <D.24703>;
      <D.24703>:
      D.24532 = ins->opcode;
      D.24704 = D.24532 + 65181;
      if (D.24704 <= 2) goto <D.24689>; else goto <D.24705>;
      <D.24705>:
      D.24532 = ins->opcode;
      D.24706 = D.24532 + 65190;
      if (D.24706 <= 2) goto <D.24689>; else goto <D.24707>;
      <D.24707>:
      D.24532 = ins->opcode;
      D.24708 = D.24532 + 65178;
      if (D.24708 <= 2) goto <D.24689>; else goto <D.24709>;
      <D.24709>:
      D.24532 = ins->opcode;
      if (D.24532 == 448) goto <D.24689>; else goto <D.24690>;
      <D.24689>:
      {
        struct MonoCallInst * call;
        struct GSList * list;

        call = ins;
        list = call->out_ireg_args;
        if (list != 0B) goto <D.24710>; else goto <D.24711>;
        <D.24710>:
        goto <D.23764>;
        <D.23763>:
        {
          guint32 regpair;
          int reg;
          int hreg;

          D.24712 = list->data;
          D.24713 = (long int) D.24712;
          regpair = (guint32) D.24713;
          D.24714 = regpair >> 24;
          hreg = (int) D.24714;
          regpair.29 = (int) regpair;
          reg = regpair.29 & 16777215;
          if (list != 0B) goto <D.24717>; else goto <D.24718>;
          <D.24717>:
          iftmp.30 = list->next;
          goto <D.24719>;
          <D.24718>:
          iftmp.30 = 0B;
          <D.24719>:
          list = iftmp.30;
        }
        <D.23764>:
        if (list != 0B) goto <D.23763>; else goto <D.23765>;
        <D.23765>:
        <D.24711>:
        list = call->out_freg_args;
        if (list != 0B) goto <D.24720>; else goto <D.24721>;
        <D.24720>:
        goto <D.23770>;
        <D.23769>:
        {
          guint32 regpair;
          int reg;
          int hreg;

          D.24712 = list->data;
          D.24713 = (long int) D.24712;
          regpair = (guint32) D.24713;
          D.24722 = regpair >> 24;
          hreg = (int) D.24722;
          regpair.31 = (int) regpair;
          reg = regpair.31 & 16777215;
          if (list != 0B) goto <D.24725>; else goto <D.24726>;
          <D.24725>:
          iftmp.32 = list->next;
          goto <D.24727>;
          <D.24726>:
          iftmp.32 = 0B;
          <D.24727>:
          list = iftmp.32;
        }
        <D.23770>:
        if (list != 0B) goto <D.23769>; else goto <D.23771>;
        <D.23771>:
        <D.24721>:
      }
      <D.24690>:
      <D.24694>:
      i = i + 1;
      ins = ins->next;
      <D.23773>:
      if (ins != 0B) goto <D.23772>; else goto <D.23774>;
      <D.23774>:
      tmp = &last;
      D.24528 = cfg->verbose_level;
      D.24560 = D.24528 > 2;
      D.24561 = (long int) D.24560;
      D.24562 = __builtin_expect (D.24561, 0);
      if (D.24562 != 0) goto <D.24728>; else goto <D.24729>;
      <D.24728>:
      D.24522 = rs->next_vreg;
      print_regtrack (reginfo, D.24522);
      <D.24729>:
      ins = bb->last_ins;
      if (ins != 0B) goto <D.24731>; else goto <D.24732>;
      <D.24731>:
      iftmp.33 = ins->prev;
      goto <D.24733>;
      <D.24732>:
      iftmp.33 = 0B;
      <D.24733>:
      prev = iftmp.33;
      goto <D.23903>;
      <D.23902>:
      {
        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.24532 = ins->opcode;
            D.24533 = (int) D.24532;
            D.24534 = D.24533 + -313;
            D.24535 = amd64_desc_idx[D.24534];
            D.24536 = (sizetype) D.24535;
            spec = &amd64_desc + D.24536;
            D.24485 = spec + 1;
            D.24486 = *D.24485;
            spec_src1 = (unsigned char) D.24486;
            D.24478 = *spec;
            spec_dest = (unsigned char) D.24478;
            prev_dreg = -1;
            clob_dreg = -1;
            clob_reg = -1;
            dest_dreg = -1;
            dreg_high = -1;
            sreg1_high = -1;
            spec_dest.34 = (char) spec_dest;
            D.24735 = (int) spec_dest.34;
            dreg_mask = get_callee_mask (D.24735);
            j = 0;
            goto <D.23790>;
            <D.23789>:
            prev_sregs[j] = -1;
            D.24574 = j + 1;
            D.24575 = (sizetype) D.24574;
            D.24576 = spec + D.24575;
            D.24577 = *D.24576;
            D.24736 = (int) D.24577;
            D.24737 = get_callee_mask (D.24736);
            sreg_masks[j] = D.24737;
            D.24574 = j + 1;
            D.24575 = (sizetype) D.24574;
            D.24576 = spec + D.24575;
            D.24577 = *D.24576;
            D.24736 = (int) D.24577;
            D.24738 = desc_to_fixed_reg[D.24736];
            D.24739 = (int) D.24738;
            dest_sregs[j] = D.24739;
            sreg_fixed_masks[j] = 0;
            j = j + 1;
            <D.23790>:
            if (j <= 2) goto <D.23789>; else goto <D.23791>;
            <D.23791>:
            D.24528 = cfg->verbose_level;
            D.24560 = D.24528 > 2;
            D.24561 = (long int) D.24560;
            D.24562 = __builtin_expect (D.24561, 0);
            if (D.24562 != 0) goto <D.24740>; else goto <D.24741>;
            <D.24740>:
            printf ("processing:");
            <D.24741>:
            D.24528 = cfg->verbose_level;
            D.24560 = D.24528 > 2;
            D.24561 = (long int) D.24560;
            D.24562 = __builtin_expect (D.24561, 0);
            if (D.24562 != 0) goto <D.24742>; else goto <D.24743>;
            <D.24742>:
            mono_print_ins_index (i, ins);
            <D.24743>:
            ip = ins->cil_code;
            last = ins;
            D.24669 = (int) spec_dest;
            D.24670 = desc_to_fixed_reg[D.24669];
            dest_dreg = (int) D.24670;
            D.24691 = spec + 5;
            D.24692 = *D.24691;
            D.24744 = (int) D.24692;
            D.24745 = desc_to_fixed_reg[D.24744];
            clob_reg = (int) D.24745;
            D.24746 = sreg_masks[1];
            D.24691 = spec + 5;
            D.24692 = *D.24691;
            D.24748 = D.24692 == 97;
            D.24691 = spec + 5;
            D.24692 = *D.24691;
            D.24749 = D.24692 == 100;
            D.24750 = D.24748 | D.24749;
            if (D.24750 != 0) goto <D.24751>; else goto <D.24752>;
            <D.24751>:
            iftmp.35 = 18446744073709551611;
            goto <D.24753>;
            <D.24752>:
            iftmp.35 = 18446744073709551615;
            <D.24753>:
            D.24754 = D.24746 & iftmp.35;
            sreg_masks[1] = D.24754;
            dreg_fixed_mask = 0;
            D.24545 = ins->sreg1;
            sregs[0] = D.24545;
            D.24546 = ins->sreg2;
            sregs[1] = D.24546;
            D.24547 = ins->sreg3;
            sregs[2] = D.24547;
            D.24532 = ins->opcode;
            D.24533 = (int) D.24532;
            D.24534 = D.24533 + -313;
            D.24548 = ins_sreg_counts[D.24534];
            num_sregs = (int) D.24548;
            j = 1;
            goto <D.23822>;
            <D.23821>:
            {
              int sreg;
              int dest_sreg;

              sreg = sregs[j];
              dest_sreg = dest_sregs[j];
              if (dest_sreg == -1) goto <D.24755>; else goto <D.24756>;
              <D.24755>:
              // predicted unlikely by continue predictor.
              goto <D.23794>;
              <D.24756>:
              if (j == 2) goto <D.24757>; else goto <D.24758>;
              <D.24757>:
              {
                int k;

                D.24759 = 1 << dest_sreg;
                sreg_masks[j] = D.24759;
                k = 0;
                goto <D.23797>;
                <D.23796>:
                if (k != j) goto <D.24760>; else goto <D.24761>;
                <D.24760>:
                D.24762 = sreg_masks[k];
                D.24759 = 1 << dest_sreg;
                D.24763 = ~D.24759;
                D.24764 = D.24762 & D.24763;
                sreg_masks[k] = D.24764;
                <D.24761>:
                k = k + 1;
                <D.23797>:
                if (k < num_sregs) goto <D.23796>; else goto <D.23798>;
                <D.23798>:
                k = 0;
                goto <D.23800>;
                <D.23799>:
                if (k != j) goto <D.24765>; else goto <D.24766>;
                <D.24765>:
                D.24767 = sregs[k];
                if (D.24767 > 15) goto <D.24768>; else goto <D.24769>;
                <D.24768>:
                D.24623 = rs->vassign;
                D.24767 = sregs[k];
                D.24770 = (long unsigned int) D.24767;
                D.24771 = D.24770 * 4;
                D.24772 = D.24623 + D.24771;
                D.24773 = *D.24772;
                if (D.24773 == dest_sreg) goto <D.24774>; else goto <D.24775>;
                <D.24774>:
                free_up_hreg (cfg, bb, tmp, ins, dest_sreg, 0);
                <D.24775>:
                <D.24769>:
                <D.24766>:
                k = k + 1;
                <D.23800>:
                if (k < num_sregs) goto <D.23799>; else goto <D.23801>;
                <D.23801>:
                if (sreg > 15) goto <D.24776>; else goto <D.24777>;
                <D.24776>:
                D.24623 = rs->vassign;
                D.24778 = (long unsigned int) sreg;
                D.24779 = D.24778 * 4;
                D.24780 = D.24623 + D.24779;
                D.24781 = *D.24780;
                if (D.24781 >= 0) goto <D.24782>; else goto <D.24783>;
                <D.24782>:
                D.24623 = rs->vassign;
                D.24778 = (long unsigned int) sreg;
                D.24779 = D.24778 * 4;
                D.24780 = D.24623 + D.24779;
                D.24781 = *D.24780;
                if (D.24781 != dest_sreg) goto <D.24784>; else goto <D.24785>;
                <D.24784>:
                spill_vreg (cfg, bb, tmp, ins, sreg, 0);
                <D.24785>:
                <D.24783>:
                <D.24777>:
                // predicted unlikely by continue predictor.
                goto <D.23794>;
              }
              <D.24758>:
              D.24786 = rs->ifree_mask;
              D.24787 = D.24786 >> dest_sreg;
              D.24788 = D.24787 & 1;
              if (D.24788 != 0) goto <D.24789>; else goto <D.24790>;
              <D.24789>:
              sreg.36 = (unsigned int) sreg;
              if (sreg.36 <= 15) goto <D.24794>; else goto <D.24791>;
              <D.24794>:
              D.24795 = 61480 >> sreg;
              D.24796 = D.24795 & 1;
              if (D.24796 != 0) goto <D.24797>; else goto <D.24791>;
              <D.24797>:
              {
                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.23805>;
                <D.23804>:
                if (k != j) goto <D.24798>; else goto <D.24799>;
                <D.24798>:
                D.24800 = sreg_masks[k];
                D.24759 = 1 << dest_sreg;
                D.24763 = ~D.24759;
                D.24801 = D.24800 & D.24763;
                sreg_masks[k] = D.24801;
                <D.24799>:
                k = k + 1;
                <D.23805>:
                if (k < num_sregs) goto <D.23804>; else goto <D.23806>;
                <D.23806>:
              }
              goto <D.24792>;
              <D.24791>:
              D.24623 = rs->vassign;
              D.24778 = (long unsigned int) sreg;
              D.24779 = D.24778 * 4;
              D.24780 = D.24623 + D.24779;
              val = *D.24780;
              if (val == -1) goto <D.24802>; else goto <D.24803>;
              <D.24802>:
              D.24528 = cfg->verbose_level;
              D.24560 = D.24528 > 2;
              D.24561 = (long int) D.24560;
              D.24562 = __builtin_expect (D.24561, 0);
              if (D.24562 != 0) goto <D.24804>; else goto <D.24805>;
              <D.24804>:
              D.24806 = mono_arch_regname (dest_sreg);
              printf ("\tshortcut assignment of R%d to %s\n", sreg, D.24806);
              <D.24805>:
              assign_reg (cfg, rs, sreg, dest_sreg, 0);
              goto <D.24807>;
              <D.24803>:
              if (val < -1) goto <D.24808>; else goto <D.24809>;
              <D.24808>:
              monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-codegen.c", 1459);
              <D.24809>:
              {
                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.23810>;
                <D.23809>:
                if (k != j) goto <D.24810>; else goto <D.24811>;
                <D.24810>:
                D.24812 = sreg_masks[k];
                D.24759 = 1 << dest_sreg;
                D.24763 = ~D.24759;
                D.24813 = D.24812 & D.24763;
                sreg_masks[k] = D.24813;
                <D.24811>:
                k = k + 1;
                <D.23810>:
                if (k < num_sregs) goto <D.23809>; else goto <D.23811>;
                <D.23811>:
                D.24759 = 1 << dest_sreg;
                D.24763 = ~D.24759;
                dreg_mask = D.24763 & dreg_mask;
              }
              <D.24807>:
              <D.24792>:
              goto <D.24814>;
              <D.24790>:
              {
                gboolean need_spill;
                gboolean need_assign;
                int k;

                need_spill = 1;
                need_assign = 1;
                D.24759 = 1 << dest_sreg;
                D.24763 = ~D.24759;
                dreg_mask = D.24763 & dreg_mask;
                k = 0;
                goto <D.23816>;
                <D.23815>:
                if (k != j) goto <D.24815>; else goto <D.24816>;
                <D.24815>:
                D.24817 = sreg_masks[k];
                D.24759 = 1 << dest_sreg;
                D.24763 = ~D.24759;
                D.24818 = D.24817 & D.24763;
                sreg_masks[k] = D.24818;
                <D.24816>:
                k = k + 1;
                <D.23816>:
                if (k < num_sregs) goto <D.23815>; else goto <D.23817>;
                <D.23817>:
                D.24478 = *spec;
                if (D.24478 != 0) goto <D.24819>; else goto <D.24820>;
                <D.24819>:
                D.24623 = rs->vassign;
                D.24537 = ins->dreg;
                D.24542 = (long unsigned int) D.24537;
                D.24663 = D.24542 * 4;
                D.24664 = D.24623 + D.24663;
                val = *D.24664;
                goto <D.24821>;
                <D.24820>:
                val = -1;
                <D.24821>:
                if (val == dest_sreg) goto <D.24822>; else goto <D.24823>;
                <D.24822>:
                D.24537 = ins->dreg;
                if (D.24537 != sreg) goto <D.24824>; else goto <D.24825>;
                <D.24824>:
                {
                  int new_dest;

                  D.24537 = ins->dreg;
                  D.24542 = (long unsigned int) D.24537;
                  D.24543 = D.24542 * 16;
                  D.24657 = reginfo + D.24543;
                  D.24537 = ins->dreg;
                  new_dest = alloc_int_reg (cfg, bb, tmp, ins, dreg_mask, D.24537, D.24657);
                  D.24826 = new_dest < 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", 1505, "new_dest >= 0");
                  <D.24830>:
                  D.24528 = cfg->verbose_level;
                  D.24560 = D.24528 > 2;
                  D.24561 = (long int) D.24560;
                  D.24562 = __builtin_expect (D.24561, 0);
                  if (D.24562 != 0) goto <D.24831>; else goto <D.24832>;
                  <D.24831>:
                  D.24833 = mono_arch_regname (dest_sreg);
                  D.24834 = mono_arch_regname (new_dest);
                  D.24537 = ins->dreg;
                  printf ("\tchanging dreg R%d to %s from %s\n", D.24537, D.24834, D.24833);
                  <D.24832>:
                  prev_dreg = ins->dreg;
                  D.24537 = ins->dreg;
                  assign_reg (cfg, rs, D.24537, 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.24825>:
                <D.24823>:
                sreg.36 = (unsigned int) sreg;
                if (sreg.36 <= 15) goto <D.24837>; else goto <D.24835>;
                <D.24837>:
                D.24795 = 61480 >> sreg;
                D.24796 = D.24795 & 1;
                if (D.24796 != 0) goto <D.24838>; else goto <D.24835>;
                <D.24838>:
                {
                  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.24836>;
                <D.24835>:
                D.24623 = rs->vassign;
                D.24778 = (long unsigned int) sreg;
                D.24779 = D.24778 * 4;
                D.24780 = D.24623 + D.24779;
                val = *D.24780;
                if (val == dest_sreg) goto <D.24839>; else goto <D.24840>;
                <D.24839>:
                need_spill = 0;
                goto <D.24841>;
                <D.24840>:
                if (val < -1) goto <D.24842>; else goto <D.24843>;
                <D.24842>:
                goto <D.24844>;
                <D.24843>:
                if (val >= 0) goto <D.24845>; else goto <D.24846>;
                <D.24845>:
                free_up_hreg (cfg, bb, tmp, ins, val, 0);
                <D.24846>:
                <D.24844>:
                <D.24841>:
                <D.24836>:
                if (need_spill != 0) goto <D.24847>; else goto <D.24848>;
                <D.24847>:
                free_up_hreg (cfg, bb, tmp, ins, dest_sreg, 0);
                <D.24848>:
                if (need_assign != 0) goto <D.24849>; else goto <D.24850>;
                <D.24849>:
                D.24623 = rs->vassign;
                D.24778 = (long unsigned int) sreg;
                D.24779 = D.24778 * 4;
                D.24780 = D.24623 + D.24779;
                D.24781 = *D.24780;
                if (D.24781 < -1) goto <D.24851>; else goto <D.24852>;
                <D.24851>:
                {
                  int spill;

                  D.24623 = rs->vassign;
                  D.24778 = (long unsigned int) sreg;
                  D.24779 = D.24778 * 4;
                  D.24780 = D.24623 + D.24779;
                  D.24781 = *D.24780;
                  spill = ~D.24781;
                  create_spilled_store (cfg, bb, spill, dest_sreg, sreg, tmp, 0B, ins, bank);
                }
                <D.24852>:
                D.24549 = sregs[j];
                assign_reg (cfg, rs, D.24549, dest_sreg, 0);
                <D.24850>:
              }
              <D.24814>:
              sregs[j] = dest_sreg;
            }
            <D.23794>:
            j = j + 1;
            <D.23822>:
            if (j < num_sregs) goto <D.23821>; else goto <D.23823>;
            <D.23823>:
            mono_inst_set_src_registers (ins, &sregs);
            D.24478 = *spec;
            D.24642 = D.24478 == 102;
            D.24643 = (long int) D.24642;
            D.24644 = __builtin_expect (D.24643, 0);
            if (D.24644 == 0) goto <D.24854>; else goto <D.24855>;
            <D.24854>:
            D.24478 = *spec;
            D.24648 = D.24478 == 120;
            D.24649 = (long int) D.24648;
            D.24650 = __builtin_expect (D.24649, 0);
            if (D.24650 != 0) goto <D.24857>; else goto <D.24858>;
            <D.24857>:
            iftmp.38 = 4;
            goto <D.24859>;
            <D.24858>:
            iftmp.38 = 0;
            <D.24859>:
            iftmp.37 = iftmp.38;
            goto <D.24860>;
            <D.24855>:
            iftmp.37 = 1;
            <D.24860>:
            bank = iftmp.37;
            if (spec_dest != 0) goto <D.24861>; else goto <D.24862>;
            <D.24861>:
            D.24600 = bank != 0;
            D.24601 = (long int) D.24600;
            D.24602 = __builtin_expect (D.24601, 0);
            if (D.24602 != 0) goto <D.24864>; else goto <D.24865>;
            <D.24864>:
            D.24537 = ins->dreg;
            if (D.24537 < 0) goto <D.24867>; else goto <D.24870>;
            <D.24870>:
            D.24537 = ins->dreg;
            D.24610 = regbank_size[bank];
            if (D.24537 >= D.24610) goto <D.24867>; else goto <D.24868>;
            <D.24867>:
            iftmp.40 = 1;
            goto <D.24869>;
            <D.24868>:
            iftmp.40 = 0;
            <D.24869>:
            iftmp.39 = (_Bool) iftmp.40;
            goto <D.24871>;
            <D.24865>:
            D.24537 = ins->dreg;
            iftmp.39 = D.24537 > 15;
            <D.24871>:
            if (iftmp.39 != 0) goto <D.24872>; else goto <D.24873>;
            <D.24872>:
            prev_dreg = ins->dreg;
            <D.24873>:
            <D.24862>:
            if (spec_dest == 98) goto <D.24874>; else goto <D.24875>;
            <D.24874>:
            D.24876 = dest_sregs[0];
            if (D.24876 != -1) goto <D.24877>; else goto <D.24878>;
            <D.24877>:
            D.24876 = dest_sregs[0];
            D.24879 = 1 << D.24876;
            D.24880 = ~D.24879;
            dreg_mask = D.24880 & dreg_mask;
            <D.24878>:
            j = 1;
            goto <D.23825>;
            <D.23824>:
            D.24881 = dest_sregs[j];
            if (D.24881 != -1) goto <D.24882>; else goto <D.24883>;
            <D.24882>:
            D.24881 = dest_sregs[j];
            D.24884 = 1 << D.24881;
            D.24885 = ~D.24884;
            dreg_mask = D.24885 & dreg_mask;
            <D.24883>:
            j = j + 1;
            <D.23825>:
            if (j < num_sregs) goto <D.23824>; else goto <D.23826>;
            <D.23826>:
            D.24623 = rs->vassign;
            D.24537 = ins->dreg;
            D.24542 = (long unsigned int) D.24537;
            D.24663 = D.24542 * 4;
            D.24664 = D.24623 + D.24663;
            val = *D.24664;
            D.24600 = bank != 0;
            D.24601 = (long int) D.24600;
            D.24602 = __builtin_expect (D.24601, 0);
            if (D.24602 != 0) goto <D.24887>; else goto <D.24888>;
            <D.24887>:
            D.24537 = ins->dreg;
            if (D.24537 < 0) goto <D.24890>; else goto <D.24893>;
            <D.24893>:
            D.24537 = ins->dreg;
            D.24610 = regbank_size[bank];
            if (D.24537 >= D.24610) goto <D.24890>; else goto <D.24891>;
            <D.24890>:
            iftmp.42 = 1;
            goto <D.24892>;
            <D.24891>:
            iftmp.42 = 0;
            <D.24892>:
            iftmp.41 = (_Bool) iftmp.42;
            goto <D.24894>;
            <D.24888>:
            D.24537 = ins->dreg;
            iftmp.41 = D.24537 > 15;
            <D.24894>:
            if (iftmp.41 != 0) goto <D.24895>; else goto <D.24896>;
            <D.24895>:
            if (val >= 0) goto <D.24897>; else goto <D.24898>;
            <D.24897>:
            D.24899 = dreg_mask >> val;
            D.24900 = D.24899 & 1;
            if (D.24900 == 0) goto <D.24901>; else goto <D.24902>;
            <D.24901>:
            D.24537 = ins->dreg;
            spill_vreg (cfg, bb, tmp, ins, D.24537, 0);
            <D.24902>:
            <D.24898>:
            <D.24896>:
            <D.24875>:
            if (0 != 0) goto <D.24903>; else goto <D.24904>;
            <D.24903>:
            {
              guint32 dreg2;
              guint32 dest_dreg2;

              D.24600 = bank != 0;
              D.24601 = (long int) D.24600;
              D.24602 = __builtin_expect (D.24601, 0);
              if (D.24602 != 0) goto <D.24906>; else goto <D.24907>;
              <D.24906>:
              D.24537 = ins->dreg;
              if (D.24537 >= 0) goto <D.24911>; else goto <D.24909>;
              <D.24911>:
              D.24537 = ins->dreg;
              D.24610 = regbank_size[bank];
              if (D.24537 < D.24610) goto <D.24912>; else goto <D.24909>;
              <D.24912>:
              iftmp.44 = 1;
              goto <D.24910>;
              <D.24909>:
              iftmp.44 = 0;
              <D.24910>:
              D.24913 = iftmp.44 != 0;
              D.24914 = (int) D.24913;
              iftmp.43 = (long int) D.24914;
              goto <D.24915>;
              <D.24907>:
              D.24537 = ins->dreg;
              D.24916 = D.24537 <= 15;
              D.24917 = (int) D.24916;
              iftmp.43 = (long int) D.24917;
              <D.24915>:
              D.24918 = __builtin_expect (iftmp.43, 0);
              if (D.24918 != 0) goto <D.24919>; else goto <D.24920>;
              <D.24919>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1594, "is_soft_reg (ins->dreg, bank)");
              <D.24920>:
              if (dest_dreg != -1) goto <D.24921>; else goto <D.24922>;
              <D.24921>:
              D.24623 = rs->vassign;
              D.24537 = ins->dreg;
              D.24542 = (long unsigned int) D.24537;
              D.24663 = D.24542 * 4;
              D.24664 = D.24623 + D.24663;
              D.24923 = *D.24664;
              if (D.24923 != dest_dreg) goto <D.24924>; else goto <D.24925>;
              <D.24924>:
              free_up_hreg (cfg, bb, tmp, ins, dest_dreg, 0);
              <D.24925>:
              D.24537 = ins->dreg;
              D.24926 = D.24537 + 1;
              dreg2 = (guint32) D.24926;
              dest_dreg2 = 4294967295;
              if (dest_dreg2 != 4294967295) goto <D.24927>; else goto <D.24928>;
              <D.24927>:
              D.24623 = rs->vassign;
              D.24929 = (long unsigned int) dreg2;
              D.24930 = D.24929 * 4;
              D.24931 = D.24623 + D.24930;
              D.24932 = *D.24931;
              D.24933 = (unsigned int) D.24932;
              if (D.24933 != dest_dreg2) goto <D.24934>; else goto <D.24935>;
              <D.24934>:
              dest_dreg2.45 = (int) dest_dreg2;
              free_up_hreg (cfg, bb, tmp, ins, dest_dreg2.45, 0);
              <D.24935>:
              <D.24928>:
              <D.24922>:
            }
            <D.24904>:
            if (dreg_fixed_mask != 0) goto <D.24937>; else goto <D.24938>;
            <D.24937>:
            D.24600 = bank != 0;
            D.24601 = (long int) D.24600;
            D.24602 = __builtin_expect (D.24601, 0);
            if (D.24602 != 0) goto <D.24939>; else goto <D.24940>;
            <D.24939>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1610, "!bank");
            <D.24940>:
            D.24537 = ins->dreg;
            D.24943 = (unsigned int) D.24537;
            if (D.24943 <= 15) goto <D.24944>; else goto <D.24941>;
            <D.24944>:
            D.24537 = ins->dreg;
            D.24945 = 61480 >> D.24537;
            D.24946 = D.24945 & 1;
            if (D.24946 != 0) goto <D.24947>; else goto <D.24941>;
            <D.24947>:
            val = mono_regstate_alloc_int (rs, dreg_fixed_mask);
            if (val < 0) goto <D.24948>; else goto <D.24949>;
            <D.24948>:
            val = get_register_spilling (cfg, bb, tmp, ins, dreg_fixed_mask, -1, bank);
            <D.24949>:
            mono_regstate_free_int (rs, val);
            dest_dreg = val;
            goto <D.24942>;
            <D.24941>:
            dreg_mask = dreg_mask & dreg_fixed_mask;
            <D.24942>:
            <D.24938>:
            D.24600 = bank != 0;
            D.24601 = (long int) D.24600;
            D.24602 = __builtin_expect (D.24601, 0);
            if (D.24602 != 0) goto <D.24951>; else goto <D.24952>;
            <D.24951>:
            D.24537 = ins->dreg;
            if (D.24537 < 0) goto <D.24954>; else goto <D.24957>;
            <D.24957>:
            D.24537 = ins->dreg;
            D.24610 = regbank_size[bank];
            if (D.24537 >= D.24610) goto <D.24954>; else goto <D.24955>;
            <D.24954>:
            iftmp.47 = 1;
            goto <D.24956>;
            <D.24955>:
            iftmp.47 = 0;
            <D.24956>:
            iftmp.46 = (_Bool) iftmp.47;
            goto <D.24958>;
            <D.24952>:
            D.24537 = ins->dreg;
            iftmp.46 = D.24537 > 15;
            <D.24958>:
            if (iftmp.46 != 0) goto <D.24959>; else goto <D.24960>;
            <D.24959>:
            D.24623 = rs->vassign;
            D.24537 = ins->dreg;
            D.24542 = (long unsigned int) D.24537;
            D.24663 = D.24542 * 4;
            D.24664 = D.24623 + D.24663;
            val = *D.24664;
            if (val < 0) goto <D.24961>; else goto <D.24962>;
            <D.24961>:
            {
              int spill;

              spill = 0;
              if (val < -1) goto <D.24963>; else goto <D.24964>;
              <D.24963>:
              spill = ~val;
              <D.24964>:
              D.24537 = ins->dreg;
              D.24542 = (long unsigned int) D.24537;
              D.24543 = D.24542 * 16;
              D.24657 = reginfo + D.24543;
              D.24537 = ins->dreg;
              val = alloc_reg (cfg, bb, tmp, ins, dreg_mask, D.24537, D.24657, bank);
              D.24537 = ins->dreg;
              assign_reg (cfg, rs, D.24537, val, bank);
              if (spill != 0) goto <D.24965>; else goto <D.24966>;
              <D.24965>:
              create_spilled_store (cfg, bb, spill, val, prev_dreg, tmp, ins, 0B, bank);
              <D.24966>:
            }
            <D.24962>:
            D.24528 = cfg->verbose_level;
            D.24560 = D.24528 > 2;
            D.24561 = (long int) D.24560;
            D.24562 = __builtin_expect (D.24561, 0);
            if (D.24562 != 0) goto <D.24967>; else goto <D.24968>;
            <D.24967>:
            D.24537 = ins->dreg;
            D.24969 = mono_regname_full (val, bank);
            printf ("\tassigned dreg %s to dest R%d\n", D.24969, D.24537);
            <D.24968>:
            ins->dreg = val;
            <D.24960>:
            if (0 != 0) goto <D.24970>; else goto <D.24971>;
            <D.24970>:
            {
              int reg2;

              reg2 = prev_dreg + 1;
              D.24600 = bank != 0;
              D.24601 = (long int) D.24600;
              D.24602 = __builtin_expect (D.24601, 0);
              if (D.24602 != 0) goto <D.24972>; else goto <D.24973>;
              <D.24972>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1651, "!bank");
              <D.24973>:
              D.24974 = prev_dreg < 0;
              D.24975 = (long int) D.24974;
              D.24976 = __builtin_expect (D.24975, 0);
              if (D.24976 != 0) goto <D.24977>; else goto <D.24978>;
              <D.24977>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1652, "prev_dreg > -1");
              <D.24978>:
              D.24623 = rs->vassign;
              D.24982 = (long unsigned int) prev_dreg;
              D.24983 = D.24982 * 4;
              D.24984 = D.24623 + D.24983;
              D.24985 = *D.24984;
              D.24986 = (unsigned int) D.24985;
              if (D.24986 <= 15) goto <D.24987>; else goto <D.24980>;
              <D.24987>:
              D.24623 = rs->vassign;
              D.24982 = (long unsigned int) prev_dreg;
              D.24983 = D.24982 * 4;
              D.24984 = D.24623 + D.24983;
              D.24985 = *D.24984;
              D.24988 = 61480 >> D.24985;
              D.24989 = D.24988 & 1;
              if (D.24989 != 0) goto <D.24990>; else goto <D.24980>;
              <D.24990>:
              iftmp.48 = 1;
              goto <D.24981>;
              <D.24980>:
              iftmp.48 = 0;
              <D.24981>:
              D.24991 = iftmp.48 != 0;
              D.24992 = (long int) D.24991;
              D.24993 = __builtin_expect (D.24992, 0);
              if (D.24993 != 0) goto <D.24994>; else goto <D.24995>;
              <D.24994>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1653, "!is_global_ireg (rs->vassign [prev_dreg])");
              <D.24995>:
              mask = 1991;
              D.24623 = rs->vassign;
              D.24996 = (long unsigned int) reg2;
              D.24997 = D.24996 * 4;
              D.24998 = D.24623 + D.24997;
              val = *D.24998;
              if (val < 0) goto <D.24999>; else goto <D.25000>;
              <D.24999>:
              {
                int spill;

                spill = 0;
                if (val < -1) goto <D.25001>; else goto <D.25002>;
                <D.25001>:
                spill = ~val;
                <D.25002>:
                val = mono_regstate_alloc_int (rs, mask);
                if (val < 0) goto <D.25003>; else goto <D.25004>;
                <D.25003>:
                val = get_register_spilling (cfg, bb, tmp, ins, mask, reg2, bank);
                <D.25004>:
                if (spill != 0) goto <D.25005>; else goto <D.25006>;
                <D.25005>:
                create_spilled_store (cfg, bb, spill, val, reg2, tmp, ins, 0B, bank);
                <D.25006>:
              }
              goto <D.25007>;
              <D.25000>:
              D.25008 = mask >> val;
              D.25009 = D.25008 & 1;
              if (D.25009 == 0) goto <D.25010>; else goto <D.25011>;
              <D.25010>:
              val = mono_regstate_alloc_int (rs, mask);
              if (val < 0) goto <D.25012>; else goto <D.25013>;
              <D.25012>:
              val = get_register_spilling (cfg, bb, tmp, ins, mask, reg2, bank);
              <D.25013>:
              D.24623 = rs->vassign;
              D.24996 = (long unsigned int) reg2;
              D.24997 = D.24996 * 4;
              D.24998 = D.24623 + D.24997;
              D.25014 = *D.24998;
              create_copy_ins (cfg, bb, tmp, D.25014, val, ins, ip, bank);
              D.24623 = rs->vassign;
              D.24996 = (long unsigned int) reg2;
              D.24997 = D.24996 * 4;
              D.24998 = D.24623 + D.24997;
              D.25014 = *D.24998;
              mono_regstate_free_int (rs, D.25014);
              <D.25011>:
              <D.25007>:
              D.24528 = cfg->verbose_level;
              D.24560 = D.24528 > 2;
              D.24561 = (long int) D.24560;
              D.24562 = __builtin_expect (D.24561, 0);
              if (D.24562 != 0) goto <D.25015>; else goto <D.25016>;
              <D.25015>:
              D.25017 = mono_arch_regname (val);
              printf ("\tassigned dreg-high %s to dest R%d\n", D.25017, reg2);
              <D.25016>:
              assign_reg (cfg, rs, reg2, val, bank);
              dreg_high = val;
              ins->backend.reg3 = val;
              D.24600 = bank != 0;
              D.24601 = (long int) D.24600;
              D.24602 = __builtin_expect (D.24601, 0);
              if (D.24602 != 0) goto <D.25019>; else goto <D.25020>;
              <D.25019>:
              D.24600 = bank != 0;
              D.24601 = (long int) D.24600;
              D.24602 = __builtin_expect (D.24601, 0);
              if (D.24602 != 0) goto <D.25022>; else goto <D.25023>;
              <D.25022>:
              D.24600 = bank != 0;
              D.24601 = (long int) D.24600;
              D.24602 = __builtin_expect (D.24601, 0);
              if (D.24602 != 0) goto <D.25027>; else goto <D.25028>;
              <D.25027>:
              if (val >= 0) goto <D.25032>; else goto <D.25030>;
              <D.25032>:
              D.24610 = regbank_size[bank];
              if (D.24610 > val) goto <D.25033>; else goto <D.25030>;
              <D.25033>:
              iftmp.52 = 1;
              goto <D.25031>;
              <D.25030>:
              iftmp.52 = 0;
              <D.25031>:
              D.25034 = (_Bool) iftmp.52;
              if (D.25034 != 0) goto <D.25035>; else goto <D.25025>;
              <D.25035>:
              goto <D.25036>;
              <D.25028>:
              if (val <= 15) goto <D.25037>; else goto <D.25025>;
              <D.25037>:
              <D.25036>:
              D.25038 = regbank_callee_regs[bank];
              D.25039 = D.25038 >> val;
              D.25040 = D.25039 & 1;
              if (D.25040 != 0) goto <D.25041>; else goto <D.25025>;
              <D.25041>:
              iftmp.51 = 1;
              goto <D.25026>;
              <D.25025>:
              iftmp.51 = 0;
              <D.25026>:
              iftmp.50 = (_Bool) iftmp.51;
              goto <D.25042>;
              <D.25023>:
              val.54 = (unsigned int) val;
              if (val.54 <= 15) goto <D.25047>; else goto <D.25044>;
              <D.25047>:
              D.25048 = 1991 >> val;
              D.25049 = D.25048 & 1;
              if (D.25049 != 0) goto <D.25050>; else goto <D.25044>;
              <D.25050>:
              iftmp.53 = 1;
              goto <D.25045>;
              <D.25044>:
              iftmp.53 = 0;
              <D.25045>:
              iftmp.50 = (_Bool) iftmp.53;
              <D.25042>:
              iftmp.49 = iftmp.50;
              goto <D.25051>;
              <D.25020>:
              val.54 = (unsigned int) val;
              if (val.54 <= 15) goto <D.25055>; else goto <D.25053>;
              <D.25055>:
              D.25048 = 1991 >> val;
              D.25049 = D.25048 & 1;
              if (D.25049 != 0) goto <D.25056>; else goto <D.25053>;
              <D.25056>:
              iftmp.55 = 1;
              goto <D.25054>;
              <D.25053>:
              iftmp.55 = 0;
              <D.25054>:
              iftmp.49 = (_Bool) iftmp.55;
              <D.25051>:
              if (iftmp.49 != 0) goto <D.25057>; else goto <D.25058>;
              <D.25057>:
              if (reg2 >= 0) goto <D.25059>; else goto <D.25060>;
              <D.25059>:
              D.24996 = (long unsigned int) reg2;
              D.25061 = D.24996 * 16;
              D.25062 = reginfo + D.25061;
              D.25063 = D.25062->born_in;
              if (D.25063 >= i) goto <D.25064>; else goto <D.25065>;
              <D.25064>:
              D.24528 = cfg->verbose_level;
              D.24560 = D.24528 > 2;
              D.24561 = (long int) D.24560;
              D.24562 = __builtin_expect (D.24561, 0);
              if (D.24562 != 0) goto <D.25066>; else goto <D.25067>;
              <D.25066>:
              D.25068 = mono_arch_regname (val);
              printf ("\tfreeable %s (R%d)\n", D.25068, reg2);
              <D.25067>:
              mono_regstate_free_int (rs, val);
              <D.25065>:
              <D.25060>:
              <D.25058>:
            }
            <D.24971>:
            if (prev_dreg >= 0) goto <D.25069>; else goto <D.25070>;
            <D.25069>:
            D.24600 = bank != 0;
            D.24601 = (long int) D.24600;
            D.24602 = __builtin_expect (D.24601, 0);
            if (D.24602 != 0) goto <D.25072>; else goto <D.25073>;
            <D.25072>:
            if (prev_dreg < 0) goto <D.25075>; else goto <D.25078>;
            <D.25078>:
            D.24610 = regbank_size[bank];
            if (D.24610 <= prev_dreg) goto <D.25075>; else goto <D.25076>;
            <D.25075>:
            iftmp.57 = 1;
            goto <D.25077>;
            <D.25076>:
            iftmp.57 = 0;
            <D.25077>:
            iftmp.56 = (_Bool) iftmp.57;
            goto <D.25079>;
            <D.25073>:
            iftmp.56 = prev_dreg > 15;
            <D.25079>:
            if (iftmp.56 != 0) goto <D.25080>; else goto <D.25081>;
            <D.25080>:
            if (spec_dest != 98) goto <D.25082>; else goto <D.25083>;
            <D.25082>:
            {
              int dreg;

              D.24623 = rs->vassign;
              D.24982 = (long unsigned int) prev_dreg;
              D.24983 = D.24982 * 4;
              D.24984 = D.24623 + D.24983;
              dreg = *D.24984;
              D.25084 = dreg < 0;
              D.25085 = (long int) D.25084;
              D.25086 = __builtin_expect (D.25085, 0);
              if (D.25086 != 0) goto <D.25087>; else goto <D.25088>;
              <D.25087>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1704, "dreg >= 0");
              <D.25088>:
              D.24528 = cfg->verbose_level;
              D.24560 = D.24528 > 2;
              D.24561 = (long int) D.24560;
              D.24562 = __builtin_expect (D.24561, 0);
              if (D.24562 != 0) goto <D.25089>; else goto <D.25090>;
              <D.25089>:
              D.24982 = (long unsigned int) prev_dreg;
              D.25091 = D.24982 * 16;
              D.25092 = reginfo + D.25091;
              D.25093 = D.25092->born_in;
              D.25094 = mono_regname_full (dreg, bank);
              printf ("\tfreeable %s (R%d) (born in %d)\n", D.25094, prev_dreg, D.25093);
              <D.25090>:
              D.24600 = bank != 0;
              D.24601 = (long int) D.24600;
              D.24602 = __builtin_expect (D.24601, 0);
              if (D.24602 != 0) goto <D.25095>; else goto <D.25096>;
              <D.25095>:
              mono_regstate_free_general (rs, dreg, bank);
              goto <D.25097>;
              <D.25096>:
              mono_regstate_free_int (rs, dreg);
              <D.25097>:
              D.24623 = rs->vassign;
              D.24982 = (long unsigned int) prev_dreg;
              D.24983 = D.24982 * 4;
              D.24984 = D.24623 + D.24983;
              *D.24984 = -1;
            }
            <D.25083>:
            <D.25081>:
            <D.25070>:
            if (dest_dreg != -1) goto <D.25098>; else goto <D.25099>;
            <D.25098>:
            D.24537 = ins->dreg;
            if (D.24537 != dest_dreg) goto <D.25100>; else goto <D.25101>;
            <D.25100>:
            D.24537 = ins->dreg;
            create_copy_ins (cfg, bb, tmp, D.24537, dest_dreg, ins, ip, bank);
            ins->dreg = dest_dreg;
            D.24600 = bank != 0;
            D.24601 = (long int) D.24600;
            D.24602 = __builtin_expect (D.24601, 0);
            if (D.24602 != 0) goto <D.25102>; else goto <D.25103>;
            <D.25102>:
            {
              int translated_bank;

              D.25104 = cfg->rs;
              translated_bank = translate_bank (D.25104, bank, dest_dreg);
              D.25105 = rs->symbolic[translated_bank];
              D.25106 = (long unsigned int) dest_dreg;
              D.25107 = D.25106 * 4;
              D.25108 = D.25105 + D.25107;
              D.25109 = *D.25108;
              D.25110 = regbank_size[translated_bank];
              if (D.25109 >= D.25110) goto <D.25111>; else goto <D.25112>;
              <D.25111>:
              free_up_hreg (cfg, bb, tmp, ins, dest_dreg, translated_bank);
              <D.25112>:
            }
            goto <D.25113>;
            <D.25103>:
            D.25114 = rs->isymbolic[dest_dreg];
            if (D.25114 > 15) goto <D.25115>; else goto <D.25116>;
            <D.25115>:
            free_up_hreg (cfg, bb, tmp, ins, dest_dreg, bank);
            <D.25116>:
            <D.25113>:
            <D.25101>:
            <D.25099>:
            if (spec_dest == 98) goto <D.25117>; else goto <D.25118>;
            <D.25117>:
            j = 0;
            goto <D.23835>;
            <D.23834>:
            D.24574 = j + 1;
            D.24575 = (sizetype) D.24574;
            D.24576 = spec + D.24575;
            D.24577 = *D.24576;
            D.24581 = D.24577 == 102;
            D.24582 = (long int) D.24581;
            D.24583 = __builtin_expect (D.24582, 0);
            if (D.24583 == 0) goto <D.25119>; else goto <D.25120>;
            <D.25119>:
            D.24574 = j + 1;
            D.24575 = (sizetype) D.24574;
            D.24576 = spec + D.24575;
            D.24577 = *D.24576;
            D.24587 = D.24577 == 120;
            D.24588 = (long int) D.24587;
            D.24589 = __builtin_expect (D.24588, 0);
            if (D.24589 == 0) goto <D.25121>; else goto <D.25122>;
            <D.25121>:
            D.25123 = sreg_masks[j];
            D.24537 = ins->dreg;
            D.25124 = 1 << D.24537;
            D.25125 = ~D.25124;
            D.25126 = D.25123 & D.25125;
            sreg_masks[j] = D.25126;
            <D.25122>:
            <D.25120>:
            j = j + 1;
            <D.23835>:
            if (j < num_sregs) goto <D.23834>; else goto <D.23836>;
            <D.23836>:
            <D.25118>:
            if (clob_reg != -1) goto <D.25127>; else goto <D.25128>;
            <D.25127>:
            D.24786 = rs->ifree_mask;
            D.25129 = D.24786 >> clob_reg;
            D.25130 = D.25129 & 1;
            if (D.25130 == 0) goto <D.25131>; else goto <D.25132>;
            <D.25131>:
            D.24528 = cfg->verbose_level;
            D.24560 = D.24528 > 2;
            D.24561 = (long int) D.24560;
            D.24562 = __builtin_expect (D.24561, 0);
            if (D.24562 != 0) goto <D.25133>; else goto <D.25134>;
            <D.25133>:
            D.25135 = rs->isymbolic[clob_reg];
            printf ("\tforced spill of clobbered reg R%d\n", D.25135);
            <D.25134>:
            free_up_hreg (cfg, bb, tmp, ins, clob_reg, 0);
            <D.25132>:
            <D.25128>:
            D.24691 = spec + 5;
            D.24692 = *D.24691;
            if (D.24692 == 99) goto <D.25136>; else goto <D.25137>;
            <D.25136>:
            {
              int j;
              int s;
              int dreg;
              int dreg2;
              int cur_bank;
              guint64 clob_mask;

              clob_mask = 1991;
              D.24786 = rs->ifree_mask;
              if (D.24786 != 1991) goto <D.25138>; else goto <D.25139>;
              <D.25138>:
              if (prev_dreg != -1) goto <D.25142>; else goto <D.25140>;
              <D.25142>:
              D.25143 = spec_dest == 102;
              D.25144 = (long int) D.25143;
              D.25145 = __builtin_expect (D.25144, 0);
              if (D.25145 == 0) goto <D.25146>; else goto <D.25140>;
              <D.25146>:
              D.25147 = spec_dest == 120;
              D.25148 = (long int) D.25147;
              D.25149 = __builtin_expect (D.25148, 0);
              if (D.25149 == 0) goto <D.25150>; else goto <D.25140>;
              <D.25150>:
              D.24623 = rs->vassign;
              D.24982 = (long unsigned int) prev_dreg;
              D.24983 = D.24982 * 4;
              D.24984 = D.24623 + D.24983;
              dreg = *D.24984;
              goto <D.25141>;
              <D.25140>:
              dreg = -1;
              <D.25141>:
              if (0 != 0) goto <D.25151>; else goto <D.25152>;
              <D.25151>:
              D.24623 = rs->vassign;
              D.25153 = (sizetype) prev_dreg;
              D.25154 = D.25153 + 1;
              D.25155 = D.25154 * 4;
              D.25156 = D.24623 + D.25155;
              dreg2 = *D.25156;
              goto <D.25157>;
              <D.25152>:
              dreg2 = -1;
              <D.25157>:
              j = 0;
              goto <D.23844>;
              <D.23843>:
              D.25158 = 1 << j;
              s = (int) D.25158;
              D.25159 = (long unsigned int) s;
              D.25160 = D.25159 & clob_mask;
              if (D.25160 != 0) goto <D.25161>; else goto <D.25162>;
              <D.25161>:
              D.24786 = rs->ifree_mask;
              D.25163 = (long unsigned int) s;
              D.25164 = D.24786 & D.25163;
              if (D.25164 == 0) goto <D.25165>; else goto <D.25166>;
              <D.25165>:
              D.24545 = ins->sreg1;
              if (D.24545 != j) goto <D.25167>; else goto <D.25168>;
              <D.25167>:
              D.25169 = j != dreg;
              D.25170 = j != dreg2;
              D.25171 = D.25169 & D.25170;
              if (D.25171 != 0) goto <D.25172>; else goto <D.25173>;
              <D.25172>:
              free_up_hreg (cfg, bb, tmp, ins, j, 0);
              goto <D.25174>;
              <D.25173>:
              D.25175 = rs->isymbolic[j];
              if (D.25175 != 0) goto <D.25176>; else goto <D.25177>;
              <D.25176>:
              D.24623 = rs->vassign;
              D.25175 = rs->isymbolic[j];
              D.25178 = (long unsigned int) D.25175;
              D.25179 = D.25178 * 4;
              D.25180 = D.24623 + D.25179;
              *D.25180 = -1;
              <D.25177>:
              <D.25174>:
              mono_regstate_free_int (rs, j);
              <D.25168>:
              <D.25166>:
              <D.25162>:
              j = j + 1;
              <D.23844>:
              if (j <= 15) goto <D.23843>; else goto <D.23845>;
              <D.23845>:
              <D.25139>:
              cur_bank = 1;
              goto <D.23851>;
              <D.23850>:
              D.25181 = rs->free_mask[cur_bank];
              D.25182 = regbank_callee_regs[cur_bank];
              if (D.25181 != D.25182) goto <D.25183>; else goto <D.25184>;
              <D.25183>:
              clob_mask = regbank_callee_regs[cur_bank];
              if (prev_dreg != -1) goto <D.25188>; else goto <D.25185>;
              <D.25188>:
              D.25143 = spec_dest == 102;
              D.25144 = (long int) D.25143;
              D.25145 = __builtin_expect (D.25144, 0);
              if (D.25145 != 0) goto <D.25186>; else goto <D.25189>;
              <D.25189>:
              D.25147 = spec_dest == 120;
              D.25148 = (long int) D.25147;
              D.25149 = __builtin_expect (D.25148, 0);
              if (D.25149 != 0) goto <D.25186>; else goto <D.25185>;
              <D.25186>:
              D.24623 = rs->vassign;
              D.24982 = (long unsigned int) prev_dreg;
              D.24983 = D.24982 * 4;
              D.24984 = D.24623 + D.24983;
              dreg = *D.24984;
              goto <D.25187>;
              <D.25185>:
              dreg = -1;
              <D.25187>:
              j = 0;
              goto <D.23848>;
              <D.23847>:
              D.25190 = rs->symbolic[cur_bank];
              D.25191 = (long unsigned int) j;
              D.25192 = D.25191 * 4;
              D.25193 = D.25190 + D.25192;
              D.25194 = *D.25193;
              if (D.25194 == -2) goto <D.25195>; else goto <D.25196>;
              <D.25195>:
              // predicted unlikely by continue predictor.
              goto <D.23846>;
              <D.25196>:
              D.25158 = 1 << j;
              s = (int) D.25158;
              D.25159 = (long unsigned int) s;
              D.25160 = D.25159 & clob_mask;
              if (D.25160 != 0) goto <D.25197>; else goto <D.25198>;
              <D.25197>:
              D.25181 = rs->free_mask[cur_bank];
              D.25163 = (long unsigned int) s;
              D.25199 = D.25181 & D.25163;
              if (D.25199 == 0) goto <D.25200>; else goto <D.25201>;
              <D.25200>:
              if (j != dreg) goto <D.25202>; else goto <D.25203>;
              <D.25202>:
              free_up_hreg (cfg, bb, tmp, ins, j, cur_bank);
              goto <D.25204>;
              <D.25203>:
              D.25190 = rs->symbolic[cur_bank];
              D.25191 = (long unsigned int) j;
              D.25192 = D.25191 * 4;
              D.25193 = D.25190 + D.25192;
              D.25194 = *D.25193;
              if (D.25194 != 0) goto <D.25205>; else goto <D.25206>;
              <D.25205>:
              D.24623 = rs->vassign;
              D.25190 = rs->symbolic[cur_bank];
              D.25191 = (long unsigned int) j;
              D.25192 = D.25191 * 4;
              D.25193 = D.25190 + D.25192;
              D.25194 = *D.25193;
              D.25207 = (long unsigned int) D.25194;
              D.25208 = D.25207 * 4;
              D.25209 = D.24623 + D.25208;
              *D.25209 = -1;
              <D.25206>:
              <D.25204>:
              mono_regstate_free_general (rs, j, cur_bank);
              <D.25201>:
              <D.25198>:
              <D.23846>:
              j = j + 1;
              <D.23848>:
              D.25210 = regbank_size[cur_bank];
              if (D.25210 > j) goto <D.23847>; else goto <D.23849>;
              <D.23849>:
              <D.25184>:
              cur_bank = cur_bank + 1;
              <D.23851>:
              if (cur_bank <= 4) goto <D.23850>; else goto <D.23852>;
              <D.23852>:
            }
            <D.25137>:
            D.24691 = spec + 5;
            D.24692 = *D.24691;
            if (D.24692 == 99) goto <D.25213>; else goto <D.25214>;
            <D.25213>:
            D.25215 = ins->opcode;
            D.25216 = D.25215 + 65193;
            D.25217 = D.25216 <= 2;
            D.25218 = D.25215 + 65187;
            D.25219 = D.25218 <= 2;
            D.25220 = D.25217 | D.25219;
            if (D.25220 != 0) goto <D.25211>; else goto <D.25221>;
            <D.25221>:
            D.24532 = ins->opcode;
            D.24702 = D.24532 + 65184;
            if (D.24702 <= 2) goto <D.25211>; else goto <D.25222>;
            <D.25222>:
            D.24532 = ins->opcode;
            D.24704 = D.24532 + 65181;
            if (D.24704 <= 2) goto <D.25211>; else goto <D.25223>;
            <D.25223>:
            D.24532 = ins->opcode;
            D.24706 = D.24532 + 65190;
            if (D.24706 <= 2) goto <D.25211>; else goto <D.25224>;
            <D.25224>:
            D.24532 = ins->opcode;
            D.24708 = D.24532 + 65178;
            if (D.24708 <= 2) goto <D.25211>; else goto <D.25225>;
            <D.25225>:
            D.24532 = ins->opcode;
            if (D.24532 == 448) goto <D.25211>; else goto <D.25212>;
            <D.25211>:
            {
              struct MonoCallInst * call;
              struct GSList * list;

              call = ins;
              list = call->out_ireg_args;
              if (list != 0B) goto <D.25226>; else goto <D.25227>;
              <D.25226>:
              goto <D.23859>;
              <D.23858>:
              {
                guint32 regpair;
                int reg;
                int hreg;

                D.25228 = list->data;
                D.25229 = (long int) D.25228;
                regpair = (guint32) D.25229;
                D.25230 = regpair >> 24;
                hreg = (int) D.25230;
                regpair.58 = (int) regpair;
                reg = regpair.58 & 16777215;
                assign_reg (cfg, rs, reg, hreg, 0);
                D.25232 = sreg_masks[0];
                D.25233 = 1 << hreg;
                D.25234 = ~D.25233;
                D.25235 = D.25232 & D.25234;
                sreg_masks[0] = D.25235;
                D.24528 = cfg->verbose_level;
                D.24560 = D.24528 > 2;
                D.24561 = (long int) D.24560;
                D.24562 = __builtin_expect (D.24561, 0);
                if (D.24562 != 0) goto <D.25236>; else goto <D.25237>;
                <D.25236>:
                D.25238 = mono_arch_regname (hreg);
                printf ("\tassigned arg reg %s to R%d\n", D.25238, reg);
                <D.25237>:
                if (list != 0B) goto <D.25240>; else goto <D.25241>;
                <D.25240>:
                iftmp.59 = list->next;
                goto <D.25242>;
                <D.25241>:
                iftmp.59 = 0B;
                <D.25242>:
                list = iftmp.59;
              }
              <D.23859>:
              if (list != 0B) goto <D.23858>; else goto <D.23860>;
              <D.23860>:
              <D.25227>:
              list = call->out_freg_args;
              if (list != 0B) goto <D.25243>; else goto <D.25244>;
              <D.25243>:
              goto <D.23865>;
              <D.23864>:
              {
                guint32 regpair;
                int reg;
                int hreg;

                D.25228 = list->data;
                D.25229 = (long int) D.25228;
                regpair = (guint32) D.25229;
                D.25245 = regpair >> 24;
                hreg = (int) D.25245;
                regpair.60 = (int) regpair;
                reg = regpair.60 & 16777215;
                assign_reg (cfg, rs, reg, hreg, 1);
                D.24528 = cfg->verbose_level;
                D.24560 = D.24528 > 2;
                D.24561 = (long int) D.24560;
                D.24562 = __builtin_expect (D.24561, 0);
                if (D.24562 != 0) goto <D.25247>; else goto <D.25248>;
                <D.25247>:
                D.25249 = mono_regname_full (hreg, 1);
                printf ("\tassigned arg reg %s to R%d\n", D.25249, reg);
                <D.25248>:
                if (list != 0B) goto <D.25251>; else goto <D.25252>;
                <D.25251>:
                iftmp.61 = list->next;
                goto <D.25253>;
                <D.25252>:
                iftmp.61 = 0B;
                <D.25253>:
                list = iftmp.61;
              }
              <D.23865>:
              if (list != 0B) goto <D.23864>; else goto <D.23866>;
              <D.23866>:
              <D.25244>:
            }
            <D.25212>:
            <D.25214>:
            D.24485 = spec + 1;
            D.24486 = *D.24485;
            D.25255 = D.24486 == 102;
            D.25256 = (long int) D.25255;
            D.25257 = __builtin_expect (D.25256, 0);
            if (D.25257 == 0) goto <D.25258>; else goto <D.25259>;
            <D.25258>:
            D.24485 = spec + 1;
            D.24486 = *D.24485;
            D.25261 = D.24486 == 120;
            D.25262 = (long int) D.25261;
            D.25263 = __builtin_expect (D.25262, 0);
            if (D.25263 != 0) goto <D.25264>; else goto <D.25265>;
            <D.25264>:
            iftmp.63 = 4;
            goto <D.25266>;
            <D.25265>:
            iftmp.63 = 0;
            <D.25266>:
            iftmp.62 = iftmp.63;
            goto <D.25267>;
            <D.25259>:
            iftmp.62 = 1;
            <D.25267>:
            bank = iftmp.62;
            if (0 != 0) goto <D.25268>; else goto <D.25269>;
            <D.25268>:
            {
              int sreg1;
              int dest_sreg1;

              sreg1 = sregs[0];
              dest_sreg1 = dest_sregs[0];
              D.24600 = bank != 0;
              D.24601 = (long int) D.24600;
              D.24602 = __builtin_expect (D.24601, 0);
              if (D.24602 != 0) goto <D.25271>; else goto <D.25272>;
              <D.25271>:
              if (sreg1 >= 0) goto <D.25276>; else goto <D.25274>;
              <D.25276>:
              D.24610 = regbank_size[bank];
              if (D.24610 > sreg1) goto <D.25277>; else goto <D.25274>;
              <D.25277>:
              iftmp.65 = 1;
              goto <D.25275>;
              <D.25274>:
              iftmp.65 = 0;
              <D.25275>:
              D.25278 = iftmp.65 != 0;
              D.25279 = (int) D.25278;
              iftmp.64 = (long int) D.25279;
              goto <D.25280>;
              <D.25272>:
              D.25281 = sreg1 <= 15;
              D.25282 = (int) D.25281;
              iftmp.64 = (long int) D.25282;
              <D.25280>:
              D.25283 = __builtin_expect (iftmp.64, 0);
              if (D.25283 != 0) goto <D.25284>; else goto <D.25285>;
              <D.25284>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1879, "is_soft_reg (sreg1, bank)");
              <D.25285>:
              if (dest_sreg1 != -1) goto <D.25286>; else goto <D.25287>;
              <D.25286>:
              D.24537 = ins->dreg;
              D.25288 = D.24537 != dest_sreg1;
              D.25289 = (long int) D.25288;
              D.25290 = __builtin_expect (D.25289, 0);
              if (D.25290 != 0) goto <D.25291>; else goto <D.25292>;
              <D.25291>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1883, "dest_sreg1 == ins->dreg");
              <D.25292>:
              <D.25287>:
              D.24537 = ins->dreg;
              D.25124 = 1 << D.24537;
              val = mono_regstate_alloc_int (rs, D.25124);
              D.25293 = val < 0;
              D.25294 = (long int) D.25293;
              D.25295 = __builtin_expect (D.25294, 0);
              if (D.25295 != 0) goto <D.25296>; else goto <D.25297>;
              <D.25296>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1885, "val >= 0");
              <D.25297>:
              D.24623 = rs->vassign;
              D.25298 = (long unsigned int) sreg1;
              D.25299 = D.25298 * 4;
              D.25300 = D.24623 + D.25299;
              D.25301 = *D.25300;
              if (D.25301 >= 0) goto <D.25302>; else goto <D.25303>;
              <D.25302>:
              D.24623 = rs->vassign;
              D.25298 = (long unsigned int) sreg1;
              D.25299 = D.25298 * 4;
              D.25300 = D.24623 + D.25299;
              D.25301 = *D.25300;
              if (D.25301 != val) goto <D.25304>; else goto <D.25305>;
              <D.25304>:
              monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-codegen.c", 1889);
              <D.25305>:
              <D.25303>:
              assign_reg (cfg, rs, sreg1, val, bank);
              D.24528 = cfg->verbose_level;
              D.24560 = D.24528 > 2;
              D.24561 = (long int) D.24560;
              D.24562 = __builtin_expect (D.24561, 0);
              if (D.24562 != 0) goto <D.25306>; else goto <D.25307>;
              <D.25306>:
              D.25308 = mono_regname_full (val, bank);
              printf ("\tassigned sreg1-low %s to R%d\n", D.25308, sreg1);
              <D.25307>:
              D.25309 = 1991 >> dreg_high;
              D.25310 = D.25309 & 1;
              D.25311 = D.25310 == 0;
              D.25312 = (long int) D.25311;
              D.25313 = __builtin_expect (D.25312, 0);
              if (D.25313 != 0) goto <D.25314>; else goto <D.25315>;
              <D.25314>:
              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.25315>:
              D.25316 = 1 << dreg_high;
              val = mono_regstate_alloc_int (rs, D.25316);
              D.25293 = val < 0;
              D.25294 = (long int) D.25293;
              D.25295 = __builtin_expect (D.25294, 0);
              if (D.25295 != 0) goto <D.25317>; else goto <D.25318>;
              <D.25317>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1897, "val >= 0");
              <D.25318>:
              D.24623 = rs->vassign;
              D.25319 = (sizetype) sreg1;
              D.25320 = D.25319 + 1;
              D.25321 = D.25320 * 4;
              D.25322 = D.24623 + D.25321;
              D.25323 = *D.25322;
              if (D.25323 >= 0) goto <D.25324>; else goto <D.25325>;
              <D.25324>:
              D.24623 = rs->vassign;
              D.25319 = (sizetype) sreg1;
              D.25320 = D.25319 + 1;
              D.25321 = D.25320 * 4;
              D.25322 = D.24623 + D.25321;
              D.25323 = *D.25322;
              if (D.25323 != val) goto <D.25326>; else goto <D.25327>;
              <D.25326>:
              monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-codegen.c", 1901);
              <D.25327>:
              <D.25325>:
              D.25328 = sreg1 + 1;
              assign_reg (cfg, rs, D.25328, val, bank);
              D.24528 = cfg->verbose_level;
              D.24560 = D.24528 > 2;
              D.24561 = (long int) D.24560;
              D.24562 = __builtin_expect (D.24561, 0);
              if (D.24562 != 0) goto <D.25329>; else goto <D.25330>;
              <D.25329>:
              D.25328 = sreg1 + 1;
              D.25331 = mono_regname_full (val, bank);
              printf ("\tassigned sreg1-high %s to R%d\n", D.25331, D.25328);
              <D.25330>:
              dest_sregs[0] = -1;
            }
            <D.25269>:
            D.25332 = sreg_fixed_masks[0];
            if (D.25332 != 0) goto <D.25333>; else goto <D.25334>;
            <D.25333>:
            D.24600 = bank != 0;
            D.24601 = (long int) D.24600;
            D.24602 = __builtin_expect (D.24601, 0);
            if (D.24602 != 0) goto <D.25335>; else goto <D.25336>;
            <D.25335>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1912, "!bank");
            <D.25336>:
            D.25339 = sregs[0];
            D.25340 = (unsigned int) D.25339;
            if (D.25340 <= 15) goto <D.25341>; else goto <D.25337>;
            <D.25341>:
            D.25339 = sregs[0];
            D.25342 = 61480 >> D.25339;
            D.25343 = D.25342 & 1;
            if (D.25343 != 0) goto <D.25344>; else goto <D.25337>;
            <D.25344>:
            D.25332 = sreg_fixed_masks[0];
            val = mono_regstate_alloc_int (rs, D.25332);
            if (val < 0) goto <D.25345>; else goto <D.25346>;
            <D.25345>:
            D.25332 = sreg_fixed_masks[0];
            val = get_register_spilling (cfg, bb, tmp, ins, D.25332, -1, bank);
            <D.25346>:
            mono_regstate_free_int (rs, val);
            dest_sregs[0] = val;
            goto <D.25338>;
            <D.25337>:
            D.25232 = sreg_masks[0];
            D.25332 = sreg_fixed_masks[0];
            D.25347 = D.25232 & D.25332;
            sreg_masks[0] = D.25347;
            <D.25338>:
            <D.25334>:
            D.24876 = dest_sregs[0];
            if (D.24876 != -1) goto <D.25348>; else goto <D.25349>;
            <D.25348>:
            D.24876 = dest_sregs[0];
            D.24879 = 1 << D.24876;
            sreg_masks[0] = D.24879;
            D.24623 = rs->vassign;
            D.25339 = sregs[0];
            D.25350 = (long unsigned int) D.25339;
            D.25351 = D.25350 * 4;
            D.25352 = D.24623 + D.25351;
            D.25353 = *D.25352;
            D.24876 = dest_sregs[0];
            if (D.25353 != D.24876) goto <D.25354>; else goto <D.25355>;
            <D.25354>:
            D.24786 = rs->ifree_mask;
            D.24876 = dest_sregs[0];
            D.25356 = D.24786 >> D.24876;
            D.25357 = D.25356 & 1;
            if (D.25357 == 0) goto <D.25358>; else goto <D.25359>;
            <D.25358>:
            D.24876 = dest_sregs[0];
            free_up_hreg (cfg, bb, tmp, ins, D.24876, 0);
            <D.25359>:
            <D.25355>:
            D.25339 = sregs[0];
            D.25340 = (unsigned int) D.25339;
            if (D.25340 <= 15) goto <D.25360>; else goto <D.25361>;
            <D.25360>:
            D.25339 = sregs[0];
            D.25342 = 61480 >> D.25339;
            D.25343 = D.25342 & 1;
            if (D.25343 != 0) goto <D.25362>; else goto <D.25363>;
            <D.25362>:
            {
              struct MonoInst * copy;

              D.25339 = sregs[0];
              D.24876 = dest_sregs[0];
              copy = create_copy_ins (cfg, bb, tmp, D.24876, D.25339, 0B, ip, 0);
              insert_before_ins (bb, ins, copy);
              D.24876 = dest_sregs[0];
              sregs[0] = D.24876;
            }
            <D.25363>:
            <D.25361>:
            <D.25349>:
            D.24600 = bank != 0;
            D.24601 = (long int) D.24600;
            D.24602 = __builtin_expect (D.24601, 0);
            if (D.24602 != 0) goto <D.25365>; else goto <D.25366>;
            <D.25365>:
            D.25339 = sregs[0];
            if (D.25339 < 0) goto <D.25368>; else goto <D.25371>;
            <D.25371>:
            D.25339 = sregs[0];
            D.24610 = regbank_size[bank];
            if (D.25339 >= D.24610) goto <D.25368>; else goto <D.25369>;
            <D.25368>:
            iftmp.67 = 1;
            goto <D.25370>;
            <D.25369>:
            iftmp.67 = 0;
            <D.25370>:
            iftmp.66 = (_Bool) iftmp.67;
            goto <D.25372>;
            <D.25366>:
            D.25339 = sregs[0];
            iftmp.66 = D.25339 > 15;
            <D.25372>:
            if (iftmp.66 != 0) goto <D.25373>; else goto <D.25374>;
            <D.25373>:
            D.24623 = rs->vassign;
            D.25339 = sregs[0];
            D.25350 = (long unsigned int) D.25339;
            D.25351 = D.25350 * 4;
            D.25352 = D.24623 + D.25351;
            val = *D.25352;
            D.25339 = sregs[0];
            prev_sregs[0] = D.25339;
            if (val < 0) goto <D.25375>; else goto <D.25376>;
            <D.25375>:
            {
              int spill;

              spill = 0;
              if (val < -1) goto <D.25377>; else goto <D.25378>;
              <D.25377>:
              spill = ~val;
              <D.25378>:
              D.24532 = ins->opcode;
              if (D.24532 == 428) goto <D.25379>; else goto <D.25380>;
              <D.25379>:
              D.25381 = spill | bank;
              if (D.25381 == 0) goto <D.25382>; else goto <D.25383>;
              <D.25382>:
              D.24537 = ins->dreg;
              D.24943 = (unsigned int) D.24537;
              if (D.24943 <= 15) goto <D.25384>; else goto <D.25385>;
              <D.25384>:
              D.24537 = ins->dreg;
              D.25386 = 1991 >> D.24537;
              D.25387 = D.25386 & 1;
              if (D.25387 != 0) goto <D.25388>; else goto <D.25389>;
              <D.25388>:
              D.24786 = rs->ifree_mask;
              D.24537 = ins->dreg;
              D.25390 = D.24786 >> D.24537;
              D.25391 = D.25390 & 1;
              if (D.25391 != 0) goto <D.25392>; else goto <D.25393>;
              <D.25392>:
              D.24537 = ins->dreg;
              D.25124 = 1 << D.24537;
              sreg_masks[0] = D.25124;
              <D.25393>:
              <D.25389>:
              <D.25385>:
              <D.25383>:
              <D.25380>:
              D.24691 = spec + 5;
              D.24692 = *D.24691;
              if (D.24692 == 49) goto <D.25394>; else goto <D.25395>;
              <D.25394>:
              D.24478 = *spec;
              D.24642 = D.24478 == 102;
              D.24643 = (long int) D.24642;
              D.24644 = __builtin_expect (D.24643, 0);
              if (D.24644 == 0) goto <D.25396>; else goto <D.25397>;
              <D.25396>:
              D.24478 = *spec;
              D.24648 = D.24478 == 120;
              D.24649 = (long int) D.24648;
              D.24650 = __builtin_expect (D.24649, 0);
              if (D.24650 == 0) goto <D.25398>; else goto <D.25399>;
              <D.25398>:
              D.24786 = rs->ifree_mask;
              D.24537 = ins->dreg;
              D.25390 = D.24786 >> D.24537;
              D.25391 = D.25390 & 1;
              if (D.25391 != 0) goto <D.25400>; else goto <D.25401>;
              <D.25400>:
              D.24537 = ins->dreg;
              D.25124 = 1 << D.24537;
              sreg_masks[0] = D.25124;
              <D.25401>:
              <D.25399>:
              <D.25397>:
              <D.25395>:
              D.25339 = sregs[0];
              D.25350 = (long unsigned int) D.25339;
              D.25402 = D.25350 * 16;
              D.25403 = reginfo + D.25402;
              D.25339 = sregs[0];
              D.25232 = sreg_masks[0];
              val = alloc_reg (cfg, bb, tmp, ins, D.25232, D.25339, D.25403, bank);
              D.25339 = sregs[0];
              assign_reg (cfg, rs, D.25339, val, bank);
              D.24528 = cfg->verbose_level;
              D.24560 = D.24528 > 2;
              D.24561 = (long int) D.24560;
              D.24562 = __builtin_expect (D.24561, 0);
              if (D.24562 != 0) goto <D.25404>; else goto <D.25405>;
              <D.25404>:
              D.25339 = sregs[0];
              D.25406 = mono_regname_full (val, bank);
              printf ("\tassigned sreg1 %s to R%d\n", D.25406, D.25339);
              <D.25405>:
              if (spill != 0) goto <D.25407>; else goto <D.25408>;
              <D.25407>:
              D.25409 = prev_sregs[0];
              create_spilled_store (cfg, bb, spill, val, D.25409, tmp, 0B, ins, bank);
              <D.25408>:
            }
            goto <D.25410>;
            <D.25376>:
            D.24876 = dest_sregs[0];
            if (D.24876 != -1) goto <D.25411>; else goto <D.25412>;
            <D.25411>:
            D.24876 = dest_sregs[0];
            if (D.24876 != val) goto <D.25413>; else goto <D.25414>;
            <D.25413>:
            {
              struct MonoInst * copy;

              D.24876 = dest_sregs[0];
              copy = create_copy_ins (cfg, bb, tmp, D.24876, val, 0B, ip, bank);
              insert_before_ins (bb, ins, copy);
              j = 1;
              goto <D.23873>;
              <D.23872>:
              D.25123 = sreg_masks[j];
              D.24876 = dest_sregs[0];
              D.24879 = 1 << D.24876;
              D.24880 = ~D.24879;
              D.25415 = D.25123 & D.24880;
              sreg_masks[j] = D.25415;
              j = j + 1;
              <D.23873>:
              if (j < num_sregs) goto <D.23872>; else goto <D.23874>;
              <D.23874>:
              val = dest_sregs[0];
            }
            <D.25414>:
            <D.25412>:
            <D.25410>:
            sregs[0] = val;
            goto <D.25416>;
            <D.25374>:
            prev_sregs[0] = -1;
            <D.25416>:
            mono_inst_set_src_registers (ins, &sregs);
            j = 1;
            goto <D.23876>;
            <D.23875>:
            D.25123 = sreg_masks[j];
            D.25339 = sregs[0];
            D.25417 = 1 << D.25339;
            D.25418 = ~D.25417;
            D.25419 = D.25123 & D.25418;
            sreg_masks[j] = D.25419;
            j = j + 1;
            <D.23876>:
            if (j < num_sregs) goto <D.23875>; else goto <D.23877>;
            <D.23877>:
            if (0 != 0) goto <D.25420>; else goto <D.25421>;
            <D.25420>:
            {
              int reg2;

              D.25409 = prev_sregs[0];
              reg2 = D.25409 + 1;
              D.24600 = bank != 0;
              D.24601 = (long int) D.24600;
              D.24602 = __builtin_expect (D.24601, 0);
              if (D.24602 != 0) goto <D.25422>; else goto <D.25423>;
              <D.25422>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 2000, "!bank");
              <D.25423>:
              D.25409 = prev_sregs[0];
              D.25424 = D.25409 < 0;
              D.25425 = (long int) D.25424;
              D.25426 = __builtin_expect (D.25425, 0);
              if (D.25426 != 0) goto <D.25427>; else goto <D.25428>;
              <D.25427>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 2001, "prev_sregs [0] > -1");
              <D.25428>:
              D.24623 = rs->vassign;
              D.25409 = prev_sregs[0];
              D.25432 = (long unsigned int) D.25409;
              D.25433 = D.25432 * 4;
              D.25434 = D.24623 + D.25433;
              D.25435 = *D.25434;
              D.25436 = (unsigned int) D.25435;
              if (D.25436 <= 15) goto <D.25437>; else goto <D.25430>;
              <D.25437>:
              D.24623 = rs->vassign;
              D.25409 = prev_sregs[0];
              D.25432 = (long unsigned int) D.25409;
              D.25433 = D.25432 * 4;
              D.25434 = D.24623 + D.25433;
              D.25435 = *D.25434;
              D.25438 = 61480 >> D.25435;
              D.25439 = D.25438 & 1;
              if (D.25439 != 0) goto <D.25440>; else goto <D.25430>;
              <D.25440>:
              iftmp.68 = 1;
              goto <D.25431>;
              <D.25430>:
              iftmp.68 = 0;
              <D.25431>:
              D.25441 = iftmp.68 != 0;
              D.25442 = (long int) D.25441;
              D.25443 = __builtin_expect (D.25442, 0);
              if (D.25443 != 0) goto <D.25444>; else goto <D.25445>;
              <D.25444>:
              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.25445>:
              mask = 1991;
              D.24623 = rs->vassign;
              D.25446 = (long unsigned int) reg2;
              D.25447 = D.25446 * 4;
              D.25448 = D.24623 + D.25447;
              val = *D.25448;
              if (val < 0) goto <D.25449>; else goto <D.25450>;
              <D.25449>:
              {
                int spill;

                spill = 0;
                if (val < -1) goto <D.25451>; else goto <D.25452>;
                <D.25451>:
                spill = ~val;
                <D.25452>:
                val = mono_regstate_alloc_int (rs, mask);
                if (val < 0) goto <D.25453>; else goto <D.25454>;
                <D.25453>:
                val = get_register_spilling (cfg, bb, tmp, ins, mask, reg2, bank);
                <D.25454>:
                if (spill != 0) goto <D.25455>; else goto <D.25456>;
                <D.25455>:
                monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-codegen.c", 2015);
                <D.25456>:
              }
              goto <D.25457>;
              <D.25450>:
              D.25008 = mask >> val;
              D.25009 = D.25008 & 1;
              if (D.25009 == 0) goto <D.25458>; else goto <D.25459>;
              <D.25458>:
              monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-codegen.c", 2021);
              <D.25459>:
              <D.25457>:
              sreg1_high = val;
              D.24528 = cfg->verbose_level;
              D.24560 = D.24528 > 2;
              D.24561 = (long int) D.24560;
              D.24562 = __builtin_expect (D.24561, 0);
              if (D.24562 != 0) goto <D.25460>; else goto <D.25461>;
              <D.25460>:
              D.25462 = mono_arch_regname (val);
              printf ("\tassigned sreg1 hreg %s to dest R%d\n", D.25462, reg2);
              <D.25461>:
              assign_reg (cfg, rs, reg2, val, bank);
            }
            <D.25421>:
            D.24478 = *spec;
            if (D.24478 == 102) goto <D.25466>; else goto <D.25463>;
            <D.25466>:
            D.24485 = spec + 1;
            D.24486 = *D.24485;
            if (D.24486 == 102) goto <D.25464>; else goto <D.25463>;
            <D.25463>:
            D.24691 = spec + 5;
            D.24692 = *D.24691;
            if (D.24692 == 49) goto <D.25464>; else goto <D.25465>;
            <D.25464>:
            D.24537 = ins->dreg;
            D.25339 = sregs[0];
            if (D.24537 != D.25339) goto <D.25467>; else goto <D.25468>;
            <D.25467>:
            {
              struct MonoInst * sreg2_copy;
              struct MonoInst * copy;
              int bank;

              sreg2_copy = 0B;
              D.25470 = spec_src1 == 102;
              D.25471 = (long int) D.25470;
              D.25472 = __builtin_expect (D.25471, 0);
              if (D.25472 == 0) goto <D.25473>; else goto <D.25474>;
              <D.25473>:
              D.25476 = spec_src1 == 120;
              D.25477 = (long int) D.25476;
              D.25478 = __builtin_expect (D.25477, 0);
              if (D.25478 != 0) goto <D.25479>; else goto <D.25480>;
              <D.25479>:
              iftmp.70 = 4;
              goto <D.25481>;
              <D.25480>:
              iftmp.70 = 0;
              <D.25481>:
              iftmp.69 = iftmp.70;
              goto <D.25482>;
              <D.25474>:
              iftmp.69 = 1;
              <D.25482>:
              bank = iftmp.69;
              D.24537 = ins->dreg;
              D.25483 = sregs[1];
              if (D.24537 == D.25483) goto <D.25484>; else goto <D.25485>;
              <D.25484>:
              {
                int reg2;

                D.25483 = sregs[1];
                reg2 = alloc_reg (cfg, bb, tmp, ins, dreg_mask, D.25483, 0B, bank);
                D.24528 = cfg->verbose_level;
                D.24560 = D.24528 > 2;
                D.24561 = (long int) D.24560;
                D.24562 = __builtin_expect (D.24561, 0);
                if (D.24562 != 0) goto <D.25486>; else goto <D.25487>;
                <D.25486>:
                D.25488 = mono_regname_full (reg2, bank);
                D.25483 = sregs[1];
                D.25489 = mono_regname_full (D.25483, bank);
                printf ("\tneed to copy sreg2 %s to reg %s\n", D.25489, D.25488);
                <D.25487>:
                D.25483 = sregs[1];
                sreg2_copy = create_copy_ins (cfg, bb, tmp, reg2, D.25483, 0B, ip, bank);
                sregs[1] = reg2;
                D.25483 = sregs[1];
                prev_sregs[1] = D.25483;
                D.25490 = bank != 0;
                D.25491 = (long int) D.25490;
                D.25492 = __builtin_expect (D.25491, 0);
                if (D.25492 != 0) goto <D.25493>; else goto <D.25494>;
                <D.25493>:
                mono_regstate_free_general (rs, reg2, bank);
                goto <D.25495>;
                <D.25494>:
                mono_regstate_free_int (rs, reg2);
                <D.25495>:
              }
              <D.25485>:
              if (0 != 0) goto <D.25496>; else goto <D.25497>;
              <D.25496>:
              D.24623 = rs->vassign;
              D.25409 = prev_sregs[0];
              D.25498 = (sizetype) D.25409;
              D.25499 = D.25498 + 1;
              D.25500 = D.25499 * 4;
              D.25501 = D.24623 + D.25500;
              D.25502 = *D.25501;
              D.25483 = sregs[1];
              if (D.25502 == D.25483) goto <D.25503>; else goto <D.25504>;
              <D.25503>:
              monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-codegen.c", 2067);
              <D.25504>:
              D.25339 = sregs[0];
              D.24537 = ins->dreg;
              D.25505 = D.25339 != D.24537;
              D.25506 = (long int) D.25505;
              D.25507 = __builtin_expect (D.25506, 0);
              if (D.25507 != 0) goto <D.25508>; else goto <D.25509>;
              <D.25508>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 2073, "sregs [0] == ins->dreg");
              <D.25509>:
              D.25510 = dreg_high != sreg1_high;
              D.25511 = (long int) D.25510;
              D.25512 = __builtin_expect (D.25511, 0);
              if (D.25512 != 0) goto <D.25513>; else goto <D.25514>;
              <D.25513>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 2074, "dreg_high == sreg1_high");
              <D.25514>:
              <D.25497>:
              D.24528 = cfg->verbose_level;
              D.24560 = D.24528 > 2;
              D.24561 = (long int) D.24560;
              D.24562 = __builtin_expect (D.24561, 0);
              if (D.24562 != 0) goto <D.25515>; else goto <D.25516>;
              <D.25515>:
              D.24537 = ins->dreg;
              D.25517 = mono_regname_full (D.24537, bank);
              D.25339 = sregs[0];
              D.25518 = mono_regname_full (D.25339, bank);
              printf ("\tneed to copy sreg1 %s to dreg %s\n", D.25518, D.25517);
              <D.25516>:
              D.25339 = sregs[0];
              D.24537 = ins->dreg;
              copy = create_copy_ins (cfg, bb, tmp, D.24537, D.25339, 0B, ip, bank);
              insert_before_ins (bb, ins, copy);
              if (sreg2_copy != 0B) goto <D.25519>; else goto <D.25520>;
              <D.25519>:
              insert_before_ins (bb, copy, sreg2_copy);
              <D.25520>:
              D.24746 = sreg_masks[1];
              D.25339 = sregs[0];
              D.25417 = 1 << D.25339;
              D.25418 = ~D.25417;
              D.25521 = D.24746 & D.25418;
              sreg_masks[1] = D.25521;
              D.24537 = ins->dreg;
              sregs[0] = D.24537;
              D.25339 = sregs[0];
              prev_sregs[0] = D.25339;
              D.24746 = sreg_masks[1];
              D.24537 = ins->dreg;
              D.25124 = 1 << D.24537;
              D.25125 = ~D.25124;
              D.25522 = D.24746 & D.25125;
              sreg_masks[1] = D.25522;
            }
            <D.25468>:
            <D.25465>:
            mono_inst_set_src_registers (ins, &sregs);
            j = 1;
            goto <D.23891>;
            <D.23890>:
            {
              int k;

              D.24574 = j + 1;
              D.24575 = (sizetype) D.24574;
              D.24576 = spec + D.24575;
              D.24577 = *D.24576;
              D.24581 = D.24577 == 102;
              D.24582 = (long int) D.24581;
              D.24583 = __builtin_expect (D.24582, 0);
              if (D.24583 == 0) goto <D.25524>; else goto <D.25525>;
              <D.25524>:
              D.24574 = j + 1;
              D.24575 = (sizetype) D.24574;
              D.24576 = spec + D.24575;
              D.24577 = *D.24576;
              D.24587 = D.24577 == 120;
              D.24588 = (long int) D.24587;
              D.24589 = __builtin_expect (D.24588, 0);
              if (D.24589 != 0) goto <D.25527>; else goto <D.25528>;
              <D.25527>:
              iftmp.72 = 4;
              goto <D.25529>;
              <D.25528>:
              iftmp.72 = 0;
              <D.25529>:
              iftmp.71 = iftmp.72;
              goto <D.25530>;
              <D.25525>:
              iftmp.71 = 1;
              <D.25530>:
              bank = iftmp.71;
              if (0 != 0) goto <D.25531>; else goto <D.25532>;
              <D.25531>:
              monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-codegen.c", 2103);
              <D.25532>:
              D.24881 = dest_sregs[j];
              if (D.24881 != -1) goto <D.25535>; else goto <D.25533>;
              <D.25535>:
              D.24549 = sregs[j];
              D.25536 = (unsigned int) D.24549;
              if (D.25536 <= 15) goto <D.25537>; else goto <D.25533>;
              <D.25537>:
              D.24549 = sregs[j];
              D.25538 = 61480 >> D.24549;
              D.25539 = D.25538 & 1;
              if (D.25539 != 0) goto <D.25540>; else goto <D.25533>;
              <D.25540>:
              {
                struct MonoInst * copy;

                D.24549 = sregs[j];
                D.24881 = dest_sregs[j];
                copy = create_copy_ins (cfg, bb, tmp, D.24881, D.24549, 0B, ip, 0);
                insert_before_ins (bb, ins, copy);
                D.24881 = dest_sregs[j];
                sregs[j] = D.24881;
              }
              goto <D.25534>;
              <D.25533>:
              D.24600 = bank != 0;
              D.24601 = (long int) D.24600;
              D.24602 = __builtin_expect (D.24601, 0);
              if (D.24602 != 0) goto <D.25542>; else goto <D.25543>;
              <D.25542>:
              D.24549 = sregs[j];
              if (D.24549 < 0) goto <D.25545>; else goto <D.25548>;
              <D.25548>:
              D.24549 = sregs[j];
              D.24610 = regbank_size[bank];
              if (D.24549 >= D.24610) goto <D.25545>; else goto <D.25546>;
              <D.25545>:
              iftmp.74 = 1;
              goto <D.25547>;
              <D.25546>:
              iftmp.74 = 0;
              <D.25547>:
              iftmp.73 = (_Bool) iftmp.74;
              goto <D.25549>;
              <D.25543>:
              D.24549 = sregs[j];
              iftmp.73 = D.24549 > 15;
              <D.25549>:
              if (iftmp.73 != 0) goto <D.25550>; else goto <D.25551>;
              <D.25550>:
              D.24623 = rs->vassign;
              D.24549 = sregs[j];
              D.24557 = (long unsigned int) D.24549;
              D.25552 = D.24557 * 4;
              D.25553 = D.24623 + D.25552;
              val = *D.25553;
              D.24881 = dest_sregs[j];
              if (D.24881 != -1) goto <D.25554>; else goto <D.25555>;
              <D.25554>:
              if (val >= 0) goto <D.25556>; else goto <D.25557>;
              <D.25556>:
              D.24881 = dest_sregs[j];
              if (D.24881 != val) goto <D.25558>; else goto <D.25559>;
              <D.25558>:
              D.24549 = sregs[j];
              spill_vreg (cfg, bb, tmp, ins, D.24549, 0);
              D.24623 = rs->vassign;
              D.24549 = sregs[j];
              D.24557 = (long unsigned int) D.24549;
              D.25552 = D.24557 * 4;
              D.25553 = D.24623 + D.25552;
              val = *D.25553;
              <D.25559>:
              <D.25557>:
              <D.25555>:
              if (val < 0) goto <D.25560>; else goto <D.25561>;
              <D.25560>:
              {
                int spill;

                spill = 0;
                if (val < -1) goto <D.25562>; else goto <D.25563>;
                <D.25562>:
                spill = ~val;
                <D.25563>:
                D.24549 = sregs[j];
                D.24557 = (long unsigned int) D.24549;
                D.24558 = D.24557 * 16;
                D.25564 = reginfo + D.24558;
                D.24549 = sregs[j];
                D.25123 = sreg_masks[j];
                val = alloc_reg (cfg, bb, tmp, ins, D.25123, D.24549, D.25564, bank);
                D.24549 = sregs[j];
                assign_reg (cfg, rs, D.24549, val, bank);
                D.24528 = cfg->verbose_level;
                D.24560 = D.24528 > 2;
                D.24561 = (long int) D.24560;
                D.24562 = __builtin_expect (D.24561, 0);
                if (D.24562 != 0) goto <D.25565>; else goto <D.25566>;
                <D.25565>:
                D.24549 = sregs[j];
                D.25567 = mono_regname_full (val, bank);
                D.24574 = j + 1;
                printf ("\tassigned sreg%d %s to R%d\n", D.24574, D.25567, D.24549);
                <D.25566>:
                if (spill != 0) goto <D.25568>; else goto <D.25569>;
                <D.25568>:
                D.24549 = sregs[j];
                create_spilled_store (cfg, bb, spill, val, D.24549, tmp, 0B, ins, bank);
                <D.25569>:
              }
              <D.25561>:
              sregs[j] = val;
              k = j + 1;
              goto <D.23888>;
              <D.23887>:
              D.25570 = sreg_masks[k];
              D.24549 = sregs[j];
              D.25571 = 1 << D.24549;
              D.25572 = ~D.25571;
              D.25573 = D.25570 & D.25572;
              sreg_masks[k] = D.25573;
              k = k + 1;
              <D.23888>:
              if (k < num_sregs) goto <D.23887>; else goto <D.23889>;
              <D.23889>:
              goto <D.25574>;
              <D.25551>:
              prev_sregs[j] = -1;
              <D.25574>:
              <D.25534>:
            }
            j = j + 1;
            <D.23891>:
            if (j < num_sregs) goto <D.23890>; else goto <D.23892>;
            <D.23892>:
            mono_inst_set_src_registers (ins, &sregs);
            j = 1;
            goto <D.23900>;
            <D.23899>:
            {
              int sreg;
              int dest_sreg;

              sreg = sregs[j];
              dest_sreg = dest_sregs[j];
              D.25575 = j == 2;
              D.25576 = dest_sreg != -1;
              D.25577 = D.25575 & D.25576;
              if (D.25577 != 0) goto <D.25578>; else goto <D.25579>;
              <D.25578>:
              {
                int k;

                D.25580 = sreg != dest_sreg;
                D.25581 = (long int) D.25580;
                D.25582 = __builtin_expect (D.25581, 0);
                if (D.25582 != 0) goto <D.25583>; else goto <D.25584>;
                <D.25583>:
                monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 2163, "sreg == dest_sreg");
                <D.25584>:
                k = 0;
                goto <D.23897>;
                <D.23896>:
                if (k != j) goto <D.25585>; else goto <D.25586>;
                <D.25585>:
                D.25587 = sregs[k];
                D.25588 = D.25587 == dest_sreg;
                D.25589 = (long int) D.25588;
                D.25590 = __builtin_expect (D.25589, 0);
                if (D.25590 != 0) goto <D.25591>; else goto <D.25592>;
                <D.25591>:
                monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 2167, "sregs [k] != dest_sreg");
                <D.25592>:
                <D.25586>:
                k = k + 1;
                <D.23897>:
                if (k < num_sregs) goto <D.23896>; else goto <D.23898>;
                <D.23898>:
              }
              <D.25579>:
            }
            j = j + 1;
            <D.23900>:
            if (j < num_sregs) goto <D.23899>; else goto <D.23901>;
            <D.23901>:
            D.24528 = cfg->verbose_level;
            D.24560 = D.24528 > 2;
            D.24561 = (long int) D.24560;
            D.24562 = __builtin_expect (D.24561, 0);
            if (D.24562 != 0) goto <D.25593>; else goto <D.25594>;
            <D.25593>:
            mono_print_ins_index (i, ins);
            <D.25594>:
          }
        finally
          {
            dest_sregs = {CLOBBER};
            prev_sregs = {CLOBBER};
            sreg_masks = {CLOBBER};
            sreg_fixed_masks = {CLOBBER};
          }
      }
      ins = prev;
      if (ins != 0B) goto <D.25596>; else goto <D.25597>;
      <D.25596>:
      iftmp.75 = ins->prev;
      goto <D.25598>;
      <D.25597>:
      iftmp.75 = 0B;
      <D.25598>:
      prev = iftmp.75;
      <D.23903>:
      if (ins != 0B) goto <D.23902>; else goto <D.23904>;
      <D.23904>:
    }
  finally
    {
      last = {CLOBBER};
      sregs = {CLOBBER};
    }
}


mono_regstate_assign (struct MonoRegState * rs)
{
  long unsigned int D.25602;
  long unsigned int D.25603;
  _Bool D.25604;
  long int D.25605;
  long int D.25606;
  long unsigned int D.25609;
  long unsigned int D.25610;
  _Bool D.25611;
  long int D.25612;
  long int D.25613;
  int D.25616;
  int D.25617;
  _Bool D.25618;
  long int D.25619;
  long int D.25620;
  int D.25623;
  int D.25624;
  gint32 * D.25627;
  int D.25628;
  long unsigned int D.25629;
  long unsigned int D.25630;
  void * D.25631;
  int[16] * D.25632;
  int[16] * D.25633;
  int[16] * D.25634;

  D.25602 = 32767;
  D.25603 = 32767;
  D.25604 = D.25602 != D.25603;
  D.25605 = (long int) D.25604;
  D.25606 = __builtin_expect (D.25605, 0);
  if (D.25606 != 0) goto <D.25607>; else goto <D.25608>;
  <D.25607>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 137, "regbank_callee_regs [MONO_REG_SIMD] == regbank_callee_regs [MONO_REG_DOUBLE]");
  <D.25608>:
  D.25609 = 0;
  D.25610 = 0;
  D.25611 = D.25609 != D.25610;
  D.25612 = (long int) D.25611;
  D.25613 = __builtin_expect (D.25612, 0);
  if (D.25613 != 0) goto <D.25614>; else goto <D.25615>;
  <D.25614>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 138, "regbank_callee_saved_regs [MONO_REG_SIMD] == regbank_callee_saved_regs [MONO_REG_DOUBLE]");
  <D.25615>:
  D.25616 = 16;
  D.25617 = 16;
  D.25618 = D.25616 != D.25617;
  D.25619 = (long int) D.25618;
  D.25620 = __builtin_expect (D.25619, 0);
  if (D.25620 != 0) goto <D.25621>; else goto <D.25622>;
  <D.25621>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 139, "regbank_size [MONO_REG_SIMD] == regbank_size [MONO_REG_DOUBLE]");
  <D.25622>:
  D.25623 = rs->next_vreg;
  D.25624 = rs->vassign_size;
  if (D.25623 > D.25624) goto <D.25625>; else goto <D.25626>;
  <D.25625>:
  D.25627 = rs->vassign;
  monoeg_g_free (D.25627);
  D.25623 = rs->next_vreg;
  D.25628 = MAX_EXPR <D.25623, 256>;
  rs->vassign_size = D.25628;
  D.25624 = rs->vassign_size;
  D.25629 = (long unsigned int) D.25624;
  D.25630 = D.25629 * 4;
  D.25631 = monoeg_malloc (D.25630);
  rs->vassign = D.25631;
  <D.25626>:
  D.25632 = &rs->isymbolic;
  memset (D.25632, 0, 64);
  D.25633 = &rs->fsymbolic;
  memset (D.25633, 0, 64);
  D.25632 = &rs->isymbolic;
  rs->symbolic[0] = D.25632;
  D.25633 = &rs->fsymbolic;
  rs->symbolic[1] = D.25633;
  D.25634 = &rs->xsymbolic;
  memset (D.25634, 0, 64);
  D.25634 = &rs->xsymbolic;
  rs->symbolic[4] = D.25634;
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.25637;
  int D.25642;
  void * D.25644;
  long unsigned int D.25645;

  D.25637 = __builtin_constant_p (__len);
  if (D.25637 != 0) goto <D.25638>; else goto <D.25639>;
  <D.25638>:
  if (__len == 0) goto <D.25640>; else goto <D.25641>;
  <D.25640>:
  D.25642 = __builtin_constant_p (__ch);
  if (D.25642 == 0) goto <D.25635>; else goto <D.25643>;
  <D.25643>:
  if (__ch != 0) goto <D.25635>; else goto <D.25636>;
  <D.25635>:
  __warn_memset_zero_len ();
  D.25644 = __dest;
  return D.25644;
  <D.25636>:
  <D.25641>:
  <D.25639>:
  D.25645 = __builtin_object_size (__dest, 0);
  D.25644 = __builtin___memset_chk (__dest, __ch, __len, D.25645);
  return D.25644;
}


print_regtrack (struct RegTrack * t, int num)
{
  long unsigned int D.25647;
  long unsigned int D.25648;
  struct RegTrack * D.25649;
  int D.25650;
  int D.25656;
  int i;
  char buf[32];
  const char * r;

  try
    {
      i = 0;
      goto <D.23572>;
      <D.23571>:
      D.25647 = (long unsigned int) i;
      D.25648 = D.25647 * 16;
      D.25649 = t + D.25648;
      D.25650 = D.25649->born_in;
      if (D.25650 == 0) goto <D.25651>; else goto <D.25652>;
      <D.25651>:
      // predicted unlikely by continue predictor.
      goto <D.23570>;
      <D.25652>:
      if (i > 15) goto <D.25653>; else goto <D.25654>;
      <D.25653>:
      monoeg_g_snprintf (&buf, 32, "R%d", i);
      r = &buf;
      goto <D.25655>;
      <D.25654>:
      r = mono_arch_regname (i);
      <D.25655>:
      D.25647 = (long unsigned int) i;
      D.25648 = D.25647 * 16;
      D.25649 = t + D.25648;
      D.25656 = D.25649->killed_in;
      D.25647 = (long unsigned int) i;
      D.25648 = D.25647 * 16;
      D.25649 = t + D.25648;
      D.25650 = D.25649->born_in;
      printf ("liveness: %s [%d - %d]\n", r, D.25650, D.25656);
      <D.23570>:
      i = i + 1;
      <D.23572>:
      if (i < num) goto <D.23571>; else goto <D.23573>;
      <D.23573>:
    }
  finally
    {
      buf = {CLOBBER};
    }
}


get_callee_mask (const char spec)
{
  _Bool D.25659;
  long int D.25660;
  long int D.25661;
  _Bool D.25667;
  long int D.25668;
  long int D.25669;
  regmask_t D.25672;
  int iftmp.76;
  int iftmp.77;

  D.25659 = spec == 102;
  D.25660 = (long int) D.25659;
  D.25661 = __builtin_expect (D.25660, 0);
  if (D.25661 != 0) goto <D.25662>; else goto <D.25663>;
  <D.25662>:
  if (1 != 0) goto <D.25657>; else goto <D.25664>;
  <D.25664>:
  goto <D.25665>;
  <D.25663>:
  if (0 != 0) goto <D.25657>; else goto <D.25666>;
  <D.25666>:
  <D.25665>:
  D.25667 = spec == 120;
  D.25668 = (long int) D.25667;
  D.25669 = __builtin_expect (D.25668, 0);
  if (D.25669 != 0) goto <D.25670>; else goto <D.25671>;
  <D.25670>:
  if (1 != 0) goto <D.25657>; else goto <D.25658>;
  <D.25671>:
  if (0 != 0) goto <D.25657>; else goto <D.25658>;
  <D.25657>:
  D.25659 = spec == 102;
  D.25660 = (long int) D.25659;
  D.25661 = __builtin_expect (D.25660, 0);
  if (D.25661 == 0) goto <D.25674>; else goto <D.25675>;
  <D.25674>:
  D.25667 = spec == 120;
  D.25668 = (long int) D.25667;
  D.25669 = __builtin_expect (D.25668, 0);
  if (D.25669 != 0) goto <D.25677>; else goto <D.25678>;
  <D.25677>:
  iftmp.77 = 4;
  goto <D.25679>;
  <D.25678>:
  iftmp.77 = 0;
  <D.25679>:
  iftmp.76 = iftmp.77;
  goto <D.25680>;
  <D.25675>:
  iftmp.76 = 1;
  <D.25680>:
  D.25672 = regbank_callee_regs[iftmp.76];
  return D.25672;
  <D.25658>:
  D.25672 = 1991;
  return D.25672;
}


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)
{
  long unsigned int D.25684;
  long unsigned int D.25687;
  struct MonoRegState * D.25688;
  unsigned int D.25691;
  _Bool D.25692;
  long int D.25693;
  long int D.25694;
  const char * D.25697;
  int D.25698;
  int val;

  if (info != 0B) goto <D.25682>; else goto <D.25683>;
  <D.25682>:
  D.25684 = info->preferred_mask;
  if (D.25684 != 0) goto <D.25685>; else goto <D.25686>;
  <D.25685>:
  D.25684 = info->preferred_mask;
  D.25687 = D.25684 & dest_mask;
  D.25688 = cfg->rs;
  val = mono_regstate_alloc_int (D.25688, D.25687);
  if (val >= 0) goto <D.25689>; else goto <D.25690>;
  <D.25689>:
  D.25691 = cfg->verbose_level;
  D.25692 = D.25691 > 2;
  D.25693 = (long int) D.25692;
  D.25694 = __builtin_expect (D.25693, 0);
  if (D.25694 != 0) goto <D.25695>; else goto <D.25696>;
  <D.25695>:
  D.25697 = mono_arch_regname (val);
  printf ("\tallocated preferred reg R%d to %s\n", sym_reg, D.25697);
  <D.25696>:
  D.25698 = val;
  return D.25698;
  <D.25690>:
  <D.25686>:
  <D.25683>:
  D.25688 = cfg->rs;
  val = mono_regstate_alloc_int (D.25688, dest_mask);
  if (val < 0) goto <D.25699>; else goto <D.25700>;
  <D.25699>:
  val = get_register_spilling (cfg, bb, last, ins, dest_mask, sym_reg, 0);
  <D.25700>:
  D.25698 = val;
  return D.25698;
}


translate_bank (struct MonoRegState * rs, int bank, int hreg)
{
  int D.25702;
  int iftmp.78;
  int * D.25704;
  long unsigned int D.25705;
  long unsigned int D.25706;
  int * D.25707;
  int D.25708;
  int iftmp.79;
  int iftmp.80;

  D.25704 = rs->symbolic[bank];
  D.25705 = (long unsigned int) hreg;
  D.25706 = D.25705 * 4;
  D.25707 = D.25704 + D.25706;
  D.25708 = *D.25707;
  if (D.25708 == -2) goto <D.25709>; else goto <D.25710>;
  <D.25709>:
  if (bank != 4) goto <D.25712>; else goto <D.25713>;
  <D.25712>:
  if (bank == 1) goto <D.25715>; else goto <D.25716>;
  <D.25715>:
  iftmp.80 = 4;
  goto <D.25717>;
  <D.25716>:
  iftmp.80 = -1;
  <D.25717>:
  iftmp.79 = iftmp.80;
  goto <D.25718>;
  <D.25713>:
  iftmp.79 = 1;
  <D.25718>:
  iftmp.78 = iftmp.79;
  goto <D.25719>;
  <D.25710>:
  iftmp.78 = bank;
  <D.25719>:
  D.25702 = iftmp.78;
  return D.25702;
}


mono_regstate_alloc_int (struct MonoRegState * rs, regmask_t allow)
{
  long unsigned int D.25721;
  int D.25724;
  int D.25725;
  long unsigned int D.25726;
  long unsigned int D.25727;
  long unsigned int D.25728;
  regmask_t mask;

  D.25721 = rs->ifree_mask;
  mask = D.25721 & allow;
  {
    guint64 i;

    if (mask == 0) goto <D.25722>; else goto <D.25723>;
    <D.25722>:
    D.25724 = -1;
    return D.25724;
    <D.25723>:
    __asm__("bsfq %1,%0
	" : "=r" i : "rm" mask);
    D.25721 = rs->ifree_mask;
    D.25725 = (int) i;
    D.25726 = 1 << D.25725;
    D.25727 = ~D.25726;
    D.25728 = D.25721 & D.25727;
    rs->ifree_mask = D.25728;
    D.25724 = (int) i;
    return D.25724;
  }
}


get_register_spilling (struct MonoCompile * cfg, struct MonoBasicBlock * bb, struct MonoInst * * last, struct MonoInst * ins, regmask_t regmask, int reg, int bank)
{
  _Bool D.25730;
  long int D.25731;
  long int D.25732;
  unsigned int D.25735;
  _Bool D.25736;
  long int D.25737;
  long int D.25738;
  int D.25741;
  int D.25742;
  int D.25743;
  int D.25744;
  short unsigned int D.25745;
  int D.25746;
  int D.25747;
  signed char D.25748;
  int iftmp.81;
  short unsigned int D.25752;
  sizetype D.25753;
  int D.25754;
  sizetype D.25755;
  sizetype D.25756;
  const char * D.25757;
  char D.25758;
  _Bool D.25759;
  long int D.25760;
  long int D.25761;
  int iftmp.82;
  _Bool D.25765;
  long int D.25766;
  long int D.25767;
  int D.25774;
  _Bool D.25777;
  long int D.25778;
  long int D.25779;
  int iftmp.83;
  int iftmp.84;
  int D.25793;
  _Bool D.25795;
  long unsigned int D.25799;
  long unsigned int D.25800;
  long unsigned int D.25801;
  _Bool D.25803;
  int iftmp.85;
  unsigned int D.25809;
  long unsigned int D.25811;
  long unsigned int D.25812;
  _Bool D.25814;
  int iftmp.86;
  _Bool D.25822;
  int iftmp.87;
  _Bool D.25831;
  gint32 * D.25835;
  long unsigned int D.25836;
  long unsigned int D.25837;
  gint32 * D.25838;
  int D.25839;
  _Bool iftmp.88;
  int iftmp.89;
  long unsigned int D.25851;
  long unsigned int D.25852;
  long unsigned int D.25854;
  long unsigned int D.25855;
  const char * D.25858;
  int iftmp.90;
  const char * D.25860;
  char D.25861;
  _Bool D.25862;
  long int D.25863;
  long int D.25864;
  int iftmp.91;
  _Bool D.25868;
  long int D.25869;
  long int D.25870;
  _Bool iftmp.92;
  _Bool iftmp.93;
  int iftmp.94;
  int iftmp.95;
  _Bool D.25895;
  long unsigned int D.25899;
  long unsigned int D.25900;
  int iftmp.96;
  unsigned int D.25906;
  long unsigned int D.25908;
  long unsigned int D.25909;
  int iftmp.97;
  long unsigned int D.25919;
  long unsigned int D.25920;
  const char * D.25923;
  _Bool D.25926;
  long int D.25927;
  long int D.25928;
  long unsigned int D.25933;
  long unsigned int D.25934;
  struct MonoRegState * D.25937;
  int * D.25940;
  long unsigned int D.25941;
  long unsigned int D.25942;
  int * D.25943;
  int D.25944;
  const char * D.25945;
  int D.25946;
  int D.25947;
  long unsigned int D.25948;
  long unsigned int D.25949;
  gint32 * D.25950;
  int D.25951;
  int D.25957;
  const char * D.25958;
  struct MonoMemPool * D.25959;
  int D.25960;
  short unsigned int D.25961;
  int D.25962;
  int D.25963;
  const unsigned char * D.25964;
  unsigned int D.25965;
  int D.25966;
  int D.25967;
  int D.25968;
  long int D.25969;
  const char * D.25972;
  long int D.25973;
  long unsigned int D.25976;
  _Bool D.25978;
  long int D.25979;
  long int D.25980;
  int D.25983;
  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.25730 = bank > 4;
      D.25731 = (long int) D.25730;
      D.25732 = __builtin_expect (D.25731, 0);
      if (D.25732 != 0) goto <D.25733>; else goto <D.25734>;
      <D.25733>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 831, "bank < MONO_NUM_REGBANKS");
      <D.25734>:
      D.25735 = cfg->verbose_level;
      D.25736 = D.25735 > 2;
      D.25737 = (long int) D.25736;
      D.25738 = __builtin_expect (D.25737, 0);
      if (D.25738 != 0) goto <D.25739>; else goto <D.25740>;
      <D.25739>:
      D.25741 = ins->sreg3;
      D.25742 = ins->sreg2;
      D.25743 = ins->sreg1;
      D.25744 = ins->dreg;
      printf ("\tstart regmask to assign R%d: 0x%08llu (R%d <- R%d R%d R%d)\n", reg, regmask, D.25744, D.25743, D.25742, D.25741);
      <D.25740>:
      D.25743 = ins->sreg1;
      sregs[0] = D.25743;
      D.25742 = ins->sreg2;
      sregs[1] = D.25742;
      D.25741 = ins->sreg3;
      sregs[2] = D.25741;
      D.25745 = ins->opcode;
      D.25746 = (int) D.25745;
      D.25747 = D.25746 + -313;
      D.25748 = ins_sreg_counts[D.25747];
      num_sregs = (int) D.25748;
      i = 0;
      goto <D.23625>;
      <D.23624>:
      D.25745 = ins->opcode;
      D.25746 = (int) D.25745;
      D.25747 = D.25746 + -313;
      D.25752 = amd64_desc_idx[D.25747];
      D.25753 = (sizetype) D.25752;
      D.25754 = i + 1;
      D.25755 = (sizetype) D.25754;
      D.25756 = D.25753 + D.25755;
      D.25757 = &amd64_desc + D.25756;
      D.25758 = *D.25757;
      D.25759 = D.25758 == 102;
      D.25760 = (long int) D.25759;
      D.25761 = __builtin_expect (D.25760, 0);
      if (D.25761 == 0) goto <D.25762>; else goto <D.25763>;
      <D.25762>:
      D.25745 = ins->opcode;
      D.25746 = (int) D.25745;
      D.25747 = D.25746 + -313;
      D.25752 = amd64_desc_idx[D.25747];
      D.25753 = (sizetype) D.25752;
      D.25754 = i + 1;
      D.25755 = (sizetype) D.25754;
      D.25756 = D.25753 + D.25755;
      D.25757 = &amd64_desc + D.25756;
      D.25758 = *D.25757;
      D.25765 = D.25758 == 120;
      D.25766 = (long int) D.25765;
      D.25767 = __builtin_expect (D.25766, 0);
      if (D.25767 != 0) goto <D.25768>; else goto <D.25769>;
      <D.25768>:
      iftmp.82 = 4;
      goto <D.25770>;
      <D.25769>:
      iftmp.82 = 0;
      <D.25770>:
      iftmp.81 = iftmp.82;
      goto <D.25771>;
      <D.25763>:
      iftmp.81 = 1;
      <D.25771>:
      if (iftmp.81 == bank) goto <D.25772>; else goto <D.25773>;
      <D.25772>:
      D.25774 = sregs[i];
      if (D.25774 != reg) goto <D.25775>; else goto <D.25776>;
      <D.25775>:
      D.25777 = bank != 0;
      D.25778 = (long int) D.25777;
      D.25779 = __builtin_expect (D.25778, 0);
      if (D.25779 != 0) goto <D.25780>; else goto <D.25781>;
      <D.25780>:
      D.25777 = bank != 0;
      D.25778 = (long int) D.25777;
      D.25779 = __builtin_expect (D.25778, 0);
      if (D.25779 != 0) goto <D.25782>; else goto <D.25783>;
      <D.25782>:
      D.25777 = bank != 0;
      D.25778 = (long int) D.25777;
      D.25779 = __builtin_expect (D.25778, 0);
      if (D.25779 != 0) goto <D.25787>; else goto <D.25788>;
      <D.25787>:
      D.25774 = sregs[i];
      if (D.25774 >= 0) goto <D.25792>; else goto <D.25790>;
      <D.25792>:
      D.25774 = sregs[i];
      D.25793 = regbank_size[bank];
      if (D.25774 < D.25793) goto <D.25794>; else goto <D.25790>;
      <D.25794>:
      iftmp.84 = 1;
      goto <D.25791>;
      <D.25790>:
      iftmp.84 = 0;
      <D.25791>:
      D.25795 = (_Bool) iftmp.84;
      if (D.25795 != 0) goto <D.25796>; else goto <D.25785>;
      <D.25796>:
      goto <D.25797>;
      <D.25788>:
      D.25774 = sregs[i];
      if (D.25774 <= 15) goto <D.25798>; else goto <D.25785>;
      <D.25798>:
      <D.25797>:
      D.25799 = regbank_callee_regs[bank];
      D.25774 = sregs[i];
      D.25800 = D.25799 >> D.25774;
      D.25801 = D.25800 & 1;
      if (D.25801 != 0) goto <D.25802>; else goto <D.25785>;
      <D.25802>:
      iftmp.83 = 1;
      goto <D.25786>;
      <D.25785>:
      iftmp.83 = 0;
      <D.25786>:
      D.25803 = (_Bool) iftmp.83;
      if (D.25803 != 0) goto <D.25749>; else goto <D.25804>;
      <D.25804>:
      goto <D.25805>;
      <D.25783>:
      D.25774 = sregs[i];
      D.25809 = (unsigned int) D.25774;
      if (D.25809 <= 15) goto <D.25810>; else goto <D.25807>;
      <D.25810>:
      D.25774 = sregs[i];
      D.25811 = 1991 >> D.25774;
      D.25812 = D.25811 & 1;
      if (D.25812 != 0) goto <D.25813>; else goto <D.25807>;
      <D.25813>:
      iftmp.85 = 1;
      goto <D.25808>;
      <D.25807>:
      iftmp.85 = 0;
      <D.25808>:
      D.25814 = (_Bool) iftmp.85;
      if (D.25814 != 0) goto <D.25749>; else goto <D.25815>;
      <D.25815>:
      <D.25805>:
      goto <D.25816>;
      <D.25781>:
      D.25774 = sregs[i];
      D.25809 = (unsigned int) D.25774;
      if (D.25809 <= 15) goto <D.25820>; else goto <D.25818>;
      <D.25820>:
      D.25774 = sregs[i];
      D.25811 = 1991 >> D.25774;
      D.25812 = D.25811 & 1;
      if (D.25812 != 0) goto <D.25821>; else goto <D.25818>;
      <D.25821>:
      iftmp.86 = 1;
      goto <D.25819>;
      <D.25818>:
      iftmp.86 = 0;
      <D.25819>:
      D.25822 = (_Bool) iftmp.86;
      if (D.25822 != 0) goto <D.25749>; else goto <D.25823>;
      <D.25823>:
      <D.25816>:
      D.25777 = bank != 0;
      D.25778 = (long int) D.25777;
      D.25779 = __builtin_expect (D.25778, 0);
      if (D.25779 != 0) goto <D.25824>; else goto <D.25825>;
      <D.25824>:
      D.25774 = sregs[i];
      if (D.25774 < 0) goto <D.25827>; else goto <D.25830>;
      <D.25830>:
      D.25774 = sregs[i];
      D.25793 = regbank_size[bank];
      if (D.25774 >= D.25793) goto <D.25827>; else goto <D.25828>;
      <D.25827>:
      iftmp.87 = 1;
      goto <D.25829>;
      <D.25828>:
      iftmp.87 = 0;
      <D.25829>:
      D.25831 = (_Bool) iftmp.87;
      if (D.25831 != 0) goto <D.25832>; else goto <D.25750>;
      <D.25832>:
      goto <D.25833>;
      <D.25825>:
      D.25774 = sregs[i];
      if (D.25774 > 15) goto <D.25834>; else goto <D.25750>;
      <D.25834>:
      <D.25833>:
      D.25835 = rs->vassign;
      D.25774 = sregs[i];
      D.25836 = (long unsigned int) D.25774;
      D.25837 = D.25836 * 4;
      D.25838 = D.25835 + D.25837;
      D.25839 = *D.25838;
      if (D.25839 >= 0) goto <D.25749>; else goto <D.25750>;
      <D.25749>:
      D.25777 = bank != 0;
      D.25778 = (long int) D.25777;
      D.25779 = __builtin_expect (D.25778, 0);
      if (D.25779 != 0) goto <D.25841>; else goto <D.25842>;
      <D.25841>:
      D.25774 = sregs[i];
      if (D.25774 < 0) goto <D.25844>; else goto <D.25847>;
      <D.25847>:
      D.25774 = sregs[i];
      D.25793 = regbank_size[bank];
      if (D.25774 >= D.25793) goto <D.25844>; else goto <D.25845>;
      <D.25844>:
      iftmp.89 = 1;
      goto <D.25846>;
      <D.25845>:
      iftmp.89 = 0;
      <D.25846>:
      iftmp.88 = (_Bool) iftmp.89;
      goto <D.25848>;
      <D.25842>:
      D.25774 = sregs[i];
      iftmp.88 = D.25774 > 15;
      <D.25848>:
      if (iftmp.88 != 0) goto <D.25849>; else goto <D.25850>;
      <D.25849>:
      D.25835 = rs->vassign;
      D.25774 = sregs[i];
      D.25836 = (long unsigned int) D.25774;
      D.25837 = D.25836 * 4;
      D.25838 = D.25835 + D.25837;
      D.25839 = *D.25838;
      D.25851 = 1 << D.25839;
      D.25852 = ~D.25851;
      regmask = D.25852 & regmask;
      goto <D.25853>;
      <D.25850>:
      D.25774 = sregs[i];
      D.25854 = 1 << D.25774;
      D.25855 = ~D.25854;
      regmask = D.25855 & regmask;
      <D.25853>:
      D.25735 = cfg->verbose_level;
      D.25736 = D.25735 > 2;
      D.25737 = (long int) D.25736;
      D.25738 = __builtin_expect (D.25737, 0);
      if (D.25738 != 0) goto <D.25856>; else goto <D.25857>;
      <D.25856>:
      D.25774 = sregs[i];
      D.25774 = sregs[i];
      D.25858 = mono_regname_full (D.25774, bank);
      D.25754 = i + 1;
      printf ("\t\texcluding sreg%d %s %d\n", D.25754, D.25858, D.25774);
      <D.25857>:
      <D.25750>:
      <D.25776>:
      <D.25773>:
      i = i + 1;
      <D.23625>:
      if (i < num_sregs) goto <D.23624>; else goto <D.23626>;
      <D.23626>:
      D.25745 = ins->opcode;
      D.25746 = (int) D.25745;
      D.25747 = D.25746 + -313;
      D.25752 = amd64_desc_idx[D.25747];
      D.25753 = (sizetype) D.25752;
      D.25860 = &amd64_desc + D.25753;
      D.25861 = *D.25860;
      D.25862 = D.25861 == 102;
      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>:
      D.25745 = ins->opcode;
      D.25746 = (int) D.25745;
      D.25747 = D.25746 + -313;
      D.25752 = amd64_desc_idx[D.25747];
      D.25753 = (sizetype) D.25752;
      D.25860 = &amd64_desc + D.25753;
      D.25861 = *D.25860;
      D.25868 = D.25861 == 120;
      D.25869 = (long int) D.25868;
      D.25870 = __builtin_expect (D.25869, 0);
      if (D.25870 != 0) goto <D.25871>; else goto <D.25872>;
      <D.25871>:
      iftmp.91 = 4;
      goto <D.25873>;
      <D.25872>:
      iftmp.91 = 0;
      <D.25873>:
      iftmp.90 = iftmp.91;
      goto <D.25874>;
      <D.25866>:
      iftmp.90 = 1;
      <D.25874>:
      if (iftmp.90 == bank) goto <D.25875>; else goto <D.25876>;
      <D.25875>:
      D.25744 = ins->dreg;
      if (D.25744 != reg) goto <D.25877>; else goto <D.25878>;
      <D.25877>:
      D.25777 = bank != 0;
      D.25778 = (long int) D.25777;
      D.25779 = __builtin_expect (D.25778, 0);
      if (D.25779 != 0) goto <D.25880>; else goto <D.25881>;
      <D.25880>:
      D.25777 = bank != 0;
      D.25778 = (long int) D.25777;
      D.25779 = __builtin_expect (D.25778, 0);
      if (D.25779 != 0) goto <D.25883>; else goto <D.25884>;
      <D.25883>:
      D.25777 = bank != 0;
      D.25778 = (long int) D.25777;
      D.25779 = __builtin_expect (D.25778, 0);
      if (D.25779 != 0) goto <D.25888>; else goto <D.25889>;
      <D.25888>:
      D.25744 = ins->dreg;
      if (D.25744 >= 0) goto <D.25893>; else goto <D.25891>;
      <D.25893>:
      D.25744 = ins->dreg;
      D.25793 = regbank_size[bank];
      if (D.25744 < D.25793) goto <D.25894>; else goto <D.25891>;
      <D.25894>:
      iftmp.95 = 1;
      goto <D.25892>;
      <D.25891>:
      iftmp.95 = 0;
      <D.25892>:
      D.25895 = (_Bool) iftmp.95;
      if (D.25895 != 0) goto <D.25896>; else goto <D.25886>;
      <D.25896>:
      goto <D.25897>;
      <D.25889>:
      D.25744 = ins->dreg;
      if (D.25744 <= 15) goto <D.25898>; else goto <D.25886>;
      <D.25898>:
      <D.25897>:
      D.25799 = regbank_callee_regs[bank];
      D.25744 = ins->dreg;
      D.25899 = D.25799 >> D.25744;
      D.25900 = D.25899 & 1;
      if (D.25900 != 0) goto <D.25901>; else goto <D.25886>;
      <D.25901>:
      iftmp.94 = 1;
      goto <D.25887>;
      <D.25886>:
      iftmp.94 = 0;
      <D.25887>:
      iftmp.93 = (_Bool) iftmp.94;
      goto <D.25902>;
      <D.25884>:
      D.25744 = ins->dreg;
      D.25906 = (unsigned int) D.25744;
      if (D.25906 <= 15) goto <D.25907>; else goto <D.25904>;
      <D.25907>:
      D.25744 = ins->dreg;
      D.25908 = 1991 >> D.25744;
      D.25909 = D.25908 & 1;
      if (D.25909 != 0) goto <D.25910>; else goto <D.25904>;
      <D.25910>:
      iftmp.96 = 1;
      goto <D.25905>;
      <D.25904>:
      iftmp.96 = 0;
      <D.25905>:
      iftmp.93 = (_Bool) iftmp.96;
      <D.25902>:
      iftmp.92 = iftmp.93;
      goto <D.25911>;
      <D.25881>:
      D.25744 = ins->dreg;
      D.25906 = (unsigned int) D.25744;
      if (D.25906 <= 15) goto <D.25915>; else goto <D.25913>;
      <D.25915>:
      D.25744 = ins->dreg;
      D.25908 = 1991 >> D.25744;
      D.25909 = D.25908 & 1;
      if (D.25909 != 0) goto <D.25916>; else goto <D.25913>;
      <D.25916>:
      iftmp.97 = 1;
      goto <D.25914>;
      <D.25913>:
      iftmp.97 = 0;
      <D.25914>:
      iftmp.92 = (_Bool) iftmp.97;
      <D.25911>:
      if (iftmp.92 != 0) goto <D.25917>; else goto <D.25918>;
      <D.25917>:
      D.25744 = ins->dreg;
      D.25919 = 1 << D.25744;
      D.25920 = ~D.25919;
      regmask = D.25920 & regmask;
      D.25735 = cfg->verbose_level;
      D.25736 = D.25735 > 2;
      D.25737 = (long int) D.25736;
      D.25738 = __builtin_expect (D.25737, 0);
      if (D.25738 != 0) goto <D.25921>; else goto <D.25922>;
      <D.25921>:
      D.25744 = ins->dreg;
      D.25923 = mono_regname_full (D.25744, bank);
      printf ("\t\texcluding dreg %s\n", D.25923);
      <D.25922>:
      <D.25918>:
      <D.25878>:
      <D.25876>:
      D.25735 = cfg->verbose_level;
      D.25736 = D.25735 > 2;
      D.25737 = (long int) D.25736;
      D.25738 = __builtin_expect (D.25737, 0);
      if (D.25738 != 0) goto <D.25924>; else goto <D.25925>;
      <D.25924>:
      printf ("\t\tavailable regmask: 0x%08llu\n", regmask);
      <D.25925>:
      D.25926 = regmask == 0;
      D.25927 = (long int) D.25926;
      D.25928 = __builtin_expect (D.25927, 0);
      if (D.25928 != 0) goto <D.25929>; else goto <D.25930>;
      <D.25929>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 851, "regmask");
      <D.25930>:
      sel = 0;
      D.25777 = bank != 0;
      D.25778 = (long int) D.25777;
      D.25779 = __builtin_expect (D.25778, 0);
      if (D.25779 != 0) goto <D.25931>; else goto <D.25932>;
      <D.25931>:
      i = 0;
      goto <D.23629>;
      <D.23628>:
      D.25933 = regmask >> i;
      D.25934 = D.25933 & 1;
      if (D.25934 != 0) goto <D.25935>; else goto <D.25936>;
      <D.25935>:
      sel = i;
      D.25937 = cfg->rs;
      bank = translate_bank (D.25937, bank, sel);
      D.25735 = cfg->verbose_level;
      D.25736 = D.25735 > 2;
      D.25737 = (long int) D.25736;
      D.25738 = __builtin_expect (D.25737, 0);
      if (D.25738 != 0) goto <D.25938>; else goto <D.25939>;
      <D.25938>:
      D.25940 = rs->symbolic[bank];
      D.25941 = (long unsigned int) sel;
      D.25942 = D.25941 * 4;
      D.25943 = D.25940 + D.25942;
      D.25944 = *D.25943;
      D.25945 = mono_regname_full (sel, bank);
      printf ("\t\tselected register %s has assignment %d\n", D.25945, D.25944);
      <D.25939>:
      goto <D.23627>;
      <D.25936>:
      i = i + 1;
      <D.23629>:
      D.25793 = regbank_size[bank];
      if (D.25793 > i) goto <D.23628>; else goto <D.23627>;
      <D.23627>:
      D.25940 = rs->symbolic[bank];
      D.25941 = (long unsigned int) sel;
      D.25942 = D.25941 * 4;
      D.25943 = D.25940 + D.25942;
      i = *D.25943;
      D.25946 = cfg->spill_count;
      D.25947 = D.25946 + 1;
      cfg->spill_count = D.25947;
      spill = cfg->spill_count;
      D.25835 = rs->vassign;
      D.25948 = (long unsigned int) i;
      D.25949 = D.25948 * 4;
      D.25950 = D.25835 + D.25949;
      D.25951 = ~spill;
      *D.25950 = D.25951;
      mono_regstate_free_general (rs, sel, bank);
      goto <D.25952>;
      <D.25932>:
      i = 0;
      goto <D.23632>;
      <D.23631>:
      D.25933 = regmask >> i;
      D.25934 = D.25933 & 1;
      if (D.25934 != 0) goto <D.25953>; else goto <D.25954>;
      <D.25953>:
      sel = i;
      D.25735 = cfg->verbose_level;
      D.25736 = D.25735 > 2;
      D.25737 = (long int) D.25736;
      D.25738 = __builtin_expect (D.25737, 0);
      if (D.25738 != 0) goto <D.25955>; else goto <D.25956>;
      <D.25955>:
      D.25957 = rs->isymbolic[sel];
      D.25958 = mono_arch_regname (sel);
      printf ("\t\tselected register %s has assignment %d\n", D.25958, D.25957);
      <D.25956>:
      goto <D.23630>;
      <D.25954>:
      i = i + 1;
      <D.23632>:
      if (i <= 15) goto <D.23631>; else goto <D.23630>;
      <D.23630>:
      i = rs->isymbolic[sel];
      D.25946 = cfg->spill_count;
      D.25947 = D.25946 + 1;
      cfg->spill_count = D.25947;
      spill = cfg->spill_count;
      D.25835 = rs->vassign;
      D.25948 = (long unsigned int) i;
      D.25949 = D.25948 * 4;
      D.25950 = D.25835 + D.25949;
      D.25951 = ~spill;
      *D.25950 = D.25951;
      mono_regstate_free_int (rs, sel);
      <D.25952>:
      D.25959 = cfg->mempool;
      load = mono_mempool_alloc0 (D.25959, 80);
      D.25960 = regbank_load_ops[bank];
      D.25961 = (short unsigned int) D.25960;
      load->opcode = D.25961;
      load->dreg = -1;
      load->sreg3 = -1;
      D.25962 = load->sreg3;
      load->sreg2 = D.25962;
      D.25963 = load->sreg2;
      load->sreg1 = D.25963;
      D.25964 = cfg->ip;
      load->cil_code = D.25964;
      load->dreg = sel;
      D.25965 = cfg->frame_reg;
      D.25966 = (int) D.25965;
      load->sreg1 = D.25966;
      D.25967 = get_vreg_bank (cfg, i, bank);
      D.25968 = mono_spillvar_offset (cfg, spill, D.25967);
      D.25969 = (long int) D.25968;
      load->data.op[0].const_val = D.25969;
      insert_after_ins (bb, ins, last, load);
      D.25735 = cfg->verbose_level;
      D.25736 = D.25735 > 2;
      D.25737 = (long int) D.25736;
      D.25738 = __builtin_expect (D.25737, 0);
      if (D.25738 != 0) goto <D.25970>; else goto <D.25971>;
      <D.25970>:
      D.25972 = mono_regname_full (sel, bank);
      D.25973 = load->data.op[0].const_val;
      printf ("\tSPILLED LOAD (%d at 0x%08lx(%%ebp)) R%d (freed %s)\n", spill, D.25973, i, D.25972);
      <D.25971>:
      D.25777 = bank != 0;
      D.25778 = (long int) D.25777;
      D.25779 = __builtin_expect (D.25778, 0);
      if (D.25779 != 0) goto <D.25974>; else goto <D.25975>;
      <D.25974>:
      D.25976 = 1 << sel;
      i = mono_regstate_alloc_general (rs, D.25976, bank);
      goto <D.25977>;
      <D.25975>:
      D.25976 = 1 << sel;
      i = mono_regstate_alloc_int (rs, D.25976);
      <D.25977>:
      D.25978 = i != sel;
      D.25979 = (long int) D.25978;
      D.25980 = __builtin_expect (D.25979, 0);
      if (D.25980 != 0) goto <D.25981>; else goto <D.25982>;
      <D.25981>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 898, "i == sel");
      <D.25982>:
      D.25983 = sel;
      return D.25983;
    }
  finally
    {
      sregs = {CLOBBER};
    }
}


get_vreg_bank (struct MonoCompile * cfg, int reg, int bank)
{
  unsigned int reg.98;
  unsigned int D.25988;
  gboolean * D.25990;
  long unsigned int D.25991;
  long unsigned int D.25992;
  gboolean * D.25993;
  int D.25994;
  int D.25996;
  unsigned int D.25998;
  gboolean * D.26000;
  gboolean * D.26001;
  int D.26002;

  reg.98 = (unsigned int) reg;
  D.25988 = cfg->vreg_is_ref_len;
  if (reg.98 < D.25988) goto <D.25989>; else goto <D.25986>;
  <D.25989>:
  D.25990 = cfg->vreg_is_ref;
  D.25991 = (long unsigned int) reg;
  D.25992 = D.25991 * 4;
  D.25993 = D.25990 + D.25992;
  D.25994 = *D.25993;
  if (D.25994 != 0) goto <D.25995>; else goto <D.25986>;
  <D.25995>:
  D.25996 = 2;
  return D.25996;
  <D.25986>:
  reg.98 = (unsigned int) reg;
  D.25998 = cfg->vreg_is_mp_len;
  if (reg.98 < D.25998) goto <D.25999>; else goto <D.25997>;
  <D.25999>:
  D.26000 = cfg->vreg_is_mp;
  D.25991 = (long unsigned int) reg;
  D.25992 = D.25991 * 4;
  D.26001 = D.26000 + D.25992;
  D.26002 = *D.26001;
  if (D.26002 != 0) goto <D.26003>; else goto <D.25997>;
  <D.26003>:
  D.25996 = 3;
  return D.25996;
  <D.25997>:
  D.25996 = bank;
  return D.25996;
}


mono_spillvar_offset (struct MonoCompile * cfg, int spillvar, int bank)
{
  int D.26005;
  _Bool D.26006;
  long int D.26007;
  long int D.26008;
  struct MonoSpillInfo * D.26011;
  long unsigned int D.26012;
  long unsigned int D.26013;
  int D.26014;
  int D.26017;
  unsigned int D.26018;
  unsigned int D.26019;
  int D.26020;
  int D.26021;
  _Bool D.26022;
  long int D.26023;
  long int D.26024;
  _Bool D.26027;
  long int D.26028;
  long int D.26029;
  unsigned int D.26033;
  unsigned int D.26034;
  int D.26037;
  int D.26038;
  int D.26039;
  int D.26040;
  int D.26041;
  int D.26043;
  int D.26044;
  struct MonoSpillInfo * info;
  int size;

  D.26005 = cfg->spill_info_len[bank];
  D.26006 = D.26005 <= spillvar;
  D.26007 = (long int) D.26006;
  D.26008 = __builtin_expect (D.26007, 0);
  if (D.26008 != 0) goto <D.26009>; else goto <D.26010>;
  <D.26009>:
  goto <D.23435>;
  <D.23434>:
  resize_spill_info (cfg, bank);
  <D.23435>:
  D.26005 = cfg->spill_info_len[bank];
  if (D.26005 <= spillvar) goto <D.23434>; else goto <D.23436>;
  <D.23436>:
  <D.26010>:
  D.26011 = cfg->spill_info[bank];
  D.26012 = (long unsigned int) spillvar;
  D.26013 = D.26012 * 4;
  info = D.26011 + D.26013;
  D.26014 = info->offset;
  if (D.26014 == -1) goto <D.26015>; else goto <D.26016>;
  <D.26015>:
  D.26017 = cfg->stack_offset;
  D.26018 = (unsigned int) D.26017;
  D.26019 = D.26018 + 7;
  D.26020 = (int) D.26019;
  cfg->stack_offset = D.26020;
  D.26017 = cfg->stack_offset;
  D.26021 = D.26017 & -8;
  cfg->stack_offset = D.26021;
  D.26022 = bank > 4;
  D.26023 = (long int) D.26022;
  D.26024 = __builtin_expect (D.26023, 0);
  if (D.26024 != 0) goto <D.26025>; else goto <D.26026>;
  <D.26025>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 329, "bank < MONO_NUM_REGBANKS");
  <D.26026>:
  D.26027 = bank != 0;
  D.26028 = (long int) D.26027;
  D.26029 = __builtin_expect (D.26028, 0);
  if (D.26029 != 0) goto <D.26030>; else goto <D.26031>;
  <D.26030>:
  size = regbank_spill_var_size[bank];
  goto <D.26032>;
  <D.26031>:
  size = 8;
  <D.26032>:
  D.26033 = cfg->flags;
  D.26034 = D.26033 & 64;
  if (D.26034 != 0) goto <D.26035>; else goto <D.26036>;
  <D.26035>:
  D.26017 = cfg->stack_offset;
  D.26037 = size + -1;
  D.26038 = D.26017 + D.26037;
  cfg->stack_offset = D.26038;
  D.26017 = cfg->stack_offset;
  D.26039 = -size;
  D.26040 = D.26017 & D.26039;
  cfg->stack_offset = D.26040;
  D.26017 = cfg->stack_offset;
  info->offset = D.26017;
  D.26017 = cfg->stack_offset;
  D.26041 = D.26017 + size;
  cfg->stack_offset = D.26041;
  goto <D.26042>;
  <D.26036>:
  D.26017 = cfg->stack_offset;
  D.26037 = size + -1;
  D.26038 = D.26017 + D.26037;
  cfg->stack_offset = D.26038;
  D.26017 = cfg->stack_offset;
  D.26039 = -size;
  D.26040 = D.26017 & D.26039;
  cfg->stack_offset = D.26040;
  D.26017 = cfg->stack_offset;
  D.26041 = D.26017 + size;
  cfg->stack_offset = D.26041;
  D.26017 = cfg->stack_offset;
  D.26043 = -D.26017;
  info->offset = D.26043;
  <D.26042>:
  <D.26016>:
  D.26044 = info->offset;
  return D.26044;
}


resize_spill_info (struct MonoCompile * cfg, int bank)
{
  int iftmp.99;
  _Bool D.26050;
  long int D.26051;
  long int D.26052;
  long unsigned int D.26055;
  unsigned int D.26056;
  unsigned int D.26057;
  struct MonoMemPool * D.26058;
  long unsigned int D.26061;
  long unsigned int D.26062;
  long unsigned int D.26063;
  long unsigned int D.26064;
  struct MonoSpillInfo * D.26065;
  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.26047>; else goto <D.26048>;
  <D.26047>:
  iftmp.99 = orig_len * 2;
  goto <D.26049>;
  <D.26048>:
  iftmp.99 = 16;
  <D.26049>:
  new_len = iftmp.99;
  D.26050 = bank > 4;
  D.26051 = (long int) D.26050;
  D.26052 = __builtin_expect (D.26051, 0);
  if (D.26052 != 0) goto <D.26053>; else goto <D.26054>;
  <D.26053>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 294, "bank < MONO_NUM_REGBANKS");
  <D.26054>:
  D.26055 = (long unsigned int) new_len;
  D.26056 = (unsigned int) D.26055;
  D.26057 = D.26056 * 4;
  D.26058 = cfg->mempool;
  new_info = mono_mempool_alloc0 (D.26058, D.26057);
  if (orig_info != 0B) goto <D.26059>; else goto <D.26060>;
  <D.26059>:
  D.26061 = (long unsigned int) orig_len;
  D.26062 = D.26061 * 4;
  memcpy (new_info, orig_info, D.26062);
  <D.26060>:
  i = orig_len;
  goto <D.23425>;
  <D.23424>:
  D.26063 = (long unsigned int) i;
  D.26064 = D.26063 * 4;
  D.26065 = new_info + D.26064;
  D.26065->offset = -1;
  i = i + 1;
  <D.23425>:
  if (i < new_len) goto <D.23424>; else goto <D.23426>;
  <D.23426>:
  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.26066;
  long unsigned int D.26067;

  D.26067 = __builtin_object_size (__dest, 0);
  D.26066 = __builtin___memcpy_chk (__dest, __src, __len, D.26067);
  return D.26066;
}


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

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


mono_regstate_alloc_general (struct MonoRegState * rs, regmask_t allow, int bank)
{
  long unsigned int D.26070;
  long unsigned int D.26071;
  long unsigned int D.26072;
  long unsigned int D.26075;
  long unsigned int D.26076;
  long unsigned int D.26077;
  int iftmp.100;
  int iftmp.101;
  int D.26088;
  int D.26089;
  int i;
  int mirrored_bank;
  regmask_t mask;

  D.26070 = rs->free_mask[bank];
  mask = D.26070 & allow;
  i = 0;
  goto <D.23390>;
  <D.23389>:
  D.26071 = mask >> i;
  D.26072 = D.26071 & 1;
  if (D.26072 != 0) goto <D.26073>; else goto <D.26074>;
  <D.26073>:
  D.26070 = rs->free_mask[bank];
  D.26075 = 1 << i;
  D.26076 = ~D.26075;
  D.26077 = D.26070 & D.26076;
  rs->free_mask[bank] = D.26077;
  if (bank != 4) goto <D.26079>; else goto <D.26080>;
  <D.26079>:
  if (bank == 1) goto <D.26082>; else goto <D.26083>;
  <D.26082>:
  iftmp.101 = 4;
  goto <D.26084>;
  <D.26083>:
  iftmp.101 = -1;
  <D.26084>:
  iftmp.100 = iftmp.101;
  goto <D.26085>;
  <D.26080>:
  iftmp.100 = 1;
  <D.26085>:
  mirrored_bank = iftmp.100;
  if (mirrored_bank == -1) goto <D.26086>; else goto <D.26087>;
  <D.26086>:
  D.26088 = i;
  return D.26088;
  <D.26087>:
  D.26070 = rs->free_mask[bank];
  rs->free_mask[mirrored_bank] = D.26070;
  D.26088 = i;
  return D.26088;
  <D.26074>:
  i = i + 1;
  <D.23390>:
  D.26089 = regbank_size[bank];
  if (D.26089 > i) goto <D.23389>; else goto <D.23391>;
  <D.23391>:
  D.26088 = -1;
  return D.26088;
}


free_up_hreg (struct MonoCompile * cfg, struct MonoBasicBlock * bb, struct MonoInst * * last, struct MonoInst * ins, int hreg, int bank)
{
  _Bool D.26091;
  long int D.26092;
  long int D.26093;
  struct MonoRegState * D.26096;
  long unsigned int D.26097;
  long unsigned int D.26098;
  long unsigned int D.26099;
  unsigned int D.26102;
  _Bool D.26103;
  long int D.26104;
  long int D.26105;
  int * D.26108;
  long unsigned int D.26109;
  long unsigned int D.26110;
  int * D.26111;
  int D.26112;
  long unsigned int D.26114;
  long unsigned int D.26115;
  long unsigned int D.26116;
  int D.26121;

  D.26091 = bank != 0;
  D.26092 = (long int) D.26091;
  D.26093 = __builtin_expect (D.26092, 0);
  if (D.26093 != 0) goto <D.26094>; else goto <D.26095>;
  <D.26094>:
  D.26096 = cfg->rs;
  D.26097 = D.26096->free_mask[bank];
  D.26098 = D.26097 >> hreg;
  D.26099 = D.26098 & 1;
  if (D.26099 == 0) goto <D.26100>; else goto <D.26101>;
  <D.26100>:
  D.26096 = cfg->rs;
  bank = translate_bank (D.26096, bank, hreg);
  D.26102 = cfg->verbose_level;
  D.26103 = D.26102 > 2;
  D.26104 = (long int) D.26103;
  D.26105 = __builtin_expect (D.26104, 0);
  if (D.26105 != 0) goto <D.26106>; else goto <D.26107>;
  <D.26106>:
  D.26096 = cfg->rs;
  D.26108 = D.26096->symbolic[bank];
  D.26109 = (long unsigned int) hreg;
  D.26110 = D.26109 * 4;
  D.26111 = D.26108 + D.26110;
  D.26112 = *D.26111;
  printf ("\tforced spill of R%d\n", D.26112);
  <D.26107>:
  D.26096 = cfg->rs;
  D.26108 = D.26096->symbolic[bank];
  D.26109 = (long unsigned int) hreg;
  D.26110 = D.26109 * 4;
  D.26111 = D.26108 + D.26110;
  D.26112 = *D.26111;
  spill_vreg (cfg, bb, last, ins, D.26112, bank);
  <D.26101>:
  goto <D.26113>;
  <D.26095>:
  D.26096 = cfg->rs;
  D.26114 = D.26096->ifree_mask;
  D.26115 = D.26114 >> hreg;
  D.26116 = D.26115 & 1;
  if (D.26116 == 0) goto <D.26117>; else goto <D.26118>;
  <D.26117>:
  D.26102 = cfg->verbose_level;
  D.26103 = D.26102 > 2;
  D.26104 = (long int) D.26103;
  D.26105 = __builtin_expect (D.26104, 0);
  if (D.26105 != 0) goto <D.26119>; else goto <D.26120>;
  <D.26119>:
  D.26096 = cfg->rs;
  D.26121 = D.26096->isymbolic[hreg];
  printf ("\tforced spill of R%d\n", D.26121);
  <D.26120>:
  D.26096 = cfg->rs;
  D.26121 = D.26096->isymbolic[hreg];
  spill_vreg (cfg, bb, last, ins, D.26121, bank);
  <D.26118>:
  <D.26113>:
}


mono_regstate_free_general (struct MonoRegState * rs, int reg, int bank)
{
  long unsigned int D.26124;
  long unsigned int D.26125;
  long unsigned int D.26126;
  int * D.26127;
  long unsigned int D.26128;
  long unsigned int D.26129;
  int * D.26130;
  int iftmp.102;
  int iftmp.103;
  int * D.26141;
  int * D.26142;
  int mirrored_bank;

  if (reg >= 0) goto <D.26122>; else goto <D.26123>;
  <D.26122>:
  D.26124 = rs->free_mask[bank];
  D.26125 = 1 << reg;
  D.26126 = D.26124 | D.26125;
  rs->free_mask[bank] = D.26126;
  D.26127 = rs->symbolic[bank];
  D.26128 = (long unsigned int) reg;
  D.26129 = D.26128 * 4;
  D.26130 = D.26127 + D.26129;
  *D.26130 = 0;
  if (bank != 4) goto <D.26132>; else goto <D.26133>;
  <D.26132>:
  if (bank == 1) goto <D.26135>; else goto <D.26136>;
  <D.26135>:
  iftmp.103 = 4;
  goto <D.26137>;
  <D.26136>:
  iftmp.103 = -1;
  <D.26137>:
  iftmp.102 = iftmp.103;
  goto <D.26138>;
  <D.26133>:
  iftmp.102 = 1;
  <D.26138>:
  mirrored_bank = iftmp.102;
  if (mirrored_bank == -1) goto <D.26139>; else goto <D.26140>;
  <D.26139>:
  return;
  <D.26140>:
  D.26124 = rs->free_mask[bank];
  rs->free_mask[mirrored_bank] = D.26124;
  D.26141 = rs->symbolic[mirrored_bank];
  D.26128 = (long unsigned int) reg;
  D.26129 = D.26128 * 4;
  D.26142 = D.26141 + D.26129;
  *D.26142 = 0;
  <D.26123>:
}


mono_regstate_free_int (struct MonoRegState * rs, int reg)
{
  long unsigned int D.26146;
  long unsigned int D.26147;
  long unsigned int D.26148;

  if (reg >= 0) goto <D.26144>; else goto <D.26145>;
  <D.26144>:
  D.26146 = rs->ifree_mask;
  D.26147 = 1 << reg;
  D.26148 = D.26146 | D.26147;
  rs->ifree_mask = D.26148;
  rs->isymbolic[reg] = 0;
  <D.26145>:
}


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.26149;
  int D.26150;
  short unsigned int D.26151;
  int D.26152;
  int D.26153;
  const unsigned char * D.26154;
  unsigned int D.26157;
  _Bool D.26158;
  long int D.26159;
  long int D.26160;
  const char * D.26163;
  const char * D.26164;
  struct MonoInst * D.26165;
  struct MonoInst * copy;

  D.26149 = cfg->mempool;
  copy = mono_mempool_alloc0 (D.26149, 80);
  D.26150 = regbank_move_ops[bank];
  D.26151 = (short unsigned int) D.26150;
  copy->opcode = D.26151;
  copy->dreg = -1;
  copy->sreg3 = -1;
  D.26152 = copy->sreg3;
  copy->sreg2 = D.26152;
  D.26153 = copy->sreg2;
  copy->sreg1 = D.26153;
  D.26154 = cfg->ip;
  copy->cil_code = D.26154;
  copy->dreg = dest;
  copy->sreg1 = src;
  copy->cil_code = ip;
  if (ins != 0B) goto <D.26155>; else goto <D.26156>;
  <D.26155>:
  mono_bblock_insert_after_ins (bb, ins, copy);
  *last = copy;
  <D.26156>:
  D.26157 = cfg->verbose_level;
  D.26158 = D.26157 > 2;
  D.26159 = (long int) D.26158;
  D.26160 = __builtin_expect (D.26159, 0);
  if (D.26160 != 0) goto <D.26161>; else goto <D.26162>;
  <D.26161>:
  D.26163 = mono_regname_full (dest, bank);
  D.26164 = mono_regname_full (src, bank);
  printf ("\tforced copy from %s to %s\n", D.26164, D.26163);
  <D.26162>:
  D.26165 = copy;
  return D.26165;
}


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.26167;
  long unsigned int D.26168;
  long unsigned int D.26169;
  gint32 * D.26170;
  struct MonoRegState * D.26171;
  int D.26172;
  int D.26173;
  long unsigned int D.26174;
  long unsigned int D.26175;
  gint32 * D.26176;
  int D.26177;
  _Bool D.26178;
  long int D.26179;
  long int D.26180;
  struct MonoMemPool * D.26184;
  int D.26185;
  short unsigned int D.26186;
  int D.26187;
  int D.26188;
  const unsigned char * D.26189;
  unsigned int D.26190;
  int D.26191;
  int D.26192;
  int D.26193;
  long int D.26194;
  unsigned int D.26195;
  _Bool D.26196;
  long int D.26197;
  long int D.26198;
  const char * D.26201;
  long int D.26202;
  long unsigned int D.26205;
  _Bool D.26207;
  long int D.26208;
  long int D.26209;
  struct MonoInst * load;
  int i;
  int sel;
  int spill;
  int * symbolic;
  struct MonoRegState * rs;

  rs = cfg->rs;
  symbolic = rs->symbolic[bank];
  D.26167 = rs->vassign;
  D.26168 = (long unsigned int) reg;
  D.26169 = D.26168 * 4;
  D.26170 = D.26167 + D.26169;
  sel = *D.26170;
  D.26171 = cfg->rs;
  bank = translate_bank (D.26171, bank, sel);
  i = reg;
  D.26172 = cfg->spill_count;
  D.26173 = D.26172 + 1;
  cfg->spill_count = D.26173;
  spill = cfg->spill_count;
  D.26167 = rs->vassign;
  D.26174 = (long unsigned int) i;
  D.26175 = D.26174 * 4;
  D.26176 = D.26167 + D.26175;
  D.26177 = ~spill;
  *D.26176 = D.26177;
  D.26178 = bank != 0;
  D.26179 = (long int) D.26178;
  D.26180 = __builtin_expect (D.26179, 0);
  if (D.26180 != 0) goto <D.26181>; else goto <D.26182>;
  <D.26181>:
  mono_regstate_free_general (rs, sel, bank);
  goto <D.26183>;
  <D.26182>:
  mono_regstate_free_int (rs, sel);
  <D.26183>:
  D.26184 = cfg->mempool;
  load = mono_mempool_alloc0 (D.26184, 80);
  D.26185 = regbank_load_ops[bank];
  D.26186 = (short unsigned int) D.26185;
  load->opcode = D.26186;
  load->dreg = -1;
  load->sreg3 = -1;
  D.26187 = load->sreg3;
  load->sreg2 = D.26187;
  D.26188 = load->sreg2;
  load->sreg1 = D.26188;
  D.26189 = cfg->ip;
  load->cil_code = D.26189;
  load->dreg = sel;
  D.26190 = cfg->frame_reg;
  D.26191 = (int) D.26190;
  load->sreg1 = D.26191;
  D.26192 = get_vreg_bank (cfg, reg, bank);
  D.26193 = mono_spillvar_offset (cfg, spill, D.26192);
  D.26194 = (long int) D.26193;
  load->data.op[0].const_val = D.26194;
  insert_after_ins (bb, ins, last, load);
  D.26195 = cfg->verbose_level;
  D.26196 = D.26195 > 2;
  D.26197 = (long int) D.26196;
  D.26198 = __builtin_expect (D.26197, 0);
  if (D.26198 != 0) goto <D.26199>; else goto <D.26200>;
  <D.26199>:
  D.26201 = mono_regname_full (sel, bank);
  D.26202 = load->data.op[0].const_val;
  printf ("SPILLED LOAD (%d at 0x%08lx(%%ebp)) R%d (freed %s)\n", spill, D.26202, i, D.26201);
  <D.26200>:
  D.26178 = bank != 0;
  D.26179 = (long int) D.26178;
  D.26180 = __builtin_expect (D.26179, 0);
  if (D.26180 != 0) goto <D.26203>; else goto <D.26204>;
  <D.26203>:
  D.26205 = 1 << sel;
  i = mono_regstate_alloc_general (rs, D.26205, bank);
  goto <D.26206>;
  <D.26204>:
  D.26205 = 1 << sel;
  i = mono_regstate_alloc_int (rs, D.26205);
  <D.26206>:
  D.26207 = i != sel;
  D.26208 = (long int) D.26207;
  D.26209 = __builtin_expect (D.26208, 0);
  if (D.26209 != 0) goto <D.26210>; else goto <D.26211>;
  <D.26210>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 807, "i == sel");
  <D.26211>:
  D.26178 = bank != 0;
  D.26179 = (long int) D.26178;
  D.26180 = __builtin_expect (D.26179, 0);
  if (D.26180 != 0) goto <D.26212>; else goto <D.26213>;
  <D.26212>:
  mono_regstate_free_general (rs, sel, bank);
  goto <D.26214>;
  <D.26213>:
  mono_regstate_free_int (rs, sel);
  <D.26214>:
}


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.26215;
  long int D.26216;
  long int D.26217;
  int D.26220;

  D.26215 = bank != 0;
  D.26216 = (long int) D.26215;
  D.26217 = __builtin_expect (D.26216, 0);
  if (D.26217 != 0) goto <D.26218>; else goto <D.26219>;
  <D.26218>:
  D.26220 = alloc_general_reg (cfg, bb, last, ins, dest_mask, sym_reg, bank);
  return D.26220;
  <D.26219>:
  D.26220 = alloc_int_reg (cfg, bb, last, ins, dest_mask, sym_reg, info);
  return D.26220;
}


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.26222;
  int D.26225;
  int val;

  D.26222 = cfg->rs;
  val = mono_regstate_alloc_general (D.26222, dest_mask, bank);
  if (val < 0) goto <D.26223>; else goto <D.26224>;
  <D.26223>:
  val = get_register_spilling (cfg, bb, last, ins, dest_mask, sym_reg, bank);
  <D.26224>:
  D.26225 = val;
  return D.26225;
}


assign_reg (struct MonoCompile * cfg, struct MonoRegState * rs, int reg, int hreg, int bank)
{
  _Bool D.26227;
  long int D.26228;
  long int D.26229;
  int D.26232;
  _Bool D.26233;
  long int D.26234;
  long int D.26235;
  _Bool D.26238;
  long int D.26239;
  long int D.26240;
  gint32 * D.26245;
  long unsigned int D.26246;
  long unsigned int D.26247;
  gint32 * D.26248;
  int * D.26249;
  long unsigned int D.26250;
  long unsigned int D.26251;
  int * D.26252;
  long unsigned int D.26253;
  long unsigned int D.26254;
  long unsigned int D.26255;
  long unsigned int D.26256;
  int iftmp.104;
  int iftmp.105;
  int * D.26267;
  int * D.26268;
  _Bool D.26270;
  long int D.26271;
  long int D.26272;
  _Bool D.26275;
  long int D.26276;
  long int D.26277;
  int iftmp.106;
  unsigned int hreg.107;
  long unsigned int D.26285;
  long unsigned int D.26286;
  _Bool D.26288;
  long int D.26289;
  long int D.26290;
  long unsigned int D.26293;
  long unsigned int D.26294;

  D.26227 = bank != 0;
  D.26228 = (long int) D.26227;
  D.26229 = __builtin_expect (D.26228, 0);
  if (D.26229 != 0) goto <D.26230>; else goto <D.26231>;
  <D.26230>:
  {
    int mirrored_bank;

    D.26232 = regbank_size[bank];
    D.26233 = D.26232 > reg;
    D.26234 = (long int) D.26233;
    D.26235 = __builtin_expect (D.26234, 0);
    if (D.26235 != 0) goto <D.26236>; else goto <D.26237>;
    <D.26236>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1040, "reg >= regbank_size [bank]");
    <D.26237>:
    D.26232 = regbank_size[bank];
    D.26238 = D.26232 <= hreg;
    D.26239 = (long int) D.26238;
    D.26240 = __builtin_expect (D.26239, 0);
    if (D.26240 != 0) goto <D.26241>; else goto <D.26242>;
    <D.26241>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1041, "hreg < regbank_size [bank]");
    <D.26242>:
    if (0 != 0) goto <D.26243>; else goto <D.26244>;
    <D.26243>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1042, "! is_global_freg (hreg)");
    <D.26244>:
    D.26245 = rs->vassign;
    D.26246 = (long unsigned int) reg;
    D.26247 = D.26246 * 4;
    D.26248 = D.26245 + D.26247;
    *D.26248 = hreg;
    D.26249 = rs->symbolic[bank];
    D.26250 = (long unsigned int) hreg;
    D.26251 = D.26250 * 4;
    D.26252 = D.26249 + D.26251;
    *D.26252 = reg;
    D.26253 = rs->free_mask[bank];
    D.26254 = 1 << hreg;
    D.26255 = ~D.26254;
    D.26256 = D.26253 & D.26255;
    rs->free_mask[bank] = D.26256;
    if (bank != 4) goto <D.26258>; else goto <D.26259>;
    <D.26258>:
    if (bank == 1) goto <D.26261>; else goto <D.26262>;
    <D.26261>:
    iftmp.105 = 4;
    goto <D.26263>;
    <D.26262>:
    iftmp.105 = -1;
    <D.26263>:
    iftmp.104 = iftmp.105;
    goto <D.26264>;
    <D.26259>:
    iftmp.104 = 1;
    <D.26264>:
    mirrored_bank = iftmp.104;
    if (mirrored_bank == -1) goto <D.26265>; else goto <D.26266>;
    <D.26265>:
    return;
    <D.26266>:
    D.26253 = rs->free_mask[bank];
    rs->free_mask[mirrored_bank] = D.26253;
    D.26267 = rs->symbolic[mirrored_bank];
    D.26250 = (long unsigned int) hreg;
    D.26251 = D.26250 * 4;
    D.26268 = D.26267 + D.26251;
    *D.26268 = -2;
  }
  goto <D.26269>;
  <D.26231>:
  D.26270 = reg <= 15;
  D.26271 = (long int) D.26270;
  D.26272 = __builtin_expect (D.26271, 0);
  if (D.26272 != 0) goto <D.26273>; else goto <D.26274>;
  <D.26273>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1064, "reg >= MONO_MAX_IREGS");
  <D.26274>:
  D.26275 = hreg > 15;
  D.26276 = (long int) D.26275;
  D.26277 = __builtin_expect (D.26276, 0);
  if (D.26277 != 0) goto <D.26278>; else goto <D.26279>;
  <D.26278>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1065, "hreg < MONO_MAX_IREGS");
  <D.26279>:
  hreg.107 = (unsigned int) hreg;
  if (hreg.107 <= 15) goto <D.26284>; else goto <D.26281>;
  <D.26284>:
  D.26285 = 61480 >> hreg;
  D.26286 = D.26285 & 1;
  if (D.26286 != 0) goto <D.26287>; else goto <D.26281>;
  <D.26287>:
  iftmp.106 = 1;
  goto <D.26282>;
  <D.26281>:
  iftmp.106 = 0;
  <D.26282>:
  D.26288 = iftmp.106 != 0;
  D.26289 = (long int) D.26288;
  D.26290 = __builtin_expect (D.26289, 0);
  if (D.26290 != 0) goto <D.26291>; else goto <D.26292>;
  <D.26291>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1068, "! is_global_ireg (hreg)");
  <D.26292>:
  D.26245 = rs->vassign;
  D.26246 = (long unsigned int) reg;
  D.26247 = D.26246 * 4;
  D.26248 = D.26245 + D.26247;
  *D.26248 = hreg;
  rs->isymbolic[hreg] = reg;
  D.26293 = rs->ifree_mask;
  D.26254 = 1 << hreg;
  D.26255 = ~D.26254;
  D.26294 = D.26293 & D.26255;
  rs->ifree_mask = D.26294;
  <D.26269>:
}


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.26296;
  int D.26297;
  short unsigned int D.26298;
  int D.26299;
  int D.26300;
  const unsigned char * D.26301;
  unsigned int D.26302;
  int D.26303;
  int D.26304;
  long int D.26305;
  unsigned int D.26312;
  _Bool D.26313;
  long int D.26314;
  long int D.26315;
  const char * D.26318;
  long int D.26319;
  const char * D.26320;
  unsigned int bank.108;
  unsigned int D.26322;
  unsigned char D.26325;
  unsigned char D.26326;
  _Bool D.26329;
  long int D.26330;
  long int D.26331;
  int D.26334;
  int D.26335;
  long int D.26336;
  long int D.26337;
  struct MonoInst * store;
  struct MonoInst * def;

  bank = get_vreg_bank (cfg, prev_reg, bank);
  D.26296 = cfg->mempool;
  store = mono_mempool_alloc0 (D.26296, 80);
  D.26297 = regbank_store_ops[bank];
  D.26298 = (short unsigned int) D.26297;
  store->opcode = D.26298;
  store->dreg = -1;
  store->sreg3 = -1;
  D.26299 = store->sreg3;
  store->sreg2 = D.26299;
  D.26300 = store->sreg2;
  store->sreg1 = D.26300;
  D.26301 = cfg->ip;
  store->cil_code = D.26301;
  store->sreg1 = reg;
  D.26302 = cfg->frame_reg;
  D.26303 = (int) D.26302;
  store->dreg = D.26303;
  D.26304 = mono_spillvar_offset (cfg, spill, bank);
  D.26305 = (long int) D.26304;
  store->data.op[0].const_val = D.26305;
  if (ins != 0B) goto <D.26306>; else goto <D.26307>;
  <D.26306>:
  mono_bblock_insert_after_ins (bb, ins, store);
  *last = store;
  goto <D.26308>;
  <D.26307>:
  if (insert_before != 0B) goto <D.26309>; else goto <D.26310>;
  <D.26309>:
  insert_before_ins (bb, insert_before, store);
  goto <D.26311>;
  <D.26310>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-codegen.c", 972);
  <D.26311>:
  <D.26308>:
  D.26312 = cfg->verbose_level;
  D.26313 = D.26312 > 2;
  D.26314 = (long int) D.26313;
  D.26315 = __builtin_expect (D.26314, 0);
  if (D.26315 != 0) goto <D.26316>; else goto <D.26317>;
  <D.26316>:
  D.26318 = mono_regname_full (reg, bank);
  D.26319 = store->data.op[0].const_val;
  D.26320 = regbank_to_string (bank);
  printf ("\t%sSPILLED STORE (%d at 0x%08lx(%%ebp)) R%d (from %s)\n", D.26320, spill, D.26319, prev_reg, D.26318);
  <D.26317>:
  bank.108 = (unsigned int) bank;
  D.26322 = bank.108 + 4294967294;
  if (D.26322 <= 1) goto <D.26323>; else goto <D.26324>;
  <D.26323>:
  D.26325 = BIT_FIELD_REF <*cfg, 8, 5632>;
  D.26326 = D.26325 & 128;
  if (D.26326 != 0) goto <D.26327>; else goto <D.26328>;
  <D.26327>:
  D.26329 = prev_reg == -1;
  D.26330 = (long int) D.26329;
  D.26331 = __builtin_expect (D.26330, 0);
  if (D.26331 != 0) goto <D.26332>; else goto <D.26333>;
  <D.26332>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 977, "prev_reg != -1");
  <D.26333>:
  D.26296 = cfg->mempool;
  def = mono_mempool_alloc0 (D.26296, 80);
  def->opcode = 1002;
  def->dreg = -1;
  def->sreg3 = -1;
  D.26334 = def->sreg3;
  def->sreg2 = D.26334;
  D.26335 = def->sreg2;
  def->sreg1 = D.26335;
  D.26301 = cfg->ip;
  def->cil_code = D.26301;
  D.26336 = (long int) spill;
  def->data.op[0].const_val = D.26336;
  D.26337 = (long int) bank;
  def->data.op[1].const_val = D.26337;
  mono_bblock_insert_after_ins (bb, store, def);
  <D.26328>:
  <D.26324>:
}


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

  if (bank == 2) goto <D.26338>; else goto <D.26339>;
  <D.26338>:
  D.26340 = "REF ";
  return D.26340;
  <D.26339>:
  if (bank == 3) goto <D.26341>; else goto <D.26342>;
  <D.26341>:
  D.26340 = "MP ";
  return D.26340;
  <D.26342>:
  D.26340 = "";
  return D.26340;
}


mono_opcode_to_cond (int opcode)
{
  CompRelation D.26344;
  const char * D.26345;

  switch (opcode) <default: <D.24000>, case 450: <D.23908>, case 451: <D.23953>, case 452: <D.23989>, case 453: <D.23942>, case 454: <D.23978>, case 455: <D.23915>, case 457: <D.23960>, case 459: <D.23949>, case 460: <D.23924>, case 462: <D.23996>, case 463: <D.23968>, case 464: <D.23985>, case 469: <D.23916>, case 471: <D.23961>, case 473: <D.23950>, case 474: <D.23925>, case 476: <D.23997>, case 477: <D.23969>, case 478: <D.23986>, case 535: <D.23912>, case 536: <D.23957>, case 537: <D.23993>, case 538: <D.23946>, case 539: <D.23982>, case 555: <D.23911>, case 556: <D.23938>, case 557: <D.23956>, case 558: <D.23931>, case 559: <D.23945>, case 560: <D.23922>, case 561: <D.23974>, case 562: <D.23992>, case 563: <D.23966>, case 564: <D.23981>, case 642: <D.23910>, case 643: <D.23955>, case 644: <D.23991>, case 645: <D.23944>, case 646: <D.23980>, case 647: <D.23920>, case 648: <D.23936>, case 649: <D.23929>, case 650: <D.23972>, case 651: <D.23964>, case 652: <D.23909>, case 653: <D.23937>, case 654: <D.23954>, case 655: <D.23930>, case 656: <D.23943>, case 657: <D.23921>, case 658: <D.23973>, case 659: <D.23990>, case 660: <D.23965>, case 661: <D.23979>, case 662: <D.23913>, case 663: <D.23939>, case 664: <D.23958>, case 665: <D.23932>, case 666: <D.23947>, case 667: <D.23923>, case 668: <D.23975>, case 669: <D.23995>, case 670: <D.23967>, case 671: <D.23983>, case 718: <D.23914>, case 719: <D.23959>, case 720: <D.23994>, case 721: <D.23948>, case 722: <D.23984>, case 723: <D.23919>, case 724: <D.23935>, case 725: <D.23928>, case 978: <D.23917>, case 979: <D.23940>, case 980: <D.23962>, case 981: <D.23933>, case 982: <D.23951>, case 983: <D.23926>, case 984: <D.23976>, case 985: <D.23998>, case 986: <D.23970>, case 987: <D.23987>, case 988: <D.23918>, case 989: <D.23941>, case 990: <D.23963>, case 991: <D.23934>, case 992: <D.23952>, case 993: <D.23927>, case 994: <D.23977>, case 995: <D.23999>, case 996: <D.23971>, case 997: <D.23988>>
  <D.23908>:
  <D.23909>:
  <D.23910>:
  <D.23911>:
  <D.23912>:
  <D.23913>:
  <D.23914>:
  <D.23915>:
  <D.23916>:
  <D.23917>:
  <D.23918>:
  D.26344 = 0;
  return D.26344;
  <D.23919>:
  <D.23920>:
  <D.23921>:
  <D.23922>:
  <D.23923>:
  <D.23924>:
  <D.23925>:
  <D.23926>:
  <D.23927>:
  D.26344 = 1;
  return D.26344;
  <D.23928>:
  <D.23929>:
  <D.23930>:
  <D.23931>:
  <D.23932>:
  <D.23933>:
  <D.23934>:
  D.26344 = 2;
  return D.26344;
  <D.23935>:
  <D.23936>:
  <D.23937>:
  <D.23938>:
  <D.23939>:
  <D.23940>:
  <D.23941>:
  D.26344 = 3;
  return D.26344;
  <D.23942>:
  <D.23943>:
  <D.23944>:
  <D.23945>:
  <D.23946>:
  <D.23947>:
  <D.23948>:
  <D.23949>:
  <D.23950>:
  <D.23951>:
  <D.23952>:
  D.26344 = 4;
  return D.26344;
  <D.23953>:
  <D.23954>:
  <D.23955>:
  <D.23956>:
  <D.23957>:
  <D.23958>:
  <D.23959>:
  <D.23960>:
  <D.23961>:
  <D.23962>:
  <D.23963>:
  D.26344 = 5;
  return D.26344;
  <D.23964>:
  <D.23965>:
  <D.23966>:
  <D.23967>:
  <D.23968>:
  <D.23969>:
  <D.23970>:
  <D.23971>:
  D.26344 = 6;
  return D.26344;
  <D.23972>:
  <D.23973>:
  <D.23974>:
  <D.23975>:
  <D.23976>:
  <D.23977>:
  D.26344 = 7;
  return D.26344;
  <D.23978>:
  <D.23979>:
  <D.23980>:
  <D.23981>:
  <D.23982>:
  <D.23983>:
  <D.23984>:
  <D.23985>:
  <D.23986>:
  <D.23987>:
  <D.23988>:
  D.26344 = 8;
  return D.26344;
  <D.23989>:
  <D.23990>:
  <D.23991>:
  <D.23992>:
  <D.23993>:
  <D.23994>:
  <D.23995>:
  <D.23996>:
  <D.23997>:
  <D.23998>:
  <D.23999>:
  D.26344 = 9;
  return D.26344;
  <D.24000>:
  D.26345 = mono_inst_name (opcode);
  printf ("%s\n", D.26345);
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-codegen.c", 2447);
  D.26344 = 0;
  return D.26344;
}


mono_negate_cond (CompRelation cond)
{
  CompRelation D.26347;

  switch (cond) <default: <D.24014>, case 0: <D.24004>, case 1: <D.24005>, case 2: <D.24006>, case 3: <D.24007>, case 4: <D.24008>, case 5: <D.24009>, case 6: <D.24010>, case 7: <D.24011>, case 8: <D.24012>, case 9: <D.24013>>
  <D.24004>:
  D.26347 = 1;
  return D.26347;
  <D.24005>:
  D.26347 = 0;
  return D.26347;
  <D.24006>:
  D.26347 = 5;
  return D.26347;
  <D.24007>:
  D.26347 = 4;
  return D.26347;
  <D.24008>:
  D.26347 = 3;
  return D.26347;
  <D.24009>:
  D.26347 = 2;
  return D.26347;
  <D.24010>:
  D.26347 = 9;
  return D.26347;
  <D.24011>:
  D.26347 = 8;
  return D.26347;
  <D.24012>:
  D.26347 = 7;
  return D.26347;
  <D.24013>:
  D.26347 = 6;
  return D.26347;
  <D.24014>:
  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.109;
  unsigned int D.26350;
  CompType D.26353;
  unsigned int D.26354;
  unsigned int D.26357;
  unsigned int D.26360;
  unsigned int D.26363;
  unsigned int D.26366;
  unsigned int D.26369;
  unsigned int D.26372;
  unsigned int D.26375;
  const char * D.26378;

  opcode.109 = (unsigned int) opcode;
  D.26350 = opcode.109 + 4294966846;
  if (D.26350 <= 4) goto <D.26351>; else goto <D.26352>;
  <D.26351>:
  D.26353 = 0;
  return D.26353;
  <D.26352>:
  opcode.109 = (unsigned int) opcode;
  D.26354 = opcode.109 + 4294966644;
  if (D.26354 <= 9) goto <D.26355>; else goto <D.26356>;
  <D.26355>:
  D.26353 = 1;
  return D.26353;
  <D.26356>:
  opcode.109 = (unsigned int) opcode;
  D.26357 = opcode.109 + 4294966654;
  if (D.26357 <= 4) goto <D.26358>; else goto <D.26359>;
  <D.26358>:
  D.26353 = 1;
  return D.26353;
  <D.26359>:
  opcode.109 = (unsigned int) opcode;
  D.26360 = opcode.109 + 4294966741;
  if (D.26360 <= 9) goto <D.26361>; else goto <D.26362>;
  <D.26361>:
  D.26353 = 0;
  return D.26353;
  <D.26362>:
  opcode.109 = (unsigned int) opcode;
  D.26363 = opcode.109 + 4294966761;
  if (D.26363 <= 4) goto <D.26364>; else goto <D.26365>;
  <D.26364>:
  D.26353 = 0;
  return D.26353;
  <D.26365>:
  opcode.109 = (unsigned int) opcode;
  D.26366 = opcode.109 + 4294966634;
  if (D.26366 <= 9) goto <D.26367>; else goto <D.26368>;
  <D.26367>:
  D.26353 = 2;
  return D.26353;
  <D.26368>:
  opcode.109 = (unsigned int) opcode;
  D.26369 = opcode.109 + 4294966578;
  if (D.26369 <= 4) goto <D.26370>; else goto <D.26371>;
  <D.26370>:
  D.26353 = 2;
  return D.26353;
  <D.26371>:
  opcode.109 = (unsigned int) opcode;
  D.26372 = opcode.109 + 4294966827;
  if (D.26372 <= 9) goto <D.26373>; else goto <D.26374>;
  <D.26373>:
  D.26353 = 1;
  return D.26353;
  <D.26374>:
  opcode.109 = (unsigned int) opcode;
  D.26375 = opcode.109 + 4294966841;
  if (D.26375 <= 9) goto <D.26376>; else goto <D.26377>;
  <D.26376>:
  switch (cmp_opcode) <default: <D.24021>, case 326: <D.24019>, case 327: <D.24020>>
  <D.24019>:
  <D.24020>:
  D.26353 = 1;
  return D.26353;
  <D.24021>:
  D.26353 = 0;
  return D.26353;
  <D.26377>:
  D.26378 = mono_inst_name (opcode);
  monoeg_g_log (0B, 4, "Unknown opcode \'%s\' in opcode_to_type", D.26378);
  <D.24022>:
  goto <D.24022>;
  D.26353 = 0;
  return D.26353;
}


mono_is_regsize_var (struct MonoType * t)
{
  unsigned char D.26380;
  unsigned char D.26381;
  gboolean D.26384;
  unsigned char D.26385;
  int D.26386;
  int D.26387;

  D.26380 = BIT_FIELD_REF <*t, 8, 88>;
  D.26381 = D.26380 & 64;
  if (D.26381 != 0) goto <D.26382>; else goto <D.26383>;
  <D.26382>:
  D.26384 = 1;
  return D.26384;
  <D.26383>:
  t = mono_type_get_underlying_type (t);
  D.26385 = t->type;
  D.26386 = (int) D.26385;
  switch (D.26386) <default: <D.24047>, case 2: <D.24026>, case 3: <D.24027>, case 4: <D.24028>, case 5: <D.24029>, case 6: <D.24030>, case 7: <D.24031>, case 8: <D.24032>, case 9: <D.24033>, case 10: <D.24038>, case 11: <D.24039>, case 14: <D.24041>, case 15: <D.24036>, case 17: <D.24046>, case 18: <D.24042>, case 20: <D.24044>, case 21: <D.24045>, case 24: <D.24034>, case 25: <D.24035>, case 27: <D.24037>, case 28: <D.24040>, case 29: <D.24043>>
  <D.24026>:
  <D.24027>:
  <D.24028>:
  <D.24029>:
  <D.24030>:
  <D.24031>:
  <D.24032>:
  <D.24033>:
  <D.24034>:
  <D.24035>:
  <D.24036>:
  <D.24037>:
  <D.24038>:
  <D.24039>:
  D.26384 = 1;
  return D.26384;
  <D.24040>:
  <D.24041>:
  <D.24042>:
  <D.24043>:
  <D.24044>:
  D.26384 = 1;
  return D.26384;
  <D.24045>:
  D.26387 = mono_type_generic_inst_is_valuetype (t);
  if (D.26387 == 0) goto <D.26388>; else goto <D.26389>;
  <D.26388>:
  D.26384 = 1;
  return D.26384;
  <D.26389>:
  D.26384 = 0;
  return D.26384;
  <D.24046>:
  D.26384 = 0;
  return D.26384;
  <D.24047>:
  D.26384 = 0;
  return D.26384;
}


mono_peephole_ins (struct MonoBasicBlock * bb, struct MonoInst * ins)
{
  short unsigned int D.26391;
  int D.26392;
  long int D.26393;
  int D.26396;
  int D.26397;
  struct MonoInst * D.26401;
  struct MonoInst * D.26404;
  struct MonoInst * D.26407;
  struct MonoInst * D.26410;
  int D.26413;
  int D.26414;
  short unsigned int D.26417;
  int D.26427;
  long int D.26430;
  long int D.26431;
  int D.26434;
  short unsigned int D.26447;
  _Bool D.26448;
  _Bool D.26449;
  _Bool D.26450;
  guint16 iftmp.110;
  guint16 iftmp.111;
  struct MonoInst * last_ins;

  last_ins = ins->prev;
  D.26391 = ins->opcode;
  D.26392 = (int) D.26391;
  switch (D.26392) <default: <D.26528>, case 316: <D.24063>, case 391: <D.24055>, case 392: <D.24057>, case 393: <D.24058>, case 394: <D.24059>, case 395: <D.24060>, case 396: <D.24056>, case 428: <D.24061>, case 430: <D.24062>, case 435: <D.24053>>
  <D.24053>:
  D.26393 = ins->data.op[1].const_val;
  if (D.26393 == 1) goto <D.26394>; else goto <D.26395>;
  <D.26394>:
  D.26396 = ins->dreg;
  D.26397 = ins->sreg1;
  if (D.26396 != D.26397) goto <D.26398>; else goto <D.26399>;
  <D.26398>:
  ins->opcode = 428;
  goto <D.26400>;
  <D.26399>:
  D.26401 = ins->prev;
  if (D.26401 != 0B) goto <D.26402>; else goto <D.26403>;
  <D.26402>:
  D.26401 = ins->prev;
  D.26404 = ins->next;
  D.26401->next = D.26404;
  <D.26403>:
  D.26404 = ins->next;
  if (D.26404 != 0B) goto <D.26405>; else goto <D.26406>;
  <D.26405>:
  D.26404 = ins->next;
  D.26401 = ins->prev;
  D.26404->prev = D.26401;
  <D.26406>:
  D.26407 = bb->code;
  if (D.26407 == ins) goto <D.26408>; else goto <D.26409>;
  <D.26408>:
  D.26404 = ins->next;
  bb->code = D.26404;
  <D.26409>:
  D.26410 = bb->last_ins;
  if (D.26410 == ins) goto <D.26411>; else goto <D.26412>;
  <D.26411>:
  D.26401 = ins->prev;
  bb->last_ins = D.26401;
  <D.26412>:
  ins->opcode = 316;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.26413 = ins->sreg3;
  ins->sreg2 = D.26413;
  D.26414 = ins->sreg2;
  ins->sreg1 = D.26414;
  <D.26400>:
  <D.26395>:
  goto <D.24054>;
  <D.24055>:
  <D.24056>:
  if (last_ins != 0B) goto <D.26415>; else goto <D.26416>;
  <D.26415>:
  D.26417 = last_ins->opcode;
  if (D.26417 == 1000) goto <D.26418>; else goto <D.26419>;
  <D.26418>:
  last_ins = last_ins->prev;
  <D.26419>:
  <D.26416>:
  if (last_ins != 0B) goto <D.26423>; else goto <D.26424>;
  <D.26423>:
  D.26391 = ins->opcode;
  if (D.26391 == 396) goto <D.26425>; else goto <D.26420>;
  <D.26425>:
  D.26417 = last_ins->opcode;
  if (D.26417 == 377) goto <D.26421>; else goto <D.26420>;
  <D.26420>:
  D.26391 = ins->opcode;
  if (D.26391 == 391) goto <D.26426>; else goto <D.26422>;
  <D.26426>:
  D.26417 = last_ins->opcode;
  if (D.26417 == 374) goto <D.26421>; else goto <D.26422>;
  <D.26421>:
  D.26397 = ins->sreg1;
  D.26427 = last_ins->dreg;
  if (D.26397 == D.26427) goto <D.26428>; else goto <D.26429>;
  <D.26428>:
  D.26430 = ins->data.op[0].const_val;
  D.26431 = last_ins->data.op[0].const_val;
  if (D.26430 == D.26431) goto <D.26432>; else goto <D.26433>;
  <D.26432>:
  D.26396 = ins->dreg;
  D.26434 = last_ins->sreg1;
  if (D.26396 == D.26434) goto <D.26435>; else goto <D.26436>;
  <D.26435>:
  D.26401 = ins->prev;
  if (D.26401 != 0B) goto <D.26437>; else goto <D.26438>;
  <D.26437>:
  D.26401 = ins->prev;
  D.26404 = ins->next;
  D.26401->next = D.26404;
  <D.26438>:
  D.26404 = ins->next;
  if (D.26404 != 0B) goto <D.26439>; else goto <D.26440>;
  <D.26439>:
  D.26404 = ins->next;
  D.26401 = ins->prev;
  D.26404->prev = D.26401;
  <D.26440>:
  D.26407 = bb->code;
  if (D.26407 == ins) goto <D.26441>; else goto <D.26442>;
  <D.26441>:
  D.26404 = ins->next;
  bb->code = D.26404;
  <D.26442>:
  D.26410 = bb->last_ins;
  if (D.26410 == ins) goto <D.26443>; else goto <D.26444>;
  <D.26443>:
  D.26401 = ins->prev;
  bb->last_ins = D.26401;
  <D.26444>:
  ins->opcode = 316;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.26413 = ins->sreg3;
  ins->sreg2 = D.26413;
  D.26414 = ins->sreg2;
  ins->sreg1 = D.26414;
  goto <D.24054>;
  <D.26436>:
  ins->opcode = 428;
  D.26434 = last_ins->sreg1;
  ins->sreg1 = D.26434;
  <D.26433>:
  <D.26429>:
  <D.26422>:
  <D.26424>:
  if (last_ins != 0B) goto <D.26445>; else goto <D.26446>;
  <D.26445>:
  D.26447 = last_ins->opcode;
  D.26448 = D.26447 == 396;
  D.26449 = D.26447 == 391;
  D.26450 = D.26448 | D.26449;
  if (D.26450 != 0) goto <D.26451>; else goto <D.26452>;
  <D.26451>:
  D.26397 = ins->sreg1;
  D.26427 = last_ins->dreg;
  if (D.26397 != D.26427) goto <D.26453>; else goto <D.26454>;
  <D.26453>:
  D.26397 = ins->sreg1;
  D.26434 = last_ins->sreg1;
  if (D.26397 == D.26434) goto <D.26455>; else goto <D.26456>;
  <D.26455>:
  D.26430 = ins->data.op[0].const_val;
  D.26431 = last_ins->data.op[0].const_val;
  if (D.26430 == D.26431) goto <D.26457>; else goto <D.26458>;
  <D.26457>:
  D.26396 = ins->dreg;
  D.26427 = last_ins->dreg;
  if (D.26396 == D.26427) goto <D.26459>; else goto <D.26460>;
  <D.26459>:
  D.26401 = ins->prev;
  if (D.26401 != 0B) goto <D.26461>; else goto <D.26462>;
  <D.26461>:
  D.26401 = ins->prev;
  D.26404 = ins->next;
  D.26401->next = D.26404;
  <D.26462>:
  D.26404 = ins->next;
  if (D.26404 != 0B) goto <D.26463>; else goto <D.26464>;
  <D.26463>:
  D.26404 = ins->next;
  D.26401 = ins->prev;
  D.26404->prev = D.26401;
  <D.26464>:
  D.26407 = bb->code;
  if (D.26407 == ins) goto <D.26465>; else goto <D.26466>;
  <D.26465>:
  D.26404 = ins->next;
  bb->code = D.26404;
  <D.26466>:
  D.26410 = bb->last_ins;
  if (D.26410 == ins) goto <D.26467>; else goto <D.26468>;
  <D.26467>:
  D.26401 = ins->prev;
  bb->last_ins = D.26401;
  <D.26468>:
  ins->opcode = 316;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.26413 = ins->sreg3;
  ins->sreg2 = D.26413;
  D.26414 = ins->sreg2;
  ins->sreg1 = D.26414;
  goto <D.26469>;
  <D.26460>:
  ins->opcode = 428;
  D.26427 = last_ins->dreg;
  ins->sreg1 = D.26427;
  <D.26469>:
  <D.26458>:
  <D.26456>:
  <D.26454>:
  <D.26452>:
  <D.26446>:
  goto <D.24054>;
  <D.24057>:
  <D.24058>:
  if (last_ins != 0B) goto <D.26470>; else goto <D.26471>;
  <D.26470>:
  D.26417 = last_ins->opcode;
  if (D.26417 == 375) goto <D.26472>; else goto <D.26473>;
  <D.26472>:
  D.26397 = ins->sreg1;
  D.26427 = last_ins->dreg;
  if (D.26397 == D.26427) goto <D.26474>; else goto <D.26475>;
  <D.26474>:
  D.26430 = ins->data.op[0].const_val;
  D.26431 = last_ins->data.op[0].const_val;
  if (D.26430 == D.26431) goto <D.26476>; else goto <D.26477>;
  <D.26476>:
  D.26391 = ins->opcode;
  if (D.26391 == 392) goto <D.26479>; else goto <D.26480>;
  <D.26479>:
  iftmp.110 = 498;
  goto <D.26481>;
  <D.26480>:
  iftmp.110 = 507;
  <D.26481>:
  ins->opcode = iftmp.110;
  D.26434 = last_ins->sreg1;
  ins->sreg1 = D.26434;
  <D.26477>:
  <D.26475>:
  <D.26473>:
  <D.26471>:
  goto <D.24054>;
  <D.24059>:
  <D.24060>:
  if (last_ins != 0B) goto <D.26482>; else goto <D.26483>;
  <D.26482>:
  D.26417 = last_ins->opcode;
  if (D.26417 == 376) goto <D.26484>; else goto <D.26485>;
  <D.26484>:
  D.26397 = ins->sreg1;
  D.26427 = last_ins->dreg;
  if (D.26397 == D.26427) goto <D.26486>; else goto <D.26487>;
  <D.26486>:
  D.26430 = ins->data.op[0].const_val;
  D.26431 = last_ins->data.op[0].const_val;
  if (D.26430 == D.26431) goto <D.26488>; else goto <D.26489>;
  <D.26488>:
  D.26391 = ins->opcode;
  if (D.26391 == 394) goto <D.26491>; else goto <D.26492>;
  <D.26491>:
  iftmp.111 = 499;
  goto <D.26493>;
  <D.26492>:
  iftmp.111 = 506;
  <D.26493>:
  ins->opcode = iftmp.111;
  D.26434 = last_ins->sreg1;
  ins->sreg1 = D.26434;
  <D.26489>:
  <D.26487>:
  <D.26485>:
  <D.26483>:
  goto <D.24054>;
  <D.24061>:
  <D.24062>:
  D.26396 = ins->dreg;
  D.26397 = ins->sreg1;
  if (D.26396 == D.26397) goto <D.26494>; else goto <D.26495>;
  <D.26494>:
  D.26401 = ins->prev;
  if (D.26401 != 0B) goto <D.26496>; else goto <D.26497>;
  <D.26496>:
  D.26401 = ins->prev;
  D.26404 = ins->next;
  D.26401->next = D.26404;
  <D.26497>:
  D.26404 = ins->next;
  if (D.26404 != 0B) goto <D.26498>; else goto <D.26499>;
  <D.26498>:
  D.26404 = ins->next;
  D.26401 = ins->prev;
  D.26404->prev = D.26401;
  <D.26499>:
  D.26407 = bb->code;
  if (D.26407 == ins) goto <D.26500>; else goto <D.26501>;
  <D.26500>:
  D.26404 = ins->next;
  bb->code = D.26404;
  <D.26501>:
  D.26410 = bb->last_ins;
  if (D.26410 == ins) goto <D.26502>; else goto <D.26503>;
  <D.26502>:
  D.26401 = ins->prev;
  bb->last_ins = D.26401;
  <D.26503>:
  ins->opcode = 316;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.26413 = ins->sreg3;
  ins->sreg2 = D.26413;
  D.26414 = ins->sreg2;
  ins->sreg1 = D.26414;
  goto <D.24054>;
  <D.26495>:
  if (last_ins != 0B) goto <D.26504>; else goto <D.26505>;
  <D.26504>:
  D.26417 = last_ins->opcode;
  D.26391 = ins->opcode;
  if (D.26417 == D.26391) goto <D.26506>; else goto <D.26507>;
  <D.26506>:
  D.26397 = ins->sreg1;
  D.26427 = last_ins->dreg;
  if (D.26397 == D.26427) goto <D.26508>; else goto <D.26509>;
  <D.26508>:
  D.26396 = ins->dreg;
  D.26434 = last_ins->sreg1;
  if (D.26396 == D.26434) goto <D.26510>; else goto <D.26511>;
  <D.26510>:
  D.26401 = ins->prev;
  if (D.26401 != 0B) goto <D.26512>; else goto <D.26513>;
  <D.26512>:
  D.26401 = ins->prev;
  D.26404 = ins->next;
  D.26401->next = D.26404;
  <D.26513>:
  D.26404 = ins->next;
  if (D.26404 != 0B) goto <D.26514>; else goto <D.26515>;
  <D.26514>:
  D.26404 = ins->next;
  D.26401 = ins->prev;
  D.26404->prev = D.26401;
  <D.26515>:
  D.26407 = bb->code;
  if (D.26407 == ins) goto <D.26516>; else goto <D.26517>;
  <D.26516>:
  D.26404 = ins->next;
  bb->code = D.26404;
  <D.26517>:
  D.26410 = bb->last_ins;
  if (D.26410 == ins) goto <D.26518>; else goto <D.26519>;
  <D.26518>:
  D.26401 = ins->prev;
  bb->last_ins = D.26401;
  <D.26519>:
  ins->opcode = 316;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.26413 = ins->sreg3;
  ins->sreg2 = D.26413;
  D.26414 = ins->sreg2;
  ins->sreg1 = D.26414;
  <D.26511>:
  <D.26509>:
  <D.26507>:
  <D.26505>:
  goto <D.24054>;
  <D.24063>:
  D.26401 = ins->prev;
  if (D.26401 != 0B) goto <D.26520>; else goto <D.26521>;
  <D.26520>:
  D.26401 = ins->prev;
  D.26404 = ins->next;
  D.26401->next = D.26404;
  <D.26521>:
  D.26404 = ins->next;
  if (D.26404 != 0B) goto <D.26522>; else goto <D.26523>;
  <D.26522>:
  D.26404 = ins->next;
  D.26401 = ins->prev;
  D.26404->prev = D.26401;
  <D.26523>:
  D.26407 = bb->code;
  if (D.26407 == ins) goto <D.26524>; else goto <D.26525>;
  <D.26524>:
  D.26404 = ins->next;
  bb->code = D.26404;
  <D.26525>:
  D.26410 = bb->last_ins;
  if (D.26410 == ins) goto <D.26526>; else goto <D.26527>;
  <D.26526>:
  D.26401 = ins->prev;
  bb->last_ins = D.26401;
  <D.26527>:
  ins->opcode = 316;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.26413 = ins->sreg3;
  ins->sreg2 = D.26413;
  D.26414 = ins->sreg2;
  ins->sreg1 = D.26414;
  goto <D.24054>;
  <D.26528>:
  <D.24054>:
}


mini_exception_id_by_name (const char * name)
{
  int D.24075;
  int iftmp.112;
  int D.24074;
  const char[25] * D.26532;
  unsigned char D.26533;
  int D.26534;
  unsigned char D.26535;
  int D.26536;
  _Bool D.26537;
  _Bool D.26538;
  _Bool D.26539;
  const unsigned char * D.26542;
  unsigned char D.26543;
  int D.26544;
  const unsigned char * D.26545;
  unsigned char D.26546;
  int D.26547;
  _Bool D.26548;
  _Bool D.26549;
  const unsigned char * D.26552;
  unsigned char D.26553;
  int D.26554;
  const unsigned char * D.26555;
  unsigned char D.26556;
  int D.26557;
  _Bool D.26558;
  _Bool D.26559;
  const unsigned char * D.26562;
  unsigned char D.26563;
  int D.26564;
  const unsigned char * D.26565;
  unsigned char D.26566;
  int D.26567;
  int D.26571;
  int D.24084;
  int iftmp.113;
  int D.24083;
  const char[18] * D.26575;
  unsigned char D.26576;
  int D.26577;
  unsigned char D.26578;
  int D.26579;
  _Bool D.26580;
  _Bool D.26581;
  _Bool D.26582;
  const unsigned char * D.26585;
  unsigned char D.26586;
  int D.26587;
  const unsigned char * D.26588;
  unsigned char D.26589;
  int D.26590;
  _Bool D.26591;
  _Bool D.26592;
  const unsigned char * D.26595;
  unsigned char D.26596;
  int D.26597;
  const unsigned char * D.26598;
  unsigned char D.26599;
  int D.26600;
  _Bool D.26601;
  _Bool D.26602;
  const unsigned char * D.26605;
  unsigned char D.26606;
  int D.26607;
  const unsigned char * D.26608;
  unsigned char D.26609;
  int D.26610;
  int D.24093;
  int iftmp.114;
  int D.24092;
  const char[20] * D.26617;
  unsigned char D.26618;
  int D.26619;
  unsigned char D.26620;
  int D.26621;
  _Bool D.26622;
  _Bool D.26623;
  _Bool D.26624;
  const unsigned char * D.26627;
  unsigned char D.26628;
  int D.26629;
  const unsigned char * D.26630;
  unsigned char D.26631;
  int D.26632;
  _Bool D.26633;
  _Bool D.26634;
  const unsigned char * D.26637;
  unsigned char D.26638;
  int D.26639;
  const unsigned char * D.26640;
  unsigned char D.26641;
  int D.26642;
  _Bool D.26643;
  _Bool D.26644;
  const unsigned char * D.26647;
  unsigned char D.26648;
  int D.26649;
  const unsigned char * D.26650;
  unsigned char D.26651;
  int D.26652;
  int D.24102;
  int iftmp.115;
  int D.24101;
  const char[22] * D.26659;
  unsigned char D.26660;
  int D.26661;
  unsigned char D.26662;
  int D.26663;
  _Bool D.26664;
  _Bool D.26665;
  _Bool D.26666;
  const unsigned char * D.26669;
  unsigned char D.26670;
  int D.26671;
  const unsigned char * D.26672;
  unsigned char D.26673;
  int D.26674;
  _Bool D.26675;
  _Bool D.26676;
  const unsigned char * D.26679;
  unsigned char D.26680;
  int D.26681;
  const unsigned char * D.26682;
  unsigned char D.26683;
  int D.26684;
  _Bool D.26685;
  _Bool D.26686;
  const unsigned char * D.26689;
  unsigned char D.26690;
  int D.26691;
  const unsigned char * D.26692;
  unsigned char D.26693;
  int D.26694;
  int D.24111;
  int iftmp.116;
  int D.24110;
  const char[21] * D.26701;
  unsigned char D.26702;
  int D.26703;
  unsigned char D.26704;
  int D.26705;
  _Bool D.26706;
  _Bool D.26707;
  _Bool D.26708;
  const unsigned char * D.26711;
  unsigned char D.26712;
  int D.26713;
  const unsigned char * D.26714;
  unsigned char D.26715;
  int D.26716;
  _Bool D.26717;
  _Bool D.26718;
  const unsigned char * D.26721;
  unsigned char D.26722;
  int D.26723;
  const unsigned char * D.26724;
  unsigned char D.26725;
  int D.26726;
  _Bool D.26727;
  _Bool D.26728;
  const unsigned char * D.26731;
  unsigned char D.26732;
  int D.26733;
  const unsigned char * D.26734;
  unsigned char D.26735;
  int D.26736;
  int D.24120;
  int iftmp.117;
  int D.24119;
  const char[23] * D.26743;
  unsigned char D.26744;
  int D.26745;
  unsigned char D.26746;
  int D.26747;
  _Bool D.26748;
  _Bool D.26749;
  _Bool D.26750;
  const unsigned char * D.26753;
  unsigned char D.26754;
  int D.26755;
  const unsigned char * D.26756;
  unsigned char D.26757;
  int D.26758;
  _Bool D.26759;
  _Bool D.26760;
  const unsigned char * D.26763;
  unsigned char D.26764;
  int D.26765;
  const unsigned char * D.26766;
  unsigned char D.26767;
  int D.26768;
  _Bool D.26769;
  _Bool D.26770;
  const unsigned char * D.26773;
  unsigned char D.26774;
  int D.26775;
  const unsigned char * D.26776;
  unsigned char D.26777;
  int D.26778;
  int D.24129;
  int iftmp.118;
  int D.24128;
  const char[27] * D.26785;
  unsigned char D.26786;
  int D.26787;
  unsigned char D.26788;
  int D.26789;
  _Bool D.26790;
  _Bool D.26791;
  _Bool D.26792;
  const unsigned char * D.26795;
  unsigned char D.26796;
  int D.26797;
  const unsigned char * D.26798;
  unsigned char D.26799;
  int D.26800;
  _Bool D.26801;
  _Bool D.26802;
  const unsigned char * D.26805;
  unsigned char D.26806;
  int D.26807;
  const unsigned char * D.26808;
  unsigned char D.26809;
  int D.26810;
  _Bool D.26811;
  _Bool D.26812;
  const unsigned char * D.26815;
  unsigned char D.26816;
  int D.26817;
  const unsigned char * D.26818;
  unsigned char D.26819;
  int D.26820;
  int D.24138;
  int iftmp.119;
  int D.24137;
  const char[18] * D.26827;
  unsigned char D.26828;
  int D.26829;
  unsigned char D.26830;
  int D.26831;
  _Bool D.26832;
  _Bool D.26833;
  _Bool D.26834;
  const unsigned char * D.26837;
  unsigned char D.26838;
  int D.26839;
  const unsigned char * D.26840;
  unsigned char D.26841;
  int D.26842;
  _Bool D.26843;
  _Bool D.26844;
  const unsigned char * D.26847;
  unsigned char D.26848;
  int D.26849;
  const unsigned char * D.26850;
  unsigned char D.26851;
  int D.26852;
  _Bool D.26853;
  _Bool D.26854;
  const unsigned char * D.26857;
  unsigned char D.26858;
  int D.26859;
  const unsigned char * D.26860;
  unsigned char D.26861;
  int D.26862;

  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.26532 = "IndexOutOfRangeException";
      D.26533 = MEM[(const unsigned char *)D.26532];
      D.26534 = (int) D.26533;
      D.26535 = *__s2;
      D.26536 = (int) D.26535;
      __result = D.26534 - D.26536;
      {
        D.26537 = __s2_len != 0;
        D.26538 = __result == 0;
        D.26539 = D.26537 & D.26538;
        if (D.26539 != 0) goto <D.26540>; else goto <D.26541>;
        <D.26540>:
        D.26542 = &MEM[(void *)"IndexOutOfRangeException" + 1B];
        D.26543 = *D.26542;
        D.26544 = (int) D.26543;
        D.26545 = __s2 + 1;
        D.26546 = *D.26545;
        D.26547 = (int) D.26546;
        __result = D.26544 - D.26547;
        D.26548 = __s2_len > 1;
        D.26538 = __result == 0;
        D.26549 = D.26548 & D.26538;
        if (D.26549 != 0) goto <D.26550>; else goto <D.26551>;
        <D.26550>:
        D.26552 = &MEM[(void *)"IndexOutOfRangeException" + 2B];
        D.26553 = *D.26552;
        D.26554 = (int) D.26553;
        D.26555 = __s2 + 2;
        D.26556 = *D.26555;
        D.26557 = (int) D.26556;
        __result = D.26554 - D.26557;
        D.26558 = __s2_len > 2;
        D.26538 = __result == 0;
        D.26559 = D.26558 & D.26538;
        if (D.26559 != 0) goto <D.26560>; else goto <D.26561>;
        <D.26560>:
        D.26562 = &MEM[(void *)"IndexOutOfRangeException" + 3B];
        D.26563 = *D.26562;
        D.26564 = (int) D.26563;
        D.26565 = __s2 + 3;
        D.26566 = *D.26565;
        D.26567 = (int) D.26566;
        __result = D.26564 - D.26567;
        <D.26561>:
        <D.26551>:
        <D.26541>:
      }
      D.24074 = __result;
    }
    iftmp.112 = -D.24074;
    goto <D.26568>;
    <D.26531>:
    iftmp.112 = __builtin_strcmp (name, "IndexOutOfRangeException");
    <D.26568>:
    D.24075 = iftmp.112;
  }
  if (D.24075 == 0) goto <D.26569>; else goto <D.26570>;
  <D.26569>:
  D.26571 = 0;
  return D.26571;
  <D.26570>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.26575 = "OverflowException";
      D.26576 = MEM[(const unsigned char *)D.26575];
      D.26577 = (int) D.26576;
      D.26578 = *__s2;
      D.26579 = (int) D.26578;
      __result = D.26577 - D.26579;
      {
        D.26580 = __s2_len != 0;
        D.26581 = __result == 0;
        D.26582 = D.26580 & D.26581;
        if (D.26582 != 0) goto <D.26583>; else goto <D.26584>;
        <D.26583>:
        D.26585 = &MEM[(void *)"OverflowException" + 1B];
        D.26586 = *D.26585;
        D.26587 = (int) D.26586;
        D.26588 = __s2 + 1;
        D.26589 = *D.26588;
        D.26590 = (int) D.26589;
        __result = D.26587 - D.26590;
        D.26591 = __s2_len > 1;
        D.26581 = __result == 0;
        D.26592 = D.26591 & D.26581;
        if (D.26592 != 0) goto <D.26593>; else goto <D.26594>;
        <D.26593>:
        D.26595 = &MEM[(void *)"OverflowException" + 2B];
        D.26596 = *D.26595;
        D.26597 = (int) D.26596;
        D.26598 = __s2 + 2;
        D.26599 = *D.26598;
        D.26600 = (int) D.26599;
        __result = D.26597 - D.26600;
        D.26601 = __s2_len > 2;
        D.26581 = __result == 0;
        D.26602 = D.26601 & D.26581;
        if (D.26602 != 0) goto <D.26603>; else goto <D.26604>;
        <D.26603>:
        D.26605 = &MEM[(void *)"OverflowException" + 3B];
        D.26606 = *D.26605;
        D.26607 = (int) D.26606;
        D.26608 = __s2 + 3;
        D.26609 = *D.26608;
        D.26610 = (int) D.26609;
        __result = D.26607 - D.26610;
        <D.26604>:
        <D.26594>:
        <D.26584>:
      }
      D.24083 = __result;
    }
    iftmp.113 = -D.24083;
    goto <D.26611>;
    <D.26574>:
    iftmp.113 = __builtin_strcmp (name, "OverflowException");
    <D.26611>:
    D.24084 = iftmp.113;
  }
  if (D.24084 == 0) goto <D.26612>; else goto <D.26613>;
  <D.26612>:
  D.26571 = 1;
  return D.26571;
  <D.26613>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.26617 = "ArithmeticException";
      D.26618 = MEM[(const unsigned char *)D.26617];
      D.26619 = (int) D.26618;
      D.26620 = *__s2;
      D.26621 = (int) D.26620;
      __result = D.26619 - D.26621;
      {
        D.26622 = __s2_len != 0;
        D.26623 = __result == 0;
        D.26624 = D.26622 & D.26623;
        if (D.26624 != 0) goto <D.26625>; else goto <D.26626>;
        <D.26625>:
        D.26627 = &MEM[(void *)"ArithmeticException" + 1B];
        D.26628 = *D.26627;
        D.26629 = (int) D.26628;
        D.26630 = __s2 + 1;
        D.26631 = *D.26630;
        D.26632 = (int) D.26631;
        __result = D.26629 - D.26632;
        D.26633 = __s2_len > 1;
        D.26623 = __result == 0;
        D.26634 = D.26633 & D.26623;
        if (D.26634 != 0) goto <D.26635>; else goto <D.26636>;
        <D.26635>:
        D.26637 = &MEM[(void *)"ArithmeticException" + 2B];
        D.26638 = *D.26637;
        D.26639 = (int) D.26638;
        D.26640 = __s2 + 2;
        D.26641 = *D.26640;
        D.26642 = (int) D.26641;
        __result = D.26639 - D.26642;
        D.26643 = __s2_len > 2;
        D.26623 = __result == 0;
        D.26644 = D.26643 & D.26623;
        if (D.26644 != 0) goto <D.26645>; else goto <D.26646>;
        <D.26645>:
        D.26647 = &MEM[(void *)"ArithmeticException" + 3B];
        D.26648 = *D.26647;
        D.26649 = (int) D.26648;
        D.26650 = __s2 + 3;
        D.26651 = *D.26650;
        D.26652 = (int) D.26651;
        __result = D.26649 - D.26652;
        <D.26646>:
        <D.26636>:
        <D.26626>:
      }
      D.24092 = __result;
    }
    iftmp.114 = -D.24092;
    goto <D.26653>;
    <D.26616>:
    iftmp.114 = __builtin_strcmp (name, "ArithmeticException");
    <D.26653>:
    D.24093 = iftmp.114;
  }
  if (D.24093 == 0) goto <D.26654>; else goto <D.26655>;
  <D.26654>:
  D.26571 = 2;
  return D.26571;
  <D.26655>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.26659 = "DivideByZeroException";
      D.26660 = MEM[(const unsigned char *)D.26659];
      D.26661 = (int) D.26660;
      D.26662 = *__s2;
      D.26663 = (int) D.26662;
      __result = D.26661 - D.26663;
      {
        D.26664 = __s2_len != 0;
        D.26665 = __result == 0;
        D.26666 = D.26664 & D.26665;
        if (D.26666 != 0) goto <D.26667>; else goto <D.26668>;
        <D.26667>:
        D.26669 = &MEM[(void *)"DivideByZeroException" + 1B];
        D.26670 = *D.26669;
        D.26671 = (int) D.26670;
        D.26672 = __s2 + 1;
        D.26673 = *D.26672;
        D.26674 = (int) D.26673;
        __result = D.26671 - D.26674;
        D.26675 = __s2_len > 1;
        D.26665 = __result == 0;
        D.26676 = D.26675 & D.26665;
        if (D.26676 != 0) goto <D.26677>; else goto <D.26678>;
        <D.26677>:
        D.26679 = &MEM[(void *)"DivideByZeroException" + 2B];
        D.26680 = *D.26679;
        D.26681 = (int) D.26680;
        D.26682 = __s2 + 2;
        D.26683 = *D.26682;
        D.26684 = (int) D.26683;
        __result = D.26681 - D.26684;
        D.26685 = __s2_len > 2;
        D.26665 = __result == 0;
        D.26686 = D.26685 & D.26665;
        if (D.26686 != 0) goto <D.26687>; else goto <D.26688>;
        <D.26687>:
        D.26689 = &MEM[(void *)"DivideByZeroException" + 3B];
        D.26690 = *D.26689;
        D.26691 = (int) D.26690;
        D.26692 = __s2 + 3;
        D.26693 = *D.26692;
        D.26694 = (int) D.26693;
        __result = D.26691 - D.26694;
        <D.26688>:
        <D.26678>:
        <D.26668>:
      }
      D.24101 = __result;
    }
    iftmp.115 = -D.24101;
    goto <D.26695>;
    <D.26658>:
    iftmp.115 = __builtin_strcmp (name, "DivideByZeroException");
    <D.26695>:
    D.24102 = iftmp.115;
  }
  if (D.24102 == 0) goto <D.26696>; else goto <D.26697>;
  <D.26696>:
  D.26571 = 3;
  return D.26571;
  <D.26697>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.26701 = "InvalidCastException";
      D.26702 = MEM[(const unsigned char *)D.26701];
      D.26703 = (int) D.26702;
      D.26704 = *__s2;
      D.26705 = (int) D.26704;
      __result = D.26703 - D.26705;
      {
        D.26706 = __s2_len != 0;
        D.26707 = __result == 0;
        D.26708 = D.26706 & D.26707;
        if (D.26708 != 0) goto <D.26709>; else goto <D.26710>;
        <D.26709>:
        D.26711 = &MEM[(void *)"InvalidCastException" + 1B];
        D.26712 = *D.26711;
        D.26713 = (int) D.26712;
        D.26714 = __s2 + 1;
        D.26715 = *D.26714;
        D.26716 = (int) D.26715;
        __result = D.26713 - D.26716;
        D.26717 = __s2_len > 1;
        D.26707 = __result == 0;
        D.26718 = D.26717 & D.26707;
        if (D.26718 != 0) goto <D.26719>; else goto <D.26720>;
        <D.26719>:
        D.26721 = &MEM[(void *)"InvalidCastException" + 2B];
        D.26722 = *D.26721;
        D.26723 = (int) D.26722;
        D.26724 = __s2 + 2;
        D.26725 = *D.26724;
        D.26726 = (int) D.26725;
        __result = D.26723 - D.26726;
        D.26727 = __s2_len > 2;
        D.26707 = __result == 0;
        D.26728 = D.26727 & D.26707;
        if (D.26728 != 0) goto <D.26729>; else goto <D.26730>;
        <D.26729>:
        D.26731 = &MEM[(void *)"InvalidCastException" + 3B];
        D.26732 = *D.26731;
        D.26733 = (int) D.26732;
        D.26734 = __s2 + 3;
        D.26735 = *D.26734;
        D.26736 = (int) D.26735;
        __result = D.26733 - D.26736;
        <D.26730>:
        <D.26720>:
        <D.26710>:
      }
      D.24110 = __result;
    }
    iftmp.116 = -D.24110;
    goto <D.26737>;
    <D.26700>:
    iftmp.116 = __builtin_strcmp (name, "InvalidCastException");
    <D.26737>:
    D.24111 = iftmp.116;
  }
  if (D.24111 == 0) goto <D.26738>; else goto <D.26739>;
  <D.26738>:
  D.26571 = 4;
  return D.26571;
  <D.26739>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.26743 = "NullReferenceException";
      D.26744 = MEM[(const unsigned char *)D.26743];
      D.26745 = (int) D.26744;
      D.26746 = *__s2;
      D.26747 = (int) D.26746;
      __result = D.26745 - D.26747;
      {
        D.26748 = __s2_len != 0;
        D.26749 = __result == 0;
        D.26750 = D.26748 & D.26749;
        if (D.26750 != 0) goto <D.26751>; else goto <D.26752>;
        <D.26751>:
        D.26753 = &MEM[(void *)"NullReferenceException" + 1B];
        D.26754 = *D.26753;
        D.26755 = (int) D.26754;
        D.26756 = __s2 + 1;
        D.26757 = *D.26756;
        D.26758 = (int) D.26757;
        __result = D.26755 - D.26758;
        D.26759 = __s2_len > 1;
        D.26749 = __result == 0;
        D.26760 = D.26759 & D.26749;
        if (D.26760 != 0) goto <D.26761>; else goto <D.26762>;
        <D.26761>:
        D.26763 = &MEM[(void *)"NullReferenceException" + 2B];
        D.26764 = *D.26763;
        D.26765 = (int) D.26764;
        D.26766 = __s2 + 2;
        D.26767 = *D.26766;
        D.26768 = (int) D.26767;
        __result = D.26765 - D.26768;
        D.26769 = __s2_len > 2;
        D.26749 = __result == 0;
        D.26770 = D.26769 & D.26749;
        if (D.26770 != 0) goto <D.26771>; else goto <D.26772>;
        <D.26771>:
        D.26773 = &MEM[(void *)"NullReferenceException" + 3B];
        D.26774 = *D.26773;
        D.26775 = (int) D.26774;
        D.26776 = __s2 + 3;
        D.26777 = *D.26776;
        D.26778 = (int) D.26777;
        __result = D.26775 - D.26778;
        <D.26772>:
        <D.26762>:
        <D.26752>:
      }
      D.24119 = __result;
    }
    iftmp.117 = -D.24119;
    goto <D.26779>;
    <D.26742>:
    iftmp.117 = __builtin_strcmp (name, "NullReferenceException");
    <D.26779>:
    D.24120 = iftmp.117;
  }
  if (D.24120 == 0) goto <D.26780>; else goto <D.26781>;
  <D.26780>:
  D.26571 = 5;
  return D.26571;
  <D.26781>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.26785 = "ArrayTypeMismatchException";
      D.26786 = MEM[(const unsigned char *)D.26785];
      D.26787 = (int) D.26786;
      D.26788 = *__s2;
      D.26789 = (int) D.26788;
      __result = D.26787 - D.26789;
      {
        D.26790 = __s2_len != 0;
        D.26791 = __result == 0;
        D.26792 = D.26790 & D.26791;
        if (D.26792 != 0) goto <D.26793>; else goto <D.26794>;
        <D.26793>:
        D.26795 = &MEM[(void *)"ArrayTypeMismatchException" + 1B];
        D.26796 = *D.26795;
        D.26797 = (int) D.26796;
        D.26798 = __s2 + 1;
        D.26799 = *D.26798;
        D.26800 = (int) D.26799;
        __result = D.26797 - D.26800;
        D.26801 = __s2_len > 1;
        D.26791 = __result == 0;
        D.26802 = D.26801 & D.26791;
        if (D.26802 != 0) goto <D.26803>; else goto <D.26804>;
        <D.26803>:
        D.26805 = &MEM[(void *)"ArrayTypeMismatchException" + 2B];
        D.26806 = *D.26805;
        D.26807 = (int) D.26806;
        D.26808 = __s2 + 2;
        D.26809 = *D.26808;
        D.26810 = (int) D.26809;
        __result = D.26807 - D.26810;
        D.26811 = __s2_len > 2;
        D.26791 = __result == 0;
        D.26812 = D.26811 & D.26791;
        if (D.26812 != 0) goto <D.26813>; else goto <D.26814>;
        <D.26813>:
        D.26815 = &MEM[(void *)"ArrayTypeMismatchException" + 3B];
        D.26816 = *D.26815;
        D.26817 = (int) D.26816;
        D.26818 = __s2 + 3;
        D.26819 = *D.26818;
        D.26820 = (int) D.26819;
        __result = D.26817 - D.26820;
        <D.26814>:
        <D.26804>:
        <D.26794>:
      }
      D.24128 = __result;
    }
    iftmp.118 = -D.24128;
    goto <D.26821>;
    <D.26784>:
    iftmp.118 = __builtin_strcmp (name, "ArrayTypeMismatchException");
    <D.26821>:
    D.24129 = iftmp.118;
  }
  if (D.24129 == 0) goto <D.26822>; else goto <D.26823>;
  <D.26822>:
  D.26571 = 6;
  return D.26571;
  <D.26823>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.26827 = "ArgumentException";
      D.26828 = MEM[(const unsigned char *)D.26827];
      D.26829 = (int) D.26828;
      D.26830 = *__s2;
      D.26831 = (int) D.26830;
      __result = D.26829 - D.26831;
      {
        D.26832 = __s2_len != 0;
        D.26833 = __result == 0;
        D.26834 = D.26832 & D.26833;
        if (D.26834 != 0) goto <D.26835>; else goto <D.26836>;
        <D.26835>:
        D.26837 = &MEM[(void *)"ArgumentException" + 1B];
        D.26838 = *D.26837;
        D.26839 = (int) D.26838;
        D.26840 = __s2 + 1;
        D.26841 = *D.26840;
        D.26842 = (int) D.26841;
        __result = D.26839 - D.26842;
        D.26843 = __s2_len > 1;
        D.26833 = __result == 0;
        D.26844 = D.26843 & D.26833;
        if (D.26844 != 0) goto <D.26845>; else goto <D.26846>;
        <D.26845>:
        D.26847 = &MEM[(void *)"ArgumentException" + 2B];
        D.26848 = *D.26847;
        D.26849 = (int) D.26848;
        D.26850 = __s2 + 2;
        D.26851 = *D.26850;
        D.26852 = (int) D.26851;
        __result = D.26849 - D.26852;
        D.26853 = __s2_len > 2;
        D.26833 = __result == 0;
        D.26854 = D.26853 & D.26833;
        if (D.26854 != 0) goto <D.26855>; else goto <D.26856>;
        <D.26855>:
        D.26857 = &MEM[(void *)"ArgumentException" + 3B];
        D.26858 = *D.26857;
        D.26859 = (int) D.26858;
        D.26860 = __s2 + 3;
        D.26861 = *D.26860;
        D.26862 = (int) D.26861;
        __result = D.26859 - D.26862;
        <D.26856>:
        <D.26846>:
        <D.26836>:
      }
      D.24137 = __result;
    }
    iftmp.119 = -D.24137;
    goto <D.26863>;
    <D.26826>:
    iftmp.119 = __builtin_strcmp (name, "ArgumentException");
    <D.26863>:
    D.24138 = iftmp.119;
  }
  if (D.24138 == 0) goto <D.26864>; else goto <D.26865>;
  <D.26864>:
  D.26571 = 7;
  return D.26571;
  <D.26865>:
  monoeg_g_log (0B, 4, "Unknown intrinsic exception %s\n", name);
  <D.24139>:
  goto <D.24139>;
  D.26571 = -1;
  return D.26571;
}