mono_regname_full (int reg, int bank)
{
  _Bool D.23363;
  long int D.23364;
  long int D.23365;
  unsigned int bank.0;
  unsigned int D.23369;
  const char * D.23372;
  _Bool D.23373;
  long int D.23374;
  long int D.23375;

  D.23363 = bank != 0;
  D.23364 = (long int) D.23363;
  D.23365 = __builtin_expect (D.23364, 0);
  if (D.23365 != 0) goto <D.23366>; else goto <D.23367>;
  <D.23366>:
  bank.0 = (unsigned int) bank;
  D.23369 = bank.0 + 4294967294;
  if (D.23369 <= 1) goto <D.23370>; else goto <D.23371>;
  <D.23370>:
  D.23372 = mono_arch_regname (reg);
  return D.23372;
  <D.23371>:
  D.23373 = bank != 1;
  D.23374 = (long int) D.23373;
  D.23375 = __builtin_expect (D.23374, 0);
  if (D.23375 != 0) goto <D.23376>; else goto <D.23377>;
  <D.23376>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 248, "bank == MONO_REG_DOUBLE");
  <D.23377>:
  D.23372 = mono_arch_fregname (reg);
  return D.23372;
  <D.23367>:
  D.23372 = mono_arch_regname (reg);
  return D.23372;
}


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.23380;
  unsigned int vreg.2;
  _Bool D.23382;
  long int D.23383;
  long int D.23384;
  int D.23387;
  _Bool D.23388;
  long int D.23389;
  long int D.23390;
  _Bool D.23393;
  long int D.23394;
  long int D.23395;
  unsigned int D.23398;
  int D.23399;
  unsigned int D.23400;
  unsigned int D.23401;
  struct MonoMemPool * D.23402;
  struct GSList * D.23403;
  void * regpair.3;
  struct GSList * D.23405;
  _Bool D.23407;
  long int D.23408;
  long int D.23409;
  _Bool D.23412;
  long int D.23413;
  long int D.23414;
  unsigned int D.23417;
  unsigned int D.23418;
  struct GSList * D.23419;
  struct GSList * D.23420;
  guint32 regpair;

  hreg.1 = (unsigned int) hreg;
  D.23380 = hreg.1 << 24;
  vreg.2 = (unsigned int) vreg;
  regpair = D.23380 + vreg.2;
  D.23382 = bank != 0;
  D.23383 = (long int) D.23382;
  D.23384 = __builtin_expect (D.23383, 0);
  if (D.23384 != 0) goto <D.23385>; else goto <D.23386>;
  <D.23385>:
  D.23387 = regbank_size[bank];
  D.23388 = D.23387 > vreg;
  D.23389 = (long int) D.23388;
  D.23390 = __builtin_expect (D.23389, 0);
  if (D.23390 != 0) goto <D.23391>; else goto <D.23392>;
  <D.23391>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 262, "vreg >= regbank_size [bank]");
  <D.23392>:
  D.23387 = regbank_size[bank];
  D.23393 = D.23387 <= hreg;
  D.23394 = (long int) D.23393;
  D.23395 = __builtin_expect (D.23394, 0);
  if (D.23395 != 0) goto <D.23396>; else goto <D.23397>;
  <D.23396>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 263, "hreg < regbank_size [bank]");
  <D.23397>:
  D.23398 = call->used_fregs;
  D.23399 = 1 << hreg;
  D.23400 = (unsigned int) D.23399;
  D.23401 = D.23398 | D.23400;
  call->used_fregs = D.23401;
  D.23402 = cfg->mempool;
  D.23403 = call->out_freg_args;
  regpair.3 = (void *) regpair;
  D.23405 = g_slist_append_mempool (D.23402, D.23403, regpair.3);
  call->out_freg_args = D.23405;
  goto <D.23406>;
  <D.23386>:
  D.23407 = vreg <= 31;
  D.23408 = (long int) D.23407;
  D.23409 = __builtin_expect (D.23408, 0);
  if (D.23409 != 0) goto <D.23410>; else goto <D.23411>;
  <D.23410>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 267, "vreg >= MONO_MAX_IREGS");
  <D.23411>:
  D.23412 = hreg > 31;
  D.23413 = (long int) D.23412;
  D.23414 = __builtin_expect (D.23413, 0);
  if (D.23414 != 0) goto <D.23415>; else goto <D.23416>;
  <D.23415>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 268, "hreg < MONO_MAX_IREGS");
  <D.23416>:
  D.23417 = call->used_iregs;
  D.23399 = 1 << hreg;
  D.23400 = (unsigned int) D.23399;
  D.23418 = D.23417 | D.23400;
  call->used_iregs = D.23418;
  D.23402 = cfg->mempool;
  D.23419 = call->out_ireg_args;
  regpair.3 = (void *) regpair;
  D.23420 = g_slist_append_mempool (D.23402, D.23419, regpair.3);
  call->out_ireg_args = D.23420;
  <D.23406>:
}


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

  new_list = mono_mempool_alloc (mp, 8);
  new_list->data = data;
  new_list->next = 0B;
  if (list != 0B) goto <D.23421>; else goto <D.23422>;
  <D.23421>:
  last = list;
  goto <D.8273>;
  <D.8272>:
  last = last->next;
  <D.8273>:
  D.23423 = last->next;
  if (D.23423 != 0B) goto <D.8272>; else goto <D.8274>;
  <D.8274>:
  last->next = new_list;
  D.23424 = list;
  return D.23424;
  <D.23422>:
  D.23424 = new_list;
  return D.23424;
}


mono_call_inst_add_outarg_vt (struct MonoCompile * cfg, struct MonoCallInst * call, struct MonoInst * outarg_vt)
{
  struct MonoMemPool * D.23426;
  struct GSList * D.23427;
  struct GSList * D.23428;

  D.23426 = cfg->mempool;
  D.23427 = call->outarg_vts;
  D.23428 = g_slist_append_mempool (D.23426, D.23427, outarg_vt);
  call->outarg_vts = D.23428;
}


mono_print_ji (const struct MonoJumpInfo * ji)
{
  <unnamed type> D.23429;
  struct MonoJumpInfo * D.23430;
  <unnamed type> D.23431;
  const char * D.23432;
  struct MonoMethod * D.23433;
  const char * D.23434;

  D.23429 = ji->type;
  switch (D.23429) <default: <D.22680>, case 6: <D.22678>, case 35: <D.22675>>
  <D.22675>:
  {
    struct MonoJumpInfoRgctxEntry * entry;

    entry = ji->data.rgctx_entry;
    printf ("[RGCTX_FETCH ");
    D.23430 = entry->data;
    mono_print_ji (D.23430);
    D.23431 = entry->info_type;
    D.23432 = mono_rgctx_info_type_to_str (D.23431);
    printf (" - %s]", D.23432);
    goto <D.22677>;
  }
  <D.22678>:
  {
    char * s;

    D.23433 = ji->data.method;
    s = mono_method_full_name (D.23433, 1);
    printf ("[METHODCONST - %s]", s);
    monoeg_g_free (s);
    goto <D.22677>;
  }
  <D.22680>:
  D.23429 = ji->type;
  D.23434 = patch_info_str[D.23429];
  printf ("[%s]", D.23434);
  goto <D.22677>;
  <D.22677>:
}


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

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


