mono_regname_full (int reg, int bank)
{
  _Bool D.26454;
  long int D.26455;
  long int D.26456;
  unsigned int bank.0;
  unsigned int D.26460;
  const char * D.26463;
  _Bool D.26464;
  long int D.26465;
  long int D.26466;

  D.26454 = bank != 0;
  D.26455 = (long int) D.26454;
  D.26456 = __builtin_expect (D.26455, 0);
  if (D.26456 != 0) goto <D.26457>; else goto <D.26458>;
  <D.26457>:
  bank.0 = (unsigned int) bank;
  D.26460 = bank.0 + 4294967294;
  if (D.26460 <= 1) goto <D.26461>; else goto <D.26462>;
  <D.26461>:
  D.26463 = mono_arch_regname (reg);
  return D.26463;
  <D.26462>:
  D.26464 = bank != 1;
  D.26465 = (long int) D.26464;
  D.26466 = __builtin_expect (D.26465, 0);
  if (D.26466 != 0) goto <D.26467>; else goto <D.26468>;
  <D.26467>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 248, "bank == MONO_REG_DOUBLE");
  <D.26468>:
  D.26463 = mono_arch_fregname (reg);
  return D.26463;
  <D.26458>:
  D.26463 = mono_arch_regname (reg);
  return D.26463;
}


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.26471;
  unsigned int vreg.2;
  _Bool D.26473;
  long int D.26474;
  long int D.26475;
  int D.26478;
  _Bool D.26479;
  long int D.26480;
  long int D.26481;
  _Bool D.26484;
  long int D.26485;
  long int D.26486;
  unsigned int D.26489;
  int D.26490;
  unsigned int D.26491;
  unsigned int D.26492;
  struct MonoMemPool * D.26493;
  struct GSList * D.26494;
  void * regpair.3;
  struct GSList * D.26496;
  _Bool D.26498;
  long int D.26499;
  long int D.26500;
  _Bool D.26503;
  long int D.26504;
  long int D.26505;
  unsigned int D.26508;
  unsigned int D.26509;
  struct GSList * D.26510;
  struct GSList * D.26511;
  guint32 regpair;

  hreg.1 = (unsigned int) hreg;
  D.26471 = hreg.1 << 24;
  vreg.2 = (unsigned int) vreg;
  regpair = D.26471 + vreg.2;
  D.26473 = bank != 0;
  D.26474 = (long int) D.26473;
  D.26475 = __builtin_expect (D.26474, 0);
  if (D.26475 != 0) goto <D.26476>; else goto <D.26477>;
  <D.26476>:
  D.26478 = regbank_size[bank];
  D.26479 = D.26478 > vreg;
  D.26480 = (long int) D.26479;
  D.26481 = __builtin_expect (D.26480, 0);
  if (D.26481 != 0) goto <D.26482>; else goto <D.26483>;
  <D.26482>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 262, "vreg >= regbank_size [bank]");
  <D.26483>:
  D.26478 = regbank_size[bank];
  D.26484 = D.26478 <= hreg;
  D.26485 = (long int) D.26484;
  D.26486 = __builtin_expect (D.26485, 0);
  if (D.26486 != 0) goto <D.26487>; else goto <D.26488>;
  <D.26487>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 263, "hreg < regbank_size [bank]");
  <D.26488>:
  D.26489 = call->used_fregs;
  D.26490 = 1 << hreg;
  D.26491 = (unsigned int) D.26490;
  D.26492 = D.26489 | D.26491;
  call->used_fregs = D.26492;
  D.26493 = cfg->mempool;
  D.26494 = call->out_freg_args;
  regpair.3 = (void *) regpair;
  D.26496 = g_slist_append_mempool (D.26493, D.26494, regpair.3);
  call->out_freg_args = D.26496;
  goto <D.26497>;
  <D.26477>:
  D.26498 = vreg <= 15;
  D.26499 = (long int) D.26498;
  D.26500 = __builtin_expect (D.26499, 0);
  if (D.26500 != 0) goto <D.26501>; else goto <D.26502>;
  <D.26501>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 267, "vreg >= MONO_MAX_IREGS");
  <D.26502>:
  D.26503 = hreg > 15;
  D.26504 = (long int) D.26503;
  D.26505 = __builtin_expect (D.26504, 0);
  if (D.26505 != 0) goto <D.26506>; else goto <D.26507>;
  <D.26506>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 268, "hreg < MONO_MAX_IREGS");
  <D.26507>:
  D.26508 = call->used_iregs;
  D.26490 = 1 << hreg;
  D.26491 = (unsigned int) D.26490;
  D.26509 = D.26508 | D.26491;
  call->used_iregs = D.26509;
  D.26493 = cfg->mempool;
  D.26510 = call->out_ireg_args;
  regpair.3 = (void *) regpair;
  D.26511 = g_slist_append_mempool (D.26493, D.26510, regpair.3);
  call->out_ireg_args = D.26511;
  <D.26497>:
}


g_slist_append_mempool (struct MonoMemPool * mp, struct GSList * list, void * data)
{
  struct GSList * D.26514;
  struct GSList * D.26515;
  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.26512>; else goto <D.26513>;
  <D.26512>:
  last = list;
  goto <D.11112>;
  <D.11111>:
  last = last->next;
  <D.11112>:
  D.26514 = last->next;
  if (D.26514 != 0B) goto <D.11111>; else goto <D.11113>;
  <D.11113>:
  last->next = new_list;
  D.26515 = list;
  return D.26515;
  <D.26513>:
  D.26515 = new_list;
  return D.26515;
}


mono_call_inst_add_outarg_vt (struct MonoCompile * cfg, struct MonoCallInst * call, struct MonoInst * outarg_vt)
{
  struct MonoMemPool * D.26517;
  struct GSList * D.26518;
  struct GSList * D.26519;

  D.26517 = cfg->mempool;
  D.26518 = call->outarg_vts;
  D.26519 = g_slist_append_mempool (D.26517, D.26518, outarg_vt);
  call->outarg_vts = D.26519;
}


mono_print_ji (const struct MonoJumpInfo * ji)
{
  <unnamed type> D.26520;
  struct MonoJumpInfo * D.26521;
  <unnamed type> D.26522;
  const char * D.26523;
  struct MonoMethod * D.26524;
  const char * D.26525;

  D.26520 = ji->type;
  switch (D.26520) <default: <D.25765>, case 6: <D.25763>, case 35: <D.25760>>
  <D.25760>:
  {
    struct MonoJumpInfoRgctxEntry * entry;

    entry = ji->data.rgctx_entry;
    printf ("[RGCTX_FETCH ");
    D.26521 = entry->data;
    mono_print_ji (D.26521);
    D.26522 = entry->info_type;
    D.26523 = mono_rgctx_info_type_to_str (D.26522);
    printf (" - %s]", D.26523);
    goto <D.25762>;
  }
  <D.25763>:
  {
    char * s;

    D.26524 = ji->data.method;
    s = mono_method_full_name (D.26524, 1);
    printf ("[METHODCONST - %s]", s);
    monoeg_g_free (s);
    goto <D.25762>;
  }
  <D.25765>:
  D.26520 = ji->type;
  D.26525 = patch_info_str[D.26520];
  printf ("[%s]", D.26525);
  goto <D.25762>;
  <D.25762>:
}


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

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


mono_print_ins_index (int i, struct MonoInst * ins)
{
  short unsigned int D.26528;
  int D.26529;
  int D.26530;
  short unsigned int D.26531;
  sizetype D.26532;
  const char * D.26535;
  const char * D.26537;
  int D.26540;
  int D.26545;
  int D.26547;
  int D.26550;
  int D.26553;
  struct MonoBasicBlock * * D.26556;
  struct MonoBasicBlock * * D.26557;
  struct MonoBasicBlock * D.26558;
  struct MonoBasicBlock * D.26561;
  int D.26562;
  int D.26564;
  int * D.26567;
  sizetype i.4;
  sizetype D.26569;
  sizetype D.26570;
  int * D.26571;
  int D.26572;
  int D.26573;
  void * D.26574;
  int D.26575;
  char D.26576;
  int iftmp.5;
  int D.26582;
  char D.26584;
  _Bool iftmp.6;
  _Bool D.26587;
  long int D.26588;
  long int D.26589;
  int iftmp.7;
  int D.26597;
  const char * D.26612;
  const char * D.26614;
  const char * D.26616;
  const char * D.26617;
  char D.26618;
  int iftmp.8;
  int D.26624;
  char D.26626;
  _Bool iftmp.9;
  _Bool D.26629;
  long int D.26630;
  long int D.26631;
  int iftmp.10;
  int D.26639;
  const char * D.26649;
  const char * D.26651;
  signed char D.26652;
  int iftmp.11;
  int D.26656;
  int D.26658;
  sizetype D.26659;
  const char * D.26660;
  char D.26661;
  char D.26662;
  _Bool iftmp.12;
  _Bool D.26665;
  long int D.26666;
  long int D.26667;
  int iftmp.13;
  int D.26674;
  int D.26676;
  const char * D.26681;
  int D.26682;
  void * D.26683;
  int D.26684;
  long long int D.26685;
  double D.26686;
  float D.26687;
  double D.26688;
  short unsigned int D.26689;
  struct MonoMethod * D.26694;
  unsigned char D.26698;
  unsigned char D.26699;
  const void * D.26703;
  const char * D.26708;
  void * D.26709;
  unsigned int D.26710;
  int regpair.14;
  const char * D.26712;
  struct GSList * iftmp.15;
  struct MonoBasicBlock * D.26717;
  int D.26718;
  const char * D.26722;
  char D.26723;
  int D.26726;
  const char * spec;
  int num_sregs;
  int j;
  int sregs[3];

  try
    {
      D.26528 = ins->opcode;
      D.26529 = (int) D.26528;
      D.26530 = D.26529 + -313;
      D.26531 = arm_cpu_desc_idx[D.26530];
      D.26532 = (sizetype) D.26531;
      spec = &arm_cpu_desc + D.26532;
      if (i != -1) goto <D.26533>; else goto <D.26534>;
      <D.26533>:
      D.26528 = ins->opcode;
      D.26529 = (int) D.26528;
      D.26535 = mono_inst_name (D.26529);
      printf ("\t%-2d %s", i, D.26535);
      goto <D.26536>;
      <D.26534>:
      D.26528 = ins->opcode;
      D.26529 = (int) D.26528;
      D.26537 = mono_inst_name (D.26529);
      printf (" %s", D.26537);
      <D.26536>:
      if (spec == &arm_cpu_desc) goto <D.26538>; else goto <D.26539>;
      <D.26538>:
      {
        gboolean dest_base;

        dest_base = 0;
        D.26528 = ins->opcode;
        D.26529 = (int) D.26528;
        switch (D.26529) <default: <D.25777>, case 387: <D.25775>>
        <D.25775>:
        dest_base = 1;
        goto <D.25776>;
        <D.25777>:
        goto <D.25776>;
        <D.25776>:
        D.26540 = ins->dreg;
        if (D.26540 != -1) goto <D.26541>; else goto <D.26542>;
        <D.26541>:
        if (dest_base != 0) goto <D.26543>; else goto <D.26544>;
        <D.26543>:
        D.26540 = ins->dreg;
        D.26545 = ins->data.op[0].const_val;
        printf (" [R%d + 0x%lx] <-", D.26540, D.26545);
        goto <D.26546>;
        <D.26544>:
        D.26540 = ins->dreg;
        printf (" R%d <-", D.26540);
        <D.26546>:
        <D.26542>:
        D.26547 = ins->sreg1;
        if (D.26547 != -1) goto <D.26548>; else goto <D.26549>;
        <D.26548>:
        D.26547 = ins->sreg1;
        printf (" R%d", D.26547);
        <D.26549>:
        D.26550 = ins->sreg2;
        if (D.26550 != -1) goto <D.26551>; else goto <D.26552>;
        <D.26551>:
        D.26550 = ins->sreg2;
        printf (" R%d", D.26550);
        <D.26552>:
        D.26553 = ins->sreg3;
        if (D.26553 != -1) goto <D.26554>; else goto <D.26555>;
        <D.26554>:
        D.26553 = ins->sreg3;
        printf (" R%d", D.26553);
        <D.26555>:
        D.26528 = ins->opcode;
        D.26529 = (int) D.26528;
        switch (D.26529) <default: <D.25801>, case 314: <D.25797>, case 319: <D.25789>, case 320: <D.25792>, case 321: <D.25790>, case 332: <D.25800>, case 334: <D.25798>, case 367: <D.25799>, case 551: <D.25779>, case 552: <D.25784>, case 553: <D.25782>, case 554: <D.25786>, case 555: <D.25780>, case 556: <D.25778>, case 557: <D.25785>, case 558: <D.25783>, case 559: <D.25787>, case 560: <D.25781>, case 802: <D.25791>>
        <D.25778>:
        <D.25779>:
        <D.25780>:
        <D.25781>:
        <D.25782>:
        <D.25783>:
        <D.25784>:
        <D.25785>:
        <D.25786>:
        <D.25787>:
        D.26556 = ins->data.op[1].many_blocks;
        D.26557 = D.26556 + 4;
        D.26558 = *D.26557;
        if (D.26558 == 0B) goto <D.26559>; else goto <D.26560>;
        <D.26559>:
        D.26556 = ins->data.op[1].many_blocks;
        D.26561 = *D.26556;
        D.26562 = D.26561->block_num;
        printf (" [B%d]", D.26562);
        goto <D.26563>;
        <D.26560>:
        D.26556 = ins->data.op[1].many_blocks;
        D.26561 = *D.26556;
        D.26562 = D.26561->block_num;
        D.26556 = ins->data.op[1].many_blocks;
        D.26557 = D.26556 + 4;
        D.26558 = *D.26557;
        D.26564 = D.26558->block_num;
        printf (" [B%dB%d]", D.26562, D.26564);
        <D.26563>:
        goto <D.25788>;
        <D.25789>:
        <D.25790>:
        <D.25791>:
        <D.25792>:
        {
          int i;

          D.26545 = ins->data.op[0].const_val;
          printf (" [%d (", D.26545);
          i = 0;
          goto <D.25795>;
          <D.25794>:
          if (i != 0) goto <D.26565>; else goto <D.26566>;
          <D.26565>:
          printf (", ");
          <D.26566>:
          D.26567 = ins->data.op[1].phi_args;
          i.4 = (sizetype) i;
          D.26569 = i.4 + 1;
          D.26570 = D.26569 * 4;
          D.26571 = D.26567 + D.26570;
          D.26572 = *D.26571;
          printf ("R%d", D.26572);
          i = i + 1;
          <D.25795>:
          D.26567 = ins->data.op[1].phi_args;
          D.26573 = *D.26567;
          if (D.26573 > i) goto <D.25794>; else goto <D.25796>;
          <D.25796>:
          printf (")]");
          goto <D.25788>;
        }
        <D.25797>:
        <D.25798>:
        D.26574 = ins->data.op[0].p;
        D.26575 = MEM[(struct MonoInst *)D.26574].dreg;
        printf (" R%d", D.26575);
        goto <D.25788>;
        <D.25799>:
        <D.25800>:
        D.26545 = ins->data.op[0].const_val;
        printf (" + 0x%lx", D.26545);
        goto <D.25788>;
        <D.25801>:
        goto <D.25788>;
        <D.25788>:
        printf ("\n");
        return;
      }
      <D.26539>:
      D.26576 = *spec;
      if (D.26576 != 0) goto <D.26577>; else goto <D.26578>;
      <D.26577>:
      {
        int bank;

        D.26582 = mono_arch_is_soft_float ();
        if (D.26582 == 0) goto <D.26583>; else goto <D.26580>;
        <D.26583>:
        D.26576 = *spec;
        D.26584 = D.26576 + 154;
        if (D.26584 <= 1) goto <D.26585>; else goto <D.26580>;
        <D.26585>:
        iftmp.5 = 1;
        goto <D.26581>;
        <D.26580>:
        iftmp.5 = 0;
        <D.26581>:
        bank = iftmp.5;
        D.26587 = bank != 0;
        D.26588 = (long int) D.26587;
        D.26589 = __builtin_expect (D.26588, 0);
        if (D.26589 != 0) goto <D.26590>; else goto <D.26591>;
        <D.26590>:
        D.26540 = ins->dreg;
        if (D.26540 < 0) goto <D.26593>; else goto <D.26596>;
        <D.26596>:
        D.26540 = ins->dreg;
        D.26597 = regbank_size[bank];
        if (D.26540 >= D.26597) goto <D.26593>; else goto <D.26594>;
        <D.26593>:
        iftmp.7 = 1;
        goto <D.26595>;
        <D.26594>:
        iftmp.7 = 0;
        <D.26595>:
        iftmp.6 = (_Bool) iftmp.7;
        goto <D.26598>;
        <D.26591>:
        D.26540 = ins->dreg;
        iftmp.6 = D.26540 > 15;
        <D.26598>:
        if (iftmp.6 != 0) goto <D.26599>; else goto <D.26600>;
        <D.26599>:
        D.26576 = *spec;
        if (D.26576 == 98) goto <D.26601>; else goto <D.26602>;
        <D.26601>:
        D.26545 = ins->data.op[0].const_val;
        if (D.26545 == 0) goto <D.26603>; else goto <D.26604>;
        <D.26603>:
        D.26540 = ins->dreg;
        printf (" [R%d] <-", D.26540);
        goto <D.26605>;
        <D.26604>:
        D.26540 = ins->dreg;
        D.26545 = ins->data.op[0].const_val;
        printf (" [R%d + 0x%lx] <-", D.26540, D.26545);
        <D.26605>:
        goto <D.26606>;
        <D.26602>:
        D.26540 = ins->dreg;
        printf (" R%d <-", D.26540);
        <D.26606>:
        goto <D.26607>;
        <D.26600>:
        D.26576 = *spec;
        if (D.26576 == 98) goto <D.26608>; else goto <D.26609>;
        <D.26608>:
        D.26545 = ins->data.op[0].const_val;
        if (D.26545 == 0) goto <D.26610>; else goto <D.26611>;
        <D.26610>:
        D.26540 = ins->dreg;
        D.26612 = mono_arch_regname (D.26540);
        printf (" [%s] <-", D.26612);
        goto <D.26613>;
        <D.26611>:
        D.26540 = ins->dreg;
        D.26614 = mono_arch_regname (D.26540);
        D.26545 = ins->data.op[0].const_val;
        printf (" [%s + 0x%lx] <-", D.26614, D.26545);
        <D.26613>:
        goto <D.26615>;
        <D.26609>:
        D.26540 = ins->dreg;
        D.26616 = mono_regname_full (D.26540, bank);
        printf (" %s <-", D.26616);
        <D.26615>:
        <D.26607>:
      }
      <D.26578>:
      D.26617 = spec + 1;
      D.26618 = *D.26617;
      if (D.26618 != 0) goto <D.26619>; else goto <D.26620>;
      <D.26619>:
      {
        int bank;

        D.26624 = mono_arch_is_soft_float ();
        if (D.26624 == 0) goto <D.26625>; else goto <D.26622>;
        <D.26625>:
        D.26617 = spec + 1;
        D.26618 = *D.26617;
        D.26626 = D.26618 + 154;
        if (D.26626 <= 1) goto <D.26627>; else goto <D.26622>;
        <D.26627>:
        iftmp.8 = 1;
        goto <D.26623>;
        <D.26622>:
        iftmp.8 = 0;
        <D.26623>:
        bank = iftmp.8;
        D.26629 = bank != 0;
        D.26630 = (long int) D.26629;
        D.26631 = __builtin_expect (D.26630, 0);
        if (D.26631 != 0) goto <D.26632>; else goto <D.26633>;
        <D.26632>:
        D.26547 = ins->sreg1;
        if (D.26547 < 0) goto <D.26635>; else goto <D.26638>;
        <D.26638>:
        D.26547 = ins->sreg1;
        D.26639 = regbank_size[bank];
        if (D.26547 >= D.26639) goto <D.26635>; else goto <D.26636>;
        <D.26635>:
        iftmp.10 = 1;
        goto <D.26637>;
        <D.26636>:
        iftmp.10 = 0;
        <D.26637>:
        iftmp.9 = (_Bool) iftmp.10;
        goto <D.26640>;
        <D.26633>:
        D.26547 = ins->sreg1;
        iftmp.9 = D.26547 > 15;
        <D.26640>:
        if (iftmp.9 != 0) goto <D.26641>; else goto <D.26642>;
        <D.26641>:
        D.26617 = spec + 1;
        D.26618 = *D.26617;
        if (D.26618 == 98) goto <D.26643>; else goto <D.26644>;
        <D.26643>:
        D.26547 = ins->sreg1;
        D.26545 = ins->data.op[0].const_val;
        printf (" [R%d + 0x%lx]", D.26547, D.26545);
        goto <D.26645>;
        <D.26644>:
        D.26547 = ins->sreg1;
        printf (" R%d", D.26547);
        <D.26645>:
        goto <D.26646>;
        <D.26642>:
        D.26617 = spec + 1;
        D.26618 = *D.26617;
        if (D.26618 == 98) goto <D.26647>; else goto <D.26648>;
        <D.26647>:
        D.26547 = ins->sreg1;
        D.26649 = mono_arch_regname (D.26547);
        D.26545 = ins->data.op[0].const_val;
        printf (" [%s + 0x%lx]", D.26649, D.26545);
        goto <D.26650>;
        <D.26648>:
        D.26547 = ins->sreg1;
        D.26651 = mono_regname_full (D.26547, bank);
        printf (" %s", D.26651);
        <D.26650>:
        <D.26646>:
      }
      <D.26620>:
      D.26547 = ins->sreg1;
      sregs[0] = D.26547;
      D.26550 = ins->sreg2;
      sregs[1] = D.26550;
      D.26553 = ins->sreg3;
      sregs[2] = D.26553;
      D.26528 = ins->opcode;
      D.26529 = (int) D.26528;
      D.26530 = D.26529 + -313;
      D.26652 = ins_sreg_counts[D.26530];
      num_sregs = (int) D.26652;
      j = 1;
      goto <D.25806>;
      <D.25805>:
      {
        int bank;

        D.26656 = mono_arch_is_soft_float ();
        if (D.26656 == 0) goto <D.26657>; else goto <D.26654>;
        <D.26657>:
        D.26658 = j + 1;
        D.26659 = (sizetype) D.26658;
        D.26660 = spec + D.26659;
        D.26661 = *D.26660;
        D.26662 = D.26661 + 154;
        if (D.26662 <= 1) goto <D.26663>; else goto <D.26654>;
        <D.26663>:
        iftmp.11 = 1;
        goto <D.26655>;
        <D.26654>:
        iftmp.11 = 0;
        <D.26655>:
        bank = iftmp.11;
        D.26665 = bank != 0;
        D.26666 = (long int) D.26665;
        D.26667 = __builtin_expect (D.26666, 0);
        if (D.26667 != 0) goto <D.26668>; else goto <D.26669>;
        <D.26668>:
        D.26674 = sregs[j];
        if (D.26674 < 0) goto <D.26671>; else goto <D.26675>;
        <D.26675>:
        D.26674 = sregs[j];
        D.26676 = regbank_size[bank];
        if (D.26674 >= D.26676) goto <D.26671>; else goto <D.26672>;
        <D.26671>:
        iftmp.13 = 1;
        goto <D.26673>;
        <D.26672>:
        iftmp.13 = 0;
        <D.26673>:
        iftmp.12 = (_Bool) iftmp.13;
        goto <D.26677>;
        <D.26669>:
        D.26674 = sregs[j];
        iftmp.12 = D.26674 > 15;
        <D.26677>:
        if (iftmp.12 != 0) goto <D.26678>; else goto <D.26679>;
        <D.26678>:
        D.26674 = sregs[j];
        printf (" R%d", D.26674);
        goto <D.26680>;
        <D.26679>:
        D.26674 = sregs[j];
        D.26681 = mono_regname_full (D.26674, bank);
        printf (" %s", D.26681);
        <D.26680>:
      }
      j = j + 1;
      <D.25806>:
      if (j < num_sregs) goto <D.25805>; else goto <D.25807>;
      <D.25807>:
      D.26528 = ins->opcode;
      D.26529 = (int) D.26528;
      switch (D.26529) <default: <D.25875>, case 323: <D.25811>, case 327: <D.25810>, case 341: <D.25874>, case 343: <D.25834>, case 345: <D.25835>, case 346: <D.25823>, case 347: <D.25825>, case 348: <D.25824>, case 349: <D.25826>, case 352: <D.25827>, case 355: <D.25828>, case 356: <D.25829>, case 357: <D.25830>, case 358: <D.25831>, case 359: <D.25832>, case 360: <D.25833>, case 362: <D.25808>, case 363: <D.25820>, case 364: <D.25822>, case 365: <D.25821>, case 429: <D.25818>, case 430: <D.25817>, case 442: <D.25848>, case 444: <D.25836>, case 538: <D.25819>, case 551: <D.25861>, case 552: <D.25866>, case 553: <D.25864>, case 554: <D.25868>, case 555: <D.25862>, case 556: <D.25860>, case 557: <D.25867>, case 558: <D.25865>, case 559: <D.25869>, case 560: <D.25863>, case 625: <D.25812>, case 626: <D.25813>, case 632: <D.25814>, case 633: <D.25815>, case 634: <D.25816>, case 648: <D.25851>, case 649: <D.25856>, case 650: <D.25854>, case 651: <D.25858>, case 652: <D.25852>, case 653: <D.25850>, case 654: <D.25857>, case 655: <D.25855>, case 656: <D.25859>, case 657: <D.25853>, case 735: <D.25849>, case 836: <D.25870>, case 837: <D.25871>, case 838: <D.25872>, case 839: <D.25873>>
      <D.25808>:
      D.26545 = ins->data.op[0].const_val;
      printf (" [%d]", D.26545);
      goto <D.25809>;
      <D.25810>:
      <D.25811>:
      <D.25812>:
      <D.25813>:
      <D.25814>:
      <D.25815>:
      <D.25816>:
      <D.25817>:
      D.26682 = ins->data.op[1].const_val;
      printf (" [%d]", D.26682);
      goto <D.25809>;
      <D.25818>:
      <D.25819>:
      D.26683 = ins->data.op[1].p;
      D.26684 = (int) D.26683;
      printf (" [%d]", D.26684);
      goto <D.25809>;
      <D.25820>:
      D.26685 = ins->data.i8const;
      printf (" [%lld]", D.26685);
      goto <D.25809>;
      <D.25821>:
      D.26574 = ins->data.op[0].p;
      D.26686 = MEM[(double *)D.26574];
      printf (" [%f]", D.26686);
      goto <D.25809>;
      <D.25822>:
      D.26574 = ins->data.op[0].p;
      D.26687 = MEM[(float *)D.26574];
      D.26688 = (double) D.26687;
      printf (" [%f]", D.26688);
      goto <D.25809>;
      <D.25823>:
      <D.25824>:
      <D.25825>:
      <D.25826>:
      <D.25827>:
      <D.25828>:
      <D.25829>:
      <D.25830>:
      <D.25831>:
      <D.25832>:
      <D.25833>:
      <D.25834>:
      <D.25835>:
      <D.25836>:
      {
        struct MonoCallInst * call;
        struct GSList * list;

        call = ins;
        D.26528 = ins->opcode;
        D.26689 = D.26528 + 65181;
        if (D.26689 <= 2) goto <D.26690>; else goto <D.26691>;
        <D.26690>:
        D.26540 = ins->dreg;
        if (D.26540 != -1) goto <D.26692>; else goto <D.26693>;
        <D.26692>:
        D.26540 = ins->dreg;
        printf (" R%d <-", D.26540);
        <D.26693>:
        <D.26691>:
        D.26694 = call->method;
        if (D.26694 != 0B) goto <D.26695>; else goto <D.26696>;
        <D.26695>:
        {
          char * full_name;

          D.26694 = call->method;
          full_name = mono_method_full_name (D.26694, 1);
          printf (" [%s]", full_name);
          monoeg_g_free (full_name);
        }
        goto <D.26697>;
        <D.26696>:
        D.26698 = BIT_FIELD_REF <*call, 8, 704>;
        D.26699 = D.26698 & 4;
        if (D.26699 != 0) goto <D.26700>; else goto <D.26701>;
        <D.26700>:
        {
          struct MonoJumpInfo * ji;

          ji = call->fptr;
          printf (" ");
          mono_print_ji (ji);
        }
        goto <D.26702>;
        <D.26701>:
        D.26703 = call->fptr;
        if (D.26703 != 0B) goto <D.26704>; else goto <D.26705>;
        <D.26704>:
        {
          struct MonoJitICallInfo * info;

          D.26703 = call->fptr;
          info = mono_find_jit_icall_by_addr (D.26703);
          if (info != 0B) goto <D.26706>; else goto <D.26707>;
          <D.26706>:
          D.26708 = info->name;
          printf (" [%s]", D.26708);
          <D.26707>:
        }
        <D.26705>:
        <D.26702>:
        <D.26697>:
        list = call->out_ireg_args;
        goto <D.25846>;
        <D.25845>:
        {
          guint32 regpair;
          int reg;
          int hreg;

          D.26709 = list->data;
          regpair = (guint32) D.26709;
          D.26710 = regpair >> 24;
          hreg = (int) D.26710;
          regpair.14 = (int) regpair;
          reg = regpair.14 & 16777215;
          D.26712 = mono_arch_regname (hreg);
          printf (" [%s <- R%d]", D.26712, reg);
          if (list != 0B) goto <D.26714>; else goto <D.26715>;
          <D.26714>:
          iftmp.15 = list->next;
          goto <D.26716>;
          <D.26715>:
          iftmp.15 = 0B;
          <D.26716>:
          list = iftmp.15;
        }
        <D.25846>:
        if (list != 0B) goto <D.25845>; else goto <D.25847>;
        <D.25847>:
        goto <D.25809>;
      }
      <D.25848>:
      <D.25849>:
      D.26717 = ins->data.op[0].target_block;
      D.26718 = D.26717->block_num;
      printf (" [B%d]", D.26718);
      goto <D.25809>;
      <D.25850>:
      <D.25851>:
      <D.25852>:
      <D.25853>:
      <D.25854>:
      <D.25855>:
      <D.25856>:
      <D.25857>:
      <D.25858>:
      <D.25859>:
      <D.25860>:
      <D.25861>:
      <D.25862>:
      <D.25863>:
      <D.25864>:
      <D.25865>:
      <D.25866>:
      <D.25867>:
      <D.25868>:
      <D.25869>:
      D.26556 = ins->data.op[1].many_blocks;
      D.26557 = D.26556 + 4;
      D.26558 = *D.26557;
      if (D.26558 == 0B) goto <D.26719>; else goto <D.26720>;
      <D.26719>:
      D.26556 = ins->data.op[1].many_blocks;
      D.26561 = *D.26556;
      D.26562 = D.26561->block_num;
      printf (" [B%d]", D.26562);
      goto <D.26721>;
      <D.26720>:
      D.26556 = ins->data.op[1].many_blocks;
      D.26561 = *D.26556;
      D.26562 = D.26561->block_num;
      D.26556 = ins->data.op[1].many_blocks;
      D.26557 = D.26556 + 4;
      D.26558 = *D.26557;
      D.26564 = D.26558->block_num;
      printf (" [B%dB%d]", D.26562, D.26564);
      <D.26721>:
      goto <D.25809>;
      <D.25870>:
      <D.25871>:
      <D.25872>:
      <D.25873>:
      D.26682 = ins->data.op[1].const_val;
      printf (" R%d", D.26682);
      goto <D.25809>;
      <D.25874>:
      D.26682 = ins->data.op[1].const_val;
      printf (" il: %x", D.26682);
      goto <D.25809>;
      <D.25875>:
      goto <D.25809>;
      <D.25809>:
      D.26722 = spec + 5;
      D.26723 = *D.26722;
      if (D.26723 != 0) goto <D.26724>; else goto <D.26725>;
      <D.26724>:
      D.26722 = spec + 5;
      D.26723 = *D.26722;
      D.26726 = (int) D.26723;
      printf (" clobbers: %c", D.26726);
      <D.26725>:
      printf ("\n");
    }
  finally
    {
      sregs = {CLOBBER};
    }
}


mono_arch_is_soft_float ()
{
  gboolean D.26733;

  D.26733 = 0;
  return D.26733;
}


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