mono_print_ins_index (int i, struct MonoInst * ins)
{
  short unsigned int D.23437;
  int D.23438;
  int D.23439;
  short unsigned int D.23440;
  sizetype D.23441;
  const char * D.23444;
  const char * D.23446;
  int D.23449;
  int D.23454;
  int D.23456;
  int D.23459;
  int D.23462;
  struct MonoBasicBlock * * D.23465;
  struct MonoBasicBlock * * D.23466;
  struct MonoBasicBlock * D.23467;
  struct MonoBasicBlock * D.23470;
  int D.23471;
  int D.23473;
  int * D.23476;
  sizetype i.4;
  sizetype D.23478;
  sizetype D.23479;
  int * D.23480;
  int D.23481;
  int D.23482;
  void * D.23483;
  int D.23484;
  char D.23485;
  unsigned char D.23488;
  unsigned char D.23489;
  _Bool D.23490;
  _Bool iftmp.5;
  _Bool D.23492;
  long int D.23493;
  long int D.23494;
  int iftmp.6;
  int D.23502;
  const char * D.23517;
  const char * D.23519;
  const char * D.23521;
  const char * D.23522;
  char D.23523;
  unsigned char D.23526;
  unsigned char D.23527;
  _Bool D.23528;
  _Bool iftmp.7;
  _Bool D.23530;
  long int D.23531;
  long int D.23532;
  int iftmp.8;
  int D.23540;
  const char * D.23550;
  const char * D.23552;
  signed char D.23553;
  int D.23554;
  sizetype D.23555;
  const char * D.23556;
  char D.23557;
  unsigned char D.23558;
  unsigned char D.23559;
  _Bool D.23560;
  _Bool iftmp.9;
  _Bool D.23562;
  long int D.23563;
  long int D.23564;
  int iftmp.10;
  int D.23571;
  int D.23573;
  const char * D.23578;
  int D.23579;
  void * D.23580;
  int D.23581;
  long long int D.23582;
  double D.23583;
  float D.23584;
  double D.23585;
  short unsigned int D.23586;
  struct MonoMethod * D.23591;
  unsigned int D.23595;
  unsigned int D.23596;
  const void * D.23600;
  const char * D.23605;
  void * D.23606;
  unsigned int D.23607;
  int regpair.11;
  const char * D.23609;
  struct GSList * iftmp.12;
  struct MonoBasicBlock * D.23614;
  int D.23615;
  const char * D.23619;
  char D.23620;
  int D.23623;
  const char * spec;
  int num_sregs;
  int j;
  int sregs[3];

  try
    {
      D.23437 = ins->opcode;
      D.23438 = (int) D.23437;
      D.23439 = D.23438 + -313;
      D.23440 = mips_desc_idx[D.23439];
      D.23441 = (sizetype) D.23440;
      spec = &mips_desc + D.23441;
      if (i != -1) goto <D.23442>; else goto <D.23443>;
      <D.23442>:
      D.23437 = ins->opcode;
      D.23438 = (int) D.23437;
      D.23444 = mono_inst_name (D.23438);
      printf ("\t%-2d %s", i, D.23444);
      goto <D.23445>;
      <D.23443>:
      D.23437 = ins->opcode;
      D.23438 = (int) D.23437;
      D.23446 = mono_inst_name (D.23438);
      printf (" %s", D.23446);
      <D.23445>:
      if (spec == &mips_desc) goto <D.23447>; else goto <D.23448>;
      <D.23447>:
      {
        gboolean dest_base;

        dest_base = 0;
        D.23437 = ins->opcode;
        D.23438 = (int) D.23437;
        switch (D.23438) <default: <D.22692>, case 387: <D.22690>>
        <D.22690>:
        dest_base = 1;
        goto <D.22691>;
        <D.22692>:
        goto <D.22691>;
        <D.22691>:
        D.23449 = ins->dreg;
        if (D.23449 != -1) goto <D.23450>; else goto <D.23451>;
        <D.23450>:
        if (dest_base != 0) goto <D.23452>; else goto <D.23453>;
        <D.23452>:
        D.23449 = ins->dreg;
        D.23454 = ins->data.op[0].const_val;
        printf (" [R%d + 0x%lx] <-", D.23449, D.23454);
        goto <D.23455>;
        <D.23453>:
        D.23449 = ins->dreg;
        printf (" R%d <-", D.23449);
        <D.23455>:
        <D.23451>:
        D.23456 = ins->sreg1;
        if (D.23456 != -1) goto <D.23457>; else goto <D.23458>;
        <D.23457>:
        D.23456 = ins->sreg1;
        printf (" R%d", D.23456);
        <D.23458>:
        D.23459 = ins->sreg2;
        if (D.23459 != -1) goto <D.23460>; else goto <D.23461>;
        <D.23460>:
        D.23459 = ins->sreg2;
        printf (" R%d", D.23459);
        <D.23461>:
        D.23462 = ins->sreg3;
        if (D.23462 != -1) goto <D.23463>; else goto <D.23464>;
        <D.23463>:
        D.23462 = ins->sreg3;
        printf (" R%d", D.23462);
        <D.23464>:
        D.23437 = ins->opcode;
        D.23438 = (int) D.23437;
        switch (D.23438) <default: <D.22716>, case 314: <D.22712>, case 319: <D.22704>, case 320: <D.22707>, case 321: <D.22705>, case 332: <D.22715>, case 334: <D.22713>, case 367: <D.22714>, case 551: <D.22694>, case 552: <D.22699>, case 553: <D.22697>, case 554: <D.22701>, case 555: <D.22695>, case 556: <D.22693>, case 557: <D.22700>, case 558: <D.22698>, case 559: <D.22702>, case 560: <D.22696>, case 802: <D.22706>>
        <D.22693>:
        <D.22694>:
        <D.22695>:
        <D.22696>:
        <D.22697>:
        <D.22698>:
        <D.22699>:
        <D.22700>:
        <D.22701>:
        <D.22702>:
        D.23465 = ins->data.op[1].many_blocks;
        D.23466 = D.23465 + 4;
        D.23467 = *D.23466;
        if (D.23467 == 0B) goto <D.23468>; else goto <D.23469>;
        <D.23468>:
        D.23465 = ins->data.op[1].many_blocks;
        D.23470 = *D.23465;
        D.23471 = D.23470->block_num;
        printf (" [B%d]", D.23471);
        goto <D.23472>;
        <D.23469>:
        D.23465 = ins->data.op[1].many_blocks;
        D.23470 = *D.23465;
        D.23471 = D.23470->block_num;
        D.23465 = ins->data.op[1].many_blocks;
        D.23466 = D.23465 + 4;
        D.23467 = *D.23466;
        D.23473 = D.23467->block_num;
        printf (" [B%dB%d]", D.23471, D.23473);
        <D.23472>:
        goto <D.22703>;
        <D.22704>:
        <D.22705>:
        <D.22706>:
        <D.22707>:
        {
          int i;

          D.23454 = ins->data.op[0].const_val;
          printf (" [%d (", D.23454);
          i = 0;
          goto <D.22710>;
          <D.22709>:
          if (i != 0) goto <D.23474>; else goto <D.23475>;
          <D.23474>:
          printf (", ");
          <D.23475>:
          D.23476 = ins->data.op[1].phi_args;
          i.4 = (sizetype) i;
          D.23478 = i.4 + 1;
          D.23479 = D.23478 * 4;
          D.23480 = D.23476 + D.23479;
          D.23481 = *D.23480;
          printf ("R%d", D.23481);
          i = i + 1;
          <D.22710>:
          D.23476 = ins->data.op[1].phi_args;
          D.23482 = *D.23476;
          if (D.23482 > i) goto <D.22709>; else goto <D.22711>;
          <D.22711>:
          printf (")]");
          goto <D.22703>;
        }
        <D.22712>:
        <D.22713>:
        D.23483 = ins->data.op[0].p;
        D.23484 = MEM[(struct MonoInst *)D.23483].dreg;
        printf (" R%d", D.23484);
        goto <D.22703>;
        <D.22714>:
        <D.22715>:
        D.23454 = ins->data.op[0].const_val;
        printf (" + 0x%lx", D.23454);
        goto <D.22703>;
        <D.22716>:
        goto <D.22703>;
        <D.22703>:
        printf ("\n");
        return;
      }
      <D.23448>:
      D.23485 = *spec;
      if (D.23485 != 0) goto <D.23486>; else goto <D.23487>;
      <D.23486>:
      {
        int bank;

        D.23485 = *spec;
        D.23488 = (unsigned char) D.23485;
        D.23489 = D.23488 + 154;
        D.23490 = D.23489 <= 1;
        bank = (int) D.23490;
        D.23492 = bank != 0;
        D.23493 = (long int) D.23492;
        D.23494 = __builtin_expect (D.23493, 0);
        if (D.23494 != 0) goto <D.23495>; else goto <D.23496>;
        <D.23495>:
        D.23449 = ins->dreg;
        if (D.23449 < 0) goto <D.23498>; else goto <D.23501>;
        <D.23501>:
        D.23449 = ins->dreg;
        D.23502 = regbank_size[bank];
        if (D.23449 >= D.23502) goto <D.23498>; else goto <D.23499>;
        <D.23498>:
        iftmp.6 = 1;
        goto <D.23500>;
        <D.23499>:
        iftmp.6 = 0;
        <D.23500>:
        iftmp.5 = (_Bool) iftmp.6;
        goto <D.23503>;
        <D.23496>:
        D.23449 = ins->dreg;
        iftmp.5 = D.23449 > 31;
        <D.23503>:
        if (iftmp.5 != 0) goto <D.23504>; else goto <D.23505>;
        <D.23504>:
        D.23485 = *spec;
        if (D.23485 == 98) goto <D.23506>; else goto <D.23507>;
        <D.23506>:
        D.23454 = ins->data.op[0].const_val;
        if (D.23454 == 0) goto <D.23508>; else goto <D.23509>;
        <D.23508>:
        D.23449 = ins->dreg;
        printf (" [R%d] <-", D.23449);
        goto <D.23510>;
        <D.23509>:
        D.23449 = ins->dreg;
        D.23454 = ins->data.op[0].const_val;
        printf (" [R%d + 0x%lx] <-", D.23449, D.23454);
        <D.23510>:
        goto <D.23511>;
        <D.23507>:
        D.23449 = ins->dreg;
        printf (" R%d <-", D.23449);
        <D.23511>:
        goto <D.23512>;
        <D.23505>:
        D.23485 = *spec;
        if (D.23485 == 98) goto <D.23513>; else goto <D.23514>;
        <D.23513>:
        D.23454 = ins->data.op[0].const_val;
        if (D.23454 == 0) goto <D.23515>; else goto <D.23516>;
        <D.23515>:
        D.23449 = ins->dreg;
        D.23517 = mono_arch_regname (D.23449);
        printf (" [%s] <-", D.23517);
        goto <D.23518>;
        <D.23516>:
        D.23449 = ins->dreg;
        D.23519 = mono_arch_regname (D.23449);
        D.23454 = ins->data.op[0].const_val;
        printf (" [%s + 0x%lx] <-", D.23519, D.23454);
        <D.23518>:
        goto <D.23520>;
        <D.23514>:
        D.23449 = ins->dreg;
        D.23521 = mono_regname_full (D.23449, bank);
        printf (" %s <-", D.23521);
        <D.23520>:
        <D.23512>:
      }
      <D.23487>:
      D.23522 = spec + 1;
      D.23523 = *D.23522;
      if (D.23523 != 0) goto <D.23524>; else goto <D.23525>;
      <D.23524>:
      {
        int bank;

        D.23522 = spec + 1;
        D.23523 = *D.23522;
        D.23526 = (unsigned char) D.23523;
        D.23527 = D.23526 + 154;
        D.23528 = D.23527 <= 1;
        bank = (int) D.23528;
        D.23530 = bank != 0;
        D.23531 = (long int) D.23530;
        D.23532 = __builtin_expect (D.23531, 0);
        if (D.23532 != 0) goto <D.23533>; else goto <D.23534>;
        <D.23533>:
        D.23456 = ins->sreg1;
        if (D.23456 < 0) goto <D.23536>; else goto <D.23539>;
        <D.23539>:
        D.23456 = ins->sreg1;
        D.23540 = regbank_size[bank];
        if (D.23456 >= D.23540) goto <D.23536>; else goto <D.23537>;
        <D.23536>:
        iftmp.8 = 1;
        goto <D.23538>;
        <D.23537>:
        iftmp.8 = 0;
        <D.23538>:
        iftmp.7 = (_Bool) iftmp.8;
        goto <D.23541>;
        <D.23534>:
        D.23456 = ins->sreg1;
        iftmp.7 = D.23456 > 31;
        <D.23541>:
        if (iftmp.7 != 0) goto <D.23542>; else goto <D.23543>;
        <D.23542>:
        D.23522 = spec + 1;
        D.23523 = *D.23522;
        if (D.23523 == 98) goto <D.23544>; else goto <D.23545>;
        <D.23544>:
        D.23456 = ins->sreg1;
        D.23454 = ins->data.op[0].const_val;
        printf (" [R%d + 0x%lx]", D.23456, D.23454);
        goto <D.23546>;
        <D.23545>:
        D.23456 = ins->sreg1;
        printf (" R%d", D.23456);
        <D.23546>:
        goto <D.23547>;
        <D.23543>:
        D.23522 = spec + 1;
        D.23523 = *D.23522;
        if (D.23523 == 98) goto <D.23548>; else goto <D.23549>;
        <D.23548>:
        D.23456 = ins->sreg1;
        D.23550 = mono_arch_regname (D.23456);
        D.23454 = ins->data.op[0].const_val;
        printf (" [%s + 0x%lx]", D.23550, D.23454);
        goto <D.23551>;
        <D.23549>:
        D.23456 = ins->sreg1;
        D.23552 = mono_regname_full (D.23456, bank);
        printf (" %s", D.23552);
        <D.23551>:
        <D.23547>:
      }
      <D.23525>:
      D.23456 = ins->sreg1;
      sregs[0] = D.23456;
      D.23459 = ins->sreg2;
      sregs[1] = D.23459;
      D.23462 = ins->sreg3;
      sregs[2] = D.23462;
      D.23437 = ins->opcode;
      D.23438 = (int) D.23437;
      D.23439 = D.23438 + -313;
      D.23553 = ins_sreg_counts[D.23439];
      num_sregs = (int) D.23553;
      j = 1;
      goto <D.22721>;
      <D.22720>:
      {
        int bank;

        D.23554 = j + 1;
        D.23555 = (sizetype) D.23554;
        D.23556 = spec + D.23555;
        D.23557 = *D.23556;
        D.23558 = (unsigned char) D.23557;
        D.23559 = D.23558 + 154;
        D.23560 = D.23559 <= 1;
        bank = (int) D.23560;
        D.23562 = bank != 0;
        D.23563 = (long int) D.23562;
        D.23564 = __builtin_expect (D.23563, 0);
        if (D.23564 != 0) goto <D.23565>; else goto <D.23566>;
        <D.23565>:
        D.23571 = sregs[j];
        if (D.23571 < 0) goto <D.23568>; else goto <D.23572>;
        <D.23572>:
        D.23571 = sregs[j];
        D.23573 = regbank_size[bank];
        if (D.23571 >= D.23573) goto <D.23568>; else goto <D.23569>;
        <D.23568>:
        iftmp.10 = 1;
        goto <D.23570>;
        <D.23569>:
        iftmp.10 = 0;
        <D.23570>:
        iftmp.9 = (_Bool) iftmp.10;
        goto <D.23574>;
        <D.23566>:
        D.23571 = sregs[j];
        iftmp.9 = D.23571 > 31;
        <D.23574>:
        if (iftmp.9 != 0) goto <D.23575>; else goto <D.23576>;
        <D.23575>:
        D.23571 = sregs[j];
        printf (" R%d", D.23571);
        goto <D.23577>;
        <D.23576>:
        D.23571 = sregs[j];
        D.23578 = mono_regname_full (D.23571, bank);
        printf (" %s", D.23578);
        <D.23577>:
      }
      j = j + 1;
      <D.22721>:
      if (j < num_sregs) goto <D.22720>; else goto <D.22722>;
      <D.22722>:
      D.23437 = ins->opcode;
      D.23438 = (int) D.23437;
      switch (D.23438) <default: <D.22790>, case 323: <D.22726>, case 327: <D.22725>, case 341: <D.22789>, case 343: <D.22749>, case 345: <D.22750>, case 346: <D.22738>, case 347: <D.22740>, case 348: <D.22739>, case 349: <D.22741>, case 352: <D.22742>, case 355: <D.22743>, case 356: <D.22744>, case 357: <D.22745>, case 358: <D.22746>, case 359: <D.22747>, case 360: <D.22748>, case 362: <D.22723>, case 363: <D.22735>, case 364: <D.22737>, case 365: <D.22736>, case 429: <D.22733>, case 430: <D.22732>, case 442: <D.22763>, case 444: <D.22751>, case 538: <D.22734>, case 551: <D.22776>, case 552: <D.22781>, case 553: <D.22779>, case 554: <D.22783>, case 555: <D.22777>, case 556: <D.22775>, case 557: <D.22782>, case 558: <D.22780>, case 559: <D.22784>, case 560: <D.22778>, case 625: <D.22727>, case 626: <D.22728>, case 632: <D.22729>, case 633: <D.22730>, case 634: <D.22731>, case 648: <D.22766>, case 649: <D.22771>, case 650: <D.22769>, case 651: <D.22773>, case 652: <D.22767>, case 653: <D.22765>, case 654: <D.22772>, case 655: <D.22770>, case 656: <D.22774>, case 657: <D.22768>, case 735: <D.22764>, case 836: <D.22785>, case 837: <D.22786>, case 838: <D.22787>, case 839: <D.22788>>
      <D.22723>:
      D.23454 = ins->data.op[0].const_val;
      printf (" [%d]", D.23454);
      goto <D.22724>;
      <D.22725>:
      <D.22726>:
      <D.22727>:
      <D.22728>:
      <D.22729>:
      <D.22730>:
      <D.22731>:
      <D.22732>:
      D.23579 = ins->data.op[1].const_val;
      printf (" [%d]", D.23579);
      goto <D.22724>;
      <D.22733>:
      <D.22734>:
      D.23580 = ins->data.op[1].p;
      D.23581 = (int) D.23580;
      printf (" [%d]", D.23581);
      goto <D.22724>;
      <D.22735>:
      D.23582 = ins->data.i8const;
      printf (" [%lld]", D.23582);
      goto <D.22724>;
      <D.22736>:
      D.23483 = ins->data.op[0].p;
      D.23583 = MEM[(double *)D.23483];
      printf (" [%f]", D.23583);
      goto <D.22724>;
      <D.22737>:
      D.23483 = ins->data.op[0].p;
      D.23584 = MEM[(float *)D.23483];
      D.23585 = (double) D.23584;
      printf (" [%f]", D.23585);
      goto <D.22724>;
      <D.22738>:
      <D.22739>:
      <D.22740>:
      <D.22741>:
      <D.22742>:
      <D.22743>:
      <D.22744>:
      <D.22745>:
      <D.22746>:
      <D.22747>:
      <D.22748>:
      <D.22749>:
      <D.22750>:
      <D.22751>:
      {
        struct MonoCallInst * call;
        struct GSList * list;

        call = ins;
        D.23437 = ins->opcode;
        D.23586 = D.23437 + 65181;
        if (D.23586 <= 2) goto <D.23587>; else goto <D.23588>;
        <D.23587>:
        D.23449 = ins->dreg;
        if (D.23449 != -1) goto <D.23589>; else goto <D.23590>;
        <D.23589>:
        D.23449 = ins->dreg;
        printf (" R%d <-", D.23449);
        <D.23590>:
        <D.23588>:
        D.23591 = call->method;
        if (D.23591 != 0B) goto <D.23592>; else goto <D.23593>;
        <D.23592>:
        {
          char * full_name;

          D.23591 = call->method;
          full_name = mono_method_full_name (D.23591, 1);
          printf (" [%s]", full_name);
          monoeg_g_free (full_name);
        }
        goto <D.23594>;
        <D.23593>:
        D.23595 = BIT_FIELD_REF <*call, 32, 704>;
        D.23596 = D.23595 & 4;
        if (D.23596 != 0) goto <D.23597>; else goto <D.23598>;
        <D.23597>:
        {
          struct MonoJumpInfo * ji;

          ji = call->fptr;
          printf (" ");
          mono_print_ji (ji);
        }
        goto <D.23599>;
        <D.23598>:
        D.23600 = call->fptr;
        if (D.23600 != 0B) goto <D.23601>; else goto <D.23602>;
        <D.23601>:
        {
          struct MonoJitICallInfo * info;

          D.23600 = call->fptr;
          info = mono_find_jit_icall_by_addr (D.23600);
          if (info != 0B) goto <D.23603>; else goto <D.23604>;
          <D.23603>:
          D.23605 = info->name;
          printf (" [%s]", D.23605);
          <D.23604>:
        }
        <D.23602>:
        <D.23599>:
        <D.23594>:
        list = call->out_ireg_args;
        goto <D.22761>;
        <D.22760>:
        {
          guint32 regpair;
          int reg;
          int hreg;

          D.23606 = list->data;
          regpair = (guint32) D.23606;
          D.23607 = regpair >> 24;
          hreg = (int) D.23607;
          regpair.11 = (int) regpair;
          reg = regpair.11 & 16777215;
          D.23609 = mono_arch_regname (hreg);
          printf (" [%s <- R%d]", D.23609, reg);
          if (list != 0B) goto <D.23611>; else goto <D.23612>;
          <D.23611>:
          iftmp.12 = list->next;
          goto <D.23613>;
          <D.23612>:
          iftmp.12 = 0B;
          <D.23613>:
          list = iftmp.12;
        }
        <D.22761>:
        if (list != 0B) goto <D.22760>; else goto <D.22762>;
        <D.22762>:
        goto <D.22724>;
      }
      <D.22763>:
      <D.22764>:
      D.23614 = ins->data.op[0].target_block;
      D.23615 = D.23614->block_num;
      printf (" [B%d]", D.23615);
      goto <D.22724>;
      <D.22765>:
      <D.22766>:
      <D.22767>:
      <D.22768>:
      <D.22769>:
      <D.22770>:
      <D.22771>:
      <D.22772>:
      <D.22773>:
      <D.22774>:
      <D.22775>:
      <D.22776>:
      <D.22777>:
      <D.22778>:
      <D.22779>:
      <D.22780>:
      <D.22781>:
      <D.22782>:
      <D.22783>:
      <D.22784>:
      D.23465 = ins->data.op[1].many_blocks;
      D.23466 = D.23465 + 4;
      D.23467 = *D.23466;
      if (D.23467 == 0B) goto <D.23616>; else goto <D.23617>;
      <D.23616>:
      D.23465 = ins->data.op[1].many_blocks;
      D.23470 = *D.23465;
      D.23471 = D.23470->block_num;
      printf (" [B%d]", D.23471);
      goto <D.23618>;
      <D.23617>:
      D.23465 = ins->data.op[1].many_blocks;
      D.23470 = *D.23465;
      D.23471 = D.23470->block_num;
      D.23465 = ins->data.op[1].many_blocks;
      D.23466 = D.23465 + 4;
      D.23467 = *D.23466;
      D.23473 = D.23467->block_num;
      printf (" [B%dB%d]", D.23471, D.23473);
      <D.23618>:
      goto <D.22724>;
      <D.22785>:
      <D.22786>:
      <D.22787>:
      <D.22788>:
      D.23579 = ins->data.op[1].const_val;
      printf (" R%d", D.23579);
      goto <D.22724>;
      <D.22789>:
      D.23579 = ins->data.op[1].const_val;
      printf (" il: %x", D.23579);
      goto <D.22724>;
      <D.22790>:
      goto <D.22724>;
      <D.22724>:
      D.23619 = spec + 5;
      D.23620 = *D.23619;
      if (D.23620 != 0) goto <D.23621>; else goto <D.23622>;
      <D.23621>:
      D.23619 = spec + 5;
      D.23620 = *D.23619;
      D.23623 = (int) D.23620;
      printf (" clobbers: %c", D.23623);
      <D.23622>:
      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.23630;
  int desc_to_fixed_reg_inited.13;
  gint8 iftmp.14;
  gint8 iftmp.15;
  gint8 iftmp.16;
  gint8 iftmp.17;
  gint8 iftmp.18;
  unsigned int D.23656;
  int D.23657;
  unsigned int D.23658;
  void * D.23659;
  int D.23662;
  int D.23667;
  int D.23668;
  struct MonoMemPool * D.23669;
  unsigned int D.23670;
  unsigned int D.23671;
  void * D.23672;
  int D.23674;
  _Bool D.23675;
  long int D.23676;
  long int D.23677;
  unsigned int D.23680;
  short unsigned int D.23683;
  int D.23684;
  int D.23685;
  short unsigned int D.23686;
  sizetype D.23687;
  int D.23688;
  unsigned int D.23693;
  unsigned int D.23694;
  void * D.23695;
  char D.23698;
  int D.23700;
  sizetype D.23701;
  sizetype D.23702;
  sizetype D.23703;
  struct RegTrack * D.23704;
  int D.23705;
  int D.23706;
  int D.23707;
  signed char D.23708;
  int D.23709;
  _Bool D.23710;
  long int D.23711;
  long int D.23712;
  unsigned int D.23717;
  unsigned int D.23718;
  void * D.23719;
  int D.23722;
  sizetype D.23723;
  const char * D.23724;
  char D.23725;
  int D.23727;
  sizetype D.23728;
  sizetype D.23729;
  sizetype D.23730;
  struct RegTrack * D.23731;
  _Bool D.23732;
  long int D.23733;
  long int D.23734;
  int D.23737;
  _Bool D.23738;
  long int D.23739;
  long int D.23740;
  const char * D.23743;
  unsigned char D.23748;
  unsigned char D.23749;
  _Bool D.23750;
  _Bool D.23751;
  long int D.23752;
  long int D.23753;
  _Bool iftmp.19;
  _Bool D.23757;
  long int D.23758;
  long int D.23759;
  int iftmp.20;
  int D.23767;
  unsigned int sreg.21;
  unsigned int D.23772;
  struct RegTrack * D.23773;
  int D.23774;
  _Bool D.23775;
  long int D.23776;
  long int D.23777;
  gint32 * D.23780;
  unsigned int D.23781;
  gint32 * D.23782;
  sizetype sreg.22;
  sizetype D.23787;
  sizetype D.23788;
  gint32 * D.23789;
  sizetype D.23792;
  struct RegTrack * D.23793;
  int D.23794;
  unsigned char D.23799;
  unsigned char D.23800;
  _Bool D.23801;
  struct RegTrack * D.23804;
  _Bool D.23805;
  long int D.23806;
  long int D.23807;
  unsigned int D.23810;
  gint32 * D.23811;
  int D.23814;
  int D.23816;
  signed char D.23817;
  unsigned int D.23820;
  sizetype D.23824;
  gint32 * D.23825;
  int D.23828;
  unsigned int iftmp.23;
  unsigned int iftmp.24;
  unsigned int iftmp.25;
  const char * D.23849;
  char D.23850;
  short unsigned int D.23853;
  short unsigned int D.23855;
  short unsigned int D.23857;
  short unsigned int D.23859;
  short unsigned int D.23861;
  short unsigned int D.23863;
  void * D.23867;
  unsigned int D.23868;
  int regpair.26;
  struct GSList * iftmp.27;
  unsigned int D.23876;
  int regpair.28;
  struct GSList * iftmp.29;
  struct MonoInst * iftmp.30;
  const char * D.23888;
  char D.23889;
  char spec_dest.31;
  int D.23891;
  int D.23892;
  unsigned int D.23893;
  signed char D.23894;
  int D.23895;
  int D.23900;
  signed char D.23901;
  unsigned int D.23902;
  unsigned int D.23907;
  unsigned int D.23910;
  unsigned int D.23911;
  unsigned int D.23912;
  int D.23915;
  unsigned int D.23918;
  unsigned int D.23919;
  gint32 * D.23920;
  int D.23921;
  unsigned int sreg.32;
  unsigned int D.23927;
  gint32 * D.23928;
  int D.23929;
  unsigned int D.23934;
  unsigned int D.23935;
  unsigned int sreg.33;
  unsigned int D.23942;
  unsigned int D.23943;
  unsigned int D.23947;
  unsigned int D.23948;
  const char * D.23953;
  unsigned int D.23959;
  unsigned int D.23960;
  unsigned int D.23964;
  unsigned int D.23965;
  _Bool D.23973;
  long int D.23974;
  long int D.23975;
  const char * D.23980;
  const char * D.23981;
  _Bool iftmp.34;
  int iftmp.35;
  int D.24015;
  unsigned int D.24018;
  unsigned int D.24019;
  int D.24020;
  unsigned int D.24023;
  unsigned int D.24024;
  _Bool iftmp.36;
  int iftmp.37;
  unsigned int D.24038;
  unsigned int D.24039;
  long int iftmp.38;
  int iftmp.39;
  _Bool D.24053;
  _Bool D.24055;
  long int D.24056;
  int D.24061;
  int D.24064;
  guint32 iftmp.40;
  int D.24068;
  guint32 iftmp.41;
  unsigned int D.24076;
  gint32 * D.24077;
  int D.24078;
  unsigned int D.24079;
  int dest_dreg2.42;
  unsigned int D.24089;
  unsigned int D.24091;
  unsigned int D.24092;
  _Bool iftmp.43;
  int iftmp.44;
  const char * D.24115;
  _Bool D.24121;
  long int D.24122;
  long int D.24123;
  int iftmp.45;
  unsigned int prev_dreg.46;
  unsigned int D.24130;
  gint32 * D.24131;
  int D.24132;
  unsigned int D.24133;
  unsigned int D.24135;
  unsigned int D.24136;
  _Bool D.24138;
  long int D.24139;
  long int D.24140;
  unsigned int iftmp.47;
  _Bool iftmp.48;
  unsigned int iftmp.49;
  int D.24153;
  unsigned int iftmp.50;
  unsigned int reg2.51;
  unsigned int D.24161;
  gint32 * D.24162;
  unsigned int D.24172;
  unsigned int D.24173;
  int D.24178;
  const char * D.24181;
  _Bool iftmp.52;
  _Bool iftmp.53;
  int iftmp.54;
  int iftmp.55;
  _Bool D.24198;
  unsigned int D.24202;
  unsigned int D.24203;
  unsigned int D.24204;
  int iftmp.56;
  unsigned int val.57;
  unsigned int D.24212;
  unsigned int D.24213;
  int iftmp.58;
  unsigned int D.24225;
  struct RegTrack * D.24226;
  int D.24227;
  const char * D.24232;
  _Bool iftmp.59;
  int iftmp.60;
  _Bool D.24248;
  long int D.24249;
  long int D.24250;
  const char * D.24255;
  unsigned int D.24256;
  struct RegTrack * D.24257;
  int D.24258;
  struct MonoRegState * D.24268;
  int * D.24269;
  unsigned int dest_dreg.61;
  unsigned int D.24271;
  int * D.24272;
  int D.24273;
  int D.24274;
  int D.24278;
  unsigned int D.24285;
  unsigned int D.24286;
  unsigned int D.24287;
  unsigned int D.24288;
  unsigned int D.24291;
  unsigned int D.24292;
  int D.24297;
  unsigned char D.24305;
  sizetype prev_dreg.62;
  sizetype D.24312;
  sizetype D.24313;
  gint32 * D.24314;
  unsigned int D.24315;
  long long unsigned int D.24316;
  long long unsigned int D.24317;
  unsigned int s.63;
  unsigned int D.24321;
  int D.24330;
  unsigned int D.24333;
  unsigned int D.24334;
  gint32 * D.24335;
  unsigned int D.24336;
  unsigned int D.24337;
  unsigned int D.24348;
  int * D.24354;
  unsigned int j.64;
  unsigned int D.24356;
  int * D.24357;
  int D.24358;
  unsigned int D.24361;
  unsigned int D.24362;
  gint32 * D.24363;
  int D.24364;
  void * D.24377;
  unsigned int D.24378;
  int regpair.65;
  unsigned int D.24380;
  unsigned int D.24381;
  unsigned int D.24382;
  unsigned int D.24383;
  const char * D.24386;
  struct GSList * iftmp.66;
  unsigned int D.24393;
  int regpair.67;
  const char * D.24397;
  struct GSList * iftmp.68;
  unsigned char D.24402;
  unsigned char D.24403;
  _Bool D.24404;
  long int iftmp.69;
  int iftmp.70;
  _Bool D.24418;
  _Bool D.24420;
  long int D.24421;
  _Bool D.24426;
  long int D.24427;
  long int D.24428;
  _Bool D.24431;
  long int D.24432;
  long int D.24433;
  unsigned int sreg1.71;
  unsigned int D.24437;
  gint32 * D.24438;
  int D.24439;
  const char * D.24446;
  unsigned int iftmp.72;
  _Bool iftmp.73;
  unsigned int iftmp.74;
  unsigned int iftmp.75;
  unsigned int D.24463;
  unsigned int D.24464;
  _Bool D.24465;
  long int D.24466;
  long int D.24467;
  unsigned int D.24470;
  sizetype sreg1.76;
  sizetype D.24474;
  sizetype D.24475;
  gint32 * D.24476;
  int D.24477;
  int D.24482;
  const char * D.24485;
  unsigned int D.24486;
  int D.24493;
  unsigned int D.24494;
  unsigned int D.24496;
  unsigned int D.24497;
  unsigned int D.24501;
  unsigned int D.24504;
  unsigned int D.24505;
  gint32 * D.24506;
  int D.24507;
  unsigned int D.24510;
  _Bool iftmp.77;
  int iftmp.78;
  unsigned int D.24540;
  unsigned int D.24541;
  unsigned int D.24544;
  unsigned int D.24553;
  struct RegTrack * D.24554;
  const char * D.24557;
  int D.24560;
  unsigned int D.24566;
  unsigned int D.24568;
  unsigned int D.24569;
  unsigned int D.24570;
  _Bool D.24578;
  long int D.24579;
  long int D.24580;
  int iftmp.79;
  unsigned int D.24586;
  unsigned int D.24587;
  gint32 * D.24588;
  int D.24589;
  unsigned int D.24590;
  unsigned int D.24592;
  unsigned int D.24593;
  _Bool D.24595;
  long int D.24596;
  long int D.24597;
  unsigned int iftmp.80;
  _Bool iftmp.81;
  unsigned int iftmp.82;
  int D.24610;
  unsigned int iftmp.83;
  unsigned int reg2.84;
  unsigned int D.24618;
  gint32 * D.24619;
  const char * D.24633;
  unsigned char D.24640;
  _Bool D.24641;
  int D.24642;
  const char * D.24647;
  const char * D.24648;
  _Bool D.24649;
  long int D.24650;
  long int D.24651;
  sizetype D.24658;
  sizetype D.24659;
  sizetype D.24660;
  gint32 * D.24661;
  int D.24662;
  _Bool D.24665;
  long int D.24666;
  long int D.24667;
  _Bool D.24670;
  long int D.24671;
  long int D.24672;
  const char * D.24677;
  const char * D.24678;
  unsigned int D.24681;
  unsigned int D.24682;
  unsigned int D.24689;
  unsigned int D.24691;
  unsigned int D.24692;
  _Bool iftmp.85;
  int iftmp.86;
  unsigned int D.24705;
  gint32 * D.24706;
  struct RegTrack * D.24717;
  const char * D.24720;
  unsigned int D.24723;
  unsigned int D.24724;
  unsigned int D.24725;
  unsigned int D.24726;
  _Bool D.24732;
  long int D.24733;
  long int D.24734;
  int D.24739;
  _Bool D.24740;
  long int D.24741;
  long int D.24742;
  struct MonoInst * iftmp.87;
  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.23630 = bb->code;
      if (D.23630 == 0B) goto <D.23631>; else goto <D.23632>;
      <D.23631>:
      return;
      <D.23632>:
      desc_to_fixed_reg_inited.13 = desc_to_fixed_reg_inited;
      if (desc_to_fixed_reg_inited.13 == 0) goto <D.23634>; else goto <D.23635>;
      <D.23634>:
      i = 0;
      goto <D.22964>;
      <D.22963>:
      if (i != 48) goto <D.23637>; else goto <D.23638>;
      <D.23637>:
      if (i != 97) goto <D.23640>; else goto <D.23641>;
      <D.23640>:
      if (i != 118) goto <D.23643>; else goto <D.23644>;
      <D.23643>:
      if (i != 86) goto <D.23646>; else goto <D.23647>;
      <D.23646>:
      if (i == 103) goto <D.23649>; else goto <D.23650>;
      <D.23649>:
      iftmp.18 = 0;
      goto <D.23651>;
      <D.23650>:
      iftmp.18 = -1;
      <D.23651>:
      iftmp.17 = iftmp.18;
      goto <D.23652>;
      <D.23647>:
      iftmp.17 = 2;
      <D.23652>:
      iftmp.16 = iftmp.17;
      goto <D.23653>;
      <D.23644>:
      iftmp.16 = 2;
      <D.23653>:
      iftmp.15 = iftmp.16;
      goto <D.23654>;
      <D.23641>:
      iftmp.15 = 1;
      <D.23654>:
      iftmp.14 = iftmp.15;
      goto <D.23655>;
      <D.23638>:
      iftmp.14 = 0;
      <D.23655>:
      desc_to_fixed_reg[i] = iftmp.14;
      i = i + 1;
      <D.22964>:
      if (i <= 255) goto <D.22963>; else goto <D.22965>;
      <D.22965>:
      desc_to_fixed_reg_inited = 1;
      <D.23635>:
      D.23656 = bb->max_vreg;
      D.23657 = (int) D.23656;
      rs->next_vreg = D.23657;
      mono_regstate_assign (rs);
      rs->ifree_mask = 65532;
      i = 0;
      goto <D.22967>;
      <D.22966>:
      D.23658 = regbank_callee_regs[i];
      rs->free_mask[i] = D.23658;
      i = i + 1;
      <D.22967>:
      if (i <= 3) goto <D.22966>; else goto <D.22968>;
      <D.22968>:
      max = rs->next_vreg;
      D.23659 = cfg->reginfo;
      if (D.23659 != 0B) goto <D.23660>; else goto <D.23661>;
      <D.23660>:
      D.23662 = cfg->reginfo_len;
      if (D.23662 < max) goto <D.23663>; else goto <D.23664>;
      <D.23663>:
      cfg->reginfo = 0B;
      <D.23664>:
      <D.23661>:
      reginfo = cfg->reginfo;
      if (reginfo == 0B) goto <D.23665>; else goto <D.23666>;
      <D.23665>:
      D.23667 = max * 2;
      D.23668 = MAX_EXPR <D.23667, 1024>;
      cfg->reginfo_len = D.23668;
      D.23669 = cfg->mempool;
      D.23662 = cfg->reginfo_len;
      D.23670 = (unsigned int) D.23662;
      D.23671 = D.23670 * 12;
      D.23672 = mono_mempool_alloc (D.23669, D.23671);
      cfg->reginfo = D.23672;
      reginfo = cfg->reginfo;
      goto <D.23673>;
      <D.23666>:
      D.23662 = cfg->reginfo_len;
      D.23674 = rs->next_vreg;
      D.23675 = D.23662 < D.23674;
      D.23676 = (long int) D.23675;
      D.23677 = __builtin_expect (D.23676, 0);
      if (D.23677 != 0) goto <D.23678>; else goto <D.23679>;
      <D.23678>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1160, "cfg->reginfo_len >= rs->next_vreg");
      <D.23679>:
      <D.23673>:
      D.23680 = cfg->verbose_level;
      if (D.23680 > 1) goto <D.23681>; else goto <D.23682>;
      <D.23681>:
      D.23659 = cfg->reginfo;
      D.23662 = cfg->reginfo_len;
      D.23670 = (unsigned int) D.23662;
      D.23671 = D.23670 * 12;
      memset (D.23659, 0, D.23671);
      <D.23682>:
      ins = bb->code;
      goto <D.22973>;
      <D.22972>:
      D.23683 = ins->opcode;
      D.23684 = (int) D.23683;
      D.23685 = D.23684 + -313;
      D.23686 = mips_desc_idx[D.23685];
      D.23687 = (sizetype) D.23686;
      spec = &mips_desc + D.23687;
      D.23688 = ins->dreg;
      if (D.23688 != -1) goto <D.23689>; else goto <D.23690>;
      <D.23689>:
      D.23688 = ins->dreg;
      if (D.23688 < max) goto <D.23691>; else goto <D.23692>;
      <D.23691>:
      D.23688 = ins->dreg;
      D.23693 = (unsigned int) D.23688;
      D.23694 = D.23693 * 12;
      D.23695 = reginfo + D.23694;
      memset (D.23695, 0, 12);
      D.23698 = *spec;
      if (D.23698 == 86) goto <D.23696>; else goto <D.23699>;
      <D.23699>:
      D.23698 = *spec;
      if (D.23698 == 108) goto <D.23696>; else goto <D.23697>;
      <D.23696>:
      D.23688 = ins->dreg;
      D.23700 = D.23688 + 1;
      ins->dreg = D.23700;
      D.23688 = ins->dreg;
      D.23701 = (sizetype) D.23688;
      D.23702 = D.23701 + 1;
      D.23703 = D.23702 * 12;
      D.23704 = reginfo + D.23703;
      memset (D.23704, 0, 12);
      <D.23697>:
      <D.23692>:
      <D.23690>:
      D.23705 = ins->sreg1;
      sregs[0] = D.23705;
      D.23706 = ins->sreg2;
      sregs[1] = D.23706;
      D.23707 = ins->sreg3;
      sregs[2] = D.23707;
      D.23683 = ins->opcode;
      D.23684 = (int) D.23683;
      D.23685 = D.23684 + -313;
      D.23708 = ins_sreg_counts[D.23685];
      num_sregs = (int) D.23708;
      j = 0;
      goto <D.22970>;
      <D.22969>:
      D.23709 = sregs[j];
      D.23710 = D.23709 == -1;
      D.23711 = (long int) D.23710;
      D.23712 = __builtin_expect (D.23711, 0);
      if (D.23712 != 0) goto <D.23713>; else goto <D.23714>;
      <D.23713>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1192, "sregs [j] != -1");
      <D.23714>:
      D.23709 = sregs[j];
      if (D.23709 < max) goto <D.23715>; else goto <D.23716>;
      <D.23715>:
      D.23709 = sregs[j];
      D.23717 = (unsigned int) D.23709;
      D.23718 = D.23717 * 12;
      D.23719 = reginfo + D.23718;
      memset (D.23719, 0, 12);
      D.23722 = j + 1;
      D.23723 = (sizetype) D.23722;
      D.23724 = spec + D.23723;
      D.23725 = *D.23724;
      if (D.23725 == 86) goto <D.23720>; else goto <D.23726>;
      <D.23726>:
      D.23722 = j + 1;
      D.23723 = (sizetype) D.23722;
      D.23724 = spec + D.23723;
      D.23725 = *D.23724;
      if (D.23725 == 108) goto <D.23720>; else goto <D.23721>;
      <D.23720>:
      D.23709 = sregs[j];
      D.23727 = D.23709 + 1;
      sregs[j] = D.23727;
      D.23709 = sregs[j];
      D.23728 = (sizetype) D.23709;
      D.23729 = D.23728 + 1;
      D.23730 = D.23729 * 12;
      D.23731 = reginfo + D.23730;
      memset (D.23731, 0, 12);
      <D.23721>:
      <D.23716>:
      j = j + 1;
      <D.22970>:
      if (j < num_sregs) goto <D.22969>; else goto <D.22971>;
      <D.22971>:
      mono_inst_set_src_registers (ins, &sregs);
      ins = ins->next;
      <D.22973>:
      if (ins != 0B) goto <D.22972>; else goto <D.22974>;
      <D.22974>:
      i = 1;
      D.23680 = cfg->verbose_level;
      D.23732 = D.23680 > 2;
      D.23733 = (long int) D.23732;
      D.23734 = __builtin_expect (D.23733, 0);
      if (D.23734 != 0) goto <D.23735>; else goto <D.23736>;
      <D.23735>:
      D.23737 = bb->block_num;
      printf ("\nLOCAL REGALLOC BLOCK %d:\n", D.23737);
      <D.23736>:
      ins = bb->code;
      goto <D.22997>;
      <D.22996>:
      D.23683 = ins->opcode;
      D.23684 = (int) D.23683;
      D.23685 = D.23684 + -313;
      D.23686 = mips_desc_idx[D.23685];
      D.23687 = (sizetype) D.23686;
      spec = &mips_desc + D.23687;
      D.23698 = *spec;
      spec_dest = (unsigned char) D.23698;
      D.23738 = spec == &mips_desc;
      D.23739 = (long int) D.23738;
      D.23740 = __builtin_expect (D.23739, 0);
      if (D.23740 != 0) goto <D.23741>; else goto <D.23742>;
      <D.23741>:
      D.23683 = ins->opcode;
      D.23684 = (int) D.23683;
      D.23743 = mono_inst_name (D.23684);
      monoeg_g_log (0B, 4, "Opcode \'%s\' missing from machine description file.", D.23743);
      <D.22975>:
      goto <D.22975>;
      <D.23742>:
      D.23680 = cfg->verbose_level;
      D.23732 = D.23680 > 2;
      D.23733 = (long int) D.23732;
      D.23734 = __builtin_expect (D.23733, 0);
      if (D.23734 != 0) goto <D.23744>; else goto <D.23745>;
      <D.23744>:
      mono_print_ins_index (i, ins);
      <D.23745>:
      D.23705 = ins->sreg1;
      sregs[0] = D.23705;
      D.23706 = ins->sreg2;
      sregs[1] = D.23706;
      D.23707 = ins->sreg3;
      sregs[2] = D.23707;
      D.23683 = ins->opcode;
      D.23684 = (int) D.23683;
      D.23685 = D.23684 + -313;
      D.23708 = ins_sreg_counts[D.23685];
      num_sregs = (int) D.23708;
      j = 0;
      goto <D.22979>;
      <D.22978>:
      {
        int sreg;
        int sreg_spec;

        sreg = sregs[j];
        D.23722 = j + 1;
        D.23723 = (sizetype) D.23722;
        D.23724 = spec + D.23723;
        D.23725 = *D.23724;
        sreg_spec = (int) D.23725;
        if (sreg_spec != 0) goto <D.23746>; else goto <D.23747>;
        <D.23746>:
        D.23722 = j + 1;
        D.23723 = (sizetype) D.23722;
        D.23724 = spec + D.23723;
        D.23725 = *D.23724;
        D.23748 = (unsigned char) D.23725;
        D.23749 = D.23748 + 154;
        D.23750 = D.23749 <= 1;
        bank = (int) D.23750;
        D.23751 = sreg == -1;
        D.23752 = (long int) D.23751;
        D.23753 = __builtin_expect (D.23752, 0);
        if (D.23753 != 0) goto <D.23754>; else goto <D.23755>;
        <D.23754>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1240, "sreg != -1");
        <D.23755>:
        D.23757 = bank != 0;
        D.23758 = (long int) D.23757;
        D.23759 = __builtin_expect (D.23758, 0);
        if (D.23759 != 0) goto <D.23760>; else goto <D.23761>;
        <D.23760>:
        if (sreg < 0) goto <D.23763>; else goto <D.23766>;
        <D.23766>:
        D.23767 = regbank_size[bank];
        if (D.23767 <= sreg) goto <D.23763>; else goto <D.23764>;
        <D.23763>:
        iftmp.20 = 1;
        goto <D.23765>;
        <D.23764>:
        iftmp.20 = 0;
        <D.23765>:
        iftmp.19 = (_Bool) iftmp.20;
        goto <D.23768>;
        <D.23761>:
        iftmp.19 = sreg > 31;
        <D.23768>:
        if (iftmp.19 != 0) goto <D.23769>; else goto <D.23770>;
        <D.23769>:
        sreg.21 = (unsigned int) sreg;
        D.23772 = sreg.21 * 12;
        D.23773 = reginfo + D.23772;
        D.23774 = D.23773->born_in;
        D.23775 = D.23774 <= 0;
        D.23776 = (long int) D.23775;
        D.23777 = __builtin_expect (D.23776, 0);
        if (D.23777 != 0) goto <D.23778>; else goto <D.23779>;
        <D.23778>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1243, "reginfo [sreg].born_in > 0");
        <D.23779>:
        <D.23770>:
        D.23780 = rs->vassign;
        sreg.21 = (unsigned int) sreg;
        D.23781 = sreg.21 * 4;
        D.23782 = D.23780 + D.23781;
        *D.23782 = -1;
        if (sreg_spec == 86) goto <D.23783>; else goto <D.23785>;
        <D.23785>:
        if (sreg_spec == 108) goto <D.23783>; else goto <D.23784>;
        <D.23783>:
        D.23780 = rs->vassign;
        sreg.22 = (sizetype) sreg;
        D.23787 = sreg.22 + 1;
        D.23788 = D.23787 * 4;
        D.23789 = D.23780 + D.23788;
        *D.23789 = -1;
        sreg.22 = (sizetype) sreg;
        D.23787 = sreg.22 + 1;
        D.23792 = D.23787 * 12;
        D.23793 = reginfo + D.23792;
        D.23794 = D.23793->born_in;
        if (D.23794 == 0) goto <D.23790>; else goto <D.23795>;
        <D.23795>:
        sreg.22 = (sizetype) sreg;
        D.23787 = sreg.22 + 1;
        D.23792 = D.23787 * 12;
        D.23793 = reginfo + D.23792;
        D.23794 = D.23793->born_in;
        if (D.23794 > i) goto <D.23790>; else goto <D.23791>;
        <D.23790>:
        sreg.22 = (sizetype) sreg;
        D.23787 = sreg.22 + 1;
        D.23792 = D.23787 * 12;
        D.23793 = reginfo + D.23792;
        D.23793->born_in = i;
        <D.23791>:
        <D.23784>:
        goto <D.23796>;
        <D.23747>:
        sregs[j] = -1;
        <D.23796>:
      }
      j = j + 1;
      <D.22979>:
      if (j < num_sregs) goto <D.22978>; else goto <D.22980>;
      <D.22980>:
      mono_inst_set_src_registers (ins, &sregs);
      if (spec_dest != 0) goto <D.23797>; else goto <D.23798>;
      <D.23797>:
      {
        int dest_dreg;

        D.23698 = *spec;
        D.23799 = (unsigned char) D.23698;
        D.23800 = D.23799 + 154;
        D.23801 = D.23800 <= 1;
        bank = (int) D.23801;
        if (spec_dest != 98) goto <D.23802>; else goto <D.23803>;
        <D.23802>:
        D.23688 = ins->dreg;
        D.23693 = (unsigned int) D.23688;
        D.23694 = D.23693 * 12;
        D.23804 = reginfo + D.23694;
        D.23804->killed_in = i;
        <D.23803>:
        D.23688 = ins->dreg;
        D.23805 = D.23688 == -1;
        D.23806 = (long int) D.23805;
        D.23807 = __builtin_expect (D.23806, 0);
        if (D.23807 != 0) goto <D.23808>; else goto <D.23809>;
        <D.23808>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1267, "ins->dreg != -1");
        <D.23809>:
        D.23780 = rs->vassign;
        D.23688 = ins->dreg;
        D.23693 = (unsigned int) D.23688;
        D.23810 = D.23693 * 4;
        D.23811 = D.23780 + D.23810;
        *D.23811 = -1;
        D.23688 = ins->dreg;
        D.23693 = (unsigned int) D.23688;
        D.23694 = D.23693 * 12;
        D.23804 = reginfo + D.23694;
        D.23814 = D.23804->born_in;
        if (D.23814 == 0) goto <D.23812>; else goto <D.23815>;
        <D.23815>:
        D.23688 = ins->dreg;
        D.23693 = (unsigned int) D.23688;
        D.23694 = D.23693 * 12;
        D.23804 = reginfo + D.23694;
        D.23814 = D.23804->born_in;
        if (D.23814 > i) goto <D.23812>; else goto <D.23813>;
        <D.23812>:
        D.23688 = ins->dreg;
        D.23693 = (unsigned int) D.23688;
        D.23694 = D.23693 * 12;
        D.23804 = reginfo + D.23694;
        D.23804->born_in = i;
        <D.23813>:
        D.23816 = (int) spec_dest;
        D.23817 = desc_to_fixed_reg[D.23816];
        dest_dreg = (int) D.23817;
        if (dest_dreg != -1) goto <D.23818>; else goto <D.23819>;
        <D.23818>:
        D.23688 = ins->dreg;
        D.23693 = (unsigned int) D.23688;
        D.23694 = D.23693 * 12;
        D.23804 = reginfo + D.23694;
        D.23820 = 1 << dest_dreg;
        D.23804->preferred_mask = D.23820;
        <D.23819>:
        if (spec_dest == 86) goto <D.23821>; else goto <D.23823>;
        <D.23823>:
        if (spec_dest == 108) goto <D.23821>; else goto <D.23822>;
        <D.23821>:
        D.23780 = rs->vassign;
        D.23688 = ins->dreg;
        D.23701 = (sizetype) D.23688;
        D.23702 = D.23701 + 1;
        D.23824 = D.23702 * 4;
        D.23825 = D.23780 + D.23824;
        *D.23825 = -1;
        D.23688 = ins->dreg;
        D.23701 = (sizetype) D.23688;
        D.23702 = D.23701 + 1;
        D.23703 = D.23702 * 12;
        D.23704 = reginfo + D.23703;
        D.23828 = D.23704->born_in;
        if (D.23828 == 0) goto <D.23826>; else goto <D.23829>;
        <D.23829>:
        D.23688 = ins->dreg;
        D.23701 = (sizetype) D.23688;
        D.23702 = D.23701 + 1;
        D.23703 = D.23702 * 12;
        D.23704 = reginfo + D.23703;
        D.23828 = D.23704->born_in;
        if (D.23828 > i) goto <D.23826>; else goto <D.23827>;
        <D.23826>:
        D.23688 = ins->dreg;
        D.23701 = (sizetype) D.23688;
        D.23702 = D.23701 + 1;
        D.23703 = D.23702 * 12;
        D.23704 = reginfo + D.23703;
        D.23704->born_in = i;
        <D.23827>:
        if (spec_dest == 108) goto <D.23830>; else goto <D.23832>;
        <D.23832>:
        if (spec_dest == 86) goto <D.23830>; else goto <D.23831>;
        <D.23830>:
        D.23688 = ins->dreg;
        D.23701 = (sizetype) D.23688;
        D.23702 = D.23701 + 1;
        D.23703 = D.23702 * 12;
        D.23704 = reginfo + D.23703;
        if (spec_dest == 108) goto <D.23834>; else goto <D.23837>;
        <D.23837>:
        if (spec_dest == 86) goto <D.23834>; else goto <D.23835>;
        <D.23834>:
        if (spec_dest != 108) goto <D.23839>; else goto <D.23840>;
        <D.23839>:
        if (spec_dest == 86) goto <D.23842>; else goto <D.23843>;
        <D.23842>:
        iftmp.25 = 8;
        goto <D.23844>;
        <D.23843>:
        iftmp.25 = 0;
        <D.23844>:
        iftmp.24 = iftmp.25;
        goto <D.23845>;
        <D.23840>:
        iftmp.24 = 1;
        <D.23845>:
        iftmp.23 = iftmp.24;
        goto <D.23836>;
        <D.23835>:
        iftmp.23 = 65532;
        <D.23836>:
        D.23704->preferred_mask = iftmp.23;
        <D.23831>:
        <D.23822>:
      }
      goto <D.23846>;
      <D.23798>:
      ins->dreg = -1;
      <D.23846>:
      D.23849 = spec + 5;
      D.23850 = *D.23849;
      if (D.23850 == 99) goto <D.23851>; else goto <D.23852>;
      <D.23851>:
      D.23683 = ins->opcode;
      D.23853 = D.23683 + 65193;
      if (D.23853 <= 2) goto <D.23847>; else goto <D.23854>;
      <D.23854>:
      D.23683 = ins->opcode;
      D.23855 = D.23683 + 65187;
      if (D.23855 <= 2) goto <D.23847>; else goto <D.23856>;
      <D.23856>:
      D.23683 = ins->opcode;
      D.23857 = D.23683 + 65184;
      if (D.23857 <= 2) goto <D.23847>; else goto <D.23858>;
      <D.23858>:
      D.23683 = ins->opcode;
      D.23859 = D.23683 + 65181;
      if (D.23859 <= 2) goto <D.23847>; else goto <D.23860>;
      <D.23860>:
      D.23683 = ins->opcode;
      D.23861 = D.23683 + 65190;
      if (D.23861 <= 2) goto <D.23847>; else goto <D.23862>;
      <D.23862>:
      D.23683 = ins->opcode;
      D.23863 = D.23683 + 65178;
      if (D.23863 <= 2) goto <D.23847>; else goto <D.23864>;
      <D.23864>:
      D.23683 = ins->opcode;
      if (D.23683 == 444) goto <D.23847>; else goto <D.23848>;
      <D.23847>:
      {
        struct MonoCallInst * call;
        struct GSList * list;

        call = ins;
        list = call->out_ireg_args;
        if (list != 0B) goto <D.23865>; else goto <D.23866>;
        <D.23865>:
        goto <D.22988>;
        <D.22987>:
        {
          guint32 regpair;
          int reg;
          int hreg;

          D.23867 = list->data;
          regpair = (guint32) D.23867;
          D.23868 = regpair >> 24;
          hreg = (int) D.23868;
          regpair.26 = (int) regpair;
          reg = regpair.26 & 16777215;
          if (list != 0B) goto <D.23871>; else goto <D.23872>;
          <D.23871>:
          iftmp.27 = list->next;
          goto <D.23873>;
          <D.23872>:
          iftmp.27 = 0B;
          <D.23873>:
          list = iftmp.27;
        }
        <D.22988>:
        if (list != 0B) goto <D.22987>; else goto <D.22989>;
        <D.22989>:
        <D.23866>:
        list = call->out_freg_args;
        if (list != 0B) goto <D.23874>; else goto <D.23875>;
        <D.23874>:
        goto <D.22994>;
        <D.22993>:
        {
          guint32 regpair;
          int reg;
          int hreg;

          D.23867 = list->data;
          regpair = (guint32) D.23867;
          D.23876 = regpair >> 24;
          hreg = (int) D.23876;
          regpair.28 = (int) regpair;
          reg = regpair.28 & 16777215;
          if (list != 0B) goto <D.23879>; else goto <D.23880>;
          <D.23879>:
          iftmp.29 = list->next;
          goto <D.23881>;
          <D.23880>:
          iftmp.29 = 0B;
          <D.23881>:
          list = iftmp.29;
        }
        <D.22994>:
        if (list != 0B) goto <D.22993>; else goto <D.22995>;
        <D.22995>:
        <D.23875>:
      }
      <D.23848>:
      <D.23852>:
      i = i + 1;
      ins = ins->next;
      <D.22997>:
      if (ins != 0B) goto <D.22996>; else goto <D.22998>;
      <D.22998>:
      tmp = &last;
      D.23680 = cfg->verbose_level;
      D.23732 = D.23680 > 2;
      D.23733 = (long int) D.23732;
      D.23734 = __builtin_expect (D.23733, 0);
      if (D.23734 != 0) goto <D.23882>; else goto <D.23883>;
      <D.23882>:
      D.23674 = rs->next_vreg;
      print_regtrack (reginfo, D.23674);
      <D.23883>:
      ins = bb->last_ins;
      if (ins != 0B) goto <D.23885>; else goto <D.23886>;
      <D.23885>:
      iftmp.30 = ins->prev;
      goto <D.23887>;
      <D.23886>:
      iftmp.30 = 0B;
      <D.23887>:
      prev = iftmp.30;
      goto <D.23127>;
      <D.23126>:
      {
        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.23683 = ins->opcode;
            D.23684 = (int) D.23683;
            D.23685 = D.23684 + -313;
            D.23686 = mips_desc_idx[D.23685];
            D.23687 = (sizetype) D.23686;
            spec = &mips_desc + D.23687;
            D.23888 = spec + 1;
            D.23889 = *D.23888;
            spec_src1 = (unsigned char) D.23889;
            D.23698 = *spec;
            spec_dest = (unsigned char) D.23698;
            prev_dreg = -1;
            clob_dreg = -1;
            clob_reg = -1;
            dest_dreg = -1;
            dreg_high = -1;
            sreg1_high = -1;
            spec_dest.31 = (char) spec_dest;
            D.23891 = (int) spec_dest.31;
            dreg_mask = get_callee_mask (D.23891);
            j = 0;
            goto <D.23014>;
            <D.23013>:
            prev_sregs[j] = -1;
            D.23722 = j + 1;
            D.23723 = (sizetype) D.23722;
            D.23724 = spec + D.23723;
            D.23725 = *D.23724;
            D.23892 = (int) D.23725;
            D.23893 = get_callee_mask (D.23892);
            sreg_masks[j] = D.23893;
            D.23722 = j + 1;
            D.23723 = (sizetype) D.23722;
            D.23724 = spec + D.23723;
            D.23725 = *D.23724;
            D.23892 = (int) D.23725;
            D.23894 = desc_to_fixed_reg[D.23892];
            D.23895 = (int) D.23894;
            dest_sregs[j] = D.23895;
            sreg_fixed_masks[j] = 0;
            j = j + 1;
            <D.23014>:
            if (j <= 2) goto <D.23013>; else goto <D.23015>;
            <D.23015>:
            D.23680 = cfg->verbose_level;
            D.23732 = D.23680 > 2;
            D.23733 = (long int) D.23732;
            D.23734 = __builtin_expect (D.23733, 0);
            if (D.23734 != 0) goto <D.23896>; else goto <D.23897>;
            <D.23896>:
            printf ("processing:");
            <D.23897>:
            D.23680 = cfg->verbose_level;
            D.23732 = D.23680 > 2;
            D.23733 = (long int) D.23732;
            D.23734 = __builtin_expect (D.23733, 0);
            if (D.23734 != 0) goto <D.23898>; else goto <D.23899>;
            <D.23898>:
            mono_print_ins_index (i, ins);
            <D.23899>:
            ip = ins->cil_code;
            last = ins;
            D.23816 = (int) spec_dest;
            D.23817 = desc_to_fixed_reg[D.23816];
            dest_dreg = (int) D.23817;
            D.23849 = spec + 5;
            D.23850 = *D.23849;
            D.23900 = (int) D.23850;
            D.23901 = desc_to_fixed_reg[D.23900];
            clob_reg = (int) D.23901;
            D.23902 = sreg_masks[1];
            sreg_masks[1] = D.23902;
            dreg_fixed_mask = 0;
            D.23705 = ins->sreg1;
            sregs[0] = D.23705;
            D.23706 = ins->sreg2;
            sregs[1] = D.23706;
            D.23707 = ins->sreg3;
            sregs[2] = D.23707;
            D.23683 = ins->opcode;
            D.23684 = (int) D.23683;
            D.23685 = D.23684 + -313;
            D.23708 = ins_sreg_counts[D.23685];
            num_sregs = (int) D.23708;
            j = 1;
            goto <D.23046>;
            <D.23045>:
            {
              int sreg;
              int dest_sreg;

              sreg = sregs[j];
              dest_sreg = dest_sregs[j];
              if (dest_sreg == -1) goto <D.23903>; else goto <D.23904>;
              <D.23903>:
              // predicted unlikely by continue predictor.
              goto <D.23018>;
              <D.23904>:
              if (j == 2) goto <D.23905>; else goto <D.23906>;
              <D.23905>:
              {
                int k;

                D.23907 = 1 << dest_sreg;
                sreg_masks[j] = D.23907;
                k = 0;
                goto <D.23021>;
                <D.23020>:
                if (k != j) goto <D.23908>; else goto <D.23909>;
                <D.23908>:
                D.23910 = sreg_masks[k];
                D.23907 = 1 << dest_sreg;
                D.23911 = ~D.23907;
                D.23912 = D.23910 & D.23911;
                sreg_masks[k] = D.23912;
                <D.23909>:
                k = k + 1;
                <D.23021>:
                if (k < num_sregs) goto <D.23020>; else goto <D.23022>;
                <D.23022>:
                k = 0;
                goto <D.23024>;
                <D.23023>:
                if (k != j) goto <D.23913>; else goto <D.23914>;
                <D.23913>:
                D.23915 = sregs[k];
                if (D.23915 > 31) goto <D.23916>; else goto <D.23917>;
                <D.23916>:
                D.23780 = rs->vassign;
                D.23915 = sregs[k];
                D.23918 = (unsigned int) D.23915;
                D.23919 = D.23918 * 4;
                D.23920 = D.23780 + D.23919;
                D.23921 = *D.23920;
                if (D.23921 == dest_sreg) goto <D.23922>; else goto <D.23923>;
                <D.23922>:
                free_up_hreg (cfg, bb, tmp, ins, dest_sreg, 0);
                <D.23923>:
                <D.23917>:
                <D.23914>:
                k = k + 1;
                <D.23024>:
                if (k < num_sregs) goto <D.23023>; else goto <D.23025>;
                <D.23025>:
                if (sreg > 31) goto <D.23924>; else goto <D.23925>;
                <D.23924>:
                D.23780 = rs->vassign;
                sreg.32 = (unsigned int) sreg;
                D.23927 = sreg.32 * 4;
                D.23928 = D.23780 + D.23927;
                D.23929 = *D.23928;
                if (D.23929 >= 0) goto <D.23930>; else goto <D.23931>;
                <D.23930>:
                D.23780 = rs->vassign;
                sreg.32 = (unsigned int) sreg;
                D.23927 = sreg.32 * 4;
                D.23928 = D.23780 + D.23927;
                D.23929 = *D.23928;
                if (D.23929 != dest_sreg) goto <D.23932>; else goto <D.23933>;
                <D.23932>:
                spill_vreg (cfg, bb, tmp, ins, sreg, 0);
                <D.23933>:
                <D.23931>:
                <D.23925>:
                // predicted unlikely by continue predictor.
                goto <D.23018>;
              }
              <D.23906>:
              D.23934 = rs->ifree_mask;
              D.23907 = 1 << dest_sreg;
              D.23935 = D.23934 & D.23907;
              if (D.23935 != 0) goto <D.23936>; else goto <D.23937>;
              <D.23936>:
              sreg.33 = (unsigned int) sreg;
              if (sreg.33 <= 31) goto <D.23941>; else goto <D.23938>;
              <D.23941>:
              D.23942 = 1090453504 >> sreg;
              D.23943 = D.23942 & 1;
              if (D.23943 != 0) goto <D.23944>; else goto <D.23938>;
              <D.23944>:
              {
                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.23029>;
                <D.23028>:
                if (k != j) goto <D.23945>; else goto <D.23946>;
                <D.23945>:
                D.23947 = sreg_masks[k];
                D.23907 = 1 << dest_sreg;
                D.23911 = ~D.23907;
                D.23948 = D.23947 & D.23911;
                sreg_masks[k] = D.23948;
                <D.23946>:
                k = k + 1;
                <D.23029>:
                if (k < num_sregs) goto <D.23028>; else goto <D.23030>;
                <D.23030>:
              }
              goto <D.23939>;
              <D.23938>:
              D.23780 = rs->vassign;
              sreg.32 = (unsigned int) sreg;
              D.23927 = sreg.32 * 4;
              D.23928 = D.23780 + D.23927;
              val = *D.23928;
              if (val == -1) goto <D.23949>; else goto <D.23950>;
              <D.23949>:
              D.23680 = cfg->verbose_level;
              D.23732 = D.23680 > 2;
              D.23733 = (long int) D.23732;
              D.23734 = __builtin_expect (D.23733, 0);
              if (D.23734 != 0) goto <D.23951>; else goto <D.23952>;
              <D.23951>:
              D.23953 = mono_arch_regname (dest_sreg);
              printf ("\tshortcut assignment of R%d to %s\n", sreg, D.23953);
              <D.23952>:
              assign_reg (cfg, rs, sreg, dest_sreg, 0);
              goto <D.23954>;
              <D.23950>:
              if (val < -1) goto <D.23955>; else goto <D.23956>;
              <D.23955>:
              monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-codegen.c", 1459);
              <D.23956>:
              {
                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.23034>;
                <D.23033>:
                if (k != j) goto <D.23957>; else goto <D.23958>;
                <D.23957>:
                D.23959 = sreg_masks[k];
                D.23907 = 1 << dest_sreg;
                D.23911 = ~D.23907;
                D.23960 = D.23959 & D.23911;
                sreg_masks[k] = D.23960;
                <D.23958>:
                k = k + 1;
                <D.23034>:
                if (k < num_sregs) goto <D.23033>; else goto <D.23035>;
                <D.23035>:
                D.23907 = 1 << dest_sreg;
                D.23911 = ~D.23907;
                dreg_mask = D.23911 & dreg_mask;
              }
              <D.23954>:
              <D.23939>:
              goto <D.23961>;
              <D.23937>:
              {
                gboolean need_spill;
                gboolean need_assign;
                int k;

                need_spill = 1;
                need_assign = 1;
                D.23907 = 1 << dest_sreg;
                D.23911 = ~D.23907;
                dreg_mask = D.23911 & dreg_mask;
                k = 0;
                goto <D.23040>;
                <D.23039>:
                if (k != j) goto <D.23962>; else goto <D.23963>;
                <D.23962>:
                D.23964 = sreg_masks[k];
                D.23907 = 1 << dest_sreg;
                D.23911 = ~D.23907;
                D.23965 = D.23964 & D.23911;
                sreg_masks[k] = D.23965;
                <D.23963>:
                k = k + 1;
                <D.23040>:
                if (k < num_sregs) goto <D.23039>; else goto <D.23041>;
                <D.23041>:
                D.23698 = *spec;
                if (D.23698 != 0) goto <D.23966>; else goto <D.23967>;
                <D.23966>:
                D.23780 = rs->vassign;
                D.23688 = ins->dreg;
                D.23693 = (unsigned int) D.23688;
                D.23810 = D.23693 * 4;
                D.23811 = D.23780 + D.23810;
                val = *D.23811;
                goto <D.23968>;
                <D.23967>:
                val = -1;
                <D.23968>:
                if (val == dest_sreg) goto <D.23969>; else goto <D.23970>;
                <D.23969>:
                D.23688 = ins->dreg;
                if (D.23688 != sreg) goto <D.23971>; else goto <D.23972>;
                <D.23971>:
                {
                  int new_dest;

                  D.23688 = ins->dreg;
                  D.23688 = ins->dreg;
                  D.23693 = (unsigned int) D.23688;
                  D.23694 = D.23693 * 12;
                  D.23804 = reginfo + D.23694;
                  new_dest = alloc_int_reg (cfg, bb, tmp, ins, dreg_mask, D.23688, D.23804);
                  D.23973 = new_dest < 0;
                  D.23974 = (long int) D.23973;
                  D.23975 = __builtin_expect (D.23974, 0);
                  if (D.23975 != 0) goto <D.23976>; else goto <D.23977>;
                  <D.23976>:
                  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1505, "new_dest >= 0");
                  <D.23977>:
                  D.23680 = cfg->verbose_level;
                  D.23732 = D.23680 > 2;
                  D.23733 = (long int) D.23732;
                  D.23734 = __builtin_expect (D.23733, 0);
                  if (D.23734 != 0) goto <D.23978>; else goto <D.23979>;
                  <D.23978>:
                  D.23688 = ins->dreg;
                  D.23980 = mono_arch_regname (new_dest);
                  D.23981 = mono_arch_regname (dest_sreg);
                  printf ("\tchanging dreg R%d to %s from %s\n", D.23688, D.23980, D.23981);
                  <D.23979>:
                  prev_dreg = ins->dreg;
                  D.23688 = ins->dreg;
                  assign_reg (cfg, rs, D.23688, 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.23972>:
                <D.23970>:
                sreg.33 = (unsigned int) sreg;
                if (sreg.33 <= 31) goto <D.23984>; else goto <D.23982>;
                <D.23984>:
                D.23942 = 1090453504 >> sreg;
                D.23943 = D.23942 & 1;
                if (D.23943 != 0) goto <D.23985>; else goto <D.23982>;
                <D.23985>:
                {
                  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.23983>;
                <D.23982>:
                D.23780 = rs->vassign;
                sreg.32 = (unsigned int) sreg;
                D.23927 = sreg.32 * 4;
                D.23928 = D.23780 + D.23927;
                val = *D.23928;
                if (val == dest_sreg) goto <D.23986>; else goto <D.23987>;
                <D.23986>:
                need_spill = 0;
                goto <D.23988>;
                <D.23987>:
                if (val < -1) goto <D.23989>; else goto <D.23990>;
                <D.23989>:
                goto <D.23991>;
                <D.23990>:
                if (val >= 0) goto <D.23992>; else goto <D.23993>;
                <D.23992>:
                free_up_hreg (cfg, bb, tmp, ins, val, 0);
                <D.23993>:
                <D.23991>:
                <D.23988>:
                <D.23983>:
                if (need_spill != 0) goto <D.23994>; else goto <D.23995>;
                <D.23994>:
                free_up_hreg (cfg, bb, tmp, ins, dest_sreg, 0);
                <D.23995>:
                if (need_assign != 0) goto <D.23996>; else goto <D.23997>;
                <D.23996>:
                D.23780 = rs->vassign;
                sreg.32 = (unsigned int) sreg;
                D.23927 = sreg.32 * 4;
                D.23928 = D.23780 + D.23927;
                D.23929 = *D.23928;
                if (D.23929 < -1) goto <D.23998>; else goto <D.23999>;
                <D.23998>:
                {
                  int spill;

                  D.23780 = rs->vassign;
                  sreg.32 = (unsigned int) sreg;
                  D.23927 = sreg.32 * 4;
                  D.23928 = D.23780 + D.23927;
                  D.23929 = *D.23928;
                  spill = ~D.23929;
                  create_spilled_store (cfg, bb, spill, dest_sreg, sreg, tmp, 0B, ins, bank);
                }
                <D.23999>:
                D.23709 = sregs[j];
                assign_reg (cfg, rs, D.23709, dest_sreg, 0);
                <D.23997>:
              }
              <D.23961>:
              sregs[j] = dest_sreg;
            }
            <D.23018>:
            j = j + 1;
            <D.23046>:
            if (j < num_sregs) goto <D.23045>; else goto <D.23047>;
            <D.23047>:
            mono_inst_set_src_registers (ins, &sregs);
            D.23698 = *spec;
            D.23799 = (unsigned char) D.23698;
            D.23800 = D.23799 + 154;
            D.23801 = D.23800 <= 1;
            bank = (int) D.23801;
            if (spec_dest != 0) goto <D.24000>; else goto <D.24001>;
            <D.24000>:
            D.23757 = bank != 0;
            D.23758 = (long int) D.23757;
            D.23759 = __builtin_expect (D.23758, 0);
            if (D.23759 != 0) goto <D.24003>; else goto <D.24004>;
            <D.24003>:
            D.23688 = ins->dreg;
            if (D.23688 < 0) goto <D.24006>; else goto <D.24009>;
            <D.24009>:
            D.23688 = ins->dreg;
            D.23767 = regbank_size[bank];
            if (D.23688 >= D.23767) goto <D.24006>; else goto <D.24007>;
            <D.24006>:
            iftmp.35 = 1;
            goto <D.24008>;
            <D.24007>:
            iftmp.35 = 0;
            <D.24008>:
            iftmp.34 = (_Bool) iftmp.35;
            goto <D.24010>;
            <D.24004>:
            D.23688 = ins->dreg;
            iftmp.34 = D.23688 > 31;
            <D.24010>:
            if (iftmp.34 != 0) goto <D.24011>; else goto <D.24012>;
            <D.24011>:
            prev_dreg = ins->dreg;
            <D.24012>:
            <D.24001>:
            if (spec_dest == 98) goto <D.24013>; else goto <D.24014>;
            <D.24013>:
            D.24015 = dest_sregs[0];
            if (D.24015 != -1) goto <D.24016>; else goto <D.24017>;
            <D.24016>:
            D.24015 = dest_sregs[0];
            D.24018 = 1 << D.24015;
            D.24019 = ~D.24018;
            dreg_mask = D.24019 & dreg_mask;
            <D.24017>:
            j = 1;
            goto <D.23049>;
            <D.23048>:
            D.24020 = dest_sregs[j];
            if (D.24020 != -1) goto <D.24021>; else goto <D.24022>;
            <D.24021>:
            D.24020 = dest_sregs[j];
            D.24023 = 1 << D.24020;
            D.24024 = ~D.24023;
            dreg_mask = D.24024 & dreg_mask;
            <D.24022>:
            j = j + 1;
            <D.23049>:
            if (j < num_sregs) goto <D.23048>; else goto <D.23050>;
            <D.23050>:
            D.23780 = rs->vassign;
            D.23688 = ins->dreg;
            D.23693 = (unsigned int) D.23688;
            D.23810 = D.23693 * 4;
            D.23811 = D.23780 + D.23810;
            val = *D.23811;
            D.23757 = bank != 0;
            D.23758 = (long int) D.23757;
            D.23759 = __builtin_expect (D.23758, 0);
            if (D.23759 != 0) goto <D.24026>; else goto <D.24027>;
            <D.24026>:
            D.23688 = ins->dreg;
            if (D.23688 < 0) goto <D.24029>; else goto <D.24032>;
            <D.24032>:
            D.23688 = ins->dreg;
            D.23767 = regbank_size[bank];
            if (D.23688 >= D.23767) goto <D.24029>; else goto <D.24030>;
            <D.24029>:
            iftmp.37 = 1;
            goto <D.24031>;
            <D.24030>:
            iftmp.37 = 0;
            <D.24031>:
            iftmp.36 = (_Bool) iftmp.37;
            goto <D.24033>;
            <D.24027>:
            D.23688 = ins->dreg;
            iftmp.36 = D.23688 > 31;
            <D.24033>:
            if (iftmp.36 != 0) goto <D.24034>; else goto <D.24035>;
            <D.24034>:
            if (val >= 0) goto <D.24036>; else goto <D.24037>;
            <D.24036>:
            D.24038 = dreg_mask >> val;
            D.24039 = D.24038 & 1;
            if (D.24039 == 0) goto <D.24040>; else goto <D.24041>;
            <D.24040>:
            D.23688 = ins->dreg;
            spill_vreg (cfg, bb, tmp, ins, D.23688, 0);
            <D.24041>:
            <D.24037>:
            <D.24035>:
            <D.24014>:
            if (spec_dest == 86) goto <D.24042>; else goto <D.24044>;
            <D.24044>:
            if (spec_dest == 108) goto <D.24042>; else goto <D.24043>;
            <D.24042>:
            {
              guint32 dreg2;
              guint32 dest_dreg2;

              D.23757 = bank != 0;
              D.23758 = (long int) D.23757;
              D.23759 = __builtin_expect (D.23758, 0);
              if (D.23759 != 0) goto <D.24046>; else goto <D.24047>;
              <D.24046>:
              D.23688 = ins->dreg;
              if (D.23688 >= 0) goto <D.24051>; else goto <D.24049>;
              <D.24051>:
              D.23688 = ins->dreg;
              D.23767 = regbank_size[bank];
              if (D.23688 < D.23767) goto <D.24052>; else goto <D.24049>;
              <D.24052>:
              iftmp.39 = 1;
              goto <D.24050>;
              <D.24049>:
              iftmp.39 = 0;
              <D.24050>:
              D.24053 = iftmp.39 != 0;
              iftmp.38 = (long int) D.24053;
              goto <D.24054>;
              <D.24047>:
              D.23688 = ins->dreg;
              D.24055 = D.23688 <= 31;
              iftmp.38 = (long int) D.24055;
              <D.24054>:
              D.24056 = __builtin_expect (iftmp.38, 0);
              if (D.24056 != 0) goto <D.24057>; else goto <D.24058>;
              <D.24057>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1594, "is_soft_reg (ins->dreg, bank)");
              <D.24058>:
              if (dest_dreg != -1) goto <D.24059>; else goto <D.24060>;
              <D.24059>:
              D.23780 = rs->vassign;
              D.23688 = ins->dreg;
              D.23693 = (unsigned int) D.23688;
              D.23810 = D.23693 * 4;
              D.23811 = D.23780 + D.23810;
              D.24061 = *D.23811;
              if (D.24061 != dest_dreg) goto <D.24062>; else goto <D.24063>;
              <D.24062>:
              free_up_hreg (cfg, bb, tmp, ins, dest_dreg, 0);
              <D.24063>:
              D.23688 = ins->dreg;
              D.24064 = D.23688 + 1;
              dreg2 = (guint32) D.24064;
              if (spec_dest == 108) goto <D.24066>; else goto <D.24067>;
              <D.24066>:
              D.24068 = dest_dreg + 1;
              iftmp.40 = (guint32) D.24068;
              goto <D.24069>;
              <D.24067>:
              if (spec_dest == 86) goto <D.24071>; else goto <D.24072>;
              <D.24071>:
              iftmp.41 = 3;
              goto <D.24073>;
              <D.24072>:
              iftmp.41 = 4294967295;
              <D.24073>:
              iftmp.40 = iftmp.41;
              <D.24069>:
              dest_dreg2 = iftmp.40;
              if (dest_dreg2 != 4294967295) goto <D.24074>; else goto <D.24075>;
              <D.24074>:
              D.23780 = rs->vassign;
              D.24076 = dreg2 * 4;
              D.24077 = D.23780 + D.24076;
              D.24078 = *D.24077;
              D.24079 = (unsigned int) D.24078;
              if (D.24079 != dest_dreg2) goto <D.24080>; else goto <D.24081>;
              <D.24080>:
              dest_dreg2.42 = (int) dest_dreg2;
              free_up_hreg (cfg, bb, tmp, ins, dest_dreg2.42, 0);
              <D.24081>:
              <D.24075>:
              <D.24060>:
            }
            <D.24043>:
            if (dreg_fixed_mask != 0) goto <D.24083>; else goto <D.24084>;
            <D.24083>:
            D.23757 = bank != 0;
            D.23758 = (long int) D.23757;
            D.23759 = __builtin_expect (D.23758, 0);
            if (D.23759 != 0) goto <D.24085>; else goto <D.24086>;
            <D.24085>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1610, "!bank");
            <D.24086>:
            D.23688 = ins->dreg;
            D.24089 = (unsigned int) D.23688;
            if (D.24089 <= 31) goto <D.24090>; else goto <D.24087>;
            <D.24090>:
            D.23688 = ins->dreg;
            D.24091 = 1090453504 >> D.23688;
            D.24092 = D.24091 & 1;
            if (D.24092 != 0) goto <D.24093>; else goto <D.24087>;
            <D.24093>:
            val = mono_regstate_alloc_int (rs, dreg_fixed_mask);
            if (val < 0) goto <D.24094>; else goto <D.24095>;
            <D.24094>:
            val = get_register_spilling (cfg, bb, tmp, ins, dreg_fixed_mask, -1, bank);
            <D.24095>:
            mono_regstate_free_int (rs, val);
            dest_dreg = val;
            goto <D.24088>;
            <D.24087>:
            dreg_mask = dreg_mask & dreg_fixed_mask;
            <D.24088>:
            <D.24084>:
            D.23757 = bank != 0;
            D.23758 = (long int) D.23757;
            D.23759 = __builtin_expect (D.23758, 0);
            if (D.23759 != 0) goto <D.24097>; else goto <D.24098>;
            <D.24097>:
            D.23688 = ins->dreg;
            if (D.23688 < 0) goto <D.24100>; else goto <D.24103>;
            <D.24103>:
            D.23688 = ins->dreg;
            D.23767 = regbank_size[bank];
            if (D.23688 >= D.23767) goto <D.24100>; else goto <D.24101>;
            <D.24100>:
            iftmp.44 = 1;
            goto <D.24102>;
            <D.24101>:
            iftmp.44 = 0;
            <D.24102>:
            iftmp.43 = (_Bool) iftmp.44;
            goto <D.24104>;
            <D.24098>:
            D.23688 = ins->dreg;
            iftmp.43 = D.23688 > 31;
            <D.24104>:
            if (iftmp.43 != 0) goto <D.24105>; else goto <D.24106>;
            <D.24105>:
            D.23780 = rs->vassign;
            D.23688 = ins->dreg;
            D.23693 = (unsigned int) D.23688;
            D.23810 = D.23693 * 4;
            D.23811 = D.23780 + D.23810;
            val = *D.23811;
            if (val < 0) goto <D.24107>; else goto <D.24108>;
            <D.24107>:
            {
              int spill;

              spill = 0;
              if (val < -1) goto <D.24109>; else goto <D.24110>;
              <D.24109>:
              spill = ~val;
              <D.24110>:
              D.23688 = ins->dreg;
              D.23688 = ins->dreg;
              D.23693 = (unsigned int) D.23688;
              D.23694 = D.23693 * 12;
              D.23804 = reginfo + D.23694;
              val = alloc_reg (cfg, bb, tmp, ins, dreg_mask, D.23688, D.23804, bank);
              D.23688 = ins->dreg;
              assign_reg (cfg, rs, D.23688, val, bank);
              if (spill != 0) goto <D.24111>; else goto <D.24112>;
              <D.24111>:
              create_spilled_store (cfg, bb, spill, val, prev_dreg, tmp, ins, 0B, bank);
              <D.24112>:
            }
            <D.24108>:
            D.23680 = cfg->verbose_level;
            D.23732 = D.23680 > 2;
            D.23733 = (long int) D.23732;
            D.23734 = __builtin_expect (D.23733, 0);
            if (D.23734 != 0) goto <D.24113>; else goto <D.24114>;
            <D.24113>:
            D.24115 = mono_regname_full (val, bank);
            D.23688 = ins->dreg;
            printf ("\tassigned dreg %s to dest R%d\n", D.24115, D.23688);
            <D.24114>:
            ins->dreg = val;
            <D.24106>:
            if (spec_dest == 86) goto <D.24116>; else goto <D.24118>;
            <D.24118>:
            if (spec_dest == 108) goto <D.24116>; else goto <D.24117>;
            <D.24116>:
            {
              int reg2;

              reg2 = prev_dreg + 1;
              D.23757 = bank != 0;
              D.23758 = (long int) D.23757;
              D.23759 = __builtin_expect (D.23758, 0);
              if (D.23759 != 0) goto <D.24119>; else goto <D.24120>;
              <D.24119>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1651, "!bank");
              <D.24120>:
              D.24121 = prev_dreg < 0;
              D.24122 = (long int) D.24121;
              D.24123 = __builtin_expect (D.24122, 0);
              if (D.24123 != 0) goto <D.24124>; else goto <D.24125>;
              <D.24124>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1652, "prev_dreg > -1");
              <D.24125>:
              D.23780 = rs->vassign;
              prev_dreg.46 = (unsigned int) prev_dreg;
              D.24130 = prev_dreg.46 * 4;
              D.24131 = D.23780 + D.24130;
              D.24132 = *D.24131;
              D.24133 = (unsigned int) D.24132;
              if (D.24133 <= 31) goto <D.24134>; else goto <D.24127>;
              <D.24134>:
              D.23780 = rs->vassign;
              prev_dreg.46 = (unsigned int) prev_dreg;
              D.24130 = prev_dreg.46 * 4;
              D.24131 = D.23780 + D.24130;
              D.24132 = *D.24131;
              D.24135 = 1090453504 >> D.24132;
              D.24136 = D.24135 & 1;
              if (D.24136 != 0) goto <D.24137>; else goto <D.24127>;
              <D.24137>:
              iftmp.45 = 1;
              goto <D.24128>;
              <D.24127>:
              iftmp.45 = 0;
              <D.24128>:
              D.24138 = iftmp.45 != 0;
              D.24139 = (long int) D.24138;
              D.24140 = __builtin_expect (D.24139, 0);
              if (D.24140 != 0) goto <D.24141>; else goto <D.24142>;
              <D.24141>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1653, "!is_global_ireg (rs->vassign [prev_dreg])");
              <D.24142>:
              if (spec_dest == 108) goto <D.24145>; else goto <D.24146>;
              <D.24145>:
              D.23780 = rs->vassign;
              prev_dreg.46 = (unsigned int) prev_dreg;
              D.24130 = prev_dreg.46 * 4;
              D.24131 = D.23780 + D.24130;
              D.24132 = *D.24131;
              iftmp.48 = D.24132 != -2;
              goto <D.24147>;
              <D.24146>:
              iftmp.48 = spec_dest == 86;
              <D.24147>:
              if (iftmp.48 != 0) goto <D.24148>; else goto <D.24149>;
              <D.24148>:
              if (spec_dest == 108) goto <D.24151>; else goto <D.24152>;
              <D.24151>:
              D.23780 = rs->vassign;
              prev_dreg.46 = (unsigned int) prev_dreg;
              D.24130 = prev_dreg.46 * 4;
              D.24131 = D.23780 + D.24130;
              D.24132 = *D.24131;
              D.24153 = D.24132 + 1;
              iftmp.49 = 1 << D.24153;
              goto <D.24154>;
              <D.24152>:
              if (spec_dest == 86) goto <D.24156>; else goto <D.24157>;
              <D.24156>:
              iftmp.50 = 8;
              goto <D.24158>;
              <D.24157>:
              iftmp.50 = 0;
              <D.24158>:
              iftmp.49 = iftmp.50;
              <D.24154>:
              iftmp.47 = iftmp.49;
              goto <D.24159>;
              <D.24149>:
              iftmp.47 = 65532;
              <D.24159>:
              mask = iftmp.47;
              D.23780 = rs->vassign;
              reg2.51 = (unsigned int) reg2;
              D.24161 = reg2.51 * 4;
              D.24162 = D.23780 + D.24161;
              val = *D.24162;
              if (val < 0) goto <D.24163>; else goto <D.24164>;
              <D.24163>:
              {
                int spill;

                spill = 0;
                if (val < -1) goto <D.24165>; else goto <D.24166>;
                <D.24165>:
                spill = ~val;
                <D.24166>:
                val = mono_regstate_alloc_int (rs, mask);
                if (val < 0) goto <D.24167>; else goto <D.24168>;
                <D.24167>:
                val = get_register_spilling (cfg, bb, tmp, ins, mask, reg2, bank);
                <D.24168>:
                if (spill != 0) goto <D.24169>; else goto <D.24170>;
                <D.24169>:
                create_spilled_store (cfg, bb, spill, val, reg2, tmp, ins, 0B, bank);
                <D.24170>:
              }
              goto <D.24171>;
              <D.24164>:
              D.24172 = 1 << val;
              D.24173 = D.24172 & mask;
              if (D.24173 == 0) goto <D.24174>; else goto <D.24175>;
              <D.24174>:
              val = mono_regstate_alloc_int (rs, mask);
              if (val < 0) goto <D.24176>; else goto <D.24177>;
              <D.24176>:
              val = get_register_spilling (cfg, bb, tmp, ins, mask, reg2, bank);
              <D.24177>:
              D.23780 = rs->vassign;
              reg2.51 = (unsigned int) reg2;
              D.24161 = reg2.51 * 4;
              D.24162 = D.23780 + D.24161;
              D.24178 = *D.24162;
              create_copy_ins (cfg, bb, tmp, D.24178, val, ins, ip, bank);
              D.23780 = rs->vassign;
              reg2.51 = (unsigned int) reg2;
              D.24161 = reg2.51 * 4;
              D.24162 = D.23780 + D.24161;
              D.24178 = *D.24162;
              mono_regstate_free_int (rs, D.24178);
              <D.24175>:
              <D.24171>:
              D.23680 = cfg->verbose_level;
              D.23732 = D.23680 > 2;
              D.23733 = (long int) D.23732;
              D.23734 = __builtin_expect (D.23733, 0);
              if (D.23734 != 0) goto <D.24179>; else goto <D.24180>;
              <D.24179>:
              D.24181 = mono_arch_regname (val);
              printf ("\tassigned dreg-high %s to dest R%d\n", D.24181, reg2);
              <D.24180>:
              assign_reg (cfg, rs, reg2, val, bank);
              dreg_high = val;
              ins->backend.reg3 = val;
              D.23757 = bank != 0;
              D.23758 = (long int) D.23757;
              D.23759 = __builtin_expect (D.23758, 0);
              if (D.23759 != 0) goto <D.24183>; else goto <D.24184>;
              <D.24183>:
              D.23757 = bank != 0;
              D.23758 = (long int) D.23757;
              D.23759 = __builtin_expect (D.23758, 0);
              if (D.23759 != 0) goto <D.24186>; else goto <D.24187>;
              <D.24186>:
              D.23757 = bank != 0;
              D.23758 = (long int) D.23757;
              D.23759 = __builtin_expect (D.23758, 0);
              if (D.23759 != 0) goto <D.24191>; else goto <D.24192>;
              <D.24191>:
              if (val >= 0) goto <D.24196>; else goto <D.24194>;
              <D.24196>:
              D.23767 = regbank_size[bank];
              if (D.23767 > val) goto <D.24197>; else goto <D.24194>;
              <D.24197>:
              iftmp.55 = 1;
              goto <D.24195>;
              <D.24194>:
              iftmp.55 = 0;
              <D.24195>:
              D.24198 = (_Bool) iftmp.55;
              if (D.24198 != 0) goto <D.24199>; else goto <D.24189>;
              <D.24199>:
              goto <D.24200>;
              <D.24192>:
              if (val <= 31) goto <D.24201>; else goto <D.24189>;
              <D.24201>:
              <D.24200>:
              D.24202 = regbank_callee_regs[bank];
              D.24203 = D.24202 >> val;
              D.24204 = D.24203 & 1;
              if (D.24204 != 0) goto <D.24205>; else goto <D.24189>;
              <D.24205>:
              iftmp.54 = 1;
              goto <D.24190>;
              <D.24189>:
              iftmp.54 = 0;
              <D.24190>:
              iftmp.53 = (_Bool) iftmp.54;
              goto <D.24206>;
              <D.24187>:
              val.57 = (unsigned int) val;
              if (val.57 <= 31) goto <D.24211>; else goto <D.24208>;
              <D.24211>:
              D.24212 = 65532 >> val;
              D.24213 = D.24212 & 1;
              if (D.24213 != 0) goto <D.24214>; else goto <D.24208>;
              <D.24214>:
              iftmp.56 = 1;
              goto <D.24209>;
              <D.24208>:
              iftmp.56 = 0;
              <D.24209>:
              iftmp.53 = (_Bool) iftmp.56;
              <D.24206>:
              iftmp.52 = iftmp.53;
              goto <D.24215>;
              <D.24184>:
              val.57 = (unsigned int) val;
              if (val.57 <= 31) goto <D.24219>; else goto <D.24217>;
              <D.24219>:
              D.24212 = 65532 >> val;
              D.24213 = D.24212 & 1;
              if (D.24213 != 0) goto <D.24220>; else goto <D.24217>;
              <D.24220>:
              iftmp.58 = 1;
              goto <D.24218>;
              <D.24217>:
              iftmp.58 = 0;
              <D.24218>:
              iftmp.52 = (_Bool) iftmp.58;
              <D.24215>:
              if (iftmp.52 != 0) goto <D.24221>; else goto <D.24222>;
              <D.24221>:
              if (reg2 >= 0) goto <D.24223>; else goto <D.24224>;
              <D.24223>:
              reg2.51 = (unsigned int) reg2;
              D.24225 = reg2.51 * 12;
              D.24226 = reginfo + D.24225;
              D.24227 = D.24226->born_in;
              if (D.24227 >= i) goto <D.24228>; else goto <D.24229>;
              <D.24228>:
              D.23680 = cfg->verbose_level;
              D.23732 = D.23680 > 2;
              D.23733 = (long int) D.23732;
              D.23734 = __builtin_expect (D.23733, 0);
              if (D.23734 != 0) goto <D.24230>; else goto <D.24231>;
              <D.24230>:
              D.24232 = mono_arch_regname (val);
              printf ("\tfreeable %s (R%d)\n", D.24232, reg2);
              <D.24231>:
              mono_regstate_free_int (rs, val);
              <D.24229>:
              <D.24224>:
              <D.24222>:
            }
            <D.24117>:
            if (prev_dreg >= 0) goto <D.24233>; else goto <D.24234>;
            <D.24233>:
            D.23757 = bank != 0;
            D.23758 = (long int) D.23757;
            D.23759 = __builtin_expect (D.23758, 0);
            if (D.23759 != 0) goto <D.24236>; else goto <D.24237>;
            <D.24236>:
            if (prev_dreg < 0) goto <D.24239>; else goto <D.24242>;
            <D.24242>:
            D.23767 = regbank_size[bank];
            if (D.23767 <= prev_dreg) goto <D.24239>; else goto <D.24240>;
            <D.24239>:
            iftmp.60 = 1;
            goto <D.24241>;
            <D.24240>:
            iftmp.60 = 0;
            <D.24241>:
            iftmp.59 = (_Bool) iftmp.60;
            goto <D.24243>;
            <D.24237>:
            iftmp.59 = prev_dreg > 31;
            <D.24243>:
            if (iftmp.59 != 0) goto <D.24244>; else goto <D.24245>;
            <D.24244>:
            if (spec_dest != 98) goto <D.24246>; else goto <D.24247>;
            <D.24246>:
            {
              int dreg;

              D.23780 = rs->vassign;
              prev_dreg.46 = (unsigned int) prev_dreg;
              D.24130 = prev_dreg.46 * 4;
              D.24131 = D.23780 + D.24130;
              dreg = *D.24131;
              D.24248 = dreg < 0;
              D.24249 = (long int) D.24248;
              D.24250 = __builtin_expect (D.24249, 0);
              if (D.24250 != 0) goto <D.24251>; else goto <D.24252>;
              <D.24251>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1704, "dreg >= 0");
              <D.24252>:
              D.23680 = cfg->verbose_level;
              D.23732 = D.23680 > 2;
              D.23733 = (long int) D.23732;
              D.23734 = __builtin_expect (D.23733, 0);
              if (D.23734 != 0) goto <D.24253>; else goto <D.24254>;
              <D.24253>:
              D.24255 = mono_regname_full (dreg, bank);
              prev_dreg.46 = (unsigned int) prev_dreg;
              D.24256 = prev_dreg.46 * 12;
              D.24257 = reginfo + D.24256;
              D.24258 = D.24257->born_in;
              printf ("\tfreeable %s (R%d) (born in %d)\n", D.24255, prev_dreg, D.24258);
              <D.24254>:
              D.23757 = bank != 0;
              D.23758 = (long int) D.23757;
              D.23759 = __builtin_expect (D.23758, 0);
              if (D.23759 != 0) goto <D.24259>; else goto <D.24260>;
              <D.24259>:
              mono_regstate_free_general (rs, dreg, bank);
              goto <D.24261>;
              <D.24260>:
              mono_regstate_free_int (rs, dreg);
              <D.24261>:
              D.23780 = rs->vassign;
              prev_dreg.46 = (unsigned int) prev_dreg;
              D.24130 = prev_dreg.46 * 4;
              D.24131 = D.23780 + D.24130;
              *D.24131 = -1;
            }
            <D.24247>:
            <D.24245>:
            <D.24234>:
            if (dest_dreg != -1) goto <D.24262>; else goto <D.24263>;
            <D.24262>:
            D.23688 = ins->dreg;
            if (D.23688 != dest_dreg) goto <D.24264>; else goto <D.24265>;
            <D.24264>:
            D.23688 = ins->dreg;
            create_copy_ins (cfg, bb, tmp, D.23688, dest_dreg, ins, ip, bank);
            ins->dreg = dest_dreg;
            D.23757 = bank != 0;
            D.23758 = (long int) D.23757;
            D.23759 = __builtin_expect (D.23758, 0);
            if (D.23759 != 0) goto <D.24266>; else goto <D.24267>;
            <D.24266>:
            {
              int translated_bank;

              D.24268 = cfg->rs;
              translated_bank = translate_bank (D.24268, bank, dest_dreg);
              D.24269 = rs->symbolic[translated_bank];
              dest_dreg.61 = (unsigned int) dest_dreg;
              D.24271 = dest_dreg.61 * 4;
              D.24272 = D.24269 + D.24271;
              D.24273 = *D.24272;
              D.24274 = regbank_size[translated_bank];
              if (D.24273 >= D.24274) goto <D.24275>; else goto <D.24276>;
              <D.24275>:
              free_up_hreg (cfg, bb, tmp, ins, dest_dreg, translated_bank);
              <D.24276>:
            }
            goto <D.24277>;
            <D.24267>:
            D.24278 = rs->isymbolic[dest_dreg];
            if (D.24278 > 31) goto <D.24279>; else goto <D.24280>;
            <D.24279>:
            free_up_hreg (cfg, bb, tmp, ins, dest_dreg, bank);
            <D.24280>:
            <D.24277>:
            <D.24265>:
            <D.24263>:
            if (spec_dest == 98) goto <D.24281>; else goto <D.24282>;
            <D.24281>:
            j = 0;
            goto <D.23059>;
            <D.23058>:
            D.23722 = j + 1;
            D.23723 = (sizetype) D.23722;
            D.23724 = spec + D.23723;
            D.23725 = *D.23724;
            D.23748 = (unsigned char) D.23725;
            D.23749 = D.23748 + 154;
            if (D.23749 > 1) goto <D.24283>; else goto <D.24284>;
            <D.24283>:
            D.24285 = sreg_masks[j];
            D.23688 = ins->dreg;
            D.24286 = 1 << D.23688;
            D.24287 = ~D.24286;
            D.24288 = D.24285 & D.24287;
            sreg_masks[j] = D.24288;
            <D.24284>:
            j = j + 1;
            <D.23059>:
            if (j < num_sregs) goto <D.23058>; else goto <D.23060>;
            <D.23060>:
            <D.24282>:
            if (clob_reg != -1) goto <D.24289>; else goto <D.24290>;
            <D.24289>:
            D.23934 = rs->ifree_mask;
            D.24291 = 1 << clob_reg;
            D.24292 = D.23934 & D.24291;
            if (D.24292 == 0) goto <D.24293>; else goto <D.24294>;
            <D.24293>:
            D.23680 = cfg->verbose_level;
            D.23732 = D.23680 > 2;
            D.23733 = (long int) D.23732;
            D.23734 = __builtin_expect (D.23733, 0);
            if (D.23734 != 0) goto <D.24295>; else goto <D.24296>;
            <D.24295>:
            D.24297 = rs->isymbolic[clob_reg];
            printf ("\tforced spill of clobbered reg R%d\n", D.24297);
            <D.24296>:
            free_up_hreg (cfg, bb, tmp, ins, clob_reg, 0);
            <D.24294>:
            <D.24290>:
            D.23849 = spec + 5;
            D.23850 = *D.23849;
            if (D.23850 == 99) goto <D.24298>; else goto <D.24299>;
            <D.24298>:
            {
              int j;
              int s;
              int dreg;
              int dreg2;
              int cur_bank;
              guint64 clob_mask;

              clob_mask = 65532;
              D.23934 = rs->ifree_mask;
              if (D.23934 != 65532) goto <D.24300>; else goto <D.24301>;
              <D.24300>:
              if (prev_dreg != -1) goto <D.24304>; else goto <D.24302>;
              <D.24304>:
              D.24305 = spec_dest + 154;
              if (D.24305 > 1) goto <D.24306>; else goto <D.24302>;
              <D.24306>:
              D.23780 = rs->vassign;
              prev_dreg.46 = (unsigned int) prev_dreg;
              D.24130 = prev_dreg.46 * 4;
              D.24131 = D.23780 + D.24130;
              dreg = *D.24131;
              goto <D.24303>;
              <D.24302>:
              dreg = -1;
              <D.24303>:
              if (spec_dest == 86) goto <D.24307>; else goto <D.24310>;
              <D.24310>:
              if (spec_dest == 108) goto <D.24307>; else goto <D.24308>;
              <D.24307>:
              D.23780 = rs->vassign;
              prev_dreg.62 = (sizetype) prev_dreg;
              D.24312 = prev_dreg.62 + 1;
              D.24313 = D.24312 * 4;
              D.24314 = D.23780 + D.24313;
              dreg2 = *D.24314;
              goto <D.24309>;
              <D.24308>:
              dreg2 = -1;
              <D.24309>:
              j = 0;
              goto <D.23068>;
              <D.23067>:
              D.24315 = 1 << j;
              s = (int) D.24315;
              D.24316 = (long long unsigned int) s;
              D.24317 = D.24316 & clob_mask;
              if (D.24317 != 0) goto <D.24318>; else goto <D.24319>;
              <D.24318>:
              D.23934 = rs->ifree_mask;
              s.63 = (unsigned int) s;
              D.24321 = D.23934 & s.63;
              if (D.24321 == 0) goto <D.24322>; else goto <D.24323>;
              <D.24322>:
              D.23705 = ins->sreg1;
              if (D.23705 != j) goto <D.24324>; else goto <D.24325>;
              <D.24324>:
              if (j != dreg) goto <D.24328>; else goto <D.24326>;
              <D.24328>:
              if (j != dreg2) goto <D.24329>; else goto <D.24326>;
              <D.24329>:
              free_up_hreg (cfg, bb, tmp, ins, j, 0);
              goto <D.24327>;
              <D.24326>:
              D.24330 = rs->isymbolic[j];
              if (D.24330 != 0) goto <D.24331>; else goto <D.24332>;
              <D.24331>:
              D.23780 = rs->vassign;
              D.24330 = rs->isymbolic[j];
              D.24333 = (unsigned int) D.24330;
              D.24334 = D.24333 * 4;
              D.24335 = D.23780 + D.24334;
              *D.24335 = -1;
              <D.24332>:
              <D.24327>:
              mono_regstate_free_int (rs, j);
              <D.24325>:
              <D.24323>:
              <D.24319>:
              j = j + 1;
              <D.23068>:
              if (j <= 31) goto <D.23067>; else goto <D.23069>;
              <D.23069>:
              <D.24301>:
              cur_bank = 1;
              goto <D.23075>;
              <D.23074>:
              D.24336 = rs->free_mask[cur_bank];
              D.24337 = regbank_callee_regs[cur_bank];
              if (D.24336 != D.24337) goto <D.24338>; else goto <D.24339>;
              <D.24338>:
              D.24337 = regbank_callee_regs[cur_bank];
              clob_mask = (guint64) D.24337;
              if (prev_dreg != -1) goto <D.24342>; else goto <D.24340>;
              <D.24342>:
              D.24305 = spec_dest + 154;
              if (D.24305 <= 1) goto <D.24343>; else goto <D.24340>;
              <D.24343>:
              D.23780 = rs->vassign;
              prev_dreg.46 = (unsigned int) prev_dreg;
              D.24130 = prev_dreg.46 * 4;
              D.24131 = D.23780 + D.24130;
              dreg = *D.24131;
              goto <D.24341>;
              <D.24340>:
              dreg = -1;
              <D.24341>:
              j = 0;
              goto <D.23072>;
              <D.23071>:
              if (0 != 0) goto <D.24344>; else goto <D.24345>;
              <D.24344>:
              // predicted unlikely by continue predictor.
              goto <D.23070>;
              <D.24345>:
              D.24315 = 1 << j;
              s = (int) D.24315;
              D.24316 = (long long unsigned int) s;
              D.24317 = D.24316 & clob_mask;
              if (D.24317 != 0) goto <D.24346>; else goto <D.24347>;
              <D.24346>:
              D.24336 = rs->free_mask[cur_bank];
              s.63 = (unsigned int) s;
              D.24348 = D.24336 & s.63;
              if (D.24348 == 0) goto <D.24349>; else goto <D.24350>;
              <D.24349>:
              if (j != dreg) goto <D.24351>; else goto <D.24352>;
              <D.24351>:
              free_up_hreg (cfg, bb, tmp, ins, j, cur_bank);
              goto <D.24353>;
              <D.24352>:
              D.24354 = rs->symbolic[cur_bank];
              j.64 = (unsigned int) j;
              D.24356 = j.64 * 4;
              D.24357 = D.24354 + D.24356;
              D.24358 = *D.24357;
              if (D.24358 != 0) goto <D.24359>; else goto <D.24360>;
              <D.24359>:
              D.23780 = rs->vassign;
              D.24354 = rs->symbolic[cur_bank];
              j.64 = (unsigned int) j;
              D.24356 = j.64 * 4;
              D.24357 = D.24354 + D.24356;
              D.24358 = *D.24357;
              D.24361 = (unsigned int) D.24358;
              D.24362 = D.24361 * 4;
              D.24363 = D.23780 + D.24362;
              *D.24363 = -1;
              <D.24360>:
              <D.24353>:
              mono_regstate_free_general (rs, j, cur_bank);
              <D.24350>:
              <D.24347>:
              <D.23070>:
              j = j + 1;
              <D.23072>:
              D.24364 = regbank_size[cur_bank];
              if (D.24364 > j) goto <D.23071>; else goto <D.23073>;
              <D.23073>:
              <D.24339>:
              cur_bank = cur_bank + 1;
              <D.23075>:
              if (cur_bank <= 3) goto <D.23074>; else goto <D.23076>;
              <D.23076>:
            }
            <D.24299>:
            D.23849 = spec + 5;
            D.23850 = *D.23849;
            if (D.23850 == 99) goto <D.24367>; else goto <D.24368>;
            <D.24367>:
            D.23683 = ins->opcode;
            D.23853 = D.23683 + 65193;
            if (D.23853 <= 2) goto <D.24365>; else goto <D.24369>;
            <D.24369>:
            D.23683 = ins->opcode;
            D.23855 = D.23683 + 65187;
            if (D.23855 <= 2) goto <D.24365>; else goto <D.24370>;
            <D.24370>:
            D.23683 = ins->opcode;
            D.23857 = D.23683 + 65184;
            if (D.23857 <= 2) goto <D.24365>; else goto <D.24371>;
            <D.24371>:
            D.23683 = ins->opcode;
            D.23859 = D.23683 + 65181;
            if (D.23859 <= 2) goto <D.24365>; else goto <D.24372>;
            <D.24372>:
            D.23683 = ins->opcode;
            D.23861 = D.23683 + 65190;
            if (D.23861 <= 2) goto <D.24365>; else goto <D.24373>;
            <D.24373>:
            D.23683 = ins->opcode;
            D.23863 = D.23683 + 65178;
            if (D.23863 <= 2) goto <D.24365>; else goto <D.24374>;
            <D.24374>:
            D.23683 = ins->opcode;
            if (D.23683 == 444) goto <D.24365>; else goto <D.24366>;
            <D.24365>:
            {
              struct MonoCallInst * call;
              struct GSList * list;

              call = ins;
              list = call->out_ireg_args;
              if (list != 0B) goto <D.24375>; else goto <D.24376>;
              <D.24375>:
              goto <D.23083>;
              <D.23082>:
              {
                guint32 regpair;
                int reg;
                int hreg;

                D.24377 = list->data;
                regpair = (guint32) D.24377;
                D.24378 = regpair >> 24;
                hreg = (int) D.24378;
                regpair.65 = (int) regpair;
                reg = regpair.65 & 16777215;
                assign_reg (cfg, rs, reg, hreg, 0);
                D.24380 = sreg_masks[0];
                D.24381 = 1 << hreg;
                D.24382 = ~D.24381;
                D.24383 = D.24380 & D.24382;
                sreg_masks[0] = D.24383;
                D.23680 = cfg->verbose_level;
                D.23732 = D.23680 > 2;
                D.23733 = (long int) D.23732;
                D.23734 = __builtin_expect (D.23733, 0);
                if (D.23734 != 0) goto <D.24384>; else goto <D.24385>;
                <D.24384>:
                D.24386 = mono_arch_regname (hreg);
                printf ("\tassigned arg reg %s to R%d\n", D.24386, reg);
                <D.24385>:
                if (list != 0B) goto <D.24388>; else goto <D.24389>;
                <D.24388>:
                iftmp.66 = list->next;
                goto <D.24390>;
                <D.24389>:
                iftmp.66 = 0B;
                <D.24390>:
                list = iftmp.66;
              }
              <D.23083>:
              if (list != 0B) goto <D.23082>; else goto <D.23084>;
              <D.23084>:
              <D.24376>:
              list = call->out_freg_args;
              if (list != 0B) goto <D.24391>; else goto <D.24392>;
              <D.24391>:
              goto <D.23089>;
              <D.23088>:
              {
                guint32 regpair;
                int reg;
                int hreg;

                D.24377 = list->data;
                regpair = (guint32) D.24377;
                D.24393 = regpair >> 24;
                hreg = (int) D.24393;
                regpair.67 = (int) regpair;
                reg = regpair.67 & 16777215;
                assign_reg (cfg, rs, reg, hreg, 1);
                D.23680 = cfg->verbose_level;
                D.23732 = D.23680 > 2;
                D.23733 = (long int) D.23732;
                D.23734 = __builtin_expect (D.23733, 0);
                if (D.23734 != 0) goto <D.24395>; else goto <D.24396>;
                <D.24395>:
                D.24397 = mono_regname_full (hreg, 1);
                printf ("\tassigned arg reg %s to R%d\n", D.24397, reg);
                <D.24396>:
                if (list != 0B) goto <D.24399>; else goto <D.24400>;
                <D.24399>:
                iftmp.68 = list->next;
                goto <D.24401>;
                <D.24400>:
                iftmp.68 = 0B;
                <D.24401>:
                list = iftmp.68;
              }
              <D.23089>:
              if (list != 0B) goto <D.23088>; else goto <D.23090>;
              <D.23090>:
              <D.24392>:
            }
            <D.24366>:
            <D.24368>:
            D.23888 = spec + 1;
            D.23889 = *D.23888;
            D.24402 = (unsigned char) D.23889;
            D.24403 = D.24402 + 154;
            D.24404 = D.24403 <= 1;
            bank = (int) D.24404;
            if (spec_dest == 86) goto <D.24405>; else goto <D.24407>;
            <D.24407>:
            if (spec_dest == 108) goto <D.24405>; else goto <D.24406>;
            <D.24405>:
            D.23849 = spec + 5;
            D.23850 = *D.23849;
            if (D.23850 == 49) goto <D.24408>; else goto <D.24409>;
            <D.24408>:
            {
              int sreg1;
              int dest_sreg1;

              sreg1 = sregs[0];
              dest_sreg1 = dest_sregs[0];
              D.23757 = bank != 0;
              D.23758 = (long int) D.23757;
              D.23759 = __builtin_expect (D.23758, 0);
              if (D.23759 != 0) goto <D.24411>; else goto <D.24412>;
              <D.24411>:
              if (sreg1 >= 0) goto <D.24416>; else goto <D.24414>;
              <D.24416>:
              D.23767 = regbank_size[bank];
              if (D.23767 > sreg1) goto <D.24417>; else goto <D.24414>;
              <D.24417>:
              iftmp.70 = 1;
              goto <D.24415>;
              <D.24414>:
              iftmp.70 = 0;
              <D.24415>:
              D.24418 = iftmp.70 != 0;
              iftmp.69 = (long int) D.24418;
              goto <D.24419>;
              <D.24412>:
              D.24420 = sreg1 <= 31;
              iftmp.69 = (long int) D.24420;
              <D.24419>:
              D.24421 = __builtin_expect (iftmp.69, 0);
              if (D.24421 != 0) goto <D.24422>; else goto <D.24423>;
              <D.24422>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1879, "is_soft_reg (sreg1, bank)");
              <D.24423>:
              if (dest_sreg1 != -1) goto <D.24424>; else goto <D.24425>;
              <D.24424>:
              D.23688 = ins->dreg;
              D.24426 = D.23688 != dest_sreg1;
              D.24427 = (long int) D.24426;
              D.24428 = __builtin_expect (D.24427, 0);
              if (D.24428 != 0) goto <D.24429>; else goto <D.24430>;
              <D.24429>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1883, "dest_sreg1 == ins->dreg");
              <D.24430>:
              <D.24425>:
              D.23688 = ins->dreg;
              D.24286 = 1 << D.23688;
              val = mono_regstate_alloc_int (rs, D.24286);
              D.24431 = val < 0;
              D.24432 = (long int) D.24431;
              D.24433 = __builtin_expect (D.24432, 0);
              if (D.24433 != 0) goto <D.24434>; else goto <D.24435>;
              <D.24434>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1885, "val >= 0");
              <D.24435>:
              D.23780 = rs->vassign;
              sreg1.71 = (unsigned int) sreg1;
              D.24437 = sreg1.71 * 4;
              D.24438 = D.23780 + D.24437;
              D.24439 = *D.24438;
              if (D.24439 >= 0) goto <D.24440>; else goto <D.24441>;
              <D.24440>:
              D.23780 = rs->vassign;
              sreg1.71 = (unsigned int) sreg1;
              D.24437 = sreg1.71 * 4;
              D.24438 = D.23780 + D.24437;
              D.24439 = *D.24438;
              if (D.24439 != val) goto <D.24442>; else goto <D.24443>;
              <D.24442>:
              monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-codegen.c", 1889);
              <D.24443>:
              <D.24441>:
              assign_reg (cfg, rs, sreg1, val, bank);
              D.23680 = cfg->verbose_level;
              D.23732 = D.23680 > 2;
              D.23733 = (long int) D.23732;
              D.23734 = __builtin_expect (D.23733, 0);
              if (D.23734 != 0) goto <D.24444>; else goto <D.24445>;
              <D.24444>:
              D.24446 = mono_regname_full (val, bank);
              printf ("\tassigned sreg1-low %s to R%d\n", D.24446, sreg1);
              <D.24445>:
              if (spec_src1 == 108) goto <D.24449>; else goto <D.24450>;
              <D.24449>:
              D.23688 = ins->dreg;
              iftmp.73 = D.23688 != -2;
              goto <D.24451>;
              <D.24450>:
              iftmp.73 = spec_src1 == 86;
              <D.24451>:
              if (iftmp.73 != 0) goto <D.24452>; else goto <D.24453>;
              <D.24452>:
              if (spec_src1 == 108) goto <D.24455>; else goto <D.24456>;
              <D.24455>:
              D.23688 = ins->dreg;
              D.24064 = D.23688 + 1;
              iftmp.74 = 1 << D.24064;
              goto <D.24457>;
              <D.24456>:
              if (spec_src1 == 86) goto <D.24459>; else goto <D.24460>;
              <D.24459>:
              iftmp.75 = 8;
              goto <D.24461>;
              <D.24460>:
              iftmp.75 = 0;
              <D.24461>:
              iftmp.74 = iftmp.75;
              <D.24457>:
              iftmp.72 = iftmp.74;
              goto <D.24462>;
              <D.24453>:
              iftmp.72 = 65532;
              <D.24462>:
              D.24463 = iftmp.72 >> dreg_high;
              D.24464 = D.24463 & 1;
              D.24465 = D.24464 == 0;
              D.24466 = (long int) D.24465;
              D.24467 = __builtin_expect (D.24466, 0);
              if (D.24467 != 0) goto <D.24468>; else goto <D.24469>;
              <D.24468>:
              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.24469>:
              D.24470 = 1 << dreg_high;
              val = mono_regstate_alloc_int (rs, D.24470);
              D.24431 = val < 0;
              D.24432 = (long int) D.24431;
              D.24433 = __builtin_expect (D.24432, 0);
              if (D.24433 != 0) goto <D.24471>; else goto <D.24472>;
              <D.24471>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1897, "val >= 0");
              <D.24472>:
              D.23780 = rs->vassign;
              sreg1.76 = (sizetype) sreg1;
              D.24474 = sreg1.76 + 1;
              D.24475 = D.24474 * 4;
              D.24476 = D.23780 + D.24475;
              D.24477 = *D.24476;
              if (D.24477 >= 0) goto <D.24478>; else goto <D.24479>;
              <D.24478>:
              D.23780 = rs->vassign;
              sreg1.76 = (sizetype) sreg1;
              D.24474 = sreg1.76 + 1;
              D.24475 = D.24474 * 4;
              D.24476 = D.23780 + D.24475;
              D.24477 = *D.24476;
              if (D.24477 != val) goto <D.24480>; else goto <D.24481>;
              <D.24480>:
              monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-codegen.c", 1901);
              <D.24481>:
              <D.24479>:
              D.24482 = sreg1 + 1;
              assign_reg (cfg, rs, D.24482, val, bank);
              D.23680 = cfg->verbose_level;
              D.23732 = D.23680 > 2;
              D.23733 = (long int) D.23732;
              D.23734 = __builtin_expect (D.23733, 0);
              if (D.23734 != 0) goto <D.24483>; else goto <D.24484>;
              <D.24483>:
              D.24485 = mono_regname_full (val, bank);
              D.24482 = sreg1 + 1;
              printf ("\tassigned sreg1-high %s to R%d\n", D.24485, D.24482);
              <D.24484>:
              dest_sregs[0] = -1;
            }
            <D.24409>:
            <D.24406>:
            D.24486 = sreg_fixed_masks[0];
            if (D.24486 != 0) goto <D.24487>; else goto <D.24488>;
            <D.24487>:
            D.23757 = bank != 0;
            D.23758 = (long int) D.23757;
            D.23759 = __builtin_expect (D.23758, 0);
            if (D.23759 != 0) goto <D.24489>; else goto <D.24490>;
            <D.24489>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1912, "!bank");
            <D.24490>:
            D.24493 = sregs[0];
            D.24494 = (unsigned int) D.24493;
            if (D.24494 <= 31) goto <D.24495>; else goto <D.24491>;
            <D.24495>:
            D.24493 = sregs[0];
            D.24496 = 1090453504 >> D.24493;
            D.24497 = D.24496 & 1;
            if (D.24497 != 0) goto <D.24498>; else goto <D.24491>;
            <D.24498>:
            D.24486 = sreg_fixed_masks[0];
            val = mono_regstate_alloc_int (rs, D.24486);
            if (val < 0) goto <D.24499>; else goto <D.24500>;
            <D.24499>:
            D.24486 = sreg_fixed_masks[0];
            val = get_register_spilling (cfg, bb, tmp, ins, D.24486, -1, bank);
            <D.24500>:
            mono_regstate_free_int (rs, val);
            dest_sregs[0] = val;
            goto <D.24492>;
            <D.24491>:
            D.24380 = sreg_masks[0];
            D.24486 = sreg_fixed_masks[0];
            D.24501 = D.24380 & D.24486;
            sreg_masks[0] = D.24501;
            <D.24492>:
            <D.24488>:
            D.24015 = dest_sregs[0];
            if (D.24015 != -1) goto <D.24502>; else goto <D.24503>;
            <D.24502>:
            D.24015 = dest_sregs[0];
            D.24018 = 1 << D.24015;
            sreg_masks[0] = D.24018;
            D.23780 = rs->vassign;
            D.24493 = sregs[0];
            D.24504 = (unsigned int) D.24493;
            D.24505 = D.24504 * 4;
            D.24506 = D.23780 + D.24505;
            D.24507 = *D.24506;
            D.24015 = dest_sregs[0];
            if (D.24507 != D.24015) goto <D.24508>; else goto <D.24509>;
            <D.24508>:
            D.23934 = rs->ifree_mask;
            D.24015 = dest_sregs[0];
            D.24018 = 1 << D.24015;
            D.24510 = D.23934 & D.24018;
            if (D.24510 == 0) goto <D.24511>; else goto <D.24512>;
            <D.24511>:
            D.24015 = dest_sregs[0];
            free_up_hreg (cfg, bb, tmp, ins, D.24015, 0);
            <D.24512>:
            <D.24509>:
            D.24493 = sregs[0];
            D.24494 = (unsigned int) D.24493;
            if (D.24494 <= 31) goto <D.24513>; else goto <D.24514>;
            <D.24513>:
            D.24493 = sregs[0];
            D.24496 = 1090453504 >> D.24493;
            D.24497 = D.24496 & 1;
            if (D.24497 != 0) goto <D.24515>; else goto <D.24516>;
            <D.24515>:
            {
              struct MonoInst * copy;

              D.24015 = dest_sregs[0];
              D.24493 = sregs[0];
              copy = create_copy_ins (cfg, bb, tmp, D.24015, D.24493, 0B, ip, 0);
              insert_before_ins (bb, ins, copy);
              D.24015 = dest_sregs[0];
              sregs[0] = D.24015;
            }
            <D.24516>:
            <D.24514>:
            <D.24503>:
            D.23757 = bank != 0;
            D.23758 = (long int) D.23757;
            D.23759 = __builtin_expect (D.23758, 0);
            if (D.23759 != 0) goto <D.24518>; else goto <D.24519>;
            <D.24518>:
            D.24493 = sregs[0];
            if (D.24493 < 0) goto <D.24521>; else goto <D.24524>;
            <D.24524>:
            D.24493 = sregs[0];
            D.23767 = regbank_size[bank];
            if (D.24493 >= D.23767) goto <D.24521>; else goto <D.24522>;
            <D.24521>:
            iftmp.78 = 1;
            goto <D.24523>;
            <D.24522>:
            iftmp.78 = 0;
            <D.24523>:
            iftmp.77 = (_Bool) iftmp.78;
            goto <D.24525>;
            <D.24519>:
            D.24493 = sregs[0];
            iftmp.77 = D.24493 > 31;
            <D.24525>:
            if (iftmp.77 != 0) goto <D.24526>; else goto <D.24527>;
            <D.24526>:
            D.23780 = rs->vassign;
            D.24493 = sregs[0];
            D.24504 = (unsigned int) D.24493;
            D.24505 = D.24504 * 4;
            D.24506 = D.23780 + D.24505;
            val = *D.24506;
            D.24493 = sregs[0];
            prev_sregs[0] = D.24493;
            if (val < 0) goto <D.24528>; else goto <D.24529>;
            <D.24528>:
            {
              int spill;

              spill = 0;
              if (val < -1) goto <D.24530>; else goto <D.24531>;
              <D.24530>:
              spill = ~val;
              <D.24531>:
              D.23683 = ins->opcode;
              if (D.23683 == 424) goto <D.24532>; else goto <D.24533>;
              <D.24532>:
              if (spill == 0) goto <D.24534>; else goto <D.24535>;
              <D.24534>:
              if (bank == 0) goto <D.24536>; else goto <D.24537>;
              <D.24536>:
              D.23688 = ins->dreg;
              D.24089 = (unsigned int) D.23688;
              if (D.24089 <= 31) goto <D.24538>; else goto <D.24539>;
              <D.24538>:
              D.23688 = ins->dreg;
              D.24540 = 65532 >> D.23688;
              D.24541 = D.24540 & 1;
              if (D.24541 != 0) goto <D.24542>; else goto <D.24543>;
              <D.24542>:
              D.23934 = rs->ifree_mask;
              D.23688 = ins->dreg;
              D.24286 = 1 << D.23688;
              D.24544 = D.23934 & D.24286;
              if (D.24544 != 0) goto <D.24545>; else goto <D.24546>;
              <D.24545>:
              D.23688 = ins->dreg;
              D.24286 = 1 << D.23688;
              sreg_masks[0] = D.24286;
              <D.24546>:
              <D.24543>:
              <D.24539>:
              <D.24537>:
              <D.24535>:
              <D.24533>:
              D.23849 = spec + 5;
              D.23850 = *D.23849;
              if (D.23850 == 49) goto <D.24547>; else goto <D.24548>;
              <D.24547>:
              D.23698 = *spec;
              D.23799 = (unsigned char) D.23698;
              D.23800 = D.23799 + 154;
              if (D.23800 > 1) goto <D.24549>; else goto <D.24550>;
              <D.24549>:
              D.23934 = rs->ifree_mask;
              D.23688 = ins->dreg;
              D.24286 = 1 << D.23688;
              D.24544 = D.23934 & D.24286;
              if (D.24544 != 0) goto <D.24551>; else goto <D.24552>;
              <D.24551>:
              D.23688 = ins->dreg;
              D.24286 = 1 << D.23688;
              sreg_masks[0] = D.24286;
              <D.24552>:
              <D.24550>:
              <D.24548>:
              D.24380 = sreg_masks[0];
              D.24493 = sregs[0];
              D.24493 = sregs[0];
              D.24504 = (unsigned int) D.24493;
              D.24553 = D.24504 * 12;
              D.24554 = reginfo + D.24553;
              val = alloc_reg (cfg, bb, tmp, ins, D.24380, D.24493, D.24554, bank);
              D.24493 = sregs[0];
              assign_reg (cfg, rs, D.24493, val, bank);
              D.23680 = cfg->verbose_level;
              D.23732 = D.23680 > 2;
              D.23733 = (long int) D.23732;
              D.23734 = __builtin_expect (D.23733, 0);
              if (D.23734 != 0) goto <D.24555>; else goto <D.24556>;
              <D.24555>:
              D.24557 = mono_regname_full (val, bank);
              D.24493 = sregs[0];
              printf ("\tassigned sreg1 %s to R%d\n", D.24557, D.24493);
              <D.24556>:
              if (spill != 0) goto <D.24558>; else goto <D.24559>;
              <D.24558>:
              D.24560 = prev_sregs[0];
              create_spilled_store (cfg, bb, spill, val, D.24560, tmp, 0B, ins, bank);
              <D.24559>:
            }
            goto <D.24561>;
            <D.24529>:
            D.24015 = dest_sregs[0];
            if (D.24015 != -1) goto <D.24562>; else goto <D.24563>;
            <D.24562>:
            D.24015 = dest_sregs[0];
            if (D.24015 != val) goto <D.24564>; else goto <D.24565>;
            <D.24564>:
            {
              struct MonoInst * copy;

              D.24015 = dest_sregs[0];
              copy = create_copy_ins (cfg, bb, tmp, D.24015, val, 0B, ip, bank);
              insert_before_ins (bb, ins, copy);
              j = 1;
              goto <D.23097>;
              <D.23096>:
              D.24285 = sreg_masks[j];
              D.24015 = dest_sregs[0];
              D.24018 = 1 << D.24015;
              D.24019 = ~D.24018;
              D.24566 = D.24285 & D.24019;
              sreg_masks[j] = D.24566;
              j = j + 1;
              <D.23097>:
              if (j < num_sregs) goto <D.23096>; else goto <D.23098>;
              <D.23098>:
              val = dest_sregs[0];
            }
            <D.24565>:
            <D.24563>:
            <D.24561>:
            sregs[0] = val;
            goto <D.24567>;
            <D.24527>:
            prev_sregs[0] = -1;
            <D.24567>:
            mono_inst_set_src_registers (ins, &sregs);
            j = 1;
            goto <D.23100>;
            <D.23099>:
            D.24285 = sreg_masks[j];
            D.24493 = sregs[0];
            D.24568 = 1 << D.24493;
            D.24569 = ~D.24568;
            D.24570 = D.24285 & D.24569;
            sreg_masks[j] = D.24570;
            j = j + 1;
            <D.23100>:
            if (j < num_sregs) goto <D.23099>; else goto <D.23101>;
            <D.23101>:
            if (spec_src1 == 86) goto <D.24571>; else goto <D.24573>;
            <D.24573>:
            if (spec_src1 == 108) goto <D.24571>; else goto <D.24572>;
            <D.24571>:
            D.23849 = spec + 5;
            D.23850 = *D.23849;
            if (D.23850 != 49) goto <D.24574>; else goto <D.24575>;
            <D.24574>:
            {
              int reg2;

              D.24560 = prev_sregs[0];
              reg2 = D.24560 + 1;
              D.23757 = bank != 0;
              D.23758 = (long int) D.23757;
              D.23759 = __builtin_expect (D.23758, 0);
              if (D.23759 != 0) goto <D.24576>; else goto <D.24577>;
              <D.24576>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 2000, "!bank");
              <D.24577>:
              D.24560 = prev_sregs[0];
              D.24578 = D.24560 < 0;
              D.24579 = (long int) D.24578;
              D.24580 = __builtin_expect (D.24579, 0);
              if (D.24580 != 0) goto <D.24581>; else goto <D.24582>;
              <D.24581>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 2001, "prev_sregs [0] > -1");
              <D.24582>:
              D.23780 = rs->vassign;
              D.24560 = prev_sregs[0];
              D.24586 = (unsigned int) D.24560;
              D.24587 = D.24586 * 4;
              D.24588 = D.23780 + D.24587;
              D.24589 = *D.24588;
              D.24590 = (unsigned int) D.24589;
              if (D.24590 <= 31) goto <D.24591>; else goto <D.24584>;
              <D.24591>:
              D.23780 = rs->vassign;
              D.24560 = prev_sregs[0];
              D.24586 = (unsigned int) D.24560;
              D.24587 = D.24586 * 4;
              D.24588 = D.23780 + D.24587;
              D.24589 = *D.24588;
              D.24592 = 1090453504 >> D.24589;
              D.24593 = D.24592 & 1;
              if (D.24593 != 0) goto <D.24594>; else goto <D.24584>;
              <D.24594>:
              iftmp.79 = 1;
              goto <D.24585>;
              <D.24584>:
              iftmp.79 = 0;
              <D.24585>:
              D.24595 = iftmp.79 != 0;
              D.24596 = (long int) D.24595;
              D.24597 = __builtin_expect (D.24596, 0);
              if (D.24597 != 0) goto <D.24598>; else goto <D.24599>;
              <D.24598>:
              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.24599>:
              if (spec_src1 == 108) goto <D.24602>; else goto <D.24603>;
              <D.24602>:
              D.23780 = rs->vassign;
              D.24560 = prev_sregs[0];
              D.24586 = (unsigned int) D.24560;
              D.24587 = D.24586 * 4;
              D.24588 = D.23780 + D.24587;
              D.24589 = *D.24588;
              iftmp.81 = D.24589 != -2;
              goto <D.24604>;
              <D.24603>:
              iftmp.81 = spec_src1 == 86;
              <D.24604>:
              if (iftmp.81 != 0) goto <D.24605>; else goto <D.24606>;
              <D.24605>:
              if (spec_src1 == 108) goto <D.24608>; else goto <D.24609>;
              <D.24608>:
              D.23780 = rs->vassign;
              D.24560 = prev_sregs[0];
              D.24586 = (unsigned int) D.24560;
              D.24587 = D.24586 * 4;
              D.24588 = D.23780 + D.24587;
              D.24589 = *D.24588;
              D.24610 = D.24589 + 1;
              iftmp.82 = 1 << D.24610;
              goto <D.24611>;
              <D.24609>:
              if (spec_src1 == 86) goto <D.24613>; else goto <D.24614>;
              <D.24613>:
              iftmp.83 = 8;
              goto <D.24615>;
              <D.24614>:
              iftmp.83 = 0;
              <D.24615>:
              iftmp.82 = iftmp.83;
              <D.24611>:
              iftmp.80 = iftmp.82;
              goto <D.24616>;
              <D.24606>:
              iftmp.80 = 65532;
              <D.24616>:
              mask = iftmp.80;
              D.23780 = rs->vassign;
              reg2.84 = (unsigned int) reg2;
              D.24618 = reg2.84 * 4;
              D.24619 = D.23780 + D.24618;
              val = *D.24619;
              if (val < 0) goto <D.24620>; else goto <D.24621>;
              <D.24620>:
              {
                int spill;

                spill = 0;
                if (val < -1) goto <D.24622>; else goto <D.24623>;
                <D.24622>:
                spill = ~val;
                <D.24623>:
                val = mono_regstate_alloc_int (rs, mask);
                if (val < 0) goto <D.24624>; else goto <D.24625>;
                <D.24624>:
                val = get_register_spilling (cfg, bb, tmp, ins, mask, reg2, bank);
                <D.24625>:
                if (spill != 0) goto <D.24626>; else goto <D.24627>;
                <D.24626>:
                monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-codegen.c", 2015);
                <D.24627>:
              }
              goto <D.24628>;
              <D.24621>:
              D.24172 = 1 << val;
              D.24173 = D.24172 & mask;
              if (D.24173 == 0) goto <D.24629>; else goto <D.24630>;
              <D.24629>:
              monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-codegen.c", 2021);
              <D.24630>:
              <D.24628>:
              sreg1_high = val;
              D.23680 = cfg->verbose_level;
              D.23732 = D.23680 > 2;
              D.23733 = (long int) D.23732;
              D.23734 = __builtin_expect (D.23733, 0);
              if (D.23734 != 0) goto <D.24631>; else goto <D.24632>;
              <D.24631>:
              D.24633 = mono_arch_regname (val);
              printf ("\tassigned sreg1 hreg %s to dest R%d\n", D.24633, reg2);
              <D.24632>:
              assign_reg (cfg, rs, reg2, val, bank);
            }
            <D.24575>:
            <D.24572>:
            D.23698 = *spec;
            D.23799 = (unsigned char) D.23698;
            D.23800 = D.23799 + 154;
            if (D.23800 <= 1) goto <D.24637>; else goto <D.24634>;
            <D.24637>:
            D.23888 = spec + 1;
            D.23889 = *D.23888;
            D.24402 = (unsigned char) D.23889;
            D.24403 = D.24402 + 154;
            if (D.24403 <= 1) goto <D.24635>; else goto <D.24634>;
            <D.24634>:
            D.23849 = spec + 5;
            D.23850 = *D.23849;
            if (D.23850 == 49) goto <D.24635>; else goto <D.24636>;
            <D.24635>:
            D.23688 = ins->dreg;
            D.24493 = sregs[0];
            if (D.23688 != D.24493) goto <D.24638>; else goto <D.24639>;
            <D.24638>:
            {
              struct MonoInst * sreg2_copy;
              struct MonoInst * copy;
              int bank;

              sreg2_copy = 0B;
              D.24640 = spec_src1 + 154;
              D.24641 = D.24640 <= 1;
              bank = (int) D.24641;
              D.23688 = ins->dreg;
              D.24642 = sregs[1];
              if (D.23688 == D.24642) goto <D.24643>; else goto <D.24644>;
              <D.24643>:
              {
                int reg2;

                D.24642 = sregs[1];
                reg2 = alloc_reg (cfg, bb, tmp, ins, dreg_mask, D.24642, 0B, bank);
                D.23680 = cfg->verbose_level;
                D.23732 = D.23680 > 2;
                D.23733 = (long int) D.23732;
                D.23734 = __builtin_expect (D.23733, 0);
                if (D.23734 != 0) goto <D.24645>; else goto <D.24646>;
                <D.24645>:
                D.24642 = sregs[1];
                D.24647 = mono_regname_full (D.24642, bank);
                D.24648 = mono_regname_full (reg2, bank);
                printf ("\tneed to copy sreg2 %s to reg %s\n", D.24647, D.24648);
                <D.24646>:
                D.24642 = sregs[1];
                sreg2_copy = create_copy_ins (cfg, bb, tmp, reg2, D.24642, 0B, ip, bank);
                sregs[1] = reg2;
                D.24642 = sregs[1];
                prev_sregs[1] = D.24642;
                D.24649 = bank != 0;
                D.24650 = (long int) D.24649;
                D.24651 = __builtin_expect (D.24650, 0);
                if (D.24651 != 0) goto <D.24652>; else goto <D.24653>;
                <D.24652>:
                mono_regstate_free_general (rs, reg2, bank);
                goto <D.24654>;
                <D.24653>:
                mono_regstate_free_int (rs, reg2);
                <D.24654>:
              }
              <D.24644>:
              if (spec_src1 == 86) goto <D.24655>; else goto <D.24657>;
              <D.24657>:
              if (spec_src1 == 108) goto <D.24655>; else goto <D.24656>;
              <D.24655>:
              D.23780 = rs->vassign;
              D.24560 = prev_sregs[0];
              D.24658 = (sizetype) D.24560;
              D.24659 = D.24658 + 1;
              D.24660 = D.24659 * 4;
              D.24661 = D.23780 + D.24660;
              D.24662 = *D.24661;
              D.24642 = sregs[1];
              if (D.24662 == D.24642) goto <D.24663>; else goto <D.24664>;
              <D.24663>:
              monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-codegen.c", 2067);
              <D.24664>:
              D.24493 = sregs[0];
              D.23688 = ins->dreg;
              D.24665 = D.24493 != D.23688;
              D.24666 = (long int) D.24665;
              D.24667 = __builtin_expect (D.24666, 0);
              if (D.24667 != 0) goto <D.24668>; else goto <D.24669>;
              <D.24668>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 2073, "sregs [0] == ins->dreg");
              <D.24669>:
              D.24670 = dreg_high != sreg1_high;
              D.24671 = (long int) D.24670;
              D.24672 = __builtin_expect (D.24671, 0);
              if (D.24672 != 0) goto <D.24673>; else goto <D.24674>;
              <D.24673>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 2074, "dreg_high == sreg1_high");
              <D.24674>:
              <D.24656>:
              D.23680 = cfg->verbose_level;
              D.23732 = D.23680 > 2;
              D.23733 = (long int) D.23732;
              D.23734 = __builtin_expect (D.23733, 0);
              if (D.23734 != 0) goto <D.24675>; else goto <D.24676>;
              <D.24675>:
              D.24493 = sregs[0];
              D.24677 = mono_regname_full (D.24493, bank);
              D.23688 = ins->dreg;
              D.24678 = mono_regname_full (D.23688, bank);
              printf ("\tneed to copy sreg1 %s to dreg %s\n", D.24677, D.24678);
              <D.24676>:
              D.23688 = ins->dreg;
              D.24493 = sregs[0];
              copy = create_copy_ins (cfg, bb, tmp, D.23688, D.24493, 0B, ip, bank);
              insert_before_ins (bb, ins, copy);
              if (sreg2_copy != 0B) goto <D.24679>; else goto <D.24680>;
              <D.24679>:
              insert_before_ins (bb, copy, sreg2_copy);
              <D.24680>:
              D.23902 = sreg_masks[1];
              D.24493 = sregs[0];
              D.24568 = 1 << D.24493;
              D.24569 = ~D.24568;
              D.24681 = D.23902 & D.24569;
              sreg_masks[1] = D.24681;
              D.23688 = ins->dreg;
              sregs[0] = D.23688;
              D.24493 = sregs[0];
              prev_sregs[0] = D.24493;
              D.23902 = sreg_masks[1];
              D.23688 = ins->dreg;
              D.24286 = 1 << D.23688;
              D.24287 = ~D.24286;
              D.24682 = D.23902 & D.24287;
              sreg_masks[1] = D.24682;
            }
            <D.24639>:
            <D.24636>:
            mono_inst_set_src_registers (ins, &sregs);
            j = 1;
            goto <D.23115>;
            <D.23114>:
            {
              int k;

              D.23722 = j + 1;
              D.23723 = (sizetype) D.23722;
              D.23724 = spec + D.23723;
              D.23725 = *D.23724;
              D.23748 = (unsigned char) D.23725;
              D.23749 = D.23748 + 154;
              D.23750 = D.23749 <= 1;
              bank = (int) D.23750;
              D.23722 = j + 1;
              D.23723 = (sizetype) D.23722;
              D.23724 = spec + D.23723;
              D.23725 = *D.23724;
              if (D.23725 == 86) goto <D.24683>; else goto <D.24685>;
              <D.24685>:
              D.23722 = j + 1;
              D.23723 = (sizetype) D.23722;
              D.23724 = spec + D.23723;
              D.23725 = *D.23724;
              if (D.23725 == 108) goto <D.24683>; else goto <D.24684>;
              <D.24683>:
              monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-codegen.c", 2103);
              <D.24684>:
              D.24020 = dest_sregs[j];
              if (D.24020 != -1) goto <D.24688>; else goto <D.24686>;
              <D.24688>:
              D.23709 = sregs[j];
              D.24689 = (unsigned int) D.23709;
              if (D.24689 <= 31) goto <D.24690>; else goto <D.24686>;
              <D.24690>:
              D.23709 = sregs[j];
              D.24691 = 1090453504 >> D.23709;
              D.24692 = D.24691 & 1;
              if (D.24692 != 0) goto <D.24693>; else goto <D.24686>;
              <D.24693>:
              {
                struct MonoInst * copy;

                D.24020 = dest_sregs[j];
                D.23709 = sregs[j];
                copy = create_copy_ins (cfg, bb, tmp, D.24020, D.23709, 0B, ip, 0);
                insert_before_ins (bb, ins, copy);
                D.24020 = dest_sregs[j];
                sregs[j] = D.24020;
              }
              goto <D.24687>;
              <D.24686>:
              D.23757 = bank != 0;
              D.23758 = (long int) D.23757;
              D.23759 = __builtin_expect (D.23758, 0);
              if (D.23759 != 0) goto <D.24695>; else goto <D.24696>;
              <D.24695>:
              D.23709 = sregs[j];
              if (D.23709 < 0) goto <D.24698>; else goto <D.24701>;
              <D.24701>:
              D.23709 = sregs[j];
              D.23767 = regbank_size[bank];
              if (D.23709 >= D.23767) goto <D.24698>; else goto <D.24699>;
              <D.24698>:
              iftmp.86 = 1;
              goto <D.24700>;
              <D.24699>:
              iftmp.86 = 0;
              <D.24700>:
              iftmp.85 = (_Bool) iftmp.86;
              goto <D.24702>;
              <D.24696>:
              D.23709 = sregs[j];
              iftmp.85 = D.23709 > 31;
              <D.24702>:
              if (iftmp.85 != 0) goto <D.24703>; else goto <D.24704>;
              <D.24703>:
              D.23780 = rs->vassign;
              D.23709 = sregs[j];
              D.23717 = (unsigned int) D.23709;
              D.24705 = D.23717 * 4;
              D.24706 = D.23780 + D.24705;
              val = *D.24706;
              D.24020 = dest_sregs[j];
              if (D.24020 != -1) goto <D.24707>; else goto <D.24708>;
              <D.24707>:
              if (val >= 0) goto <D.24709>; else goto <D.24710>;
              <D.24709>:
              D.24020 = dest_sregs[j];
              if (D.24020 != val) goto <D.24711>; else goto <D.24712>;
              <D.24711>:
              D.23709 = sregs[j];
              spill_vreg (cfg, bb, tmp, ins, D.23709, 0);
              D.23780 = rs->vassign;
              D.23709 = sregs[j];
              D.23717 = (unsigned int) D.23709;
              D.24705 = D.23717 * 4;
              D.24706 = D.23780 + D.24705;
              val = *D.24706;
              <D.24712>:
              <D.24710>:
              <D.24708>:
              if (val < 0) goto <D.24713>; else goto <D.24714>;
              <D.24713>:
              {
                int spill;

                spill = 0;
                if (val < -1) goto <D.24715>; else goto <D.24716>;
                <D.24715>:
                spill = ~val;
                <D.24716>:
                D.24285 = sreg_masks[j];
                D.23709 = sregs[j];
                D.23709 = sregs[j];
                D.23717 = (unsigned int) D.23709;
                D.23718 = D.23717 * 12;
                D.24717 = reginfo + D.23718;
                val = alloc_reg (cfg, bb, tmp, ins, D.24285, D.23709, D.24717, bank);
                D.23709 = sregs[j];
                assign_reg (cfg, rs, D.23709, val, bank);
                D.23680 = cfg->verbose_level;
                D.23732 = D.23680 > 2;
                D.23733 = (long int) D.23732;
                D.23734 = __builtin_expect (D.23733, 0);
                if (D.23734 != 0) goto <D.24718>; else goto <D.24719>;
                <D.24718>:
                D.23722 = j + 1;
                D.24720 = mono_regname_full (val, bank);
                D.23709 = sregs[j];
                printf ("\tassigned sreg%d %s to R%d\n", D.23722, D.24720, D.23709);
                <D.24719>:
                if (spill != 0) goto <D.24721>; else goto <D.24722>;
                <D.24721>:
                D.23709 = sregs[j];
                create_spilled_store (cfg, bb, spill, val, D.23709, tmp, 0B, ins, bank);
                <D.24722>:
              }
              <D.24714>:
              sregs[j] = val;
              k = j + 1;
              goto <D.23112>;
              <D.23111>:
              D.24723 = sreg_masks[k];
              D.23709 = sregs[j];
              D.24724 = 1 << D.23709;
              D.24725 = ~D.24724;
              D.24726 = D.24723 & D.24725;
              sreg_masks[k] = D.24726;
              k = k + 1;
              <D.23112>:
              if (k < num_sregs) goto <D.23111>; else goto <D.23113>;
              <D.23113>:
              goto <D.24727>;
              <D.24704>:
              prev_sregs[j] = -1;
              <D.24727>:
              <D.24687>:
            }
            j = j + 1;
            <D.23115>:
            if (j < num_sregs) goto <D.23114>; else goto <D.23116>;
            <D.23116>:
            mono_inst_set_src_registers (ins, &sregs);
            j = 1;
            goto <D.23124>;
            <D.23123>:
            {
              int sreg;
              int dest_sreg;

              sreg = sregs[j];
              dest_sreg = dest_sregs[j];
              if (j == 2) goto <D.24728>; else goto <D.24729>;
              <D.24728>:
              if (dest_sreg != -1) goto <D.24730>; else goto <D.24731>;
              <D.24730>:
              {
                int k;

                D.24732 = sreg != dest_sreg;
                D.24733 = (long int) D.24732;
                D.24734 = __builtin_expect (D.24733, 0);
                if (D.24734 != 0) goto <D.24735>; else goto <D.24736>;
                <D.24735>:
                monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 2163, "sreg == dest_sreg");
                <D.24736>:
                k = 0;
                goto <D.23121>;
                <D.23120>:
                if (k != j) goto <D.24737>; else goto <D.24738>;
                <D.24737>:
                D.24739 = sregs[k];
                D.24740 = D.24739 == dest_sreg;
                D.24741 = (long int) D.24740;
                D.24742 = __builtin_expect (D.24741, 0);
                if (D.24742 != 0) goto <D.24743>; else goto <D.24744>;
                <D.24743>:
                monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 2167, "sregs [k] != dest_sreg");
                <D.24744>:
                <D.24738>:
                k = k + 1;
                <D.23121>:
                if (k < num_sregs) goto <D.23120>; else goto <D.23122>;
                <D.23122>:
              }
              <D.24731>:
              <D.24729>:
            }
            j = j + 1;
            <D.23124>:
            if (j < num_sregs) goto <D.23123>; else goto <D.23125>;
            <D.23125>:
            D.23680 = cfg->verbose_level;
            D.23732 = D.23680 > 2;
            D.23733 = (long int) D.23732;
            D.23734 = __builtin_expect (D.23733, 0);
            if (D.23734 != 0) goto <D.24745>; else goto <D.24746>;
            <D.24745>:
            mono_print_ins_index (i, ins);
            <D.24746>:
          }
        finally
          {
            dest_sregs = {CLOBBER};
            prev_sregs = {CLOBBER};
            sreg_masks = {CLOBBER};
            sreg_fixed_masks = {CLOBBER};
          }
      }
      ins = prev;
      if (ins != 0B) goto <D.24748>; else goto <D.24749>;
      <D.24748>:
      iftmp.87 = ins->prev;
      goto <D.24750>;
      <D.24749>:
      iftmp.87 = 0B;
      <D.24750>:
      prev = iftmp.87;
      <D.23127>:
      if (ins != 0B) goto <D.23126>; else goto <D.23128>;
      <D.23128>:
    }
  finally
    {
      last = {CLOBBER};
      sregs = {CLOBBER};
    }
}