mono_local_regalloc (struct MonoCompile * cfg, struct MonoBasicBlock * bb)
{
  struct MonoInst * D.26735;
  int desc_to_fixed_reg_inited.16;
  gint8 iftmp.17;
  int D.26742;
  gint8 iftmp.18;
  _Bool D.26748;
  _Bool D.26749;
  _Bool D.26750;
  gint8 iftmp.19;
  gint8 iftmp.20;
  gint8 iftmp.21;
  int D.26766;
  short unsigned int D.26767;
  sizetype D.26768;
  int D.26769;
  char D.26770;
  char D.26773;
  const char * D.26776;
  const char * D.26777;
  char D.26778;
  const char * D.26781;
  char D.26782;
  const char * D.26785;
  const char * D.26786;
  char D.26787;
  const char * D.26790;
  char D.26791;
  const char * D.26794;
  unsigned int D.26795;
  int D.26796;
  unsigned int D.26797;
  void * D.26798;
  int D.26801;
  int D.26806;
  int D.26807;
  struct MonoMemPool * D.26808;
  unsigned int D.26809;
  unsigned int D.26810;
  void * D.26811;
  int D.26813;
  _Bool D.26814;
  long int D.26815;
  long int D.26816;
  unsigned int D.26819;
  short unsigned int D.26822;
  int D.26823;
  int D.26824;
  short unsigned int D.26825;
  sizetype D.26826;
  int D.26827;
  unsigned int D.26832;
  unsigned int D.26833;
  void * D.26834;
  _Bool iftmp.22;
  int D.26836;
  int iftmp.23;
  _Bool D.26843;
  _Bool D.26844;
  _Bool D.26845;
  int D.26849;
  int D.26852;
  sizetype D.26853;
  sizetype D.26854;
  sizetype D.26855;
  struct RegTrack * D.26856;
  int D.26857;
  int D.26858;
  int D.26859;
  signed char D.26860;
  int D.26861;
  _Bool D.26862;
  long int D.26863;
  long int D.26864;
  unsigned int D.26869;
  unsigned int D.26870;
  void * D.26871;
  _Bool iftmp.24;
  int D.26873;
  int iftmp.25;
  int D.26880;
  sizetype D.26881;
  const char * D.26882;
  char D.26883;
  _Bool D.26884;
  _Bool D.26885;
  _Bool D.26886;
  int D.26890;
  int D.26893;
  sizetype D.26894;
  sizetype D.26895;
  sizetype D.26896;
  struct RegTrack * D.26897;
  _Bool D.26898;
  long int D.26899;
  long int D.26900;
  int D.26903;
  _Bool D.26904;
  long int D.26905;
  long int D.26906;
  const char * D.26909;
  int iftmp.26;
  int D.26917;
  char D.26919;
  _Bool D.26921;
  long int D.26922;
  long int D.26923;
  _Bool iftmp.27;
  _Bool D.26927;
  long int D.26928;
  long int D.26929;
  int iftmp.28;
  int D.26937;
  unsigned int sreg.29;
  unsigned int D.26942;
  struct RegTrack * D.26943;
  int D.26944;
  _Bool D.26945;
  long int D.26946;
  long int D.26947;
  gint32 * D.26950;
  unsigned int D.26951;
  gint32 * D.26952;
  _Bool iftmp.30;
  int D.26954;
  int iftmp.31;
  _Bool D.26961;
  _Bool D.26962;
  _Bool D.26963;
  unsigned int sreg_spec.32;
  unsigned int D.26966;
  int D.26968;
  sizetype sreg.33;
  sizetype D.26972;
  sizetype D.26973;
  gint32 * D.26974;
  sizetype D.26977;
  struct RegTrack * D.26978;
  int D.26979;
  int iftmp.34;
  int D.26987;
  char D.26989;
  struct RegTrack * D.26993;
  _Bool D.26994;
  long int D.26995;
  long int D.26996;
  unsigned int D.26999;
  gint32 * D.27000;
  int D.27003;
  int D.27005;
  signed char D.27006;
  unsigned int D.27009;
  _Bool iftmp.35;
  int D.27011;
  int iftmp.36;
  _Bool D.27018;
  _Bool D.27019;
  _Bool D.27020;
  unsigned char D.27022;
  int D.27024;
  sizetype D.27027;
  gint32 * D.27028;
  int D.27031;
  _Bool D.27035;
  _Bool D.27036;
  unsigned int iftmp.37;
  unsigned int iftmp.38;
  const char * D.27051;
  char D.27052;
  short unsigned int D.27055;
  short unsigned int D.27056;
  _Bool D.27057;
  short unsigned int D.27058;
  _Bool D.27059;
  _Bool D.27060;
  short unsigned int D.27062;
  short unsigned int D.27064;
  short unsigned int D.27066;
  short unsigned int D.27068;
  void * D.27072;
  unsigned int D.27073;
  int regpair.39;
  struct GSList * iftmp.40;
  unsigned int D.27081;
  int regpair.41;
  struct GSList * iftmp.42;
  struct MonoInst * iftmp.43;
  unsigned int D.27093;
  int D.27094;
  signed char D.27095;
  int D.27096;
  int D.27101;
  signed char D.27102;
  unsigned int D.27103;
  unsigned int D.27108;
  unsigned int D.27111;
  unsigned int D.27112;
  unsigned int D.27113;
  int D.27116;
  unsigned int D.27119;
  unsigned int D.27120;
  gint32 * D.27121;
  int D.27122;
  unsigned int sreg.44;
  unsigned int D.27128;
  gint32 * D.27129;
  int D.27130;
  unsigned int D.27135;
  unsigned int D.27136;
  unsigned int sreg.45;
  unsigned int D.27143;
  unsigned int D.27144;
  unsigned int D.27148;
  unsigned int D.27149;
  const char * D.27154;
  unsigned int D.27160;
  unsigned int D.27161;
  unsigned int D.27165;
  unsigned int D.27166;
  _Bool D.27174;
  long int D.27175;
  long int D.27176;
  const char * D.27181;
  const char * D.27182;
  int iftmp.46;
  int D.27204;
  _Bool iftmp.47;
  int iftmp.48;
  int D.27222;
  unsigned int D.27225;
  unsigned int D.27226;
  int D.27227;
  unsigned int D.27230;
  unsigned int D.27231;
  _Bool iftmp.49;
  int iftmp.50;
  unsigned int D.27245;
  unsigned int D.27246;
  _Bool iftmp.51;
  int D.27250;
  int iftmp.52;
  long int iftmp.53;
  int iftmp.54;
  _Bool D.27269;
  _Bool D.27271;
  long int D.27272;
  int D.27277;
  int D.27280;
  guint32 iftmp.55;
  unsigned int D.27288;
  gint32 * D.27289;
  int D.27290;
  unsigned int D.27291;
  int dest_dreg2.56;
  unsigned int D.27301;
  unsigned int D.27303;
  unsigned int D.27304;
  _Bool iftmp.57;
  int iftmp.58;
  const char * D.27327;
  _Bool iftmp.59;
  int D.27329;
  int iftmp.60;
  _Bool D.27342;
  long int D.27343;
  long int D.27344;
  int iftmp.61;
  unsigned int prev_dreg.62;
  unsigned int D.27351;
  gint32 * D.27352;
  int D.27353;
  unsigned int D.27354;
  unsigned int D.27356;
  unsigned int D.27357;
  _Bool D.27359;
  long int D.27360;
  long int D.27361;
  unsigned int iftmp.63;
  unsigned int iftmp.64;
  unsigned int reg2.65;
  unsigned int D.27375;
  gint32 * D.27376;
  unsigned int D.27386;
  unsigned int D.27387;
  int D.27392;
  const char * D.27395;
  _Bool iftmp.66;
  _Bool iftmp.67;
  int iftmp.68;
  int iftmp.69;
  _Bool D.27412;
  unsigned int D.27416;
  unsigned int D.27417;
  unsigned int D.27418;
  int iftmp.70;
  unsigned int val.71;
  unsigned int D.27426;
  unsigned int D.27427;
  int iftmp.72;
  unsigned int D.27439;
  struct RegTrack * D.27440;
  int D.27441;
  const char * D.27446;
  _Bool iftmp.73;
  int iftmp.74;
  _Bool D.27462;
  long int D.27463;
  long int D.27464;
  const char * D.27469;
  unsigned int D.27470;
  struct RegTrack * D.27471;
  int D.27472;
  struct MonoRegState * D.27482;
  int * D.27483;
  unsigned int dest_dreg.75;
  unsigned int D.27485;
  int * D.27486;
  int D.27487;
  int D.27488;
  int D.27492;
  int D.27499;
  unsigned int D.27501;
  unsigned int D.27502;
  unsigned int D.27503;
  unsigned int D.27504;
  unsigned int D.27507;
  unsigned int D.27508;
  int D.27513;
  int D.27522;
  _Bool iftmp.76;
  int D.27525;
  int iftmp.77;
  sizetype prev_dreg.78;
  sizetype D.27537;
  sizetype D.27538;
  gint32 * D.27539;
  unsigned int D.27541;
  long long unsigned int D.27542;
  long long unsigned int D.27543;
  unsigned int s.79;
  unsigned int D.27547;
  _Bool D.27552;
  _Bool D.27553;
  _Bool D.27554;
  int D.27558;
  unsigned int D.27561;
  unsigned int D.27562;
  gint32 * D.27563;
  unsigned int D.27564;
  unsigned int D.27565;
  int D.27571;
  unsigned int D.27578;
  int * D.27584;
  unsigned int j.80;
  unsigned int D.27586;
  int * D.27587;
  int D.27588;
  unsigned int D.27591;
  unsigned int D.27592;
  gint32 * D.27593;
  int D.27594;
  short unsigned int D.27599;
  short unsigned int D.27600;
  _Bool D.27601;
  short unsigned int D.27602;
  _Bool D.27603;
  _Bool D.27604;
  void * D.27612;
  unsigned int D.27613;
  int regpair.81;
  unsigned int D.27615;
  unsigned int D.27616;
  unsigned int D.27617;
  unsigned int D.27618;
  const char * D.27621;
  struct GSList * iftmp.82;
  unsigned int D.27628;
  int regpair.83;
  const char * D.27632;
  struct GSList * iftmp.84;
  int iftmp.85;
  int D.27640;
  char D.27642;
  _Bool iftmp.86;
  int D.27645;
  int iftmp.87;
  long int iftmp.88;
  int iftmp.89;
  _Bool D.27666;
  _Bool D.27668;
  long int D.27669;
  _Bool D.27674;
  long int D.27675;
  long int D.27676;
  _Bool D.27679;
  long int D.27680;
  long int D.27681;
  unsigned int sreg1.90;
  unsigned int D.27685;
  gint32 * D.27686;
  int D.27687;
  const char * D.27694;
  unsigned int iftmp.91;
  _Bool D.27699;
  _Bool D.27700;
  _Bool D.27701;
  unsigned int iftmp.92;
  unsigned int D.27708;
  unsigned int D.27709;
  _Bool D.27710;
  long int D.27711;
  long int D.27712;
  unsigned int D.27715;
  sizetype sreg1.93;
  sizetype D.27719;
  sizetype D.27720;
  gint32 * D.27721;
  int D.27722;
  int D.27727;
  const char * D.27730;
  unsigned int D.27731;
  int D.27738;
  unsigned int D.27739;
  unsigned int D.27741;
  unsigned int D.27742;
  unsigned int D.27746;
  unsigned int D.27749;
  unsigned int D.27750;
  gint32 * D.27751;
  int D.27752;
  unsigned int D.27755;
  _Bool iftmp.94;
  int iftmp.95;
  int D.27779;
  unsigned int D.27784;
  unsigned int D.27785;
  unsigned int D.27788;
  int D.27795;
  unsigned int D.27799;
  struct RegTrack * D.27800;
  const char * D.27803;
  int D.27806;
  unsigned int D.27812;
  unsigned int D.27814;
  unsigned int D.27815;
  unsigned int D.27816;
  _Bool iftmp.96;
  int D.27818;
  int iftmp.97;
  _Bool D.27825;
  _Bool D.27826;
  unsigned char D.27828;
  int D.27830;
  _Bool D.27837;
  long int D.27838;
  long int D.27839;
  int iftmp.98;
  unsigned int D.27845;
  unsigned int D.27846;
  gint32 * D.27847;
  int D.27848;
  unsigned int D.27849;
  unsigned int D.27851;
  unsigned int D.27852;
  _Bool D.27854;
  long int D.27855;
  long int D.27856;
  unsigned int iftmp.99;
  unsigned int iftmp.100;
  unsigned int reg2.101;
  unsigned int D.27870;
  gint32 * D.27871;
  const char * D.27885;
  int D.27889;
  int D.27892;
  int iftmp.102;
  int D.27899;
  int D.27902;
  const char * D.27907;
  const char * D.27908;
  _Bool D.27909;
  long int D.27910;
  long int D.27911;
  _Bool iftmp.103;
  int D.27916;
  int iftmp.104;
  sizetype D.27927;
  sizetype D.27928;
  sizetype D.27929;
  gint32 * D.27930;
  int D.27931;
  _Bool D.27934;
  long int D.27935;
  long int D.27936;
  _Bool D.27939;
  long int D.27940;
  long int D.27941;
  const char * D.27946;
  const char * D.27947;
  unsigned int D.27950;
  unsigned int D.27951;
  int iftmp.105;
  int D.27955;
  _Bool iftmp.106;
  int D.27959;
  int iftmp.107;
  unsigned int D.27974;
  unsigned int D.27976;
  unsigned int D.27977;
  _Bool iftmp.108;
  int iftmp.109;
  unsigned int D.27990;
  gint32 * D.27991;
  struct RegTrack * D.28002;
  const char * D.28005;
  unsigned int D.28008;
  unsigned int D.28009;
  unsigned int D.28010;
  unsigned int D.28011;
  _Bool D.28013;
  _Bool D.28014;
  _Bool D.28015;
  _Bool D.28018;
  long int D.28019;
  long int D.28020;
  int D.28025;
  _Bool D.28026;
  long int D.28027;
  long int D.28028;
  struct MonoInst * iftmp.110;
  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.26735 = bb->code;
      if (D.26735 == 0B) goto <D.26736>; else goto <D.26737>;
      <D.26736>:
      return;
      <D.26737>:
      desc_to_fixed_reg_inited.16 = desc_to_fixed_reg_inited;
      if (desc_to_fixed_reg_inited.16 == 0) goto <D.26739>; else goto <D.26740>;
      <D.26739>:
      i = 0;
      goto <D.26049>;
      <D.26048>:
      D.26742 = mono_arch_is_soft_float ();
      if (D.26742 != 0) goto <D.26743>; else goto <D.26744>;
      <D.26743>:
      D.26748 = i != 108;
      D.26749 = i != 102;
      D.26750 = D.26748 & D.26749;
      if (D.26750 != 0) goto <D.26751>; else goto <D.26746>;
      <D.26751>:
      if (i != 103) goto <D.26752>; else goto <D.26746>;
      <D.26752>:
      if (i == 97) goto <D.26754>; else goto <D.26755>;
      <D.26754>:
      iftmp.19 = 0;
      goto <D.26756>;
      <D.26755>:
      iftmp.19 = -1;
      <D.26756>:
      iftmp.18 = iftmp.19;
      goto <D.26747>;
      <D.26746>:
      iftmp.18 = 0;
      <D.26747>:
      iftmp.17 = iftmp.18;
      goto <D.26757>;
      <D.26744>:
      if (i != 108) goto <D.26759>; else goto <D.26760>;
      <D.26759>:
      if (i == 97) goto <D.26762>; else goto <D.26763>;
      <D.26762>:
      iftmp.21 = 0;
      goto <D.26764>;
      <D.26763>:
      iftmp.21 = -1;
      <D.26764>:
      iftmp.20 = iftmp.21;
      goto <D.26765>;
      <D.26760>:
      iftmp.20 = 0;
      <D.26765>:
      iftmp.17 = iftmp.20;
      <D.26757>:
      desc_to_fixed_reg[i] = iftmp.17;
      i = i + 1;
      <D.26049>:
      if (i <= 255) goto <D.26048>; else goto <D.26050>;
      <D.26050>:
      desc_to_fixed_reg_inited = 1;
      i = 313;
      goto <D.26053>;
      <D.26052>:
      {
        const char * ispec;

        D.26766 = i + -313;
        D.26767 = arm_cpu_desc_idx[D.26766];
        D.26768 = (sizetype) D.26767;
        spec = &arm_cpu_desc + D.26768;
        D.26766 = i + -313;
        D.26769 = D.26766 * 4;
        ispec = &ins_info[D.26769];
        D.26770 = *spec;
        if (D.26770 != 0) goto <D.26771>; else goto <D.26772>;
        <D.26771>:
        D.26773 = *ispec;
        if (D.26773 == 32) goto <D.26774>; else goto <D.26775>;
        <D.26774>:
        D.26776 = mono_inst_name (i);
        printf ("Instruction metadata for %s inconsistent.\n", D.26776);
        <D.26775>:
        <D.26772>:
        D.26777 = spec + 1;
        D.26778 = *D.26777;
        if (D.26778 != 0) goto <D.26779>; else goto <D.26780>;
        <D.26779>:
        D.26781 = ispec + 1;
        D.26782 = *D.26781;
        if (D.26782 == 32) goto <D.26783>; else goto <D.26784>;
        <D.26783>:
        D.26785 = mono_inst_name (i);
        printf ("Instruction metadata for %s inconsistent.\n", D.26785);
        <D.26784>:
        <D.26780>:
        D.26786 = spec + 2;
        D.26787 = *D.26786;
        if (D.26787 != 0) goto <D.26788>; else goto <D.26789>;
        <D.26788>:
        D.26790 = ispec + 2;
        D.26791 = *D.26790;
        if (D.26791 == 32) goto <D.26792>; else goto <D.26793>;
        <D.26792>:
        D.26794 = mono_inst_name (i);
        printf ("Instruction metadata for %s inconsistent.\n", D.26794);
        <D.26793>:
        <D.26789>:
      }
      i = i + 1;
      <D.26053>:
      if (i <= 845) goto <D.26052>; else goto <D.26054>;
      <D.26054>:
      <D.26740>:
      D.26795 = bb->max_vreg;
      D.26796 = (int) D.26795;
      rs->next_vreg = D.26796;
      mono_regstate_assign (rs);
      rs->ifree_mask = 4111;
      i = 0;
      goto <D.26056>;
      <D.26055>:
      D.26797 = regbank_callee_regs[i];
      rs->free_mask[i] = D.26797;
      i = i + 1;
      <D.26056>:
      if (i <= 3) goto <D.26055>; else goto <D.26057>;
      <D.26057>:
      max = rs->next_vreg;
      D.26798 = cfg->reginfo;
      if (D.26798 != 0B) goto <D.26799>; else goto <D.26800>;
      <D.26799>:
      D.26801 = cfg->reginfo_len;
      if (D.26801 < max) goto <D.26802>; else goto <D.26803>;
      <D.26802>:
      cfg->reginfo = 0B;
      <D.26803>:
      <D.26800>:
      reginfo = cfg->reginfo;
      if (reginfo == 0B) goto <D.26804>; else goto <D.26805>;
      <D.26804>:
      D.26806 = max * 2;
      D.26807 = MAX_EXPR <D.26806, 1024>;
      cfg->reginfo_len = D.26807;
      D.26808 = cfg->mempool;
      D.26801 = cfg->reginfo_len;
      D.26809 = (unsigned int) D.26801;
      D.26810 = D.26809 * 12;
      D.26811 = mono_mempool_alloc (D.26808, D.26810);
      cfg->reginfo = D.26811;
      reginfo = cfg->reginfo;
      goto <D.26812>;
      <D.26805>:
      D.26801 = cfg->reginfo_len;
      D.26813 = rs->next_vreg;
      D.26814 = D.26801 < D.26813;
      D.26815 = (long int) D.26814;
      D.26816 = __builtin_expect (D.26815, 0);
      if (D.26816 != 0) goto <D.26817>; else goto <D.26818>;
      <D.26817>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1160, "cfg->reginfo_len >= rs->next_vreg");
      <D.26818>:
      <D.26812>:
      D.26819 = cfg->verbose_level;
      if (D.26819 > 1) goto <D.26820>; else goto <D.26821>;
      <D.26820>:
      D.26798 = cfg->reginfo;
      D.26801 = cfg->reginfo_len;
      D.26809 = (unsigned int) D.26801;
      D.26810 = D.26809 * 12;
      memset (D.26798, 0, D.26810);
      <D.26821>:
      ins = bb->code;
      goto <D.26062>;
      <D.26061>:
      D.26822 = ins->opcode;
      D.26823 = (int) D.26822;
      D.26824 = D.26823 + -313;
      D.26825 = arm_cpu_desc_idx[D.26824];
      D.26826 = (sizetype) D.26825;
      spec = &arm_cpu_desc + D.26826;
      D.26827 = ins->dreg;
      if (D.26827 != -1) goto <D.26828>; else goto <D.26829>;
      <D.26828>:
      D.26827 = ins->dreg;
      if (D.26827 < max) goto <D.26830>; else goto <D.26831>;
      <D.26830>:
      D.26827 = ins->dreg;
      D.26832 = (unsigned int) D.26827;
      D.26833 = D.26832 * 12;
      D.26834 = reginfo + D.26833;
      memset (D.26834, 0, 12);
      D.26836 = mono_arch_is_soft_float ();
      if (D.26836 != 0) goto <D.26837>; else goto <D.26838>;
      <D.26837>:
      D.26770 = *spec;
      D.26843 = D.26770 == 108;
      D.26770 = *spec;
      D.26844 = D.26770 == 76;
      D.26845 = D.26843 | D.26844;
      if (D.26845 != 0) goto <D.26840>; else goto <D.26846>;
      <D.26846>:
      D.26770 = *spec;
      if (D.26770 == 102) goto <D.26840>; else goto <D.26847>;
      <D.26847>:
      D.26770 = *spec;
      if (D.26770 == 103) goto <D.26840>; else goto <D.26841>;
      <D.26840>:
      iftmp.23 = 1;
      goto <D.26842>;
      <D.26841>:
      iftmp.23 = 0;
      <D.26842>:
      iftmp.22 = (_Bool) iftmp.23;
      goto <D.26848>;
      <D.26838>:
      D.26770 = *spec;
      D.26843 = D.26770 == 108;
      D.26770 = *spec;
      D.26844 = D.26770 == 76;
      D.26845 = D.26843 | D.26844;
      D.26849 = (int) D.26845;
      iftmp.22 = (_Bool) D.26849;
      <D.26848>:
      if (iftmp.22 != 0) goto <D.26850>; else goto <D.26851>;
      <D.26850>:
      D.26827 = ins->dreg;
      D.26852 = D.26827 + 1;
      ins->dreg = D.26852;
      D.26827 = ins->dreg;
      D.26853 = (sizetype) D.26827;
      D.26854 = D.26853 + 1;
      D.26855 = D.26854 * 12;
      D.26856 = reginfo + D.26855;
      memset (D.26856, 0, 12);
      <D.26851>:
      <D.26831>:
      <D.26829>:
      D.26857 = ins->sreg1;
      sregs[0] = D.26857;
      D.26858 = ins->sreg2;
      sregs[1] = D.26858;
      D.26859 = ins->sreg3;
      sregs[2] = D.26859;
      D.26822 = ins->opcode;
      D.26823 = (int) D.26822;
      D.26824 = D.26823 + -313;
      D.26860 = ins_sreg_counts[D.26824];
      num_sregs = (int) D.26860;
      j = 0;
      goto <D.26059>;
      <D.26058>:
      D.26861 = sregs[j];
      D.26862 = D.26861 == -1;
      D.26863 = (long int) D.26862;
      D.26864 = __builtin_expect (D.26863, 0);
      if (D.26864 != 0) goto <D.26865>; else goto <D.26866>;
      <D.26865>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1192, "sregs [j] != -1");
      <D.26866>:
      D.26861 = sregs[j];
      if (D.26861 < max) goto <D.26867>; else goto <D.26868>;
      <D.26867>:
      D.26861 = sregs[j];
      D.26869 = (unsigned int) D.26861;
      D.26870 = D.26869 * 12;
      D.26871 = reginfo + D.26870;
      memset (D.26871, 0, 12);
      D.26873 = mono_arch_is_soft_float ();
      if (D.26873 != 0) goto <D.26874>; else goto <D.26875>;
      <D.26874>:
      D.26880 = j + 1;
      D.26881 = (sizetype) D.26880;
      D.26882 = spec + D.26881;
      D.26883 = *D.26882;
      D.26884 = D.26883 == 108;
      D.26880 = j + 1;
      D.26881 = (sizetype) D.26880;
      D.26882 = spec + D.26881;
      D.26883 = *D.26882;
      D.26885 = D.26883 == 76;
      D.26886 = D.26884 | D.26885;
      if (D.26886 != 0) goto <D.26877>; else goto <D.26887>;
      <D.26887>:
      D.26880 = j + 1;
      D.26881 = (sizetype) D.26880;
      D.26882 = spec + D.26881;
      D.26883 = *D.26882;
      if (D.26883 == 102) goto <D.26877>; else goto <D.26888>;
      <D.26888>:
      D.26880 = j + 1;
      D.26881 = (sizetype) D.26880;
      D.26882 = spec + D.26881;
      D.26883 = *D.26882;
      if (D.26883 == 103) goto <D.26877>; else goto <D.26878>;
      <D.26877>:
      iftmp.25 = 1;
      goto <D.26879>;
      <D.26878>:
      iftmp.25 = 0;
      <D.26879>:
      iftmp.24 = (_Bool) iftmp.25;
      goto <D.26889>;
      <D.26875>:
      D.26880 = j + 1;
      D.26881 = (sizetype) D.26880;
      D.26882 = spec + D.26881;
      D.26883 = *D.26882;
      D.26884 = D.26883 == 108;
      D.26880 = j + 1;
      D.26881 = (sizetype) D.26880;
      D.26882 = spec + D.26881;
      D.26883 = *D.26882;
      D.26885 = D.26883 == 76;
      D.26886 = D.26884 | D.26885;
      D.26890 = (int) D.26886;
      iftmp.24 = (_Bool) D.26890;
      <D.26889>:
      if (iftmp.24 != 0) goto <D.26891>; else goto <D.26892>;
      <D.26891>:
      D.26861 = sregs[j];
      D.26893 = D.26861 + 1;
      sregs[j] = D.26893;
      D.26861 = sregs[j];
      D.26894 = (sizetype) D.26861;
      D.26895 = D.26894 + 1;
      D.26896 = D.26895 * 12;
      D.26897 = reginfo + D.26896;
      memset (D.26897, 0, 12);
      <D.26892>:
      <D.26868>:
      j = j + 1;
      <D.26059>:
      if (j < num_sregs) goto <D.26058>; else goto <D.26060>;
      <D.26060>:
      mono_inst_set_src_registers (ins, &sregs);
      ins = ins->next;
      <D.26062>:
      if (ins != 0B) goto <D.26061>; else goto <D.26063>;
      <D.26063>:
      i = 1;
      D.26819 = cfg->verbose_level;
      D.26898 = D.26819 > 2;
      D.26899 = (long int) D.26898;
      D.26900 = __builtin_expect (D.26899, 0);
      if (D.26900 != 0) goto <D.26901>; else goto <D.26902>;
      <D.26901>:
      D.26903 = bb->block_num;
      printf ("\nLOCAL REGALLOC BLOCK %d:\n", D.26903);
      <D.26902>:
      ins = bb->code;
      goto <D.26086>;
      <D.26085>:
      D.26822 = ins->opcode;
      D.26823 = (int) D.26822;
      D.26824 = D.26823 + -313;
      D.26825 = arm_cpu_desc_idx[D.26824];
      D.26826 = (sizetype) D.26825;
      spec = &arm_cpu_desc + D.26826;
      spec_dest = *spec;
      D.26904 = spec == &arm_cpu_desc;
      D.26905 = (long int) D.26904;
      D.26906 = __builtin_expect (D.26905, 0);
      if (D.26906 != 0) goto <D.26907>; else goto <D.26908>;
      <D.26907>:
      D.26822 = ins->opcode;
      D.26823 = (int) D.26822;
      D.26909 = mono_inst_name (D.26823);
      monoeg_g_log (0B, 4, "Opcode \'%s\' missing from machine description file.", D.26909);
      <D.26064>:
      goto <D.26064>;
      <D.26908>:
      D.26819 = cfg->verbose_level;
      D.26898 = D.26819 > 2;
      D.26899 = (long int) D.26898;
      D.26900 = __builtin_expect (D.26899, 0);
      if (D.26900 != 0) goto <D.26910>; else goto <D.26911>;
      <D.26910>:
      mono_print_ins_index (i, ins);
      <D.26911>:
      D.26857 = ins->sreg1;
      sregs[0] = D.26857;
      D.26858 = ins->sreg2;
      sregs[1] = D.26858;
      D.26859 = ins->sreg3;
      sregs[2] = D.26859;
      D.26822 = ins->opcode;
      D.26823 = (int) D.26822;
      D.26824 = D.26823 + -313;
      D.26860 = ins_sreg_counts[D.26824];
      num_sregs = (int) D.26860;
      j = 0;
      goto <D.26068>;
      <D.26067>:
      {
        int sreg;
        int sreg_spec;

        sreg = sregs[j];
        D.26880 = j + 1;
        D.26881 = (sizetype) D.26880;
        D.26882 = spec + D.26881;
        D.26883 = *D.26882;
        sreg_spec = (int) D.26883;
        if (sreg_spec != 0) goto <D.26912>; else goto <D.26913>;
        <D.26912>:
        D.26917 = mono_arch_is_soft_float ();
        if (D.26917 == 0) goto <D.26918>; else goto <D.26915>;
        <D.26918>:
        D.26880 = j + 1;
        D.26881 = (sizetype) D.26880;
        D.26882 = spec + D.26881;
        D.26883 = *D.26882;
        D.26919 = D.26883 + 154;
        if (D.26919 <= 1) goto <D.26920>; else goto <D.26915>;
        <D.26920>:
        iftmp.26 = 1;
        goto <D.26916>;
        <D.26915>:
        iftmp.26 = 0;
        <D.26916>:
        bank = iftmp.26;
        D.26921 = sreg == -1;
        D.26922 = (long int) D.26921;
        D.26923 = __builtin_expect (D.26922, 0);
        if (D.26923 != 0) goto <D.26924>; else goto <D.26925>;
        <D.26924>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1240, "sreg != -1");
        <D.26925>:
        D.26927 = bank != 0;
        D.26928 = (long int) D.26927;
        D.26929 = __builtin_expect (D.26928, 0);
        if (D.26929 != 0) goto <D.26930>; else goto <D.26931>;
        <D.26930>:
        if (sreg < 0) goto <D.26933>; else goto <D.26936>;
        <D.26936>:
        D.26937 = regbank_size[bank];
        if (D.26937 <= sreg) goto <D.26933>; else goto <D.26934>;
        <D.26933>:
        iftmp.28 = 1;
        goto <D.26935>;
        <D.26934>:
        iftmp.28 = 0;
        <D.26935>:
        iftmp.27 = (_Bool) iftmp.28;
        goto <D.26938>;
        <D.26931>:
        iftmp.27 = sreg > 15;
        <D.26938>:
        if (iftmp.27 != 0) goto <D.26939>; else goto <D.26940>;
        <D.26939>:
        sreg.29 = (unsigned int) sreg;
        D.26942 = sreg.29 * 12;
        D.26943 = reginfo + D.26942;
        D.26944 = D.26943->born_in;
        D.26945 = D.26944 <= 0;
        D.26946 = (long int) D.26945;
        D.26947 = __builtin_expect (D.26946, 0);
        if (D.26947 != 0) goto <D.26948>; else goto <D.26949>;
        <D.26948>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1243, "reginfo [sreg].born_in > 0");
        <D.26949>:
        <D.26940>:
        D.26950 = rs->vassign;
        sreg.29 = (unsigned int) sreg;
        D.26951 = sreg.29 * 4;
        D.26952 = D.26950 + D.26951;
        *D.26952 = -1;
        D.26954 = mono_arch_is_soft_float ();
        if (D.26954 != 0) goto <D.26955>; else goto <D.26956>;
        <D.26955>:
        D.26961 = sreg_spec == 108;
        D.26962 = sreg_spec == 76;
        D.26963 = D.26961 | D.26962;
        if (D.26963 != 0) goto <D.26958>; else goto <D.26964>;
        <D.26964>:
        sreg_spec.32 = (unsigned int) sreg_spec;
        D.26966 = sreg_spec.32 + 4294967194;
        if (D.26966 <= 1) goto <D.26958>; else goto <D.26959>;
        <D.26958>:
        iftmp.31 = 1;
        goto <D.26960>;
        <D.26959>:
        iftmp.31 = 0;
        <D.26960>:
        iftmp.30 = (_Bool) iftmp.31;
        goto <D.26967>;
        <D.26956>:
        D.26961 = sreg_spec == 108;
        D.26962 = sreg_spec == 76;
        D.26963 = D.26961 | D.26962;
        D.26968 = (int) D.26963;
        iftmp.30 = (_Bool) D.26968;
        <D.26967>:
        if (iftmp.30 != 0) goto <D.26969>; else goto <D.26970>;
        <D.26969>:
        D.26950 = rs->vassign;
        sreg.33 = (sizetype) sreg;
        D.26972 = sreg.33 + 1;
        D.26973 = D.26972 * 4;
        D.26974 = D.26950 + D.26973;
        *D.26974 = -1;
        sreg.33 = (sizetype) sreg;
        D.26972 = sreg.33 + 1;
        D.26977 = D.26972 * 12;
        D.26978 = reginfo + D.26977;
        D.26979 = D.26978->born_in;
        if (D.26979 == 0) goto <D.26975>; else goto <D.26980>;
        <D.26980>:
        sreg.33 = (sizetype) sreg;
        D.26972 = sreg.33 + 1;
        D.26977 = D.26972 * 12;
        D.26978 = reginfo + D.26977;
        D.26979 = D.26978->born_in;
        if (D.26979 > i) goto <D.26975>; else goto <D.26976>;
        <D.26975>:
        sreg.33 = (sizetype) sreg;
        D.26972 = sreg.33 + 1;
        D.26977 = D.26972 * 12;
        D.26978 = reginfo + D.26977;
        D.26978->born_in = i;
        <D.26976>:
        <D.26970>:
        goto <D.26981>;
        <D.26913>:
        sregs[j] = -1;
        <D.26981>:
      }
      j = j + 1;
      <D.26068>:
      if (j < num_sregs) goto <D.26067>; else goto <D.26069>;
      <D.26069>:
      mono_inst_set_src_registers (ins, &sregs);
      if (spec_dest != 0) goto <D.26982>; else goto <D.26983>;
      <D.26982>:
      {
        int dest_dreg;

        D.26987 = mono_arch_is_soft_float ();
        if (D.26987 == 0) goto <D.26988>; else goto <D.26985>;
        <D.26988>:
        D.26770 = *spec;
        D.26989 = D.26770 + 154;
        if (D.26989 <= 1) goto <D.26990>; else goto <D.26985>;
        <D.26990>:
        iftmp.34 = 1;
        goto <D.26986>;
        <D.26985>:
        iftmp.34 = 0;
        <D.26986>:
        bank = iftmp.34;
        if (spec_dest != 98) goto <D.26991>; else goto <D.26992>;
        <D.26991>:
        D.26827 = ins->dreg;
        D.26832 = (unsigned int) D.26827;
        D.26833 = D.26832 * 12;
        D.26993 = reginfo + D.26833;
        D.26993->killed_in = i;
        <D.26992>:
        D.26827 = ins->dreg;
        D.26994 = D.26827 == -1;
        D.26995 = (long int) D.26994;
        D.26996 = __builtin_expect (D.26995, 0);
        if (D.26996 != 0) goto <D.26997>; else goto <D.26998>;
        <D.26997>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1267, "ins->dreg != -1");
        <D.26998>:
        D.26950 = rs->vassign;
        D.26827 = ins->dreg;
        D.26832 = (unsigned int) D.26827;
        D.26999 = D.26832 * 4;
        D.27000 = D.26950 + D.26999;
        *D.27000 = -1;
        D.26827 = ins->dreg;
        D.26832 = (unsigned int) D.26827;
        D.26833 = D.26832 * 12;
        D.26993 = reginfo + D.26833;
        D.27003 = D.26993->born_in;
        if (D.27003 == 0) goto <D.27001>; else goto <D.27004>;
        <D.27004>:
        D.26827 = ins->dreg;
        D.26832 = (unsigned int) D.26827;
        D.26833 = D.26832 * 12;
        D.26993 = reginfo + D.26833;
        D.27003 = D.26993->born_in;
        if (D.27003 > i) goto <D.27001>; else goto <D.27002>;
        <D.27001>:
        D.26827 = ins->dreg;
        D.26832 = (unsigned int) D.26827;
        D.26833 = D.26832 * 12;
        D.26993 = reginfo + D.26833;
        D.26993->born_in = i;
        <D.27002>:
        D.27005 = (int) spec_dest;
        D.27006 = desc_to_fixed_reg[D.27005];
        dest_dreg = (int) D.27006;
        if (dest_dreg != -1) goto <D.27007>; else goto <D.27008>;
        <D.27007>:
        D.26827 = ins->dreg;
        D.26832 = (unsigned int) D.26827;
        D.26833 = D.26832 * 12;
        D.26993 = reginfo + D.26833;
        D.27009 = 1 << dest_dreg;
        D.26993->preferred_mask = D.27009;
        <D.27008>:
        D.27011 = mono_arch_is_soft_float ();
        if (D.27011 != 0) goto <D.27012>; else goto <D.27013>;
        <D.27012>:
        D.27018 = spec_dest == 108;
        D.27019 = spec_dest == 76;
        D.27020 = D.27018 | D.27019;
        if (D.27020 != 0) goto <D.27015>; else goto <D.27021>;
        <D.27021>:
        D.27022 = spec_dest + 154;
        if (D.27022 <= 1) goto <D.27015>; else goto <D.27016>;
        <D.27015>:
        iftmp.36 = 1;
        goto <D.27017>;
        <D.27016>:
        iftmp.36 = 0;
        <D.27017>:
        iftmp.35 = (_Bool) iftmp.36;
        goto <D.27023>;
        <D.27013>:
        D.27018 = spec_dest == 108;
        D.27019 = spec_dest == 76;
        D.27020 = D.27018 | D.27019;
        D.27024 = (int) D.27020;
        iftmp.35 = (_Bool) D.27024;
        <D.27023>:
        if (iftmp.35 != 0) goto <D.27025>; else goto <D.27026>;
        <D.27025>:
        D.26950 = rs->vassign;
        D.26827 = ins->dreg;
        D.26853 = (sizetype) D.26827;
        D.26854 = D.26853 + 1;
        D.27027 = D.26854 * 4;
        D.27028 = D.26950 + D.27027;
        *D.27028 = -1;
        D.26827 = ins->dreg;
        D.26853 = (sizetype) D.26827;
        D.26854 = D.26853 + 1;
        D.26855 = D.26854 * 12;
        D.26856 = reginfo + D.26855;
        D.27031 = D.26856->born_in;
        if (D.27031 == 0) goto <D.27029>; else goto <D.27032>;
        <D.27032>:
        D.26827 = ins->dreg;
        D.26853 = (sizetype) D.26827;
        D.26854 = D.26853 + 1;
        D.26855 = D.26854 * 12;
        D.26856 = reginfo + D.26855;
        D.27031 = D.26856->born_in;
        if (D.27031 > i) goto <D.27029>; else goto <D.27030>;
        <D.27029>:
        D.26827 = ins->dreg;
        D.26853 = (sizetype) D.26827;
        D.26854 = D.26853 + 1;
        D.26855 = D.26854 * 12;
        D.26856 = reginfo + D.26855;
        D.26856->born_in = i;
        <D.27030>:
        D.27018 = spec_dest == 108;
        D.27035 = spec_dest == 102;
        D.27036 = D.27018 | D.27035;
        if (D.27036 != 0) goto <D.27033>; else goto <D.27037>;
        <D.27037>:
        if (spec_dest == 103) goto <D.27033>; else goto <D.27034>;
        <D.27033>:
        D.26827 = ins->dreg;
        D.26853 = (sizetype) D.26827;
        D.26854 = D.26853 + 1;
        D.26855 = D.26854 * 12;
        D.26856 = reginfo + D.26855;
        D.27018 = spec_dest == 108;
        D.27035 = spec_dest == 102;
        D.27036 = D.27018 | D.27035;
        if (D.27036 != 0) goto <D.27039>; else goto <D.27042>;
        <D.27042>:
        if (spec_dest == 103) goto <D.27039>; else goto <D.27040>;
        <D.27039>:
        D.27018 = spec_dest == 108;
        D.27035 = spec_dest == 102;
        D.27036 = D.27018 | D.27035;
        if (D.27036 != 0) goto <D.27044>; else goto <D.27047>;
        <D.27047>:
        if (spec_dest == 103) goto <D.27044>; else goto <D.27045>;
        <D.27044>:
        iftmp.38 = 2;
        goto <D.27046>;
        <D.27045>:
        iftmp.38 = 0;
        <D.27046>:
        iftmp.37 = iftmp.38;
        goto <D.27041>;
        <D.27040>:
        iftmp.37 = 4111;
        <D.27041>:
        D.26856->preferred_mask = iftmp.37;
        <D.27034>:
        <D.27026>:
      }
      goto <D.27048>;
      <D.26983>:
      ins->dreg = -1;
      <D.27048>:
      D.27051 = spec + 5;
      D.27052 = *D.27051;
      if (D.27052 == 99) goto <D.27053>; else goto <D.27054>;
      <D.27053>:
      D.27055 = ins->opcode;
      D.27056 = D.27055 + 65193;
      D.27057 = D.27056 <= 2;
      D.27058 = D.27055 + 65187;
      D.27059 = D.27058 <= 2;
      D.27060 = D.27057 | D.27059;
      if (D.27060 != 0) goto <D.27049>; else goto <D.27061>;
      <D.27061>:
      D.26822 = ins->opcode;
      D.27062 = D.26822 + 65184;
      if (D.27062 <= 2) goto <D.27049>; else goto <D.27063>;
      <D.27063>:
      D.26822 = ins->opcode;
      D.27064 = D.26822 + 65181;
      if (D.27064 <= 2) goto <D.27049>; else goto <D.27065>;
      <D.27065>:
      D.26822 = ins->opcode;
      D.27066 = D.26822 + 65190;
      if (D.27066 <= 2) goto <D.27049>; else goto <D.27067>;
      <D.27067>:
      D.26822 = ins->opcode;
      D.27068 = D.26822 + 65178;
      if (D.27068 <= 2) goto <D.27049>; else goto <D.27069>;
      <D.27069>:
      D.26822 = ins->opcode;
      if (D.26822 == 444) goto <D.27049>; else goto <D.27050>;
      <D.27049>:
      {
        struct MonoCallInst * call;
        struct GSList * list;

        call = ins;
        list = call->out_ireg_args;
        if (list != 0B) goto <D.27070>; else goto <D.27071>;
        <D.27070>:
        goto <D.26077>;
        <D.26076>:
        {
          guint32 regpair;
          int reg;
          int hreg;

          D.27072 = list->data;
          regpair = (guint32) D.27072;
          D.27073 = regpair >> 24;
          hreg = (int) D.27073;
          regpair.39 = (int) regpair;
          reg = regpair.39 & 16777215;
          if (list != 0B) goto <D.27076>; else goto <D.27077>;
          <D.27076>:
          iftmp.40 = list->next;
          goto <D.27078>;
          <D.27077>:
          iftmp.40 = 0B;
          <D.27078>:
          list = iftmp.40;
        }
        <D.26077>:
        if (list != 0B) goto <D.26076>; else goto <D.26078>;
        <D.26078>:
        <D.27071>:
        list = call->out_freg_args;
        if (list != 0B) goto <D.27079>; else goto <D.27080>;
        <D.27079>:
        goto <D.26083>;
        <D.26082>:
        {
          guint32 regpair;
          int reg;
          int hreg;

          D.27072 = list->data;
          regpair = (guint32) D.27072;
          D.27081 = regpair >> 24;
          hreg = (int) D.27081;
          regpair.41 = (int) regpair;
          reg = regpair.41 & 16777215;
          if (list != 0B) goto <D.27084>; else goto <D.27085>;
          <D.27084>:
          iftmp.42 = list->next;
          goto <D.27086>;
          <D.27085>:
          iftmp.42 = 0B;
          <D.27086>:
          list = iftmp.42;
        }
        <D.26083>:
        if (list != 0B) goto <D.26082>; else goto <D.26084>;
        <D.26084>:
        <D.27080>:
      }
      <D.27050>:
      <D.27054>:
      i = i + 1;
      ins = ins->next;
      <D.26086>:
      if (ins != 0B) goto <D.26085>; else goto <D.26087>;
      <D.26087>:
      tmp = &last;
      D.26819 = cfg->verbose_level;
      D.26898 = D.26819 > 2;
      D.26899 = (long int) D.26898;
      D.26900 = __builtin_expect (D.26899, 0);
      if (D.26900 != 0) goto <D.27087>; else goto <D.27088>;
      <D.27087>:
      D.26813 = rs->next_vreg;
      print_regtrack (reginfo, D.26813);
      <D.27088>:
      ins = bb->last_ins;
      if (ins != 0B) goto <D.27090>; else goto <D.27091>;
      <D.27090>:
      iftmp.43 = ins->prev;
      goto <D.27092>;
      <D.27091>:
      iftmp.43 = 0B;
      <D.27092>:
      prev = iftmp.43;
      goto <D.26216>;
      <D.26215>:
      {
        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.26822 = ins->opcode;
            D.26823 = (int) D.26822;
            D.26824 = D.26823 + -313;
            D.26825 = arm_cpu_desc_idx[D.26824];
            D.26826 = (sizetype) D.26825;
            spec = &arm_cpu_desc + D.26826;
            D.26777 = spec + 1;
            spec_src1 = *D.26777;
            spec_dest = *spec;
            prev_dreg = -1;
            clob_dreg = -1;
            clob_reg = -1;
            dest_dreg = -1;
            dreg_high = -1;
            sreg1_high = -1;
            dreg_mask = get_callee_mask (spec_dest);
            j = 0;
            goto <D.26103>;
            <D.26102>:
            prev_sregs[j] = -1;
            D.26880 = j + 1;
            D.26881 = (sizetype) D.26880;
            D.26882 = spec + D.26881;
            D.26883 = *D.26882;
            D.27093 = get_callee_mask (D.26883);
            sreg_masks[j] = D.27093;
            D.26880 = j + 1;
            D.26881 = (sizetype) D.26880;
            D.26882 = spec + D.26881;
            D.26883 = *D.26882;
            D.27094 = (int) D.26883;
            D.27095 = desc_to_fixed_reg[D.27094];
            D.27096 = (int) D.27095;
            dest_sregs[j] = D.27096;
            sreg_fixed_masks[j] = 0;
            j = j + 1;
            <D.26103>:
            if (j <= 2) goto <D.26102>; else goto <D.26104>;
            <D.26104>:
            D.26819 = cfg->verbose_level;
            D.26898 = D.26819 > 2;
            D.26899 = (long int) D.26898;
            D.26900 = __builtin_expect (D.26899, 0);
            if (D.26900 != 0) goto <D.27097>; else goto <D.27098>;
            <D.27097>:
            printf ("processing:");
            <D.27098>:
            D.26819 = cfg->verbose_level;
            D.26898 = D.26819 > 2;
            D.26899 = (long int) D.26898;
            D.26900 = __builtin_expect (D.26899, 0);
            if (D.26900 != 0) goto <D.27099>; else goto <D.27100>;
            <D.27099>:
            mono_print_ins_index (i, ins);
            <D.27100>:
            ip = ins->cil_code;
            last = ins;
            D.27005 = (int) spec_dest;
            D.27006 = desc_to_fixed_reg[D.27005];
            dest_dreg = (int) D.27006;
            D.27051 = spec + 5;
            D.27052 = *D.27051;
            D.27101 = (int) D.27052;
            D.27102 = desc_to_fixed_reg[D.27101];
            clob_reg = (int) D.27102;
            D.27103 = sreg_masks[1];
            sreg_masks[1] = D.27103;
            dreg_fixed_mask = 0;
            D.26857 = ins->sreg1;
            sregs[0] = D.26857;
            D.26858 = ins->sreg2;
            sregs[1] = D.26858;
            D.26859 = ins->sreg3;
            sregs[2] = D.26859;
            D.26822 = ins->opcode;
            D.26823 = (int) D.26822;
            D.26824 = D.26823 + -313;
            D.26860 = ins_sreg_counts[D.26824];
            num_sregs = (int) D.26860;
            j = 1;
            goto <D.26135>;
            <D.26134>:
            {
              int sreg;
              int dest_sreg;

              sreg = sregs[j];
              dest_sreg = dest_sregs[j];
              if (dest_sreg == -1) goto <D.27104>; else goto <D.27105>;
              <D.27104>:
              // predicted unlikely by continue predictor.
              goto <D.26107>;
              <D.27105>:
              if (j == 2) goto <D.27106>; else goto <D.27107>;
              <D.27106>:
              {
                int k;

                D.27108 = 1 << dest_sreg;
                sreg_masks[j] = D.27108;
                k = 0;
                goto <D.26110>;
                <D.26109>:
                if (k != j) goto <D.27109>; else goto <D.27110>;
                <D.27109>:
                D.27111 = sreg_masks[k];
                D.27108 = 1 << dest_sreg;
                D.27112 = ~D.27108;
                D.27113 = D.27111 & D.27112;
                sreg_masks[k] = D.27113;
                <D.27110>:
                k = k + 1;
                <D.26110>:
                if (k < num_sregs) goto <D.26109>; else goto <D.26111>;
                <D.26111>:
                k = 0;
                goto <D.26113>;
                <D.26112>:
                if (k != j) goto <D.27114>; else goto <D.27115>;
                <D.27114>:
                D.27116 = sregs[k];
                if (D.27116 > 15) goto <D.27117>; else goto <D.27118>;
                <D.27117>:
                D.26950 = rs->vassign;
                D.27116 = sregs[k];
                D.27119 = (unsigned int) D.27116;
                D.27120 = D.27119 * 4;
                D.27121 = D.26950 + D.27120;
                D.27122 = *D.27121;
                if (D.27122 == dest_sreg) goto <D.27123>; else goto <D.27124>;
                <D.27123>:
                free_up_hreg (cfg, bb, tmp, ins, dest_sreg, 0);
                <D.27124>:
                <D.27118>:
                <D.27115>:
                k = k + 1;
                <D.26113>:
                if (k < num_sregs) goto <D.26112>; else goto <D.26114>;
                <D.26114>:
                if (sreg > 15) goto <D.27125>; else goto <D.27126>;
                <D.27125>:
                D.26950 = rs->vassign;
                sreg.44 = (unsigned int) sreg;
                D.27128 = sreg.44 * 4;
                D.27129 = D.26950 + D.27128;
                D.27130 = *D.27129;
                if (D.27130 >= 0) goto <D.27131>; else goto <D.27132>;
                <D.27131>:
                D.26950 = rs->vassign;
                sreg.44 = (unsigned int) sreg;
                D.27128 = sreg.44 * 4;
                D.27129 = D.26950 + D.27128;
                D.27130 = *D.27129;
                if (D.27130 != dest_sreg) goto <D.27133>; else goto <D.27134>;
                <D.27133>:
                spill_vreg (cfg, bb, tmp, ins, sreg, 0);
                <D.27134>:
                <D.27132>:
                <D.27126>:
                // predicted unlikely by continue predictor.
                goto <D.26107>;
              }
              <D.27107>:
              D.27135 = rs->ifree_mask;
              D.27108 = 1 << dest_sreg;
              D.27136 = D.27135 & D.27108;
              if (D.27136 != 0) goto <D.27137>; else goto <D.27138>;
              <D.27137>:
              sreg.45 = (unsigned int) sreg;
              if (sreg.45 <= 15) goto <D.27142>; else goto <D.27139>;
              <D.27142>:
              D.27143 = 2032 >> sreg;
              D.27144 = D.27143 & 1;
              if (D.27144 != 0) goto <D.27145>; else goto <D.27139>;
              <D.27145>:
              {
                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.26118>;
                <D.26117>:
                if (k != j) goto <D.27146>; else goto <D.27147>;
                <D.27146>:
                D.27148 = sreg_masks[k];
                D.27108 = 1 << dest_sreg;
                D.27112 = ~D.27108;
                D.27149 = D.27148 & D.27112;
                sreg_masks[k] = D.27149;
                <D.27147>:
                k = k + 1;
                <D.26118>:
                if (k < num_sregs) goto <D.26117>; else goto <D.26119>;
                <D.26119>:
              }
              goto <D.27140>;
              <D.27139>:
              D.26950 = rs->vassign;
              sreg.44 = (unsigned int) sreg;
              D.27128 = sreg.44 * 4;
              D.27129 = D.26950 + D.27128;
              val = *D.27129;
              if (val == -1) goto <D.27150>; else goto <D.27151>;
              <D.27150>:
              D.26819 = cfg->verbose_level;
              D.26898 = D.26819 > 2;
              D.26899 = (long int) D.26898;
              D.26900 = __builtin_expect (D.26899, 0);
              if (D.26900 != 0) goto <D.27152>; else goto <D.27153>;
              <D.27152>:
              D.27154 = mono_arch_regname (dest_sreg);
              printf ("\tshortcut assignment of R%d to %s\n", sreg, D.27154);
              <D.27153>:
              assign_reg (cfg, rs, sreg, dest_sreg, 0);
              goto <D.27155>;
              <D.27151>:
              if (val < -1) goto <D.27156>; else goto <D.27157>;
              <D.27156>:
              monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-codegen.c", 1459);
              <D.27157>:
              {
                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.26123>;
                <D.26122>:
                if (k != j) goto <D.27158>; else goto <D.27159>;
                <D.27158>:
                D.27160 = sreg_masks[k];
                D.27108 = 1 << dest_sreg;
                D.27112 = ~D.27108;
                D.27161 = D.27160 & D.27112;
                sreg_masks[k] = D.27161;
                <D.27159>:
                k = k + 1;
                <D.26123>:
                if (k < num_sregs) goto <D.26122>; else goto <D.26124>;
                <D.26124>:
                D.27108 = 1 << dest_sreg;
                D.27112 = ~D.27108;
                dreg_mask = D.27112 & dreg_mask;
              }
              <D.27155>:
              <D.27140>:
              goto <D.27162>;
              <D.27138>:
              {
                gboolean need_spill;
                gboolean need_assign;
                int k;

                need_spill = 1;
                need_assign = 1;
                D.27108 = 1 << dest_sreg;
                D.27112 = ~D.27108;
                dreg_mask = D.27112 & dreg_mask;
                k = 0;
                goto <D.26129>;
                <D.26128>:
                if (k != j) goto <D.27163>; else goto <D.27164>;
                <D.27163>:
                D.27165 = sreg_masks[k];
                D.27108 = 1 << dest_sreg;
                D.27112 = ~D.27108;
                D.27166 = D.27165 & D.27112;
                sreg_masks[k] = D.27166;
                <D.27164>:
                k = k + 1;
                <D.26129>:
                if (k < num_sregs) goto <D.26128>; else goto <D.26130>;
                <D.26130>:
                D.26770 = *spec;
                if (D.26770 != 0) goto <D.27167>; else goto <D.27168>;
                <D.27167>:
                D.26950 = rs->vassign;
                D.26827 = ins->dreg;
                D.26832 = (unsigned int) D.26827;
                D.26999 = D.26832 * 4;
                D.27000 = D.26950 + D.26999;
                val = *D.27000;
                goto <D.27169>;
                <D.27168>:
                val = -1;
                <D.27169>:
                if (val == dest_sreg) goto <D.27170>; else goto <D.27171>;
                <D.27170>:
                D.26827 = ins->dreg;
                if (D.26827 != sreg) goto <D.27172>; else goto <D.27173>;
                <D.27172>:
                {
                  int new_dest;

                  D.26827 = ins->dreg;
                  D.26827 = ins->dreg;
                  D.26832 = (unsigned int) D.26827;
                  D.26833 = D.26832 * 12;
                  D.26993 = reginfo + D.26833;
                  new_dest = alloc_int_reg (cfg, bb, tmp, ins, dreg_mask, D.26827, D.26993);
                  D.27174 = new_dest < 0;
                  D.27175 = (long int) D.27174;
                  D.27176 = __builtin_expect (D.27175, 0);
                  if (D.27176 != 0) goto <D.27177>; else goto <D.27178>;
                  <D.27177>:
                  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1505, "new_dest >= 0");
                  <D.27178>:
                  D.26819 = cfg->verbose_level;
                  D.26898 = D.26819 > 2;
                  D.26899 = (long int) D.26898;
                  D.26900 = __builtin_expect (D.26899, 0);
                  if (D.26900 != 0) goto <D.27179>; else goto <D.27180>;
                  <D.27179>:
                  D.26827 = ins->dreg;
                  D.27181 = mono_arch_regname (new_dest);
                  D.27182 = mono_arch_regname (dest_sreg);
                  printf ("\tchanging dreg R%d to %s from %s\n", D.26827, D.27181, D.27182);
                  <D.27180>:
                  prev_dreg = ins->dreg;
                  D.26827 = ins->dreg;
                  assign_reg (cfg, rs, D.26827, 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.27173>:
                <D.27171>:
                sreg.45 = (unsigned int) sreg;
                if (sreg.45 <= 15) goto <D.27185>; else goto <D.27183>;
                <D.27185>:
                D.27143 = 2032 >> sreg;
                D.27144 = D.27143 & 1;
                if (D.27144 != 0) goto <D.27186>; else goto <D.27183>;
                <D.27186>:
                {
                  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.27184>;
                <D.27183>:
                D.26950 = rs->vassign;
                sreg.44 = (unsigned int) sreg;
                D.27128 = sreg.44 * 4;
                D.27129 = D.26950 + D.27128;
                val = *D.27129;
                if (val == dest_sreg) goto <D.27187>; else goto <D.27188>;
                <D.27187>:
                need_spill = 0;
                goto <D.27189>;
                <D.27188>:
                if (val < -1) goto <D.27190>; else goto <D.27191>;
                <D.27190>:
                goto <D.27192>;
                <D.27191>:
                if (val >= 0) goto <D.27193>; else goto <D.27194>;
                <D.27193>:
                free_up_hreg (cfg, bb, tmp, ins, val, 0);
                <D.27194>:
                <D.27192>:
                <D.27189>:
                <D.27184>:
                if (need_spill != 0) goto <D.27195>; else goto <D.27196>;
                <D.27195>:
                free_up_hreg (cfg, bb, tmp, ins, dest_sreg, 0);
                <D.27196>:
                if (need_assign != 0) goto <D.27197>; else goto <D.27198>;
                <D.27197>:
                D.26950 = rs->vassign;
                sreg.44 = (unsigned int) sreg;
                D.27128 = sreg.44 * 4;
                D.27129 = D.26950 + D.27128;
                D.27130 = *D.27129;
                if (D.27130 < -1) goto <D.27199>; else goto <D.27200>;
                <D.27199>:
                {
                  int spill;

                  D.26950 = rs->vassign;
                  sreg.44 = (unsigned int) sreg;
                  D.27128 = sreg.44 * 4;
                  D.27129 = D.26950 + D.27128;
                  D.27130 = *D.27129;
                  spill = ~D.27130;
                  create_spilled_store (cfg, bb, spill, dest_sreg, sreg, tmp, 0B, ins, bank);
                }
                <D.27200>:
                D.26861 = sregs[j];
                assign_reg (cfg, rs, D.26861, dest_sreg, 0);
                <D.27198>:
              }
              <D.27162>:
              sregs[j] = dest_sreg;
            }
            <D.26107>:
            j = j + 1;
            <D.26135>:
            if (j < num_sregs) goto <D.26134>; else goto <D.26136>;
            <D.26136>:
            mono_inst_set_src_registers (ins, &sregs);
            D.27204 = mono_arch_is_soft_float ();
            if (D.27204 == 0) goto <D.27205>; else goto <D.27202>;
            <D.27205>:
            D.26770 = *spec;
            D.26989 = D.26770 + 154;
            if (D.26989 <= 1) goto <D.27206>; else goto <D.27202>;
            <D.27206>:
            iftmp.46 = 1;
            goto <D.27203>;
            <D.27202>:
            iftmp.46 = 0;
            <D.27203>:
            bank = iftmp.46;
            if (spec_dest != 0) goto <D.27207>; else goto <D.27208>;
            <D.27207>:
            D.26927 = bank != 0;
            D.26928 = (long int) D.26927;
            D.26929 = __builtin_expect (D.26928, 0);
            if (D.26929 != 0) goto <D.27210>; else goto <D.27211>;
            <D.27210>:
            D.26827 = ins->dreg;
            if (D.26827 < 0) goto <D.27213>; else goto <D.27216>;
            <D.27216>:
            D.26827 = ins->dreg;
            D.26937 = regbank_size[bank];
            if (D.26827 >= D.26937) goto <D.27213>; else goto <D.27214>;
            <D.27213>:
            iftmp.48 = 1;
            goto <D.27215>;
            <D.27214>:
            iftmp.48 = 0;
            <D.27215>:
            iftmp.47 = (_Bool) iftmp.48;
            goto <D.27217>;
            <D.27211>:
            D.26827 = ins->dreg;
            iftmp.47 = D.26827 > 15;
            <D.27217>:
            if (iftmp.47 != 0) goto <D.27218>; else goto <D.27219>;
            <D.27218>:
            prev_dreg = ins->dreg;
            <D.27219>:
            <D.27208>:
            if (spec_dest == 98) goto <D.27220>; else goto <D.27221>;
            <D.27220>:
            D.27222 = dest_sregs[0];
            if (D.27222 != -1) goto <D.27223>; else goto <D.27224>;
            <D.27223>:
            D.27222 = dest_sregs[0];
            D.27225 = 1 << D.27222;
            D.27226 = ~D.27225;
            dreg_mask = D.27226 & dreg_mask;
            <D.27224>:
            j = 1;
            goto <D.26138>;
            <D.26137>:
            D.27227 = dest_sregs[j];
            if (D.27227 != -1) goto <D.27228>; else goto <D.27229>;
            <D.27228>:
            D.27227 = dest_sregs[j];
            D.27230 = 1 << D.27227;
            D.27231 = ~D.27230;
            dreg_mask = D.27231 & dreg_mask;
            <D.27229>:
            j = j + 1;
            <D.26138>:
            if (j < num_sregs) goto <D.26137>; else goto <D.26139>;
            <D.26139>:
            D.26950 = rs->vassign;
            D.26827 = ins->dreg;
            D.26832 = (unsigned int) D.26827;
            D.26999 = D.26832 * 4;
            D.27000 = D.26950 + D.26999;
            val = *D.27000;
            D.26927 = bank != 0;
            D.26928 = (long int) D.26927;
            D.26929 = __builtin_expect (D.26928, 0);
            if (D.26929 != 0) goto <D.27233>; else goto <D.27234>;
            <D.27233>:
            D.26827 = ins->dreg;
            if (D.26827 < 0) goto <D.27236>; else goto <D.27239>;
            <D.27239>:
            D.26827 = ins->dreg;
            D.26937 = regbank_size[bank];
            if (D.26827 >= D.26937) goto <D.27236>; else goto <D.27237>;
            <D.27236>:
            iftmp.50 = 1;
            goto <D.27238>;
            <D.27237>:
            iftmp.50 = 0;
            <D.27238>:
            iftmp.49 = (_Bool) iftmp.50;
            goto <D.27240>;
            <D.27234>:
            D.26827 = ins->dreg;
            iftmp.49 = D.26827 > 15;
            <D.27240>:
            if (iftmp.49 != 0) goto <D.27241>; else goto <D.27242>;
            <D.27241>:
            if (val >= 0) goto <D.27243>; else goto <D.27244>;
            <D.27243>:
            D.27245 = dreg_mask >> val;
            D.27246 = D.27245 & 1;
            if (D.27246 == 0) goto <D.27247>; else goto <D.27248>;
            <D.27247>:
            D.26827 = ins->dreg;
            spill_vreg (cfg, bb, tmp, ins, D.26827, 0);
            <D.27248>:
            <D.27244>:
            <D.27242>:
            <D.27221>:
            D.27250 = mono_arch_is_soft_float ();
            if (D.27250 != 0) goto <D.27251>; else goto <D.27252>;
            <D.27251>:
            D.27018 = spec_dest == 108;
            D.27019 = spec_dest == 76;
            D.27020 = D.27018 | D.27019;
            if (D.27020 != 0) goto <D.27254>; else goto <D.27257>;
            <D.27257>:
            D.27022 = spec_dest + 154;
            if (D.27022 <= 1) goto <D.27254>; else goto <D.27255>;
            <D.27254>:
            iftmp.52 = 1;
            goto <D.27256>;
            <D.27255>:
            iftmp.52 = 0;
            <D.27256>:
            iftmp.51 = (_Bool) iftmp.52;
            goto <D.27258>;
            <D.27252>:
            D.27018 = spec_dest == 108;
            D.27019 = spec_dest == 76;
            D.27020 = D.27018 | D.27019;
            D.27024 = (int) D.27020;
            iftmp.51 = (_Bool) D.27024;
            <D.27258>:
            if (iftmp.51 != 0) goto <D.27259>; else goto <D.27260>;
            <D.27259>:
            {
              guint32 dreg2;
              guint32 dest_dreg2;

              D.26927 = bank != 0;
              D.26928 = (long int) D.26927;
              D.26929 = __builtin_expect (D.26928, 0);
              if (D.26929 != 0) goto <D.27262>; else goto <D.27263>;
              <D.27262>:
              D.26827 = ins->dreg;
              if (D.26827 >= 0) goto <D.27267>; else goto <D.27265>;
              <D.27267>:
              D.26827 = ins->dreg;
              D.26937 = regbank_size[bank];
              if (D.26827 < D.26937) goto <D.27268>; else goto <D.27265>;
              <D.27268>:
              iftmp.54 = 1;
              goto <D.27266>;
              <D.27265>:
              iftmp.54 = 0;
              <D.27266>:
              D.27269 = iftmp.54 != 0;
              iftmp.53 = (long int) D.27269;
              goto <D.27270>;
              <D.27263>:
              D.26827 = ins->dreg;
              D.27271 = D.26827 <= 15;
              iftmp.53 = (long int) D.27271;
              <D.27270>:
              D.27272 = __builtin_expect (iftmp.53, 0);
              if (D.27272 != 0) goto <D.27273>; else goto <D.27274>;
              <D.27273>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1594, "is_soft_reg (ins->dreg, bank)");
              <D.27274>:
              if (dest_dreg != -1) goto <D.27275>; else goto <D.27276>;
              <D.27275>:
              D.26950 = rs->vassign;
              D.26827 = ins->dreg;
              D.26832 = (unsigned int) D.26827;
              D.26999 = D.26832 * 4;
              D.27000 = D.26950 + D.26999;
              D.27277 = *D.27000;
              if (D.27277 != dest_dreg) goto <D.27278>; else goto <D.27279>;
              <D.27278>:
              free_up_hreg (cfg, bb, tmp, ins, dest_dreg, 0);
              <D.27279>:
              D.26827 = ins->dreg;
              D.27280 = D.26827 + 1;
              dreg2 = (guint32) D.27280;
              D.27018 = spec_dest == 108;
              D.27035 = spec_dest == 102;
              D.27036 = D.27018 | D.27035;
              if (D.27036 != 0) goto <D.27282>; else goto <D.27285>;
              <D.27285>:
              if (spec_dest == 103) goto <D.27282>; else goto <D.27283>;
              <D.27282>:
              iftmp.55 = 1;
              goto <D.27284>;
              <D.27283>:
              iftmp.55 = 4294967295;
              <D.27284>:
              dest_dreg2 = iftmp.55;
              if (dest_dreg2 != 4294967295) goto <D.27286>; else goto <D.27287>;
              <D.27286>:
              D.26950 = rs->vassign;
              D.27288 = dreg2 * 4;
              D.27289 = D.26950 + D.27288;
              D.27290 = *D.27289;
              D.27291 = (unsigned int) D.27290;
              if (D.27291 != dest_dreg2) goto <D.27292>; else goto <D.27293>;
              <D.27292>:
              dest_dreg2.56 = (int) dest_dreg2;
              free_up_hreg (cfg, bb, tmp, ins, dest_dreg2.56, 0);
              <D.27293>:
              <D.27287>:
              <D.27276>:
            }
            <D.27260>:
            if (dreg_fixed_mask != 0) goto <D.27295>; else goto <D.27296>;
            <D.27295>:
            D.26927 = bank != 0;
            D.26928 = (long int) D.26927;
            D.26929 = __builtin_expect (D.26928, 0);
            if (D.26929 != 0) goto <D.27297>; else goto <D.27298>;
            <D.27297>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1610, "!bank");
            <D.27298>:
            D.26827 = ins->dreg;
            D.27301 = (unsigned int) D.26827;
            if (D.27301 <= 15) goto <D.27302>; else goto <D.27299>;
            <D.27302>:
            D.26827 = ins->dreg;
            D.27303 = 2032 >> D.26827;
            D.27304 = D.27303 & 1;
            if (D.27304 != 0) goto <D.27305>; else goto <D.27299>;
            <D.27305>:
            val = mono_regstate_alloc_int (rs, dreg_fixed_mask);
            if (val < 0) goto <D.27306>; else goto <D.27307>;
            <D.27306>:
            val = get_register_spilling (cfg, bb, tmp, ins, dreg_fixed_mask, -1, bank);
            <D.27307>:
            mono_regstate_free_int (rs, val);
            dest_dreg = val;
            goto <D.27300>;
            <D.27299>:
            dreg_mask = dreg_mask & dreg_fixed_mask;
            <D.27300>:
            <D.27296>:
            D.26927 = bank != 0;
            D.26928 = (long int) D.26927;
            D.26929 = __builtin_expect (D.26928, 0);
            if (D.26929 != 0) goto <D.27309>; else goto <D.27310>;
            <D.27309>:
            D.26827 = ins->dreg;
            if (D.26827 < 0) goto <D.27312>; else goto <D.27315>;
            <D.27315>:
            D.26827 = ins->dreg;
            D.26937 = regbank_size[bank];
            if (D.26827 >= D.26937) goto <D.27312>; else goto <D.27313>;
            <D.27312>:
            iftmp.58 = 1;
            goto <D.27314>;
            <D.27313>:
            iftmp.58 = 0;
            <D.27314>:
            iftmp.57 = (_Bool) iftmp.58;
            goto <D.27316>;
            <D.27310>:
            D.26827 = ins->dreg;
            iftmp.57 = D.26827 > 15;
            <D.27316>:
            if (iftmp.57 != 0) goto <D.27317>; else goto <D.27318>;
            <D.27317>:
            D.26950 = rs->vassign;
            D.26827 = ins->dreg;
            D.26832 = (unsigned int) D.26827;
            D.26999 = D.26832 * 4;
            D.27000 = D.26950 + D.26999;
            val = *D.27000;
            if (val < 0) goto <D.27319>; else goto <D.27320>;
            <D.27319>:
            {
              int spill;

              spill = 0;
              if (val < -1) goto <D.27321>; else goto <D.27322>;
              <D.27321>:
              spill = ~val;
              <D.27322>:
              D.26827 = ins->dreg;
              D.26827 = ins->dreg;
              D.26832 = (unsigned int) D.26827;
              D.26833 = D.26832 * 12;
              D.26993 = reginfo + D.26833;
              val = alloc_reg (cfg, bb, tmp, ins, dreg_mask, D.26827, D.26993, bank);
              D.26827 = ins->dreg;
              assign_reg (cfg, rs, D.26827, val, bank);
              if (spill != 0) goto <D.27323>; else goto <D.27324>;
              <D.27323>:
              create_spilled_store (cfg, bb, spill, val, prev_dreg, tmp, ins, 0B, bank);
              <D.27324>:
            }
            <D.27320>:
            D.26819 = cfg->verbose_level;
            D.26898 = D.26819 > 2;
            D.26899 = (long int) D.26898;
            D.26900 = __builtin_expect (D.26899, 0);
            if (D.26900 != 0) goto <D.27325>; else goto <D.27326>;
            <D.27325>:
            D.27327 = mono_regname_full (val, bank);
            D.26827 = ins->dreg;
            printf ("\tassigned dreg %s to dest R%d\n", D.27327, D.26827);
            <D.27326>:
            ins->dreg = val;
            <D.27318>:
            D.27329 = mono_arch_is_soft_float ();
            if (D.27329 != 0) goto <D.27330>; else goto <D.27331>;
            <D.27330>:
            D.27018 = spec_dest == 108;
            D.27019 = spec_dest == 76;
            D.27020 = D.27018 | D.27019;
            if (D.27020 != 0) goto <D.27333>; else goto <D.27336>;
            <D.27336>:
            D.27022 = spec_dest + 154;
            if (D.27022 <= 1) goto <D.27333>; else goto <D.27334>;
            <D.27333>:
            iftmp.60 = 1;
            goto <D.27335>;
            <D.27334>:
            iftmp.60 = 0;
            <D.27335>:
            iftmp.59 = (_Bool) iftmp.60;
            goto <D.27337>;
            <D.27331>:
            D.27018 = spec_dest == 108;
            D.27019 = spec_dest == 76;
            D.27020 = D.27018 | D.27019;
            D.27024 = (int) D.27020;
            iftmp.59 = (_Bool) D.27024;
            <D.27337>:
            if (iftmp.59 != 0) goto <D.27338>; else goto <D.27339>;
            <D.27338>:
            {
              int reg2;

              reg2 = prev_dreg + 1;
              D.26927 = bank != 0;
              D.26928 = (long int) D.26927;
              D.26929 = __builtin_expect (D.26928, 0);
              if (D.26929 != 0) goto <D.27340>; else goto <D.27341>;
              <D.27340>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1651, "!bank");
              <D.27341>:
              D.27342 = prev_dreg < 0;
              D.27343 = (long int) D.27342;
              D.27344 = __builtin_expect (D.27343, 0);
              if (D.27344 != 0) goto <D.27345>; else goto <D.27346>;
              <D.27345>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1652, "prev_dreg > -1");
              <D.27346>:
              D.26950 = rs->vassign;
              prev_dreg.62 = (unsigned int) prev_dreg;
              D.27351 = prev_dreg.62 * 4;
              D.27352 = D.26950 + D.27351;
              D.27353 = *D.27352;
              D.27354 = (unsigned int) D.27353;
              if (D.27354 <= 15) goto <D.27355>; else goto <D.27348>;
              <D.27355>:
              D.26950 = rs->vassign;
              prev_dreg.62 = (unsigned int) prev_dreg;
              D.27351 = prev_dreg.62 * 4;
              D.27352 = D.26950 + D.27351;
              D.27353 = *D.27352;
              D.27356 = 2032 >> D.27353;
              D.27357 = D.27356 & 1;
              if (D.27357 != 0) goto <D.27358>; else goto <D.27348>;
              <D.27358>:
              iftmp.61 = 1;
              goto <D.27349>;
              <D.27348>:
              iftmp.61 = 0;
              <D.27349>:
              D.27359 = iftmp.61 != 0;
              D.27360 = (long int) D.27359;
              D.27361 = __builtin_expect (D.27360, 0);
              if (D.27361 != 0) goto <D.27362>; else goto <D.27363>;
              <D.27362>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1653, "!is_global_ireg (rs->vassign [prev_dreg])");
              <D.27363>:
              D.27018 = spec_dest == 108;
              D.27035 = spec_dest == 102;
              D.27036 = D.27018 | D.27035;
              if (D.27036 != 0) goto <D.27365>; else goto <D.27368>;
              <D.27368>:
              if (spec_dest == 103) goto <D.27365>; else goto <D.27366>;
              <D.27365>:
              D.27018 = spec_dest == 108;
              D.27035 = spec_dest == 102;
              D.27036 = D.27018 | D.27035;
              if (D.27036 != 0) goto <D.27370>; else goto <D.27373>;
              <D.27373>:
              if (spec_dest == 103) goto <D.27370>; else goto <D.27371>;
              <D.27370>:
              iftmp.64 = 2;
              goto <D.27372>;
              <D.27371>:
              iftmp.64 = 0;
              <D.27372>:
              iftmp.63 = iftmp.64;
              goto <D.27367>;
              <D.27366>:
              iftmp.63 = 4111;
              <D.27367>:
              mask = iftmp.63;
              D.26950 = rs->vassign;
              reg2.65 = (unsigned int) reg2;
              D.27375 = reg2.65 * 4;
              D.27376 = D.26950 + D.27375;
              val = *D.27376;
              if (val < 0) goto <D.27377>; else goto <D.27378>;
              <D.27377>:
              {
                int spill;

                spill = 0;
                if (val < -1) goto <D.27379>; else goto <D.27380>;
                <D.27379>:
                spill = ~val;
                <D.27380>:
                val = mono_regstate_alloc_int (rs, mask);
                if (val < 0) goto <D.27381>; else goto <D.27382>;
                <D.27381>:
                val = get_register_spilling (cfg, bb, tmp, ins, mask, reg2, bank);
                <D.27382>:
                if (spill != 0) goto <D.27383>; else goto <D.27384>;
                <D.27383>:
                create_spilled_store (cfg, bb, spill, val, reg2, tmp, ins, 0B, bank);
                <D.27384>:
              }
              goto <D.27385>;
              <D.27378>:
              D.27386 = 1 << val;
              D.27387 = D.27386 & mask;
              if (D.27387 == 0) goto <D.27388>; else goto <D.27389>;
              <D.27388>:
              val = mono_regstate_alloc_int (rs, mask);
              if (val < 0) goto <D.27390>; else goto <D.27391>;
              <D.27390>:
              val = get_register_spilling (cfg, bb, tmp, ins, mask, reg2, bank);
              <D.27391>:
              D.26950 = rs->vassign;
              reg2.65 = (unsigned int) reg2;
              D.27375 = reg2.65 * 4;
              D.27376 = D.26950 + D.27375;
              D.27392 = *D.27376;
              create_copy_ins (cfg, bb, tmp, D.27392, val, ins, ip, bank);
              D.26950 = rs->vassign;
              reg2.65 = (unsigned int) reg2;
              D.27375 = reg2.65 * 4;
              D.27376 = D.26950 + D.27375;
              D.27392 = *D.27376;
              mono_regstate_free_int (rs, D.27392);
              <D.27389>:
              <D.27385>:
              D.26819 = cfg->verbose_level;
              D.26898 = D.26819 > 2;
              D.26899 = (long int) D.26898;
              D.26900 = __builtin_expect (D.26899, 0);
              if (D.26900 != 0) goto <D.27393>; else goto <D.27394>;
              <D.27393>:
              D.27395 = mono_arch_regname (val);
              printf ("\tassigned dreg-high %s to dest R%d\n", D.27395, reg2);
              <D.27394>:
              assign_reg (cfg, rs, reg2, val, bank);
              dreg_high = val;
              ins->backend.reg3 = val;
              D.26927 = bank != 0;
              D.26928 = (long int) D.26927;
              D.26929 = __builtin_expect (D.26928, 0);
              if (D.26929 != 0) goto <D.27397>; else goto <D.27398>;
              <D.27397>:
              D.26927 = bank != 0;
              D.26928 = (long int) D.26927;
              D.26929 = __builtin_expect (D.26928, 0);
              if (D.26929 != 0) goto <D.27400>; else goto <D.27401>;
              <D.27400>:
              D.26927 = bank != 0;
              D.26928 = (long int) D.26927;
              D.26929 = __builtin_expect (D.26928, 0);
              if (D.26929 != 0) goto <D.27405>; else goto <D.27406>;
              <D.27405>:
              if (val >= 0) goto <D.27410>; else goto <D.27408>;
              <D.27410>:
              D.26937 = regbank_size[bank];
              if (D.26937 > val) goto <D.27411>; else goto <D.27408>;
              <D.27411>:
              iftmp.69 = 1;
              goto <D.27409>;
              <D.27408>:
              iftmp.69 = 0;
              <D.27409>:
              D.27412 = (_Bool) iftmp.69;
              if (D.27412 != 0) goto <D.27413>; else goto <D.27403>;
              <D.27413>:
              goto <D.27414>;
              <D.27406>:
              if (val <= 15) goto <D.27415>; else goto <D.27403>;
              <D.27415>:
              <D.27414>:
              D.27416 = regbank_callee_regs[bank];
              D.27417 = D.27416 >> val;
              D.27418 = D.27417 & 1;
              if (D.27418 != 0) goto <D.27419>; else goto <D.27403>;
              <D.27419>:
              iftmp.68 = 1;
              goto <D.27404>;
              <D.27403>:
              iftmp.68 = 0;
              <D.27404>:
              iftmp.67 = (_Bool) iftmp.68;
              goto <D.27420>;
              <D.27401>:
              val.71 = (unsigned int) val;
              if (val.71 <= 15) goto <D.27425>; else goto <D.27422>;
              <D.27425>:
              D.27426 = 4111 >> val;
              D.27427 = D.27426 & 1;
              if (D.27427 != 0) goto <D.27428>; else goto <D.27422>;
              <D.27428>:
              iftmp.70 = 1;
              goto <D.27423>;
              <D.27422>:
              iftmp.70 = 0;
              <D.27423>:
              iftmp.67 = (_Bool) iftmp.70;
              <D.27420>:
              iftmp.66 = iftmp.67;
              goto <D.27429>;
              <D.27398>:
              val.71 = (unsigned int) val;
              if (val.71 <= 15) goto <D.27433>; else goto <D.27431>;
              <D.27433>:
              D.27426 = 4111 >> val;
              D.27427 = D.27426 & 1;
              if (D.27427 != 0) goto <D.27434>; else goto <D.27431>;
              <D.27434>:
              iftmp.72 = 1;
              goto <D.27432>;
              <D.27431>:
              iftmp.72 = 0;
              <D.27432>:
              iftmp.66 = (_Bool) iftmp.72;
              <D.27429>:
              if (iftmp.66 != 0) goto <D.27435>; else goto <D.27436>;
              <D.27435>:
              if (reg2 >= 0) goto <D.27437>; else goto <D.27438>;
              <D.27437>:
              reg2.65 = (unsigned int) reg2;
              D.27439 = reg2.65 * 12;
              D.27440 = reginfo + D.27439;
              D.27441 = D.27440->born_in;
              if (D.27441 >= i) goto <D.27442>; else goto <D.27443>;
              <D.27442>:
              D.26819 = cfg->verbose_level;
              D.26898 = D.26819 > 2;
              D.26899 = (long int) D.26898;
              D.26900 = __builtin_expect (D.26899, 0);
              if (D.26900 != 0) goto <D.27444>; else goto <D.27445>;
              <D.27444>:
              D.27446 = mono_arch_regname (val);
              printf ("\tfreeable %s (R%d)\n", D.27446, reg2);
              <D.27445>:
              mono_regstate_free_int (rs, val);
              <D.27443>:
              <D.27438>:
              <D.27436>:
            }
            <D.27339>:
            if (prev_dreg >= 0) goto <D.27447>; else goto <D.27448>;
            <D.27447>:
            D.26927 = bank != 0;
            D.26928 = (long int) D.26927;
            D.26929 = __builtin_expect (D.26928, 0);
            if (D.26929 != 0) goto <D.27450>; else goto <D.27451>;
            <D.27450>:
            if (prev_dreg < 0) goto <D.27453>; else goto <D.27456>;
            <D.27456>:
            D.26937 = regbank_size[bank];
            if (D.26937 <= prev_dreg) goto <D.27453>; else goto <D.27454>;
            <D.27453>:
            iftmp.74 = 1;
            goto <D.27455>;
            <D.27454>:
            iftmp.74 = 0;
            <D.27455>:
            iftmp.73 = (_Bool) iftmp.74;
            goto <D.27457>;
            <D.27451>:
            iftmp.73 = prev_dreg > 15;
            <D.27457>:
            if (iftmp.73 != 0) goto <D.27458>; else goto <D.27459>;
            <D.27458>:
            if (spec_dest != 98) goto <D.27460>; else goto <D.27461>;
            <D.27460>:
            {
              int dreg;

              D.26950 = rs->vassign;
              prev_dreg.62 = (unsigned int) prev_dreg;
              D.27351 = prev_dreg.62 * 4;
              D.27352 = D.26950 + D.27351;
              dreg = *D.27352;
              D.27462 = dreg < 0;
              D.27463 = (long int) D.27462;
              D.27464 = __builtin_expect (D.27463, 0);
              if (D.27464 != 0) goto <D.27465>; else goto <D.27466>;
              <D.27465>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1704, "dreg >= 0");
              <D.27466>:
              D.26819 = cfg->verbose_level;
              D.26898 = D.26819 > 2;
              D.26899 = (long int) D.26898;
              D.26900 = __builtin_expect (D.26899, 0);
              if (D.26900 != 0) goto <D.27467>; else goto <D.27468>;
              <D.27467>:
              D.27469 = mono_regname_full (dreg, bank);
              prev_dreg.62 = (unsigned int) prev_dreg;
              D.27470 = prev_dreg.62 * 12;
              D.27471 = reginfo + D.27470;
              D.27472 = D.27471->born_in;
              printf ("\tfreeable %s (R%d) (born in %d)\n", D.27469, prev_dreg, D.27472);
              <D.27468>:
              D.26927 = bank != 0;
              D.26928 = (long int) D.26927;
              D.26929 = __builtin_expect (D.26928, 0);
              if (D.26929 != 0) goto <D.27473>; else goto <D.27474>;
              <D.27473>:
              mono_regstate_free_general (rs, dreg, bank);
              goto <D.27475>;
              <D.27474>:
              mono_regstate_free_int (rs, dreg);
              <D.27475>:
              D.26950 = rs->vassign;
              prev_dreg.62 = (unsigned int) prev_dreg;
              D.27351 = prev_dreg.62 * 4;
              D.27352 = D.26950 + D.27351;
              *D.27352 = -1;
            }
            <D.27461>:
            <D.27459>:
            <D.27448>:
            if (dest_dreg != -1) goto <D.27476>; else goto <D.27477>;
            <D.27476>:
            D.26827 = ins->dreg;
            if (D.26827 != dest_dreg) goto <D.27478>; else goto <D.27479>;
            <D.27478>:
            D.26827 = ins->dreg;
            create_copy_ins (cfg, bb, tmp, D.26827, dest_dreg, ins, ip, bank);
            ins->dreg = dest_dreg;
            D.26927 = bank != 0;
            D.26928 = (long int) D.26927;
            D.26929 = __builtin_expect (D.26928, 0);
            if (D.26929 != 0) goto <D.27480>; else goto <D.27481>;
            <D.27480>:
            {
              int translated_bank;

              D.27482 = cfg->rs;
              translated_bank = translate_bank (D.27482, bank, dest_dreg);
              D.27483 = rs->symbolic[translated_bank];
              dest_dreg.75 = (unsigned int) dest_dreg;
              D.27485 = dest_dreg.75 * 4;
              D.27486 = D.27483 + D.27485;
              D.27487 = *D.27486;
              D.27488 = regbank_size[translated_bank];
              if (D.27487 >= D.27488) goto <D.27489>; else goto <D.27490>;
              <D.27489>:
              free_up_hreg (cfg, bb, tmp, ins, dest_dreg, translated_bank);
              <D.27490>:
            }
            goto <D.27491>;
            <D.27481>:
            D.27492 = rs->isymbolic[dest_dreg];
            if (D.27492 > 15) goto <D.27493>; else goto <D.27494>;
            <D.27493>:
            free_up_hreg (cfg, bb, tmp, ins, dest_dreg, bank);
            <D.27494>:
            <D.27491>:
            <D.27479>:
            <D.27477>:
            if (spec_dest == 98) goto <D.27495>; else goto <D.27496>;
            <D.27495>:
            j = 0;
            goto <D.26148>;
            <D.26147>:
            D.27499 = mono_arch_is_soft_float ();
            if (D.27499 != 0) goto <D.27497>; else goto <D.27500>;
            <D.27500>:
            D.26880 = j + 1;
            D.26881 = (sizetype) D.26880;
            D.26882 = spec + D.26881;
            D.26883 = *D.26882;
            D.26919 = D.26883 + 154;
            if (D.26919 > 1) goto <D.27497>; else goto <D.27498>;
            <D.27497>:
            D.27501 = sreg_masks[j];
            D.26827 = ins->dreg;
            D.27502 = 1 << D.26827;
            D.27503 = ~D.27502;
            D.27504 = D.27501 & D.27503;
            sreg_masks[j] = D.27504;
            <D.27498>:
            j = j + 1;
            <D.26148>:
            if (j < num_sregs) goto <D.26147>; else goto <D.26149>;
            <D.26149>:
            <D.27496>:
            if (clob_reg != -1) goto <D.27505>; else goto <D.27506>;
            <D.27505>:
            D.27135 = rs->ifree_mask;
            D.27507 = 1 << clob_reg;
            D.27508 = D.27135 & D.27507;
            if (D.27508 == 0) goto <D.27509>; else goto <D.27510>;
            <D.27509>:
            D.26819 = cfg->verbose_level;
            D.26898 = D.26819 > 2;
            D.26899 = (long int) D.26898;
            D.26900 = __builtin_expect (D.26899, 0);
            if (D.26900 != 0) goto <D.27511>; else goto <D.27512>;
            <D.27511>:
            D.27513 = rs->isymbolic[clob_reg];
            printf ("\tforced spill of clobbered reg R%d\n", D.27513);
            <D.27512>:
            free_up_hreg (cfg, bb, tmp, ins, clob_reg, 0);
            <D.27510>:
            <D.27506>:
            D.27051 = spec + 5;
            D.27052 = *D.27051;
            if (D.27052 == 99) goto <D.27514>; else goto <D.27515>;
            <D.27514>:
            {
              int j;
              int s;
              int dreg;
              int dreg2;
              int cur_bank;
              guint64 clob_mask;

              clob_mask = 4111;
              D.27135 = rs->ifree_mask;
              if (D.27135 != 4111) goto <D.27516>; else goto <D.27517>;
              <D.27516>:
              if (prev_dreg != -1) goto <D.27521>; else goto <D.27518>;
              <D.27521>:
              D.27522 = mono_arch_is_soft_float ();
              if (D.27522 != 0) goto <D.27519>; else goto <D.27523>;
              <D.27523>:
              D.27022 = spec_dest + 154;
              if (D.27022 > 1) goto <D.27519>; else goto <D.27518>;
              <D.27519>:
              D.26950 = rs->vassign;
              prev_dreg.62 = (unsigned int) prev_dreg;
              D.27351 = prev_dreg.62 * 4;
              D.27352 = D.26950 + D.27351;
              dreg = *D.27352;
              goto <D.27520>;
              <D.27518>:
              dreg = -1;
              <D.27520>:
              D.27525 = mono_arch_is_soft_float ();
              if (D.27525 != 0) goto <D.27526>; else goto <D.27527>;
              <D.27526>:
              D.27018 = spec_dest == 108;
              D.27019 = spec_dest == 76;
              D.27020 = D.27018 | D.27019;
              if (D.27020 != 0) goto <D.27529>; else goto <D.27532>;
              <D.27532>:
              D.27022 = spec_dest + 154;
              if (D.27022 <= 1) goto <D.27529>; else goto <D.27530>;
              <D.27529>:
              iftmp.77 = 1;
              goto <D.27531>;
              <D.27530>:
              iftmp.77 = 0;
              <D.27531>:
              iftmp.76 = (_Bool) iftmp.77;
              goto <D.27533>;
              <D.27527>:
              D.27018 = spec_dest == 108;
              D.27019 = spec_dest == 76;
              D.27020 = D.27018 | D.27019;
              D.27024 = (int) D.27020;
              iftmp.76 = (_Bool) D.27024;
              <D.27533>:
              if (iftmp.76 != 0) goto <D.27534>; else goto <D.27535>;
              <D.27534>:
              D.26950 = rs->vassign;
              prev_dreg.78 = (sizetype) prev_dreg;
              D.27537 = prev_dreg.78 + 1;
              D.27538 = D.27537 * 4;
              D.27539 = D.26950 + D.27538;
              dreg2 = *D.27539;
              goto <D.27540>;
              <D.27535>:
              dreg2 = -1;
              <D.27540>:
              j = 0;
              goto <D.26157>;
              <D.26156>:
              D.27541 = 1 << j;
              s = (int) D.27541;
              D.27542 = (long long unsigned int) s;
              D.27543 = D.27542 & clob_mask;
              if (D.27543 != 0) goto <D.27544>; else goto <D.27545>;
              <D.27544>:
              D.27135 = rs->ifree_mask;
              s.79 = (unsigned int) s;
              D.27547 = D.27135 & s.79;
              if (D.27547 == 0) goto <D.27548>; else goto <D.27549>;
              <D.27548>:
              D.26857 = ins->sreg1;
              if (D.26857 != j) goto <D.27550>; else goto <D.27551>;
              <D.27550>:
              D.27552 = j != dreg;
              D.27553 = j != dreg2;
              D.27554 = D.27552 & D.27553;
              if (D.27554 != 0) goto <D.27555>; else goto <D.27556>;
              <D.27555>:
              free_up_hreg (cfg, bb, tmp, ins, j, 0);
              goto <D.27557>;
              <D.27556>:
              D.27558 = rs->isymbolic[j];
              if (D.27558 != 0) goto <D.27559>; else goto <D.27560>;
              <D.27559>:
              D.26950 = rs->vassign;
              D.27558 = rs->isymbolic[j];
              D.27561 = (unsigned int) D.27558;
              D.27562 = D.27561 * 4;
              D.27563 = D.26950 + D.27562;
              *D.27563 = -1;
              <D.27560>:
              <D.27557>:
              mono_regstate_free_int (rs, j);
              <D.27551>:
              <D.27549>:
              <D.27545>:
              j = j + 1;
              <D.26157>:
              if (j <= 15) goto <D.26156>; else goto <D.26158>;
              <D.26158>:
              <D.27517>:
              cur_bank = 1;
              goto <D.26164>;
              <D.26163>:
              D.27564 = rs->free_mask[cur_bank];
              D.27565 = regbank_callee_regs[cur_bank];
              if (D.27564 != D.27565) goto <D.27566>; else goto <D.27567>;
              <D.27566>:
              D.27565 = regbank_callee_regs[cur_bank];
              clob_mask = (guint64) D.27565;
              if (prev_dreg != -1) goto <D.27570>; else goto <D.27568>;
              <D.27570>:
              D.27571 = mono_arch_is_soft_float ();
              if (D.27571 == 0) goto <D.27572>; else goto <D.27568>;
              <D.27572>:
              D.27022 = spec_dest + 154;
              if (D.27022 <= 1) goto <D.27573>; else goto <D.27568>;
              <D.27573>:
              D.26950 = rs->vassign;
              prev_dreg.62 = (unsigned int) prev_dreg;
              D.27351 = prev_dreg.62 * 4;
              D.27352 = D.26950 + D.27351;
              dreg = *D.27352;
              goto <D.27569>;
              <D.27568>:
              dreg = -1;
              <D.27569>:
              j = 0;
              goto <D.26161>;
              <D.26160>:
              if (0 != 0) goto <D.27574>; else goto <D.27575>;
              <D.27574>:
              // predicted unlikely by continue predictor.
              goto <D.26159>;
              <D.27575>:
              D.27541 = 1 << j;
              s = (int) D.27541;
              D.27542 = (long long unsigned int) s;
              D.27543 = D.27542 & clob_mask;
              if (D.27543 != 0) goto <D.27576>; else goto <D.27577>;
              <D.27576>:
              D.27564 = rs->free_mask[cur_bank];
              s.79 = (unsigned int) s;
              D.27578 = D.27564 & s.79;
              if (D.27578 == 0) goto <D.27579>; else goto <D.27580>;
              <D.27579>:
              if (j != dreg) goto <D.27581>; else goto <D.27582>;
              <D.27581>:
              free_up_hreg (cfg, bb, tmp, ins, j, cur_bank);
              goto <D.27583>;
              <D.27582>:
              D.27584 = rs->symbolic[cur_bank];
              j.80 = (unsigned int) j;
              D.27586 = j.80 * 4;
              D.27587 = D.27584 + D.27586;
              D.27588 = *D.27587;
              if (D.27588 != 0) goto <D.27589>; else goto <D.27590>;
              <D.27589>:
              D.26950 = rs->vassign;
              D.27584 = rs->symbolic[cur_bank];
              j.80 = (unsigned int) j;
              D.27586 = j.80 * 4;
              D.27587 = D.27584 + D.27586;
              D.27588 = *D.27587;
              D.27591 = (unsigned int) D.27588;
              D.27592 = D.27591 * 4;
              D.27593 = D.26950 + D.27592;
              *D.27593 = -1;
              <D.27590>:
              <D.27583>:
              mono_regstate_free_general (rs, j, cur_bank);
              <D.27580>:
              <D.27577>:
              <D.26159>:
              j = j + 1;
              <D.26161>:
              D.27594 = regbank_size[cur_bank];
              if (D.27594 > j) goto <D.26160>; else goto <D.26162>;
              <D.26162>:
              <D.27567>:
              cur_bank = cur_bank + 1;
              <D.26164>:
              if (cur_bank <= 3) goto <D.26163>; else goto <D.26165>;
              <D.26165>:
            }
            <D.27515>:
            D.27051 = spec + 5;
            D.27052 = *D.27051;
            if (D.27052 == 99) goto <D.27597>; else goto <D.27598>;
            <D.27597>:
            D.27599 = ins->opcode;
            D.27600 = D.27599 + 65193;
            D.27601 = D.27600 <= 2;
            D.27602 = D.27599 + 65187;
            D.27603 = D.27602 <= 2;
            D.27604 = D.27601 | D.27603;
            if (D.27604 != 0) goto <D.27595>; else goto <D.27605>;
            <D.27605>:
            D.26822 = ins->opcode;
            D.27062 = D.26822 + 65184;
            if (D.27062 <= 2) goto <D.27595>; else goto <D.27606>;
            <D.27606>:
            D.26822 = ins->opcode;
            D.27064 = D.26822 + 65181;
            if (D.27064 <= 2) goto <D.27595>; else goto <D.27607>;
            <D.27607>:
            D.26822 = ins->opcode;
            D.27066 = D.26822 + 65190;
            if (D.27066 <= 2) goto <D.27595>; else goto <D.27608>;
            <D.27608>:
            D.26822 = ins->opcode;
            D.27068 = D.26822 + 65178;
            if (D.27068 <= 2) goto <D.27595>; else goto <D.27609>;
            <D.27609>:
            D.26822 = ins->opcode;
            if (D.26822 == 444) goto <D.27595>; else goto <D.27596>;
            <D.27595>:
            {
              struct MonoCallInst * call;
              struct GSList * list;

              call = ins;
              list = call->out_ireg_args;
              if (list != 0B) goto <D.27610>; else goto <D.27611>;
              <D.27610>:
              goto <D.26172>;
              <D.26171>:
              {
                guint32 regpair;
                int reg;
                int hreg;

                D.27612 = list->data;
                regpair = (guint32) D.27612;
                D.27613 = regpair >> 24;
                hreg = (int) D.27613;
                regpair.81 = (int) regpair;
                reg = regpair.81 & 16777215;
                assign_reg (cfg, rs, reg, hreg, 0);
                D.27615 = sreg_masks[0];
                D.27616 = 1 << hreg;
                D.27617 = ~D.27616;
                D.27618 = D.27615 & D.27617;
                sreg_masks[0] = D.27618;
                D.26819 = cfg->verbose_level;
                D.26898 = D.26819 > 2;
                D.26899 = (long int) D.26898;
                D.26900 = __builtin_expect (D.26899, 0);
                if (D.26900 != 0) goto <D.27619>; else goto <D.27620>;
                <D.27619>:
                D.27621 = mono_arch_regname (hreg);
                printf ("\tassigned arg reg %s to R%d\n", D.27621, reg);
                <D.27620>:
                if (list != 0B) goto <D.27623>; else goto <D.27624>;
                <D.27623>:
                iftmp.82 = list->next;
                goto <D.27625>;
                <D.27624>:
                iftmp.82 = 0B;
                <D.27625>:
                list = iftmp.82;
              }
              <D.26172>:
              if (list != 0B) goto <D.26171>; else goto <D.26173>;
              <D.26173>:
              <D.27611>:
              list = call->out_freg_args;
              if (list != 0B) goto <D.27626>; else goto <D.27627>;
              <D.27626>:
              goto <D.26178>;
              <D.26177>:
              {
                guint32 regpair;
                int reg;
                int hreg;

                D.27612 = list->data;
                regpair = (guint32) D.27612;
                D.27628 = regpair >> 24;
                hreg = (int) D.27628;
                regpair.83 = (int) regpair;
                reg = regpair.83 & 16777215;
                assign_reg (cfg, rs, reg, hreg, 1);
                D.26819 = cfg->verbose_level;
                D.26898 = D.26819 > 2;
                D.26899 = (long int) D.26898;
                D.26900 = __builtin_expect (D.26899, 0);
                if (D.26900 != 0) goto <D.27630>; else goto <D.27631>;
                <D.27630>:
                D.27632 = mono_regname_full (hreg, 1);
                printf ("\tassigned arg reg %s to R%d\n", D.27632, reg);
                <D.27631>:
                if (list != 0B) goto <D.27634>; else goto <D.27635>;
                <D.27634>:
                iftmp.84 = list->next;
                goto <D.27636>;
                <D.27635>:
                iftmp.84 = 0B;
                <D.27636>:
                list = iftmp.84;
              }
              <D.26178>:
              if (list != 0B) goto <D.26177>; else goto <D.26179>;
              <D.26179>:
              <D.27627>:
            }
            <D.27596>:
            <D.27598>:
            D.27640 = mono_arch_is_soft_float ();
            if (D.27640 == 0) goto <D.27641>; else goto <D.27638>;
            <D.27641>:
            D.26777 = spec + 1;
            D.26778 = *D.26777;
            D.27642 = D.26778 + 154;
            if (D.27642 <= 1) goto <D.27643>; else goto <D.27638>;
            <D.27643>:
            iftmp.85 = 1;
            goto <D.27639>;
            <D.27638>:
            iftmp.85 = 0;
            <D.27639>:
            bank = iftmp.85;
            D.27645 = mono_arch_is_soft_float ();
            if (D.27645 != 0) goto <D.27646>; else goto <D.27647>;
            <D.27646>:
            D.27018 = spec_dest == 108;
            D.27019 = spec_dest == 76;
            D.27020 = D.27018 | D.27019;
            if (D.27020 != 0) goto <D.27649>; else goto <D.27652>;
            <D.27652>:
            D.27022 = spec_dest + 154;
            if (D.27022 <= 1) goto <D.27649>; else goto <D.27650>;
            <D.27649>:
            iftmp.87 = 1;
            goto <D.27651>;
            <D.27650>:
            iftmp.87 = 0;
            <D.27651>:
            iftmp.86 = (_Bool) iftmp.87;
            goto <D.27653>;
            <D.27647>:
            D.27018 = spec_dest == 108;
            D.27019 = spec_dest == 76;
            D.27020 = D.27018 | D.27019;
            D.27024 = (int) D.27020;
            iftmp.86 = (_Bool) D.27024;
            <D.27653>:
            if (iftmp.86 != 0) goto <D.27654>; else goto <D.27655>;
            <D.27654>:
            D.27051 = spec + 5;
            D.27052 = *D.27051;
            if (D.27052 == 49) goto <D.27656>; else goto <D.27657>;
            <D.27656>:
            {
              int sreg1;
              int dest_sreg1;

              sreg1 = sregs[0];
              dest_sreg1 = dest_sregs[0];
              D.26927 = bank != 0;
              D.26928 = (long int) D.26927;
              D.26929 = __builtin_expect (D.26928, 0);
              if (D.26929 != 0) goto <D.27659>; else goto <D.27660>;
              <D.27659>:
              if (sreg1 >= 0) goto <D.27664>; else goto <D.27662>;
              <D.27664>:
              D.26937 = regbank_size[bank];
              if (D.26937 > sreg1) goto <D.27665>; else goto <D.27662>;
              <D.27665>:
              iftmp.89 = 1;
              goto <D.27663>;
              <D.27662>:
              iftmp.89 = 0;
              <D.27663>:
              D.27666 = iftmp.89 != 0;
              iftmp.88 = (long int) D.27666;
              goto <D.27667>;
              <D.27660>:
              D.27668 = sreg1 <= 15;
              iftmp.88 = (long int) D.27668;
              <D.27667>:
              D.27669 = __builtin_expect (iftmp.88, 0);
              if (D.27669 != 0) goto <D.27670>; else goto <D.27671>;
              <D.27670>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1879, "is_soft_reg (sreg1, bank)");
              <D.27671>:
              if (dest_sreg1 != -1) goto <D.27672>; else goto <D.27673>;
              <D.27672>:
              D.26827 = ins->dreg;
              D.27674 = D.26827 != dest_sreg1;
              D.27675 = (long int) D.27674;
              D.27676 = __builtin_expect (D.27675, 0);
              if (D.27676 != 0) goto <D.27677>; else goto <D.27678>;
              <D.27677>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1883, "dest_sreg1 == ins->dreg");
              <D.27678>:
              <D.27673>:
              D.26827 = ins->dreg;
              D.27502 = 1 << D.26827;
              val = mono_regstate_alloc_int (rs, D.27502);
              D.27679 = val < 0;
              D.27680 = (long int) D.27679;
              D.27681 = __builtin_expect (D.27680, 0);
              if (D.27681 != 0) goto <D.27682>; else goto <D.27683>;
              <D.27682>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1885, "val >= 0");
              <D.27683>:
              D.26950 = rs->vassign;
              sreg1.90 = (unsigned int) sreg1;
              D.27685 = sreg1.90 * 4;
              D.27686 = D.26950 + D.27685;
              D.27687 = *D.27686;
              if (D.27687 >= 0) goto <D.27688>; else goto <D.27689>;
              <D.27688>:
              D.26950 = rs->vassign;
              sreg1.90 = (unsigned int) sreg1;
              D.27685 = sreg1.90 * 4;
              D.27686 = D.26950 + D.27685;
              D.27687 = *D.27686;
              if (D.27687 != val) goto <D.27690>; else goto <D.27691>;
              <D.27690>:
              monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-codegen.c", 1889);
              <D.27691>:
              <D.27689>:
              assign_reg (cfg, rs, sreg1, val, bank);
              D.26819 = cfg->verbose_level;
              D.26898 = D.26819 > 2;
              D.26899 = (long int) D.26898;
              D.26900 = __builtin_expect (D.26899, 0);
              if (D.26900 != 0) goto <D.27692>; else goto <D.27693>;
              <D.27692>:
              D.27694 = mono_regname_full (val, bank);
              printf ("\tassigned sreg1-low %s to R%d\n", D.27694, sreg1);
              <D.27693>:
              D.27699 = spec_src1 == 108;
              D.27700 = spec_src1 == 102;
              D.27701 = D.27699 | D.27700;
              if (D.27701 != 0) goto <D.27696>; else goto <D.27702>;
              <D.27702>:
              if (spec_src1 == 103) goto <D.27696>; else goto <D.27697>;
              <D.27696>:
              D.27699 = spec_src1 == 108;
              D.27700 = spec_src1 == 102;
              D.27701 = D.27699 | D.27700;
              if (D.27701 != 0) goto <D.27704>; else goto <D.27707>;
              <D.27707>:
              if (spec_src1 == 103) goto <D.27704>; else goto <D.27705>;
              <D.27704>:
              iftmp.92 = 2;
              goto <D.27706>;
              <D.27705>:
              iftmp.92 = 0;
              <D.27706>:
              iftmp.91 = iftmp.92;
              goto <D.27698>;
              <D.27697>:
              iftmp.91 = 4111;
              <D.27698>:
              D.27708 = iftmp.91 >> dreg_high;
              D.27709 = D.27708 & 1;
              D.27710 = D.27709 == 0;
              D.27711 = (long int) D.27710;
              D.27712 = __builtin_expect (D.27711, 0);
              if (D.27712 != 0) goto <D.27713>; else goto <D.27714>;
              <D.27713>:
              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.27714>:
              D.27715 = 1 << dreg_high;
              val = mono_regstate_alloc_int (rs, D.27715);
              D.27679 = val < 0;
              D.27680 = (long int) D.27679;
              D.27681 = __builtin_expect (D.27680, 0);
              if (D.27681 != 0) goto <D.27716>; else goto <D.27717>;
              <D.27716>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1897, "val >= 0");
              <D.27717>:
              D.26950 = rs->vassign;
              sreg1.93 = (sizetype) sreg1;
              D.27719 = sreg1.93 + 1;
              D.27720 = D.27719 * 4;
              D.27721 = D.26950 + D.27720;
              D.27722 = *D.27721;
              if (D.27722 >= 0) goto <D.27723>; else goto <D.27724>;
              <D.27723>:
              D.26950 = rs->vassign;
              sreg1.93 = (sizetype) sreg1;
              D.27719 = sreg1.93 + 1;
              D.27720 = D.27719 * 4;
              D.27721 = D.26950 + D.27720;
              D.27722 = *D.27721;
              if (D.27722 != val) goto <D.27725>; else goto <D.27726>;
              <D.27725>:
              monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-codegen.c", 1901);
              <D.27726>:
              <D.27724>:
              D.27727 = sreg1 + 1;
              assign_reg (cfg, rs, D.27727, val, bank);
              D.26819 = cfg->verbose_level;
              D.26898 = D.26819 > 2;
              D.26899 = (long int) D.26898;
              D.26900 = __builtin_expect (D.26899, 0);
              if (D.26900 != 0) goto <D.27728>; else goto <D.27729>;
              <D.27728>:
              D.27730 = mono_regname_full (val, bank);
              D.27727 = sreg1 + 1;
              printf ("\tassigned sreg1-high %s to R%d\n", D.27730, D.27727);
              <D.27729>:
              dest_sregs[0] = -1;
            }
            <D.27657>:
            <D.27655>:
            D.27731 = sreg_fixed_masks[0];
            if (D.27731 != 0) goto <D.27732>; else goto <D.27733>;
            <D.27732>:
            D.26927 = bank != 0;
            D.26928 = (long int) D.26927;
            D.26929 = __builtin_expect (D.26928, 0);
            if (D.26929 != 0) goto <D.27734>; else goto <D.27735>;
            <D.27734>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1912, "!bank");
            <D.27735>:
            D.27738 = sregs[0];
            D.27739 = (unsigned int) D.27738;
            if (D.27739 <= 15) goto <D.27740>; else goto <D.27736>;
            <D.27740>:
            D.27738 = sregs[0];
            D.27741 = 2032 >> D.27738;
            D.27742 = D.27741 & 1;
            if (D.27742 != 0) goto <D.27743>; else goto <D.27736>;
            <D.27743>:
            D.27731 = sreg_fixed_masks[0];
            val = mono_regstate_alloc_int (rs, D.27731);
            if (val < 0) goto <D.27744>; else goto <D.27745>;
            <D.27744>:
            D.27731 = sreg_fixed_masks[0];
            val = get_register_spilling (cfg, bb, tmp, ins, D.27731, -1, bank);
            <D.27745>:
            mono_regstate_free_int (rs, val);
            dest_sregs[0] = val;
            goto <D.27737>;
            <D.27736>:
            D.27615 = sreg_masks[0];
            D.27731 = sreg_fixed_masks[0];
            D.27746 = D.27615 & D.27731;
            sreg_masks[0] = D.27746;
            <D.27737>:
            <D.27733>:
            D.27222 = dest_sregs[0];
            if (D.27222 != -1) goto <D.27747>; else goto <D.27748>;
            <D.27747>:
            D.27222 = dest_sregs[0];
            D.27225 = 1 << D.27222;
            sreg_masks[0] = D.27225;
            D.26950 = rs->vassign;
            D.27738 = sregs[0];
            D.27749 = (unsigned int) D.27738;
            D.27750 = D.27749 * 4;
            D.27751 = D.26950 + D.27750;
            D.27752 = *D.27751;
            D.27222 = dest_sregs[0];
            if (D.27752 != D.27222) goto <D.27753>; else goto <D.27754>;
            <D.27753>:
            D.27135 = rs->ifree_mask;
            D.27222 = dest_sregs[0];
            D.27225 = 1 << D.27222;
            D.27755 = D.27135 & D.27225;
            if (D.27755 == 0) goto <D.27756>; else goto <D.27757>;
            <D.27756>:
            D.27222 = dest_sregs[0];
            free_up_hreg (cfg, bb, tmp, ins, D.27222, 0);
            <D.27757>:
            <D.27754>:
            D.27738 = sregs[0];
            D.27739 = (unsigned int) D.27738;
            if (D.27739 <= 15) goto <D.27758>; else goto <D.27759>;
            <D.27758>:
            D.27738 = sregs[0];
            D.27741 = 2032 >> D.27738;
            D.27742 = D.27741 & 1;
            if (D.27742 != 0) goto <D.27760>; else goto <D.27761>;
            <D.27760>:
            {
              struct MonoInst * copy;

              D.27222 = dest_sregs[0];
              D.27738 = sregs[0];
              copy = create_copy_ins (cfg, bb, tmp, D.27222, D.27738, 0B, ip, 0);
              insert_before_ins (bb, ins, copy);
              D.27222 = dest_sregs[0];
              sregs[0] = D.27222;
            }
            <D.27761>:
            <D.27759>:
            <D.27748>:
            D.26927 = bank != 0;
            D.26928 = (long int) D.26927;
            D.26929 = __builtin_expect (D.26928, 0);
            if (D.26929 != 0) goto <D.27763>; else goto <D.27764>;
            <D.27763>:
            D.27738 = sregs[0];
            if (D.27738 < 0) goto <D.27766>; else goto <D.27769>;
            <D.27769>:
            D.27738 = sregs[0];
            D.26937 = regbank_size[bank];
            if (D.27738 >= D.26937) goto <D.27766>; else goto <D.27767>;
            <D.27766>:
            iftmp.95 = 1;
            goto <D.27768>;
            <D.27767>:
            iftmp.95 = 0;
            <D.27768>:
            iftmp.94 = (_Bool) iftmp.95;
            goto <D.27770>;
            <D.27764>:
            D.27738 = sregs[0];
            iftmp.94 = D.27738 > 15;
            <D.27770>:
            if (iftmp.94 != 0) goto <D.27771>; else goto <D.27772>;
            <D.27771>:
            D.26950 = rs->vassign;
            D.27738 = sregs[0];
            D.27749 = (unsigned int) D.27738;
            D.27750 = D.27749 * 4;
            D.27751 = D.26950 + D.27750;
            val = *D.27751;
            D.27738 = sregs[0];
            prev_sregs[0] = D.27738;
            if (val < 0) goto <D.27773>; else goto <D.27774>;
            <D.27773>:
            {
              int spill;

              spill = 0;
              if (val < -1) goto <D.27775>; else goto <D.27776>;
              <D.27775>:
              spill = ~val;
              <D.27776>:
              D.26822 = ins->opcode;
              if (D.26822 == 424) goto <D.27777>; else goto <D.27778>;
              <D.27777>:
              D.27779 = spill | bank;
              if (D.27779 == 0) goto <D.27780>; else goto <D.27781>;
              <D.27780>:
              D.26827 = ins->dreg;
              D.27301 = (unsigned int) D.26827;
              if (D.27301 <= 15) goto <D.27782>; else goto <D.27783>;
              <D.27782>:
              D.26827 = ins->dreg;
              D.27784 = 4111 >> D.26827;
              D.27785 = D.27784 & 1;
              if (D.27785 != 0) goto <D.27786>; else goto <D.27787>;
              <D.27786>:
              D.27135 = rs->ifree_mask;
              D.26827 = ins->dreg;
              D.27502 = 1 << D.26827;
              D.27788 = D.27135 & D.27502;
              if (D.27788 != 0) goto <D.27789>; else goto <D.27790>;
              <D.27789>:
              D.26827 = ins->dreg;
              D.27502 = 1 << D.26827;
              sreg_masks[0] = D.27502;
              <D.27790>:
              <D.27787>:
              <D.27783>:
              <D.27781>:
              <D.27778>:
              D.27051 = spec + 5;
              D.27052 = *D.27051;
              if (D.27052 == 49) goto <D.27793>; else goto <D.27794>;
              <D.27793>:
              D.27795 = mono_arch_is_soft_float ();
              if (D.27795 != 0) goto <D.27791>; else goto <D.27796>;
              <D.27796>:
              D.26770 = *spec;
              D.26989 = D.26770 + 154;
              if (D.26989 > 1) goto <D.27791>; else goto <D.27792>;
              <D.27791>:
              D.27135 = rs->ifree_mask;
              D.26827 = ins->dreg;
              D.27502 = 1 << D.26827;
              D.27788 = D.27135 & D.27502;
              if (D.27788 != 0) goto <D.27797>; else goto <D.27798>;
              <D.27797>:
              D.26827 = ins->dreg;
              D.27502 = 1 << D.26827;
              sreg_masks[0] = D.27502;
              <D.27798>:
              <D.27792>:
              <D.27794>:
              D.27615 = sreg_masks[0];
              D.27738 = sregs[0];
              D.27738 = sregs[0];
              D.27749 = (unsigned int) D.27738;
              D.27799 = D.27749 * 12;
              D.27800 = reginfo + D.27799;
              val = alloc_reg (cfg, bb, tmp, ins, D.27615, D.27738, D.27800, bank);
              D.27738 = sregs[0];
              assign_reg (cfg, rs, D.27738, val, bank);
              D.26819 = cfg->verbose_level;
              D.26898 = D.26819 > 2;
              D.26899 = (long int) D.26898;
              D.26900 = __builtin_expect (D.26899, 0);
              if (D.26900 != 0) goto <D.27801>; else goto <D.27802>;
              <D.27801>:
              D.27803 = mono_regname_full (val, bank);
              D.27738 = sregs[0];
              printf ("\tassigned sreg1 %s to R%d\n", D.27803, D.27738);
              <D.27802>:
              if (spill != 0) goto <D.27804>; else goto <D.27805>;
              <D.27804>:
              D.27806 = prev_sregs[0];
              create_spilled_store (cfg, bb, spill, val, D.27806, tmp, 0B, ins, bank);
              <D.27805>:
            }
            goto <D.27807>;
            <D.27774>:
            D.27222 = dest_sregs[0];
            if (D.27222 != -1) goto <D.27808>; else goto <D.27809>;
            <D.27808>:
            D.27222 = dest_sregs[0];
            if (D.27222 != val) goto <D.27810>; else goto <D.27811>;
            <D.27810>:
            {
              struct MonoInst * copy;

              D.27222 = dest_sregs[0];
              copy = create_copy_ins (cfg, bb, tmp, D.27222, val, 0B, ip, bank);
              insert_before_ins (bb, ins, copy);
              j = 1;
              goto <D.26186>;
              <D.26185>:
              D.27501 = sreg_masks[j];
              D.27222 = dest_sregs[0];
              D.27225 = 1 << D.27222;
              D.27226 = ~D.27225;
              D.27812 = D.27501 & D.27226;
              sreg_masks[j] = D.27812;
              j = j + 1;
              <D.26186>:
              if (j < num_sregs) goto <D.26185>; else goto <D.26187>;
              <D.26187>:
              val = dest_sregs[0];
            }
            <D.27811>:
            <D.27809>:
            <D.27807>:
            sregs[0] = val;
            goto <D.27813>;
            <D.27772>:
            prev_sregs[0] = -1;
            <D.27813>:
            mono_inst_set_src_registers (ins, &sregs);
            j = 1;
            goto <D.26189>;
            <D.26188>:
            D.27501 = sreg_masks[j];
            D.27738 = sregs[0];
            D.27814 = 1 << D.27738;
            D.27815 = ~D.27814;
            D.27816 = D.27501 & D.27815;
            sreg_masks[j] = D.27816;
            j = j + 1;
            <D.26189>:
            if (j < num_sregs) goto <D.26188>; else goto <D.26190>;
            <D.26190>:
            D.27818 = mono_arch_is_soft_float ();
            if (D.27818 != 0) goto <D.27819>; else goto <D.27820>;
            <D.27819>:
            D.27699 = spec_src1 == 108;
            D.27825 = spec_src1 == 76;
            D.27826 = D.27699 | D.27825;
            if (D.27826 != 0) goto <D.27822>; else goto <D.27827>;
            <D.27827>:
            D.27828 = spec_src1 + 154;
            if (D.27828 <= 1) goto <D.27822>; else goto <D.27823>;
            <D.27822>:
            iftmp.97 = 1;
            goto <D.27824>;
            <D.27823>:
            iftmp.97 = 0;
            <D.27824>:
            iftmp.96 = (_Bool) iftmp.97;
            goto <D.27829>;
            <D.27820>:
            D.27699 = spec_src1 == 108;
            D.27825 = spec_src1 == 76;
            D.27826 = D.27699 | D.27825;
            D.27830 = (int) D.27826;
            iftmp.96 = (_Bool) D.27830;
            <D.27829>:
            if (iftmp.96 != 0) goto <D.27831>; else goto <D.27832>;
            <D.27831>:
            D.27051 = spec + 5;
            D.27052 = *D.27051;
            if (D.27052 != 49) goto <D.27833>; else goto <D.27834>;
            <D.27833>:
            {
              int reg2;

              D.27806 = prev_sregs[0];
              reg2 = D.27806 + 1;
              D.26927 = bank != 0;
              D.26928 = (long int) D.26927;
              D.26929 = __builtin_expect (D.26928, 0);
              if (D.26929 != 0) goto <D.27835>; else goto <D.27836>;
              <D.27835>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 2000, "!bank");
              <D.27836>:
              D.27806 = prev_sregs[0];
              D.27837 = D.27806 < 0;
              D.27838 = (long int) D.27837;
              D.27839 = __builtin_expect (D.27838, 0);
              if (D.27839 != 0) goto <D.27840>; else goto <D.27841>;
              <D.27840>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 2001, "prev_sregs [0] > -1");
              <D.27841>:
              D.26950 = rs->vassign;
              D.27806 = prev_sregs[0];
              D.27845 = (unsigned int) D.27806;
              D.27846 = D.27845 * 4;
              D.27847 = D.26950 + D.27846;
              D.27848 = *D.27847;
              D.27849 = (unsigned int) D.27848;
              if (D.27849 <= 15) goto <D.27850>; else goto <D.27843>;
              <D.27850>:
              D.26950 = rs->vassign;
              D.27806 = prev_sregs[0];
              D.27845 = (unsigned int) D.27806;
              D.27846 = D.27845 * 4;
              D.27847 = D.26950 + D.27846;
              D.27848 = *D.27847;
              D.27851 = 2032 >> D.27848;
              D.27852 = D.27851 & 1;
              if (D.27852 != 0) goto <D.27853>; else goto <D.27843>;
              <D.27853>:
              iftmp.98 = 1;
              goto <D.27844>;
              <D.27843>:
              iftmp.98 = 0;
              <D.27844>:
              D.27854 = iftmp.98 != 0;
              D.27855 = (long int) D.27854;
              D.27856 = __builtin_expect (D.27855, 0);
              if (D.27856 != 0) goto <D.27857>; else goto <D.27858>;
              <D.27857>:
              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.27858>:
              D.27699 = spec_src1 == 108;
              D.27700 = spec_src1 == 102;
              D.27701 = D.27699 | D.27700;
              if (D.27701 != 0) goto <D.27860>; else goto <D.27863>;
              <D.27863>:
              if (spec_src1 == 103) goto <D.27860>; else goto <D.27861>;
              <D.27860>:
              D.27699 = spec_src1 == 108;
              D.27700 = spec_src1 == 102;
              D.27701 = D.27699 | D.27700;
              if (D.27701 != 0) goto <D.27865>; else goto <D.27868>;
              <D.27868>:
              if (spec_src1 == 103) goto <D.27865>; else goto <D.27866>;
              <D.27865>:
              iftmp.100 = 2;
              goto <D.27867>;
              <D.27866>:
              iftmp.100 = 0;
              <D.27867>:
              iftmp.99 = iftmp.100;
              goto <D.27862>;
              <D.27861>:
              iftmp.99 = 4111;
              <D.27862>:
              mask = iftmp.99;
              D.26950 = rs->vassign;
              reg2.101 = (unsigned int) reg2;
              D.27870 = reg2.101 * 4;
              D.27871 = D.26950 + D.27870;
              val = *D.27871;
              if (val < 0) goto <D.27872>; else goto <D.27873>;
              <D.27872>:
              {
                int spill;

                spill = 0;
                if (val < -1) goto <D.27874>; else goto <D.27875>;
                <D.27874>:
                spill = ~val;
                <D.27875>:
                val = mono_regstate_alloc_int (rs, mask);
                if (val < 0) goto <D.27876>; else goto <D.27877>;
                <D.27876>:
                val = get_register_spilling (cfg, bb, tmp, ins, mask, reg2, bank);
                <D.27877>:
                if (spill != 0) goto <D.27878>; else goto <D.27879>;
                <D.27878>:
                monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-codegen.c", 2015);
                <D.27879>:
              }
              goto <D.27880>;
              <D.27873>:
              D.27386 = 1 << val;
              D.27387 = D.27386 & mask;
              if (D.27387 == 0) goto <D.27881>; else goto <D.27882>;
              <D.27881>:
              monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-codegen.c", 2021);
              <D.27882>:
              <D.27880>:
              sreg1_high = val;
              D.26819 = cfg->verbose_level;
              D.26898 = D.26819 > 2;
              D.26899 = (long int) D.26898;
              D.26900 = __builtin_expect (D.26899, 0);
              if (D.26900 != 0) goto <D.27883>; else goto <D.27884>;
              <D.27883>:
              D.27885 = mono_arch_regname (val);
              printf ("\tassigned sreg1 hreg %s to dest R%d\n", D.27885, reg2);
              <D.27884>:
              assign_reg (cfg, rs, reg2, val, bank);
            }
            <D.27834>:
            <D.27832>:
            D.27889 = mono_arch_is_soft_float ();
            if (D.27889 == 0) goto <D.27890>; else goto <D.27886>;
            <D.27890>:
            D.26770 = *spec;
            D.26989 = D.26770 + 154;
            if (D.26989 <= 1) goto <D.27891>; else goto <D.27886>;
            <D.27891>:
            D.27892 = mono_arch_is_soft_float ();
            if (D.27892 == 0) goto <D.27893>; else goto <D.27886>;
            <D.27893>:
            D.26777 = spec + 1;
            D.26778 = *D.26777;
            D.27642 = D.26778 + 154;
            if (D.27642 <= 1) goto <D.27887>; else goto <D.27886>;
            <D.27886>:
            D.27051 = spec + 5;
            D.27052 = *D.27051;
            if (D.27052 == 49) goto <D.27887>; else goto <D.27888>;
            <D.27887>:
            D.26827 = ins->dreg;
            D.27738 = sregs[0];
            if (D.26827 != D.27738) goto <D.27894>; else goto <D.27895>;
            <D.27894>:
            {
              struct MonoInst * sreg2_copy;
              struct MonoInst * copy;
              int bank;

              sreg2_copy = 0B;
              D.27899 = mono_arch_is_soft_float ();
              if (D.27899 == 0) goto <D.27900>; else goto <D.27897>;
              <D.27900>:
              D.27828 = spec_src1 + 154;
              if (D.27828 <= 1) goto <D.27901>; else goto <D.27897>;
              <D.27901>:
              iftmp.102 = 1;
              goto <D.27898>;
              <D.27897>:
              iftmp.102 = 0;
              <D.27898>:
              bank = iftmp.102;
              D.26827 = ins->dreg;
              D.27902 = sregs[1];
              if (D.26827 == D.27902) goto <D.27903>; else goto <D.27904>;
              <D.27903>:
              {
                int reg2;

                D.27902 = sregs[1];
                reg2 = alloc_reg (cfg, bb, tmp, ins, dreg_mask, D.27902, 0B, bank);
                D.26819 = cfg->verbose_level;
                D.26898 = D.26819 > 2;
                D.26899 = (long int) D.26898;
                D.26900 = __builtin_expect (D.26899, 0);
                if (D.26900 != 0) goto <D.27905>; else goto <D.27906>;
                <D.27905>:
                D.27902 = sregs[1];
                D.27907 = mono_regname_full (D.27902, bank);
                D.27908 = mono_regname_full (reg2, bank);
                printf ("\tneed to copy sreg2 %s to reg %s\n", D.27907, D.27908);
                <D.27906>:
                D.27902 = sregs[1];
                sreg2_copy = create_copy_ins (cfg, bb, tmp, reg2, D.27902, 0B, ip, bank);
                sregs[1] = reg2;
                D.27902 = sregs[1];
                prev_sregs[1] = D.27902;
                D.27909 = bank != 0;
                D.27910 = (long int) D.27909;
                D.27911 = __builtin_expect (D.27910, 0);
                if (D.27911 != 0) goto <D.27912>; else goto <D.27913>;
                <D.27912>:
                mono_regstate_free_general (rs, reg2, bank);
                goto <D.27914>;
                <D.27913>:
                mono_regstate_free_int (rs, reg2);
                <D.27914>:
              }
              <D.27904>:
              D.27916 = mono_arch_is_soft_float ();
              if (D.27916 != 0) goto <D.27917>; else goto <D.27918>;
              <D.27917>:
              D.27699 = spec_src1 == 108;
              D.27825 = spec_src1 == 76;
              D.27826 = D.27699 | D.27825;
              if (D.27826 != 0) goto <D.27920>; else goto <D.27923>;
              <D.27923>:
              D.27828 = spec_src1 + 154;
              if (D.27828 <= 1) goto <D.27920>; else goto <D.27921>;
              <D.27920>:
              iftmp.104 = 1;
              goto <D.27922>;
              <D.27921>:
              iftmp.104 = 0;
              <D.27922>:
              iftmp.103 = (_Bool) iftmp.104;
              goto <D.27924>;
              <D.27918>:
              D.27699 = spec_src1 == 108;
              D.27825 = spec_src1 == 76;
              D.27826 = D.27699 | D.27825;
              D.27830 = (int) D.27826;
              iftmp.103 = (_Bool) D.27830;
              <D.27924>:
              if (iftmp.103 != 0) goto <D.27925>; else goto <D.27926>;
              <D.27925>:
              D.26950 = rs->vassign;
              D.27806 = prev_sregs[0];
              D.27927 = (sizetype) D.27806;
              D.27928 = D.27927 + 1;
              D.27929 = D.27928 * 4;
              D.27930 = D.26950 + D.27929;
              D.27931 = *D.27930;
              D.27902 = sregs[1];
              if (D.27931 == D.27902) goto <D.27932>; else goto <D.27933>;
              <D.27932>:
              monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-codegen.c", 2067);
              <D.27933>:
              D.27738 = sregs[0];
              D.26827 = ins->dreg;
              D.27934 = D.27738 != D.26827;
              D.27935 = (long int) D.27934;
              D.27936 = __builtin_expect (D.27935, 0);
              if (D.27936 != 0) goto <D.27937>; else goto <D.27938>;
              <D.27937>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 2073, "sregs [0] == ins->dreg");
              <D.27938>:
              D.27939 = dreg_high != sreg1_high;
              D.27940 = (long int) D.27939;
              D.27941 = __builtin_expect (D.27940, 0);
              if (D.27941 != 0) goto <D.27942>; else goto <D.27943>;
              <D.27942>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 2074, "dreg_high == sreg1_high");
              <D.27943>:
              <D.27926>:
              D.26819 = cfg->verbose_level;
              D.26898 = D.26819 > 2;
              D.26899 = (long int) D.26898;
              D.26900 = __builtin_expect (D.26899, 0);
              if (D.26900 != 0) goto <D.27944>; else goto <D.27945>;
              <D.27944>:
              D.27738 = sregs[0];
              D.27946 = mono_regname_full (D.27738, bank);
              D.26827 = ins->dreg;
              D.27947 = mono_regname_full (D.26827, bank);
              printf ("\tneed to copy sreg1 %s to dreg %s\n", D.27946, D.27947);
              <D.27945>:
              D.26827 = ins->dreg;
              D.27738 = sregs[0];
              copy = create_copy_ins (cfg, bb, tmp, D.26827, D.27738, 0B, ip, bank);
              insert_before_ins (bb, ins, copy);
              if (sreg2_copy != 0B) goto <D.27948>; else goto <D.27949>;
              <D.27948>:
              insert_before_ins (bb, copy, sreg2_copy);
              <D.27949>:
              D.27103 = sreg_masks[1];
              D.27738 = sregs[0];
              D.27814 = 1 << D.27738;
              D.27815 = ~D.27814;
              D.27950 = D.27103 & D.27815;
              sreg_masks[1] = D.27950;
              D.26827 = ins->dreg;
              sregs[0] = D.26827;
              D.27738 = sregs[0];
              prev_sregs[0] = D.27738;
              D.27103 = sreg_masks[1];
              D.26827 = ins->dreg;
              D.27502 = 1 << D.26827;
              D.27503 = ~D.27502;
              D.27951 = D.27103 & D.27503;
              sreg_masks[1] = D.27951;
            }
            <D.27895>:
            <D.27888>:
            mono_inst_set_src_registers (ins, &sregs);
            j = 1;
            goto <D.26204>;
            <D.26203>:
            {
              int k;

              D.27955 = mono_arch_is_soft_float ();
              if (D.27955 == 0) goto <D.27956>; else goto <D.27953>;
              <D.27956>:
              D.26880 = j + 1;
              D.26881 = (sizetype) D.26880;
              D.26882 = spec + D.26881;
              D.26883 = *D.26882;
              D.26919 = D.26883 + 154;
              if (D.26919 <= 1) goto <D.27957>; else goto <D.27953>;
              <D.27957>:
              iftmp.105 = 1;
              goto <D.27954>;
              <D.27953>:
              iftmp.105 = 0;
              <D.27954>:
              bank = iftmp.105;
              D.27959 = mono_arch_is_soft_float ();
              if (D.27959 != 0) goto <D.27960>; else goto <D.27961>;
              <D.27960>:
              D.26880 = j + 1;
              D.26881 = (sizetype) D.26880;
              D.26882 = spec + D.26881;
              D.26883 = *D.26882;
              D.26884 = D.26883 == 108;
              D.26880 = j + 1;
              D.26881 = (sizetype) D.26880;
              D.26882 = spec + D.26881;
              D.26883 = *D.26882;
              D.26885 = D.26883 == 76;
              D.26886 = D.26884 | D.26885;
              if (D.26886 != 0) goto <D.27963>; else goto <D.27966>;
              <D.27966>:
              D.26880 = j + 1;
              D.26881 = (sizetype) D.26880;
              D.26882 = spec + D.26881;
              D.26883 = *D.26882;
              if (D.26883 == 102) goto <D.27963>; else goto <D.27967>;
              <D.27967>:
              D.26880 = j + 1;
              D.26881 = (sizetype) D.26880;
              D.26882 = spec + D.26881;
              D.26883 = *D.26882;
              if (D.26883 == 103) goto <D.27963>; else goto <D.27964>;
              <D.27963>:
              iftmp.107 = 1;
              goto <D.27965>;
              <D.27964>:
              iftmp.107 = 0;
              <D.27965>:
              iftmp.106 = (_Bool) iftmp.107;
              goto <D.27968>;
              <D.27961>:
              D.26880 = j + 1;
              D.26881 = (sizetype) D.26880;
              D.26882 = spec + D.26881;
              D.26883 = *D.26882;
              D.26884 = D.26883 == 108;
              D.26880 = j + 1;
              D.26881 = (sizetype) D.26880;
              D.26882 = spec + D.26881;
              D.26883 = *D.26882;
              D.26885 = D.26883 == 76;
              D.26886 = D.26884 | D.26885;
              D.26890 = (int) D.26886;
              iftmp.106 = (_Bool) D.26890;
              <D.27968>:
              if (iftmp.106 != 0) goto <D.27969>; else goto <D.27970>;
              <D.27969>:
              monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-codegen.c", 2103);
              <D.27970>:
              D.27227 = dest_sregs[j];
              if (D.27227 != -1) goto <D.27973>; else goto <D.27971>;
              <D.27973>:
              D.26861 = sregs[j];
              D.27974 = (unsigned int) D.26861;
              if (D.27974 <= 15) goto <D.27975>; else goto <D.27971>;
              <D.27975>:
              D.26861 = sregs[j];
              D.27976 = 2032 >> D.26861;
              D.27977 = D.27976 & 1;
              if (D.27977 != 0) goto <D.27978>; else goto <D.27971>;
              <D.27978>:
              {
                struct MonoInst * copy;

                D.27227 = dest_sregs[j];
                D.26861 = sregs[j];
                copy = create_copy_ins (cfg, bb, tmp, D.27227, D.26861, 0B, ip, 0);
                insert_before_ins (bb, ins, copy);
                D.27227 = dest_sregs[j];
                sregs[j] = D.27227;
              }
              goto <D.27972>;
              <D.27971>:
              D.26927 = bank != 0;
              D.26928 = (long int) D.26927;
              D.26929 = __builtin_expect (D.26928, 0);
              if (D.26929 != 0) goto <D.27980>; else goto <D.27981>;
              <D.27980>:
              D.26861 = sregs[j];
              if (D.26861 < 0) goto <D.27983>; else goto <D.27986>;
              <D.27986>:
              D.26861 = sregs[j];
              D.26937 = regbank_size[bank];
              if (D.26861 >= D.26937) goto <D.27983>; else goto <D.27984>;
              <D.27983>:
              iftmp.109 = 1;
              goto <D.27985>;
              <D.27984>:
              iftmp.109 = 0;
              <D.27985>:
              iftmp.108 = (_Bool) iftmp.109;
              goto <D.27987>;
              <D.27981>:
              D.26861 = sregs[j];
              iftmp.108 = D.26861 > 15;
              <D.27987>:
              if (iftmp.108 != 0) goto <D.27988>; else goto <D.27989>;
              <D.27988>:
              D.26950 = rs->vassign;
              D.26861 = sregs[j];
              D.26869 = (unsigned int) D.26861;
              D.27990 = D.26869 * 4;
              D.27991 = D.26950 + D.27990;
              val = *D.27991;
              D.27227 = dest_sregs[j];
              if (D.27227 != -1) goto <D.27992>; else goto <D.27993>;
              <D.27992>:
              if (val >= 0) goto <D.27994>; else goto <D.27995>;
              <D.27994>:
              D.27227 = dest_sregs[j];
              if (D.27227 != val) goto <D.27996>; else goto <D.27997>;
              <D.27996>:
              D.26861 = sregs[j];
              spill_vreg (cfg, bb, tmp, ins, D.26861, 0);
              D.26950 = rs->vassign;
              D.26861 = sregs[j];
              D.26869 = (unsigned int) D.26861;
              D.27990 = D.26869 * 4;
              D.27991 = D.26950 + D.27990;
              val = *D.27991;
              <D.27997>:
              <D.27995>:
              <D.27993>:
              if (val < 0) goto <D.27998>; else goto <D.27999>;
              <D.27998>:
              {
                int spill;

                spill = 0;
                if (val < -1) goto <D.28000>; else goto <D.28001>;
                <D.28000>:
                spill = ~val;
                <D.28001>:
                D.27501 = sreg_masks[j];
                D.26861 = sregs[j];
                D.26861 = sregs[j];
                D.26869 = (unsigned int) D.26861;
                D.26870 = D.26869 * 12;
                D.28002 = reginfo + D.26870;
                val = alloc_reg (cfg, bb, tmp, ins, D.27501, D.26861, D.28002, bank);
                D.26861 = sregs[j];
                assign_reg (cfg, rs, D.26861, val, bank);
                D.26819 = cfg->verbose_level;
                D.26898 = D.26819 > 2;
                D.26899 = (long int) D.26898;
                D.26900 = __builtin_expect (D.26899, 0);
                if (D.26900 != 0) goto <D.28003>; else goto <D.28004>;
                <D.28003>:
                D.26880 = j + 1;
                D.28005 = mono_regname_full (val, bank);
                D.26861 = sregs[j];
                printf ("\tassigned sreg%d %s to R%d\n", D.26880, D.28005, D.26861);
                <D.28004>:
                if (spill != 0) goto <D.28006>; else goto <D.28007>;
                <D.28006>:
                D.26861 = sregs[j];
                create_spilled_store (cfg, bb, spill, val, D.26861, tmp, 0B, ins, bank);
                <D.28007>:
              }
              <D.27999>:
              sregs[j] = val;
              k = j + 1;
              goto <D.26201>;
              <D.26200>:
              D.28008 = sreg_masks[k];
              D.26861 = sregs[j];
              D.28009 = 1 << D.26861;
              D.28010 = ~D.28009;
              D.28011 = D.28008 & D.28010;
              sreg_masks[k] = D.28011;
              k = k + 1;
              <D.26201>:
              if (k < num_sregs) goto <D.26200>; else goto <D.26202>;
              <D.26202>:
              goto <D.28012>;
              <D.27989>:
              prev_sregs[j] = -1;
              <D.28012>:
              <D.27972>:
            }
            j = j + 1;
            <D.26204>:
            if (j < num_sregs) goto <D.26203>; else goto <D.26205>;
            <D.26205>:
            mono_inst_set_src_registers (ins, &sregs);
            j = 1;
            goto <D.26213>;
            <D.26212>:
            {
              int sreg;
              int dest_sreg;

              sreg = sregs[j];
              dest_sreg = dest_sregs[j];
              D.28013 = j == 2;
              D.28014 = dest_sreg != -1;
              D.28015 = D.28013 & D.28014;
              if (D.28015 != 0) goto <D.28016>; else goto <D.28017>;
              <D.28016>:
              {
                int k;

                D.28018 = sreg != dest_sreg;
                D.28019 = (long int) D.28018;
                D.28020 = __builtin_expect (D.28019, 0);
                if (D.28020 != 0) goto <D.28021>; else goto <D.28022>;
                <D.28021>:
                monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 2163, "sreg == dest_sreg");
                <D.28022>:
                k = 0;
                goto <D.26210>;
                <D.26209>:
                if (k != j) goto <D.28023>; else goto <D.28024>;
                <D.28023>:
                D.28025 = sregs[k];
                D.28026 = D.28025 == dest_sreg;
                D.28027 = (long int) D.28026;
                D.28028 = __builtin_expect (D.28027, 0);
                if (D.28028 != 0) goto <D.28029>; else goto <D.28030>;
                <D.28029>:
                monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 2167, "sregs [k] != dest_sreg");
                <D.28030>:
                <D.28024>:
                k = k + 1;
                <D.26210>:
                if (k < num_sregs) goto <D.26209>; else goto <D.26211>;
                <D.26211>:
              }
              <D.28017>:
            }
            j = j + 1;
            <D.26213>:
            if (j < num_sregs) goto <D.26212>; else goto <D.26214>;
            <D.26214>:
            D.26819 = cfg->verbose_level;
            D.26898 = D.26819 > 2;
            D.26899 = (long int) D.26898;
            D.26900 = __builtin_expect (D.26899, 0);
            if (D.26900 != 0) goto <D.28031>; else goto <D.28032>;
            <D.28031>:
            mono_print_ins_index (i, ins);
            <D.28032>:
          }
        finally
          {
            dest_sregs = {CLOBBER};
            prev_sregs = {CLOBBER};
            sreg_masks = {CLOBBER};
            sreg_fixed_masks = {CLOBBER};
          }
      }
      ins = prev;
      if (ins != 0B) goto <D.28034>; else goto <D.28035>;
      <D.28034>:
      iftmp.110 = ins->prev;
      goto <D.28036>;
      <D.28035>:
      iftmp.110 = 0B;
      <D.28036>:
      prev = iftmp.110;
      <D.26216>:
      if (ins != 0B) goto <D.26215>; else goto <D.26217>;
      <D.26217>:
    }
  finally
    {
      last = {CLOBBER};
      sregs = {CLOBBER};
    }
}


mono_regstate_assign (struct MonoRegState * rs)
{
  int D.28040;
  int D.28041;
  gint32 * D.28044;
  int D.28045;
  unsigned int D.28046;
  unsigned int D.28047;
  void * D.28048;
  int[16] * D.28049;
  int[32] * D.28050;

  D.28040 = rs->next_vreg;
  D.28041 = rs->vassign_size;
  if (D.28040 > D.28041) goto <D.28042>; else goto <D.28043>;
  <D.28042>:
  D.28044 = rs->vassign;
  monoeg_g_free (D.28044);
  D.28040 = rs->next_vreg;
  D.28045 = MAX_EXPR <D.28040, 256>;
  rs->vassign_size = D.28045;
  D.28041 = rs->vassign_size;
  D.28046 = (unsigned int) D.28041;
  D.28047 = D.28046 * 4;
  D.28048 = monoeg_malloc (D.28047);
  rs->vassign = D.28048;
  <D.28043>:
  D.28049 = &rs->isymbolic;
  memset (D.28049, 0, 64);
  D.28050 = &rs->fsymbolic;
  memset (D.28050, 0, 128);
  D.28049 = &rs->isymbolic;
  rs->symbolic[0] = D.28049;
  D.28050 = &rs->fsymbolic;
  rs->symbolic[1] = D.28050;
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.28053;
  int D.28058;
  void * D.28060;
  unsigned int D.28061;

  D.28053 = __builtin_constant_p (__len);
  if (D.28053 != 0) goto <D.28054>; else goto <D.28055>;
  <D.28054>:
  if (__len == 0) goto <D.28056>; else goto <D.28057>;
  <D.28056>:
  D.28058 = __builtin_constant_p (__ch);
  if (D.28058 == 0) goto <D.28051>; else goto <D.28059>;
  <D.28059>:
  if (__ch != 0) goto <D.28051>; else goto <D.28052>;
  <D.28051>:
  __warn_memset_zero_len ();
  D.28060 = __dest;
  return D.28060;
  <D.28052>:
  <D.28057>:
  <D.28055>:
  D.28061 = __builtin_object_size (__dest, 0);
  D.28060 = __builtin___memset_chk (__dest, __ch, __len, D.28061);
  return D.28060;
}