mono_regstate_assign (struct MonoRegState * rs)
{
  int D.24754;
  int D.24755;
  gint32 * D.24758;
  int D.24759;
  unsigned int D.24760;
  unsigned int D.24761;
  void * D.24762;
  int[32] * D.24763;
  int[32] * D.24764;

  D.24754 = rs->next_vreg;
  D.24755 = rs->vassign_size;
  if (D.24754 > D.24755) goto <D.24756>; else goto <D.24757>;
  <D.24756>:
  D.24758 = rs->vassign;
  monoeg_g_free (D.24758);
  D.24754 = rs->next_vreg;
  D.24759 = MAX_EXPR <D.24754, 256>;
  rs->vassign_size = D.24759;
  D.24755 = rs->vassign_size;
  D.24760 = (unsigned int) D.24755;
  D.24761 = D.24760 * 4;
  D.24762 = monoeg_malloc (D.24761);
  rs->vassign = D.24762;
  <D.24757>:
  D.24763 = &rs->isymbolic;
  memset (D.24763, 0, 128);
  D.24764 = &rs->fsymbolic;
  memset (D.24764, 0, 128);
  D.24763 = &rs->isymbolic;
  rs->symbolic[0] = D.24763;
  D.24764 = &rs->fsymbolic;
  rs->symbolic[1] = D.24764;
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.24767;
  int D.24772;
  void * D.24774;
  unsigned int D.24775;

  D.24767 = __builtin_constant_p (__len);
  if (D.24767 != 0) goto <D.24768>; else goto <D.24769>;
  <D.24768>:
  if (__len == 0) goto <D.24770>; else goto <D.24771>;
  <D.24770>:
  D.24772 = __builtin_constant_p (__ch);
  if (D.24772 == 0) goto <D.24765>; else goto <D.24773>;
  <D.24773>:
  if (__ch != 0) goto <D.24765>; else goto <D.24766>;
  <D.24765>:
  __warn_memset_zero_len ();
  D.24774 = __dest;
  return D.24774;
  <D.24766>:
  <D.24771>:
  <D.24769>:
  D.24775 = __builtin_object_size (__dest, 0);
  D.24774 = __builtin___memset_chk (__dest, __ch, __len, D.24775);
  return D.24774;
}