print_regtrack (struct RegTrack * t, int num)
{
  unsigned int i.111;
  unsigned int D.28064;
  struct RegTrack * D.28065;
  int D.28066;
  int D.28072;
  int i;
  char buf[32];
  const char * r;

  try
    {
      i = 0;
      goto <D.25885>;
      <D.25884>:
      i.111 = (unsigned int) i;
      D.28064 = i.111 * 12;
      D.28065 = t + D.28064;
      D.28066 = D.28065->born_in;
      if (D.28066 == 0) goto <D.28067>; else goto <D.28068>;
      <D.28067>:
      // predicted unlikely by continue predictor.
      goto <D.25883>;
      <D.28068>:
      if (i > 15) goto <D.28069>; else goto <D.28070>;
      <D.28069>:
      monoeg_g_snprintf (&buf, 32, "R%d", i);
      r = &buf;
      goto <D.28071>;
      <D.28070>:
      r = mono_arch_regname (i);
      <D.28071>:
      i.111 = (unsigned int) i;
      D.28064 = i.111 * 12;
      D.28065 = t + D.28064;
      D.28066 = D.28065->born_in;
      i.111 = (unsigned int) i;
      D.28064 = i.111 * 12;
      D.28065 = t + D.28064;
      D.28072 = D.28065->killed_in;
      printf ("liveness: %s [%d - %d]\n", r, D.28066, D.28072);
      <D.25883>:
      i = i + 1;
      <D.25885>:
      if (i < num) goto <D.25884>; else goto <D.25886>;
      <D.25886>:
    }
  finally
    {
      buf = {CLOBBER};
    }
}


get_callee_mask (const char spec)
{
  int iftmp.112;
  int D.28076;
  char D.28078;
  _Bool D.28080;
  long int D.28081;
  long int D.28082;
  regmask_t D.28085;
  int iftmp.113;
  int D.28089;

  D.28076 = mono_arch_is_soft_float ();
  if (D.28076 == 0) goto <D.28077>; else goto <D.28074>;
  <D.28077>:
  D.28078 = spec + 154;
  if (D.28078 <= 1) goto <D.28079>; else goto <D.28074>;
  <D.28079>:
  iftmp.112 = 1;
  goto <D.28075>;
  <D.28074>:
  iftmp.112 = 0;
  <D.28075>:
  D.28080 = iftmp.112 != 0;
  D.28081 = (long int) D.28080;
  D.28082 = __builtin_expect (D.28081, 0);
  if (D.28082 != 0) goto <D.28083>; else goto <D.28084>;
  <D.28083>:
  D.28089 = mono_arch_is_soft_float ();
  if (D.28089 == 0) goto <D.28090>; else goto <D.28087>;
  <D.28090>:
  D.28078 = spec + 154;
  if (D.28078 <= 1) goto <D.28091>; else goto <D.28087>;
  <D.28091>:
  iftmp.113 = 1;
  goto <D.28088>;
  <D.28087>:
  iftmp.113 = 0;
  <D.28088>:
  D.28085 = regbank_callee_regs[iftmp.113];
  return D.28085;
  <D.28084>:
  D.28085 = 4111;
  return D.28085;
}


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.28095;
  struct MonoRegState * D.28098;
  unsigned int D.28099;
  unsigned int D.28102;
  _Bool D.28103;
  long int D.28104;
  long int D.28105;
  const char * D.28108;
  int D.28109;
  int val;

  if (info != 0B) goto <D.28093>; else goto <D.28094>;
  <D.28093>:
  D.28095 = info->preferred_mask;
  if (D.28095 != 0) goto <D.28096>; else goto <D.28097>;
  <D.28096>:
  D.28098 = cfg->rs;
  D.28095 = info->preferred_mask;
  D.28099 = D.28095 & dest_mask;
  val = mono_regstate_alloc_int (D.28098, D.28099);
  if (val >= 0) goto <D.28100>; else goto <D.28101>;
  <D.28100>:
  D.28102 = cfg->verbose_level;
  D.28103 = D.28102 > 2;
  D.28104 = (long int) D.28103;
  D.28105 = __builtin_expect (D.28104, 0);
  if (D.28105 != 0) goto <D.28106>; else goto <D.28107>;
  <D.28106>:
  D.28108 = mono_arch_regname (val);
  printf ("\tallocated preferred reg R%d to %s\n", sym_reg, D.28108);
  <D.28107>:
  D.28109 = val;
  return D.28109;
  <D.28101>:
  <D.28097>:
  <D.28094>:
  D.28098 = cfg->rs;
  val = mono_regstate_alloc_int (D.28098, dest_mask);
  if (val < 0) goto <D.28110>; else goto <D.28111>;
  <D.28110>:
  val = get_register_spilling (cfg, bb, last, ins, dest_mask, sym_reg, 0);
  <D.28111>:
  D.28109 = val;
  return D.28109;
}


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

  D.28113 = bank;
  return D.28113;
}