print_regtrack (struct RegTrack * t, int num)
{
  unsigned int i.88;
  unsigned int D.24778;
  struct RegTrack * D.24779;
  int D.24780;
  int D.24786;
  int i;
  char buf[32];
  const char * r;

  try
    {
      i = 0;
      goto <D.22800>;
      <D.22799>:
      i.88 = (unsigned int) i;
      D.24778 = i.88 * 12;
      D.24779 = t + D.24778;
      D.24780 = D.24779->born_in;
      if (D.24780 == 0) goto <D.24781>; else goto <D.24782>;
      <D.24781>:
      // predicted unlikely by continue predictor.
      goto <D.22798>;
      <D.24782>:
      if (i > 31) goto <D.24783>; else goto <D.24784>;
      <D.24783>:
      monoeg_g_snprintf (&buf, 32, "R%d", i);
      r = &buf;
      goto <D.24785>;
      <D.24784>:
      r = mono_arch_regname (i);
      <D.24785>:
      i.88 = (unsigned int) i;
      D.24778 = i.88 * 12;
      D.24779 = t + D.24778;
      D.24780 = D.24779->born_in;
      i.88 = (unsigned int) i;
      D.24778 = i.88 * 12;
      D.24779 = t + D.24778;
      D.24786 = D.24779->killed_in;
      printf ("liveness: %s [%d - %d]\n", r, D.24780, D.24786);
      <D.22798>:
      i = i + 1;
      <D.22800>:
      if (i < num) goto <D.22799>; else goto <D.22801>;
      <D.22801>:
    }
  finally
    {
      buf = {CLOBBER};
    }
}