free_up_hreg (struct MonoCompile * cfg, struct MonoBasicBlock * bb, struct MonoInst * * last, struct MonoInst * ins, int hreg, int bank)
{
  _Bool D.28115;
  long int D.28116;
  long int D.28117;
  struct MonoRegState * D.28120;
  unsigned int D.28121;
  unsigned int D.28122;
  unsigned int D.28123;
  unsigned int D.28126;
  _Bool D.28127;
  long int D.28128;
  long int D.28129;
  int * D.28132;
  unsigned int hreg.114;
  unsigned int D.28134;
  int * D.28135;
  int D.28136;
  unsigned int D.28138;
  unsigned int D.28139;
  int D.28144;

  D.28115 = bank != 0;
  D.28116 = (long int) D.28115;
  D.28117 = __builtin_expect (D.28116, 0);
  if (D.28117 != 0) goto <D.28118>; else goto <D.28119>;
  <D.28118>:
  D.28120 = cfg->rs;
  D.28121 = D.28120->free_mask[bank];
  D.28122 = 1 << hreg;
  D.28123 = D.28121 & D.28122;
  if (D.28123 == 0) goto <D.28124>; else goto <D.28125>;
  <D.28124>:
  D.28120 = cfg->rs;
  bank = translate_bank (D.28120, bank, hreg);
  D.28126 = cfg->verbose_level;
  D.28127 = D.28126 > 2;
  D.28128 = (long int) D.28127;
  D.28129 = __builtin_expect (D.28128, 0);
  if (D.28129 != 0) goto <D.28130>; else goto <D.28131>;
  <D.28130>:
  D.28120 = cfg->rs;
  D.28132 = D.28120->symbolic[bank];
  hreg.114 = (unsigned int) hreg;
  D.28134 = hreg.114 * 4;
  D.28135 = D.28132 + D.28134;
  D.28136 = *D.28135;
  printf ("\tforced spill of R%d\n", D.28136);
  <D.28131>:
  D.28120 = cfg->rs;
  D.28132 = D.28120->symbolic[bank];
  hreg.114 = (unsigned int) hreg;
  D.28134 = hreg.114 * 4;
  D.28135 = D.28132 + D.28134;
  D.28136 = *D.28135;
  spill_vreg (cfg, bb, last, ins, D.28136, bank);
  <D.28125>:
  goto <D.28137>;
  <D.28119>:
  D.28120 = cfg->rs;
  D.28138 = D.28120->ifree_mask;
  D.28122 = 1 << hreg;
  D.28139 = D.28138 & D.28122;
  if (D.28139 == 0) goto <D.28140>; else goto <D.28141>;
  <D.28140>:
  D.28126 = cfg->verbose_level;
  D.28127 = D.28126 > 2;
  D.28128 = (long int) D.28127;
  D.28129 = __builtin_expect (D.28128, 0);
  if (D.28129 != 0) goto <D.28142>; else goto <D.28143>;
  <D.28142>:
  D.28120 = cfg->rs;
  D.28144 = D.28120->isymbolic[hreg];
  printf ("\tforced spill of R%d\n", D.28144);
  <D.28143>:
  D.28120 = cfg->rs;
  D.28144 = D.28120->isymbolic[hreg];
  spill_vreg (cfg, bb, last, ins, D.28144, bank);
  <D.28141>:
  <D.28137>:
}


mono_regstate_alloc_int (struct MonoRegState * rs, regmask_t allow)
{
  unsigned int D.28145;
  unsigned int D.28146;
  unsigned int D.28147;
  unsigned int D.28150;
  unsigned int D.28151;
  int D.28152;
  regmask_t mask;
  int i;

  D.28145 = rs->ifree_mask;
  mask = D.28145 & allow;
  i = 0;
  goto <D.25689>;
  <D.25688>:
  D.28146 = 1 << i;
  D.28147 = D.28146 & mask;
  if (D.28147 != 0) goto <D.28148>; else goto <D.28149>;
  <D.28148>:
  D.28145 = rs->ifree_mask;
  D.28146 = 1 << i;
  D.28150 = ~D.28146;
  D.28151 = D.28145 & D.28150;
  rs->ifree_mask = D.28151;
  D.28152 = i;
  return D.28152;
  <D.28149>:
  i = i + 1;
  <D.25689>:
  if (i <= 15) goto <D.25688>; else goto <D.25690>;
  <D.25690>:
  D.28152 = -1;
  return D.28152;
}


get_register_spilling (struct MonoCompile * cfg, struct MonoBasicBlock * bb, struct MonoInst * * last, struct MonoInst * ins, regmask_t regmask, int reg, int bank)
{
  _Bool D.28154;
  long int D.28155;
  long int D.28156;
  unsigned int D.28159;
  _Bool D.28160;
  long int D.28161;
  long int D.28162;
  long long unsigned int D.28165;
  int D.28166;
  int D.28167;
  int D.28168;
  int D.28169;
  short unsigned int D.28170;
  int D.28171;
  int D.28172;
  signed char D.28173;
  int iftmp.115;
  int D.28179;
  short unsigned int D.28181;
  sizetype D.28182;
  sizetype i.116;
  sizetype D.28184;
  sizetype D.28185;
  const char * D.28186;
  char D.28187;
  char D.28188;
  int D.28192;
  _Bool D.28195;
  long int D.28196;
  long int D.28197;
  int iftmp.117;
  int iftmp.118;
  int D.28211;
  _Bool D.28213;
  unsigned int D.28217;
  unsigned int D.28218;
  unsigned int D.28219;
  _Bool D.28221;
  int iftmp.119;
  unsigned int D.28227;
  unsigned int D.28229;
  unsigned int D.28230;
  _Bool D.28232;
  int iftmp.120;
  _Bool D.28240;
  int iftmp.121;
  _Bool D.28249;
  gint32 * D.28253;
  unsigned int D.28254;
  unsigned int D.28255;
  gint32 * D.28256;
  int D.28257;
  _Bool iftmp.122;
  int iftmp.123;
  unsigned int D.28269;
  unsigned int D.28270;
  unsigned int D.28272;
  unsigned int D.28273;
  int D.28276;
  const char * D.28277;
  int iftmp.124;
  int D.28281;
  const char * D.28283;
  char D.28284;
  char D.28285;
  _Bool iftmp.125;
  _Bool iftmp.126;
  int iftmp.127;
  int iftmp.128;
  _Bool D.28307;
  unsigned int D.28311;
  unsigned int D.28312;
  int iftmp.129;
  unsigned int D.28318;
  unsigned int D.28320;
  unsigned int D.28321;
  int iftmp.130;
  unsigned int D.28331;
  unsigned int D.28332;
  const char * D.28335;
  _Bool D.28338;
  long int D.28339;
  long int D.28340;
  unsigned int D.28345;
  unsigned int D.28346;
  struct MonoRegState * D.28349;
  const char * D.28352;
  int * D.28353;
  unsigned int sel.131;
  unsigned int D.28355;
  int * D.28356;
  int D.28357;
  int D.28358;
  int D.28359;
  unsigned int i.132;
  unsigned int D.28361;
  gint32 * D.28362;
  int D.28363;
  const char * D.28369;
  int D.28370;
  struct MonoMemPool * D.28371;
  int D.28372;
  short unsigned int D.28373;
  int D.28374;
  int D.28375;
  const unsigned char * D.28376;
  unsigned int D.28377;
  int D.28378;
  int D.28379;
  int D.28380;
  int D.28383;
  const char * D.28384;
  unsigned int D.28387;
  _Bool D.28389;
  long int D.28390;
  long int D.28391;
  int D.28394;
  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.28154 = bank > 3;
      D.28155 = (long int) D.28154;
      D.28156 = __builtin_expect (D.28155, 0);
      if (D.28156 != 0) goto <D.28157>; else goto <D.28158>;
      <D.28157>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 831, "bank < MONO_NUM_REGBANKS");
      <D.28158>:
      D.28159 = cfg->verbose_level;
      D.28160 = D.28159 > 2;
      D.28161 = (long int) D.28160;
      D.28162 = __builtin_expect (D.28161, 0);
      if (D.28162 != 0) goto <D.28163>; else goto <D.28164>;
      <D.28163>:
      D.28165 = (long long unsigned int) regmask;
      D.28166 = ins->dreg;
      D.28167 = ins->sreg1;
      D.28168 = ins->sreg2;
      D.28169 = ins->sreg3;
      printf ("\tstart regmask to assign R%d: 0x%08llu (R%d <- R%d R%d R%d)\n", reg, D.28165, D.28166, D.28167, D.28168, D.28169);
      <D.28164>:
      D.28167 = ins->sreg1;
      sregs[0] = D.28167;
      D.28168 = ins->sreg2;
      sregs[1] = D.28168;
      D.28169 = ins->sreg3;
      sregs[2] = D.28169;
      D.28170 = ins->opcode;
      D.28171 = (int) D.28170;
      D.28172 = D.28171 + -313;
      D.28173 = ins_sreg_counts[D.28172];
      num_sregs = (int) D.28173;
      i = 0;
      goto <D.25938>;
      <D.25937>:
      D.28179 = mono_arch_is_soft_float ();
      if (D.28179 == 0) goto <D.28180>; else goto <D.28177>;
      <D.28180>:
      D.28170 = ins->opcode;
      D.28171 = (int) D.28170;
      D.28172 = D.28171 + -313;
      D.28181 = arm_cpu_desc_idx[D.28172];
      D.28182 = (sizetype) D.28181;
      i.116 = (sizetype) i;
      D.28184 = D.28182 + i.116;
      D.28185 = D.28184 + 1;
      D.28186 = &arm_cpu_desc + D.28185;
      D.28187 = *D.28186;
      D.28188 = D.28187 + 154;
      if (D.28188 <= 1) goto <D.28189>; else goto <D.28177>;
      <D.28189>:
      iftmp.115 = 1;
      goto <D.28178>;
      <D.28177>:
      iftmp.115 = 0;
      <D.28178>:
      if (iftmp.115 == bank) goto <D.28190>; else goto <D.28191>;
      <D.28190>:
      D.28192 = sregs[i];
      if (D.28192 != reg) goto <D.28193>; else goto <D.28194>;
      <D.28193>:
      D.28195 = bank != 0;
      D.28196 = (long int) D.28195;
      D.28197 = __builtin_expect (D.28196, 0);
      if (D.28197 != 0) goto <D.28198>; else goto <D.28199>;
      <D.28198>:
      D.28195 = bank != 0;
      D.28196 = (long int) D.28195;
      D.28197 = __builtin_expect (D.28196, 0);
      if (D.28197 != 0) goto <D.28200>; else goto <D.28201>;
      <D.28200>:
      D.28195 = bank != 0;
      D.28196 = (long int) D.28195;
      D.28197 = __builtin_expect (D.28196, 0);
      if (D.28197 != 0) goto <D.28205>; else goto <D.28206>;
      <D.28205>:
      D.28192 = sregs[i];
      if (D.28192 >= 0) goto <D.28210>; else goto <D.28208>;
      <D.28210>:
      D.28192 = sregs[i];
      D.28211 = regbank_size[bank];
      if (D.28192 < D.28211) goto <D.28212>; else goto <D.28208>;
      <D.28212>:
      iftmp.118 = 1;
      goto <D.28209>;
      <D.28208>:
      iftmp.118 = 0;
      <D.28209>:
      D.28213 = (_Bool) iftmp.118;
      if (D.28213 != 0) goto <D.28214>; else goto <D.28203>;
      <D.28214>:
      goto <D.28215>;
      <D.28206>:
      D.28192 = sregs[i];
      if (D.28192 <= 15) goto <D.28216>; else goto <D.28203>;
      <D.28216>:
      <D.28215>:
      D.28217 = regbank_callee_regs[bank];
      D.28192 = sregs[i];
      D.28218 = D.28217 >> D.28192;
      D.28219 = D.28218 & 1;
      if (D.28219 != 0) goto <D.28220>; else goto <D.28203>;
      <D.28220>:
      iftmp.117 = 1;
      goto <D.28204>;
      <D.28203>:
      iftmp.117 = 0;
      <D.28204>:
      D.28221 = (_Bool) iftmp.117;
      if (D.28221 != 0) goto <D.28174>; else goto <D.28222>;
      <D.28222>:
      goto <D.28223>;
      <D.28201>:
      D.28192 = sregs[i];
      D.28227 = (unsigned int) D.28192;
      if (D.28227 <= 15) goto <D.28228>; else goto <D.28225>;
      <D.28228>:
      D.28192 = sregs[i];
      D.28229 = 4111 >> D.28192;
      D.28230 = D.28229 & 1;
      if (D.28230 != 0) goto <D.28231>; else goto <D.28225>;
      <D.28231>:
      iftmp.119 = 1;
      goto <D.28226>;
      <D.28225>:
      iftmp.119 = 0;
      <D.28226>:
      D.28232 = (_Bool) iftmp.119;
      if (D.28232 != 0) goto <D.28174>; else goto <D.28233>;
      <D.28233>:
      <D.28223>:
      goto <D.28234>;
      <D.28199>:
      D.28192 = sregs[i];
      D.28227 = (unsigned int) D.28192;
      if (D.28227 <= 15) goto <D.28238>; else goto <D.28236>;
      <D.28238>:
      D.28192 = sregs[i];
      D.28229 = 4111 >> D.28192;
      D.28230 = D.28229 & 1;
      if (D.28230 != 0) goto <D.28239>; else goto <D.28236>;
      <D.28239>:
      iftmp.120 = 1;
      goto <D.28237>;
      <D.28236>:
      iftmp.120 = 0;
      <D.28237>:
      D.28240 = (_Bool) iftmp.120;
      if (D.28240 != 0) goto <D.28174>; else goto <D.28241>;
      <D.28241>:
      <D.28234>:
      D.28195 = bank != 0;
      D.28196 = (long int) D.28195;
      D.28197 = __builtin_expect (D.28196, 0);
      if (D.28197 != 0) goto <D.28242>; else goto <D.28243>;
      <D.28242>:
      D.28192 = sregs[i];
      if (D.28192 < 0) goto <D.28245>; else goto <D.28248>;
      <D.28248>:
      D.28192 = sregs[i];
      D.28211 = regbank_size[bank];
      if (D.28192 >= D.28211) goto <D.28245>; else goto <D.28246>;
      <D.28245>:
      iftmp.121 = 1;
      goto <D.28247>;
      <D.28246>:
      iftmp.121 = 0;
      <D.28247>:
      D.28249 = (_Bool) iftmp.121;
      if (D.28249 != 0) goto <D.28250>; else goto <D.28175>;
      <D.28250>:
      goto <D.28251>;
      <D.28243>:
      D.28192 = sregs[i];
      if (D.28192 > 15) goto <D.28252>; else goto <D.28175>;
      <D.28252>:
      <D.28251>:
      D.28253 = rs->vassign;
      D.28192 = sregs[i];
      D.28254 = (unsigned int) D.28192;
      D.28255 = D.28254 * 4;
      D.28256 = D.28253 + D.28255;
      D.28257 = *D.28256;
      if (D.28257 >= 0) goto <D.28174>; else goto <D.28175>;
      <D.28174>:
      D.28195 = bank != 0;
      D.28196 = (long int) D.28195;
      D.28197 = __builtin_expect (D.28196, 0);
      if (D.28197 != 0) goto <D.28259>; else goto <D.28260>;
      <D.28259>:
      D.28192 = sregs[i];
      if (D.28192 < 0) goto <D.28262>; else goto <D.28265>;
      <D.28265>:
      D.28192 = sregs[i];
      D.28211 = regbank_size[bank];
      if (D.28192 >= D.28211) goto <D.28262>; else goto <D.28263>;
      <D.28262>:
      iftmp.123 = 1;
      goto <D.28264>;
      <D.28263>:
      iftmp.123 = 0;
      <D.28264>:
      iftmp.122 = (_Bool) iftmp.123;
      goto <D.28266>;
      <D.28260>:
      D.28192 = sregs[i];
      iftmp.122 = D.28192 > 15;
      <D.28266>:
      if (iftmp.122 != 0) goto <D.28267>; else goto <D.28268>;
      <D.28267>:
      D.28253 = rs->vassign;
      D.28192 = sregs[i];
      D.28254 = (unsigned int) D.28192;
      D.28255 = D.28254 * 4;
      D.28256 = D.28253 + D.28255;
      D.28257 = *D.28256;
      D.28269 = 1 << D.28257;
      D.28270 = ~D.28269;
      regmask = D.28270 & regmask;
      goto <D.28271>;
      <D.28268>:
      D.28192 = sregs[i];
      D.28272 = 1 << D.28192;
      D.28273 = ~D.28272;
      regmask = D.28273 & regmask;
      <D.28271>:
      D.28159 = cfg->verbose_level;
      D.28160 = D.28159 > 2;
      D.28161 = (long int) D.28160;
      D.28162 = __builtin_expect (D.28161, 0);
      if (D.28162 != 0) goto <D.28274>; else goto <D.28275>;
      <D.28274>:
      D.28276 = i + 1;
      D.28192 = sregs[i];
      D.28277 = mono_regname_full (D.28192, bank);
      D.28192 = sregs[i];
      printf ("\t\texcluding sreg%d %s %d\n", D.28276, D.28277, D.28192);
      <D.28275>:
      <D.28175>:
      <D.28194>:
      <D.28191>:
      i = i + 1;
      <D.25938>:
      if (i < num_sregs) goto <D.25937>; else goto <D.25939>;
      <D.25939>:
      D.28281 = mono_arch_is_soft_float ();
      if (D.28281 == 0) goto <D.28282>; else goto <D.28279>;
      <D.28282>:
      D.28170 = ins->opcode;
      D.28171 = (int) D.28170;
      D.28172 = D.28171 + -313;
      D.28181 = arm_cpu_desc_idx[D.28172];
      D.28182 = (sizetype) D.28181;
      D.28283 = &arm_cpu_desc + D.28182;
      D.28284 = *D.28283;
      D.28285 = D.28284 + 154;
      if (D.28285 <= 1) goto <D.28286>; else goto <D.28279>;
      <D.28286>:
      iftmp.124 = 1;
      goto <D.28280>;
      <D.28279>:
      iftmp.124 = 0;
      <D.28280>:
      if (iftmp.124 == bank) goto <D.28287>; else goto <D.28288>;
      <D.28287>:
      D.28166 = ins->dreg;
      if (D.28166 != reg) goto <D.28289>; else goto <D.28290>;
      <D.28289>:
      D.28195 = bank != 0;
      D.28196 = (long int) D.28195;
      D.28197 = __builtin_expect (D.28196, 0);
      if (D.28197 != 0) goto <D.28292>; else goto <D.28293>;
      <D.28292>:
      D.28195 = bank != 0;
      D.28196 = (long int) D.28195;
      D.28197 = __builtin_expect (D.28196, 0);
      if (D.28197 != 0) goto <D.28295>; else goto <D.28296>;
      <D.28295>:
      D.28195 = bank != 0;
      D.28196 = (long int) D.28195;
      D.28197 = __builtin_expect (D.28196, 0);
      if (D.28197 != 0) goto <D.28300>; else goto <D.28301>;
      <D.28300>:
      D.28166 = ins->dreg;
      if (D.28166 >= 0) goto <D.28305>; else goto <D.28303>;
      <D.28305>:
      D.28166 = ins->dreg;
      D.28211 = regbank_size[bank];
      if (D.28166 < D.28211) goto <D.28306>; else goto <D.28303>;
      <D.28306>:
      iftmp.128 = 1;
      goto <D.28304>;
      <D.28303>:
      iftmp.128 = 0;
      <D.28304>:
      D.28307 = (_Bool) iftmp.128;
      if (D.28307 != 0) goto <D.28308>; else goto <D.28298>;
      <D.28308>:
      goto <D.28309>;
      <D.28301>:
      D.28166 = ins->dreg;
      if (D.28166 <= 15) goto <D.28310>; else goto <D.28298>;
      <D.28310>:
      <D.28309>:
      D.28217 = regbank_callee_regs[bank];
      D.28166 = ins->dreg;
      D.28311 = D.28217 >> D.28166;
      D.28312 = D.28311 & 1;
      if (D.28312 != 0) goto <D.28313>; else goto <D.28298>;
      <D.28313>:
      iftmp.127 = 1;
      goto <D.28299>;
      <D.28298>:
      iftmp.127 = 0;
      <D.28299>:
      iftmp.126 = (_Bool) iftmp.127;
      goto <D.28314>;
      <D.28296>:
      D.28166 = ins->dreg;
      D.28318 = (unsigned int) D.28166;
      if (D.28318 <= 15) goto <D.28319>; else goto <D.28316>;
      <D.28319>:
      D.28166 = ins->dreg;
      D.28320 = 4111 >> D.28166;
      D.28321 = D.28320 & 1;
      if (D.28321 != 0) goto <D.28322>; else goto <D.28316>;
      <D.28322>:
      iftmp.129 = 1;
      goto <D.28317>;
      <D.28316>:
      iftmp.129 = 0;
      <D.28317>:
      iftmp.126 = (_Bool) iftmp.129;
      <D.28314>:
      iftmp.125 = iftmp.126;
      goto <D.28323>;
      <D.28293>:
      D.28166 = ins->dreg;
      D.28318 = (unsigned int) D.28166;
      if (D.28318 <= 15) goto <D.28327>; else goto <D.28325>;
      <D.28327>:
      D.28166 = ins->dreg;
      D.28320 = 4111 >> D.28166;
      D.28321 = D.28320 & 1;
      if (D.28321 != 0) goto <D.28328>; else goto <D.28325>;
      <D.28328>:
      iftmp.130 = 1;
      goto <D.28326>;
      <D.28325>:
      iftmp.130 = 0;
      <D.28326>:
      iftmp.125 = (_Bool) iftmp.130;
      <D.28323>:
      if (iftmp.125 != 0) goto <D.28329>; else goto <D.28330>;
      <D.28329>:
      D.28166 = ins->dreg;
      D.28331 = 1 << D.28166;
      D.28332 = ~D.28331;
      regmask = D.28332 & regmask;
      D.28159 = cfg->verbose_level;
      D.28160 = D.28159 > 2;
      D.28161 = (long int) D.28160;
      D.28162 = __builtin_expect (D.28161, 0);
      if (D.28162 != 0) goto <D.28333>; else goto <D.28334>;
      <D.28333>:
      D.28166 = ins->dreg;
      D.28335 = mono_regname_full (D.28166, bank);
      printf ("\t\texcluding dreg %s\n", D.28335);
      <D.28334>:
      <D.28330>:
      <D.28290>:
      <D.28288>:
      D.28159 = cfg->verbose_level;
      D.28160 = D.28159 > 2;
      D.28161 = (long int) D.28160;
      D.28162 = __builtin_expect (D.28161, 0);
      if (D.28162 != 0) goto <D.28336>; else goto <D.28337>;
      <D.28336>:
      D.28165 = (long long unsigned int) regmask;
      printf ("\t\tavailable regmask: 0x%08llu\n", D.28165);
      <D.28337>:
      D.28338 = regmask == 0;
      D.28339 = (long int) D.28338;
      D.28340 = __builtin_expect (D.28339, 0);
      if (D.28340 != 0) goto <D.28341>; else goto <D.28342>;
      <D.28341>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 851, "regmask");
      <D.28342>:
      sel = 0;
      D.28195 = bank != 0;
      D.28196 = (long int) D.28195;
      D.28197 = __builtin_expect (D.28196, 0);
      if (D.28197 != 0) goto <D.28343>; else goto <D.28344>;
      <D.28343>:
      i = 0;
      goto <D.25942>;
      <D.25941>:
      D.28345 = 1 << i;
      D.28346 = D.28345 & regmask;
      if (D.28346 != 0) goto <D.28347>; else goto <D.28348>;
      <D.28347>:
      sel = i;
      D.28349 = cfg->rs;
      bank = translate_bank (D.28349, bank, sel);
      D.28159 = cfg->verbose_level;
      D.28160 = D.28159 > 2;
      D.28161 = (long int) D.28160;
      D.28162 = __builtin_expect (D.28161, 0);
      if (D.28162 != 0) goto <D.28350>; else goto <D.28351>;
      <D.28350>:
      D.28352 = mono_regname_full (sel, bank);
      D.28353 = rs->symbolic[bank];
      sel.131 = (unsigned int) sel;
      D.28355 = sel.131 * 4;
      D.28356 = D.28353 + D.28355;
      D.28357 = *D.28356;
      printf ("\t\tselected register %s has assignment %d\n", D.28352, D.28357);
      <D.28351>:
      goto <D.25940>;
      <D.28348>:
      i = i + 1;
      <D.25942>:
      D.28211 = regbank_size[bank];
      if (D.28211 > i) goto <D.25941>; else goto <D.25940>;
      <D.25940>:
      D.28353 = rs->symbolic[bank];
      sel.131 = (unsigned int) sel;
      D.28355 = sel.131 * 4;
      D.28356 = D.28353 + D.28355;
      i = *D.28356;
      D.28358 = cfg->spill_count;
      D.28359 = D.28358 + 1;
      cfg->spill_count = D.28359;
      spill = cfg->spill_count;
      D.28253 = rs->vassign;
      i.132 = (unsigned int) i;
      D.28361 = i.132 * 4;
      D.28362 = D.28253 + D.28361;
      D.28363 = ~spill;
      *D.28362 = D.28363;
      mono_regstate_free_general (rs, sel, bank);
      goto <D.28364>;
      <D.28344>:
      i = 0;
      goto <D.25945>;
      <D.25944>:
      D.28345 = 1 << i;
      D.28346 = D.28345 & regmask;
      if (D.28346 != 0) goto <D.28365>; else goto <D.28366>;
      <D.28365>:
      sel = i;
      D.28159 = cfg->verbose_level;
      D.28160 = D.28159 > 2;
      D.28161 = (long int) D.28160;
      D.28162 = __builtin_expect (D.28161, 0);
      if (D.28162 != 0) goto <D.28367>; else goto <D.28368>;
      <D.28367>:
      D.28369 = mono_arch_regname (sel);
      D.28370 = rs->isymbolic[sel];
      printf ("\t\tselected register %s has assignment %d\n", D.28369, D.28370);
      <D.28368>:
      goto <D.25943>;
      <D.28366>:
      i = i + 1;
      <D.25945>:
      if (i <= 15) goto <D.25944>; else goto <D.25943>;
      <D.25943>:
      i = rs->isymbolic[sel];
      D.28358 = cfg->spill_count;
      D.28359 = D.28358 + 1;
      cfg->spill_count = D.28359;
      spill = cfg->spill_count;
      D.28253 = rs->vassign;
      i.132 = (unsigned int) i;
      D.28361 = i.132 * 4;
      D.28362 = D.28253 + D.28361;
      D.28363 = ~spill;
      *D.28362 = D.28363;
      mono_regstate_free_int (rs, sel);
      <D.28364>:
      D.28371 = cfg->mempool;
      load = mono_mempool_alloc0 (D.28371, 56);
      D.28372 = regbank_load_ops[bank];
      D.28373 = (short unsigned int) D.28372;
      load->opcode = D.28373;
      load->dreg = -1;
      load->sreg3 = -1;
      D.28374 = load->sreg3;
      load->sreg2 = D.28374;
      D.28375 = load->sreg2;
      load->sreg1 = D.28375;
      D.28376 = cfg->ip;
      load->cil_code = D.28376;
      load->dreg = sel;
      D.28377 = cfg->frame_reg;
      D.28378 = (int) D.28377;
      load->sreg1 = D.28378;
      D.28379 = get_vreg_bank (cfg, i, bank);
      D.28380 = mono_spillvar_offset (cfg, spill, D.28379);
      load->data.op[0].const_val = D.28380;
      insert_after_ins (bb, ins, last, load);
      D.28159 = cfg->verbose_level;
      D.28160 = D.28159 > 2;
      D.28161 = (long int) D.28160;
      D.28162 = __builtin_expect (D.28161, 0);
      if (D.28162 != 0) goto <D.28381>; else goto <D.28382>;
      <D.28381>:
      D.28383 = load->data.op[0].const_val;
      D.28384 = mono_regname_full (sel, bank);
      printf ("\tSPILLED LOAD (%d at 0x%08lx(%%ebp)) R%d (freed %s)\n", spill, D.28383, i, D.28384);
      <D.28382>:
      D.28195 = bank != 0;
      D.28196 = (long int) D.28195;
      D.28197 = __builtin_expect (D.28196, 0);
      if (D.28197 != 0) goto <D.28385>; else goto <D.28386>;
      <D.28385>:
      D.28387 = 1 << sel;
      i = mono_regstate_alloc_general (rs, D.28387, bank);
      goto <D.28388>;
      <D.28386>:
      D.28387 = 1 << sel;
      i = mono_regstate_alloc_int (rs, D.28387);
      <D.28388>:
      D.28389 = i != sel;
      D.28390 = (long int) D.28389;
      D.28391 = __builtin_expect (D.28390, 0);
      if (D.28391 != 0) goto <D.28392>; else goto <D.28393>;
      <D.28392>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 898, "i == sel");
      <D.28393>:
      D.28394 = sel;
      return D.28394;
    }
  finally
    {
      sregs = {CLOBBER};
    }
}


get_vreg_bank (struct MonoCompile * cfg, int reg, int bank)
{
  unsigned int reg.133;
  unsigned int D.28399;
  gboolean * D.28401;
  unsigned int reg.134;
  unsigned int D.28403;
  gboolean * D.28404;
  int D.28405;
  int D.28407;
  unsigned int D.28409;
  gboolean * D.28411;
  gboolean * D.28412;
  int D.28413;

  reg.133 = (unsigned int) reg;
  D.28399 = cfg->vreg_is_ref_len;
  if (reg.133 < D.28399) goto <D.28400>; else goto <D.28397>;
  <D.28400>:
  D.28401 = cfg->vreg_is_ref;
  reg.134 = (unsigned int) reg;
  D.28403 = reg.134 * 4;
  D.28404 = D.28401 + D.28403;
  D.28405 = *D.28404;
  if (D.28405 != 0) goto <D.28406>; else goto <D.28397>;
  <D.28406>:
  D.28407 = 2;
  return D.28407;
  <D.28397>:
  reg.133 = (unsigned int) reg;
  D.28409 = cfg->vreg_is_mp_len;
  if (reg.133 < D.28409) goto <D.28410>; else goto <D.28408>;
  <D.28410>:
  D.28411 = cfg->vreg_is_mp;
  reg.134 = (unsigned int) reg;
  D.28403 = reg.134 * 4;
  D.28412 = D.28411 + D.28403;
  D.28413 = *D.28412;
  if (D.28413 != 0) goto <D.28414>; else goto <D.28408>;
  <D.28414>:
  D.28407 = 3;
  return D.28407;
  <D.28408>:
  D.28407 = bank;
  return D.28407;
}


mono_spillvar_offset (struct MonoCompile * cfg, int spillvar, int bank)
{
  int D.28416;
  _Bool D.28417;
  long int D.28418;
  long int D.28419;
  struct MonoSpillInfo * D.28422;
  unsigned int spillvar.135;
  unsigned int D.28424;
  int D.28425;
  int D.28428;
  unsigned int D.28429;
  unsigned int D.28430;
  int D.28431;
  int D.28432;
  _Bool D.28433;
  long int D.28434;
  long int D.28435;
  _Bool D.28438;
  long int D.28439;
  long int D.28440;
  unsigned int D.28444;
  unsigned int D.28445;
  int D.28448;
  int D.28449;
  int D.28450;
  int D.28451;
  int D.28452;
  int D.28454;
  int D.28455;
  struct MonoSpillInfo * info;
  int size;

  D.28416 = cfg->spill_info_len[bank];
  D.28417 = D.28416 <= spillvar;
  D.28418 = (long int) D.28417;
  D.28419 = __builtin_expect (D.28418, 0);
  if (D.28419 != 0) goto <D.28420>; else goto <D.28421>;
  <D.28420>:
  goto <D.25749>;
  <D.25748>:
  resize_spill_info (cfg, bank);
  <D.25749>:
  D.28416 = cfg->spill_info_len[bank];
  if (D.28416 <= spillvar) goto <D.25748>; else goto <D.25750>;
  <D.25750>:
  <D.28421>:
  D.28422 = cfg->spill_info[bank];
  spillvar.135 = (unsigned int) spillvar;
  D.28424 = spillvar.135 * 4;
  info = D.28422 + D.28424;
  D.28425 = info->offset;
  if (D.28425 == -1) goto <D.28426>; else goto <D.28427>;
  <D.28426>:
  D.28428 = cfg->stack_offset;
  D.28429 = (unsigned int) D.28428;
  D.28430 = D.28429 + 3;
  D.28431 = (int) D.28430;
  cfg->stack_offset = D.28431;
  D.28428 = cfg->stack_offset;
  D.28432 = D.28428 & -4;
  cfg->stack_offset = D.28432;
  D.28433 = bank > 3;
  D.28434 = (long int) D.28433;
  D.28435 = __builtin_expect (D.28434, 0);
  if (D.28435 != 0) goto <D.28436>; else goto <D.28437>;
  <D.28436>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 329, "bank < MONO_NUM_REGBANKS");
  <D.28437>:
  D.28438 = bank != 0;
  D.28439 = (long int) D.28438;
  D.28440 = __builtin_expect (D.28439, 0);
  if (D.28440 != 0) goto <D.28441>; else goto <D.28442>;
  <D.28441>:
  size = regbank_spill_var_size[bank];
  goto <D.28443>;
  <D.28442>:
  size = 4;
  <D.28443>:
  D.28444 = cfg->flags;
  D.28445 = D.28444 & 64;
  if (D.28445 != 0) goto <D.28446>; else goto <D.28447>;
  <D.28446>:
  D.28428 = cfg->stack_offset;
  D.28448 = size + -1;
  D.28449 = D.28428 + D.28448;
  cfg->stack_offset = D.28449;
  D.28428 = cfg->stack_offset;
  D.28450 = -size;
  D.28451 = D.28428 & D.28450;
  cfg->stack_offset = D.28451;
  D.28428 = cfg->stack_offset;
  info->offset = D.28428;
  D.28428 = cfg->stack_offset;
  D.28452 = D.28428 + size;
  cfg->stack_offset = D.28452;
  goto <D.28453>;
  <D.28447>:
  D.28428 = cfg->stack_offset;
  D.28448 = size + -1;
  D.28449 = D.28428 + D.28448;
  cfg->stack_offset = D.28449;
  D.28428 = cfg->stack_offset;
  D.28450 = -size;
  D.28451 = D.28428 & D.28450;
  cfg->stack_offset = D.28451;
  D.28428 = cfg->stack_offset;
  D.28452 = D.28428 + size;
  cfg->stack_offset = D.28452;
  D.28428 = cfg->stack_offset;
  D.28454 = -D.28428;
  info->offset = D.28454;
  <D.28453>:
  <D.28427>:
  D.28455 = info->offset;
  return D.28455;
}


resize_spill_info (struct MonoCompile * cfg, int bank)
{
  int iftmp.136;
  _Bool D.28461;
  long int D.28462;
  long int D.28463;
  struct MonoMemPool * D.28466;
  unsigned int new_len.137;
  unsigned int D.28468;
  unsigned int orig_len.138;
  unsigned int D.28472;
  unsigned int i.139;
  unsigned int D.28474;
  struct MonoSpillInfo * D.28475;
  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.28458>; else goto <D.28459>;
  <D.28458>:
  iftmp.136 = orig_len * 2;
  goto <D.28460>;
  <D.28459>:
  iftmp.136 = 16;
  <D.28460>:
  new_len = iftmp.136;
  D.28461 = bank > 3;
  D.28462 = (long int) D.28461;
  D.28463 = __builtin_expect (D.28462, 0);
  if (D.28463 != 0) goto <D.28464>; else goto <D.28465>;
  <D.28464>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 294, "bank < MONO_NUM_REGBANKS");
  <D.28465>:
  D.28466 = cfg->mempool;
  new_len.137 = (unsigned int) new_len;
  D.28468 = new_len.137 * 4;
  new_info = mono_mempool_alloc0 (D.28466, D.28468);
  if (orig_info != 0B) goto <D.28469>; else goto <D.28470>;
  <D.28469>:
  orig_len.138 = (unsigned int) orig_len;
  D.28472 = orig_len.138 * 4;
  memcpy (new_info, orig_info, D.28472);
  <D.28470>:
  i = orig_len;
  goto <D.25739>;
  <D.25738>:
  i.139 = (unsigned int) i;
  D.28474 = i.139 * 4;
  D.28475 = new_info + D.28474;
  D.28475->offset = -1;
  i = i + 1;
  <D.25739>:
  if (i < new_len) goto <D.25738>; else goto <D.25740>;
  <D.25740>:
  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.28476;
  unsigned int D.28477;

  D.28477 = __builtin_object_size (__dest, 0);
  D.28476 = __builtin___memcpy_chk (__dest, __src, __len, D.28477);
  return D.28476;
}


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

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


mono_regstate_alloc_general (struct MonoRegState * rs, regmask_t allow, int bank)
{
  unsigned int D.28480;
  unsigned int D.28481;
  unsigned int D.28482;
  unsigned int D.28485;
  unsigned int D.28486;
  int D.28489;
  int D.28490;
  int i;
  int mirrored_bank;
  regmask_t mask;

  D.28480 = rs->free_mask[bank];
  mask = D.28480 & allow;
  i = 0;
  goto <D.25704>;
  <D.25703>:
  D.28481 = 1 << i;
  D.28482 = D.28481 & mask;
  if (D.28482 != 0) goto <D.28483>; else goto <D.28484>;
  <D.28483>:
  D.28480 = rs->free_mask[bank];
  D.28481 = 1 << i;
  D.28485 = ~D.28481;
  D.28486 = D.28480 & D.28485;
  rs->free_mask[bank] = D.28486;
  mirrored_bank = -1;
  if (mirrored_bank == -1) goto <D.28487>; else goto <D.28488>;
  <D.28487>:
  D.28489 = i;
  return D.28489;
  <D.28488>:
  D.28480 = rs->free_mask[bank];
  rs->free_mask[mirrored_bank] = D.28480;
  D.28489 = i;
  return D.28489;
  <D.28484>:
  i = i + 1;
  <D.25704>:
  D.28490 = regbank_size[bank];
  if (D.28490 > i) goto <D.25703>; else goto <D.25705>;
  <D.25705>:
  D.28489 = -1;
  return D.28489;
}


mono_regstate_free_general (struct MonoRegState * rs, int reg, int bank)
{
  unsigned int D.28494;
  unsigned int D.28495;
  unsigned int D.28496;
  int * D.28497;
  unsigned int reg.140;
  unsigned int D.28499;
  int * D.28500;
  int * D.28503;
  int * D.28504;
  int mirrored_bank;

  if (reg >= 0) goto <D.28492>; else goto <D.28493>;
  <D.28492>:
  D.28494 = rs->free_mask[bank];
  D.28495 = 1 << reg;
  D.28496 = D.28494 | D.28495;
  rs->free_mask[bank] = D.28496;
  D.28497 = rs->symbolic[bank];
  reg.140 = (unsigned int) reg;
  D.28499 = reg.140 * 4;
  D.28500 = D.28497 + D.28499;
  *D.28500 = 0;
  mirrored_bank = -1;
  if (mirrored_bank == -1) goto <D.28501>; else goto <D.28502>;
  <D.28501>:
  return;
  <D.28502>:
  D.28494 = rs->free_mask[bank];
  rs->free_mask[mirrored_bank] = D.28494;
  D.28503 = rs->symbolic[mirrored_bank];
  reg.140 = (unsigned int) reg;
  D.28499 = reg.140 * 4;
  D.28504 = D.28503 + D.28499;
  *D.28504 = 0;
  <D.28493>:
}


mono_regstate_free_int (struct MonoRegState * rs, int reg)
{
  unsigned int D.28508;
  unsigned int D.28509;
  unsigned int D.28510;

  if (reg >= 0) goto <D.28506>; else goto <D.28507>;
  <D.28506>:
  D.28508 = rs->ifree_mask;
  D.28509 = 1 << reg;
  D.28510 = D.28508 | D.28509;
  rs->ifree_mask = D.28510;
  rs->isymbolic[reg] = 0;
  <D.28507>:
}


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.28511;
  int D.28512;
  short unsigned int D.28513;
  int D.28514;
  int D.28515;
  const unsigned char * D.28516;
  unsigned int D.28519;
  _Bool D.28520;
  long int D.28521;
  long int D.28522;
  const char * D.28525;
  const char * D.28526;
  struct MonoInst * D.28527;
  struct MonoInst * copy;

  D.28511 = cfg->mempool;
  copy = mono_mempool_alloc0 (D.28511, 56);
  D.28512 = regbank_move_ops[bank];
  D.28513 = (short unsigned int) D.28512;
  copy->opcode = D.28513;
  copy->dreg = -1;
  copy->sreg3 = -1;
  D.28514 = copy->sreg3;
  copy->sreg2 = D.28514;
  D.28515 = copy->sreg2;
  copy->sreg1 = D.28515;
  D.28516 = cfg->ip;
  copy->cil_code = D.28516;
  copy->dreg = dest;
  copy->sreg1 = src;
  copy->cil_code = ip;
  if (ins != 0B) goto <D.28517>; else goto <D.28518>;
  <D.28517>:
  mono_bblock_insert_after_ins (bb, ins, copy);
  *last = copy;
  <D.28518>:
  D.28519 = cfg->verbose_level;
  D.28520 = D.28519 > 2;
  D.28521 = (long int) D.28520;
  D.28522 = __builtin_expect (D.28521, 0);
  if (D.28522 != 0) goto <D.28523>; else goto <D.28524>;
  <D.28523>:
  D.28525 = mono_regname_full (src, bank);
  D.28526 = mono_regname_full (dest, bank);
  printf ("\tforced copy from %s to %s\n", D.28525, D.28526);
  <D.28524>:
  D.28527 = copy;
  return D.28527;
}


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.28529;
  unsigned int reg.141;
  unsigned int D.28531;
  gint32 * D.28532;
  struct MonoRegState * D.28533;
  int D.28534;
  int D.28535;
  unsigned int i.142;
  unsigned int D.28537;
  gint32 * D.28538;
  int D.28539;
  _Bool D.28540;
  long int D.28541;
  long int D.28542;
  struct MonoMemPool * D.28546;
  int D.28547;
  short unsigned int D.28548;
  int D.28549;
  int D.28550;
  const unsigned char * D.28551;
  unsigned int D.28552;
  int D.28553;
  int D.28554;
  int D.28555;
  unsigned int D.28556;
  _Bool D.28557;
  long int D.28558;
  long int D.28559;
  int D.28562;
  const char * D.28563;
  unsigned int D.28566;
  _Bool D.28568;
  long int D.28569;
  long int D.28570;
  struct MonoInst * load;
  int i;
  int sel;
  int spill;
  int * symbolic;
  struct MonoRegState * rs;

  rs = cfg->rs;
  symbolic = rs->symbolic[bank];
  D.28529 = rs->vassign;
  reg.141 = (unsigned int) reg;
  D.28531 = reg.141 * 4;
  D.28532 = D.28529 + D.28531;
  sel = *D.28532;
  D.28533 = cfg->rs;
  bank = translate_bank (D.28533, bank, sel);
  i = reg;
  D.28534 = cfg->spill_count;
  D.28535 = D.28534 + 1;
  cfg->spill_count = D.28535;
  spill = cfg->spill_count;
  D.28529 = rs->vassign;
  i.142 = (unsigned int) i;
  D.28537 = i.142 * 4;
  D.28538 = D.28529 + D.28537;
  D.28539 = ~spill;
  *D.28538 = D.28539;
  D.28540 = bank != 0;
  D.28541 = (long int) D.28540;
  D.28542 = __builtin_expect (D.28541, 0);
  if (D.28542 != 0) goto <D.28543>; else goto <D.28544>;
  <D.28543>:
  mono_regstate_free_general (rs, sel, bank);
  goto <D.28545>;
  <D.28544>:
  mono_regstate_free_int (rs, sel);
  <D.28545>:
  D.28546 = cfg->mempool;
  load = mono_mempool_alloc0 (D.28546, 56);
  D.28547 = regbank_load_ops[bank];
  D.28548 = (short unsigned int) D.28547;
  load->opcode = D.28548;
  load->dreg = -1;
  load->sreg3 = -1;
  D.28549 = load->sreg3;
  load->sreg2 = D.28549;
  D.28550 = load->sreg2;
  load->sreg1 = D.28550;
  D.28551 = cfg->ip;
  load->cil_code = D.28551;
  load->dreg = sel;
  D.28552 = cfg->frame_reg;
  D.28553 = (int) D.28552;
  load->sreg1 = D.28553;
  D.28554 = get_vreg_bank (cfg, reg, bank);
  D.28555 = mono_spillvar_offset (cfg, spill, D.28554);
  load->data.op[0].const_val = D.28555;
  insert_after_ins (bb, ins, last, load);
  D.28556 = cfg->verbose_level;
  D.28557 = D.28556 > 2;
  D.28558 = (long int) D.28557;
  D.28559 = __builtin_expect (D.28558, 0);
  if (D.28559 != 0) goto <D.28560>; else goto <D.28561>;
  <D.28560>:
  D.28562 = load->data.op[0].const_val;
  D.28563 = mono_regname_full (sel, bank);
  printf ("SPILLED LOAD (%d at 0x%08lx(%%ebp)) R%d (freed %s)\n", spill, D.28562, i, D.28563);
  <D.28561>:
  D.28540 = bank != 0;
  D.28541 = (long int) D.28540;
  D.28542 = __builtin_expect (D.28541, 0);
  if (D.28542 != 0) goto <D.28564>; else goto <D.28565>;
  <D.28564>:
  D.28566 = 1 << sel;
  i = mono_regstate_alloc_general (rs, D.28566, bank);
  goto <D.28567>;
  <D.28565>:
  D.28566 = 1 << sel;
  i = mono_regstate_alloc_int (rs, D.28566);
  <D.28567>:
  D.28568 = i != sel;
  D.28569 = (long int) D.28568;
  D.28570 = __builtin_expect (D.28569, 0);
  if (D.28570 != 0) goto <D.28571>; else goto <D.28572>;
  <D.28571>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 807, "i == sel");
  <D.28572>:
  D.28540 = bank != 0;
  D.28541 = (long int) D.28540;
  D.28542 = __builtin_expect (D.28541, 0);
  if (D.28542 != 0) goto <D.28573>; else goto <D.28574>;
  <D.28573>:
  mono_regstate_free_general (rs, sel, bank);
  goto <D.28575>;
  <D.28574>:
  mono_regstate_free_int (rs, sel);
  <D.28575>:
}


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.28576;
  long int D.28577;
  long int D.28578;
  int D.28581;

  D.28576 = bank != 0;
  D.28577 = (long int) D.28576;
  D.28578 = __builtin_expect (D.28577, 0);
  if (D.28578 != 0) goto <D.28579>; else goto <D.28580>;
  <D.28579>:
  D.28581 = alloc_general_reg (cfg, bb, last, ins, dest_mask, sym_reg, bank);
  return D.28581;
  <D.28580>:
  D.28581 = alloc_int_reg (cfg, bb, last, ins, dest_mask, sym_reg, info);
  return D.28581;
}


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.28583;
  int D.28586;
  int val;

  D.28583 = cfg->rs;
  val = mono_regstate_alloc_general (D.28583, dest_mask, bank);
  if (val < 0) goto <D.28584>; else goto <D.28585>;
  <D.28584>:
  val = get_register_spilling (cfg, bb, last, ins, dest_mask, sym_reg, bank);
  <D.28585>:
  D.28586 = val;
  return D.28586;
}


assign_reg (struct MonoCompile * cfg, struct MonoRegState * rs, int reg, int hreg, int bank)
{
  _Bool D.28588;
  long int D.28589;
  long int D.28590;
  int D.28593;
  _Bool D.28594;
  long int D.28595;
  long int D.28596;
  _Bool D.28599;
  long int D.28600;
  long int D.28601;
  int iftmp.143;
  unsigned int hreg.144;
  unsigned int D.28609;
  unsigned int D.28610;
  _Bool D.28612;
  long int D.28613;
  long int D.28614;
  gint32 * D.28617;
  unsigned int reg.145;
  unsigned int D.28619;
  gint32 * D.28620;
  int * D.28621;
  unsigned int hreg.146;
  unsigned int D.28623;
  int * D.28624;
  unsigned int D.28625;
  unsigned int D.28626;
  unsigned int D.28627;
  unsigned int D.28628;
  int * D.28631;
  int * D.28632;
  _Bool D.28634;
  long int D.28635;
  long int D.28636;
  _Bool D.28639;
  long int D.28640;
  long int D.28641;
  unsigned int D.28644;
  unsigned int D.28645;

  D.28588 = bank != 0;
  D.28589 = (long int) D.28588;
  D.28590 = __builtin_expect (D.28589, 0);
  if (D.28590 != 0) goto <D.28591>; else goto <D.28592>;
  <D.28591>:
  {
    int mirrored_bank;

    D.28593 = regbank_size[bank];
    D.28594 = D.28593 > reg;
    D.28595 = (long int) D.28594;
    D.28596 = __builtin_expect (D.28595, 0);
    if (D.28596 != 0) goto <D.28597>; else goto <D.28598>;
    <D.28597>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1040, "reg >= regbank_size [bank]");
    <D.28598>:
    D.28593 = regbank_size[bank];
    D.28599 = D.28593 <= hreg;
    D.28600 = (long int) D.28599;
    D.28601 = __builtin_expect (D.28600, 0);
    if (D.28601 != 0) goto <D.28602>; else goto <D.28603>;
    <D.28602>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1041, "hreg < regbank_size [bank]");
    <D.28603>:
    hreg.144 = (unsigned int) hreg;
    if (hreg.144 <= 31) goto <D.28608>; else goto <D.28605>;
    <D.28608>:
    D.28609 = 1431633920 >> hreg;
    D.28610 = D.28609 & 1;
    if (D.28610 != 0) goto <D.28611>; else goto <D.28605>;
    <D.28611>:
    iftmp.143 = 1;
    goto <D.28606>;
    <D.28605>:
    iftmp.143 = 0;
    <D.28606>:
    D.28612 = iftmp.143 != 0;
    D.28613 = (long int) D.28612;
    D.28614 = __builtin_expect (D.28613, 0);
    if (D.28614 != 0) goto <D.28615>; else goto <D.28616>;
    <D.28615>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1042, "! is_global_freg (hreg)");
    <D.28616>:
    D.28617 = rs->vassign;
    reg.145 = (unsigned int) reg;
    D.28619 = reg.145 * 4;
    D.28620 = D.28617 + D.28619;
    *D.28620 = hreg;
    D.28621 = rs->symbolic[bank];
    hreg.146 = (unsigned int) hreg;
    D.28623 = hreg.146 * 4;
    D.28624 = D.28621 + D.28623;
    *D.28624 = reg;
    D.28625 = rs->free_mask[bank];
    D.28626 = 1 << hreg;
    D.28627 = ~D.28626;
    D.28628 = D.28625 & D.28627;
    rs->free_mask[bank] = D.28628;
    mirrored_bank = -1;
    if (mirrored_bank == -1) goto <D.28629>; else goto <D.28630>;
    <D.28629>:
    return;
    <D.28630>:
    D.28625 = rs->free_mask[bank];
    rs->free_mask[mirrored_bank] = D.28625;
    D.28631 = rs->symbolic[mirrored_bank];
    hreg.146 = (unsigned int) hreg;
    D.28623 = hreg.146 * 4;
    D.28632 = D.28631 + D.28623;
    *D.28632 = -2;
  }
  goto <D.28633>;
  <D.28592>:
  D.28634 = reg <= 15;
  D.28635 = (long int) D.28634;
  D.28636 = __builtin_expect (D.28635, 0);
  if (D.28636 != 0) goto <D.28637>; else goto <D.28638>;
  <D.28637>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1064, "reg >= MONO_MAX_IREGS");
  <D.28638>:
  D.28639 = hreg > 15;
  D.28640 = (long int) D.28639;
  D.28641 = __builtin_expect (D.28640, 0);
  if (D.28641 != 0) goto <D.28642>; else goto <D.28643>;
  <D.28642>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1065, "hreg < MONO_MAX_IREGS");
  <D.28643>:
  D.28617 = rs->vassign;
  reg.145 = (unsigned int) reg;
  D.28619 = reg.145 * 4;
  D.28620 = D.28617 + D.28619;
  *D.28620 = hreg;
  rs->isymbolic[hreg] = reg;
  D.28644 = rs->ifree_mask;
  D.28626 = 1 << hreg;
  D.28627 = ~D.28626;
  D.28645 = D.28644 & D.28627;
  rs->ifree_mask = D.28645;
  <D.28633>:
}


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.28647;
  int D.28648;
  short unsigned int D.28649;
  int D.28650;
  int D.28651;
  const unsigned char * D.28652;
  unsigned int D.28653;
  int D.28654;
  int D.28655;
  unsigned int D.28662;
  _Bool D.28663;
  long int D.28664;
  long int D.28665;
  const char * D.28668;
  int D.28669;
  const char * D.28670;
  unsigned int bank.147;
  unsigned int D.28672;
  unsigned char D.28675;
  unsigned char D.28676;
  _Bool D.28679;
  long int D.28680;
  long int D.28681;
  int D.28684;
  int D.28685;
  struct MonoInst * store;
  struct MonoInst * def;

  bank = get_vreg_bank (cfg, prev_reg, bank);
  D.28647 = cfg->mempool;
  store = mono_mempool_alloc0 (D.28647, 56);
  D.28648 = regbank_store_ops[bank];
  D.28649 = (short unsigned int) D.28648;
  store->opcode = D.28649;
  store->dreg = -1;
  store->sreg3 = -1;
  D.28650 = store->sreg3;
  store->sreg2 = D.28650;
  D.28651 = store->sreg2;
  store->sreg1 = D.28651;
  D.28652 = cfg->ip;
  store->cil_code = D.28652;
  store->sreg1 = reg;
  D.28653 = cfg->frame_reg;
  D.28654 = (int) D.28653;
  store->dreg = D.28654;
  D.28655 = mono_spillvar_offset (cfg, spill, bank);
  store->data.op[0].const_val = D.28655;
  if (ins != 0B) goto <D.28656>; else goto <D.28657>;
  <D.28656>:
  mono_bblock_insert_after_ins (bb, ins, store);
  *last = store;
  goto <D.28658>;
  <D.28657>:
  if (insert_before != 0B) goto <D.28659>; else goto <D.28660>;
  <D.28659>:
  insert_before_ins (bb, insert_before, store);
  goto <D.28661>;
  <D.28660>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-codegen.c", 972);
  <D.28661>:
  <D.28658>:
  D.28662 = cfg->verbose_level;
  D.28663 = D.28662 > 2;
  D.28664 = (long int) D.28663;
  D.28665 = __builtin_expect (D.28664, 0);
  if (D.28665 != 0) goto <D.28666>; else goto <D.28667>;
  <D.28666>:
  D.28668 = regbank_to_string (bank);
  D.28669 = store->data.op[0].const_val;
  D.28670 = mono_regname_full (reg, bank);
  printf ("\t%sSPILLED STORE (%d at 0x%08lx(%%ebp)) R%d (from %s)\n", D.28668, spill, D.28669, prev_reg, D.28670);
  <D.28667>:
  bank.147 = (unsigned int) bank;
  D.28672 = bank.147 + 4294967294;
  if (D.28672 <= 1) goto <D.28673>; else goto <D.28674>;
  <D.28673>:
  D.28675 = BIT_FIELD_REF <*cfg, 8, 3424>;
  D.28676 = D.28675 & 128;
  if (D.28676 != 0) goto <D.28677>; else goto <D.28678>;
  <D.28677>:
  D.28679 = prev_reg == -1;
  D.28680 = (long int) D.28679;
  D.28681 = __builtin_expect (D.28680, 0);
  if (D.28681 != 0) goto <D.28682>; else goto <D.28683>;
  <D.28682>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 977, "prev_reg != -1");
  <D.28683>:
  D.28647 = cfg->mempool;
  def = mono_mempool_alloc0 (D.28647, 56);
  def->opcode = 840;
  def->dreg = -1;
  def->sreg3 = -1;
  D.28684 = def->sreg3;
  def->sreg2 = D.28684;
  D.28685 = def->sreg2;
  def->sreg1 = D.28685;
  D.28652 = cfg->ip;
  def->cil_code = D.28652;
  def->data.op[0].const_val = spill;
  def->data.op[1].const_val = bank;
  mono_bblock_insert_after_ins (bb, store, def);
  <D.28678>:
  <D.28674>:
}


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

  if (bank == 2) goto <D.28686>; else goto <D.28687>;
  <D.28686>:
  D.28688 = "REF ";
  return D.28688;
  <D.28687>:
  if (bank == 3) goto <D.28689>; else goto <D.28690>;
  <D.28689>:
  D.28688 = "MP ";
  return D.28688;
  <D.28690>:
  D.28688 = "";
  return D.28688;
}


mono_opcode_to_cond (int opcode)
{
  CompRelation D.28692;
  const char * D.28693;

  switch (opcode) <default: <D.26313>, case 446: <D.26221>, case 447: <D.26266>, case 448: <D.26302>, case 449: <D.26255>, case 450: <D.26291>, case 451: <D.26228>, case 453: <D.26273>, case 455: <D.26262>, case 456: <D.26237>, case 458: <D.26309>, case 459: <D.26281>, case 460: <D.26298>, case 465: <D.26229>, case 467: <D.26274>, case 469: <D.26263>, case 470: <D.26238>, case 472: <D.26310>, case 473: <D.26282>, case 474: <D.26299>, case 531: <D.26225>, case 532: <D.26270>, case 533: <D.26306>, case 534: <D.26259>, case 535: <D.26295>, case 551: <D.26224>, case 552: <D.26251>, case 553: <D.26269>, case 554: <D.26244>, case 555: <D.26258>, case 556: <D.26235>, case 557: <D.26287>, case 558: <D.26305>, case 559: <D.26279>, case 560: <D.26294>, case 638: <D.26223>, case 639: <D.26268>, case 640: <D.26304>, case 641: <D.26257>, case 642: <D.26293>, case 643: <D.26233>, case 644: <D.26249>, case 645: <D.26242>, case 646: <D.26285>, case 647: <D.26277>, case 648: <D.26222>, case 649: <D.26250>, case 650: <D.26267>, case 651: <D.26243>, case 652: <D.26256>, case 653: <D.26234>, case 654: <D.26286>, case 655: <D.26303>, case 656: <D.26278>, case 657: <D.26292>, case 658: <D.26226>, case 659: <D.26252>, case 660: <D.26271>, case 661: <D.26245>, case 662: <D.26260>, case 663: <D.26236>, case 664: <D.26288>, case 665: <D.26308>, case 666: <D.26280>, case 667: <D.26296>, case 714: <D.26227>, case 715: <D.26272>, case 716: <D.26307>, case 717: <D.26261>, case 718: <D.26297>, case 719: <D.26232>, case 720: <D.26248>, case 721: <D.26241>, case 816: <D.26230>, case 817: <D.26253>, case 818: <D.26275>, case 819: <D.26246>, case 820: <D.26264>, case 821: <D.26239>, case 822: <D.26289>, case 823: <D.26311>, case 824: <D.26283>, case 825: <D.26300>, case 826: <D.26231>, case 827: <D.26254>, case 828: <D.26276>, case 829: <D.26247>, case 830: <D.26265>, case 831: <D.26240>, case 832: <D.26290>, case 833: <D.26312>, case 834: <D.26284>, case 835: <D.26301>>
  <D.26221>:
  <D.26222>:
  <D.26223>:
  <D.26224>:
  <D.26225>:
  <D.26226>:
  <D.26227>:
  <D.26228>:
  <D.26229>:
  <D.26230>:
  <D.26231>:
  D.28692 = 0;
  return D.28692;
  <D.26232>:
  <D.26233>:
  <D.26234>:
  <D.26235>:
  <D.26236>:
  <D.26237>:
  <D.26238>:
  <D.26239>:
  <D.26240>:
  D.28692 = 1;
  return D.28692;
  <D.26241>:
  <D.26242>:
  <D.26243>:
  <D.26244>:
  <D.26245>:
  <D.26246>:
  <D.26247>:
  D.28692 = 2;
  return D.28692;
  <D.26248>:
  <D.26249>:
  <D.26250>:
  <D.26251>:
  <D.26252>:
  <D.26253>:
  <D.26254>:
  D.28692 = 3;
  return D.28692;
  <D.26255>:
  <D.26256>:
  <D.26257>:
  <D.26258>:
  <D.26259>:
  <D.26260>:
  <D.26261>:
  <D.26262>:
  <D.26263>:
  <D.26264>:
  <D.26265>:
  D.28692 = 4;
  return D.28692;
  <D.26266>:
  <D.26267>:
  <D.26268>:
  <D.26269>:
  <D.26270>:
  <D.26271>:
  <D.26272>:
  <D.26273>:
  <D.26274>:
  <D.26275>:
  <D.26276>:
  D.28692 = 5;
  return D.28692;
  <D.26277>:
  <D.26278>:
  <D.26279>:
  <D.26280>:
  <D.26281>:
  <D.26282>:
  <D.26283>:
  <D.26284>:
  D.28692 = 6;
  return D.28692;
  <D.26285>:
  <D.26286>:
  <D.26287>:
  <D.26288>:
  <D.26289>:
  <D.26290>:
  D.28692 = 7;
  return D.28692;
  <D.26291>:
  <D.26292>:
  <D.26293>:
  <D.26294>:
  <D.26295>:
  <D.26296>:
  <D.26297>:
  <D.26298>:
  <D.26299>:
  <D.26300>:
  <D.26301>:
  D.28692 = 8;
  return D.28692;
  <D.26302>:
  <D.26303>:
  <D.26304>:
  <D.26305>:
  <D.26306>:
  <D.26307>:
  <D.26308>:
  <D.26309>:
  <D.26310>:
  <D.26311>:
  <D.26312>:
  D.28692 = 9;
  return D.28692;
  <D.26313>:
  D.28693 = mono_inst_name (opcode);
  printf ("%s\n", D.28693);
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-codegen.c", 2447);
  D.28692 = 0;
  return D.28692;
}


mono_negate_cond (CompRelation cond)
{
  CompRelation D.28695;

  switch (cond) <default: <D.26327>, case 0: <D.26317>, case 1: <D.26318>, case 2: <D.26319>, case 3: <D.26320>, case 4: <D.26321>, case 5: <D.26322>, case 6: <D.26323>, case 7: <D.26324>, case 8: <D.26325>, case 9: <D.26326>>
  <D.26317>:
  D.28695 = 1;
  return D.28695;
  <D.26318>:
  D.28695 = 0;
  return D.28695;
  <D.26319>:
  D.28695 = 5;
  return D.28695;
  <D.26320>:
  D.28695 = 4;
  return D.28695;
  <D.26321>:
  D.28695 = 3;
  return D.28695;
  <D.26322>:
  D.28695 = 2;
  return D.28695;
  <D.26323>:
  D.28695 = 9;
  return D.28695;
  <D.26324>:
  D.28695 = 8;
  return D.28695;
  <D.26325>:
  D.28695 = 7;
  return D.28695;
  <D.26326>:
  D.28695 = 6;
  return D.28695;
  <D.26327>:
  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.148;
  unsigned int D.28698;
  CompType D.28701;
  unsigned int D.28702;
  unsigned int D.28705;
  unsigned int D.28708;
  unsigned int D.28711;
  unsigned int D.28714;
  unsigned int D.28717;
  unsigned int D.28720;
  unsigned int D.28723;
  const char * D.28726;

  opcode.148 = (unsigned int) opcode;
  D.28698 = opcode.148 + 4294966850;
  if (D.28698 <= 4) goto <D.28699>; else goto <D.28700>;
  <D.28699>:
  D.28701 = 0;
  return D.28701;
  <D.28700>:
  opcode.148 = (unsigned int) opcode;
  D.28702 = opcode.148 + 4294966648;
  if (D.28702 <= 9) goto <D.28703>; else goto <D.28704>;
  <D.28703>:
  D.28701 = 1;
  return D.28701;
  <D.28704>:
  opcode.148 = (unsigned int) opcode;
  D.28705 = opcode.148 + 4294966658;
  if (D.28705 <= 4) goto <D.28706>; else goto <D.28707>;
  <D.28706>:
  D.28701 = 1;
  return D.28701;
  <D.28707>:
  opcode.148 = (unsigned int) opcode;
  D.28708 = opcode.148 + 4294966745;
  if (D.28708 <= 9) goto <D.28709>; else goto <D.28710>;
  <D.28709>:
  D.28701 = 0;
  return D.28701;
  <D.28710>:
  opcode.148 = (unsigned int) opcode;
  D.28711 = opcode.148 + 4294966765;
  if (D.28711 <= 4) goto <D.28712>; else goto <D.28713>;
  <D.28712>:
  D.28701 = 0;
  return D.28701;
  <D.28713>:
  opcode.148 = (unsigned int) opcode;
  D.28714 = opcode.148 + 4294966638;
  if (D.28714 <= 9) goto <D.28715>; else goto <D.28716>;
  <D.28715>:
  D.28701 = 2;
  return D.28701;
  <D.28716>:
  opcode.148 = (unsigned int) opcode;
  D.28717 = opcode.148 + 4294966582;
  if (D.28717 <= 4) goto <D.28718>; else goto <D.28719>;
  <D.28718>:
  D.28701 = 2;
  return D.28701;
  <D.28719>:
  opcode.148 = (unsigned int) opcode;
  D.28720 = opcode.148 + 4294966831;
  if (D.28720 <= 9) goto <D.28721>; else goto <D.28722>;
  <D.28721>:
  D.28701 = 1;
  return D.28701;
  <D.28722>:
  opcode.148 = (unsigned int) opcode;
  D.28723 = opcode.148 + 4294966845;
  if (D.28723 <= 9) goto <D.28724>; else goto <D.28725>;
  <D.28724>:
  switch (cmp_opcode) <default: <D.26334>, case 326: <D.26332>, case 327: <D.26333>>
  <D.26332>:
  <D.26333>:
  D.28701 = 1;
  return D.28701;
  <D.26334>:
  D.28701 = 0;
  return D.28701;
  <D.28725>:
  D.28726 = mono_inst_name (opcode);
  monoeg_g_log (0B, 4, "Unknown opcode \'%s\' in opcode_to_type", D.28726);
  <D.26335>:
  goto <D.26335>;
  D.28701 = 0;
  return D.28701;
}


mono_is_regsize_var (struct MonoType * t)
{
  unsigned char D.28728;
  unsigned char D.28729;
  gboolean D.28732;
  unsigned char D.28733;
  int D.28734;
  int D.28735;

  D.28728 = BIT_FIELD_REF <*t, 8, 56>;
  D.28729 = D.28728 & 64;
  if (D.28729 != 0) goto <D.28730>; else goto <D.28731>;
  <D.28730>:
  D.28732 = 1;
  return D.28732;
  <D.28731>:
  t = mono_type_get_underlying_type (t);
  D.28733 = t->type;
  D.28734 = (int) D.28733;
  switch (D.28734) <default: <D.26358>, case 2: <D.26339>, case 3: <D.26340>, case 4: <D.26341>, case 5: <D.26342>, case 6: <D.26343>, case 7: <D.26344>, case 8: <D.26345>, case 9: <D.26346>, case 14: <D.26352>, case 15: <D.26349>, case 17: <D.26357>, case 18: <D.26353>, case 20: <D.26355>, case 21: <D.26356>, case 24: <D.26347>, case 25: <D.26348>, case 27: <D.26350>, case 28: <D.26351>, case 29: <D.26354>>
  <D.26339>:
  <D.26340>:
  <D.26341>:
  <D.26342>:
  <D.26343>:
  <D.26344>:
  <D.26345>:
  <D.26346>:
  <D.26347>:
  <D.26348>:
  <D.26349>:
  <D.26350>:
  D.28732 = 1;
  return D.28732;
  <D.26351>:
  <D.26352>:
  <D.26353>:
  <D.26354>:
  <D.26355>:
  D.28732 = 1;
  return D.28732;
  <D.26356>:
  D.28735 = mono_type_generic_inst_is_valuetype (t);
  if (D.28735 == 0) goto <D.28736>; else goto <D.28737>;
  <D.28736>:
  D.28732 = 1;
  return D.28732;
  <D.28737>:
  D.28732 = 0;
  return D.28732;
  <D.26357>:
  D.28732 = 0;
  return D.28732;
  <D.26358>:
  D.28732 = 0;
  return D.28732;
}