get_callee_mask (const char spec)
{
  unsigned char spec.89;
  unsigned char D.24788;
  _Bool D.24789;
  long int D.24790;
  long int D.24791;
  regmask_t D.24794;
  int D.24795;

  spec.89 = (unsigned char) spec;
  D.24788 = spec.89 + 154;
  D.24789 = D.24788 <= 1;
  D.24790 = (long int) D.24789;
  D.24791 = __builtin_expect (D.24790, 0);
  if (D.24791 != 0) goto <D.24792>; else goto <D.24793>;
  <D.24792>:
  spec.89 = (unsigned char) spec;
  D.24788 = spec.89 + 154;
  D.24789 = D.24788 <= 1;
  D.24795 = (int) D.24789;
  D.24794 = regbank_callee_regs[D.24795];
  return D.24794;
  <D.24793>:
  D.24794 = 65532;
  return D.24794;
}


alloc_int_reg (struct MonoCompile * cfg, struct MonoBasicBlock * bb, struct MonoInst * * last, struct MonoInst * ins, regmask_t dest_mask, int sym_reg, struct RegTrack * info)
{
  unsigned int D.24799;
  struct MonoRegState * D.24802;
  unsigned int D.24803;
  unsigned int D.24806;
  _Bool D.24807;
  long int D.24808;
  long int D.24809;
  const char * D.24812;
  int D.24813;
  int val;

  if (info != 0B) goto <D.24797>; else goto <D.24798>;
  <D.24797>:
  D.24799 = info->preferred_mask;
  if (D.24799 != 0) goto <D.24800>; else goto <D.24801>;
  <D.24800>:
  D.24802 = cfg->rs;
  D.24799 = info->preferred_mask;
  D.24803 = D.24799 & dest_mask;
  val = mono_regstate_alloc_int (D.24802, D.24803);
  if (val >= 0) goto <D.24804>; else goto <D.24805>;
  <D.24804>:
  D.24806 = cfg->verbose_level;
  D.24807 = D.24806 > 2;
  D.24808 = (long int) D.24807;
  D.24809 = __builtin_expect (D.24808, 0);
  if (D.24809 != 0) goto <D.24810>; else goto <D.24811>;
  <D.24810>:
  D.24812 = mono_arch_regname (val);
  printf ("\tallocated preferred reg R%d to %s\n", sym_reg, D.24812);
  <D.24811>:
  D.24813 = val;
  return D.24813;
  <D.24805>:
  <D.24801>:
  <D.24798>:
  D.24802 = cfg->rs;
  val = mono_regstate_alloc_int (D.24802, dest_mask);
  if (val < 0) goto <D.24814>; else goto <D.24815>;
  <D.24814>:
  val = get_register_spilling (cfg, bb, last, ins, dest_mask, sym_reg, 0);
  <D.24815>:
  D.24813 = val;
  return D.24813;
}


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

  D.24817 = bank;
  return D.24817;
}


free_up_hreg (struct MonoCompile * cfg, struct MonoBasicBlock * bb, struct MonoInst * * last, struct MonoInst * ins, int hreg, int bank)
{
  _Bool D.24819;
  long int D.24820;
  long int D.24821;
  struct MonoRegState * D.24824;
  unsigned int D.24825;
  unsigned int D.24826;
  unsigned int D.24827;
  unsigned int D.24830;
  _Bool D.24831;
  long int D.24832;
  long int D.24833;
  int * D.24836;
  unsigned int hreg.90;
  unsigned int D.24838;
  int * D.24839;
  int D.24840;
  unsigned int D.24842;
  unsigned int D.24843;
  int D.24848;

  D.24819 = bank != 0;
  D.24820 = (long int) D.24819;
  D.24821 = __builtin_expect (D.24820, 0);
  if (D.24821 != 0) goto <D.24822>; else goto <D.24823>;
  <D.24822>:
  D.24824 = cfg->rs;
  D.24825 = D.24824->free_mask[bank];
  D.24826 = 1 << hreg;
  D.24827 = D.24825 & D.24826;
  if (D.24827 == 0) goto <D.24828>; else goto <D.24829>;
  <D.24828>:
  D.24824 = cfg->rs;
  bank = translate_bank (D.24824, bank, hreg);
  D.24830 = cfg->verbose_level;
  D.24831 = D.24830 > 2;
  D.24832 = (long int) D.24831;
  D.24833 = __builtin_expect (D.24832, 0);
  if (D.24833 != 0) goto <D.24834>; else goto <D.24835>;
  <D.24834>:
  D.24824 = cfg->rs;
  D.24836 = D.24824->symbolic[bank];
  hreg.90 = (unsigned int) hreg;
  D.24838 = hreg.90 * 4;
  D.24839 = D.24836 + D.24838;
  D.24840 = *D.24839;
  printf ("\tforced spill of R%d\n", D.24840);
  <D.24835>:
  D.24824 = cfg->rs;
  D.24836 = D.24824->symbolic[bank];
  hreg.90 = (unsigned int) hreg;
  D.24838 = hreg.90 * 4;
  D.24839 = D.24836 + D.24838;
  D.24840 = *D.24839;
  spill_vreg (cfg, bb, last, ins, D.24840, bank);
  <D.24829>:
  goto <D.24841>;
  <D.24823>:
  D.24824 = cfg->rs;
  D.24842 = D.24824->ifree_mask;
  D.24826 = 1 << hreg;
  D.24843 = D.24842 & D.24826;
  if (D.24843 == 0) goto <D.24844>; else goto <D.24845>;
  <D.24844>:
  D.24830 = cfg->verbose_level;
  D.24831 = D.24830 > 2;
  D.24832 = (long int) D.24831;
  D.24833 = __builtin_expect (D.24832, 0);
  if (D.24833 != 0) goto <D.24846>; else goto <D.24847>;
  <D.24846>:
  D.24824 = cfg->rs;
  D.24848 = D.24824->isymbolic[hreg];
  printf ("\tforced spill of R%d\n", D.24848);
  <D.24847>:
  D.24824 = cfg->rs;
  D.24848 = D.24824->isymbolic[hreg];
  spill_vreg (cfg, bb, last, ins, D.24848, bank);
  <D.24845>:
  <D.24841>:
}


mono_regstate_alloc_int (struct MonoRegState * rs, regmask_t allow)
{
  unsigned int D.24849;
  unsigned int D.24850;
  unsigned int D.24851;
  unsigned int D.24854;
  unsigned int D.24855;
  int D.24856;
  regmask_t mask;
  int i;

  D.24849 = rs->ifree_mask;
  mask = D.24849 & allow;
  i = 0;
  goto <D.22604>;
  <D.22603>:
  D.24850 = 1 << i;
  D.24851 = D.24850 & mask;
  if (D.24851 != 0) goto <D.24852>; else goto <D.24853>;
  <D.24852>:
  D.24849 = rs->ifree_mask;
  D.24850 = 1 << i;
  D.24854 = ~D.24850;
  D.24855 = D.24849 & D.24854;
  rs->ifree_mask = D.24855;
  D.24856 = i;
  return D.24856;
  <D.24853>:
  i = i + 1;
  <D.22604>:
  if (i <= 31) goto <D.22603>; else goto <D.22605>;
  <D.22605>:
  D.24856 = -1;
  return D.24856;
}