mono_peephole_ins (struct MonoBasicBlock * bb, struct MonoInst * ins)
{
  short unsigned int D.28739;
  int D.28740;
  int D.28741;
  int D.28744;
  int D.28745;
  struct MonoInst * D.28749;
  struct MonoInst * D.28752;
  struct MonoInst * D.28755;
  struct MonoInst * D.28758;
  int D.28761;
  int D.28762;
  short unsigned int D.28765;
  int D.28775;
  int D.28778;
  int D.28779;
  int D.28782;
  short unsigned int D.28795;
  _Bool D.28796;
  _Bool D.28797;
  _Bool D.28798;
  guint16 iftmp.149;
  guint16 iftmp.150;
  struct MonoInst * last_ins;

  last_ins = ins->prev;
  D.28739 = ins->opcode;
  D.28740 = (int) D.28739;
  switch (D.28740) <default: <D.28876>, case 316: <D.26374>, case 388: <D.26366>, case 389: <D.26368>, case 390: <D.26369>, case 391: <D.26370>, case 392: <D.26371>, case 393: <D.26367>, case 424: <D.26372>, case 426: <D.26373>, case 431: <D.26364>>
  <D.26364>:
  D.28741 = ins->data.op[1].const_val;
  if (D.28741 == 1) goto <D.28742>; else goto <D.28743>;
  <D.28742>:
  D.28744 = ins->dreg;
  D.28745 = ins->sreg1;
  if (D.28744 != D.28745) goto <D.28746>; else goto <D.28747>;
  <D.28746>:
  ins->opcode = 424;
  goto <D.28748>;
  <D.28747>:
  D.28749 = ins->prev;
  if (D.28749 != 0B) goto <D.28750>; else goto <D.28751>;
  <D.28750>:
  D.28749 = ins->prev;
  D.28752 = ins->next;
  D.28749->next = D.28752;
  <D.28751>:
  D.28752 = ins->next;
  if (D.28752 != 0B) goto <D.28753>; else goto <D.28754>;
  <D.28753>:
  D.28752 = ins->next;
  D.28749 = ins->prev;
  D.28752->prev = D.28749;
  <D.28754>:
  D.28755 = bb->code;
  if (D.28755 == ins) goto <D.28756>; else goto <D.28757>;
  <D.28756>:
  D.28752 = ins->next;
  bb->code = D.28752;
  <D.28757>:
  D.28758 = bb->last_ins;
  if (D.28758 == ins) goto <D.28759>; else goto <D.28760>;
  <D.28759>:
  D.28749 = ins->prev;
  bb->last_ins = D.28749;
  <D.28760>:
  ins->opcode = 316;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.28761 = ins->sreg3;
  ins->sreg2 = D.28761;
  D.28762 = ins->sreg2;
  ins->sreg1 = D.28762;
  <D.28748>:
  <D.28743>:
  goto <D.26365>;
  <D.26366>:
  <D.26367>:
  if (last_ins != 0B) goto <D.28763>; else goto <D.28764>;
  <D.28763>:
  D.28765 = last_ins->opcode;
  if (D.28765 == 838) goto <D.28766>; else goto <D.28767>;
  <D.28766>:
  last_ins = last_ins->prev;
  <D.28767>:
  <D.28764>:
  if (last_ins != 0B) goto <D.28771>; else goto <D.28772>;
  <D.28771>:
  D.28739 = ins->opcode;
  if (D.28739 == 393) goto <D.28773>; else goto <D.28768>;
  <D.28773>:
  D.28765 = last_ins->opcode;
  if (D.28765 == 377) goto <D.28769>; else goto <D.28768>;
  <D.28768>:
  D.28739 = ins->opcode;
  if (D.28739 == 388) goto <D.28774>; else goto <D.28770>;
  <D.28774>:
  D.28765 = last_ins->opcode;
  if (D.28765 == 374) goto <D.28769>; else goto <D.28770>;
  <D.28769>:
  D.28745 = ins->sreg1;
  D.28775 = last_ins->dreg;
  if (D.28745 == D.28775) goto <D.28776>; else goto <D.28777>;
  <D.28776>:
  D.28778 = ins->data.op[0].const_val;
  D.28779 = last_ins->data.op[0].const_val;
  if (D.28778 == D.28779) goto <D.28780>; else goto <D.28781>;
  <D.28780>:
  D.28744 = ins->dreg;
  D.28782 = last_ins->sreg1;
  if (D.28744 == D.28782) goto <D.28783>; else goto <D.28784>;
  <D.28783>:
  D.28749 = ins->prev;
  if (D.28749 != 0B) goto <D.28785>; else goto <D.28786>;
  <D.28785>:
  D.28749 = ins->prev;
  D.28752 = ins->next;
  D.28749->next = D.28752;
  <D.28786>:
  D.28752 = ins->next;
  if (D.28752 != 0B) goto <D.28787>; else goto <D.28788>;
  <D.28787>:
  D.28752 = ins->next;
  D.28749 = ins->prev;
  D.28752->prev = D.28749;
  <D.28788>:
  D.28755 = bb->code;
  if (D.28755 == ins) goto <D.28789>; else goto <D.28790>;
  <D.28789>:
  D.28752 = ins->next;
  bb->code = D.28752;
  <D.28790>:
  D.28758 = bb->last_ins;
  if (D.28758 == ins) goto <D.28791>; else goto <D.28792>;
  <D.28791>:
  D.28749 = ins->prev;
  bb->last_ins = D.28749;
  <D.28792>:
  ins->opcode = 316;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.28761 = ins->sreg3;
  ins->sreg2 = D.28761;
  D.28762 = ins->sreg2;
  ins->sreg1 = D.28762;
  goto <D.26365>;
  <D.28784>:
  ins->opcode = 424;
  D.28782 = last_ins->sreg1;
  ins->sreg1 = D.28782;
  <D.28781>:
  <D.28777>:
  <D.28770>:
  <D.28772>:
  if (last_ins != 0B) goto <D.28793>; else goto <D.28794>;
  <D.28793>:
  D.28795 = last_ins->opcode;
  D.28796 = D.28795 == 393;
  D.28797 = D.28795 == 388;
  D.28798 = D.28796 | D.28797;
  if (D.28798 != 0) goto <D.28799>; else goto <D.28800>;
  <D.28799>:
  D.28745 = ins->sreg1;
  D.28775 = last_ins->dreg;
  if (D.28745 != D.28775) goto <D.28801>; else goto <D.28802>;
  <D.28801>:
  D.28745 = ins->sreg1;
  D.28782 = last_ins->sreg1;
  if (D.28745 == D.28782) goto <D.28803>; else goto <D.28804>;
  <D.28803>:
  D.28778 = ins->data.op[0].const_val;
  D.28779 = last_ins->data.op[0].const_val;
  if (D.28778 == D.28779) goto <D.28805>; else goto <D.28806>;
  <D.28805>:
  D.28744 = ins->dreg;
  D.28775 = last_ins->dreg;
  if (D.28744 == D.28775) goto <D.28807>; else goto <D.28808>;
  <D.28807>:
  D.28749 = ins->prev;
  if (D.28749 != 0B) goto <D.28809>; else goto <D.28810>;
  <D.28809>:
  D.28749 = ins->prev;
  D.28752 = ins->next;
  D.28749->next = D.28752;
  <D.28810>:
  D.28752 = ins->next;
  if (D.28752 != 0B) goto <D.28811>; else goto <D.28812>;
  <D.28811>:
  D.28752 = ins->next;
  D.28749 = ins->prev;
  D.28752->prev = D.28749;
  <D.28812>:
  D.28755 = bb->code;
  if (D.28755 == ins) goto <D.28813>; else goto <D.28814>;
  <D.28813>:
  D.28752 = ins->next;
  bb->code = D.28752;
  <D.28814>:
  D.28758 = bb->last_ins;
  if (D.28758 == ins) goto <D.28815>; else goto <D.28816>;
  <D.28815>:
  D.28749 = ins->prev;
  bb->last_ins = D.28749;
  <D.28816>:
  ins->opcode = 316;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.28761 = ins->sreg3;
  ins->sreg2 = D.28761;
  D.28762 = ins->sreg2;
  ins->sreg1 = D.28762;
  goto <D.28817>;
  <D.28808>:
  ins->opcode = 424;
  D.28775 = last_ins->dreg;
  ins->sreg1 = D.28775;
  <D.28817>:
  <D.28806>:
  <D.28804>:
  <D.28802>:
  <D.28800>:
  <D.28794>:
  goto <D.26365>;
  <D.26368>:
  <D.26369>:
  if (last_ins != 0B) goto <D.28818>; else goto <D.28819>;
  <D.28818>:
  D.28765 = last_ins->opcode;
  if (D.28765 == 375) goto <D.28820>; else goto <D.28821>;
  <D.28820>:
  D.28745 = ins->sreg1;
  D.28775 = last_ins->dreg;
  if (D.28745 == D.28775) goto <D.28822>; else goto <D.28823>;
  <D.28822>:
  D.28778 = ins->data.op[0].const_val;
  D.28779 = last_ins->data.op[0].const_val;
  if (D.28778 == D.28779) goto <D.28824>; else goto <D.28825>;
  <D.28824>:
  D.28739 = ins->opcode;
  if (D.28739 == 389) goto <D.28827>; else goto <D.28828>;
  <D.28827>:
  iftmp.149 = 580;
  goto <D.28829>;
  <D.28828>:
  iftmp.149 = 591;
  <D.28829>:
  ins->opcode = iftmp.149;
  D.28782 = last_ins->sreg1;
  ins->sreg1 = D.28782;
  <D.28825>:
  <D.28823>:
  <D.28821>:
  <D.28819>:
  goto <D.26365>;
  <D.26370>:
  <D.26371>:
  if (last_ins != 0B) goto <D.28830>; else goto <D.28831>;
  <D.28830>:
  D.28765 = last_ins->opcode;
  if (D.28765 == 376) goto <D.28832>; else goto <D.28833>;
  <D.28832>:
  D.28745 = ins->sreg1;
  D.28775 = last_ins->dreg;
  if (D.28745 == D.28775) goto <D.28834>; else goto <D.28835>;
  <D.28834>:
  D.28778 = ins->data.op[0].const_val;
  D.28779 = last_ins->data.op[0].const_val;
  if (D.28778 == D.28779) goto <D.28836>; else goto <D.28837>;
  <D.28836>:
  D.28739 = ins->opcode;
  if (D.28739 == 391) goto <D.28839>; else goto <D.28840>;
  <D.28839>:
  iftmp.150 = 581;
  goto <D.28841>;
  <D.28840>:
  iftmp.150 = 590;
  <D.28841>:
  ins->opcode = iftmp.150;
  D.28782 = last_ins->sreg1;
  ins->sreg1 = D.28782;
  <D.28837>:
  <D.28835>:
  <D.28833>:
  <D.28831>:
  goto <D.26365>;
  <D.26372>:
  <D.26373>:
  D.28744 = ins->dreg;
  D.28745 = ins->sreg1;
  if (D.28744 == D.28745) goto <D.28842>; else goto <D.28843>;
  <D.28842>:
  D.28749 = ins->prev;
  if (D.28749 != 0B) goto <D.28844>; else goto <D.28845>;
  <D.28844>:
  D.28749 = ins->prev;
  D.28752 = ins->next;
  D.28749->next = D.28752;
  <D.28845>:
  D.28752 = ins->next;
  if (D.28752 != 0B) goto <D.28846>; else goto <D.28847>;
  <D.28846>:
  D.28752 = ins->next;
  D.28749 = ins->prev;
  D.28752->prev = D.28749;
  <D.28847>:
  D.28755 = bb->code;
  if (D.28755 == ins) goto <D.28848>; else goto <D.28849>;
  <D.28848>:
  D.28752 = ins->next;
  bb->code = D.28752;
  <D.28849>:
  D.28758 = bb->last_ins;
  if (D.28758 == ins) goto <D.28850>; else goto <D.28851>;
  <D.28850>:
  D.28749 = ins->prev;
  bb->last_ins = D.28749;
  <D.28851>:
  ins->opcode = 316;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.28761 = ins->sreg3;
  ins->sreg2 = D.28761;
  D.28762 = ins->sreg2;
  ins->sreg1 = D.28762;
  goto <D.26365>;
  <D.28843>:
  if (last_ins != 0B) goto <D.28852>; else goto <D.28853>;
  <D.28852>:
  D.28765 = last_ins->opcode;
  D.28739 = ins->opcode;
  if (D.28765 == D.28739) goto <D.28854>; else goto <D.28855>;
  <D.28854>:
  D.28745 = ins->sreg1;
  D.28775 = last_ins->dreg;
  if (D.28745 == D.28775) goto <D.28856>; else goto <D.28857>;
  <D.28856>:
  D.28744 = ins->dreg;
  D.28782 = last_ins->sreg1;
  if (D.28744 == D.28782) goto <D.28858>; else goto <D.28859>;
  <D.28858>:
  D.28749 = ins->prev;
  if (D.28749 != 0B) goto <D.28860>; else goto <D.28861>;
  <D.28860>:
  D.28749 = ins->prev;
  D.28752 = ins->next;
  D.28749->next = D.28752;
  <D.28861>:
  D.28752 = ins->next;
  if (D.28752 != 0B) goto <D.28862>; else goto <D.28863>;
  <D.28862>:
  D.28752 = ins->next;
  D.28749 = ins->prev;
  D.28752->prev = D.28749;
  <D.28863>:
  D.28755 = bb->code;
  if (D.28755 == ins) goto <D.28864>; else goto <D.28865>;
  <D.28864>:
  D.28752 = ins->next;
  bb->code = D.28752;
  <D.28865>:
  D.28758 = bb->last_ins;
  if (D.28758 == ins) goto <D.28866>; else goto <D.28867>;
  <D.28866>:
  D.28749 = ins->prev;
  bb->last_ins = D.28749;
  <D.28867>:
  ins->opcode = 316;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.28761 = ins->sreg3;
  ins->sreg2 = D.28761;
  D.28762 = ins->sreg2;
  ins->sreg1 = D.28762;
  <D.28859>:
  <D.28857>:
  <D.28855>:
  <D.28853>:
  goto <D.26365>;
  <D.26374>:
  D.28749 = ins->prev;
  if (D.28749 != 0B) goto <D.28868>; else goto <D.28869>;
  <D.28868>:
  D.28749 = ins->prev;
  D.28752 = ins->next;
  D.28749->next = D.28752;
  <D.28869>:
  D.28752 = ins->next;
  if (D.28752 != 0B) goto <D.28870>; else goto <D.28871>;
  <D.28870>:
  D.28752 = ins->next;
  D.28749 = ins->prev;
  D.28752->prev = D.28749;
  <D.28871>:
  D.28755 = bb->code;
  if (D.28755 == ins) goto <D.28872>; else goto <D.28873>;
  <D.28872>:
  D.28752 = ins->next;
  bb->code = D.28752;
  <D.28873>:
  D.28758 = bb->last_ins;
  if (D.28758 == ins) goto <D.28874>; else goto <D.28875>;
  <D.28874>:
  D.28749 = ins->prev;
  bb->last_ins = D.28749;
  <D.28875>:
  ins->opcode = 316;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.28761 = ins->sreg3;
  ins->sreg2 = D.28761;
  D.28762 = ins->sreg2;
  ins->sreg1 = D.28762;
  goto <D.26365>;
  <D.28876>:
  <D.26365>:
}


mini_exception_id_by_name (const char * name)
{
  int D.26386;
  int iftmp.151;
  int D.26385;
  const char[25] * D.28880;
  unsigned char D.28881;
  int D.28882;
  unsigned char D.28883;
  int D.28884;
  _Bool D.28885;
  _Bool D.28886;
  _Bool D.28887;
  const unsigned char * D.28890;
  unsigned char D.28891;
  int D.28892;
  const unsigned char * D.28893;
  unsigned char D.28894;
  int D.28895;
  _Bool D.28896;
  _Bool D.28897;
  const unsigned char * D.28900;
  unsigned char D.28901;
  int D.28902;
  const unsigned char * D.28903;
  unsigned char D.28904;
  int D.28905;
  _Bool D.28906;
  _Bool D.28907;
  const unsigned char * D.28910;
  unsigned char D.28911;
  int D.28912;
  const unsigned char * D.28913;
  unsigned char D.28914;
  int D.28915;
  int D.28919;
  int D.26395;
  int iftmp.152;
  int D.26394;
  const char[18] * D.28923;
  unsigned char D.28924;
  int D.28925;
  unsigned char D.28926;
  int D.28927;
  _Bool D.28928;
  _Bool D.28929;
  _Bool D.28930;
  const unsigned char * D.28933;
  unsigned char D.28934;
  int D.28935;
  const unsigned char * D.28936;
  unsigned char D.28937;
  int D.28938;
  _Bool D.28939;
  _Bool D.28940;
  const unsigned char * D.28943;
  unsigned char D.28944;
  int D.28945;
  const unsigned char * D.28946;
  unsigned char D.28947;
  int D.28948;
  _Bool D.28949;
  _Bool D.28950;
  const unsigned char * D.28953;
  unsigned char D.28954;
  int D.28955;
  const unsigned char * D.28956;
  unsigned char D.28957;
  int D.28958;
  int D.26404;
  int iftmp.153;
  int D.26403;
  const char[20] * D.28965;
  unsigned char D.28966;
  int D.28967;
  unsigned char D.28968;
  int D.28969;
  _Bool D.28970;
  _Bool D.28971;
  _Bool D.28972;
  const unsigned char * D.28975;
  unsigned char D.28976;
  int D.28977;
  const unsigned char * D.28978;
  unsigned char D.28979;
  int D.28980;
  _Bool D.28981;
  _Bool D.28982;
  const unsigned char * D.28985;
  unsigned char D.28986;
  int D.28987;
  const unsigned char * D.28988;
  unsigned char D.28989;
  int D.28990;
  _Bool D.28991;
  _Bool D.28992;
  const unsigned char * D.28995;
  unsigned char D.28996;
  int D.28997;
  const unsigned char * D.28998;
  unsigned char D.28999;
  int D.29000;
  int D.26413;
  int iftmp.154;
  int D.26412;
  const char[22] * D.29007;
  unsigned char D.29008;
  int D.29009;
  unsigned char D.29010;
  int D.29011;
  _Bool D.29012;
  _Bool D.29013;
  _Bool D.29014;
  const unsigned char * D.29017;
  unsigned char D.29018;
  int D.29019;
  const unsigned char * D.29020;
  unsigned char D.29021;
  int D.29022;
  _Bool D.29023;
  _Bool D.29024;
  const unsigned char * D.29027;
  unsigned char D.29028;
  int D.29029;
  const unsigned char * D.29030;
  unsigned char D.29031;
  int D.29032;
  _Bool D.29033;
  _Bool D.29034;
  const unsigned char * D.29037;
  unsigned char D.29038;
  int D.29039;
  const unsigned char * D.29040;
  unsigned char D.29041;
  int D.29042;
  int D.26422;
  int iftmp.155;
  int D.26421;
  const char[21] * D.29049;
  unsigned char D.29050;
  int D.29051;
  unsigned char D.29052;
  int D.29053;
  _Bool D.29054;
  _Bool D.29055;
  _Bool D.29056;
  const unsigned char * D.29059;
  unsigned char D.29060;
  int D.29061;
  const unsigned char * D.29062;
  unsigned char D.29063;
  int D.29064;
  _Bool D.29065;
  _Bool D.29066;
  const unsigned char * D.29069;
  unsigned char D.29070;
  int D.29071;
  const unsigned char * D.29072;
  unsigned char D.29073;
  int D.29074;
  _Bool D.29075;
  _Bool D.29076;
  const unsigned char * D.29079;
  unsigned char D.29080;
  int D.29081;
  const unsigned char * D.29082;
  unsigned char D.29083;
  int D.29084;
  int D.26431;
  int iftmp.156;
  int D.26430;
  const char[23] * D.29091;
  unsigned char D.29092;
  int D.29093;
  unsigned char D.29094;
  int D.29095;
  _Bool D.29096;
  _Bool D.29097;
  _Bool D.29098;
  const unsigned char * D.29101;
  unsigned char D.29102;
  int D.29103;
  const unsigned char * D.29104;
  unsigned char D.29105;
  int D.29106;
  _Bool D.29107;
  _Bool D.29108;
  const unsigned char * D.29111;
  unsigned char D.29112;
  int D.29113;
  const unsigned char * D.29114;
  unsigned char D.29115;
  int D.29116;
  _Bool D.29117;
  _Bool D.29118;
  const unsigned char * D.29121;
  unsigned char D.29122;
  int D.29123;
  const unsigned char * D.29124;
  unsigned char D.29125;
  int D.29126;
  int D.26440;
  int iftmp.157;
  int D.26439;
  const char[27] * D.29133;
  unsigned char D.29134;
  int D.29135;
  unsigned char D.29136;
  int D.29137;
  _Bool D.29138;
  _Bool D.29139;
  _Bool D.29140;
  const unsigned char * D.29143;
  unsigned char D.29144;
  int D.29145;
  const unsigned char * D.29146;
  unsigned char D.29147;
  int D.29148;
  _Bool D.29149;
  _Bool D.29150;
  const unsigned char * D.29153;
  unsigned char D.29154;
  int D.29155;
  const unsigned char * D.29156;
  unsigned char D.29157;
  int D.29158;
  _Bool D.29159;
  _Bool D.29160;
  const unsigned char * D.29163;
  unsigned char D.29164;
  int D.29165;
  const unsigned char * D.29166;
  unsigned char D.29167;
  int D.29168;
  int D.26449;
  int iftmp.158;
  int D.26448;
  const char[18] * D.29175;
  unsigned char D.29176;
  int D.29177;
  unsigned char D.29178;
  int D.29179;
  _Bool D.29180;
  _Bool D.29181;
  _Bool D.29182;
  const unsigned char * D.29185;
  unsigned char D.29186;
  int D.29187;
  const unsigned char * D.29188;
  unsigned char D.29189;
  int D.29190;
  _Bool D.29191;
  _Bool D.29192;
  const unsigned char * D.29195;
  unsigned char D.29196;
  int D.29197;
  const unsigned char * D.29198;
  unsigned char D.29199;
  int D.29200;
  _Bool D.29201;
  _Bool D.29202;
  const unsigned char * D.29205;
  unsigned char D.29206;
  int D.29207;
  const unsigned char * D.29208;
  unsigned char D.29209;
  int D.29210;

  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.28880 = "IndexOutOfRangeException";
      D.28881 = MEM[(const unsigned char *)D.28880];
      D.28882 = (int) D.28881;
      D.28883 = *__s2;
      D.28884 = (int) D.28883;
      __result = D.28882 - D.28884;
      {
        D.28885 = __s2_len != 0;
        D.28886 = __result == 0;
        D.28887 = D.28885 & D.28886;
        if (D.28887 != 0) goto <D.28888>; else goto <D.28889>;
        <D.28888>:
        D.28890 = &MEM[(void *)"IndexOutOfRangeException" + 1B];
        D.28891 = *D.28890;
        D.28892 = (int) D.28891;
        D.28893 = __s2 + 1;
        D.28894 = *D.28893;
        D.28895 = (int) D.28894;
        __result = D.28892 - D.28895;
        D.28896 = __s2_len > 1;
        D.28886 = __result == 0;
        D.28897 = D.28896 & D.28886;
        if (D.28897 != 0) goto <D.28898>; else goto <D.28899>;
        <D.28898>:
        D.28900 = &MEM[(void *)"IndexOutOfRangeException" + 2B];
        D.28901 = *D.28900;
        D.28902 = (int) D.28901;
        D.28903 = __s2 + 2;
        D.28904 = *D.28903;
        D.28905 = (int) D.28904;
        __result = D.28902 - D.28905;
        D.28906 = __s2_len > 2;
        D.28886 = __result == 0;
        D.28907 = D.28906 & D.28886;
        if (D.28907 != 0) goto <D.28908>; else goto <D.28909>;
        <D.28908>:
        D.28910 = &MEM[(void *)"IndexOutOfRangeException" + 3B];
        D.28911 = *D.28910;
        D.28912 = (int) D.28911;
        D.28913 = __s2 + 3;
        D.28914 = *D.28913;
        D.28915 = (int) D.28914;
        __result = D.28912 - D.28915;
        <D.28909>:
        <D.28899>:
        <D.28889>:
      }
      D.26385 = __result;
    }
    iftmp.151 = -D.26385;
    goto <D.28916>;
    <D.28879>:
    iftmp.151 = __builtin_strcmp (name, "IndexOutOfRangeException");
    <D.28916>:
    D.26386 = iftmp.151;
  }
  if (D.26386 == 0) goto <D.28917>; else goto <D.28918>;
  <D.28917>:
  D.28919 = 0;
  return D.28919;
  <D.28918>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.28923 = "OverflowException";
      D.28924 = MEM[(const unsigned char *)D.28923];
      D.28925 = (int) D.28924;
      D.28926 = *__s2;
      D.28927 = (int) D.28926;
      __result = D.28925 - D.28927;
      {
        D.28928 = __s2_len != 0;
        D.28929 = __result == 0;
        D.28930 = D.28928 & D.28929;
        if (D.28930 != 0) goto <D.28931>; else goto <D.28932>;
        <D.28931>:
        D.28933 = &MEM[(void *)"OverflowException" + 1B];
        D.28934 = *D.28933;
        D.28935 = (int) D.28934;
        D.28936 = __s2 + 1;
        D.28937 = *D.28936;
        D.28938 = (int) D.28937;
        __result = D.28935 - D.28938;
        D.28939 = __s2_len > 1;
        D.28929 = __result == 0;
        D.28940 = D.28939 & D.28929;
        if (D.28940 != 0) goto <D.28941>; else goto <D.28942>;
        <D.28941>:
        D.28943 = &MEM[(void *)"OverflowException" + 2B];
        D.28944 = *D.28943;
        D.28945 = (int) D.28944;
        D.28946 = __s2 + 2;
        D.28947 = *D.28946;
        D.28948 = (int) D.28947;
        __result = D.28945 - D.28948;
        D.28949 = __s2_len > 2;
        D.28929 = __result == 0;
        D.28950 = D.28949 & D.28929;
        if (D.28950 != 0) goto <D.28951>; else goto <D.28952>;
        <D.28951>:
        D.28953 = &MEM[(void *)"OverflowException" + 3B];
        D.28954 = *D.28953;
        D.28955 = (int) D.28954;
        D.28956 = __s2 + 3;
        D.28957 = *D.28956;
        D.28958 = (int) D.28957;
        __result = D.28955 - D.28958;
        <D.28952>:
        <D.28942>:
        <D.28932>:
      }
      D.26394 = __result;
    }
    iftmp.152 = -D.26394;
    goto <D.28959>;
    <D.28922>:
    iftmp.152 = __builtin_strcmp (name, "OverflowException");
    <D.28959>:
    D.26395 = iftmp.152;
  }
  if (D.26395 == 0) goto <D.28960>; else goto <D.28961>;
  <D.28960>:
  D.28919 = 1;
  return D.28919;
  <D.28961>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.28965 = "ArithmeticException";
      D.28966 = MEM[(const unsigned char *)D.28965];
      D.28967 = (int) D.28966;
      D.28968 = *__s2;
      D.28969 = (int) D.28968;
      __result = D.28967 - D.28969;
      {
        D.28970 = __s2_len != 0;
        D.28971 = __result == 0;
        D.28972 = D.28970 & D.28971;
        if (D.28972 != 0) goto <D.28973>; else goto <D.28974>;
        <D.28973>:
        D.28975 = &MEM[(void *)"ArithmeticException" + 1B];
        D.28976 = *D.28975;
        D.28977 = (int) D.28976;
        D.28978 = __s2 + 1;
        D.28979 = *D.28978;
        D.28980 = (int) D.28979;
        __result = D.28977 - D.28980;
        D.28981 = __s2_len > 1;
        D.28971 = __result == 0;
        D.28982 = D.28981 & D.28971;
        if (D.28982 != 0) goto <D.28983>; else goto <D.28984>;
        <D.28983>:
        D.28985 = &MEM[(void *)"ArithmeticException" + 2B];
        D.28986 = *D.28985;
        D.28987 = (int) D.28986;
        D.28988 = __s2 + 2;
        D.28989 = *D.28988;
        D.28990 = (int) D.28989;
        __result = D.28987 - D.28990;
        D.28991 = __s2_len > 2;
        D.28971 = __result == 0;
        D.28992 = D.28991 & D.28971;
        if (D.28992 != 0) goto <D.28993>; else goto <D.28994>;
        <D.28993>:
        D.28995 = &MEM[(void *)"ArithmeticException" + 3B];
        D.28996 = *D.28995;
        D.28997 = (int) D.28996;
        D.28998 = __s2 + 3;
        D.28999 = *D.28998;
        D.29000 = (int) D.28999;
        __result = D.28997 - D.29000;
        <D.28994>:
        <D.28984>:
        <D.28974>:
      }
      D.26403 = __result;
    }
    iftmp.153 = -D.26403;
    goto <D.29001>;
    <D.28964>:
    iftmp.153 = __builtin_strcmp (name, "ArithmeticException");
    <D.29001>:
    D.26404 = iftmp.153;
  }
  if (D.26404 == 0) goto <D.29002>; else goto <D.29003>;
  <D.29002>:
  D.28919 = 2;
  return D.28919;
  <D.29003>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.29007 = "DivideByZeroException";
      D.29008 = MEM[(const unsigned char *)D.29007];
      D.29009 = (int) D.29008;
      D.29010 = *__s2;
      D.29011 = (int) D.29010;
      __result = D.29009 - D.29011;
      {
        D.29012 = __s2_len != 0;
        D.29013 = __result == 0;
        D.29014 = D.29012 & D.29013;
        if (D.29014 != 0) goto <D.29015>; else goto <D.29016>;
        <D.29015>:
        D.29017 = &MEM[(void *)"DivideByZeroException" + 1B];
        D.29018 = *D.29017;
        D.29019 = (int) D.29018;
        D.29020 = __s2 + 1;
        D.29021 = *D.29020;
        D.29022 = (int) D.29021;
        __result = D.29019 - D.29022;
        D.29023 = __s2_len > 1;
        D.29013 = __result == 0;
        D.29024 = D.29023 & D.29013;
        if (D.29024 != 0) goto <D.29025>; else goto <D.29026>;
        <D.29025>:
        D.29027 = &MEM[(void *)"DivideByZeroException" + 2B];
        D.29028 = *D.29027;
        D.29029 = (int) D.29028;
        D.29030 = __s2 + 2;
        D.29031 = *D.29030;
        D.29032 = (int) D.29031;
        __result = D.29029 - D.29032;
        D.29033 = __s2_len > 2;
        D.29013 = __result == 0;
        D.29034 = D.29033 & D.29013;
        if (D.29034 != 0) goto <D.29035>; else goto <D.29036>;
        <D.29035>:
        D.29037 = &MEM[(void *)"DivideByZeroException" + 3B];
        D.29038 = *D.29037;
        D.29039 = (int) D.29038;
        D.29040 = __s2 + 3;
        D.29041 = *D.29040;
        D.29042 = (int) D.29041;
        __result = D.29039 - D.29042;
        <D.29036>:
        <D.29026>:
        <D.29016>:
      }
      D.26412 = __result;
    }
    iftmp.154 = -D.26412;
    goto <D.29043>;
    <D.29006>:
    iftmp.154 = __builtin_strcmp (name, "DivideByZeroException");
    <D.29043>:
    D.26413 = iftmp.154;
  }
  if (D.26413 == 0) goto <D.29044>; else goto <D.29045>;
  <D.29044>:
  D.28919 = 3;
  return D.28919;
  <D.29045>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.29049 = "InvalidCastException";
      D.29050 = MEM[(const unsigned char *)D.29049];
      D.29051 = (int) D.29050;
      D.29052 = *__s2;
      D.29053 = (int) D.29052;
      __result = D.29051 - D.29053;
      {
        D.29054 = __s2_len != 0;
        D.29055 = __result == 0;
        D.29056 = D.29054 & D.29055;
        if (D.29056 != 0) goto <D.29057>; else goto <D.29058>;
        <D.29057>:
        D.29059 = &MEM[(void *)"InvalidCastException" + 1B];
        D.29060 = *D.29059;
        D.29061 = (int) D.29060;
        D.29062 = __s2 + 1;
        D.29063 = *D.29062;
        D.29064 = (int) D.29063;
        __result = D.29061 - D.29064;
        D.29065 = __s2_len > 1;
        D.29055 = __result == 0;
        D.29066 = D.29065 & D.29055;
        if (D.29066 != 0) goto <D.29067>; else goto <D.29068>;
        <D.29067>:
        D.29069 = &MEM[(void *)"InvalidCastException" + 2B];
        D.29070 = *D.29069;
        D.29071 = (int) D.29070;
        D.29072 = __s2 + 2;
        D.29073 = *D.29072;
        D.29074 = (int) D.29073;
        __result = D.29071 - D.29074;
        D.29075 = __s2_len > 2;
        D.29055 = __result == 0;
        D.29076 = D.29075 & D.29055;
        if (D.29076 != 0) goto <D.29077>; else goto <D.29078>;
        <D.29077>:
        D.29079 = &MEM[(void *)"InvalidCastException" + 3B];
        D.29080 = *D.29079;
        D.29081 = (int) D.29080;
        D.29082 = __s2 + 3;
        D.29083 = *D.29082;
        D.29084 = (int) D.29083;
        __result = D.29081 - D.29084;
        <D.29078>:
        <D.29068>:
        <D.29058>:
      }
      D.26421 = __result;
    }
    iftmp.155 = -D.26421;
    goto <D.29085>;
    <D.29048>:
    iftmp.155 = __builtin_strcmp (name, "InvalidCastException");
    <D.29085>:
    D.26422 = iftmp.155;
  }
  if (D.26422 == 0) goto <D.29086>; else goto <D.29087>;
  <D.29086>:
  D.28919 = 4;
  return D.28919;
  <D.29087>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.29091 = "NullReferenceException";
      D.29092 = MEM[(const unsigned char *)D.29091];
      D.29093 = (int) D.29092;
      D.29094 = *__s2;
      D.29095 = (int) D.29094;
      __result = D.29093 - D.29095;
      {
        D.29096 = __s2_len != 0;
        D.29097 = __result == 0;
        D.29098 = D.29096 & D.29097;
        if (D.29098 != 0) goto <D.29099>; else goto <D.29100>;
        <D.29099>:
        D.29101 = &MEM[(void *)"NullReferenceException" + 1B];
        D.29102 = *D.29101;
        D.29103 = (int) D.29102;
        D.29104 = __s2 + 1;
        D.29105 = *D.29104;
        D.29106 = (int) D.29105;
        __result = D.29103 - D.29106;
        D.29107 = __s2_len > 1;
        D.29097 = __result == 0;
        D.29108 = D.29107 & D.29097;
        if (D.29108 != 0) goto <D.29109>; else goto <D.29110>;
        <D.29109>:
        D.29111 = &MEM[(void *)"NullReferenceException" + 2B];
        D.29112 = *D.29111;
        D.29113 = (int) D.29112;
        D.29114 = __s2 + 2;
        D.29115 = *D.29114;
        D.29116 = (int) D.29115;
        __result = D.29113 - D.29116;
        D.29117 = __s2_len > 2;
        D.29097 = __result == 0;
        D.29118 = D.29117 & D.29097;
        if (D.29118 != 0) goto <D.29119>; else goto <D.29120>;
        <D.29119>:
        D.29121 = &MEM[(void *)"NullReferenceException" + 3B];
        D.29122 = *D.29121;
        D.29123 = (int) D.29122;
        D.29124 = __s2 + 3;
        D.29125 = *D.29124;
        D.29126 = (int) D.29125;
        __result = D.29123 - D.29126;
        <D.29120>:
        <D.29110>:
        <D.29100>:
      }
      D.26430 = __result;
    }
    iftmp.156 = -D.26430;
    goto <D.29127>;
    <D.29090>:
    iftmp.156 = __builtin_strcmp (name, "NullReferenceException");
    <D.29127>:
    D.26431 = iftmp.156;
  }
  if (D.26431 == 0) goto <D.29128>; else goto <D.29129>;
  <D.29128>:
  D.28919 = 5;
  return D.28919;
  <D.29129>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.29133 = "ArrayTypeMismatchException";
      D.29134 = MEM[(const unsigned char *)D.29133];
      D.29135 = (int) D.29134;
      D.29136 = *__s2;
      D.29137 = (int) D.29136;
      __result = D.29135 - D.29137;
      {
        D.29138 = __s2_len != 0;
        D.29139 = __result == 0;
        D.29140 = D.29138 & D.29139;
        if (D.29140 != 0) goto <D.29141>; else goto <D.29142>;
        <D.29141>:
        D.29143 = &MEM[(void *)"ArrayTypeMismatchException" + 1B];
        D.29144 = *D.29143;
        D.29145 = (int) D.29144;
        D.29146 = __s2 + 1;
        D.29147 = *D.29146;
        D.29148 = (int) D.29147;
        __result = D.29145 - D.29148;
        D.29149 = __s2_len > 1;
        D.29139 = __result == 0;
        D.29150 = D.29149 & D.29139;
        if (D.29150 != 0) goto <D.29151>; else goto <D.29152>;
        <D.29151>:
        D.29153 = &MEM[(void *)"ArrayTypeMismatchException" + 2B];
        D.29154 = *D.29153;
        D.29155 = (int) D.29154;
        D.29156 = __s2 + 2;
        D.29157 = *D.29156;
        D.29158 = (int) D.29157;
        __result = D.29155 - D.29158;
        D.29159 = __s2_len > 2;
        D.29139 = __result == 0;
        D.29160 = D.29159 & D.29139;
        if (D.29160 != 0) goto <D.29161>; else goto <D.29162>;
        <D.29161>:
        D.29163 = &MEM[(void *)"ArrayTypeMismatchException" + 3B];
        D.29164 = *D.29163;
        D.29165 = (int) D.29164;
        D.29166 = __s2 + 3;
        D.29167 = *D.29166;
        D.29168 = (int) D.29167;
        __result = D.29165 - D.29168;
        <D.29162>:
        <D.29152>:
        <D.29142>:
      }
      D.26439 = __result;
    }
    iftmp.157 = -D.26439;
    goto <D.29169>;
    <D.29132>:
    iftmp.157 = __builtin_strcmp (name, "ArrayTypeMismatchException");
    <D.29169>:
    D.26440 = iftmp.157;
  }
  if (D.26440 == 0) goto <D.29170>; else goto <D.29171>;
  <D.29170>:
  D.28919 = 6;
  return D.28919;
  <D.29171>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.29175 = "ArgumentException";
      D.29176 = MEM[(const unsigned char *)D.29175];
      D.29177 = (int) D.29176;
      D.29178 = *__s2;
      D.29179 = (int) D.29178;
      __result = D.29177 - D.29179;
      {
        D.29180 = __s2_len != 0;
        D.29181 = __result == 0;
        D.29182 = D.29180 & D.29181;
        if (D.29182 != 0) goto <D.29183>; else goto <D.29184>;
        <D.29183>:
        D.29185 = &MEM[(void *)"ArgumentException" + 1B];
        D.29186 = *D.29185;
        D.29187 = (int) D.29186;
        D.29188 = __s2 + 1;
        D.29189 = *D.29188;
        D.29190 = (int) D.29189;
        __result = D.29187 - D.29190;
        D.29191 = __s2_len > 1;
        D.29181 = __result == 0;
        D.29192 = D.29191 & D.29181;
        if (D.29192 != 0) goto <D.29193>; else goto <D.29194>;
        <D.29193>:
        D.29195 = &MEM[(void *)"ArgumentException" + 2B];
        D.29196 = *D.29195;
        D.29197 = (int) D.29196;
        D.29198 = __s2 + 2;
        D.29199 = *D.29198;
        D.29200 = (int) D.29199;
        __result = D.29197 - D.29200;
        D.29201 = __s2_len > 2;
        D.29181 = __result == 0;
        D.29202 = D.29201 & D.29181;
        if (D.29202 != 0) goto <D.29203>; else goto <D.29204>;
        <D.29203>:
        D.29205 = &MEM[(void *)"ArgumentException" + 3B];
        D.29206 = *D.29205;
        D.29207 = (int) D.29206;
        D.29208 = __s2 + 3;
        D.29209 = *D.29208;
        D.29210 = (int) D.29209;
        __result = D.29207 - D.29210;
        <D.29204>:
        <D.29194>:
        <D.29184>:
      }
      D.26448 = __result;
    }
    iftmp.158 = -D.26448;
    goto <D.29211>;
    <D.29174>:
    iftmp.158 = __builtin_strcmp (name, "ArgumentException");
    <D.29211>:
    D.26449 = iftmp.158;
  }
  if (D.26449 == 0) goto <D.29212>; else goto <D.29213>;
  <D.29212>:
  D.28919 = 7;
  return D.28919;
  <D.29213>:
  monoeg_g_log (0B, 4, "Unknown intrinsic exception %s\n", name);
  <D.26450>:
  goto <D.26450>;
  D.28919 = -1;
  return D.28919;
}