get_register_spilling (struct MonoCompile * cfg, struct MonoBasicBlock * bb, struct MonoInst * * last, struct MonoInst * ins, regmask_t regmask, int reg, int bank)
{
  _Bool D.24858;
  long int D.24859;
  long int D.24860;
  unsigned int D.24863;
  _Bool D.24864;
  long int D.24865;
  long int D.24866;
  long long unsigned int D.24869;
  int D.24870;
  int D.24871;
  int D.24872;
  int D.24873;
  short unsigned int D.24874;
  int D.24875;
  int D.24876;
  signed char D.24877;
  short unsigned int D.24880;
  sizetype D.24881;
  sizetype i.91;
  sizetype D.24883;
  sizetype D.24884;
  const char * D.24885;
  char D.24886;
  unsigned char D.24887;
  unsigned char D.24888;
  _Bool D.24889;
  int D.24890;
  int D.24893;
  _Bool D.24896;
  long int D.24897;
  long int D.24898;
  int iftmp.92;
  int iftmp.93;
  int D.24912;
  _Bool D.24914;
  unsigned int D.24918;
  unsigned int D.24919;
  unsigned int D.24920;
  _Bool D.24922;
  int iftmp.94;
  unsigned int D.24928;
  unsigned int D.24930;
  unsigned int D.24931;
  _Bool D.24933;
  int iftmp.95;
  _Bool D.24941;
  int iftmp.96;
  _Bool D.24950;
  gint32 * D.24954;
  unsigned int D.24955;
  unsigned int D.24956;
  gint32 * D.24957;
  int D.24958;
  _Bool iftmp.97;
  int iftmp.98;
  unsigned int D.24970;
  unsigned int D.24971;
  unsigned int D.24973;
  unsigned int D.24974;
  int D.24977;
  const char * D.24978;
  const char * D.24979;
  char D.24980;
  unsigned char D.24981;
  unsigned char D.24982;
  _Bool D.24983;
  int D.24984;
  _Bool iftmp.99;
  _Bool iftmp.100;
  int iftmp.101;
  int iftmp.102;
  _Bool D.25005;
  unsigned int D.25009;
  unsigned int D.25010;
  int iftmp.103;
  unsigned int D.25016;
  unsigned int D.25018;
  unsigned int D.25019;
  int iftmp.104;
  unsigned int D.25029;
  unsigned int D.25030;
  const char * D.25033;
  _Bool D.25036;
  long int D.25037;
  long int D.25038;
  unsigned int D.25043;
  unsigned int D.25044;
  struct MonoRegState * D.25047;
  const char * D.25050;
  int * D.25051;
  unsigned int sel.105;
  unsigned int D.25053;
  int * D.25054;
  int D.25055;
  int D.25056;
  int D.25057;
  unsigned int i.106;
  unsigned int D.25059;
  gint32 * D.25060;
  int D.25061;
  const char * D.25067;
  int D.25068;
  struct MonoMemPool * D.25069;
  int D.25070;
  short unsigned int D.25071;
  int D.25072;
  int D.25073;
  const unsigned char * D.25074;
  unsigned int D.25075;
  int D.25076;
  int D.25077;
  int D.25078;
  int D.25081;
  const char * D.25082;
  unsigned int D.25085;
  _Bool D.25087;
  long int D.25088;
  long int D.25089;
  int D.25092;
  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.24858 = bank > 3;
      D.24859 = (long int) D.24858;
      D.24860 = __builtin_expect (D.24859, 0);
      if (D.24860 != 0) goto <D.24861>; else goto <D.24862>;
      <D.24861>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 831, "bank < MONO_NUM_REGBANKS");
      <D.24862>:
      D.24863 = cfg->verbose_level;
      D.24864 = D.24863 > 2;
      D.24865 = (long int) D.24864;
      D.24866 = __builtin_expect (D.24865, 0);
      if (D.24866 != 0) goto <D.24867>; else goto <D.24868>;
      <D.24867>:
      D.24869 = (long long unsigned int) regmask;
      D.24870 = ins->dreg;
      D.24871 = ins->sreg1;
      D.24872 = ins->sreg2;
      D.24873 = ins->sreg3;
      printf ("\tstart regmask to assign R%d: 0x%08llu (R%d <- R%d R%d R%d)\n", reg, D.24869, D.24870, D.24871, D.24872, D.24873);
      <D.24868>:
      D.24871 = ins->sreg1;
      sregs[0] = D.24871;
      D.24872 = ins->sreg2;
      sregs[1] = D.24872;
      D.24873 = ins->sreg3;
      sregs[2] = D.24873;
      D.24874 = ins->opcode;
      D.24875 = (int) D.24874;
      D.24876 = D.24875 + -313;
      D.24877 = ins_sreg_counts[D.24876];
      num_sregs = (int) D.24877;
      i = 0;
      goto <D.22853>;
      <D.22852>:
      D.24874 = ins->opcode;
      D.24875 = (int) D.24874;
      D.24876 = D.24875 + -313;
      D.24880 = mips_desc_idx[D.24876];
      D.24881 = (sizetype) D.24880;
      i.91 = (sizetype) i;
      D.24883 = D.24881 + i.91;
      D.24884 = D.24883 + 1;
      D.24885 = &mips_desc + D.24884;
      D.24886 = *D.24885;
      D.24887 = (unsigned char) D.24886;
      D.24888 = D.24887 + 154;
      D.24889 = D.24888 <= 1;
      D.24890 = (int) D.24889;
      if (D.24890 == bank) goto <D.24891>; else goto <D.24892>;
      <D.24891>:
      D.24893 = sregs[i];
      if (D.24893 != reg) goto <D.24894>; else goto <D.24895>;
      <D.24894>:
      D.24896 = bank != 0;
      D.24897 = (long int) D.24896;
      D.24898 = __builtin_expect (D.24897, 0);
      if (D.24898 != 0) goto <D.24899>; else goto <D.24900>;
      <D.24899>:
      D.24896 = bank != 0;
      D.24897 = (long int) D.24896;
      D.24898 = __builtin_expect (D.24897, 0);
      if (D.24898 != 0) goto <D.24901>; else goto <D.24902>;
      <D.24901>:
      D.24896 = bank != 0;
      D.24897 = (long int) D.24896;
      D.24898 = __builtin_expect (D.24897, 0);
      if (D.24898 != 0) goto <D.24906>; else goto <D.24907>;
      <D.24906>:
      D.24893 = sregs[i];
      if (D.24893 >= 0) goto <D.24911>; else goto <D.24909>;
      <D.24911>:
      D.24893 = sregs[i];
      D.24912 = regbank_size[bank];
      if (D.24893 < D.24912) goto <D.24913>; else goto <D.24909>;
      <D.24913>:
      iftmp.93 = 1;
      goto <D.24910>;
      <D.24909>:
      iftmp.93 = 0;
      <D.24910>:
      D.24914 = (_Bool) iftmp.93;
      if (D.24914 != 0) goto <D.24915>; else goto <D.24904>;
      <D.24915>:
      goto <D.24916>;
      <D.24907>:
      D.24893 = sregs[i];
      if (D.24893 <= 31) goto <D.24917>; else goto <D.24904>;
      <D.24917>:
      <D.24916>:
      D.24918 = regbank_callee_regs[bank];
      D.24893 = sregs[i];
      D.24919 = D.24918 >> D.24893;
      D.24920 = D.24919 & 1;
      if (D.24920 != 0) goto <D.24921>; else goto <D.24904>;
      <D.24921>:
      iftmp.92 = 1;
      goto <D.24905>;
      <D.24904>:
      iftmp.92 = 0;
      <D.24905>:
      D.24922 = (_Bool) iftmp.92;
      if (D.24922 != 0) goto <D.24878>; else goto <D.24923>;
      <D.24923>:
      goto <D.24924>;
      <D.24902>:
      D.24893 = sregs[i];
      D.24928 = (unsigned int) D.24893;
      if (D.24928 <= 31) goto <D.24929>; else goto <D.24926>;
      <D.24929>:
      D.24893 = sregs[i];
      D.24930 = 65532 >> D.24893;
      D.24931 = D.24930 & 1;
      if (D.24931 != 0) goto <D.24932>; else goto <D.24926>;
      <D.24932>:
      iftmp.94 = 1;
      goto <D.24927>;
      <D.24926>:
      iftmp.94 = 0;
      <D.24927>:
      D.24933 = (_Bool) iftmp.94;
      if (D.24933 != 0) goto <D.24878>; else goto <D.24934>;
      <D.24934>:
      <D.24924>:
      goto <D.24935>;
      <D.24900>:
      D.24893 = sregs[i];
      D.24928 = (unsigned int) D.24893;
      if (D.24928 <= 31) goto <D.24939>; else goto <D.24937>;
      <D.24939>:
      D.24893 = sregs[i];
      D.24930 = 65532 >> D.24893;
      D.24931 = D.24930 & 1;
      if (D.24931 != 0) goto <D.24940>; else goto <D.24937>;
      <D.24940>:
      iftmp.95 = 1;
      goto <D.24938>;
      <D.24937>:
      iftmp.95 = 0;
      <D.24938>:
      D.24941 = (_Bool) iftmp.95;
      if (D.24941 != 0) goto <D.24878>; else goto <D.24942>;
      <D.24942>:
      <D.24935>:
      D.24896 = bank != 0;
      D.24897 = (long int) D.24896;
      D.24898 = __builtin_expect (D.24897, 0);
      if (D.24898 != 0) goto <D.24943>; else goto <D.24944>;
      <D.24943>:
      D.24893 = sregs[i];
      if (D.24893 < 0) goto <D.24946>; else goto <D.24949>;
      <D.24949>:
      D.24893 = sregs[i];
      D.24912 = regbank_size[bank];
      if (D.24893 >= D.24912) goto <D.24946>; else goto <D.24947>;
      <D.24946>:
      iftmp.96 = 1;
      goto <D.24948>;
      <D.24947>:
      iftmp.96 = 0;
      <D.24948>:
      D.24950 = (_Bool) iftmp.96;
      if (D.24950 != 0) goto <D.24951>; else goto <D.24879>;
      <D.24951>:
      goto <D.24952>;
      <D.24944>:
      D.24893 = sregs[i];
      if (D.24893 > 31) goto <D.24953>; else goto <D.24879>;
      <D.24953>:
      <D.24952>:
      D.24954 = rs->vassign;
      D.24893 = sregs[i];
      D.24955 = (unsigned int) D.24893;
      D.24956 = D.24955 * 4;
      D.24957 = D.24954 + D.24956;
      D.24958 = *D.24957;
      if (D.24958 >= 0) goto <D.24878>; else goto <D.24879>;
      <D.24878>:
      D.24896 = bank != 0;
      D.24897 = (long int) D.24896;
      D.24898 = __builtin_expect (D.24897, 0);
      if (D.24898 != 0) goto <D.24960>; else goto <D.24961>;
      <D.24960>:
      D.24893 = sregs[i];
      if (D.24893 < 0) goto <D.24963>; else goto <D.24966>;
      <D.24966>:
      D.24893 = sregs[i];
      D.24912 = regbank_size[bank];
      if (D.24893 >= D.24912) goto <D.24963>; else goto <D.24964>;
      <D.24963>:
      iftmp.98 = 1;
      goto <D.24965>;
      <D.24964>:
      iftmp.98 = 0;
      <D.24965>:
      iftmp.97 = (_Bool) iftmp.98;
      goto <D.24967>;
      <D.24961>:
      D.24893 = sregs[i];
      iftmp.97 = D.24893 > 31;
      <D.24967>:
      if (iftmp.97 != 0) goto <D.24968>; else goto <D.24969>;
      <D.24968>:
      D.24954 = rs->vassign;
      D.24893 = sregs[i];
      D.24955 = (unsigned int) D.24893;
      D.24956 = D.24955 * 4;
      D.24957 = D.24954 + D.24956;
      D.24958 = *D.24957;
      D.24970 = 1 << D.24958;
      D.24971 = ~D.24970;
      regmask = D.24971 & regmask;
      goto <D.24972>;
      <D.24969>:
      D.24893 = sregs[i];
      D.24973 = 1 << D.24893;
      D.24974 = ~D.24973;
      regmask = D.24974 & regmask;
      <D.24972>:
      D.24863 = cfg->verbose_level;
      D.24864 = D.24863 > 2;
      D.24865 = (long int) D.24864;
      D.24866 = __builtin_expect (D.24865, 0);
      if (D.24866 != 0) goto <D.24975>; else goto <D.24976>;
      <D.24975>:
      D.24977 = i + 1;
      D.24893 = sregs[i];
      D.24978 = mono_regname_full (D.24893, bank);
      D.24893 = sregs[i];
      printf ("\t\texcluding sreg%d %s %d\n", D.24977, D.24978, D.24893);
      <D.24976>:
      <D.24879>:
      <D.24895>:
      <D.24892>:
      i = i + 1;
      <D.22853>:
      if (i < num_sregs) goto <D.22852>; else goto <D.22854>;
      <D.22854>:
      D.24874 = ins->opcode;
      D.24875 = (int) D.24874;
      D.24876 = D.24875 + -313;
      D.24880 = mips_desc_idx[D.24876];
      D.24881 = (sizetype) D.24880;
      D.24979 = &mips_desc + D.24881;
      D.24980 = *D.24979;
      D.24981 = (unsigned char) D.24980;
      D.24982 = D.24981 + 154;
      D.24983 = D.24982 <= 1;
      D.24984 = (int) D.24983;
      if (D.24984 == bank) goto <D.24985>; else goto <D.24986>;
      <D.24985>:
      D.24870 = ins->dreg;
      if (D.24870 != reg) goto <D.24987>; else goto <D.24988>;
      <D.24987>:
      D.24896 = bank != 0;
      D.24897 = (long int) D.24896;
      D.24898 = __builtin_expect (D.24897, 0);
      if (D.24898 != 0) goto <D.24990>; else goto <D.24991>;
      <D.24990>:
      D.24896 = bank != 0;
      D.24897 = (long int) D.24896;
      D.24898 = __builtin_expect (D.24897, 0);
      if (D.24898 != 0) goto <D.24993>; else goto <D.24994>;
      <D.24993>:
      D.24896 = bank != 0;
      D.24897 = (long int) D.24896;
      D.24898 = __builtin_expect (D.24897, 0);
      if (D.24898 != 0) goto <D.24998>; else goto <D.24999>;
      <D.24998>:
      D.24870 = ins->dreg;
      if (D.24870 >= 0) goto <D.25003>; else goto <D.25001>;
      <D.25003>:
      D.24870 = ins->dreg;
      D.24912 = regbank_size[bank];
      if (D.24870 < D.24912) goto <D.25004>; else goto <D.25001>;
      <D.25004>:
      iftmp.102 = 1;
      goto <D.25002>;
      <D.25001>:
      iftmp.102 = 0;
      <D.25002>:
      D.25005 = (_Bool) iftmp.102;
      if (D.25005 != 0) goto <D.25006>; else goto <D.24996>;
      <D.25006>:
      goto <D.25007>;
      <D.24999>:
      D.24870 = ins->dreg;
      if (D.24870 <= 31) goto <D.25008>; else goto <D.24996>;
      <D.25008>:
      <D.25007>:
      D.24918 = regbank_callee_regs[bank];
      D.24870 = ins->dreg;
      D.25009 = D.24918 >> D.24870;
      D.25010 = D.25009 & 1;
      if (D.25010 != 0) goto <D.25011>; else goto <D.24996>;
      <D.25011>:
      iftmp.101 = 1;
      goto <D.24997>;
      <D.24996>:
      iftmp.101 = 0;
      <D.24997>:
      iftmp.100 = (_Bool) iftmp.101;
      goto <D.25012>;
      <D.24994>:
      D.24870 = ins->dreg;
      D.25016 = (unsigned int) D.24870;
      if (D.25016 <= 31) goto <D.25017>; else goto <D.25014>;
      <D.25017>:
      D.24870 = ins->dreg;
      D.25018 = 65532 >> D.24870;
      D.25019 = D.25018 & 1;
      if (D.25019 != 0) goto <D.25020>; else goto <D.25014>;
      <D.25020>:
      iftmp.103 = 1;
      goto <D.25015>;
      <D.25014>:
      iftmp.103 = 0;
      <D.25015>:
      iftmp.100 = (_Bool) iftmp.103;
      <D.25012>:
      iftmp.99 = iftmp.100;
      goto <D.25021>;
      <D.24991>:
      D.24870 = ins->dreg;
      D.25016 = (unsigned int) D.24870;
      if (D.25016 <= 31) goto <D.25025>; else goto <D.25023>;
      <D.25025>:
      D.24870 = ins->dreg;
      D.25018 = 65532 >> D.24870;
      D.25019 = D.25018 & 1;
      if (D.25019 != 0) goto <D.25026>; else goto <D.25023>;
      <D.25026>:
      iftmp.104 = 1;
      goto <D.25024>;
      <D.25023>:
      iftmp.104 = 0;
      <D.25024>:
      iftmp.99 = (_Bool) iftmp.104;
      <D.25021>:
      if (iftmp.99 != 0) goto <D.25027>; else goto <D.25028>;
      <D.25027>:
      D.24870 = ins->dreg;
      D.25029 = 1 << D.24870;
      D.25030 = ~D.25029;
      regmask = D.25030 & regmask;
      D.24863 = cfg->verbose_level;
      D.24864 = D.24863 > 2;
      D.24865 = (long int) D.24864;
      D.24866 = __builtin_expect (D.24865, 0);
      if (D.24866 != 0) goto <D.25031>; else goto <D.25032>;
      <D.25031>:
      D.24870 = ins->dreg;
      D.25033 = mono_regname_full (D.24870, bank);
      printf ("\t\texcluding dreg %s\n", D.25033);
      <D.25032>:
      <D.25028>:
      <D.24988>:
      <D.24986>:
      D.24863 = cfg->verbose_level;
      D.24864 = D.24863 > 2;
      D.24865 = (long int) D.24864;
      D.24866 = __builtin_expect (D.24865, 0);
      if (D.24866 != 0) goto <D.25034>; else goto <D.25035>;
      <D.25034>:
      D.24869 = (long long unsigned int) regmask;
      printf ("\t\tavailable regmask: 0x%08llu\n", D.24869);
      <D.25035>:
      D.25036 = regmask == 0;
      D.25037 = (long int) D.25036;
      D.25038 = __builtin_expect (D.25037, 0);
      if (D.25038 != 0) goto <D.25039>; else goto <D.25040>;
      <D.25039>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 851, "regmask");
      <D.25040>:
      sel = 0;
      D.24896 = bank != 0;
      D.24897 = (long int) D.24896;
      D.24898 = __builtin_expect (D.24897, 0);
      if (D.24898 != 0) goto <D.25041>; else goto <D.25042>;
      <D.25041>:
      i = 0;
      goto <D.22857>;
      <D.22856>:
      D.25043 = 1 << i;
      D.25044 = D.25043 & regmask;
      if (D.25044 != 0) goto <D.25045>; else goto <D.25046>;
      <D.25045>:
      sel = i;
      D.25047 = cfg->rs;
      bank = translate_bank (D.25047, bank, sel);
      D.24863 = cfg->verbose_level;
      D.24864 = D.24863 > 2;
      D.24865 = (long int) D.24864;
      D.24866 = __builtin_expect (D.24865, 0);
      if (D.24866 != 0) goto <D.25048>; else goto <D.25049>;
      <D.25048>:
      D.25050 = mono_regname_full (sel, bank);
      D.25051 = rs->symbolic[bank];
      sel.105 = (unsigned int) sel;
      D.25053 = sel.105 * 4;
      D.25054 = D.25051 + D.25053;
      D.25055 = *D.25054;
      printf ("\t\tselected register %s has assignment %d\n", D.25050, D.25055);
      <D.25049>:
      goto <D.22855>;
      <D.25046>:
      i = i + 1;
      <D.22857>:
      D.24912 = regbank_size[bank];
      if (D.24912 > i) goto <D.22856>; else goto <D.22855>;
      <D.22855>:
      D.25051 = rs->symbolic[bank];
      sel.105 = (unsigned int) sel;
      D.25053 = sel.105 * 4;
      D.25054 = D.25051 + D.25053;
      i = *D.25054;
      D.25056 = cfg->spill_count;
      D.25057 = D.25056 + 1;
      cfg->spill_count = D.25057;
      spill = cfg->spill_count;
      D.24954 = rs->vassign;
      i.106 = (unsigned int) i;
      D.25059 = i.106 * 4;
      D.25060 = D.24954 + D.25059;
      D.25061 = ~spill;
      *D.25060 = D.25061;
      mono_regstate_free_general (rs, sel, bank);
      goto <D.25062>;
      <D.25042>:
      i = 0;
      goto <D.22860>;
      <D.22859>:
      D.25043 = 1 << i;
      D.25044 = D.25043 & regmask;
      if (D.25044 != 0) goto <D.25063>; else goto <D.25064>;
      <D.25063>:
      sel = i;
      D.24863 = cfg->verbose_level;
      D.24864 = D.24863 > 2;
      D.24865 = (long int) D.24864;
      D.24866 = __builtin_expect (D.24865, 0);
      if (D.24866 != 0) goto <D.25065>; else goto <D.25066>;
      <D.25065>:
      D.25067 = mono_arch_regname (sel);
      D.25068 = rs->isymbolic[sel];
      printf ("\t\tselected register %s has assignment %d\n", D.25067, D.25068);
      <D.25066>:
      goto <D.22858>;
      <D.25064>:
      i = i + 1;
      <D.22860>:
      if (i <= 31) goto <D.22859>; else goto <D.22858>;
      <D.22858>:
      i = rs->isymbolic[sel];
      D.25056 = cfg->spill_count;
      D.25057 = D.25056 + 1;
      cfg->spill_count = D.25057;
      spill = cfg->spill_count;
      D.24954 = rs->vassign;
      i.106 = (unsigned int) i;
      D.25059 = i.106 * 4;
      D.25060 = D.24954 + D.25059;
      D.25061 = ~spill;
      *D.25060 = D.25061;
      mono_regstate_free_int (rs, sel);
      <D.25062>:
      D.25069 = cfg->mempool;
      load = mono_mempool_alloc0 (D.25069, 56);
      D.25070 = regbank_load_ops[bank];
      D.25071 = (short unsigned int) D.25070;
      load->opcode = D.25071;
      load->dreg = -1;
      load->sreg3 = -1;
      D.25072 = load->sreg3;
      load->sreg2 = D.25072;
      D.25073 = load->sreg2;
      load->sreg1 = D.25073;
      D.25074 = cfg->ip;
      load->cil_code = D.25074;
      load->dreg = sel;
      D.25075 = cfg->frame_reg;
      D.25076 = (int) D.25075;
      load->sreg1 = D.25076;
      D.25077 = get_vreg_bank (cfg, i, bank);
      D.25078 = mono_spillvar_offset (cfg, spill, D.25077);
      load->data.op[0].const_val = D.25078;
      insert_after_ins (bb, ins, last, load);
      D.24863 = cfg->verbose_level;
      D.24864 = D.24863 > 2;
      D.24865 = (long int) D.24864;
      D.24866 = __builtin_expect (D.24865, 0);
      if (D.24866 != 0) goto <D.25079>; else goto <D.25080>;
      <D.25079>:
      D.25081 = load->data.op[0].const_val;
      D.25082 = mono_regname_full (sel, bank);
      printf ("\tSPILLED LOAD (%d at 0x%08lx(%%ebp)) R%d (freed %s)\n", spill, D.25081, i, D.25082);
      <D.25080>:
      D.24896 = bank != 0;
      D.24897 = (long int) D.24896;
      D.24898 = __builtin_expect (D.24897, 0);
      if (D.24898 != 0) goto <D.25083>; else goto <D.25084>;
      <D.25083>:
      D.25085 = 1 << sel;
      i = mono_regstate_alloc_general (rs, D.25085, bank);
      goto <D.25086>;
      <D.25084>:
      D.25085 = 1 << sel;
      i = mono_regstate_alloc_int (rs, D.25085);
      <D.25086>:
      D.25087 = i != sel;
      D.25088 = (long int) D.25087;
      D.25089 = __builtin_expect (D.25088, 0);
      if (D.25089 != 0) goto <D.25090>; else goto <D.25091>;
      <D.25090>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 898, "i == sel");
      <D.25091>:
      D.25092 = sel;
      return D.25092;
    }
  finally
    {
      sregs = {CLOBBER};
    }
}


get_vreg_bank (struct MonoCompile * cfg, int reg, int bank)
{
  unsigned int reg.107;
  unsigned int D.25097;
  gboolean * D.25099;
  unsigned int reg.108;
  unsigned int D.25101;
  gboolean * D.25102;
  int D.25103;
  int D.25105;
  unsigned int D.25107;
  gboolean * D.25109;
  gboolean * D.25110;
  int D.25111;

  reg.107 = (unsigned int) reg;
  D.25097 = cfg->vreg_is_ref_len;
  if (reg.107 < D.25097) goto <D.25098>; else goto <D.25095>;
  <D.25098>:
  D.25099 = cfg->vreg_is_ref;
  reg.108 = (unsigned int) reg;
  D.25101 = reg.108 * 4;
  D.25102 = D.25099 + D.25101;
  D.25103 = *D.25102;
  if (D.25103 != 0) goto <D.25104>; else goto <D.25095>;
  <D.25104>:
  D.25105 = 2;
  return D.25105;
  <D.25095>:
  reg.107 = (unsigned int) reg;
  D.25107 = cfg->vreg_is_mp_len;
  if (reg.107 < D.25107) goto <D.25108>; else goto <D.25106>;
  <D.25108>:
  D.25109 = cfg->vreg_is_mp;
  reg.108 = (unsigned int) reg;
  D.25101 = reg.108 * 4;
  D.25110 = D.25109 + D.25101;
  D.25111 = *D.25110;
  if (D.25111 != 0) goto <D.25112>; else goto <D.25106>;
  <D.25112>:
  D.25105 = 3;
  return D.25105;
  <D.25106>:
  D.25105 = bank;
  return D.25105;
}


mono_spillvar_offset (struct MonoCompile * cfg, int spillvar, int bank)
{
  int D.25114;
  _Bool D.25115;
  long int D.25116;
  long int D.25117;
  struct MonoSpillInfo * D.25120;
  unsigned int spillvar.109;
  unsigned int D.25122;
  int D.25123;
  int D.25126;
  unsigned int D.25127;
  unsigned int D.25128;
  int D.25129;
  int D.25130;
  _Bool D.25131;
  long int D.25132;
  long int D.25133;
  _Bool D.25136;
  long int D.25137;
  long int D.25138;
  unsigned int D.25142;
  unsigned int D.25143;
  int D.25146;
  int D.25147;
  int D.25148;
  int D.25149;
  int D.25150;
  int D.25152;
  int D.25153;
  struct MonoSpillInfo * info;
  int size;

  D.25114 = cfg->spill_info_len[bank];
  D.25115 = D.25114 <= spillvar;
  D.25116 = (long int) D.25115;
  D.25117 = __builtin_expect (D.25116, 0);
  if (D.25117 != 0) goto <D.25118>; else goto <D.25119>;
  <D.25118>:
  goto <D.22664>;
  <D.22663>:
  resize_spill_info (cfg, bank);
  <D.22664>:
  D.25114 = cfg->spill_info_len[bank];
  if (D.25114 <= spillvar) goto <D.22663>; else goto <D.22665>;
  <D.22665>:
  <D.25119>:
  D.25120 = cfg->spill_info[bank];
  spillvar.109 = (unsigned int) spillvar;
  D.25122 = spillvar.109 * 4;
  info = D.25120 + D.25122;
  D.25123 = info->offset;
  if (D.25123 == -1) goto <D.25124>; else goto <D.25125>;
  <D.25124>:
  D.25126 = cfg->stack_offset;
  D.25127 = (unsigned int) D.25126;
  D.25128 = D.25127 + 3;
  D.25129 = (int) D.25128;
  cfg->stack_offset = D.25129;
  D.25126 = cfg->stack_offset;
  D.25130 = D.25126 & -4;
  cfg->stack_offset = D.25130;
  D.25131 = bank > 3;
  D.25132 = (long int) D.25131;
  D.25133 = __builtin_expect (D.25132, 0);
  if (D.25133 != 0) goto <D.25134>; else goto <D.25135>;
  <D.25134>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 329, "bank < MONO_NUM_REGBANKS");
  <D.25135>:
  D.25136 = bank != 0;
  D.25137 = (long int) D.25136;
  D.25138 = __builtin_expect (D.25137, 0);
  if (D.25138 != 0) goto <D.25139>; else goto <D.25140>;
  <D.25139>:
  size = regbank_spill_var_size[bank];
  goto <D.25141>;
  <D.25140>:
  size = 4;
  <D.25141>:
  D.25142 = cfg->flags;
  D.25143 = D.25142 & 64;
  if (D.25143 != 0) goto <D.25144>; else goto <D.25145>;
  <D.25144>:
  D.25126 = cfg->stack_offset;
  D.25146 = size + -1;
  D.25147 = D.25126 + D.25146;
  cfg->stack_offset = D.25147;
  D.25126 = cfg->stack_offset;
  D.25148 = -size;
  D.25149 = D.25126 & D.25148;
  cfg->stack_offset = D.25149;
  D.25126 = cfg->stack_offset;
  info->offset = D.25126;
  D.25126 = cfg->stack_offset;
  D.25150 = D.25126 + size;
  cfg->stack_offset = D.25150;
  goto <D.25151>;
  <D.25145>:
  D.25126 = cfg->stack_offset;
  D.25146 = size + -1;
  D.25147 = D.25126 + D.25146;
  cfg->stack_offset = D.25147;
  D.25126 = cfg->stack_offset;
  D.25148 = -size;
  D.25149 = D.25126 & D.25148;
  cfg->stack_offset = D.25149;
  D.25126 = cfg->stack_offset;
  D.25150 = D.25126 + size;
  cfg->stack_offset = D.25150;
  D.25126 = cfg->stack_offset;
  D.25152 = -D.25126;
  info->offset = D.25152;
  <D.25151>:
  <D.25125>:
  D.25153 = info->offset;
  return D.25153;
}


resize_spill_info (struct MonoCompile * cfg, int bank)
{
  int iftmp.110;
  _Bool D.25159;
  long int D.25160;
  long int D.25161;
  struct MonoMemPool * D.25164;
  unsigned int new_len.111;
  unsigned int D.25166;
  unsigned int orig_len.112;
  unsigned int D.25170;
  unsigned int i.113;
  unsigned int D.25172;
  struct MonoSpillInfo * D.25173;
  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.25156>; else goto <D.25157>;
  <D.25156>:
  iftmp.110 = orig_len * 2;
  goto <D.25158>;
  <D.25157>:
  iftmp.110 = 16;
  <D.25158>:
  new_len = iftmp.110;
  D.25159 = bank > 3;
  D.25160 = (long int) D.25159;
  D.25161 = __builtin_expect (D.25160, 0);
  if (D.25161 != 0) goto <D.25162>; else goto <D.25163>;
  <D.25162>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 294, "bank < MONO_NUM_REGBANKS");
  <D.25163>:
  D.25164 = cfg->mempool;
  new_len.111 = (unsigned int) new_len;
  D.25166 = new_len.111 * 4;
  new_info = mono_mempool_alloc0 (D.25164, D.25166);
  if (orig_info != 0B) goto <D.25167>; else goto <D.25168>;
  <D.25167>:
  orig_len.112 = (unsigned int) orig_len;
  D.25170 = orig_len.112 * 4;
  memcpy (new_info, orig_info, D.25170);
  <D.25168>:
  i = orig_len;
  goto <D.22654>;
  <D.22653>:
  i.113 = (unsigned int) i;
  D.25172 = i.113 * 4;
  D.25173 = new_info + D.25172;
  D.25173->offset = -1;
  i = i + 1;
  <D.22654>:
  if (i < new_len) goto <D.22653>; else goto <D.22655>;
  <D.22655>:
  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.25174;
  unsigned int D.25175;

  D.25175 = __builtin_object_size (__dest, 0);
  D.25174 = __builtin___memcpy_chk (__dest, __src, __len, D.25175);
  return D.25174;
}


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

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


mono_regstate_alloc_general (struct MonoRegState * rs, regmask_t allow, int bank)
{
  unsigned int D.25178;
  unsigned int D.25179;
  unsigned int D.25180;
  unsigned int D.25183;
  unsigned int D.25184;
  int D.25187;
  int D.25188;
  int i;
  int mirrored_bank;
  regmask_t mask;

  D.25178 = rs->free_mask[bank];
  mask = D.25178 & allow;
  i = 0;
  goto <D.22619>;
  <D.22618>:
  D.25179 = 1 << i;
  D.25180 = D.25179 & mask;
  if (D.25180 != 0) goto <D.25181>; else goto <D.25182>;
  <D.25181>:
  D.25178 = rs->free_mask[bank];
  D.25179 = 1 << i;
  D.25183 = ~D.25179;
  D.25184 = D.25178 & D.25183;
  rs->free_mask[bank] = D.25184;
  mirrored_bank = -1;
  if (mirrored_bank == -1) goto <D.25185>; else goto <D.25186>;
  <D.25185>:
  D.25187 = i;
  return D.25187;
  <D.25186>:
  D.25178 = rs->free_mask[bank];
  rs->free_mask[mirrored_bank] = D.25178;
  D.25187 = i;
  return D.25187;
  <D.25182>:
  i = i + 1;
  <D.22619>:
  D.25188 = regbank_size[bank];
  if (D.25188 > i) goto <D.22618>; else goto <D.22620>;
  <D.22620>:
  D.25187 = -1;
  return D.25187;
}


mono_regstate_free_general (struct MonoRegState * rs, int reg, int bank)
{
  unsigned int D.25192;
  unsigned int D.25193;
  unsigned int D.25194;
  int * D.25195;
  unsigned int reg.114;
  unsigned int D.25197;
  int * D.25198;
  int * D.25201;
  int * D.25202;
  int mirrored_bank;

  if (reg >= 0) goto <D.25190>; else goto <D.25191>;
  <D.25190>:
  D.25192 = rs->free_mask[bank];
  D.25193 = 1 << reg;
  D.25194 = D.25192 | D.25193;
  rs->free_mask[bank] = D.25194;
  D.25195 = rs->symbolic[bank];
  reg.114 = (unsigned int) reg;
  D.25197 = reg.114 * 4;
  D.25198 = D.25195 + D.25197;
  *D.25198 = 0;
  mirrored_bank = -1;
  if (mirrored_bank == -1) goto <D.25199>; else goto <D.25200>;
  <D.25199>:
  return;
  <D.25200>:
  D.25192 = rs->free_mask[bank];
  rs->free_mask[mirrored_bank] = D.25192;
  D.25201 = rs->symbolic[mirrored_bank];
  reg.114 = (unsigned int) reg;
  D.25197 = reg.114 * 4;
  D.25202 = D.25201 + D.25197;
  *D.25202 = 0;
  <D.25191>:
}


mono_regstate_free_int (struct MonoRegState * rs, int reg)
{
  unsigned int D.25206;
  unsigned int D.25207;
  unsigned int D.25208;

  if (reg >= 0) goto <D.25204>; else goto <D.25205>;
  <D.25204>:
  D.25206 = rs->ifree_mask;
  D.25207 = 1 << reg;
  D.25208 = D.25206 | D.25207;
  rs->ifree_mask = D.25208;
  rs->isymbolic[reg] = 0;
  <D.25205>:
}


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.25209;
  int D.25210;
  short unsigned int D.25211;
  int D.25212;
  int D.25213;
  const unsigned char * D.25214;
  unsigned int D.25217;
  _Bool D.25218;
  long int D.25219;
  long int D.25220;
  const char * D.25223;
  const char * D.25224;
  struct MonoInst * D.25225;
  struct MonoInst * copy;

  D.25209 = cfg->mempool;
  copy = mono_mempool_alloc0 (D.25209, 56);
  D.25210 = regbank_move_ops[bank];
  D.25211 = (short unsigned int) D.25210;
  copy->opcode = D.25211;
  copy->dreg = -1;
  copy->sreg3 = -1;
  D.25212 = copy->sreg3;
  copy->sreg2 = D.25212;
  D.25213 = copy->sreg2;
  copy->sreg1 = D.25213;
  D.25214 = cfg->ip;
  copy->cil_code = D.25214;
  copy->dreg = dest;
  copy->sreg1 = src;
  copy->cil_code = ip;
  if (ins != 0B) goto <D.25215>; else goto <D.25216>;
  <D.25215>:
  mono_bblock_insert_after_ins (bb, ins, copy);
  *last = copy;
  <D.25216>:
  D.25217 = cfg->verbose_level;
  D.25218 = D.25217 > 2;
  D.25219 = (long int) D.25218;
  D.25220 = __builtin_expect (D.25219, 0);
  if (D.25220 != 0) goto <D.25221>; else goto <D.25222>;
  <D.25221>:
  D.25223 = mono_regname_full (src, bank);
  D.25224 = mono_regname_full (dest, bank);
  printf ("\tforced copy from %s to %s\n", D.25223, D.25224);
  <D.25222>:
  D.25225 = copy;
  return D.25225;
}


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.25227;
  unsigned int reg.115;
  unsigned int D.25229;
  gint32 * D.25230;
  struct MonoRegState * D.25231;
  int D.25232;
  int D.25233;
  unsigned int i.116;
  unsigned int D.25235;
  gint32 * D.25236;
  int D.25237;
  _Bool D.25238;
  long int D.25239;
  long int D.25240;
  struct MonoMemPool * D.25244;
  int D.25245;
  short unsigned int D.25246;
  int D.25247;
  int D.25248;
  const unsigned char * D.25249;
  unsigned int D.25250;
  int D.25251;
  int D.25252;
  int D.25253;
  unsigned int D.25254;
  _Bool D.25255;
  long int D.25256;
  long int D.25257;
  int D.25260;
  const char * D.25261;
  unsigned int D.25264;
  _Bool D.25266;
  long int D.25267;
  long int D.25268;
  struct MonoInst * load;
  int i;
  int sel;
  int spill;
  int * symbolic;
  struct MonoRegState * rs;

  rs = cfg->rs;
  symbolic = rs->symbolic[bank];
  D.25227 = rs->vassign;
  reg.115 = (unsigned int) reg;
  D.25229 = reg.115 * 4;
  D.25230 = D.25227 + D.25229;
  sel = *D.25230;
  D.25231 = cfg->rs;
  bank = translate_bank (D.25231, bank, sel);
  i = reg;
  D.25232 = cfg->spill_count;
  D.25233 = D.25232 + 1;
  cfg->spill_count = D.25233;
  spill = cfg->spill_count;
  D.25227 = rs->vassign;
  i.116 = (unsigned int) i;
  D.25235 = i.116 * 4;
  D.25236 = D.25227 + D.25235;
  D.25237 = ~spill;
  *D.25236 = D.25237;
  D.25238 = bank != 0;
  D.25239 = (long int) D.25238;
  D.25240 = __builtin_expect (D.25239, 0);
  if (D.25240 != 0) goto <D.25241>; else goto <D.25242>;
  <D.25241>:
  mono_regstate_free_general (rs, sel, bank);
  goto <D.25243>;
  <D.25242>:
  mono_regstate_free_int (rs, sel);
  <D.25243>:
  D.25244 = cfg->mempool;
  load = mono_mempool_alloc0 (D.25244, 56);
  D.25245 = regbank_load_ops[bank];
  D.25246 = (short unsigned int) D.25245;
  load->opcode = D.25246;
  load->dreg = -1;
  load->sreg3 = -1;
  D.25247 = load->sreg3;
  load->sreg2 = D.25247;
  D.25248 = load->sreg2;
  load->sreg1 = D.25248;
  D.25249 = cfg->ip;
  load->cil_code = D.25249;
  load->dreg = sel;
  D.25250 = cfg->frame_reg;
  D.25251 = (int) D.25250;
  load->sreg1 = D.25251;
  D.25252 = get_vreg_bank (cfg, reg, bank);
  D.25253 = mono_spillvar_offset (cfg, spill, D.25252);
  load->data.op[0].const_val = D.25253;
  insert_after_ins (bb, ins, last, load);
  D.25254 = cfg->verbose_level;
  D.25255 = D.25254 > 2;
  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.25260 = load->data.op[0].const_val;
  D.25261 = mono_regname_full (sel, bank);
  printf ("SPILLED LOAD (%d at 0x%08lx(%%ebp)) R%d (freed %s)\n", spill, D.25260, i, D.25261);
  <D.25259>:
  D.25238 = bank != 0;
  D.25239 = (long int) D.25238;
  D.25240 = __builtin_expect (D.25239, 0);
  if (D.25240 != 0) goto <D.25262>; else goto <D.25263>;
  <D.25262>:
  D.25264 = 1 << sel;
  i = mono_regstate_alloc_general (rs, D.25264, bank);
  goto <D.25265>;
  <D.25263>:
  D.25264 = 1 << sel;
  i = mono_regstate_alloc_int (rs, D.25264);
  <D.25265>:
  D.25266 = i != sel;
  D.25267 = (long int) D.25266;
  D.25268 = __builtin_expect (D.25267, 0);
  if (D.25268 != 0) goto <D.25269>; else goto <D.25270>;
  <D.25269>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 807, "i == sel");
  <D.25270>:
  D.25238 = bank != 0;
  D.25239 = (long int) D.25238;
  D.25240 = __builtin_expect (D.25239, 0);
  if (D.25240 != 0) goto <D.25271>; else goto <D.25272>;
  <D.25271>:
  mono_regstate_free_general (rs, sel, bank);
  goto <D.25273>;
  <D.25272>:
  mono_regstate_free_int (rs, sel);
  <D.25273>:
}


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.25274;
  long int D.25275;
  long int D.25276;
  int D.25279;

  D.25274 = bank != 0;
  D.25275 = (long int) D.25274;
  D.25276 = __builtin_expect (D.25275, 0);
  if (D.25276 != 0) goto <D.25277>; else goto <D.25278>;
  <D.25277>:
  D.25279 = alloc_general_reg (cfg, bb, last, ins, dest_mask, sym_reg, bank);
  return D.25279;
  <D.25278>:
  D.25279 = alloc_int_reg (cfg, bb, last, ins, dest_mask, sym_reg, info);
  return D.25279;
}


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.25281;
  int D.25284;
  int val;

  D.25281 = cfg->rs;
  val = mono_regstate_alloc_general (D.25281, dest_mask, bank);
  if (val < 0) goto <D.25282>; else goto <D.25283>;
  <D.25282>:
  val = get_register_spilling (cfg, bb, last, ins, dest_mask, sym_reg, bank);
  <D.25283>:
  D.25284 = val;
  return D.25284;
}


assign_reg (struct MonoCompile * cfg, struct MonoRegState * rs, int reg, int hreg, int bank)
{
  _Bool D.25286;
  long int D.25287;
  long int D.25288;
  int D.25291;
  _Bool D.25292;
  long int D.25293;
  long int D.25294;
  _Bool D.25297;
  long int D.25298;
  long int D.25299;
  int iftmp.117;
  unsigned int hreg.118;
  unsigned int D.25307;
  unsigned int D.25308;
  _Bool D.25310;
  long int D.25311;
  long int D.25312;
  gint32 * D.25315;
  unsigned int reg.119;
  unsigned int D.25317;
  gint32 * D.25318;
  int * D.25319;
  unsigned int hreg.120;
  unsigned int D.25321;
  int * D.25322;
  unsigned int D.25323;
  unsigned int D.25324;
  unsigned int D.25325;
  unsigned int D.25326;
  int * D.25329;
  int * D.25330;
  _Bool D.25332;
  long int D.25333;
  long int D.25334;
  _Bool D.25337;
  long int D.25338;
  long int D.25339;
  int iftmp.121;
  unsigned int D.25346;
  unsigned int D.25347;
  _Bool D.25349;
  long int D.25350;
  long int D.25351;
  unsigned int D.25354;
  unsigned int D.25355;

  D.25286 = bank != 0;
  D.25287 = (long int) D.25286;
  D.25288 = __builtin_expect (D.25287, 0);
  if (D.25288 != 0) goto <D.25289>; else goto <D.25290>;
  <D.25289>:
  {
    int mirrored_bank;

    D.25291 = regbank_size[bank];
    D.25292 = D.25291 > reg;
    D.25293 = (long int) D.25292;
    D.25294 = __builtin_expect (D.25293, 0);
    if (D.25294 != 0) goto <D.25295>; else goto <D.25296>;
    <D.25295>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1040, "reg >= regbank_size [bank]");
    <D.25296>:
    D.25291 = regbank_size[bank];
    D.25297 = D.25291 <= hreg;
    D.25298 = (long int) D.25297;
    D.25299 = __builtin_expect (D.25298, 0);
    if (D.25299 != 0) goto <D.25300>; else goto <D.25301>;
    <D.25300>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1041, "hreg < regbank_size [bank]");
    <D.25301>:
    hreg.118 = (unsigned int) hreg;
    if (hreg.118 <= 31) goto <D.25306>; else goto <D.25303>;
    <D.25306>:
    D.25307 = 1431306240 >> hreg;
    D.25308 = D.25307 & 1;
    if (D.25308 != 0) goto <D.25309>; else goto <D.25303>;
    <D.25309>:
    iftmp.117 = 1;
    goto <D.25304>;
    <D.25303>:
    iftmp.117 = 0;
    <D.25304>:
    D.25310 = iftmp.117 != 0;
    D.25311 = (long int) D.25310;
    D.25312 = __builtin_expect (D.25311, 0);
    if (D.25312 != 0) goto <D.25313>; else goto <D.25314>;
    <D.25313>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1042, "! is_global_freg (hreg)");
    <D.25314>:
    D.25315 = rs->vassign;
    reg.119 = (unsigned int) reg;
    D.25317 = reg.119 * 4;
    D.25318 = D.25315 + D.25317;
    *D.25318 = hreg;
    D.25319 = rs->symbolic[bank];
    hreg.120 = (unsigned int) hreg;
    D.25321 = hreg.120 * 4;
    D.25322 = D.25319 + D.25321;
    *D.25322 = reg;
    D.25323 = rs->free_mask[bank];
    D.25324 = 1 << hreg;
    D.25325 = ~D.25324;
    D.25326 = D.25323 & D.25325;
    rs->free_mask[bank] = D.25326;
    mirrored_bank = -1;
    if (mirrored_bank == -1) goto <D.25327>; else goto <D.25328>;
    <D.25327>:
    return;
    <D.25328>:
    D.25323 = rs->free_mask[bank];
    rs->free_mask[mirrored_bank] = D.25323;
    D.25329 = rs->symbolic[mirrored_bank];
    hreg.120 = (unsigned int) hreg;
    D.25321 = hreg.120 * 4;
    D.25330 = D.25329 + D.25321;
    *D.25330 = -2;
  }
  goto <D.25331>;
  <D.25290>:
  D.25332 = reg <= 31;
  D.25333 = (long int) D.25332;
  D.25334 = __builtin_expect (D.25333, 0);
  if (D.25334 != 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", 1064, "reg >= MONO_MAX_IREGS");
  <D.25336>:
  D.25337 = hreg > 31;
  D.25338 = (long int) D.25337;
  D.25339 = __builtin_expect (D.25338, 0);
  if (D.25339 != 0) goto <D.25340>; else goto <D.25341>;
  <D.25340>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1065, "hreg < MONO_MAX_IREGS");
  <D.25341>:
  hreg.118 = (unsigned int) hreg;
  if (hreg.118 <= 31) goto <D.25345>; else goto <D.25343>;
  <D.25345>:
  D.25346 = 1090453504 >> hreg;
  D.25347 = D.25346 & 1;
  if (D.25347 != 0) goto <D.25348>; else goto <D.25343>;
  <D.25348>:
  iftmp.121 = 1;
  goto <D.25344>;
  <D.25343>:
  iftmp.121 = 0;
  <D.25344>:
  D.25349 = iftmp.121 != 0;
  D.25350 = (long int) D.25349;
  D.25351 = __builtin_expect (D.25350, 0);
  if (D.25351 != 0) goto <D.25352>; else goto <D.25353>;
  <D.25352>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1068, "! is_global_ireg (hreg)");
  <D.25353>:
  D.25315 = rs->vassign;
  reg.119 = (unsigned int) reg;
  D.25317 = reg.119 * 4;
  D.25318 = D.25315 + D.25317;
  *D.25318 = hreg;
  rs->isymbolic[hreg] = reg;
  D.25354 = rs->ifree_mask;
  D.25324 = 1 << hreg;
  D.25325 = ~D.25324;
  D.25355 = D.25354 & D.25325;
  rs->ifree_mask = D.25355;
  <D.25331>:
}


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.25357;
  int D.25358;
  short unsigned int D.25359;
  int D.25360;
  int D.25361;
  const unsigned char * D.25362;
  unsigned int D.25363;
  int D.25364;
  int D.25365;
  unsigned int D.25372;
  _Bool D.25373;
  long int D.25374;
  long int D.25375;
  const char * D.25378;
  int D.25379;
  const char * D.25380;
  unsigned int bank.122;
  unsigned int D.25382;
  unsigned int D.25385;
  unsigned int D.25386;
  _Bool D.25389;
  long int D.25390;
  long int D.25391;
  int D.25394;
  int D.25395;
  struct MonoInst * store;
  struct MonoInst * def;

  bank = get_vreg_bank (cfg, prev_reg, bank);
  D.25357 = cfg->mempool;
  store = mono_mempool_alloc0 (D.25357, 56);
  D.25358 = regbank_store_ops[bank];
  D.25359 = (short unsigned int) D.25358;
  store->opcode = D.25359;
  store->dreg = -1;
  store->sreg3 = -1;
  D.25360 = store->sreg3;
  store->sreg2 = D.25360;
  D.25361 = store->sreg2;
  store->sreg1 = D.25361;
  D.25362 = cfg->ip;
  store->cil_code = D.25362;
  store->sreg1 = reg;
  D.25363 = cfg->frame_reg;
  D.25364 = (int) D.25363;
  store->dreg = D.25364;
  D.25365 = mono_spillvar_offset (cfg, spill, bank);
  store->data.op[0].const_val = D.25365;
  if (ins != 0B) goto <D.25366>; else goto <D.25367>;
  <D.25366>:
  mono_bblock_insert_after_ins (bb, ins, store);
  *last = store;
  goto <D.25368>;
  <D.25367>:
  if (insert_before != 0B) goto <D.25369>; else goto <D.25370>;
  <D.25369>:
  insert_before_ins (bb, insert_before, store);
  goto <D.25371>;
  <D.25370>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-codegen.c", 972);
  <D.25371>:
  <D.25368>:
  D.25372 = cfg->verbose_level;
  D.25373 = D.25372 > 2;
  D.25374 = (long int) D.25373;
  D.25375 = __builtin_expect (D.25374, 0);
  if (D.25375 != 0) goto <D.25376>; else goto <D.25377>;
  <D.25376>:
  D.25378 = regbank_to_string (bank);
  D.25379 = store->data.op[0].const_val;
  D.25380 = mono_regname_full (reg, bank);
  printf ("\t%sSPILLED STORE (%d at 0x%08lx(%%ebp)) R%d (from %s)\n", D.25378, spill, D.25379, prev_reg, D.25380);
  <D.25377>:
  bank.122 = (unsigned int) bank;
  D.25382 = bank.122 + 4294967294;
  if (D.25382 <= 1) goto <D.25383>; else goto <D.25384>;
  <D.25383>:
  D.25385 = BIT_FIELD_REF <*cfg, 32, 3424>;
  D.25386 = D.25385 & 128;
  if (D.25386 != 0) goto <D.25387>; else goto <D.25388>;
  <D.25387>:
  D.25389 = prev_reg == -1;
  D.25390 = (long int) D.25389;
  D.25391 = __builtin_expect (D.25390, 0);
  if (D.25391 != 0) goto <D.25392>; else goto <D.25393>;
  <D.25392>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 977, "prev_reg != -1");
  <D.25393>:
  D.25357 = cfg->mempool;
  def = mono_mempool_alloc0 (D.25357, 56);
  def->opcode = 840;
  def->dreg = -1;
  def->sreg3 = -1;
  D.25394 = def->sreg3;
  def->sreg2 = D.25394;
  D.25395 = def->sreg2;
  def->sreg1 = D.25395;
  D.25362 = cfg->ip;
  def->cil_code = D.25362;
  def->data.op[0].const_val = spill;
  def->data.op[1].const_val = bank;
  mono_bblock_insert_after_ins (bb, store, def);
  <D.25388>:
  <D.25384>:
}


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

  if (bank == 2) goto <D.25396>; else goto <D.25397>;
  <D.25396>:
  D.25398 = "REF ";
  return D.25398;
  <D.25397>:
  if (bank == 3) goto <D.25399>; else goto <D.25400>;
  <D.25399>:
  D.25398 = "MP ";
  return D.25398;
  <D.25400>:
  D.25398 = "";
  return D.25398;
}


mono_opcode_to_cond (int opcode)
{
  CompRelation D.25402;
  const char * D.25403;

  switch (opcode) <default: <D.23224>, case 446: <D.23132>, case 447: <D.23177>, case 448: <D.23213>, case 449: <D.23166>, case 450: <D.23202>, case 451: <D.23139>, case 453: <D.23184>, case 455: <D.23173>, case 456: <D.23148>, case 458: <D.23220>, case 459: <D.23192>, case 460: <D.23209>, case 465: <D.23140>, case 467: <D.23185>, case 469: <D.23174>, case 470: <D.23149>, case 472: <D.23221>, case 473: <D.23193>, case 474: <D.23210>, case 531: <D.23136>, case 532: <D.23181>, case 533: <D.23217>, case 534: <D.23170>, case 535: <D.23206>, case 551: <D.23135>, case 552: <D.23162>, case 553: <D.23180>, case 554: <D.23155>, case 555: <D.23169>, case 556: <D.23146>, case 557: <D.23198>, case 558: <D.23216>, case 559: <D.23190>, case 560: <D.23205>, case 638: <D.23134>, case 639: <D.23179>, case 640: <D.23215>, case 641: <D.23168>, case 642: <D.23204>, case 643: <D.23144>, case 644: <D.23160>, case 645: <D.23153>, case 646: <D.23196>, case 647: <D.23188>, case 648: <D.23133>, case 649: <D.23161>, case 650: <D.23178>, case 651: <D.23154>, case 652: <D.23167>, case 653: <D.23145>, case 654: <D.23197>, case 655: <D.23214>, case 656: <D.23189>, case 657: <D.23203>, case 658: <D.23137>, case 659: <D.23163>, case 660: <D.23182>, case 661: <D.23156>, case 662: <D.23171>, case 663: <D.23147>, case 664: <D.23199>, case 665: <D.23219>, case 666: <D.23191>, case 667: <D.23207>, case 714: <D.23138>, case 715: <D.23183>, case 716: <D.23218>, case 717: <D.23172>, case 718: <D.23208>, case 719: <D.23143>, case 720: <D.23159>, case 721: <D.23152>, case 816: <D.23141>, case 817: <D.23164>, case 818: <D.23186>, case 819: <D.23157>, case 820: <D.23175>, case 821: <D.23150>, case 822: <D.23200>, case 823: <D.23222>, case 824: <D.23194>, case 825: <D.23211>, case 826: <D.23142>, case 827: <D.23165>, case 828: <D.23187>, case 829: <D.23158>, case 830: <D.23176>, case 831: <D.23151>, case 832: <D.23201>, case 833: <D.23223>, case 834: <D.23195>, case 835: <D.23212>>
  <D.23132>:
  <D.23133>:
  <D.23134>:
  <D.23135>:
  <D.23136>:
  <D.23137>:
  <D.23138>:
  <D.23139>:
  <D.23140>:
  <D.23141>:
  <D.23142>:
  D.25402 = 0;
  return D.25402;
  <D.23143>:
  <D.23144>:
  <D.23145>:
  <D.23146>:
  <D.23147>:
  <D.23148>:
  <D.23149>:
  <D.23150>:
  <D.23151>:
  D.25402 = 1;
  return D.25402;
  <D.23152>:
  <D.23153>:
  <D.23154>:
  <D.23155>:
  <D.23156>:
  <D.23157>:
  <D.23158>:
  D.25402 = 2;
  return D.25402;
  <D.23159>:
  <D.23160>:
  <D.23161>:
  <D.23162>:
  <D.23163>:
  <D.23164>:
  <D.23165>:
  D.25402 = 3;
  return D.25402;
  <D.23166>:
  <D.23167>:
  <D.23168>:
  <D.23169>:
  <D.23170>:
  <D.23171>:
  <D.23172>:
  <D.23173>:
  <D.23174>:
  <D.23175>:
  <D.23176>:
  D.25402 = 4;
  return D.25402;
  <D.23177>:
  <D.23178>:
  <D.23179>:
  <D.23180>:
  <D.23181>:
  <D.23182>:
  <D.23183>:
  <D.23184>:
  <D.23185>:
  <D.23186>:
  <D.23187>:
  D.25402 = 5;
  return D.25402;
  <D.23188>:
  <D.23189>:
  <D.23190>:
  <D.23191>:
  <D.23192>:
  <D.23193>:
  <D.23194>:
  <D.23195>:
  D.25402 = 6;
  return D.25402;
  <D.23196>:
  <D.23197>:
  <D.23198>:
  <D.23199>:
  <D.23200>:
  <D.23201>:
  D.25402 = 7;
  return D.25402;
  <D.23202>:
  <D.23203>:
  <D.23204>:
  <D.23205>:
  <D.23206>:
  <D.23207>:
  <D.23208>:
  <D.23209>:
  <D.23210>:
  <D.23211>:
  <D.23212>:
  D.25402 = 8;
  return D.25402;
  <D.23213>:
  <D.23214>:
  <D.23215>:
  <D.23216>:
  <D.23217>:
  <D.23218>:
  <D.23219>:
  <D.23220>:
  <D.23221>:
  <D.23222>:
  <D.23223>:
  D.25402 = 9;
  return D.25402;
  <D.23224>:
  D.25403 = mono_inst_name (opcode);
  printf ("%s\n", D.25403);
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-codegen.c", 2447);
  D.25402 = 0;
  return D.25402;
}


mono_negate_cond (CompRelation cond)
{
  CompRelation D.25405;

  switch (cond) <default: <D.23238>, case 0: <D.23228>, case 1: <D.23229>, case 2: <D.23230>, case 3: <D.23231>, case 4: <D.23232>, case 5: <D.23233>, case 6: <D.23234>, case 7: <D.23235>, case 8: <D.23236>, case 9: <D.23237>>
  <D.23228>:
  D.25405 = 1;
  return D.25405;
  <D.23229>:
  D.25405 = 0;
  return D.25405;
  <D.23230>:
  D.25405 = 5;
  return D.25405;
  <D.23231>:
  D.25405 = 4;
  return D.25405;
  <D.23232>:
  D.25405 = 3;
  return D.25405;
  <D.23233>:
  D.25405 = 2;
  return D.25405;
  <D.23234>:
  D.25405 = 9;
  return D.25405;
  <D.23235>:
  D.25405 = 8;
  return D.25405;
  <D.23236>:
  D.25405 = 7;
  return D.25405;
  <D.23237>:
  D.25405 = 6;
  return D.25405;
  <D.23238>:
  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.123;
  unsigned int D.25408;
  CompType D.25411;
  unsigned int D.25412;
  unsigned int D.25415;
  unsigned int D.25418;
  unsigned int D.25421;
  unsigned int D.25424;
  unsigned int D.25427;
  unsigned int D.25430;
  unsigned int D.25433;
  const char * D.25436;

  opcode.123 = (unsigned int) opcode;
  D.25408 = opcode.123 + 4294966850;
  if (D.25408 <= 4) goto <D.25409>; else goto <D.25410>;
  <D.25409>:
  D.25411 = 0;
  return D.25411;
  <D.25410>:
  opcode.123 = (unsigned int) opcode;
  D.25412 = opcode.123 + 4294966648;
  if (D.25412 <= 9) goto <D.25413>; else goto <D.25414>;
  <D.25413>:
  D.25411 = 1;
  return D.25411;
  <D.25414>:
  opcode.123 = (unsigned int) opcode;
  D.25415 = opcode.123 + 4294966658;
  if (D.25415 <= 4) goto <D.25416>; else goto <D.25417>;
  <D.25416>:
  D.25411 = 1;
  return D.25411;
  <D.25417>:
  opcode.123 = (unsigned int) opcode;
  D.25418 = opcode.123 + 4294966745;
  if (D.25418 <= 9) goto <D.25419>; else goto <D.25420>;
  <D.25419>:
  D.25411 = 0;
  return D.25411;
  <D.25420>:
  opcode.123 = (unsigned int) opcode;
  D.25421 = opcode.123 + 4294966765;
  if (D.25421 <= 4) goto <D.25422>; else goto <D.25423>;
  <D.25422>:
  D.25411 = 0;
  return D.25411;
  <D.25423>:
  opcode.123 = (unsigned int) opcode;
  D.25424 = opcode.123 + 4294966638;
  if (D.25424 <= 9) goto <D.25425>; else goto <D.25426>;
  <D.25425>:
  D.25411 = 2;
  return D.25411;
  <D.25426>:
  opcode.123 = (unsigned int) opcode;
  D.25427 = opcode.123 + 4294966582;
  if (D.25427 <= 4) goto <D.25428>; else goto <D.25429>;
  <D.25428>:
  D.25411 = 2;
  return D.25411;
  <D.25429>:
  opcode.123 = (unsigned int) opcode;
  D.25430 = opcode.123 + 4294966831;
  if (D.25430 <= 9) goto <D.25431>; else goto <D.25432>;
  <D.25431>:
  D.25411 = 1;
  return D.25411;
  <D.25432>:
  opcode.123 = (unsigned int) opcode;
  D.25433 = opcode.123 + 4294966845;
  if (D.25433 <= 9) goto <D.25434>; else goto <D.25435>;
  <D.25434>:
  switch (cmp_opcode) <default: <D.23245>, case 326: <D.23243>, case 327: <D.23244>>
  <D.23243>:
  <D.23244>:
  D.25411 = 1;
  return D.25411;
  <D.23245>:
  D.25411 = 0;
  return D.25411;
  <D.25435>:
  D.25436 = mono_inst_name (opcode);
  monoeg_g_log (0B, 4, "Unknown opcode \'%s\' in opcode_to_type", D.25436);
  <D.23246>:
  goto <D.23246>;
  D.25411 = 0;
  return D.25411;
}


mono_is_regsize_var (struct MonoType * t)
{
  unsigned int D.25438;
  unsigned int D.25439;
  gboolean D.25442;
  unsigned char D.25443;
  int D.25444;
  int D.25445;

  D.25438 = BIT_FIELD_REF <*t, 32, 32>;
  D.25439 = D.25438 & 1073741824;
  if (D.25439 != 0) goto <D.25440>; else goto <D.25441>;
  <D.25440>:
  D.25442 = 1;
  return D.25442;
  <D.25441>:
  t = mono_type_get_underlying_type (t);
  D.25443 = t->type;
  D.25444 = (int) D.25443;
  switch (D.25444) <default: <D.23269>, case 2: <D.23250>, case 3: <D.23251>, case 4: <D.23252>, case 5: <D.23253>, case 6: <D.23254>, case 7: <D.23255>, case 8: <D.23256>, case 9: <D.23257>, case 14: <D.23263>, case 15: <D.23260>, case 17: <D.23268>, case 18: <D.23264>, case 20: <D.23266>, case 21: <D.23267>, case 24: <D.23258>, case 25: <D.23259>, case 27: <D.23261>, case 28: <D.23262>, case 29: <D.23265>>
  <D.23250>:
  <D.23251>:
  <D.23252>:
  <D.23253>:
  <D.23254>:
  <D.23255>:
  <D.23256>:
  <D.23257>:
  <D.23258>:
  <D.23259>:
  <D.23260>:
  <D.23261>:
  D.25442 = 1;
  return D.25442;
  <D.23262>:
  <D.23263>:
  <D.23264>:
  <D.23265>:
  <D.23266>:
  D.25442 = 1;
  return D.25442;
  <D.23267>:
  D.25445 = mono_type_generic_inst_is_valuetype (t);
  if (D.25445 == 0) goto <D.25446>; else goto <D.25447>;
  <D.25446>:
  D.25442 = 1;
  return D.25442;
  <D.25447>:
  D.25442 = 0;
  return D.25442;
  <D.23268>:
  D.25442 = 0;
  return D.25442;
  <D.23269>:
  D.25442 = 0;
  return D.25442;
}


mono_peephole_ins (struct MonoBasicBlock * bb, struct MonoInst * ins)
{
  short unsigned int D.25449;
  int D.25450;
  int D.25451;
  int D.25454;
  int D.25455;
  struct MonoInst * D.25459;
  struct MonoInst * D.25462;
  struct MonoInst * D.25465;
  struct MonoInst * D.25468;
  int D.25471;
  int D.25472;
  short unsigned int D.25475;
  int D.25485;
  int D.25488;
  int D.25489;
  int D.25492;
  guint16 iftmp.124;
  guint16 iftmp.125;
  struct MonoInst * last_ins;

  last_ins = ins->prev;
  D.25449 = ins->opcode;
  D.25450 = (int) D.25449;
  switch (D.25450) <default: <D.25583>, case 316: <D.23285>, case 388: <D.23277>, case 389: <D.23279>, case 390: <D.23280>, case 391: <D.23281>, case 392: <D.23282>, case 393: <D.23278>, case 424: <D.23283>, case 426: <D.23284>, case 431: <D.23275>>
  <D.23275>:
  D.25451 = ins->data.op[1].const_val;
  if (D.25451 == 1) goto <D.25452>; else goto <D.25453>;
  <D.25452>:
  D.25454 = ins->dreg;
  D.25455 = ins->sreg1;
  if (D.25454 != D.25455) goto <D.25456>; else goto <D.25457>;
  <D.25456>:
  ins->opcode = 424;
  goto <D.25458>;
  <D.25457>:
  D.25459 = ins->prev;
  if (D.25459 != 0B) goto <D.25460>; else goto <D.25461>;
  <D.25460>:
  D.25459 = ins->prev;
  D.25462 = ins->next;
  D.25459->next = D.25462;
  <D.25461>:
  D.25462 = ins->next;
  if (D.25462 != 0B) goto <D.25463>; else goto <D.25464>;
  <D.25463>:
  D.25462 = ins->next;
  D.25459 = ins->prev;
  D.25462->prev = D.25459;
  <D.25464>:
  D.25465 = bb->code;
  if (D.25465 == ins) goto <D.25466>; else goto <D.25467>;
  <D.25466>:
  D.25462 = ins->next;
  bb->code = D.25462;
  <D.25467>:
  D.25468 = bb->last_ins;
  if (D.25468 == ins) goto <D.25469>; else goto <D.25470>;
  <D.25469>:
  D.25459 = ins->prev;
  bb->last_ins = D.25459;
  <D.25470>:
  ins->opcode = 316;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.25471 = ins->sreg3;
  ins->sreg2 = D.25471;
  D.25472 = ins->sreg2;
  ins->sreg1 = D.25472;
  <D.25458>:
  <D.25453>:
  goto <D.23276>;
  <D.23277>:
  <D.23278>:
  if (last_ins != 0B) goto <D.25473>; else goto <D.25474>;
  <D.25473>:
  D.25475 = last_ins->opcode;
  if (D.25475 == 838) goto <D.25476>; else goto <D.25477>;
  <D.25476>:
  last_ins = last_ins->prev;
  <D.25477>:
  <D.25474>:
  if (last_ins != 0B) goto <D.25481>; else goto <D.25482>;
  <D.25481>:
  D.25449 = ins->opcode;
  if (D.25449 == 393) goto <D.25483>; else goto <D.25478>;
  <D.25483>:
  D.25475 = last_ins->opcode;
  if (D.25475 == 377) goto <D.25479>; else goto <D.25478>;
  <D.25478>:
  D.25449 = ins->opcode;
  if (D.25449 == 388) goto <D.25484>; else goto <D.25480>;
  <D.25484>:
  D.25475 = last_ins->opcode;
  if (D.25475 == 374) goto <D.25479>; else goto <D.25480>;
  <D.25479>:
  D.25455 = ins->sreg1;
  D.25485 = last_ins->dreg;
  if (D.25455 == D.25485) goto <D.25486>; else goto <D.25487>;
  <D.25486>:
  D.25488 = ins->data.op[0].const_val;
  D.25489 = last_ins->data.op[0].const_val;
  if (D.25488 == D.25489) goto <D.25490>; else goto <D.25491>;
  <D.25490>:
  D.25454 = ins->dreg;
  D.25492 = last_ins->sreg1;
  if (D.25454 == D.25492) goto <D.25493>; else goto <D.25494>;
  <D.25493>:
  D.25459 = ins->prev;
  if (D.25459 != 0B) goto <D.25495>; else goto <D.25496>;
  <D.25495>:
  D.25459 = ins->prev;
  D.25462 = ins->next;
  D.25459->next = D.25462;
  <D.25496>:
  D.25462 = ins->next;
  if (D.25462 != 0B) goto <D.25497>; else goto <D.25498>;
  <D.25497>:
  D.25462 = ins->next;
  D.25459 = ins->prev;
  D.25462->prev = D.25459;
  <D.25498>:
  D.25465 = bb->code;
  if (D.25465 == ins) goto <D.25499>; else goto <D.25500>;
  <D.25499>:
  D.25462 = ins->next;
  bb->code = D.25462;
  <D.25500>:
  D.25468 = bb->last_ins;
  if (D.25468 == ins) goto <D.25501>; else goto <D.25502>;
  <D.25501>:
  D.25459 = ins->prev;
  bb->last_ins = D.25459;
  <D.25502>:
  ins->opcode = 316;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.25471 = ins->sreg3;
  ins->sreg2 = D.25471;
  D.25472 = ins->sreg2;
  ins->sreg1 = D.25472;
  goto <D.23276>;
  <D.25494>:
  ins->opcode = 424;
  D.25492 = last_ins->sreg1;
  ins->sreg1 = D.25492;
  <D.25491>:
  <D.25487>:
  <D.25480>:
  <D.25482>:
  if (last_ins != 0B) goto <D.25505>; else goto <D.25506>;
  <D.25505>:
  D.25475 = last_ins->opcode;
  if (D.25475 == 393) goto <D.25503>; else goto <D.25507>;
  <D.25507>:
  D.25475 = last_ins->opcode;
  if (D.25475 == 388) goto <D.25503>; else goto <D.25504>;
  <D.25503>:
  D.25455 = ins->sreg1;
  D.25485 = last_ins->dreg;
  if (D.25455 != D.25485) goto <D.25508>; else goto <D.25509>;
  <D.25508>:
  D.25455 = ins->sreg1;
  D.25492 = last_ins->sreg1;
  if (D.25455 == D.25492) goto <D.25510>; else goto <D.25511>;
  <D.25510>:
  D.25488 = ins->data.op[0].const_val;
  D.25489 = last_ins->data.op[0].const_val;
  if (D.25488 == D.25489) goto <D.25512>; else goto <D.25513>;
  <D.25512>:
  D.25454 = ins->dreg;
  D.25485 = last_ins->dreg;
  if (D.25454 == D.25485) goto <D.25514>; else goto <D.25515>;
  <D.25514>:
  D.25459 = ins->prev;
  if (D.25459 != 0B) goto <D.25516>; else goto <D.25517>;
  <D.25516>:
  D.25459 = ins->prev;
  D.25462 = ins->next;
  D.25459->next = D.25462;
  <D.25517>:
  D.25462 = ins->next;
  if (D.25462 != 0B) goto <D.25518>; else goto <D.25519>;
  <D.25518>:
  D.25462 = ins->next;
  D.25459 = ins->prev;
  D.25462->prev = D.25459;
  <D.25519>:
  D.25465 = bb->code;
  if (D.25465 == ins) goto <D.25520>; else goto <D.25521>;
  <D.25520>:
  D.25462 = ins->next;
  bb->code = D.25462;
  <D.25521>:
  D.25468 = bb->last_ins;
  if (D.25468 == ins) goto <D.25522>; else goto <D.25523>;
  <D.25522>:
  D.25459 = ins->prev;
  bb->last_ins = D.25459;
  <D.25523>:
  ins->opcode = 316;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.25471 = ins->sreg3;
  ins->sreg2 = D.25471;
  D.25472 = ins->sreg2;
  ins->sreg1 = D.25472;
  goto <D.25524>;
  <D.25515>:
  ins->opcode = 424;
  D.25485 = last_ins->dreg;
  ins->sreg1 = D.25485;
  <D.25524>:
  <D.25513>:
  <D.25511>:
  <D.25509>:
  <D.25504>:
  <D.25506>:
  goto <D.23276>;
  <D.23279>:
  <D.23280>:
  if (last_ins != 0B) goto <D.25525>; else goto <D.25526>;
  <D.25525>:
  D.25475 = last_ins->opcode;
  if (D.25475 == 375) goto <D.25527>; else goto <D.25528>;
  <D.25527>:
  D.25455 = ins->sreg1;
  D.25485 = last_ins->dreg;
  if (D.25455 == D.25485) goto <D.25529>; else goto <D.25530>;
  <D.25529>:
  D.25488 = ins->data.op[0].const_val;
  D.25489 = last_ins->data.op[0].const_val;
  if (D.25488 == D.25489) goto <D.25531>; else goto <D.25532>;
  <D.25531>:
  D.25449 = ins->opcode;
  if (D.25449 == 389) goto <D.25534>; else goto <D.25535>;
  <D.25534>:
  iftmp.124 = 580;
  goto <D.25536>;
  <D.25535>:
  iftmp.124 = 591;
  <D.25536>:
  ins->opcode = iftmp.124;
  D.25492 = last_ins->sreg1;
  ins->sreg1 = D.25492;
  <D.25532>:
  <D.25530>:
  <D.25528>:
  <D.25526>:
  goto <D.23276>;
  <D.23281>:
  <D.23282>:
  if (last_ins != 0B) goto <D.25537>; else goto <D.25538>;
  <D.25537>:
  D.25475 = last_ins->opcode;
  if (D.25475 == 376) goto <D.25539>; else goto <D.25540>;
  <D.25539>:
  D.25455 = ins->sreg1;
  D.25485 = last_ins->dreg;
  if (D.25455 == D.25485) goto <D.25541>; else goto <D.25542>;
  <D.25541>:
  D.25488 = ins->data.op[0].const_val;
  D.25489 = last_ins->data.op[0].const_val;
  if (D.25488 == D.25489) goto <D.25543>; else goto <D.25544>;
  <D.25543>:
  D.25449 = ins->opcode;
  if (D.25449 == 391) goto <D.25546>; else goto <D.25547>;
  <D.25546>:
  iftmp.125 = 581;
  goto <D.25548>;
  <D.25547>:
  iftmp.125 = 590;
  <D.25548>:
  ins->opcode = iftmp.125;
  D.25492 = last_ins->sreg1;
  ins->sreg1 = D.25492;
  <D.25544>:
  <D.25542>:
  <D.25540>:
  <D.25538>:
  goto <D.23276>;
  <D.23283>:
  <D.23284>:
  D.25454 = ins->dreg;
  D.25455 = ins->sreg1;
  if (D.25454 == D.25455) goto <D.25549>; else goto <D.25550>;
  <D.25549>:
  D.25459 = ins->prev;
  if (D.25459 != 0B) goto <D.25551>; else goto <D.25552>;
  <D.25551>:
  D.25459 = ins->prev;
  D.25462 = ins->next;
  D.25459->next = D.25462;
  <D.25552>:
  D.25462 = ins->next;
  if (D.25462 != 0B) goto <D.25553>; else goto <D.25554>;
  <D.25553>:
  D.25462 = ins->next;
  D.25459 = ins->prev;
  D.25462->prev = D.25459;
  <D.25554>:
  D.25465 = bb->code;
  if (D.25465 == ins) goto <D.25555>; else goto <D.25556>;
  <D.25555>:
  D.25462 = ins->next;
  bb->code = D.25462;
  <D.25556>:
  D.25468 = bb->last_ins;
  if (D.25468 == ins) goto <D.25557>; else goto <D.25558>;
  <D.25557>:
  D.25459 = ins->prev;
  bb->last_ins = D.25459;
  <D.25558>:
  ins->opcode = 316;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.25471 = ins->sreg3;
  ins->sreg2 = D.25471;
  D.25472 = ins->sreg2;
  ins->sreg1 = D.25472;
  goto <D.23276>;
  <D.25550>:
  if (last_ins != 0B) goto <D.25559>; else goto <D.25560>;
  <D.25559>:
  D.25475 = last_ins->opcode;
  D.25449 = ins->opcode;
  if (D.25475 == D.25449) goto <D.25561>; else goto <D.25562>;
  <D.25561>:
  D.25455 = ins->sreg1;
  D.25485 = last_ins->dreg;
  if (D.25455 == D.25485) goto <D.25563>; else goto <D.25564>;
  <D.25563>:
  D.25454 = ins->dreg;
  D.25492 = last_ins->sreg1;
  if (D.25454 == D.25492) goto <D.25565>; else goto <D.25566>;
  <D.25565>:
  D.25459 = ins->prev;
  if (D.25459 != 0B) goto <D.25567>; else goto <D.25568>;
  <D.25567>:
  D.25459 = ins->prev;
  D.25462 = ins->next;
  D.25459->next = D.25462;
  <D.25568>:
  D.25462 = ins->next;
  if (D.25462 != 0B) goto <D.25569>; else goto <D.25570>;
  <D.25569>:
  D.25462 = ins->next;
  D.25459 = ins->prev;
  D.25462->prev = D.25459;
  <D.25570>:
  D.25465 = bb->code;
  if (D.25465 == ins) goto <D.25571>; else goto <D.25572>;
  <D.25571>:
  D.25462 = ins->next;
  bb->code = D.25462;
  <D.25572>:
  D.25468 = bb->last_ins;
  if (D.25468 == ins) goto <D.25573>; else goto <D.25574>;
  <D.25573>:
  D.25459 = ins->prev;
  bb->last_ins = D.25459;
  <D.25574>:
  ins->opcode = 316;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.25471 = ins->sreg3;
  ins->sreg2 = D.25471;
  D.25472 = ins->sreg2;
  ins->sreg1 = D.25472;
  <D.25566>:
  <D.25564>:
  <D.25562>:
  <D.25560>:
  goto <D.23276>;
  <D.23285>:
  D.25459 = ins->prev;
  if (D.25459 != 0B) goto <D.25575>; else goto <D.25576>;
  <D.25575>:
  D.25459 = ins->prev;
  D.25462 = ins->next;
  D.25459->next = D.25462;
  <D.25576>:
  D.25462 = ins->next;
  if (D.25462 != 0B) goto <D.25577>; else goto <D.25578>;
  <D.25577>:
  D.25462 = ins->next;
  D.25459 = ins->prev;
  D.25462->prev = D.25459;
  <D.25578>:
  D.25465 = bb->code;
  if (D.25465 == ins) goto <D.25579>; else goto <D.25580>;
  <D.25579>:
  D.25462 = ins->next;
  bb->code = D.25462;
  <D.25580>:
  D.25468 = bb->last_ins;
  if (D.25468 == ins) goto <D.25581>; else goto <D.25582>;
  <D.25581>:
  D.25459 = ins->prev;
  bb->last_ins = D.25459;
  <D.25582>:
  ins->opcode = 316;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.25471 = ins->sreg3;
  ins->sreg2 = D.25471;
  D.25472 = ins->sreg2;
  ins->sreg1 = D.25472;
  goto <D.23276>;
  <D.25583>:
  <D.23276>:
}


mini_exception_id_by_name (const char * name)
{
  int D.23297;
  int iftmp.126;
  int D.23296;
  const char[25] * D.25587;
  unsigned char D.25588;
  int D.25589;
  unsigned char D.25590;
  int D.25591;
  const unsigned char * D.25596;
  unsigned char D.25597;
  int D.25598;
  const unsigned char * D.25599;
  unsigned char D.25600;
  int D.25601;
  const unsigned char * D.25606;
  unsigned char D.25607;
  int D.25608;
  const unsigned char * D.25609;
  unsigned char D.25610;
  int D.25611;
  const unsigned char * D.25616;
  unsigned char D.25617;
  int D.25618;
  const unsigned char * D.25619;
  unsigned char D.25620;
  int D.25621;
  int D.25625;
  int D.23306;
  int iftmp.127;
  int D.23305;
  const char[18] * D.25629;
  unsigned char D.25630;
  int D.25631;
  unsigned char D.25632;
  int D.25633;
  const unsigned char * D.25638;
  unsigned char D.25639;
  int D.25640;
  const unsigned char * D.25641;
  unsigned char D.25642;
  int D.25643;
  const unsigned char * D.25648;
  unsigned char D.25649;
  int D.25650;
  const unsigned char * D.25651;
  unsigned char D.25652;
  int D.25653;
  const unsigned char * D.25658;
  unsigned char D.25659;
  int D.25660;
  const unsigned char * D.25661;
  unsigned char D.25662;
  int D.25663;
  int D.23315;
  int iftmp.128;
  int D.23314;
  const char[20] * D.25670;
  unsigned char D.25671;
  int D.25672;
  unsigned char D.25673;
  int D.25674;
  const unsigned char * D.25679;
  unsigned char D.25680;
  int D.25681;
  const unsigned char * D.25682;
  unsigned char D.25683;
  int D.25684;
  const unsigned char * D.25689;
  unsigned char D.25690;
  int D.25691;
  const unsigned char * D.25692;
  unsigned char D.25693;
  int D.25694;
  const unsigned char * D.25699;
  unsigned char D.25700;
  int D.25701;
  const unsigned char * D.25702;
  unsigned char D.25703;
  int D.25704;
  int D.23324;
  int iftmp.129;
  int D.23323;
  const char[22] * D.25711;
  unsigned char D.25712;
  int D.25713;
  unsigned char D.25714;
  int D.25715;
  const unsigned char * D.25720;
  unsigned char D.25721;
  int D.25722;
  const unsigned char * D.25723;
  unsigned char D.25724;
  int D.25725;
  const unsigned char * D.25730;
  unsigned char D.25731;
  int D.25732;
  const unsigned char * D.25733;
  unsigned char D.25734;
  int D.25735;
  const unsigned char * D.25740;
  unsigned char D.25741;
  int D.25742;
  const unsigned char * D.25743;
  unsigned char D.25744;
  int D.25745;
  int D.23333;
  int iftmp.130;
  int D.23332;
  const char[21] * D.25752;
  unsigned char D.25753;
  int D.25754;
  unsigned char D.25755;
  int D.25756;
  const unsigned char * D.25761;
  unsigned char D.25762;
  int D.25763;
  const unsigned char * D.25764;
  unsigned char D.25765;
  int D.25766;
  const unsigned char * D.25771;
  unsigned char D.25772;
  int D.25773;
  const unsigned char * D.25774;
  unsigned char D.25775;
  int D.25776;
  const unsigned char * D.25781;
  unsigned char D.25782;
  int D.25783;
  const unsigned char * D.25784;
  unsigned char D.25785;
  int D.25786;
  int D.23342;
  int iftmp.131;
  int D.23341;
  const char[23] * D.25793;
  unsigned char D.25794;
  int D.25795;
  unsigned char D.25796;
  int D.25797;
  const unsigned char * D.25802;
  unsigned char D.25803;
  int D.25804;
  const unsigned char * D.25805;
  unsigned char D.25806;
  int D.25807;
  const unsigned char * D.25812;
  unsigned char D.25813;
  int D.25814;
  const unsigned char * D.25815;
  unsigned char D.25816;
  int D.25817;
  const unsigned char * D.25822;
  unsigned char D.25823;
  int D.25824;
  const unsigned char * D.25825;
  unsigned char D.25826;
  int D.25827;
  int D.23351;
  int iftmp.132;
  int D.23350;
  const char[27] * D.25834;
  unsigned char D.25835;
  int D.25836;
  unsigned char D.25837;
  int D.25838;
  const unsigned char * D.25843;
  unsigned char D.25844;
  int D.25845;
  const unsigned char * D.25846;
  unsigned char D.25847;
  int D.25848;
  const unsigned char * D.25853;
  unsigned char D.25854;
  int D.25855;
  const unsigned char * D.25856;
  unsigned char D.25857;
  int D.25858;
  const unsigned char * D.25863;
  unsigned char D.25864;
  int D.25865;
  const unsigned char * D.25866;
  unsigned char D.25867;
  int D.25868;
  int D.23360;
  int iftmp.133;
  int D.23359;
  const char[18] * D.25875;
  unsigned char D.25876;
  int D.25877;
  unsigned char D.25878;
  int D.25879;
  const unsigned char * D.25884;
  unsigned char D.25885;
  int D.25886;
  const unsigned char * D.25887;
  unsigned char D.25888;
  int D.25889;
  const unsigned char * D.25894;
  unsigned char D.25895;
  int D.25896;
  const unsigned char * D.25897;
  unsigned char D.25898;
  int D.25899;
  const unsigned char * D.25904;
  unsigned char D.25905;
  int D.25906;
  const unsigned char * D.25907;
  unsigned char D.25908;
  int D.25909;

  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.25587 = "IndexOutOfRangeException";
      D.25588 = MEM[(const unsigned char *)D.25587];
      D.25589 = (int) D.25588;
      D.25590 = *__s2;
      D.25591 = (int) D.25590;
      __result = D.25589 - D.25591;
      {
        if (__s2_len != 0) goto <D.25592>; else goto <D.25593>;
        <D.25592>:
        if (__result == 0) goto <D.25594>; else goto <D.25595>;
        <D.25594>:
        D.25596 = &MEM[(void *)"IndexOutOfRangeException" + 1B];
        D.25597 = *D.25596;
        D.25598 = (int) D.25597;
        D.25599 = __s2 + 1;
        D.25600 = *D.25599;
        D.25601 = (int) D.25600;
        __result = D.25598 - D.25601;
        if (__s2_len > 1) goto <D.25602>; else goto <D.25603>;
        <D.25602>:
        if (__result == 0) goto <D.25604>; else goto <D.25605>;
        <D.25604>:
        D.25606 = &MEM[(void *)"IndexOutOfRangeException" + 2B];
        D.25607 = *D.25606;
        D.25608 = (int) D.25607;
        D.25609 = __s2 + 2;
        D.25610 = *D.25609;
        D.25611 = (int) D.25610;
        __result = D.25608 - D.25611;
        if (__s2_len > 2) goto <D.25612>; else goto <D.25613>;
        <D.25612>:
        if (__result == 0) goto <D.25614>; else goto <D.25615>;
        <D.25614>:
        D.25616 = &MEM[(void *)"IndexOutOfRangeException" + 3B];
        D.25617 = *D.25616;
        D.25618 = (int) D.25617;
        D.25619 = __s2 + 3;
        D.25620 = *D.25619;
        D.25621 = (int) D.25620;
        __result = D.25618 - D.25621;
        <D.25615>:
        <D.25613>:
        <D.25605>:
        <D.25603>:
        <D.25595>:
        <D.25593>:
      }
      D.23296 = __result;
    }
    iftmp.126 = -D.23296;
    goto <D.25622>;
    <D.25586>:
    iftmp.126 = __builtin_strcmp (name, "IndexOutOfRangeException");
    <D.25622>:
    D.23297 = iftmp.126;
  }
  if (D.23297 == 0) goto <D.25623>; else goto <D.25624>;
  <D.25623>:
  D.25625 = 0;
  return D.25625;
  <D.25624>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.25629 = "OverflowException";
      D.25630 = MEM[(const unsigned char *)D.25629];
      D.25631 = (int) D.25630;
      D.25632 = *__s2;
      D.25633 = (int) D.25632;
      __result = D.25631 - D.25633;
      {
        if (__s2_len != 0) goto <D.25634>; else goto <D.25635>;
        <D.25634>:
        if (__result == 0) goto <D.25636>; else goto <D.25637>;
        <D.25636>:
        D.25638 = &MEM[(void *)"OverflowException" + 1B];
        D.25639 = *D.25638;
        D.25640 = (int) D.25639;
        D.25641 = __s2 + 1;
        D.25642 = *D.25641;
        D.25643 = (int) D.25642;
        __result = D.25640 - D.25643;
        if (__s2_len > 1) goto <D.25644>; else goto <D.25645>;
        <D.25644>:
        if (__result == 0) goto <D.25646>; else goto <D.25647>;
        <D.25646>:
        D.25648 = &MEM[(void *)"OverflowException" + 2B];
        D.25649 = *D.25648;
        D.25650 = (int) D.25649;
        D.25651 = __s2 + 2;
        D.25652 = *D.25651;
        D.25653 = (int) D.25652;
        __result = D.25650 - D.25653;
        if (__s2_len > 2) goto <D.25654>; else goto <D.25655>;
        <D.25654>:
        if (__result == 0) goto <D.25656>; else goto <D.25657>;
        <D.25656>:
        D.25658 = &MEM[(void *)"OverflowException" + 3B];
        D.25659 = *D.25658;
        D.25660 = (int) D.25659;
        D.25661 = __s2 + 3;
        D.25662 = *D.25661;
        D.25663 = (int) D.25662;
        __result = D.25660 - D.25663;
        <D.25657>:
        <D.25655>:
        <D.25647>:
        <D.25645>:
        <D.25637>:
        <D.25635>:
      }
      D.23305 = __result;
    }
    iftmp.127 = -D.23305;
    goto <D.25664>;
    <D.25628>:
    iftmp.127 = __builtin_strcmp (name, "OverflowException");
    <D.25664>:
    D.23306 = iftmp.127;
  }
  if (D.23306 == 0) goto <D.25665>; else goto <D.25666>;
  <D.25665>:
  D.25625 = 1;
  return D.25625;
  <D.25666>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.25670 = "ArithmeticException";
      D.25671 = MEM[(const unsigned char *)D.25670];
      D.25672 = (int) D.25671;
      D.25673 = *__s2;
      D.25674 = (int) D.25673;
      __result = D.25672 - D.25674;
      {
        if (__s2_len != 0) goto <D.25675>; else goto <D.25676>;
        <D.25675>:
        if (__result == 0) goto <D.25677>; else goto <D.25678>;
        <D.25677>:
        D.25679 = &MEM[(void *)"ArithmeticException" + 1B];
        D.25680 = *D.25679;
        D.25681 = (int) D.25680;
        D.25682 = __s2 + 1;
        D.25683 = *D.25682;
        D.25684 = (int) D.25683;
        __result = D.25681 - D.25684;
        if (__s2_len > 1) goto <D.25685>; else goto <D.25686>;
        <D.25685>:
        if (__result == 0) goto <D.25687>; else goto <D.25688>;
        <D.25687>:
        D.25689 = &MEM[(void *)"ArithmeticException" + 2B];
        D.25690 = *D.25689;
        D.25691 = (int) D.25690;
        D.25692 = __s2 + 2;
        D.25693 = *D.25692;
        D.25694 = (int) D.25693;
        __result = D.25691 - D.25694;
        if (__s2_len > 2) goto <D.25695>; else goto <D.25696>;
        <D.25695>:
        if (__result == 0) goto <D.25697>; else goto <D.25698>;
        <D.25697>:
        D.25699 = &MEM[(void *)"ArithmeticException" + 3B];
        D.25700 = *D.25699;
        D.25701 = (int) D.25700;
        D.25702 = __s2 + 3;
        D.25703 = *D.25702;
        D.25704 = (int) D.25703;
        __result = D.25701 - D.25704;
        <D.25698>:
        <D.25696>:
        <D.25688>:
        <D.25686>:
        <D.25678>:
        <D.25676>:
      }
      D.23314 = __result;
    }
    iftmp.128 = -D.23314;
    goto <D.25705>;
    <D.25669>:
    iftmp.128 = __builtin_strcmp (name, "ArithmeticException");
    <D.25705>:
    D.23315 = iftmp.128;
  }
  if (D.23315 == 0) goto <D.25706>; else goto <D.25707>;
  <D.25706>:
  D.25625 = 2;
  return D.25625;
  <D.25707>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.25711 = "DivideByZeroException";
      D.25712 = MEM[(const unsigned char *)D.25711];
      D.25713 = (int) D.25712;
      D.25714 = *__s2;
      D.25715 = (int) D.25714;
      __result = D.25713 - D.25715;
      {
        if (__s2_len != 0) goto <D.25716>; else goto <D.25717>;
        <D.25716>:
        if (__result == 0) goto <D.25718>; else goto <D.25719>;
        <D.25718>:
        D.25720 = &MEM[(void *)"DivideByZeroException" + 1B];
        D.25721 = *D.25720;
        D.25722 = (int) D.25721;
        D.25723 = __s2 + 1;
        D.25724 = *D.25723;
        D.25725 = (int) D.25724;
        __result = D.25722 - D.25725;
        if (__s2_len > 1) goto <D.25726>; else goto <D.25727>;
        <D.25726>:
        if (__result == 0) goto <D.25728>; else goto <D.25729>;
        <D.25728>:
        D.25730 = &MEM[(void *)"DivideByZeroException" + 2B];
        D.25731 = *D.25730;
        D.25732 = (int) D.25731;
        D.25733 = __s2 + 2;
        D.25734 = *D.25733;
        D.25735 = (int) D.25734;
        __result = D.25732 - D.25735;
        if (__s2_len > 2) goto <D.25736>; else goto <D.25737>;
        <D.25736>:
        if (__result == 0) goto <D.25738>; else goto <D.25739>;
        <D.25738>:
        D.25740 = &MEM[(void *)"DivideByZeroException" + 3B];
        D.25741 = *D.25740;
        D.25742 = (int) D.25741;
        D.25743 = __s2 + 3;
        D.25744 = *D.25743;
        D.25745 = (int) D.25744;
        __result = D.25742 - D.25745;
        <D.25739>:
        <D.25737>:
        <D.25729>:
        <D.25727>:
        <D.25719>:
        <D.25717>:
      }
      D.23323 = __result;
    }
    iftmp.129 = -D.23323;
    goto <D.25746>;
    <D.25710>:
    iftmp.129 = __builtin_strcmp (name, "DivideByZeroException");
    <D.25746>:
    D.23324 = iftmp.129;
  }
  if (D.23324 == 0) goto <D.25747>; else goto <D.25748>;
  <D.25747>:
  D.25625 = 3;
  return D.25625;
  <D.25748>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.25752 = "InvalidCastException";
      D.25753 = MEM[(const unsigned char *)D.25752];
      D.25754 = (int) D.25753;
      D.25755 = *__s2;
      D.25756 = (int) D.25755;
      __result = D.25754 - D.25756;
      {
        if (__s2_len != 0) goto <D.25757>; else goto <D.25758>;
        <D.25757>:
        if (__result == 0) goto <D.25759>; else goto <D.25760>;
        <D.25759>:
        D.25761 = &MEM[(void *)"InvalidCastException" + 1B];
        D.25762 = *D.25761;
        D.25763 = (int) D.25762;
        D.25764 = __s2 + 1;
        D.25765 = *D.25764;
        D.25766 = (int) D.25765;
        __result = D.25763 - D.25766;
        if (__s2_len > 1) goto <D.25767>; else goto <D.25768>;
        <D.25767>:
        if (__result == 0) goto <D.25769>; else goto <D.25770>;
        <D.25769>:
        D.25771 = &MEM[(void *)"InvalidCastException" + 2B];
        D.25772 = *D.25771;
        D.25773 = (int) D.25772;
        D.25774 = __s2 + 2;
        D.25775 = *D.25774;
        D.25776 = (int) D.25775;
        __result = D.25773 - D.25776;
        if (__s2_len > 2) goto <D.25777>; else goto <D.25778>;
        <D.25777>:
        if (__result == 0) goto <D.25779>; else goto <D.25780>;
        <D.25779>:
        D.25781 = &MEM[(void *)"InvalidCastException" + 3B];
        D.25782 = *D.25781;
        D.25783 = (int) D.25782;
        D.25784 = __s2 + 3;
        D.25785 = *D.25784;
        D.25786 = (int) D.25785;
        __result = D.25783 - D.25786;
        <D.25780>:
        <D.25778>:
        <D.25770>:
        <D.25768>:
        <D.25760>:
        <D.25758>:
      }
      D.23332 = __result;
    }
    iftmp.130 = -D.23332;
    goto <D.25787>;
    <D.25751>:
    iftmp.130 = __builtin_strcmp (name, "InvalidCastException");
    <D.25787>:
    D.23333 = iftmp.130;
  }
  if (D.23333 == 0) goto <D.25788>; else goto <D.25789>;
  <D.25788>:
  D.25625 = 4;
  return D.25625;
  <D.25789>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.25793 = "NullReferenceException";
      D.25794 = MEM[(const unsigned char *)D.25793];
      D.25795 = (int) D.25794;
      D.25796 = *__s2;
      D.25797 = (int) D.25796;
      __result = D.25795 - D.25797;
      {
        if (__s2_len != 0) goto <D.25798>; else goto <D.25799>;
        <D.25798>:
        if (__result == 0) goto <D.25800>; else goto <D.25801>;
        <D.25800>:
        D.25802 = &MEM[(void *)"NullReferenceException" + 1B];
        D.25803 = *D.25802;
        D.25804 = (int) D.25803;
        D.25805 = __s2 + 1;
        D.25806 = *D.25805;
        D.25807 = (int) D.25806;
        __result = D.25804 - D.25807;
        if (__s2_len > 1) goto <D.25808>; else goto <D.25809>;
        <D.25808>:
        if (__result == 0) goto <D.25810>; else goto <D.25811>;
        <D.25810>:
        D.25812 = &MEM[(void *)"NullReferenceException" + 2B];
        D.25813 = *D.25812;
        D.25814 = (int) D.25813;
        D.25815 = __s2 + 2;
        D.25816 = *D.25815;
        D.25817 = (int) D.25816;
        __result = D.25814 - D.25817;
        if (__s2_len > 2) goto <D.25818>; else goto <D.25819>;
        <D.25818>:
        if (__result == 0) goto <D.25820>; else goto <D.25821>;
        <D.25820>:
        D.25822 = &MEM[(void *)"NullReferenceException" + 3B];
        D.25823 = *D.25822;
        D.25824 = (int) D.25823;
        D.25825 = __s2 + 3;
        D.25826 = *D.25825;
        D.25827 = (int) D.25826;
        __result = D.25824 - D.25827;
        <D.25821>:
        <D.25819>:
        <D.25811>:
        <D.25809>:
        <D.25801>:
        <D.25799>:
      }
      D.23341 = __result;
    }
    iftmp.131 = -D.23341;
    goto <D.25828>;
    <D.25792>:
    iftmp.131 = __builtin_strcmp (name, "NullReferenceException");
    <D.25828>:
    D.23342 = iftmp.131;
  }
  if (D.23342 == 0) goto <D.25829>; else goto <D.25830>;
  <D.25829>:
  D.25625 = 5;
  return D.25625;
  <D.25830>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.25834 = "ArrayTypeMismatchException";
      D.25835 = MEM[(const unsigned char *)D.25834];
      D.25836 = (int) D.25835;
      D.25837 = *__s2;
      D.25838 = (int) D.25837;
      __result = D.25836 - D.25838;
      {
        if (__s2_len != 0) goto <D.25839>; else goto <D.25840>;
        <D.25839>:
        if (__result == 0) goto <D.25841>; else goto <D.25842>;
        <D.25841>:
        D.25843 = &MEM[(void *)"ArrayTypeMismatchException" + 1B];
        D.25844 = *D.25843;
        D.25845 = (int) D.25844;
        D.25846 = __s2 + 1;
        D.25847 = *D.25846;
        D.25848 = (int) D.25847;
        __result = D.25845 - D.25848;
        if (__s2_len > 1) goto <D.25849>; else goto <D.25850>;
        <D.25849>:
        if (__result == 0) goto <D.25851>; else goto <D.25852>;
        <D.25851>:
        D.25853 = &MEM[(void *)"ArrayTypeMismatchException" + 2B];
        D.25854 = *D.25853;
        D.25855 = (int) D.25854;
        D.25856 = __s2 + 2;
        D.25857 = *D.25856;
        D.25858 = (int) D.25857;
        __result = D.25855 - D.25858;
        if (__s2_len > 2) goto <D.25859>; else goto <D.25860>;
        <D.25859>:
        if (__result == 0) goto <D.25861>; else goto <D.25862>;
        <D.25861>:
        D.25863 = &MEM[(void *)"ArrayTypeMismatchException" + 3B];
        D.25864 = *D.25863;
        D.25865 = (int) D.25864;
        D.25866 = __s2 + 3;
        D.25867 = *D.25866;
        D.25868 = (int) D.25867;
        __result = D.25865 - D.25868;
        <D.25862>:
        <D.25860>:
        <D.25852>:
        <D.25850>:
        <D.25842>:
        <D.25840>:
      }
      D.23350 = __result;
    }
    iftmp.132 = -D.23350;
    goto <D.25869>;
    <D.25833>:
    iftmp.132 = __builtin_strcmp (name, "ArrayTypeMismatchException");
    <D.25869>:
    D.23351 = iftmp.132;
  }
  if (D.23351 == 0) goto <D.25870>; else goto <D.25871>;
  <D.25870>:
  D.25625 = 6;
  return D.25625;
  <D.25871>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.25875 = "ArgumentException";
      D.25876 = MEM[(const unsigned char *)D.25875];
      D.25877 = (int) D.25876;
      D.25878 = *__s2;
      D.25879 = (int) D.25878;
      __result = D.25877 - D.25879;
      {
        if (__s2_len != 0) goto <D.25880>; else goto <D.25881>;
        <D.25880>:
        if (__result == 0) goto <D.25882>; else goto <D.25883>;
        <D.25882>:
        D.25884 = &MEM[(void *)"ArgumentException" + 1B];
        D.25885 = *D.25884;
        D.25886 = (int) D.25885;
        D.25887 = __s2 + 1;
        D.25888 = *D.25887;
        D.25889 = (int) D.25888;
        __result = D.25886 - D.25889;
        if (__s2_len > 1) goto <D.25890>; else goto <D.25891>;
        <D.25890>:
        if (__result == 0) goto <D.25892>; else goto <D.25893>;
        <D.25892>:
        D.25894 = &MEM[(void *)"ArgumentException" + 2B];
        D.25895 = *D.25894;
        D.25896 = (int) D.25895;
        D.25897 = __s2 + 2;
        D.25898 = *D.25897;
        D.25899 = (int) D.25898;
        __result = D.25896 - D.25899;
        if (__s2_len > 2) goto <D.25900>; else goto <D.25901>;
        <D.25900>:
        if (__result == 0) goto <D.25902>; else goto <D.25903>;
        <D.25902>:
        D.25904 = &MEM[(void *)"ArgumentException" + 3B];
        D.25905 = *D.25904;
        D.25906 = (int) D.25905;
        D.25907 = __s2 + 3;
        D.25908 = *D.25907;
        D.25909 = (int) D.25908;
        __result = D.25906 - D.25909;
        <D.25903>:
        <D.25901>:
        <D.25893>:
        <D.25891>:
        <D.25883>:
        <D.25881>:
      }
      D.23359 = __result;
    }
    iftmp.133 = -D.23359;
    goto <D.25910>;
    <D.25874>:
    iftmp.133 = __builtin_strcmp (name, "ArgumentException");
    <D.25910>:
    D.23360 = iftmp.133;
  }
  if (D.23360 == 0) goto <D.25911>; else goto <D.25912>;
  <D.25911>:
  D.25625 = 7;
  return D.25625;
  <D.25912>:
  monoeg_g_log (0B, 4, "Unknown intrinsic exception %s\n", name);
  <D.23361>:
  goto <D.23361>;
  D.25625 = -1;
  return D.25625;
}