__attribute__((visibility ("hidden")))
mono_regname_full (int reg, int bank)
{
  _Bool D.24245;
  long int D.24246;
  long int D.24247;
  unsigned int bank.0;
  unsigned int D.24251;
  const char * D.24254;
  _Bool D.24255;
  long int D.24256;
  long int D.24257;

  D.24245 = bank != 0;
  D.24246 = (long int) D.24245;
  D.24247 = __builtin_expect (D.24246, 0);
  if (D.24247 != 0) goto <D.24248>; else goto <D.24249>;
  <D.24248>:
  bank.0 = (unsigned int) bank;
  D.24251 = bank.0 + 4294967294;
  if (D.24251 <= 1) goto <D.24252>; else goto <D.24253>;
  <D.24252>:
  D.24254 = mono_arch_regname (reg);
  return D.24254;
  <D.24253>:
  D.24255 = bank != 1;
  D.24256 = (long int) D.24255;
  D.24257 = __builtin_expect (D.24256, 0);
  if (D.24257 != 0) goto <D.24258>; else goto <D.24259>;
  <D.24258>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 248, "bank == MONO_REG_DOUBLE");
  <D.24259>:
  D.24254 = mono_arch_fregname (reg);
  return D.24254;
  <D.24249>:
  D.24254 = mono_arch_regname (reg);
  return D.24254;
}


__attribute__((visibility ("hidden")))
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.24262;
  unsigned int vreg.2;
  _Bool D.24264;
  long int D.24265;
  long int D.24266;
  int D.24269;
  _Bool D.24270;
  long int D.24271;
  long int D.24272;
  _Bool D.24275;
  long int D.24276;
  long int D.24277;
  long unsigned int D.24280;
  int D.24281;
  long unsigned int D.24282;
  long unsigned int D.24283;
  struct MonoMemPool * D.24284;
  struct GSList * D.24285;
  long int D.24286;
  void * D.24287;
  struct GSList * D.24288;
  _Bool D.24290;
  long int D.24291;
  long int D.24292;
  _Bool D.24295;
  long int D.24296;
  long int D.24297;
  long unsigned int D.24300;
  long unsigned int D.24301;
  struct GSList * D.24302;
  struct GSList * D.24303;
  guint32 regpair;

  hreg.1 = (unsigned int) hreg;
  D.24262 = hreg.1 << 24;
  vreg.2 = (unsigned int) vreg;
  regpair = D.24262 + vreg.2;
  D.24264 = bank != 0;
  D.24265 = (long int) D.24264;
  D.24266 = __builtin_expect (D.24265, 0);
  if (D.24266 != 0) goto <D.24267>; else goto <D.24268>;
  <D.24267>:
  D.24269 = regbank_size[bank];
  D.24270 = D.24269 > vreg;
  D.24271 = (long int) D.24270;
  D.24272 = __builtin_expect (D.24271, 0);
  if (D.24272 != 0) goto <D.24273>; else goto <D.24274>;
  <D.24273>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 262, "vreg >= regbank_size [bank]");
  <D.24274>:
  D.24269 = regbank_size[bank];
  D.24275 = D.24269 <= hreg;
  D.24276 = (long int) D.24275;
  D.24277 = __builtin_expect (D.24276, 0);
  if (D.24277 != 0) goto <D.24278>; else goto <D.24279>;
  <D.24278>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 263, "hreg < regbank_size [bank]");
  <D.24279>:
  D.24280 = call->used_fregs;
  D.24281 = 1 << hreg;
  D.24282 = (long unsigned int) D.24281;
  D.24283 = D.24280 | D.24282;
  call->used_fregs = D.24283;
  D.24284 = cfg->mempool;
  D.24285 = call->out_freg_args;
  D.24286 = (long int) regpair;
  D.24287 = (void *) D.24286;
  D.24288 = g_slist_append_mempool (D.24284, D.24285, D.24287);
  call->out_freg_args = D.24288;
  goto <D.24289>;
  <D.24268>:
  D.24290 = vreg <= 15;
  D.24291 = (long int) D.24290;
  D.24292 = __builtin_expect (D.24291, 0);
  if (D.24292 != 0) goto <D.24293>; else goto <D.24294>;
  <D.24293>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 267, "vreg >= MONO_MAX_IREGS");
  <D.24294>:
  D.24295 = hreg > 15;
  D.24296 = (long int) D.24295;
  D.24297 = __builtin_expect (D.24296, 0);
  if (D.24297 != 0) goto <D.24298>; else goto <D.24299>;
  <D.24298>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 268, "hreg < MONO_MAX_IREGS");
  <D.24299>:
  D.24300 = call->used_iregs;
  D.24281 = 1 << hreg;
  D.24282 = (long unsigned int) D.24281;
  D.24301 = D.24300 | D.24282;
  call->used_iregs = D.24301;
  D.24284 = cfg->mempool;
  D.24302 = call->out_ireg_args;
  D.24286 = (long int) regpair;
  D.24287 = (void *) D.24286;
  D.24303 = g_slist_append_mempool (D.24284, D.24302, D.24287);
  call->out_ireg_args = D.24303;
  <D.24289>:
}


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

  new_list = mono_mempool_alloc (mp, 16);
  new_list->data = data;
  new_list->next = 0B;
  if (list != 0B) goto <D.24304>; else goto <D.24305>;
  <D.24304>:
  last = list;
  goto <D.9043>;
  <D.9042>:
  last = last->next;
  <D.9043>:
  D.24306 = last->next;
  if (D.24306 != 0B) goto <D.9042>; else goto <D.9044>;
  <D.9044>:
  last->next = new_list;
  D.24307 = list;
  return D.24307;
  <D.24305>:
  D.24307 = new_list;
  return D.24307;
}


__attribute__((visibility ("hidden")))
mono_call_inst_add_outarg_vt (struct MonoCompile * cfg, struct MonoCallInst * call, struct MonoInst * outarg_vt)
{
  struct MonoMemPool * D.24309;
  struct GSList * D.24310;
  struct GSList * D.24311;

  D.24309 = cfg->mempool;
  D.24310 = call->outarg_vts;
  D.24311 = g_slist_append_mempool (D.24309, D.24310, outarg_vt);
  call->outarg_vts = D.24311;
}


__attribute__((visibility ("hidden")))
mono_print_ji (const struct MonoJumpInfo * ji)
{
  <unnamed type> D.24312;
  struct MonoJumpInfo * D.24313;
  <unnamed type> D.24314;
  const char * D.24315;
  struct MonoMethod * D.24316;
  const char * D.24317;

  D.24312 = ji->type;
  switch (D.24312) <default: <D.23632>, case 6: <D.23630>, case 35: <D.23627>>
  <D.23627>:
  {
    struct MonoJumpInfoRgctxEntry * entry;

    entry = ji->data.rgctx_entry;
    printf ("[RGCTX_FETCH ");
    D.24313 = entry->data;
    mono_print_ji (D.24313);
    D.24314 = entry->info_type;
    D.24315 = mono_rgctx_info_type_to_str (D.24314);
    printf (" - %s]", D.24315);
    goto <D.23629>;
  }
  <D.23630>:
  {
    char * s;

    D.24316 = ji->data.method;
    s = mono_method_full_name (D.24316, 1);
    printf ("[METHODCONST - %s]", s);
    monoeg_g_free (s);
    goto <D.23629>;
  }
  <D.23632>:
  D.24312 = ji->type;
  D.24317 = patch_info_str[D.24312];
  printf ("[%s]", D.24317);
  goto <D.23629>;
  <D.23629>:
}


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

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


__attribute__((visibility ("hidden")))
mono_print_ins_index (int i, struct MonoInst * ins)
{
  short unsigned int D.24320;
  int D.24321;
  int D.24322;
  short unsigned int D.24323;
  sizetype D.24324;
  const char * D.24327;
  const char * D.24329;
  int D.24332;
  long int D.24337;
  int D.24339;
  int D.24342;
  int D.24345;
  struct MonoBasicBlock * * D.24348;
  struct MonoBasicBlock * * D.24349;
  struct MonoBasicBlock * D.24350;
  struct MonoBasicBlock * D.24353;
  int D.24354;
  int D.24356;
  int D.24357;
  int * D.24360;
  sizetype D.24361;
  sizetype D.24362;
  sizetype D.24363;
  int * D.24364;
  int D.24365;
  int D.24366;
  void * D.24367;
  int D.24368;
  char D.24369;
  char D.24372;
  _Bool D.24373;
  _Bool iftmp.3;
  _Bool D.24375;
  long int D.24376;
  long int D.24377;
  int iftmp.4;
  int D.24385;
  const char * D.24400;
  const char * D.24402;
  const char * D.24404;
  const char * D.24405;
  char D.24406;
  char D.24409;
  _Bool D.24410;
  _Bool iftmp.5;
  _Bool D.24412;
  long int D.24413;
  long int D.24414;
  int iftmp.6;
  int D.24422;
  const char * D.24432;
  const char * D.24434;
  signed char D.24435;
  int D.24436;
  sizetype D.24437;
  const char * D.24438;
  char D.24439;
  char D.24440;
  _Bool D.24441;
  _Bool iftmp.7;
  _Bool D.24443;
  long int D.24444;
  long int D.24445;
  int iftmp.8;
  int D.24452;
  int D.24454;
  const char * D.24459;
  long int D.24460;
  int D.24461;
  void * D.24462;
  long int D.24463;
  int D.24464;
  long int D.24465;
  double D.24466;
  float D.24467;
  double D.24468;
  short unsigned int D.24469;
  struct MonoMethod * D.24474;
  long unsigned int D.24478;
  long unsigned int D.24479;
  const void * D.24483;
  const char * D.24488;
  void * D.24489;
  long int D.24490;
  unsigned int D.24491;
  int regpair.9;
  const char * D.24493;
  struct GSList * iftmp.10;
  struct MonoBasicBlock * D.24498;
  int D.24499;
  const char * D.24503;
  char D.24504;
  int D.24507;
  const char * spec;
  int num_sregs;
  int j;
  int sregs[3];

  try
    {
      D.24320 = ins->opcode;
      D.24321 = (int) D.24320;
      D.24322 = D.24321 + -313;
      D.24323 = s390x_cpu_desc_idx[D.24322];
      D.24324 = (sizetype) D.24323;
      spec = &s390x_cpu_desc + D.24324;
      if (i != -1) goto <D.24325>; else goto <D.24326>;
      <D.24325>:
      D.24320 = ins->opcode;
      D.24321 = (int) D.24320;
      D.24327 = mono_inst_name (D.24321);
      printf ("\t%-2d %s", i, D.24327);
      goto <D.24328>;
      <D.24326>:
      D.24320 = ins->opcode;
      D.24321 = (int) D.24320;
      D.24329 = mono_inst_name (D.24321);
      printf (" %s", D.24329);
      <D.24328>:
      if (spec == &s390x_cpu_desc) goto <D.24330>; else goto <D.24331>;
      <D.24330>:
      {
        gboolean dest_base;

        dest_base = 0;
        D.24320 = ins->opcode;
        D.24321 = (int) D.24320;
        switch (D.24321) <default: <D.23644>, case 387: <D.23642>>
        <D.23642>:
        dest_base = 1;
        goto <D.23643>;
        <D.23644>:
        goto <D.23643>;
        <D.23643>:
        D.24332 = ins->dreg;
        if (D.24332 != -1) goto <D.24333>; else goto <D.24334>;
        <D.24333>:
        if (dest_base != 0) goto <D.24335>; else goto <D.24336>;
        <D.24335>:
        D.24332 = ins->dreg;
        D.24337 = ins->data.op[0].const_val;
        printf (" [R%d + 0x%lx] <-", D.24332, D.24337);
        goto <D.24338>;
        <D.24336>:
        D.24332 = ins->dreg;
        printf (" R%d <-", D.24332);
        <D.24338>:
        <D.24334>:
        D.24339 = ins->sreg1;
        if (D.24339 != -1) goto <D.24340>; else goto <D.24341>;
        <D.24340>:
        D.24339 = ins->sreg1;
        printf (" R%d", D.24339);
        <D.24341>:
        D.24342 = ins->sreg2;
        if (D.24342 != -1) goto <D.24343>; else goto <D.24344>;
        <D.24343>:
        D.24342 = ins->sreg2;
        printf (" R%d", D.24342);
        <D.24344>:
        D.24345 = ins->sreg3;
        if (D.24345 != -1) goto <D.24346>; else goto <D.24347>;
        <D.24346>:
        D.24345 = ins->sreg3;
        printf (" R%d", D.24345);
        <D.24347>:
        D.24320 = ins->opcode;
        D.24321 = (int) D.24320;
        switch (D.24321) <default: <D.23668>, case 314: <D.23664>, case 319: <D.23656>, case 320: <D.23659>, case 321: <D.23657>, case 332: <D.23667>, case 334: <D.23665>, case 367: <D.23666>, case 551: <D.23646>, case 552: <D.23651>, case 553: <D.23649>, case 554: <D.23653>, case 555: <D.23647>, case 556: <D.23645>, case 557: <D.23652>, case 558: <D.23650>, case 559: <D.23654>, case 560: <D.23648>, case 802: <D.23658>>
        <D.23645>:
        <D.23646>:
        <D.23647>:
        <D.23648>:
        <D.23649>:
        <D.23650>:
        <D.23651>:
        <D.23652>:
        <D.23653>:
        <D.23654>:
        D.24348 = ins->data.op[1].many_blocks;
        D.24349 = D.24348 + 8;
        D.24350 = *D.24349;
        if (D.24350 == 0B) goto <D.24351>; else goto <D.24352>;
        <D.24351>:
        D.24348 = ins->data.op[1].many_blocks;
        D.24353 = *D.24348;
        D.24354 = D.24353->block_num;
        printf (" [B%d]", D.24354);
        goto <D.24355>;
        <D.24352>:
        D.24348 = ins->data.op[1].many_blocks;
        D.24353 = *D.24348;
        D.24354 = D.24353->block_num;
        D.24348 = ins->data.op[1].many_blocks;
        D.24349 = D.24348 + 8;
        D.24350 = *D.24349;
        D.24356 = D.24350->block_num;
        printf (" [B%dB%d]", D.24354, D.24356);
        <D.24355>:
        goto <D.23655>;
        <D.23656>:
        <D.23657>:
        <D.23658>:
        <D.23659>:
        {
          int i;

          D.24337 = ins->data.op[0].const_val;
          D.24357 = (int) D.24337;
          printf (" [%d (", D.24357);
          i = 0;
          goto <D.23662>;
          <D.23661>:
          if (i != 0) goto <D.24358>; else goto <D.24359>;
          <D.24358>:
          printf (", ");
          <D.24359>:
          D.24360 = ins->data.op[1].phi_args;
          D.24361 = (sizetype) i;
          D.24362 = D.24361 + 1;
          D.24363 = D.24362 * 4;
          D.24364 = D.24360 + D.24363;
          D.24365 = *D.24364;
          printf ("R%d", D.24365);
          i = i + 1;
          <D.23662>:
          D.24360 = ins->data.op[1].phi_args;
          D.24366 = *D.24360;
          if (D.24366 > i) goto <D.23661>; else goto <D.23663>;
          <D.23663>:
          printf (")]");
          goto <D.23655>;
        }
        <D.23664>:
        <D.23665>:
        D.24367 = ins->data.op[0].p;
        D.24368 = MEM[(struct MonoInst *)D.24367].dreg;
        printf (" R%d", D.24368);
        goto <D.23655>;
        <D.23666>:
        <D.23667>:
        D.24337 = ins->data.op[0].const_val;
        printf (" + 0x%lx", D.24337);
        goto <D.23655>;
        <D.23668>:
        goto <D.23655>;
        <D.23655>:
        printf ("\n");
        return;
      }
      <D.24331>:
      D.24369 = *spec;
      if (D.24369 != 0) goto <D.24370>; else goto <D.24371>;
      <D.24370>:
      {
        int bank;

        D.24369 = *spec;
        D.24372 = D.24369 + 154;
        D.24373 = D.24372 <= 1;
        bank = (int) D.24373;
        D.24375 = bank != 0;
        D.24376 = (long int) D.24375;
        D.24377 = __builtin_expect (D.24376, 0);
        if (D.24377 != 0) goto <D.24378>; else goto <D.24379>;
        <D.24378>:
        D.24332 = ins->dreg;
        if (D.24332 < 0) goto <D.24381>; else goto <D.24384>;
        <D.24384>:
        D.24332 = ins->dreg;
        D.24385 = regbank_size[bank];
        if (D.24332 >= D.24385) goto <D.24381>; else goto <D.24382>;
        <D.24381>:
        iftmp.4 = 1;
        goto <D.24383>;
        <D.24382>:
        iftmp.4 = 0;
        <D.24383>:
        iftmp.3 = (_Bool) iftmp.4;
        goto <D.24386>;
        <D.24379>:
        D.24332 = ins->dreg;
        iftmp.3 = D.24332 > 15;
        <D.24386>:
        if (iftmp.3 != 0) goto <D.24387>; else goto <D.24388>;
        <D.24387>:
        D.24369 = *spec;
        if (D.24369 == 98) goto <D.24389>; else goto <D.24390>;
        <D.24389>:
        D.24337 = ins->data.op[0].const_val;
        if (D.24337 == 0) goto <D.24391>; else goto <D.24392>;
        <D.24391>:
        D.24332 = ins->dreg;
        printf (" [R%d] <-", D.24332);
        goto <D.24393>;
        <D.24392>:
        D.24332 = ins->dreg;
        D.24337 = ins->data.op[0].const_val;
        printf (" [R%d + 0x%lx] <-", D.24332, D.24337);
        <D.24393>:
        goto <D.24394>;
        <D.24390>:
        D.24332 = ins->dreg;
        printf (" R%d <-", D.24332);
        <D.24394>:
        goto <D.24395>;
        <D.24388>:
        D.24369 = *spec;
        if (D.24369 == 98) goto <D.24396>; else goto <D.24397>;
        <D.24396>:
        D.24337 = ins->data.op[0].const_val;
        if (D.24337 == 0) goto <D.24398>; else goto <D.24399>;
        <D.24398>:
        D.24332 = ins->dreg;
        D.24400 = mono_arch_regname (D.24332);
        printf (" [%s] <-", D.24400);
        goto <D.24401>;
        <D.24399>:
        D.24332 = ins->dreg;
        D.24402 = mono_arch_regname (D.24332);
        D.24337 = ins->data.op[0].const_val;
        printf (" [%s + 0x%lx] <-", D.24402, D.24337);
        <D.24401>:
        goto <D.24403>;
        <D.24397>:
        D.24332 = ins->dreg;
        D.24404 = mono_regname_full (D.24332, bank);
        printf (" %s <-", D.24404);
        <D.24403>:
        <D.24395>:
      }
      <D.24371>:
      D.24405 = spec + 1;
      D.24406 = *D.24405;
      if (D.24406 != 0) goto <D.24407>; else goto <D.24408>;
      <D.24407>:
      {
        int bank;

        D.24405 = spec + 1;
        D.24406 = *D.24405;
        D.24409 = D.24406 + 154;
        D.24410 = D.24409 <= 1;
        bank = (int) D.24410;
        D.24412 = bank != 0;
        D.24413 = (long int) D.24412;
        D.24414 = __builtin_expect (D.24413, 0);
        if (D.24414 != 0) goto <D.24415>; else goto <D.24416>;
        <D.24415>:
        D.24339 = ins->sreg1;
        if (D.24339 < 0) goto <D.24418>; else goto <D.24421>;
        <D.24421>:
        D.24339 = ins->sreg1;
        D.24422 = regbank_size[bank];
        if (D.24339 >= D.24422) goto <D.24418>; else goto <D.24419>;
        <D.24418>:
        iftmp.6 = 1;
        goto <D.24420>;
        <D.24419>:
        iftmp.6 = 0;
        <D.24420>:
        iftmp.5 = (_Bool) iftmp.6;
        goto <D.24423>;
        <D.24416>:
        D.24339 = ins->sreg1;
        iftmp.5 = D.24339 > 15;
        <D.24423>:
        if (iftmp.5 != 0) goto <D.24424>; else goto <D.24425>;
        <D.24424>:
        D.24405 = spec + 1;
        D.24406 = *D.24405;
        if (D.24406 == 98) goto <D.24426>; else goto <D.24427>;
        <D.24426>:
        D.24339 = ins->sreg1;
        D.24337 = ins->data.op[0].const_val;
        printf (" [R%d + 0x%lx]", D.24339, D.24337);
        goto <D.24428>;
        <D.24427>:
        D.24339 = ins->sreg1;
        printf (" R%d", D.24339);
        <D.24428>:
        goto <D.24429>;
        <D.24425>:
        D.24405 = spec + 1;
        D.24406 = *D.24405;
        if (D.24406 == 98) goto <D.24430>; else goto <D.24431>;
        <D.24430>:
        D.24339 = ins->sreg1;
        D.24432 = mono_arch_regname (D.24339);
        D.24337 = ins->data.op[0].const_val;
        printf (" [%s + 0x%lx]", D.24432, D.24337);
        goto <D.24433>;
        <D.24431>:
        D.24339 = ins->sreg1;
        D.24434 = mono_regname_full (D.24339, bank);
        printf (" %s", D.24434);
        <D.24433>:
        <D.24429>:
      }
      <D.24408>:
      D.24339 = ins->sreg1;
      sregs[0] = D.24339;
      D.24342 = ins->sreg2;
      sregs[1] = D.24342;
      D.24345 = ins->sreg3;
      sregs[2] = D.24345;
      D.24320 = ins->opcode;
      D.24321 = (int) D.24320;
      D.24322 = D.24321 + -313;
      D.24435 = ins_sreg_counts[D.24322];
      num_sregs = (int) D.24435;
      j = 1;
      goto <D.23673>;
      <D.23672>:
      {
        int bank;

        D.24436 = j + 1;
        D.24437 = (sizetype) D.24436;
        D.24438 = spec + D.24437;
        D.24439 = *D.24438;
        D.24440 = D.24439 + 154;
        D.24441 = D.24440 <= 1;
        bank = (int) D.24441;
        D.24443 = bank != 0;
        D.24444 = (long int) D.24443;
        D.24445 = __builtin_expect (D.24444, 0);
        if (D.24445 != 0) goto <D.24446>; else goto <D.24447>;
        <D.24446>:
        D.24452 = sregs[j];
        if (D.24452 < 0) goto <D.24449>; else goto <D.24453>;
        <D.24453>:
        D.24452 = sregs[j];
        D.24454 = regbank_size[bank];
        if (D.24452 >= D.24454) goto <D.24449>; else goto <D.24450>;
        <D.24449>:
        iftmp.8 = 1;
        goto <D.24451>;
        <D.24450>:
        iftmp.8 = 0;
        <D.24451>:
        iftmp.7 = (_Bool) iftmp.8;
        goto <D.24455>;
        <D.24447>:
        D.24452 = sregs[j];
        iftmp.7 = D.24452 > 15;
        <D.24455>:
        if (iftmp.7 != 0) goto <D.24456>; else goto <D.24457>;
        <D.24456>:
        D.24452 = sregs[j];
        printf (" R%d", D.24452);
        goto <D.24458>;
        <D.24457>:
        D.24452 = sregs[j];
        D.24459 = mono_regname_full (D.24452, bank);
        printf (" %s", D.24459);
        <D.24458>:
      }
      j = j + 1;
      <D.23673>:
      if (j < num_sregs) goto <D.23672>; else goto <D.23674>;
      <D.23674>:
      D.24320 = ins->opcode;
      D.24321 = (int) D.24320;
      switch (D.24321) <default: <D.23742>, case 323: <D.23678>, case 327: <D.23677>, case 341: <D.23741>, case 343: <D.23701>, case 345: <D.23702>, case 346: <D.23690>, case 347: <D.23692>, case 348: <D.23691>, case 349: <D.23693>, case 352: <D.23694>, case 355: <D.23695>, case 356: <D.23696>, case 357: <D.23697>, case 358: <D.23698>, case 359: <D.23699>, case 360: <D.23700>, case 362: <D.23675>, case 363: <D.23687>, case 364: <D.23689>, case 365: <D.23688>, case 429: <D.23685>, case 430: <D.23684>, case 442: <D.23715>, case 444: <D.23703>, case 538: <D.23686>, case 551: <D.23728>, case 552: <D.23733>, case 553: <D.23731>, case 554: <D.23735>, case 555: <D.23729>, case 556: <D.23727>, case 557: <D.23734>, case 558: <D.23732>, case 559: <D.23736>, case 560: <D.23730>, case 625: <D.23679>, case 626: <D.23680>, case 632: <D.23681>, case 633: <D.23682>, case 634: <D.23683>, case 648: <D.23718>, case 649: <D.23723>, case 650: <D.23721>, case 651: <D.23725>, case 652: <D.23719>, case 653: <D.23717>, case 654: <D.23724>, case 655: <D.23722>, case 656: <D.23726>, case 657: <D.23720>, case 735: <D.23716>, case 836: <D.23737>, case 837: <D.23738>, case 838: <D.23739>, case 839: <D.23740>>
      <D.23675>:
      D.24337 = ins->data.op[0].const_val;
      D.24357 = (int) D.24337;
      printf (" [%d]", D.24357);
      goto <D.23676>;
      <D.23677>:
      <D.23678>:
      <D.23679>:
      <D.23680>:
      <D.23681>:
      <D.23682>:
      <D.23683>:
      <D.23684>:
      D.24460 = ins->data.op[1].const_val;
      D.24461 = (int) D.24460;
      printf (" [%d]", D.24461);
      goto <D.23676>;
      <D.23685>:
      <D.23686>:
      D.24462 = ins->data.op[1].p;
      D.24463 = (long int) D.24462;
      D.24464 = (int) D.24463;
      printf (" [%d]", D.24464);
      goto <D.23676>;
      <D.23687>:
      D.24465 = ins->data.i8const;
      printf (" [%lld]", D.24465);
      goto <D.23676>;
      <D.23688>:
      D.24367 = ins->data.op[0].p;
      D.24466 = MEM[(double *)D.24367];
      printf (" [%f]", D.24466);
      goto <D.23676>;
      <D.23689>:
      D.24367 = ins->data.op[0].p;
      D.24467 = MEM[(float *)D.24367];
      D.24468 = (double) D.24467;
      printf (" [%f]", D.24468);
      goto <D.23676>;
      <D.23690>:
      <D.23691>:
      <D.23692>:
      <D.23693>:
      <D.23694>:
      <D.23695>:
      <D.23696>:
      <D.23697>:
      <D.23698>:
      <D.23699>:
      <D.23700>:
      <D.23701>:
      <D.23702>:
      <D.23703>:
      {
        struct MonoCallInst * call;
        struct GSList * list;

        call = ins;
        D.24320 = ins->opcode;
        D.24469 = D.24320 + 65181;
        if (D.24469 <= 2) goto <D.24470>; else goto <D.24471>;
        <D.24470>:
        D.24332 = ins->dreg;
        if (D.24332 != -1) goto <D.24472>; else goto <D.24473>;
        <D.24472>:
        D.24332 = ins->dreg;
        printf (" R%d <-", D.24332);
        <D.24473>:
        <D.24471>:
        D.24474 = call->method;
        if (D.24474 != 0B) goto <D.24475>; else goto <D.24476>;
        <D.24475>:
        {
          char * full_name;

          D.24474 = call->method;
          full_name = mono_method_full_name (D.24474, 1);
          printf (" [%s]", full_name);
          monoeg_g_free (full_name);
        }
        goto <D.24477>;
        <D.24476>:
        D.24478 = BIT_FIELD_REF <*call, 64, 1088>;
        D.24479 = D.24478 & 2305843009213693952;
        if (D.24479 != 0) goto <D.24480>; else goto <D.24481>;
        <D.24480>:
        {
          struct MonoJumpInfo * ji;

          ji = call->fptr;
          printf (" ");
          mono_print_ji (ji);
        }
        goto <D.24482>;
        <D.24481>:
        D.24483 = call->fptr;
        if (D.24483 != 0B) goto <D.24484>; else goto <D.24485>;
        <D.24484>:
        {
          struct MonoJitICallInfo * info;

          D.24483 = call->fptr;
          info = mono_find_jit_icall_by_addr (D.24483);
          if (info != 0B) goto <D.24486>; else goto <D.24487>;
          <D.24486>:
          D.24488 = info->name;
          printf (" [%s]", D.24488);
          <D.24487>:
        }
        <D.24485>:
        <D.24482>:
        <D.24477>:
        list = call->out_ireg_args;
        goto <D.23713>;
        <D.23712>:
        {
          guint32 regpair;
          int reg;
          int hreg;

          D.24489 = list->data;
          D.24490 = (long int) D.24489;
          regpair = (guint32) D.24490;
          D.24491 = regpair >> 24;
          hreg = (int) D.24491;
          regpair.9 = (int) regpair;
          reg = regpair.9 & 16777215;
          D.24493 = mono_arch_regname (hreg);
          printf (" [%s <- R%d]", D.24493, reg);
          if (list != 0B) goto <D.24495>; else goto <D.24496>;
          <D.24495>:
          iftmp.10 = list->next;
          goto <D.24497>;
          <D.24496>:
          iftmp.10 = 0B;
          <D.24497>:
          list = iftmp.10;
        }
        <D.23713>:
        if (list != 0B) goto <D.23712>; else goto <D.23714>;
        <D.23714>:
        goto <D.23676>;
      }
      <D.23715>:
      <D.23716>:
      D.24498 = ins->data.op[0].target_block;
      D.24499 = D.24498->block_num;
      printf (" [B%d]", D.24499);
      goto <D.23676>;
      <D.23717>:
      <D.23718>:
      <D.23719>:
      <D.23720>:
      <D.23721>:
      <D.23722>:
      <D.23723>:
      <D.23724>:
      <D.23725>:
      <D.23726>:
      <D.23727>:
      <D.23728>:
      <D.23729>:
      <D.23730>:
      <D.23731>:
      <D.23732>:
      <D.23733>:
      <D.23734>:
      <D.23735>:
      <D.23736>:
      D.24348 = ins->data.op[1].many_blocks;
      D.24349 = D.24348 + 8;
      D.24350 = *D.24349;
      if (D.24350 == 0B) goto <D.24500>; else goto <D.24501>;
      <D.24500>:
      D.24348 = ins->data.op[1].many_blocks;
      D.24353 = *D.24348;
      D.24354 = D.24353->block_num;
      printf (" [B%d]", D.24354);
      goto <D.24502>;
      <D.24501>:
      D.24348 = ins->data.op[1].many_blocks;
      D.24353 = *D.24348;
      D.24354 = D.24353->block_num;
      D.24348 = ins->data.op[1].many_blocks;
      D.24349 = D.24348 + 8;
      D.24350 = *D.24349;
      D.24356 = D.24350->block_num;
      printf (" [B%dB%d]", D.24354, D.24356);
      <D.24502>:
      goto <D.23676>;
      <D.23737>:
      <D.23738>:
      <D.23739>:
      <D.23740>:
      D.24460 = ins->data.op[1].const_val;
      D.24461 = (int) D.24460;
      printf (" R%d", D.24461);
      goto <D.23676>;
      <D.23741>:
      D.24460 = ins->data.op[1].const_val;
      D.24461 = (int) D.24460;
      printf (" il: %x", D.24461);
      goto <D.23676>;
      <D.23742>:
      goto <D.23676>;
      <D.23676>:
      D.24503 = spec + 5;
      D.24504 = *D.24503;
      if (D.24504 != 0) goto <D.24505>; else goto <D.24506>;
      <D.24505>:
      D.24503 = spec + 5;
      D.24504 = *D.24503;
      D.24507 = (int) D.24504;
      printf (" clobbers: %c", D.24507);
      <D.24506>:
      printf ("\n");
    }
  finally
    {
      sregs = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
mono_print_ins (struct MonoInst * ins)
{
  mono_print_ins_index (-1, ins);
}


__attribute__((visibility ("hidden")))
mono_local_regalloc (struct MonoCompile * cfg, struct MonoBasicBlock * bb)
{
  struct MonoInst * D.24514;
  int desc_to_fixed_reg_inited.11;
  gint8 iftmp.12;
  gint8 iftmp.13;
  unsigned int D.24528;
  int D.24529;
  long unsigned int D.24530;
  void * D.24531;
  int D.24534;
  int D.24539;
  int D.24540;
  struct MonoMemPool * D.24541;
  long unsigned int D.24542;
  unsigned int D.24543;
  unsigned int D.24544;
  void * D.24545;
  int D.24547;
  _Bool D.24548;
  long int D.24549;
  long int D.24550;
  unsigned int D.24553;
  long unsigned int D.24556;
  short unsigned int D.24557;
  int D.24558;
  int D.24559;
  short unsigned int D.24560;
  sizetype D.24561;
  int D.24562;
  long unsigned int D.24567;
  long unsigned int D.24568;
  struct RegTrack * D.24569;
  int D.24570;
  int D.24571;
  int D.24572;
  signed char D.24573;
  int D.24574;
  _Bool D.24575;
  long int D.24576;
  long int D.24577;
  long unsigned int D.24582;
  long unsigned int D.24583;
  struct RegTrack * D.24584;
  _Bool D.24585;
  long int D.24586;
  long int D.24587;
  int D.24590;
  _Bool D.24591;
  long int D.24592;
  long int D.24593;
  const char * D.24596;
  int D.24599;
  sizetype D.24600;
  const char * D.24601;
  char D.24602;
  char D.24605;
  _Bool D.24606;
  _Bool D.24607;
  long int D.24608;
  long int D.24609;
  _Bool iftmp.14;
  _Bool D.24613;
  long int D.24614;
  long int D.24615;
  int iftmp.15;
  int D.24623;
  long unsigned int D.24627;
  long unsigned int D.24628;
  struct RegTrack * D.24629;
  int D.24630;
  _Bool D.24631;
  long int D.24632;
  long int D.24633;
  gint32 * D.24636;
  long unsigned int D.24637;
  gint32 * D.24638;
  sizetype D.24641;
  sizetype D.24642;
  sizetype D.24643;
  gint32 * D.24644;
  sizetype D.24647;
  struct RegTrack * D.24648;
  int D.24649;
  char D.24654;
  char D.24655;
  _Bool D.24656;
  _Bool D.24659;
  long int D.24660;
  long int D.24661;
  long unsigned int D.24664;
  gint32 * D.24665;
  int D.24668;
  int D.24670;
  signed char D.24671;
  long unsigned int D.24674;
  sizetype D.24677;
  sizetype D.24678;
  sizetype D.24679;
  gint32 * D.24680;
  sizetype D.24683;
  struct RegTrack * D.24684;
  int D.24685;
  const char * D.24692;
  char D.24693;
  short unsigned int D.24696;
  short unsigned int D.24698;
  short unsigned int D.24700;
  short unsigned int D.24702;
  short unsigned int D.24704;
  short unsigned int D.24706;
  void * D.24710;
  long int D.24711;
  unsigned int D.24712;
  int regpair.16;
  struct GSList * iftmp.17;
  unsigned int D.24720;
  int regpair.18;
  struct GSList * iftmp.19;
  struct MonoInst * iftmp.20;
  const char * D.24732;
  long unsigned int D.24733;
  int D.24734;
  signed char D.24735;
  int D.24736;
  int D.24741;
  signed char D.24742;
  long unsigned int D.24743;
  long unsigned int D.24748;
  long unsigned int D.24751;
  long unsigned int D.24752;
  long unsigned int D.24753;
  int D.24756;
  long unsigned int D.24759;
  long unsigned int D.24760;
  gint32 * D.24761;
  int D.24762;
  long unsigned int D.24767;
  long unsigned int D.24768;
  gint32 * D.24769;
  int D.24770;
  long unsigned int D.24775;
  long unsigned int D.24776;
  long unsigned int D.24777;
  long unsigned int D.24784;
  long unsigned int D.24785;
  const char * D.24791;
  long unsigned int D.24797;
  long unsigned int D.24798;
  long unsigned int D.24802;
  long unsigned int D.24803;
  _Bool D.24811;
  long int D.24812;
  long int D.24813;
  const char * D.24818;
  const char * D.24819;
  _Bool iftmp.21;
  int iftmp.22;
  int D.24852;
  long unsigned int D.24855;
  long unsigned int D.24856;
  int D.24857;
  long unsigned int D.24860;
  long unsigned int D.24861;
  _Bool iftmp.23;
  int iftmp.24;
  long unsigned int D.24875;
  long unsigned int D.24876;
  long int iftmp.25;
  int iftmp.26;
  _Bool D.24889;
  int D.24890;
  _Bool D.24892;
  int D.24893;
  long int D.24894;
  int D.24899;
  int D.24902;
  long unsigned int D.24905;
  long unsigned int D.24906;
  gint32 * D.24907;
  int D.24908;
  unsigned int D.24909;
  int dest_dreg2.27;
  _Bool iftmp.28;
  int iftmp.29;
  const char * D.24941;
  _Bool D.24946;
  long int D.24947;
  long int D.24948;
  long unsigned int D.24953;
  long unsigned int D.24954;
  gint32 * D.24955;
  long unsigned int D.24965;
  long unsigned int D.24966;
  int D.24971;
  const char * D.24974;
  _Bool iftmp.30;
  int iftmp.31;
  int iftmp.32;
  _Bool D.24988;
  long unsigned int D.24992;
  long unsigned int D.24993;
  long unsigned int D.24994;
  int iftmp.33;
  unsigned int val.34;
  long unsigned int D.25002;
  long unsigned int D.25003;
  long unsigned int D.25009;
  struct RegTrack * D.25010;
  int D.25011;
  const char * D.25016;
  _Bool iftmp.35;
  int iftmp.36;
  long unsigned int D.25032;
  long unsigned int D.25033;
  gint32 * D.25034;
  _Bool D.25035;
  long int D.25036;
  long int D.25037;
  const char * D.25042;
  long unsigned int D.25043;
  struct RegTrack * D.25044;
  int D.25045;
  struct MonoRegState * D.25055;
  int * D.25056;
  long unsigned int D.25057;
  long unsigned int D.25058;
  int * D.25059;
  int D.25060;
  int D.25061;
  int D.25065;
  long unsigned int D.25072;
  long unsigned int D.25073;
  long unsigned int D.25074;
  long unsigned int D.25075;
  long unsigned int D.25078;
  long unsigned int D.25079;
  int D.25084;
  unsigned char D.25092;
  sizetype D.25096;
  sizetype D.25097;
  sizetype D.25098;
  gint32 * D.25099;
  long unsigned int D.25101;
  long unsigned int D.25102;
  long unsigned int D.25103;
  long unsigned int D.25106;
  long unsigned int D.25107;
  int D.25116;
  long unsigned int D.25119;
  long unsigned int D.25120;
  gint32 * D.25121;
  long unsigned int D.25122;
  long unsigned int D.25123;
  long unsigned int D.25134;
  int * D.25140;
  long unsigned int D.25141;
  long unsigned int D.25142;
  int * D.25143;
  int D.25144;
  long unsigned int D.25147;
  long unsigned int D.25148;
  gint32 * D.25149;
  int D.25150;
  void * D.25163;
  long int D.25164;
  unsigned int D.25165;
  int regpair.37;
  long unsigned int D.25167;
  long unsigned int D.25168;
  long unsigned int D.25169;
  long unsigned int D.25170;
  const char * D.25173;
  struct GSList * iftmp.38;
  unsigned int D.25180;
  int regpair.39;
  const char * D.25184;
  struct GSList * iftmp.40;
  char D.25189;
  char D.25190;
  _Bool D.25191;
  long int iftmp.41;
  int iftmp.42;
  _Bool D.25202;
  int D.25203;
  _Bool D.25205;
  int D.25206;
  long int D.25207;
  _Bool D.25212;
  long int D.25213;
  long int D.25214;
  _Bool D.25217;
  long int D.25218;
  long int D.25219;
  long unsigned int D.25222;
  long unsigned int D.25223;
  gint32 * D.25224;
  int D.25225;
  const char * D.25232;
  long unsigned int D.25233;
  long unsigned int D.25234;
  _Bool D.25235;
  long int D.25236;
  long int D.25237;
  long unsigned int D.25240;
  sizetype D.25243;
  sizetype D.25244;
  sizetype D.25245;
  gint32 * D.25246;
  int D.25247;
  int D.25252;
  const char * D.25255;
  long unsigned int D.25256;
  long unsigned int D.25266;
  int D.25269;
  long unsigned int D.25270;
  long unsigned int D.25271;
  gint32 * D.25272;
  int D.25273;
  long unsigned int D.25276;
  long unsigned int D.25277;
  _Bool iftmp.43;
  int iftmp.44;
  unsigned int D.25303;
  long unsigned int D.25306;
  long unsigned int D.25307;
  long unsigned int D.25310;
  long unsigned int D.25311;
  long unsigned int D.25320;
  struct RegTrack * D.25321;
  const char * D.25324;
  int D.25327;
  long unsigned int D.25333;
  long unsigned int D.25335;
  long unsigned int D.25336;
  long unsigned int D.25337;
  _Bool D.25342;
  long int D.25343;
  long int D.25344;
  long unsigned int D.25349;
  long unsigned int D.25350;
  gint32 * D.25351;
  const char * D.25365;
  unsigned char D.25372;
  _Bool D.25373;
  int D.25374;
  const char * D.25379;
  const char * D.25380;
  _Bool D.25381;
  long int D.25382;
  long int D.25383;
  sizetype D.25389;
  sizetype D.25390;
  sizetype D.25391;
  gint32 * D.25392;
  int D.25393;
  _Bool D.25396;
  long int D.25397;
  long int D.25398;
  _Bool D.25401;
  long int D.25402;
  long int D.25403;
  const char * D.25408;
  const char * D.25409;
  long unsigned int D.25412;
  long unsigned int D.25413;
  _Bool iftmp.45;
  int iftmp.46;
  long unsigned int D.25430;
  gint32 * D.25431;
  const char * D.25444;
  long unsigned int D.25447;
  long unsigned int D.25448;
  long unsigned int D.25449;
  long unsigned int D.25450;
  _Bool D.25456;
  long int D.25457;
  long int D.25458;
  int D.25463;
  _Bool D.25464;
  long int D.25465;
  long int D.25466;
  struct MonoInst * iftmp.47;
  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.24514 = bb->code;
      if (D.24514 == 0B) goto <D.24515>; else goto <D.24516>;
      <D.24515>:
      return;
      <D.24516>:
      desc_to_fixed_reg_inited.11 = desc_to_fixed_reg_inited;
      if (desc_to_fixed_reg_inited.11 == 0) goto <D.24518>; else goto <D.24519>;
      <D.24518>:
      i = 0;
      goto <D.23916>;
      <D.23915>:
      if (i != 111) goto <D.24521>; else goto <D.24522>;
      <D.24521>:
      if (i == 103) goto <D.24524>; else goto <D.24525>;
      <D.24524>:
      iftmp.13 = 0;
      goto <D.24526>;
      <D.24525>:
      iftmp.13 = -1;
      <D.24526>:
      iftmp.12 = iftmp.13;
      goto <D.24527>;
      <D.24522>:
      iftmp.12 = 2;
      <D.24527>:
      desc_to_fixed_reg[i] = iftmp.12;
      i = i + 1;
      <D.23916>:
      if (i <= 255) goto <D.23915>; else goto <D.23917>;
      <D.23917>:
      desc_to_fixed_reg_inited = 1;
      <D.24519>:
      D.24528 = bb->max_vreg;
      D.24529 = (int) D.24528;
      rs->next_vreg = D.24529;
      mono_regstate_assign (rs);
      rs->ifree_mask = 252;
      i = 0;
      goto <D.23919>;
      <D.23918>:
      D.24530 = regbank_callee_regs[i];
      rs->free_mask[i] = D.24530;
      i = i + 1;
      <D.23919>:
      if (i <= 3) goto <D.23918>; else goto <D.23920>;
      <D.23920>:
      max = rs->next_vreg;
      D.24531 = cfg->reginfo;
      if (D.24531 != 0B) goto <D.24532>; else goto <D.24533>;
      <D.24532>:
      D.24534 = cfg->reginfo_len;
      if (D.24534 < max) goto <D.24535>; else goto <D.24536>;
      <D.24535>:
      cfg->reginfo = 0B;
      <D.24536>:
      <D.24533>:
      reginfo = cfg->reginfo;
      if (reginfo == 0B) goto <D.24537>; else goto <D.24538>;
      <D.24537>:
      D.24539 = max * 2;
      D.24540 = MAX_EXPR <D.24539, 1024>;
      cfg->reginfo_len = D.24540;
      D.24541 = cfg->mempool;
      D.24534 = cfg->reginfo_len;
      D.24542 = (long unsigned int) D.24534;
      D.24543 = (unsigned int) D.24542;
      D.24544 = D.24543 * 16;
      D.24545 = mono_mempool_alloc (D.24541, D.24544);
      cfg->reginfo = D.24545;
      reginfo = cfg->reginfo;
      goto <D.24546>;
      <D.24538>:
      D.24534 = cfg->reginfo_len;
      D.24547 = rs->next_vreg;
      D.24548 = D.24534 < D.24547;
      D.24549 = (long int) D.24548;
      D.24550 = __builtin_expect (D.24549, 0);
      if (D.24550 != 0) goto <D.24551>; else goto <D.24552>;
      <D.24551>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1160, "cfg->reginfo_len >= rs->next_vreg");
      <D.24552>:
      <D.24546>:
      D.24553 = cfg->verbose_level;
      if (D.24553 > 1) goto <D.24554>; else goto <D.24555>;
      <D.24554>:
      D.24531 = cfg->reginfo;
      D.24534 = cfg->reginfo_len;
      D.24542 = (long unsigned int) D.24534;
      D.24556 = D.24542 * 16;
      memset (D.24531, 0, D.24556);
      <D.24555>:
      ins = bb->code;
      goto <D.23925>;
      <D.23924>:
      D.24557 = ins->opcode;
      D.24558 = (int) D.24557;
      D.24559 = D.24558 + -313;
      D.24560 = s390x_cpu_desc_idx[D.24559];
      D.24561 = (sizetype) D.24560;
      spec = &s390x_cpu_desc + D.24561;
      D.24562 = ins->dreg;
      if (D.24562 != -1) goto <D.24563>; else goto <D.24564>;
      <D.24563>:
      D.24562 = ins->dreg;
      if (D.24562 < max) goto <D.24565>; else goto <D.24566>;
      <D.24565>:
      D.24562 = ins->dreg;
      D.24567 = (long unsigned int) D.24562;
      D.24568 = D.24567 * 16;
      D.24569 = reginfo + D.24568;
      memset (D.24569, 0, 16);
      <D.24566>:
      <D.24564>:
      D.24570 = ins->sreg1;
      sregs[0] = D.24570;
      D.24571 = ins->sreg2;
      sregs[1] = D.24571;
      D.24572 = ins->sreg3;
      sregs[2] = D.24572;
      D.24557 = ins->opcode;
      D.24558 = (int) D.24557;
      D.24559 = D.24558 + -313;
      D.24573 = ins_sreg_counts[D.24559];
      num_sregs = (int) D.24573;
      j = 0;
      goto <D.23922>;
      <D.23921>:
      D.24574 = sregs[j];
      D.24575 = D.24574 == -1;
      D.24576 = (long int) D.24575;
      D.24577 = __builtin_expect (D.24576, 0);
      if (D.24577 != 0) goto <D.24578>; else goto <D.24579>;
      <D.24578>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1192, "sregs [j] != -1");
      <D.24579>:
      D.24574 = sregs[j];
      if (D.24574 < max) goto <D.24580>; else goto <D.24581>;
      <D.24580>:
      D.24574 = sregs[j];
      D.24582 = (long unsigned int) D.24574;
      D.24583 = D.24582 * 16;
      D.24584 = reginfo + D.24583;
      memset (D.24584, 0, 16);
      <D.24581>:
      j = j + 1;
      <D.23922>:
      if (j < num_sregs) goto <D.23921>; else goto <D.23923>;
      <D.23923>:
      mono_inst_set_src_registers (ins, &sregs);
      ins = ins->next;
      <D.23925>:
      if (ins != 0B) goto <D.23924>; else goto <D.23926>;
      <D.23926>:
      i = 1;
      D.24553 = cfg->verbose_level;
      D.24585 = D.24553 > 2;
      D.24586 = (long int) D.24585;
      D.24587 = __builtin_expect (D.24586, 0);
      if (D.24587 != 0) goto <D.24588>; else goto <D.24589>;
      <D.24588>:
      D.24590 = bb->block_num;
      printf ("\nLOCAL REGALLOC BLOCK %d:\n", D.24590);
      <D.24589>:
      ins = bb->code;
      goto <D.23949>;
      <D.23948>:
      D.24557 = ins->opcode;
      D.24558 = (int) D.24557;
      D.24559 = D.24558 + -313;
      D.24560 = s390x_cpu_desc_idx[D.24559];
      D.24561 = (sizetype) D.24560;
      spec = &s390x_cpu_desc + D.24561;
      spec_dest = *spec;
      D.24591 = spec == &s390x_cpu_desc;
      D.24592 = (long int) D.24591;
      D.24593 = __builtin_expect (D.24592, 0);
      if (D.24593 != 0) goto <D.24594>; else goto <D.24595>;
      <D.24594>:
      D.24557 = ins->opcode;
      D.24558 = (int) D.24557;
      D.24596 = mono_inst_name (D.24558);
      monoeg_g_log (0B, 4, "Opcode \'%s\' missing from machine description file.", D.24596);
      <D.23927>:
      goto <D.23927>;
      <D.24595>:
      D.24553 = cfg->verbose_level;
      D.24585 = D.24553 > 2;
      D.24586 = (long int) D.24585;
      D.24587 = __builtin_expect (D.24586, 0);
      if (D.24587 != 0) goto <D.24597>; else goto <D.24598>;
      <D.24597>:
      mono_print_ins_index (i, ins);
      <D.24598>:
      D.24570 = ins->sreg1;
      sregs[0] = D.24570;
      D.24571 = ins->sreg2;
      sregs[1] = D.24571;
      D.24572 = ins->sreg3;
      sregs[2] = D.24572;
      D.24557 = ins->opcode;
      D.24558 = (int) D.24557;
      D.24559 = D.24558 + -313;
      D.24573 = ins_sreg_counts[D.24559];
      num_sregs = (int) D.24573;
      j = 0;
      goto <D.23931>;
      <D.23930>:
      {
        int sreg;
        int sreg_spec;

        sreg = sregs[j];
        D.24599 = j + 1;
        D.24600 = (sizetype) D.24599;
        D.24601 = spec + D.24600;
        D.24602 = *D.24601;
        sreg_spec = (int) D.24602;
        if (sreg_spec != 0) goto <D.24603>; else goto <D.24604>;
        <D.24603>:
        D.24599 = j + 1;
        D.24600 = (sizetype) D.24599;
        D.24601 = spec + D.24600;
        D.24602 = *D.24601;
        D.24605 = D.24602 + 154;
        D.24606 = D.24605 <= 1;
        bank = (int) D.24606;
        D.24607 = sreg == -1;
        D.24608 = (long int) D.24607;
        D.24609 = __builtin_expect (D.24608, 0);
        if (D.24609 != 0) goto <D.24610>; else goto <D.24611>;
        <D.24610>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1240, "sreg != -1");
        <D.24611>:
        D.24613 = bank != 0;
        D.24614 = (long int) D.24613;
        D.24615 = __builtin_expect (D.24614, 0);
        if (D.24615 != 0) goto <D.24616>; else goto <D.24617>;
        <D.24616>:
        if (sreg < 0) goto <D.24619>; else goto <D.24622>;
        <D.24622>:
        D.24623 = regbank_size[bank];
        if (D.24623 <= sreg) goto <D.24619>; else goto <D.24620>;
        <D.24619>:
        iftmp.15 = 1;
        goto <D.24621>;
        <D.24620>:
        iftmp.15 = 0;
        <D.24621>:
        iftmp.14 = (_Bool) iftmp.15;
        goto <D.24624>;
        <D.24617>:
        iftmp.14 = sreg > 15;
        <D.24624>:
        if (iftmp.14 != 0) goto <D.24625>; else goto <D.24626>;
        <D.24625>:
        D.24627 = (long unsigned int) sreg;
        D.24628 = D.24627 * 16;
        D.24629 = reginfo + D.24628;
        D.24630 = D.24629->born_in;
        D.24631 = D.24630 <= 0;
        D.24632 = (long int) D.24631;
        D.24633 = __builtin_expect (D.24632, 0);
        if (D.24633 != 0) goto <D.24634>; else goto <D.24635>;
        <D.24634>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1243, "reginfo [sreg].born_in > 0");
        <D.24635>:
        <D.24626>:
        D.24636 = rs->vassign;
        D.24627 = (long unsigned int) sreg;
        D.24637 = D.24627 * 4;
        D.24638 = D.24636 + D.24637;
        *D.24638 = -1;
        if (0 != 0) goto <D.24639>; else goto <D.24640>;
        <D.24639>:
        D.24636 = rs->vassign;
        D.24641 = (sizetype) sreg;
        D.24642 = D.24641 + 1;
        D.24643 = D.24642 * 4;
        D.24644 = D.24636 + D.24643;
        *D.24644 = -1;
        D.24641 = (sizetype) sreg;
        D.24642 = D.24641 + 1;
        D.24647 = D.24642 * 16;
        D.24648 = reginfo + D.24647;
        D.24649 = D.24648->born_in;
        if (D.24649 == 0) goto <D.24645>; else goto <D.24650>;
        <D.24650>:
        D.24641 = (sizetype) sreg;
        D.24642 = D.24641 + 1;
        D.24647 = D.24642 * 16;
        D.24648 = reginfo + D.24647;
        D.24649 = D.24648->born_in;
        if (D.24649 > i) goto <D.24645>; else goto <D.24646>;
        <D.24645>:
        D.24641 = (sizetype) sreg;
        D.24642 = D.24641 + 1;
        D.24647 = D.24642 * 16;
        D.24648 = reginfo + D.24647;
        D.24648->born_in = i;
        <D.24646>:
        <D.24640>:
        goto <D.24651>;
        <D.24604>:
        sregs[j] = -1;
        <D.24651>:
      }
      j = j + 1;
      <D.23931>:
      if (j < num_sregs) goto <D.23930>; else goto <D.23932>;
      <D.23932>:
      mono_inst_set_src_registers (ins, &sregs);
      if (spec_dest != 0) goto <D.24652>; else goto <D.24653>;
      <D.24652>:
      {
        int dest_dreg;

        D.24654 = *spec;
        D.24655 = D.24654 + 154;
        D.24656 = D.24655 <= 1;
        bank = (int) D.24656;
        if (spec_dest != 98) goto <D.24657>; else goto <D.24658>;
        <D.24657>:
        D.24562 = ins->dreg;
        D.24567 = (long unsigned int) D.24562;
        D.24568 = D.24567 * 16;
        D.24569 = reginfo + D.24568;
        D.24569->killed_in = i;
        <D.24658>:
        D.24562 = ins->dreg;
        D.24659 = D.24562 == -1;
        D.24660 = (long int) D.24659;
        D.24661 = __builtin_expect (D.24660, 0);
        if (D.24661 != 0) goto <D.24662>; else goto <D.24663>;
        <D.24662>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1267, "ins->dreg != -1");
        <D.24663>:
        D.24636 = rs->vassign;
        D.24562 = ins->dreg;
        D.24567 = (long unsigned int) D.24562;
        D.24664 = D.24567 * 4;
        D.24665 = D.24636 + D.24664;
        *D.24665 = -1;
        D.24562 = ins->dreg;
        D.24567 = (long unsigned int) D.24562;
        D.24568 = D.24567 * 16;
        D.24569 = reginfo + D.24568;
        D.24668 = D.24569->born_in;
        if (D.24668 == 0) goto <D.24666>; else goto <D.24669>;
        <D.24669>:
        D.24562 = ins->dreg;
        D.24567 = (long unsigned int) D.24562;
        D.24568 = D.24567 * 16;
        D.24569 = reginfo + D.24568;
        D.24668 = D.24569->born_in;
        if (D.24668 > i) goto <D.24666>; else goto <D.24667>;
        <D.24666>:
        D.24562 = ins->dreg;
        D.24567 = (long unsigned int) D.24562;
        D.24568 = D.24567 * 16;
        D.24569 = reginfo + D.24568;
        D.24569->born_in = i;
        <D.24667>:
        D.24670 = (int) spec_dest;
        D.24671 = desc_to_fixed_reg[D.24670];
        dest_dreg = (int) D.24671;
        if (dest_dreg != -1) goto <D.24672>; else goto <D.24673>;
        <D.24672>:
        D.24562 = ins->dreg;
        D.24567 = (long unsigned int) D.24562;
        D.24568 = D.24567 * 16;
        D.24569 = reginfo + D.24568;
        D.24674 = 1 << dest_dreg;
        D.24569->preferred_mask = D.24674;
        <D.24673>:
        if (0 != 0) goto <D.24675>; else goto <D.24676>;
        <D.24675>:
        D.24636 = rs->vassign;
        D.24562 = ins->dreg;
        D.24677 = (sizetype) D.24562;
        D.24678 = D.24677 + 1;
        D.24679 = D.24678 * 4;
        D.24680 = D.24636 + D.24679;
        *D.24680 = -1;
        D.24562 = ins->dreg;
        D.24677 = (sizetype) D.24562;
        D.24678 = D.24677 + 1;
        D.24683 = D.24678 * 16;
        D.24684 = reginfo + D.24683;
        D.24685 = D.24684->born_in;
        if (D.24685 == 0) goto <D.24681>; else goto <D.24686>;
        <D.24686>:
        D.24562 = ins->dreg;
        D.24677 = (sizetype) D.24562;
        D.24678 = D.24677 + 1;
        D.24683 = D.24678 * 16;
        D.24684 = reginfo + D.24683;
        D.24685 = D.24684->born_in;
        if (D.24685 > i) goto <D.24681>; else goto <D.24682>;
        <D.24681>:
        D.24562 = ins->dreg;
        D.24677 = (sizetype) D.24562;
        D.24678 = D.24677 + 1;
        D.24683 = D.24678 * 16;
        D.24684 = reginfo + D.24683;
        D.24684->born_in = i;
        <D.24682>:
        if (0 != 0) goto <D.24687>; else goto <D.24688>;
        <D.24687>:
        D.24562 = ins->dreg;
        D.24677 = (sizetype) D.24562;
        D.24678 = D.24677 + 1;
        D.24683 = D.24678 * 16;
        D.24684 = reginfo + D.24683;
        D.24684->preferred_mask = 252;
        <D.24688>:
        <D.24676>:
      }
      goto <D.24689>;
      <D.24653>:
      ins->dreg = -1;
      <D.24689>:
      D.24692 = spec + 5;
      D.24693 = *D.24692;
      if (D.24693 == 99) goto <D.24694>; else goto <D.24695>;
      <D.24694>:
      D.24557 = ins->opcode;
      D.24696 = D.24557 + 65193;
      if (D.24696 <= 2) goto <D.24690>; else goto <D.24697>;
      <D.24697>:
      D.24557 = ins->opcode;
      D.24698 = D.24557 + 65187;
      if (D.24698 <= 2) goto <D.24690>; else goto <D.24699>;
      <D.24699>:
      D.24557 = ins->opcode;
      D.24700 = D.24557 + 65184;
      if (D.24700 <= 2) goto <D.24690>; else goto <D.24701>;
      <D.24701>:
      D.24557 = ins->opcode;
      D.24702 = D.24557 + 65181;
      if (D.24702 <= 2) goto <D.24690>; else goto <D.24703>;
      <D.24703>:
      D.24557 = ins->opcode;
      D.24704 = D.24557 + 65190;
      if (D.24704 <= 2) goto <D.24690>; else goto <D.24705>;
      <D.24705>:
      D.24557 = ins->opcode;
      D.24706 = D.24557 + 65178;
      if (D.24706 <= 2) goto <D.24690>; else goto <D.24707>;
      <D.24707>:
      D.24557 = ins->opcode;
      if (D.24557 == 444) goto <D.24690>; else goto <D.24691>;
      <D.24690>:
      {
        struct MonoCallInst * call;
        struct GSList * list;

        call = ins;
        list = call->out_ireg_args;
        if (list != 0B) goto <D.24708>; else goto <D.24709>;
        <D.24708>:
        goto <D.23940>;
        <D.23939>:
        {
          guint32 regpair;
          int reg;
          int hreg;

          D.24710 = list->data;
          D.24711 = (long int) D.24710;
          regpair = (guint32) D.24711;
          D.24712 = regpair >> 24;
          hreg = (int) D.24712;
          regpair.16 = (int) regpair;
          reg = regpair.16 & 16777215;
          if (list != 0B) goto <D.24715>; else goto <D.24716>;
          <D.24715>:
          iftmp.17 = list->next;
          goto <D.24717>;
          <D.24716>:
          iftmp.17 = 0B;
          <D.24717>:
          list = iftmp.17;
        }
        <D.23940>:
        if (list != 0B) goto <D.23939>; else goto <D.23941>;
        <D.23941>:
        <D.24709>:
        list = call->out_freg_args;
        if (list != 0B) goto <D.24718>; else goto <D.24719>;
        <D.24718>:
        goto <D.23946>;
        <D.23945>:
        {
          guint32 regpair;
          int reg;
          int hreg;

          D.24710 = list->data;
          D.24711 = (long int) D.24710;
          regpair = (guint32) D.24711;
          D.24720 = regpair >> 24;
          hreg = (int) D.24720;
          regpair.18 = (int) regpair;
          reg = regpair.18 & 16777215;
          if (list != 0B) goto <D.24723>; else goto <D.24724>;
          <D.24723>:
          iftmp.19 = list->next;
          goto <D.24725>;
          <D.24724>:
          iftmp.19 = 0B;
          <D.24725>:
          list = iftmp.19;
        }
        <D.23946>:
        if (list != 0B) goto <D.23945>; else goto <D.23947>;
        <D.23947>:
        <D.24719>:
      }
      <D.24691>:
      <D.24695>:
      i = i + 1;
      ins = ins->next;
      <D.23949>:
      if (ins != 0B) goto <D.23948>; else goto <D.23950>;
      <D.23950>:
      tmp = &last;
      D.24553 = cfg->verbose_level;
      D.24585 = D.24553 > 2;
      D.24586 = (long int) D.24585;
      D.24587 = __builtin_expect (D.24586, 0);
      if (D.24587 != 0) goto <D.24726>; else goto <D.24727>;
      <D.24726>:
      D.24547 = rs->next_vreg;
      print_regtrack (reginfo, D.24547);
      <D.24727>:
      ins = bb->last_ins;
      if (ins != 0B) goto <D.24729>; else goto <D.24730>;
      <D.24729>:
      iftmp.20 = ins->prev;
      goto <D.24731>;
      <D.24730>:
      iftmp.20 = 0B;
      <D.24731>:
      prev = iftmp.20;
      goto <D.24079>;
      <D.24078>:
      {
        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.24557 = ins->opcode;
            D.24558 = (int) D.24557;
            D.24559 = D.24558 + -313;
            D.24560 = s390x_cpu_desc_idx[D.24559];
            D.24561 = (sizetype) D.24560;
            spec = &s390x_cpu_desc + D.24561;
            D.24732 = spec + 1;
            spec_src1 = *D.24732;
            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.23966>;
            <D.23965>:
            prev_sregs[j] = -1;
            D.24599 = j + 1;
            D.24600 = (sizetype) D.24599;
            D.24601 = spec + D.24600;
            D.24602 = *D.24601;
            D.24733 = get_callee_mask (D.24602);
            sreg_masks[j] = D.24733;
            D.24599 = j + 1;
            D.24600 = (sizetype) D.24599;
            D.24601 = spec + D.24600;
            D.24602 = *D.24601;
            D.24734 = (int) D.24602;
            D.24735 = desc_to_fixed_reg[D.24734];
            D.24736 = (int) D.24735;
            dest_sregs[j] = D.24736;
            sreg_fixed_masks[j] = 0;
            j = j + 1;
            <D.23966>:
            if (j <= 2) goto <D.23965>; else goto <D.23967>;
            <D.23967>:
            D.24553 = cfg->verbose_level;
            D.24585 = D.24553 > 2;
            D.24586 = (long int) D.24585;
            D.24587 = __builtin_expect (D.24586, 0);
            if (D.24587 != 0) goto <D.24737>; else goto <D.24738>;
            <D.24737>:
            printf ("processing:");
            <D.24738>:
            D.24553 = cfg->verbose_level;
            D.24585 = D.24553 > 2;
            D.24586 = (long int) D.24585;
            D.24587 = __builtin_expect (D.24586, 0);
            if (D.24587 != 0) goto <D.24739>; else goto <D.24740>;
            <D.24739>:
            mono_print_ins_index (i, ins);
            <D.24740>:
            ip = ins->cil_code;
            last = ins;
            D.24670 = (int) spec_dest;
            D.24671 = desc_to_fixed_reg[D.24670];
            dest_dreg = (int) D.24671;
            D.24692 = spec + 5;
            D.24693 = *D.24692;
            D.24741 = (int) D.24693;
            D.24742 = desc_to_fixed_reg[D.24741];
            clob_reg = (int) D.24742;
            D.24743 = sreg_masks[1];
            sreg_masks[1] = D.24743;
            dreg_fixed_mask = 0;
            D.24570 = ins->sreg1;
            sregs[0] = D.24570;
            D.24571 = ins->sreg2;
            sregs[1] = D.24571;
            D.24572 = ins->sreg3;
            sregs[2] = D.24572;
            D.24557 = ins->opcode;
            D.24558 = (int) D.24557;
            D.24559 = D.24558 + -313;
            D.24573 = ins_sreg_counts[D.24559];
            num_sregs = (int) D.24573;
            j = 1;
            goto <D.23998>;
            <D.23997>:
            {
              int sreg;
              int dest_sreg;

              sreg = sregs[j];
              dest_sreg = dest_sregs[j];
              if (dest_sreg == -1) goto <D.24744>; else goto <D.24745>;
              <D.24744>:
              // predicted unlikely by continue predictor.
              goto <D.23970>;
              <D.24745>:
              if (j == 2) goto <D.24746>; else goto <D.24747>;
              <D.24746>:
              {
                int k;

                D.24748 = 1 << dest_sreg;
                sreg_masks[j] = D.24748;
                k = 0;
                goto <D.23973>;
                <D.23972>:
                if (k != j) goto <D.24749>; else goto <D.24750>;
                <D.24749>:
                D.24751 = sreg_masks[k];
                D.24748 = 1 << dest_sreg;
                D.24752 = ~D.24748;
                D.24753 = D.24751 & D.24752;
                sreg_masks[k] = D.24753;
                <D.24750>:
                k = k + 1;
                <D.23973>:
                if (k < num_sregs) goto <D.23972>; else goto <D.23974>;
                <D.23974>:
                k = 0;
                goto <D.23976>;
                <D.23975>:
                if (k != j) goto <D.24754>; else goto <D.24755>;
                <D.24754>:
                D.24756 = sregs[k];
                if (D.24756 > 15) goto <D.24757>; else goto <D.24758>;
                <D.24757>:
                D.24636 = rs->vassign;
                D.24756 = sregs[k];
                D.24759 = (long unsigned int) D.24756;
                D.24760 = D.24759 * 4;
                D.24761 = D.24636 + D.24760;
                D.24762 = *D.24761;
                if (D.24762 == dest_sreg) goto <D.24763>; else goto <D.24764>;
                <D.24763>:
                free_up_hreg (cfg, bb, tmp, ins, dest_sreg, 0);
                <D.24764>:
                <D.24758>:
                <D.24755>:
                k = k + 1;
                <D.23976>:
                if (k < num_sregs) goto <D.23975>; else goto <D.23977>;
                <D.23977>:
                if (sreg > 15) goto <D.24765>; else goto <D.24766>;
                <D.24765>:
                D.24636 = rs->vassign;
                D.24767 = (long unsigned int) sreg;
                D.24768 = D.24767 * 4;
                D.24769 = D.24636 + D.24768;
                D.24770 = *D.24769;
                if (D.24770 >= 0) goto <D.24771>; else goto <D.24772>;
                <D.24771>:
                D.24636 = rs->vassign;
                D.24767 = (long unsigned int) sreg;
                D.24768 = D.24767 * 4;
                D.24769 = D.24636 + D.24768;
                D.24770 = *D.24769;
                if (D.24770 != dest_sreg) goto <D.24773>; else goto <D.24774>;
                <D.24773>:
                spill_vreg (cfg, bb, tmp, ins, sreg, 0);
                <D.24774>:
                <D.24772>:
                <D.24766>:
                // predicted unlikely by continue predictor.
                goto <D.23970>;
              }
              <D.24747>:
              D.24775 = rs->ifree_mask;
              D.24776 = D.24775 >> dest_sreg;
              D.24777 = D.24776 & 1;
              if (D.24777 != 0) goto <D.24778>; else goto <D.24779>;
              <D.24778>:
              if (0 != 0) goto <D.24780>; else goto <D.24781>;
              <D.24780>:
              {
                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.23981>;
                <D.23980>:
                if (k != j) goto <D.24782>; else goto <D.24783>;
                <D.24782>:
                D.24784 = sreg_masks[k];
                D.24748 = 1 << dest_sreg;
                D.24752 = ~D.24748;
                D.24785 = D.24784 & D.24752;
                sreg_masks[k] = D.24785;
                <D.24783>:
                k = k + 1;
                <D.23981>:
                if (k < num_sregs) goto <D.23980>; else goto <D.23982>;
                <D.23982>:
              }
              goto <D.24786>;
              <D.24781>:
              D.24636 = rs->vassign;
              D.24767 = (long unsigned int) sreg;
              D.24768 = D.24767 * 4;
              D.24769 = D.24636 + D.24768;
              val = *D.24769;
              if (val == -1) goto <D.24787>; else goto <D.24788>;
              <D.24787>:
              D.24553 = cfg->verbose_level;
              D.24585 = D.24553 > 2;
              D.24586 = (long int) D.24585;
              D.24587 = __builtin_expect (D.24586, 0);
              if (D.24587 != 0) goto <D.24789>; else goto <D.24790>;
              <D.24789>:
              D.24791 = mono_arch_regname (dest_sreg);
              printf ("\tshortcut assignment of R%d to %s\n", sreg, D.24791);
              <D.24790>:
              assign_reg (cfg, rs, sreg, dest_sreg, 0);
              goto <D.24792>;
              <D.24788>:
              if (val < -1) goto <D.24793>; else goto <D.24794>;
              <D.24793>:
              monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-codegen.c", 1459);
              <D.24794>:
              {
                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.23986>;
                <D.23985>:
                if (k != j) goto <D.24795>; else goto <D.24796>;
                <D.24795>:
                D.24797 = sreg_masks[k];
                D.24748 = 1 << dest_sreg;
                D.24752 = ~D.24748;
                D.24798 = D.24797 & D.24752;
                sreg_masks[k] = D.24798;
                <D.24796>:
                k = k + 1;
                <D.23986>:
                if (k < num_sregs) goto <D.23985>; else goto <D.23987>;
                <D.23987>:
                D.24748 = 1 << dest_sreg;
                D.24752 = ~D.24748;
                dreg_mask = D.24752 & dreg_mask;
              }
              <D.24792>:
              <D.24786>:
              goto <D.24799>;
              <D.24779>:
              {
                gboolean need_spill;
                gboolean need_assign;
                int k;

                need_spill = 1;
                need_assign = 1;
                D.24748 = 1 << dest_sreg;
                D.24752 = ~D.24748;
                dreg_mask = D.24752 & dreg_mask;
                k = 0;
                goto <D.23992>;
                <D.23991>:
                if (k != j) goto <D.24800>; else goto <D.24801>;
                <D.24800>:
                D.24802 = sreg_masks[k];
                D.24748 = 1 << dest_sreg;
                D.24752 = ~D.24748;
                D.24803 = D.24802 & D.24752;
                sreg_masks[k] = D.24803;
                <D.24801>:
                k = k + 1;
                <D.23992>:
                if (k < num_sregs) goto <D.23991>; else goto <D.23993>;
                <D.23993>:
                D.24654 = *spec;
                if (D.24654 != 0) goto <D.24804>; else goto <D.24805>;
                <D.24804>:
                D.24636 = rs->vassign;
                D.24562 = ins->dreg;
                D.24567 = (long unsigned int) D.24562;
                D.24664 = D.24567 * 4;
                D.24665 = D.24636 + D.24664;
                val = *D.24665;
                goto <D.24806>;
                <D.24805>:
                val = -1;
                <D.24806>:
                if (val == dest_sreg) goto <D.24807>; else goto <D.24808>;
                <D.24807>:
                D.24562 = ins->dreg;
                if (D.24562 != sreg) goto <D.24809>; else goto <D.24810>;
                <D.24809>:
                {
                  int new_dest;

                  D.24562 = ins->dreg;
                  D.24562 = ins->dreg;
                  D.24567 = (long unsigned int) D.24562;
                  D.24568 = D.24567 * 16;
                  D.24569 = reginfo + D.24568;
                  new_dest = alloc_int_reg (cfg, bb, tmp, ins, dreg_mask, D.24562, D.24569);
                  D.24811 = new_dest < 0;
                  D.24812 = (long int) D.24811;
                  D.24813 = __builtin_expect (D.24812, 0);
                  if (D.24813 != 0) goto <D.24814>; else goto <D.24815>;
                  <D.24814>:
                  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1505, "new_dest >= 0");
                  <D.24815>:
                  D.24553 = cfg->verbose_level;
                  D.24585 = D.24553 > 2;
                  D.24586 = (long int) D.24585;
                  D.24587 = __builtin_expect (D.24586, 0);
                  if (D.24587 != 0) goto <D.24816>; else goto <D.24817>;
                  <D.24816>:
                  D.24562 = ins->dreg;
                  D.24818 = mono_arch_regname (new_dest);
                  D.24819 = mono_arch_regname (dest_sreg);
                  printf ("\tchanging dreg R%d to %s from %s\n", D.24562, D.24818, D.24819);
                  <D.24817>:
                  prev_dreg = ins->dreg;
                  D.24562 = ins->dreg;
                  assign_reg (cfg, rs, D.24562, 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.24810>:
                <D.24808>:
                if (0 != 0) goto <D.24820>; else goto <D.24821>;
                <D.24820>:
                {
                  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.24822>;
                <D.24821>:
                D.24636 = rs->vassign;
                D.24767 = (long unsigned int) sreg;
                D.24768 = D.24767 * 4;
                D.24769 = D.24636 + D.24768;
                val = *D.24769;
                if (val == dest_sreg) goto <D.24823>; else goto <D.24824>;
                <D.24823>:
                need_spill = 0;
                goto <D.24825>;
                <D.24824>:
                if (val < -1) goto <D.24826>; else goto <D.24827>;
                <D.24826>:
                goto <D.24828>;
                <D.24827>:
                if (val >= 0) goto <D.24829>; else goto <D.24830>;
                <D.24829>:
                free_up_hreg (cfg, bb, tmp, ins, val, 0);
                <D.24830>:
                <D.24828>:
                <D.24825>:
                <D.24822>:
                if (need_spill != 0) goto <D.24831>; else goto <D.24832>;
                <D.24831>:
                free_up_hreg (cfg, bb, tmp, ins, dest_sreg, 0);
                <D.24832>:
                if (need_assign != 0) goto <D.24833>; else goto <D.24834>;
                <D.24833>:
                D.24636 = rs->vassign;
                D.24767 = (long unsigned int) sreg;
                D.24768 = D.24767 * 4;
                D.24769 = D.24636 + D.24768;
                D.24770 = *D.24769;
                if (D.24770 < -1) goto <D.24835>; else goto <D.24836>;
                <D.24835>:
                {
                  int spill;

                  D.24636 = rs->vassign;
                  D.24767 = (long unsigned int) sreg;
                  D.24768 = D.24767 * 4;
                  D.24769 = D.24636 + D.24768;
                  D.24770 = *D.24769;
                  spill = ~D.24770;
                  create_spilled_store (cfg, bb, spill, dest_sreg, sreg, tmp, 0B, ins, bank);
                }
                <D.24836>:
                D.24574 = sregs[j];
                assign_reg (cfg, rs, D.24574, dest_sreg, 0);
                <D.24834>:
              }
              <D.24799>:
              sregs[j] = dest_sreg;
            }
            <D.23970>:
            j = j + 1;
            <D.23998>:
            if (j < num_sregs) goto <D.23997>; else goto <D.23999>;
            <D.23999>:
            mono_inst_set_src_registers (ins, &sregs);
            D.24654 = *spec;
            D.24655 = D.24654 + 154;
            D.24656 = D.24655 <= 1;
            bank = (int) D.24656;
            if (spec_dest != 0) goto <D.24837>; else goto <D.24838>;
            <D.24837>:
            D.24613 = bank != 0;
            D.24614 = (long int) D.24613;
            D.24615 = __builtin_expect (D.24614, 0);
            if (D.24615 != 0) goto <D.24840>; else goto <D.24841>;
            <D.24840>:
            D.24562 = ins->dreg;
            if (D.24562 < 0) goto <D.24843>; else goto <D.24846>;
            <D.24846>:
            D.24562 = ins->dreg;
            D.24623 = regbank_size[bank];
            if (D.24562 >= D.24623) goto <D.24843>; else goto <D.24844>;
            <D.24843>:
            iftmp.22 = 1;
            goto <D.24845>;
            <D.24844>:
            iftmp.22 = 0;
            <D.24845>:
            iftmp.21 = (_Bool) iftmp.22;
            goto <D.24847>;
            <D.24841>:
            D.24562 = ins->dreg;
            iftmp.21 = D.24562 > 15;
            <D.24847>:
            if (iftmp.21 != 0) goto <D.24848>; else goto <D.24849>;
            <D.24848>:
            prev_dreg = ins->dreg;
            <D.24849>:
            <D.24838>:
            if (spec_dest == 98) goto <D.24850>; else goto <D.24851>;
            <D.24850>:
            D.24852 = dest_sregs[0];
            if (D.24852 != -1) goto <D.24853>; else goto <D.24854>;
            <D.24853>:
            D.24852 = dest_sregs[0];
            D.24855 = 1 << D.24852;
            D.24856 = ~D.24855;
            dreg_mask = D.24856 & dreg_mask;
            <D.24854>:
            j = 1;
            goto <D.24001>;
            <D.24000>:
            D.24857 = dest_sregs[j];
            if (D.24857 != -1) goto <D.24858>; else goto <D.24859>;
            <D.24858>:
            D.24857 = dest_sregs[j];
            D.24860 = 1 << D.24857;
            D.24861 = ~D.24860;
            dreg_mask = D.24861 & dreg_mask;
            <D.24859>:
            j = j + 1;
            <D.24001>:
            if (j < num_sregs) goto <D.24000>; else goto <D.24002>;
            <D.24002>:
            D.24636 = rs->vassign;
            D.24562 = ins->dreg;
            D.24567 = (long unsigned int) D.24562;
            D.24664 = D.24567 * 4;
            D.24665 = D.24636 + D.24664;
            val = *D.24665;
            D.24613 = bank != 0;
            D.24614 = (long int) D.24613;
            D.24615 = __builtin_expect (D.24614, 0);
            if (D.24615 != 0) goto <D.24863>; else goto <D.24864>;
            <D.24863>:
            D.24562 = ins->dreg;
            if (D.24562 < 0) goto <D.24866>; else goto <D.24869>;
            <D.24869>:
            D.24562 = ins->dreg;
            D.24623 = regbank_size[bank];
            if (D.24562 >= D.24623) goto <D.24866>; else goto <D.24867>;
            <D.24866>:
            iftmp.24 = 1;
            goto <D.24868>;
            <D.24867>:
            iftmp.24 = 0;
            <D.24868>:
            iftmp.23 = (_Bool) iftmp.24;
            goto <D.24870>;
            <D.24864>:
            D.24562 = ins->dreg;
            iftmp.23 = D.24562 > 15;
            <D.24870>:
            if (iftmp.23 != 0) goto <D.24871>; else goto <D.24872>;
            <D.24871>:
            if (val >= 0) goto <D.24873>; else goto <D.24874>;
            <D.24873>:
            D.24875 = dreg_mask >> val;
            D.24876 = D.24875 & 1;
            if (D.24876 == 0) goto <D.24877>; else goto <D.24878>;
            <D.24877>:
            D.24562 = ins->dreg;
            spill_vreg (cfg, bb, tmp, ins, D.24562, 0);
            <D.24878>:
            <D.24874>:
            <D.24872>:
            <D.24851>:
            if (0 != 0) goto <D.24879>; else goto <D.24880>;
            <D.24879>:
            {
              guint32 dreg2;
              guint32 dest_dreg2;

              D.24613 = bank != 0;
              D.24614 = (long int) D.24613;
              D.24615 = __builtin_expect (D.24614, 0);
              if (D.24615 != 0) goto <D.24882>; else goto <D.24883>;
              <D.24882>:
              D.24562 = ins->dreg;
              if (D.24562 >= 0) goto <D.24887>; else goto <D.24885>;
              <D.24887>:
              D.24562 = ins->dreg;
              D.24623 = regbank_size[bank];
              if (D.24562 < D.24623) goto <D.24888>; else goto <D.24885>;
              <D.24888>:
              iftmp.26 = 1;
              goto <D.24886>;
              <D.24885>:
              iftmp.26 = 0;
              <D.24886>:
              D.24889 = iftmp.26 != 0;
              D.24890 = (int) D.24889;
              iftmp.25 = (long int) D.24890;
              goto <D.24891>;
              <D.24883>:
              D.24562 = ins->dreg;
              D.24892 = D.24562 <= 15;
              D.24893 = (int) D.24892;
              iftmp.25 = (long int) D.24893;
              <D.24891>:
              D.24894 = __builtin_expect (iftmp.25, 0);
              if (D.24894 != 0) goto <D.24895>; else goto <D.24896>;
              <D.24895>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1594, "is_soft_reg (ins->dreg, bank)");
              <D.24896>:
              if (dest_dreg != -1) goto <D.24897>; else goto <D.24898>;
              <D.24897>:
              D.24636 = rs->vassign;
              D.24562 = ins->dreg;
              D.24567 = (long unsigned int) D.24562;
              D.24664 = D.24567 * 4;
              D.24665 = D.24636 + D.24664;
              D.24899 = *D.24665;
              if (D.24899 != dest_dreg) goto <D.24900>; else goto <D.24901>;
              <D.24900>:
              free_up_hreg (cfg, bb, tmp, ins, dest_dreg, 0);
              <D.24901>:
              D.24562 = ins->dreg;
              D.24902 = D.24562 + 1;
              dreg2 = (guint32) D.24902;
              dest_dreg2 = 4294967295;
              if (dest_dreg2 != 4294967295) goto <D.24903>; else goto <D.24904>;
              <D.24903>:
              D.24636 = rs->vassign;
              D.24905 = (long unsigned int) dreg2;
              D.24906 = D.24905 * 4;
              D.24907 = D.24636 + D.24906;
              D.24908 = *D.24907;
              D.24909 = (unsigned int) D.24908;
              if (D.24909 != dest_dreg2) goto <D.24910>; else goto <D.24911>;
              <D.24910>:
              dest_dreg2.27 = (int) dest_dreg2;
              free_up_hreg (cfg, bb, tmp, ins, dest_dreg2.27, 0);
              <D.24911>:
              <D.24904>:
              <D.24898>:
            }
            <D.24880>:
            if (dreg_fixed_mask != 0) goto <D.24913>; else goto <D.24914>;
            <D.24913>:
            D.24613 = bank != 0;
            D.24614 = (long int) D.24613;
            D.24615 = __builtin_expect (D.24614, 0);
            if (D.24615 != 0) goto <D.24915>; else goto <D.24916>;
            <D.24915>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1610, "!bank");
            <D.24916>:
            if (0 != 0) goto <D.24917>; else goto <D.24918>;
            <D.24917>:
            val = mono_regstate_alloc_int (rs, dreg_fixed_mask);
            if (val < 0) goto <D.24919>; else goto <D.24920>;
            <D.24919>:
            val = get_register_spilling (cfg, bb, tmp, ins, dreg_fixed_mask, -1, bank);
            <D.24920>:
            mono_regstate_free_int (rs, val);
            dest_dreg = val;
            goto <D.24921>;
            <D.24918>:
            dreg_mask = dreg_mask & dreg_fixed_mask;
            <D.24921>:
            <D.24914>:
            D.24613 = bank != 0;
            D.24614 = (long int) D.24613;
            D.24615 = __builtin_expect (D.24614, 0);
            if (D.24615 != 0) goto <D.24923>; else goto <D.24924>;
            <D.24923>:
            D.24562 = ins->dreg;
            if (D.24562 < 0) goto <D.24926>; else goto <D.24929>;
            <D.24929>:
            D.24562 = ins->dreg;
            D.24623 = regbank_size[bank];
            if (D.24562 >= D.24623) goto <D.24926>; else goto <D.24927>;
            <D.24926>:
            iftmp.29 = 1;
            goto <D.24928>;
            <D.24927>:
            iftmp.29 = 0;
            <D.24928>:
            iftmp.28 = (_Bool) iftmp.29;
            goto <D.24930>;
            <D.24924>:
            D.24562 = ins->dreg;
            iftmp.28 = D.24562 > 15;
            <D.24930>:
            if (iftmp.28 != 0) goto <D.24931>; else goto <D.24932>;
            <D.24931>:
            D.24636 = rs->vassign;
            D.24562 = ins->dreg;
            D.24567 = (long unsigned int) D.24562;
            D.24664 = D.24567 * 4;
            D.24665 = D.24636 + D.24664;
            val = *D.24665;
            if (val < 0) goto <D.24933>; else goto <D.24934>;
            <D.24933>:
            {
              int spill;

              spill = 0;
              if (val < -1) goto <D.24935>; else goto <D.24936>;
              <D.24935>:
              spill = ~val;
              <D.24936>:
              D.24562 = ins->dreg;
              D.24562 = ins->dreg;
              D.24567 = (long unsigned int) D.24562;
              D.24568 = D.24567 * 16;
              D.24569 = reginfo + D.24568;
              val = alloc_reg (cfg, bb, tmp, ins, dreg_mask, D.24562, D.24569, bank);
              D.24562 = ins->dreg;
              assign_reg (cfg, rs, D.24562, val, bank);
              if (spill != 0) goto <D.24937>; else goto <D.24938>;
              <D.24937>:
              create_spilled_store (cfg, bb, spill, val, prev_dreg, tmp, ins, 0B, bank);
              <D.24938>:
            }
            <D.24934>:
            D.24553 = cfg->verbose_level;
            D.24585 = D.24553 > 2;
            D.24586 = (long int) D.24585;
            D.24587 = __builtin_expect (D.24586, 0);
            if (D.24587 != 0) goto <D.24939>; else goto <D.24940>;
            <D.24939>:
            D.24941 = mono_regname_full (val, bank);
            D.24562 = ins->dreg;
            printf ("\tassigned dreg %s to dest R%d\n", D.24941, D.24562);
            <D.24940>:
            ins->dreg = val;
            <D.24932>:
            if (0 != 0) goto <D.24942>; else goto <D.24943>;
            <D.24942>:
            {
              int reg2;

              reg2 = prev_dreg + 1;
              D.24613 = bank != 0;
              D.24614 = (long int) D.24613;
              D.24615 = __builtin_expect (D.24614, 0);
              if (D.24615 != 0) goto <D.24944>; else goto <D.24945>;
              <D.24944>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1651, "!bank");
              <D.24945>:
              D.24946 = prev_dreg < 0;
              D.24947 = (long int) D.24946;
              D.24948 = __builtin_expect (D.24947, 0);
              if (D.24948 != 0) goto <D.24949>; else goto <D.24950>;
              <D.24949>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1652, "prev_dreg > -1");
              <D.24950>:
              if (0 != 0) goto <D.24951>; else goto <D.24952>;
              <D.24951>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1653, "!is_global_ireg (rs->vassign [prev_dreg])");
              <D.24952>:
              mask = 252;
              D.24636 = rs->vassign;
              D.24953 = (long unsigned int) reg2;
              D.24954 = D.24953 * 4;
              D.24955 = D.24636 + D.24954;
              val = *D.24955;
              if (val < 0) goto <D.24956>; else goto <D.24957>;
              <D.24956>:
              {
                int spill;

                spill = 0;
                if (val < -1) goto <D.24958>; else goto <D.24959>;
                <D.24958>:
                spill = ~val;
                <D.24959>:
                val = mono_regstate_alloc_int (rs, mask);
                if (val < 0) goto <D.24960>; else goto <D.24961>;
                <D.24960>:
                val = get_register_spilling (cfg, bb, tmp, ins, mask, reg2, bank);
                <D.24961>:
                if (spill != 0) goto <D.24962>; else goto <D.24963>;
                <D.24962>:
                create_spilled_store (cfg, bb, spill, val, reg2, tmp, ins, 0B, bank);
                <D.24963>:
              }
              goto <D.24964>;
              <D.24957>:
              D.24965 = mask >> val;
              D.24966 = D.24965 & 1;
              if (D.24966 == 0) goto <D.24967>; else goto <D.24968>;
              <D.24967>:
              val = mono_regstate_alloc_int (rs, mask);
              if (val < 0) goto <D.24969>; else goto <D.24970>;
              <D.24969>:
              val = get_register_spilling (cfg, bb, tmp, ins, mask, reg2, bank);
              <D.24970>:
              D.24636 = rs->vassign;
              D.24953 = (long unsigned int) reg2;
              D.24954 = D.24953 * 4;
              D.24955 = D.24636 + D.24954;
              D.24971 = *D.24955;
              create_copy_ins (cfg, bb, tmp, D.24971, val, ins, ip, bank);
              D.24636 = rs->vassign;
              D.24953 = (long unsigned int) reg2;
              D.24954 = D.24953 * 4;
              D.24955 = D.24636 + D.24954;
              D.24971 = *D.24955;
              mono_regstate_free_int (rs, D.24971);
              <D.24968>:
              <D.24964>:
              D.24553 = cfg->verbose_level;
              D.24585 = D.24553 > 2;
              D.24586 = (long int) D.24585;
              D.24587 = __builtin_expect (D.24586, 0);
              if (D.24587 != 0) goto <D.24972>; else goto <D.24973>;
              <D.24972>:
              D.24974 = mono_arch_regname (val);
              printf ("\tassigned dreg-high %s to dest R%d\n", D.24974, reg2);
              <D.24973>:
              assign_reg (cfg, rs, reg2, val, bank);
              dreg_high = val;
              ins->backend.reg3 = val;
              D.24613 = bank != 0;
              D.24614 = (long int) D.24613;
              D.24615 = __builtin_expect (D.24614, 0);
              if (D.24615 != 0) goto <D.24976>; else goto <D.24977>;
              <D.24976>:
              D.24613 = bank != 0;
              D.24614 = (long int) D.24613;
              D.24615 = __builtin_expect (D.24614, 0);
              if (D.24615 != 0) goto <D.24981>; else goto <D.24982>;
              <D.24981>:
              if (val >= 0) goto <D.24986>; else goto <D.24984>;
              <D.24986>:
              D.24623 = regbank_size[bank];
              if (D.24623 > val) goto <D.24987>; else goto <D.24984>;
              <D.24987>:
              iftmp.32 = 1;
              goto <D.24985>;
              <D.24984>:
              iftmp.32 = 0;
              <D.24985>:
              D.24988 = (_Bool) iftmp.32;
              if (D.24988 != 0) goto <D.24989>; else goto <D.24979>;
              <D.24989>:
              goto <D.24990>;
              <D.24982>:
              if (val <= 15) goto <D.24991>; else goto <D.24979>;
              <D.24991>:
              <D.24990>:
              D.24992 = regbank_callee_regs[bank];
              D.24993 = D.24992 >> val;
              D.24994 = D.24993 & 1;
              if (D.24994 != 0) goto <D.24995>; else goto <D.24979>;
              <D.24995>:
              iftmp.31 = 1;
              goto <D.24980>;
              <D.24979>:
              iftmp.31 = 0;
              <D.24980>:
              iftmp.30 = (_Bool) iftmp.31;
              goto <D.24996>;
              <D.24977>:
              val.34 = (unsigned int) val;
              if (val.34 <= 15) goto <D.25001>; else goto <D.24998>;
              <D.25001>:
              D.25002 = 252 >> val;
              D.25003 = D.25002 & 1;
              if (D.25003 != 0) goto <D.25004>; else goto <D.24998>;
              <D.25004>:
              iftmp.33 = 1;
              goto <D.24999>;
              <D.24998>:
              iftmp.33 = 0;
              <D.24999>:
              iftmp.30 = (_Bool) iftmp.33;
              <D.24996>:
              if (iftmp.30 != 0) goto <D.25005>; else goto <D.25006>;
              <D.25005>:
              if (reg2 >= 0) goto <D.25007>; else goto <D.25008>;
              <D.25007>:
              D.24953 = (long unsigned int) reg2;
              D.25009 = D.24953 * 16;
              D.25010 = reginfo + D.25009;
              D.25011 = D.25010->born_in;
              if (D.25011 >= i) goto <D.25012>; else goto <D.25013>;
              <D.25012>:
              D.24553 = cfg->verbose_level;
              D.24585 = D.24553 > 2;
              D.24586 = (long int) D.24585;
              D.24587 = __builtin_expect (D.24586, 0);
              if (D.24587 != 0) goto <D.25014>; else goto <D.25015>;
              <D.25014>:
              D.25016 = mono_arch_regname (val);
              printf ("\tfreeable %s (R%d)\n", D.25016, reg2);
              <D.25015>:
              mono_regstate_free_int (rs, val);
              <D.25013>:
              <D.25008>:
              <D.25006>:
            }
            <D.24943>:
            if (prev_dreg >= 0) goto <D.25017>; else goto <D.25018>;
            <D.25017>:
            D.24613 = bank != 0;
            D.24614 = (long int) D.24613;
            D.24615 = __builtin_expect (D.24614, 0);
            if (D.24615 != 0) goto <D.25020>; else goto <D.25021>;
            <D.25020>:
            if (prev_dreg < 0) goto <D.25023>; else goto <D.25026>;
            <D.25026>:
            D.24623 = regbank_size[bank];
            if (D.24623 <= prev_dreg) goto <D.25023>; else goto <D.25024>;
            <D.25023>:
            iftmp.36 = 1;
            goto <D.25025>;
            <D.25024>:
            iftmp.36 = 0;
            <D.25025>:
            iftmp.35 = (_Bool) iftmp.36;
            goto <D.25027>;
            <D.25021>:
            iftmp.35 = prev_dreg > 15;
            <D.25027>:
            if (iftmp.35 != 0) goto <D.25028>; else goto <D.25029>;
            <D.25028>:
            if (spec_dest != 98) goto <D.25030>; else goto <D.25031>;
            <D.25030>:
            {
              int dreg;

              D.24636 = rs->vassign;
              D.25032 = (long unsigned int) prev_dreg;
              D.25033 = D.25032 * 4;
              D.25034 = D.24636 + D.25033;
              dreg = *D.25034;
              D.25035 = dreg < 0;
              D.25036 = (long int) D.25035;
              D.25037 = __builtin_expect (D.25036, 0);
              if (D.25037 != 0) goto <D.25038>; else goto <D.25039>;
              <D.25038>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1704, "dreg >= 0");
              <D.25039>:
              D.24553 = cfg->verbose_level;
              D.24585 = D.24553 > 2;
              D.24586 = (long int) D.24585;
              D.24587 = __builtin_expect (D.24586, 0);
              if (D.24587 != 0) goto <D.25040>; else goto <D.25041>;
              <D.25040>:
              D.25042 = mono_regname_full (dreg, bank);
              D.25032 = (long unsigned int) prev_dreg;
              D.25043 = D.25032 * 16;
              D.25044 = reginfo + D.25043;
              D.25045 = D.25044->born_in;
              printf ("\tfreeable %s (R%d) (born in %d)\n", D.25042, prev_dreg, D.25045);
              <D.25041>:
              D.24613 = bank != 0;
              D.24614 = (long int) D.24613;
              D.24615 = __builtin_expect (D.24614, 0);
              if (D.24615 != 0) goto <D.25046>; else goto <D.25047>;
              <D.25046>:
              mono_regstate_free_general (rs, dreg, bank);
              goto <D.25048>;
              <D.25047>:
              mono_regstate_free_int (rs, dreg);
              <D.25048>:
              D.24636 = rs->vassign;
              D.25032 = (long unsigned int) prev_dreg;
              D.25033 = D.25032 * 4;
              D.25034 = D.24636 + D.25033;
              *D.25034 = -1;
            }
            <D.25031>:
            <D.25029>:
            <D.25018>:
            if (dest_dreg != -1) goto <D.25049>; else goto <D.25050>;
            <D.25049>:
            D.24562 = ins->dreg;
            if (D.24562 != dest_dreg) goto <D.25051>; else goto <D.25052>;
            <D.25051>:
            D.24562 = ins->dreg;
            create_copy_ins (cfg, bb, tmp, D.24562, dest_dreg, ins, ip, bank);
            ins->dreg = dest_dreg;
            D.24613 = bank != 0;
            D.24614 = (long int) D.24613;
            D.24615 = __builtin_expect (D.24614, 0);
            if (D.24615 != 0) goto <D.25053>; else goto <D.25054>;
            <D.25053>:
            {
              int translated_bank;

              D.25055 = cfg->rs;
              translated_bank = translate_bank (D.25055, bank, dest_dreg);
              D.25056 = rs->symbolic[translated_bank];
              D.25057 = (long unsigned int) dest_dreg;
              D.25058 = D.25057 * 4;
              D.25059 = D.25056 + D.25058;
              D.25060 = *D.25059;
              D.25061 = regbank_size[translated_bank];
              if (D.25060 >= D.25061) goto <D.25062>; else goto <D.25063>;
              <D.25062>:
              free_up_hreg (cfg, bb, tmp, ins, dest_dreg, translated_bank);
              <D.25063>:
            }
            goto <D.25064>;
            <D.25054>:
            D.25065 = rs->isymbolic[dest_dreg];
            if (D.25065 > 15) goto <D.25066>; else goto <D.25067>;
            <D.25066>:
            free_up_hreg (cfg, bb, tmp, ins, dest_dreg, bank);
            <D.25067>:
            <D.25064>:
            <D.25052>:
            <D.25050>:
            if (spec_dest == 98) goto <D.25068>; else goto <D.25069>;
            <D.25068>:
            j = 0;
            goto <D.24011>;
            <D.24010>:
            D.24599 = j + 1;
            D.24600 = (sizetype) D.24599;
            D.24601 = spec + D.24600;
            D.24602 = *D.24601;
            D.24605 = D.24602 + 154;
            if (D.24605 > 1) goto <D.25070>; else goto <D.25071>;
            <D.25070>:
            D.25072 = sreg_masks[j];
            D.24562 = ins->dreg;
            D.25073 = 1 << D.24562;
            D.25074 = ~D.25073;
            D.25075 = D.25072 & D.25074;
            sreg_masks[j] = D.25075;
            <D.25071>:
            j = j + 1;
            <D.24011>:
            if (j < num_sregs) goto <D.24010>; else goto <D.24012>;
            <D.24012>:
            <D.25069>:
            if (clob_reg != -1) goto <D.25076>; else goto <D.25077>;
            <D.25076>:
            D.24775 = rs->ifree_mask;
            D.25078 = D.24775 >> clob_reg;
            D.25079 = D.25078 & 1;
            if (D.25079 == 0) goto <D.25080>; else goto <D.25081>;
            <D.25080>:
            D.24553 = cfg->verbose_level;
            D.24585 = D.24553 > 2;
            D.24586 = (long int) D.24585;
            D.24587 = __builtin_expect (D.24586, 0);
            if (D.24587 != 0) goto <D.25082>; else goto <D.25083>;
            <D.25082>:
            D.25084 = rs->isymbolic[clob_reg];
            printf ("\tforced spill of clobbered reg R%d\n", D.25084);
            <D.25083>:
            free_up_hreg (cfg, bb, tmp, ins, clob_reg, 0);
            <D.25081>:
            <D.25077>:
            D.24692 = spec + 5;
            D.24693 = *D.24692;
            if (D.24693 == 99) goto <D.25085>; else goto <D.25086>;
            <D.25085>:
            {
              int j;
              int s;
              int dreg;
              int dreg2;
              int cur_bank;
              guint64 clob_mask;

              clob_mask = 252;
              D.24775 = rs->ifree_mask;
              if (D.24775 != 252) goto <D.25087>; else goto <D.25088>;
              <D.25087>:
              if (prev_dreg != -1) goto <D.25091>; else goto <D.25089>;
              <D.25091>:
              D.25092 = spec_dest + 154;
              if (D.25092 > 1) goto <D.25093>; else goto <D.25089>;
              <D.25093>:
              D.24636 = rs->vassign;
              D.25032 = (long unsigned int) prev_dreg;
              D.25033 = D.25032 * 4;
              D.25034 = D.24636 + D.25033;
              dreg = *D.25034;
              goto <D.25090>;
              <D.25089>:
              dreg = -1;
              <D.25090>:
              if (0 != 0) goto <D.25094>; else goto <D.25095>;
              <D.25094>:
              D.24636 = rs->vassign;
              D.25096 = (sizetype) prev_dreg;
              D.25097 = D.25096 + 1;
              D.25098 = D.25097 * 4;
              D.25099 = D.24636 + D.25098;
              dreg2 = *D.25099;
              goto <D.25100>;
              <D.25095>:
              dreg2 = -1;
              <D.25100>:
              j = 0;
              goto <D.24020>;
              <D.24019>:
              D.25101 = 1 << j;
              s = (int) D.25101;
              D.25102 = (long unsigned int) s;
              D.25103 = D.25102 & clob_mask;
              if (D.25103 != 0) goto <D.25104>; else goto <D.25105>;
              <D.25104>:
              D.24775 = rs->ifree_mask;
              D.25106 = (long unsigned int) s;
              D.25107 = D.24775 & D.25106;
              if (D.25107 == 0) goto <D.25108>; else goto <D.25109>;
              <D.25108>:
              D.24570 = ins->sreg1;
              if (D.24570 != j) goto <D.25110>; else goto <D.25111>;
              <D.25110>:
              if (j != dreg) goto <D.25114>; else goto <D.25112>;
              <D.25114>:
              if (j != dreg2) goto <D.25115>; else goto <D.25112>;
              <D.25115>:
              free_up_hreg (cfg, bb, tmp, ins, j, 0);
              goto <D.25113>;
              <D.25112>:
              D.25116 = rs->isymbolic[j];
              if (D.25116 != 0) goto <D.25117>; else goto <D.25118>;
              <D.25117>:
              D.24636 = rs->vassign;
              D.25116 = rs->isymbolic[j];
              D.25119 = (long unsigned int) D.25116;
              D.25120 = D.25119 * 4;
              D.25121 = D.24636 + D.25120;
              *D.25121 = -1;
              <D.25118>:
              <D.25113>:
              mono_regstate_free_int (rs, j);
              <D.25111>:
              <D.25109>:
              <D.25105>:
              j = j + 1;
              <D.24020>:
              if (j <= 15) goto <D.24019>; else goto <D.24021>;
              <D.24021>:
              <D.25088>:
              cur_bank = 1;
              goto <D.24027>;
              <D.24026>:
              D.25122 = rs->free_mask[cur_bank];
              D.25123 = regbank_callee_regs[cur_bank];
              if (D.25122 != D.25123) goto <D.25124>; else goto <D.25125>;
              <D.25124>:
              clob_mask = regbank_callee_regs[cur_bank];
              if (prev_dreg != -1) goto <D.25128>; else goto <D.25126>;
              <D.25128>:
              D.25092 = spec_dest + 154;
              if (D.25092 <= 1) goto <D.25129>; else goto <D.25126>;
              <D.25129>:
              D.24636 = rs->vassign;
              D.25032 = (long unsigned int) prev_dreg;
              D.25033 = D.25032 * 4;
              D.25034 = D.24636 + D.25033;
              dreg = *D.25034;
              goto <D.25127>;
              <D.25126>:
              dreg = -1;
              <D.25127>:
              j = 0;
              goto <D.24024>;
              <D.24023>:
              if (0 != 0) goto <D.25130>; else goto <D.25131>;
              <D.25130>:
              // predicted unlikely by continue predictor.
              goto <D.24022>;
              <D.25131>:
              D.25101 = 1 << j;
              s = (int) D.25101;
              D.25102 = (long unsigned int) s;
              D.25103 = D.25102 & clob_mask;
              if (D.25103 != 0) goto <D.25132>; else goto <D.25133>;
              <D.25132>:
              D.25122 = rs->free_mask[cur_bank];
              D.25106 = (long unsigned int) s;
              D.25134 = D.25122 & D.25106;
              if (D.25134 == 0) goto <D.25135>; else goto <D.25136>;
              <D.25135>:
              if (j != dreg) goto <D.25137>; else goto <D.25138>;
              <D.25137>:
              free_up_hreg (cfg, bb, tmp, ins, j, cur_bank);
              goto <D.25139>;
              <D.25138>:
              D.25140 = rs->symbolic[cur_bank];
              D.25141 = (long unsigned int) j;
              D.25142 = D.25141 * 4;
              D.25143 = D.25140 + D.25142;
              D.25144 = *D.25143;
              if (D.25144 != 0) goto <D.25145>; else goto <D.25146>;
              <D.25145>:
              D.24636 = rs->vassign;
              D.25140 = rs->symbolic[cur_bank];
              D.25141 = (long unsigned int) j;
              D.25142 = D.25141 * 4;
              D.25143 = D.25140 + D.25142;
              D.25144 = *D.25143;
              D.25147 = (long unsigned int) D.25144;
              D.25148 = D.25147 * 4;
              D.25149 = D.24636 + D.25148;
              *D.25149 = -1;
              <D.25146>:
              <D.25139>:
              mono_regstate_free_general (rs, j, cur_bank);
              <D.25136>:
              <D.25133>:
              <D.24022>:
              j = j + 1;
              <D.24024>:
              D.25150 = regbank_size[cur_bank];
              if (D.25150 > j) goto <D.24023>; else goto <D.24025>;
              <D.24025>:
              <D.25125>:
              cur_bank = cur_bank + 1;
              <D.24027>:
              if (cur_bank <= 3) goto <D.24026>; else goto <D.24028>;
              <D.24028>:
            }
            <D.25086>:
            D.24692 = spec + 5;
            D.24693 = *D.24692;
            if (D.24693 == 99) goto <D.25153>; else goto <D.25154>;
            <D.25153>:
            D.24557 = ins->opcode;
            D.24696 = D.24557 + 65193;
            if (D.24696 <= 2) goto <D.25151>; else goto <D.25155>;
            <D.25155>:
            D.24557 = ins->opcode;
            D.24698 = D.24557 + 65187;
            if (D.24698 <= 2) goto <D.25151>; else goto <D.25156>;
            <D.25156>:
            D.24557 = ins->opcode;
            D.24700 = D.24557 + 65184;
            if (D.24700 <= 2) goto <D.25151>; else goto <D.25157>;
            <D.25157>:
            D.24557 = ins->opcode;
            D.24702 = D.24557 + 65181;
            if (D.24702 <= 2) goto <D.25151>; else goto <D.25158>;
            <D.25158>:
            D.24557 = ins->opcode;
            D.24704 = D.24557 + 65190;
            if (D.24704 <= 2) goto <D.25151>; else goto <D.25159>;
            <D.25159>:
            D.24557 = ins->opcode;
            D.24706 = D.24557 + 65178;
            if (D.24706 <= 2) goto <D.25151>; else goto <D.25160>;
            <D.25160>:
            D.24557 = ins->opcode;
            if (D.24557 == 444) goto <D.25151>; else goto <D.25152>;
            <D.25151>:
            {
              struct MonoCallInst * call;
              struct GSList * list;

              call = ins;
              list = call->out_ireg_args;
              if (list != 0B) goto <D.25161>; else goto <D.25162>;
              <D.25161>:
              goto <D.24035>;
              <D.24034>:
              {
                guint32 regpair;
                int reg;
                int hreg;

                D.25163 = list->data;
                D.25164 = (long int) D.25163;
                regpair = (guint32) D.25164;
                D.25165 = regpair >> 24;
                hreg = (int) D.25165;
                regpair.37 = (int) regpair;
                reg = regpair.37 & 16777215;
                assign_reg (cfg, rs, reg, hreg, 0);
                D.25167 = sreg_masks[0];
                D.25168 = 1 << hreg;
                D.25169 = ~D.25168;
                D.25170 = D.25167 & D.25169;
                sreg_masks[0] = D.25170;
                D.24553 = cfg->verbose_level;
                D.24585 = D.24553 > 2;
                D.24586 = (long int) D.24585;
                D.24587 = __builtin_expect (D.24586, 0);
                if (D.24587 != 0) goto <D.25171>; else goto <D.25172>;
                <D.25171>:
                D.25173 = mono_arch_regname (hreg);
                printf ("\tassigned arg reg %s to R%d\n", D.25173, reg);
                <D.25172>:
                if (list != 0B) goto <D.25175>; else goto <D.25176>;
                <D.25175>:
                iftmp.38 = list->next;
                goto <D.25177>;
                <D.25176>:
                iftmp.38 = 0B;
                <D.25177>:
                list = iftmp.38;
              }
              <D.24035>:
              if (list != 0B) goto <D.24034>; else goto <D.24036>;
              <D.24036>:
              <D.25162>:
              list = call->out_freg_args;
              if (list != 0B) goto <D.25178>; else goto <D.25179>;
              <D.25178>:
              goto <D.24041>;
              <D.24040>:
              {
                guint32 regpair;
                int reg;
                int hreg;

                D.25163 = list->data;
                D.25164 = (long int) D.25163;
                regpair = (guint32) D.25164;
                D.25180 = regpair >> 24;
                hreg = (int) D.25180;
                regpair.39 = (int) regpair;
                reg = regpair.39 & 16777215;
                assign_reg (cfg, rs, reg, hreg, 1);
                D.24553 = cfg->verbose_level;
                D.24585 = D.24553 > 2;
                D.24586 = (long int) D.24585;
                D.24587 = __builtin_expect (D.24586, 0);
                if (D.24587 != 0) goto <D.25182>; else goto <D.25183>;
                <D.25182>:
                D.25184 = mono_regname_full (hreg, 1);
                printf ("\tassigned arg reg %s to R%d\n", D.25184, reg);
                <D.25183>:
                if (list != 0B) goto <D.25186>; else goto <D.25187>;
                <D.25186>:
                iftmp.40 = list->next;
                goto <D.25188>;
                <D.25187>:
                iftmp.40 = 0B;
                <D.25188>:
                list = iftmp.40;
              }
              <D.24041>:
              if (list != 0B) goto <D.24040>; else goto <D.24042>;
              <D.24042>:
              <D.25179>:
            }
            <D.25152>:
            <D.25154>:
            D.24732 = spec + 1;
            D.25189 = *D.24732;
            D.25190 = D.25189 + 154;
            D.25191 = D.25190 <= 1;
            bank = (int) D.25191;
            if (0 != 0) goto <D.25192>; else goto <D.25193>;
            <D.25192>:
            {
              int sreg1;
              int dest_sreg1;

              sreg1 = sregs[0];
              dest_sreg1 = dest_sregs[0];
              D.24613 = bank != 0;
              D.24614 = (long int) D.24613;
              D.24615 = __builtin_expect (D.24614, 0);
              if (D.24615 != 0) goto <D.25195>; else goto <D.25196>;
              <D.25195>:
              if (sreg1 >= 0) goto <D.25200>; else goto <D.25198>;
              <D.25200>:
              D.24623 = regbank_size[bank];
              if (D.24623 > sreg1) goto <D.25201>; else goto <D.25198>;
              <D.25201>:
              iftmp.42 = 1;
              goto <D.25199>;
              <D.25198>:
              iftmp.42 = 0;
              <D.25199>:
              D.25202 = iftmp.42 != 0;
              D.25203 = (int) D.25202;
              iftmp.41 = (long int) D.25203;
              goto <D.25204>;
              <D.25196>:
              D.25205 = sreg1 <= 15;
              D.25206 = (int) D.25205;
              iftmp.41 = (long int) D.25206;
              <D.25204>:
              D.25207 = __builtin_expect (iftmp.41, 0);
              if (D.25207 != 0) goto <D.25208>; else goto <D.25209>;
              <D.25208>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1879, "is_soft_reg (sreg1, bank)");
              <D.25209>:
              if (dest_sreg1 != -1) goto <D.25210>; else goto <D.25211>;
              <D.25210>:
              D.24562 = ins->dreg;
              D.25212 = D.24562 != dest_sreg1;
              D.25213 = (long int) D.25212;
              D.25214 = __builtin_expect (D.25213, 0);
              if (D.25214 != 0) goto <D.25215>; else goto <D.25216>;
              <D.25215>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1883, "dest_sreg1 == ins->dreg");
              <D.25216>:
              <D.25211>:
              D.24562 = ins->dreg;
              D.25073 = 1 << D.24562;
              val = mono_regstate_alloc_int (rs, D.25073);
              D.25217 = val < 0;
              D.25218 = (long int) D.25217;
              D.25219 = __builtin_expect (D.25218, 0);
              if (D.25219 != 0) goto <D.25220>; else goto <D.25221>;
              <D.25220>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1885, "val >= 0");
              <D.25221>:
              D.24636 = rs->vassign;
              D.25222 = (long unsigned int) sreg1;
              D.25223 = D.25222 * 4;
              D.25224 = D.24636 + D.25223;
              D.25225 = *D.25224;
              if (D.25225 >= 0) goto <D.25226>; else goto <D.25227>;
              <D.25226>:
              D.24636 = rs->vassign;
              D.25222 = (long unsigned int) sreg1;
              D.25223 = D.25222 * 4;
              D.25224 = D.24636 + D.25223;
              D.25225 = *D.25224;
              if (D.25225 != val) goto <D.25228>; else goto <D.25229>;
              <D.25228>:
              monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-codegen.c", 1889);
              <D.25229>:
              <D.25227>:
              assign_reg (cfg, rs, sreg1, val, bank);
              D.24553 = cfg->verbose_level;
              D.24585 = D.24553 > 2;
              D.24586 = (long int) D.24585;
              D.24587 = __builtin_expect (D.24586, 0);
              if (D.24587 != 0) goto <D.25230>; else goto <D.25231>;
              <D.25230>:
              D.25232 = mono_regname_full (val, bank);
              printf ("\tassigned sreg1-low %s to R%d\n", D.25232, sreg1);
              <D.25231>:
              D.25233 = 252 >> dreg_high;
              D.25234 = D.25233 & 1;
              D.25235 = D.25234 == 0;
              D.25236 = (long int) D.25235;
              D.25237 = __builtin_expect (D.25236, 0);
              if (D.25237 != 0) goto <D.25238>; else goto <D.25239>;
              <D.25238>:
              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.25239>:
              D.25240 = 1 << dreg_high;
              val = mono_regstate_alloc_int (rs, D.25240);
              D.25217 = val < 0;
              D.25218 = (long int) D.25217;
              D.25219 = __builtin_expect (D.25218, 0);
              if (D.25219 != 0) goto <D.25241>; else goto <D.25242>;
              <D.25241>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1897, "val >= 0");
              <D.25242>:
              D.24636 = rs->vassign;
              D.25243 = (sizetype) sreg1;
              D.25244 = D.25243 + 1;
              D.25245 = D.25244 * 4;
              D.25246 = D.24636 + D.25245;
              D.25247 = *D.25246;
              if (D.25247 >= 0) goto <D.25248>; else goto <D.25249>;
              <D.25248>:
              D.24636 = rs->vassign;
              D.25243 = (sizetype) sreg1;
              D.25244 = D.25243 + 1;
              D.25245 = D.25244 * 4;
              D.25246 = D.24636 + D.25245;
              D.25247 = *D.25246;
              if (D.25247 != val) goto <D.25250>; else goto <D.25251>;
              <D.25250>:
              monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-codegen.c", 1901);
              <D.25251>:
              <D.25249>:
              D.25252 = sreg1 + 1;
              assign_reg (cfg, rs, D.25252, val, bank);
              D.24553 = cfg->verbose_level;
              D.24585 = D.24553 > 2;
              D.24586 = (long int) D.24585;
              D.24587 = __builtin_expect (D.24586, 0);
              if (D.24587 != 0) goto <D.25253>; else goto <D.25254>;
              <D.25253>:
              D.25255 = mono_regname_full (val, bank);
              D.25252 = sreg1 + 1;
              printf ("\tassigned sreg1-high %s to R%d\n", D.25255, D.25252);
              <D.25254>:
              dest_sregs[0] = -1;
            }
            <D.25193>:
            D.25256 = sreg_fixed_masks[0];
            if (D.25256 != 0) goto <D.25257>; else goto <D.25258>;
            <D.25257>:
            D.24613 = bank != 0;
            D.24614 = (long int) D.24613;
            D.24615 = __builtin_expect (D.24614, 0);
            if (D.24615 != 0) goto <D.25259>; else goto <D.25260>;
            <D.25259>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1912, "!bank");
            <D.25260>:
            if (0 != 0) goto <D.25261>; else goto <D.25262>;
            <D.25261>:
            D.25256 = sreg_fixed_masks[0];
            val = mono_regstate_alloc_int (rs, D.25256);
            if (val < 0) goto <D.25263>; else goto <D.25264>;
            <D.25263>:
            D.25256 = sreg_fixed_masks[0];
            val = get_register_spilling (cfg, bb, tmp, ins, D.25256, -1, bank);
            <D.25264>:
            mono_regstate_free_int (rs, val);
            dest_sregs[0] = val;
            goto <D.25265>;
            <D.25262>:
            D.25167 = sreg_masks[0];
            D.25256 = sreg_fixed_masks[0];
            D.25266 = D.25167 & D.25256;
            sreg_masks[0] = D.25266;
            <D.25265>:
            <D.25258>:
            D.24852 = dest_sregs[0];
            if (D.24852 != -1) goto <D.25267>; else goto <D.25268>;
            <D.25267>:
            D.24852 = dest_sregs[0];
            D.24855 = 1 << D.24852;
            sreg_masks[0] = D.24855;
            D.24636 = rs->vassign;
            D.25269 = sregs[0];
            D.25270 = (long unsigned int) D.25269;
            D.25271 = D.25270 * 4;
            D.25272 = D.24636 + D.25271;
            D.25273 = *D.25272;
            D.24852 = dest_sregs[0];
            if (D.25273 != D.24852) goto <D.25274>; else goto <D.25275>;
            <D.25274>:
            D.24775 = rs->ifree_mask;
            D.24852 = dest_sregs[0];
            D.25276 = D.24775 >> D.24852;
            D.25277 = D.25276 & 1;
            if (D.25277 == 0) goto <D.25278>; else goto <D.25279>;
            <D.25278>:
            D.24852 = dest_sregs[0];
            free_up_hreg (cfg, bb, tmp, ins, D.24852, 0);
            <D.25279>:
            <D.25275>:
            if (0 != 0) goto <D.25280>; else goto <D.25281>;
            <D.25280>:
            {
              struct MonoInst * copy;

              D.24852 = dest_sregs[0];
              D.25269 = sregs[0];
              copy = create_copy_ins (cfg, bb, tmp, D.24852, D.25269, 0B, ip, 0);
              insert_before_ins (bb, ins, copy);
              D.24852 = dest_sregs[0];
              sregs[0] = D.24852;
            }
            <D.25281>:
            <D.25268>:
            D.24613 = bank != 0;
            D.24614 = (long int) D.24613;
            D.24615 = __builtin_expect (D.24614, 0);
            if (D.24615 != 0) goto <D.25283>; else goto <D.25284>;
            <D.25283>:
            D.25269 = sregs[0];
            if (D.25269 < 0) goto <D.25286>; else goto <D.25289>;
            <D.25289>:
            D.25269 = sregs[0];
            D.24623 = regbank_size[bank];
            if (D.25269 >= D.24623) goto <D.25286>; else goto <D.25287>;
            <D.25286>:
            iftmp.44 = 1;
            goto <D.25288>;
            <D.25287>:
            iftmp.44 = 0;
            <D.25288>:
            iftmp.43 = (_Bool) iftmp.44;
            goto <D.25290>;
            <D.25284>:
            D.25269 = sregs[0];
            iftmp.43 = D.25269 > 15;
            <D.25290>:
            if (iftmp.43 != 0) goto <D.25291>; else goto <D.25292>;
            <D.25291>:
            D.24636 = rs->vassign;
            D.25269 = sregs[0];
            D.25270 = (long unsigned int) D.25269;
            D.25271 = D.25270 * 4;
            D.25272 = D.24636 + D.25271;
            val = *D.25272;
            D.25269 = sregs[0];
            prev_sregs[0] = D.25269;
            if (val < 0) goto <D.25293>; else goto <D.25294>;
            <D.25293>:
            {
              int spill;

              spill = 0;
              if (val < -1) goto <D.25295>; else goto <D.25296>;
              <D.25295>:
              spill = ~val;
              <D.25296>:
              D.24557 = ins->opcode;
              if (D.24557 == 424) goto <D.25297>; else goto <D.25298>;
              <D.25297>:
              if (spill == 0) goto <D.25299>; else goto <D.25300>;
              <D.25299>:
              if (bank == 0) goto <D.25301>; else goto <D.25302>;
              <D.25301>:
              D.24562 = ins->dreg;
              D.25303 = (unsigned int) D.24562;
              if (D.25303 <= 15) goto <D.25304>; else goto <D.25305>;
              <D.25304>:
              D.24562 = ins->dreg;
              D.25306 = 252 >> D.24562;
              D.25307 = D.25306 & 1;
              if (D.25307 != 0) goto <D.25308>; else goto <D.25309>;
              <D.25308>:
              D.24775 = rs->ifree_mask;
              D.24562 = ins->dreg;
              D.25310 = D.24775 >> D.24562;
              D.25311 = D.25310 & 1;
              if (D.25311 != 0) goto <D.25312>; else goto <D.25313>;
              <D.25312>:
              D.24562 = ins->dreg;
              D.25073 = 1 << D.24562;
              sreg_masks[0] = D.25073;
              <D.25313>:
              <D.25309>:
              <D.25305>:
              <D.25302>:
              <D.25300>:
              <D.25298>:
              D.24692 = spec + 5;
              D.24693 = *D.24692;
              if (D.24693 == 49) goto <D.25314>; else goto <D.25315>;
              <D.25314>:
              D.24654 = *spec;
              D.24655 = D.24654 + 154;
              if (D.24655 > 1) goto <D.25316>; else goto <D.25317>;
              <D.25316>:
              D.24775 = rs->ifree_mask;
              D.24562 = ins->dreg;
              D.25310 = D.24775 >> D.24562;
              D.25311 = D.25310 & 1;
              if (D.25311 != 0) goto <D.25318>; else goto <D.25319>;
              <D.25318>:
              D.24562 = ins->dreg;
              D.25073 = 1 << D.24562;
              sreg_masks[0] = D.25073;
              <D.25319>:
              <D.25317>:
              <D.25315>:
              D.25167 = sreg_masks[0];
              D.25269 = sregs[0];
              D.25269 = sregs[0];
              D.25270 = (long unsigned int) D.25269;
              D.25320 = D.25270 * 16;
              D.25321 = reginfo + D.25320;
              val = alloc_reg (cfg, bb, tmp, ins, D.25167, D.25269, D.25321, bank);
              D.25269 = sregs[0];
              assign_reg (cfg, rs, D.25269, val, bank);
              D.24553 = cfg->verbose_level;
              D.24585 = D.24553 > 2;
              D.24586 = (long int) D.24585;
              D.24587 = __builtin_expect (D.24586, 0);
              if (D.24587 != 0) goto <D.25322>; else goto <D.25323>;
              <D.25322>:
              D.25324 = mono_regname_full (val, bank);
              D.25269 = sregs[0];
              printf ("\tassigned sreg1 %s to R%d\n", D.25324, D.25269);
              <D.25323>:
              if (spill != 0) goto <D.25325>; else goto <D.25326>;
              <D.25325>:
              D.25327 = prev_sregs[0];
              create_spilled_store (cfg, bb, spill, val, D.25327, tmp, 0B, ins, bank);
              <D.25326>:
            }
            goto <D.25328>;
            <D.25294>:
            D.24852 = dest_sregs[0];
            if (D.24852 != -1) goto <D.25329>; else goto <D.25330>;
            <D.25329>:
            D.24852 = dest_sregs[0];
            if (D.24852 != val) goto <D.25331>; else goto <D.25332>;
            <D.25331>:
            {
              struct MonoInst * copy;

              D.24852 = dest_sregs[0];
              copy = create_copy_ins (cfg, bb, tmp, D.24852, val, 0B, ip, bank);
              insert_before_ins (bb, ins, copy);
              j = 1;
              goto <D.24049>;
              <D.24048>:
              D.25072 = sreg_masks[j];
              D.24852 = dest_sregs[0];
              D.24855 = 1 << D.24852;
              D.24856 = ~D.24855;
              D.25333 = D.25072 & D.24856;
              sreg_masks[j] = D.25333;
              j = j + 1;
              <D.24049>:
              if (j < num_sregs) goto <D.24048>; else goto <D.24050>;
              <D.24050>:
              val = dest_sregs[0];
            }
            <D.25332>:
            <D.25330>:
            <D.25328>:
            sregs[0] = val;
            goto <D.25334>;
            <D.25292>:
            prev_sregs[0] = -1;
            <D.25334>:
            mono_inst_set_src_registers (ins, &sregs);
            j = 1;
            goto <D.24052>;
            <D.24051>:
            D.25072 = sreg_masks[j];
            D.25269 = sregs[0];
            D.25335 = 1 << D.25269;
            D.25336 = ~D.25335;
            D.25337 = D.25072 & D.25336;
            sreg_masks[j] = D.25337;
            j = j + 1;
            <D.24052>:
            if (j < num_sregs) goto <D.24051>; else goto <D.24053>;
            <D.24053>:
            if (0 != 0) goto <D.25338>; else goto <D.25339>;
            <D.25338>:
            {
              int reg2;

              D.25327 = prev_sregs[0];
              reg2 = D.25327 + 1;
              D.24613 = bank != 0;
              D.24614 = (long int) D.24613;
              D.24615 = __builtin_expect (D.24614, 0);
              if (D.24615 != 0) goto <D.25340>; else goto <D.25341>;
              <D.25340>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 2000, "!bank");
              <D.25341>:
              D.25327 = prev_sregs[0];
              D.25342 = D.25327 < 0;
              D.25343 = (long int) D.25342;
              D.25344 = __builtin_expect (D.25343, 0);
              if (D.25344 != 0) goto <D.25345>; else goto <D.25346>;
              <D.25345>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 2001, "prev_sregs [0] > -1");
              <D.25346>:
              if (0 != 0) goto <D.25347>; else goto <D.25348>;
              <D.25347>:
              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.25348>:
              mask = 252;
              D.24636 = rs->vassign;
              D.25349 = (long unsigned int) reg2;
              D.25350 = D.25349 * 4;
              D.25351 = D.24636 + D.25350;
              val = *D.25351;
              if (val < 0) goto <D.25352>; else goto <D.25353>;
              <D.25352>:
              {
                int spill;

                spill = 0;
                if (val < -1) goto <D.25354>; else goto <D.25355>;
                <D.25354>:
                spill = ~val;
                <D.25355>:
                val = mono_regstate_alloc_int (rs, mask);
                if (val < 0) goto <D.25356>; else goto <D.25357>;
                <D.25356>:
                val = get_register_spilling (cfg, bb, tmp, ins, mask, reg2, bank);
                <D.25357>:
                if (spill != 0) goto <D.25358>; else goto <D.25359>;
                <D.25358>:
                monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-codegen.c", 2015);
                <D.25359>:
              }
              goto <D.25360>;
              <D.25353>:
              D.24965 = mask >> val;
              D.24966 = D.24965 & 1;
              if (D.24966 == 0) goto <D.25361>; else goto <D.25362>;
              <D.25361>:
              monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-codegen.c", 2021);
              <D.25362>:
              <D.25360>:
              sreg1_high = val;
              D.24553 = cfg->verbose_level;
              D.24585 = D.24553 > 2;
              D.24586 = (long int) D.24585;
              D.24587 = __builtin_expect (D.24586, 0);
              if (D.24587 != 0) goto <D.25363>; else goto <D.25364>;
              <D.25363>:
              D.25365 = mono_arch_regname (val);
              printf ("\tassigned sreg1 hreg %s to dest R%d\n", D.25365, reg2);
              <D.25364>:
              assign_reg (cfg, rs, reg2, val, bank);
            }
            <D.25339>:
            D.24654 = *spec;
            D.24655 = D.24654 + 154;
            if (D.24655 <= 1) goto <D.25369>; else goto <D.25366>;
            <D.25369>:
            D.24732 = spec + 1;
            D.25189 = *D.24732;
            D.25190 = D.25189 + 154;
            if (D.25190 <= 1) goto <D.25367>; else goto <D.25366>;
            <D.25366>:
            D.24692 = spec + 5;
            D.24693 = *D.24692;
            if (D.24693 == 49) goto <D.25367>; else goto <D.25368>;
            <D.25367>:
            D.24562 = ins->dreg;
            D.25269 = sregs[0];
            if (D.24562 != D.25269) goto <D.25370>; else goto <D.25371>;
            <D.25370>:
            {
              struct MonoInst * sreg2_copy;
              struct MonoInst * copy;
              int bank;

              sreg2_copy = 0B;
              D.25372 = spec_src1 + 154;
              D.25373 = D.25372 <= 1;
              bank = (int) D.25373;
              D.24562 = ins->dreg;
              D.25374 = sregs[1];
              if (D.24562 == D.25374) goto <D.25375>; else goto <D.25376>;
              <D.25375>:
              {
                int reg2;

                D.25374 = sregs[1];
                reg2 = alloc_reg (cfg, bb, tmp, ins, dreg_mask, D.25374, 0B, bank);
                D.24553 = cfg->verbose_level;
                D.24585 = D.24553 > 2;
                D.24586 = (long int) D.24585;
                D.24587 = __builtin_expect (D.24586, 0);
                if (D.24587 != 0) goto <D.25377>; else goto <D.25378>;
                <D.25377>:
                D.25374 = sregs[1];
                D.25379 = mono_regname_full (D.25374, bank);
                D.25380 = mono_regname_full (reg2, bank);
                printf ("\tneed to copy sreg2 %s to reg %s\n", D.25379, D.25380);
                <D.25378>:
                D.25374 = sregs[1];
                sreg2_copy = create_copy_ins (cfg, bb, tmp, reg2, D.25374, 0B, ip, bank);
                sregs[1] = reg2;
                D.25374 = sregs[1];
                prev_sregs[1] = D.25374;
                D.25381 = bank != 0;
                D.25382 = (long int) D.25381;
                D.25383 = __builtin_expect (D.25382, 0);
                if (D.25383 != 0) goto <D.25384>; else goto <D.25385>;
                <D.25384>:
                mono_regstate_free_general (rs, reg2, bank);
                goto <D.25386>;
                <D.25385>:
                mono_regstate_free_int (rs, reg2);
                <D.25386>:
              }
              <D.25376>:
              if (0 != 0) goto <D.25387>; else goto <D.25388>;
              <D.25387>:
              D.24636 = rs->vassign;
              D.25327 = prev_sregs[0];
              D.25389 = (sizetype) D.25327;
              D.25390 = D.25389 + 1;
              D.25391 = D.25390 * 4;
              D.25392 = D.24636 + D.25391;
              D.25393 = *D.25392;
              D.25374 = sregs[1];
              if (D.25393 == D.25374) goto <D.25394>; else goto <D.25395>;
              <D.25394>:
              monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-codegen.c", 2067);
              <D.25395>:
              D.25269 = sregs[0];
              D.24562 = ins->dreg;
              D.25396 = D.25269 != D.24562;
              D.25397 = (long int) D.25396;
              D.25398 = __builtin_expect (D.25397, 0);
              if (D.25398 != 0) goto <D.25399>; else goto <D.25400>;
              <D.25399>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 2073, "sregs [0] == ins->dreg");
              <D.25400>:
              D.25401 = dreg_high != sreg1_high;
              D.25402 = (long int) D.25401;
              D.25403 = __builtin_expect (D.25402, 0);
              if (D.25403 != 0) goto <D.25404>; else goto <D.25405>;
              <D.25404>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 2074, "dreg_high == sreg1_high");
              <D.25405>:
              <D.25388>:
              D.24553 = cfg->verbose_level;
              D.24585 = D.24553 > 2;
              D.24586 = (long int) D.24585;
              D.24587 = __builtin_expect (D.24586, 0);
              if (D.24587 != 0) goto <D.25406>; else goto <D.25407>;
              <D.25406>:
              D.25269 = sregs[0];
              D.25408 = mono_regname_full (D.25269, bank);
              D.24562 = ins->dreg;
              D.25409 = mono_regname_full (D.24562, bank);
              printf ("\tneed to copy sreg1 %s to dreg %s\n", D.25408, D.25409);
              <D.25407>:
              D.24562 = ins->dreg;
              D.25269 = sregs[0];
              copy = create_copy_ins (cfg, bb, tmp, D.24562, D.25269, 0B, ip, bank);
              insert_before_ins (bb, ins, copy);
              if (sreg2_copy != 0B) goto <D.25410>; else goto <D.25411>;
              <D.25410>:
              insert_before_ins (bb, copy, sreg2_copy);
              <D.25411>:
              D.24743 = sreg_masks[1];
              D.25269 = sregs[0];
              D.25335 = 1 << D.25269;
              D.25336 = ~D.25335;
              D.25412 = D.24743 & D.25336;
              sreg_masks[1] = D.25412;
              D.24562 = ins->dreg;
              sregs[0] = D.24562;
              D.25269 = sregs[0];
              prev_sregs[0] = D.25269;
              D.24743 = sreg_masks[1];
              D.24562 = ins->dreg;
              D.25073 = 1 << D.24562;
              D.25074 = ~D.25073;
              D.25413 = D.24743 & D.25074;
              sreg_masks[1] = D.25413;
            }
            <D.25371>:
            <D.25368>:
            mono_inst_set_src_registers (ins, &sregs);
            j = 1;
            goto <D.24067>;
            <D.24066>:
            {
              int k;

              D.24599 = j + 1;
              D.24600 = (sizetype) D.24599;
              D.24601 = spec + D.24600;
              D.24602 = *D.24601;
              D.24605 = D.24602 + 154;
              D.24606 = D.24605 <= 1;
              bank = (int) D.24606;
              if (0 != 0) goto <D.25414>; else goto <D.25415>;
              <D.25414>:
              monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-codegen.c", 2103);
              <D.25415>:
              if (0 != 0) goto <D.25416>; else goto <D.25417>;
              <D.25416>:
              {
                struct MonoInst * copy;

                D.24857 = dest_sregs[j];
                D.24574 = sregs[j];
                copy = create_copy_ins (cfg, bb, tmp, D.24857, D.24574, 0B, ip, 0);
                insert_before_ins (bb, ins, copy);
                D.24857 = dest_sregs[j];
                sregs[j] = D.24857;
              }
              goto <D.25418>;
              <D.25417>:
              D.24613 = bank != 0;
              D.24614 = (long int) D.24613;
              D.24615 = __builtin_expect (D.24614, 0);
              if (D.24615 != 0) goto <D.25420>; else goto <D.25421>;
              <D.25420>:
              D.24574 = sregs[j];
              if (D.24574 < 0) goto <D.25423>; else goto <D.25426>;
              <D.25426>:
              D.24574 = sregs[j];
              D.24623 = regbank_size[bank];
              if (D.24574 >= D.24623) goto <D.25423>; else goto <D.25424>;
              <D.25423>:
              iftmp.46 = 1;
              goto <D.25425>;
              <D.25424>:
              iftmp.46 = 0;
              <D.25425>:
              iftmp.45 = (_Bool) iftmp.46;
              goto <D.25427>;
              <D.25421>:
              D.24574 = sregs[j];
              iftmp.45 = D.24574 > 15;
              <D.25427>:
              if (iftmp.45 != 0) goto <D.25428>; else goto <D.25429>;
              <D.25428>:
              D.24636 = rs->vassign;
              D.24574 = sregs[j];
              D.24582 = (long unsigned int) D.24574;
              D.25430 = D.24582 * 4;
              D.25431 = D.24636 + D.25430;
              val = *D.25431;
              D.24857 = dest_sregs[j];
              if (D.24857 != -1) goto <D.25432>; else goto <D.25433>;
              <D.25432>:
              if (val >= 0) goto <D.25434>; else goto <D.25435>;
              <D.25434>:
              D.24857 = dest_sregs[j];
              if (D.24857 != val) goto <D.25436>; else goto <D.25437>;
              <D.25436>:
              D.24574 = sregs[j];
              spill_vreg (cfg, bb, tmp, ins, D.24574, 0);
              D.24636 = rs->vassign;
              D.24574 = sregs[j];
              D.24582 = (long unsigned int) D.24574;
              D.25430 = D.24582 * 4;
              D.25431 = D.24636 + D.25430;
              val = *D.25431;
              <D.25437>:
              <D.25435>:
              <D.25433>:
              if (val < 0) goto <D.25438>; else goto <D.25439>;
              <D.25438>:
              {
                int spill;

                spill = 0;
                if (val < -1) goto <D.25440>; else goto <D.25441>;
                <D.25440>:
                spill = ~val;
                <D.25441>:
                D.25072 = sreg_masks[j];
                D.24574 = sregs[j];
                D.24574 = sregs[j];
                D.24582 = (long unsigned int) D.24574;
                D.24583 = D.24582 * 16;
                D.24584 = reginfo + D.24583;
                val = alloc_reg (cfg, bb, tmp, ins, D.25072, D.24574, D.24584, bank);
                D.24574 = sregs[j];
                assign_reg (cfg, rs, D.24574, val, bank);
                D.24553 = cfg->verbose_level;
                D.24585 = D.24553 > 2;
                D.24586 = (long int) D.24585;
                D.24587 = __builtin_expect (D.24586, 0);
                if (D.24587 != 0) goto <D.25442>; else goto <D.25443>;
                <D.25442>:
                D.24599 = j + 1;
                D.25444 = mono_regname_full (val, bank);
                D.24574 = sregs[j];
                printf ("\tassigned sreg%d %s to R%d\n", D.24599, D.25444, D.24574);
                <D.25443>:
                if (spill != 0) goto <D.25445>; else goto <D.25446>;
                <D.25445>:
                D.24574 = sregs[j];
                create_spilled_store (cfg, bb, spill, val, D.24574, tmp, 0B, ins, bank);
                <D.25446>:
              }
              <D.25439>:
              sregs[j] = val;
              k = j + 1;
              goto <D.24064>;
              <D.24063>:
              D.25447 = sreg_masks[k];
              D.24574 = sregs[j];
              D.25448 = 1 << D.24574;
              D.25449 = ~D.25448;
              D.25450 = D.25447 & D.25449;
              sreg_masks[k] = D.25450;
              k = k + 1;
              <D.24064>:
              if (k < num_sregs) goto <D.24063>; else goto <D.24065>;
              <D.24065>:
              goto <D.25451>;
              <D.25429>:
              prev_sregs[j] = -1;
              <D.25451>:
              <D.25418>:
            }
            j = j + 1;
            <D.24067>:
            if (j < num_sregs) goto <D.24066>; else goto <D.24068>;
            <D.24068>:
            mono_inst_set_src_registers (ins, &sregs);
            j = 1;
            goto <D.24076>;
            <D.24075>:
            {
              int sreg;
              int dest_sreg;

              sreg = sregs[j];
              dest_sreg = dest_sregs[j];
              if (j == 2) goto <D.25452>; else goto <D.25453>;
              <D.25452>:
              if (dest_sreg != -1) goto <D.25454>; else goto <D.25455>;
              <D.25454>:
              {
                int k;

                D.25456 = sreg != dest_sreg;
                D.25457 = (long int) D.25456;
                D.25458 = __builtin_expect (D.25457, 0);
                if (D.25458 != 0) goto <D.25459>; else goto <D.25460>;
                <D.25459>:
                monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 2163, "sreg == dest_sreg");
                <D.25460>:
                k = 0;
                goto <D.24073>;
                <D.24072>:
                if (k != j) goto <D.25461>; else goto <D.25462>;
                <D.25461>:
                D.25463 = sregs[k];
                D.25464 = D.25463 == dest_sreg;
                D.25465 = (long int) D.25464;
                D.25466 = __builtin_expect (D.25465, 0);
                if (D.25466 != 0) goto <D.25467>; else goto <D.25468>;
                <D.25467>:
                monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 2167, "sregs [k] != dest_sreg");
                <D.25468>:
                <D.25462>:
                k = k + 1;
                <D.24073>:
                if (k < num_sregs) goto <D.24072>; else goto <D.24074>;
                <D.24074>:
              }
              <D.25455>:
              <D.25453>:
            }
            j = j + 1;
            <D.24076>:
            if (j < num_sregs) goto <D.24075>; else goto <D.24077>;
            <D.24077>:
            D.24553 = cfg->verbose_level;
            D.24585 = D.24553 > 2;
            D.24586 = (long int) D.24585;
            D.24587 = __builtin_expect (D.24586, 0);
            if (D.24587 != 0) goto <D.25469>; else goto <D.25470>;
            <D.25469>:
            mono_print_ins_index (i, ins);
            <D.25470>:
          }
        finally
          {
            dest_sregs = {CLOBBER};
            prev_sregs = {CLOBBER};
            sreg_masks = {CLOBBER};
            sreg_fixed_masks = {CLOBBER};
          }
      }
      ins = prev;
      if (ins != 0B) goto <D.25472>; else goto <D.25473>;
      <D.25472>:
      iftmp.47 = ins->prev;
      goto <D.25474>;
      <D.25473>:
      iftmp.47 = 0B;
      <D.25474>:
      prev = iftmp.47;
      <D.24079>:
      if (ins != 0B) goto <D.24078>; else goto <D.24080>;
      <D.24080>:
    }
  finally
    {
      last = {CLOBBER};
      sregs = {CLOBBER};
    }
}


mono_regstate_assign (struct MonoRegState * rs)
{
  int D.25478;
  int D.25479;
  gint32 * D.25482;
  int D.25483;
  long unsigned int D.25484;
  long unsigned int D.25485;
  void * D.25486;
  int[16] * D.25487;
  int[16] * D.25488;

  D.25478 = rs->next_vreg;
  D.25479 = rs->vassign_size;
  if (D.25478 > D.25479) goto <D.25480>; else goto <D.25481>;
  <D.25480>:
  D.25482 = rs->vassign;
  monoeg_g_free (D.25482);
  D.25478 = rs->next_vreg;
  D.25483 = MAX_EXPR <D.25478, 256>;
  rs->vassign_size = D.25483;
  D.25479 = rs->vassign_size;
  D.25484 = (long unsigned int) D.25479;
  D.25485 = D.25484 * 4;
  D.25486 = monoeg_malloc (D.25485);
  rs->vassign = D.25486;
  <D.25481>:
  D.25487 = &rs->isymbolic;
  memset (D.25487, 0, 64);
  D.25488 = &rs->fsymbolic;
  memset (D.25488, 0, 64);
  D.25487 = &rs->isymbolic;
  rs->symbolic[0] = D.25487;
  D.25488 = &rs->fsymbolic;
  rs->symbolic[1] = D.25488;
}


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

  D.25490 = __builtin_object_size (__dest, 0);
  D.25489 = __builtin___memset_chk (__dest, __ch, __len, D.25490);
  return D.25489;
}


print_regtrack (struct RegTrack * t, int num)
{
  long unsigned int D.25492;
  long unsigned int D.25493;
  struct RegTrack * D.25494;
  int D.25495;
  int D.25501;
  int i;
  char buf[32];
  const char * r;

  try
    {
      i = 0;
      goto <D.23752>;
      <D.23751>:
      D.25492 = (long unsigned int) i;
      D.25493 = D.25492 * 16;
      D.25494 = t + D.25493;
      D.25495 = D.25494->born_in;
      if (D.25495 == 0) goto <D.25496>; else goto <D.25497>;
      <D.25496>:
      // predicted unlikely by continue predictor.
      goto <D.23750>;
      <D.25497>:
      if (i > 15) goto <D.25498>; else goto <D.25499>;
      <D.25498>:
      monoeg_g_snprintf (&buf, 32, "R%d", i);
      r = &buf;
      goto <D.25500>;
      <D.25499>:
      r = mono_arch_regname (i);
      <D.25500>:
      D.25492 = (long unsigned int) i;
      D.25493 = D.25492 * 16;
      D.25494 = t + D.25493;
      D.25495 = D.25494->born_in;
      D.25492 = (long unsigned int) i;
      D.25493 = D.25492 * 16;
      D.25494 = t + D.25493;
      D.25501 = D.25494->killed_in;
      printf ("liveness: %s [%d - %d]\n", r, D.25495, D.25501);
      <D.23750>:
      i = i + 1;
      <D.23752>:
      if (i < num) goto <D.23751>; else goto <D.23753>;
      <D.23753>:
    }
  finally
    {
      buf = {CLOBBER};
    }
}


get_callee_mask (const char spec)
{
  char D.25502;
  _Bool D.25503;
  long int D.25504;
  long int D.25505;
  regmask_t D.25508;
  int D.25509;

  D.25502 = spec + 154;
  D.25503 = D.25502 <= 1;
  D.25504 = (long int) D.25503;
  D.25505 = __builtin_expect (D.25504, 0);
  if (D.25505 != 0) goto <D.25506>; else goto <D.25507>;
  <D.25506>:
  D.25502 = spec + 154;
  D.25503 = D.25502 <= 1;
  D.25509 = (int) D.25503;
  D.25508 = regbank_callee_regs[D.25509];
  return D.25508;
  <D.25507>:
  D.25508 = 252;
  return D.25508;
}


alloc_int_reg (struct MonoCompile * cfg, struct MonoBasicBlock * bb, struct MonoInst * * last, struct MonoInst * ins, regmask_t dest_mask, int sym_reg, struct RegTrack * info)
{
  long unsigned int D.25513;
  struct MonoRegState * D.25516;
  long unsigned int D.25517;
  unsigned int D.25520;
  _Bool D.25521;
  long int D.25522;
  long int D.25523;
  const char * D.25526;
  int D.25527;
  int val;

  if (info != 0B) goto <D.25511>; else goto <D.25512>;
  <D.25511>:
  D.25513 = info->preferred_mask;
  if (D.25513 != 0) goto <D.25514>; else goto <D.25515>;
  <D.25514>:
  D.25516 = cfg->rs;
  D.25513 = info->preferred_mask;
  D.25517 = D.25513 & dest_mask;
  val = mono_regstate_alloc_int (D.25516, D.25517);
  if (val >= 0) goto <D.25518>; else goto <D.25519>;
  <D.25518>:
  D.25520 = cfg->verbose_level;
  D.25521 = D.25520 > 2;
  D.25522 = (long int) D.25521;
  D.25523 = __builtin_expect (D.25522, 0);
  if (D.25523 != 0) goto <D.25524>; else goto <D.25525>;
  <D.25524>:
  D.25526 = mono_arch_regname (val);
  printf ("\tallocated preferred reg R%d to %s\n", sym_reg, D.25526);
  <D.25525>:
  D.25527 = val;
  return D.25527;
  <D.25519>:
  <D.25515>:
  <D.25512>:
  D.25516 = cfg->rs;
  val = mono_regstate_alloc_int (D.25516, dest_mask);
  if (val < 0) goto <D.25528>; else goto <D.25529>;
  <D.25528>:
  val = get_register_spilling (cfg, bb, last, ins, dest_mask, sym_reg, 0);
  <D.25529>:
  D.25527 = val;
  return D.25527;
}


mono_regstate_alloc_int (struct MonoRegState * rs, regmask_t allow)
{
  long unsigned int D.25531;
  long unsigned int D.25532;
  long unsigned int D.25533;
  long unsigned int D.25536;
  long unsigned int D.25537;
  long unsigned int D.25538;
  int D.25539;
  regmask_t mask;
  int i;

  D.25531 = rs->ifree_mask;
  mask = D.25531 & allow;
  i = 0;
  goto <D.23556>;
  <D.23555>:
  D.25532 = mask >> i;
  D.25533 = D.25532 & 1;
  if (D.25533 != 0) goto <D.25534>; else goto <D.25535>;
  <D.25534>:
  D.25531 = rs->ifree_mask;
  D.25536 = 1 << i;
  D.25537 = ~D.25536;
  D.25538 = D.25531 & D.25537;
  rs->ifree_mask = D.25538;
  D.25539 = i;
  return D.25539;
  <D.25535>:
  i = i + 1;
  <D.23556>:
  if (i <= 15) goto <D.23555>; else goto <D.23557>;
  <D.23557>:
  D.25539 = -1;
  return D.25539;
}


get_register_spilling (struct MonoCompile * cfg, struct MonoBasicBlock * bb, struct MonoInst * * last, struct MonoInst * ins, regmask_t regmask, int reg, int bank)
{
  _Bool D.25541;
  long int D.25542;
  long int D.25543;
  unsigned int D.25546;
  _Bool D.25547;
  long int D.25548;
  long int D.25549;
  int D.25552;
  int D.25553;
  int D.25554;
  int D.25555;
  short unsigned int D.25556;
  int D.25557;
  int D.25558;
  signed char D.25559;
  short unsigned int D.25562;
  sizetype D.25563;
  int D.25564;
  sizetype D.25565;
  sizetype D.25566;
  const char * D.25567;
  char D.25568;
  char D.25569;
  _Bool D.25570;
  int D.25571;
  int D.25574;
  _Bool D.25577;
  long int D.25578;
  long int D.25579;
  int iftmp.48;
  int iftmp.49;
  int D.25591;
  _Bool D.25593;
  long unsigned int D.25597;
  long unsigned int D.25598;
  long unsigned int D.25599;
  _Bool D.25601;
  int iftmp.50;
  unsigned int D.25607;
  long unsigned int D.25609;
  long unsigned int D.25610;
  _Bool D.25612;
  int iftmp.51;
  _Bool D.25621;
  gint32 * D.25625;
  long unsigned int D.25626;
  long unsigned int D.25627;
  gint32 * D.25628;
  int D.25629;
  _Bool iftmp.52;
  int iftmp.53;
  long unsigned int D.25641;
  long unsigned int D.25642;
  long unsigned int D.25644;
  long unsigned int D.25645;
  const char * D.25648;
  const char * D.25649;
  char D.25650;
  char D.25651;
  _Bool D.25652;
  int D.25653;
  _Bool iftmp.54;
  int iftmp.55;
  int iftmp.56;
  _Bool D.25671;
  long unsigned int D.25675;
  long unsigned int D.25676;
  int iftmp.57;
  unsigned int D.25682;
  long unsigned int D.25684;
  long unsigned int D.25685;
  long unsigned int D.25689;
  long unsigned int D.25690;
  const char * D.25693;
  _Bool D.25696;
  long int D.25697;
  long int D.25698;
  long unsigned int D.25703;
  long unsigned int D.25704;
  struct MonoRegState * D.25707;
  const char * D.25710;
  int * D.25711;
  long unsigned int D.25712;
  long unsigned int D.25713;
  int * D.25714;
  int D.25715;
  int D.25716;
  int D.25717;
  long unsigned int D.25718;
  long unsigned int D.25719;
  gint32 * D.25720;
  int D.25721;
  const char * D.25727;
  int D.25728;
  struct MonoMemPool * D.25729;
  int D.25730;
  short unsigned int D.25731;
  int D.25732;
  int D.25733;
  const unsigned char * D.25734;
  unsigned int D.25735;
  int D.25736;
  int D.25737;
  int D.25738;
  long int D.25739;
  long int D.25742;
  const char * D.25743;
  long unsigned int D.25746;
  _Bool D.25748;
  long int D.25749;
  long int D.25750;
  int D.25753;
  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.25541 = bank > 3;
      D.25542 = (long int) D.25541;
      D.25543 = __builtin_expect (D.25542, 0);
      if (D.25543 != 0) goto <D.25544>; else goto <D.25545>;
      <D.25544>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 831, "bank < MONO_NUM_REGBANKS");
      <D.25545>:
      D.25546 = cfg->verbose_level;
      D.25547 = D.25546 > 2;
      D.25548 = (long int) D.25547;
      D.25549 = __builtin_expect (D.25548, 0);
      if (D.25549 != 0) goto <D.25550>; else goto <D.25551>;
      <D.25550>:
      D.25552 = ins->dreg;
      D.25553 = ins->sreg1;
      D.25554 = ins->sreg2;
      D.25555 = ins->sreg3;
      printf ("\tstart regmask to assign R%d: 0x%08llu (R%d <- R%d R%d R%d)\n", reg, regmask, D.25552, D.25553, D.25554, D.25555);
      <D.25551>:
      D.25553 = ins->sreg1;
      sregs[0] = D.25553;
      D.25554 = ins->sreg2;
      sregs[1] = D.25554;
      D.25555 = ins->sreg3;
      sregs[2] = D.25555;
      D.25556 = ins->opcode;
      D.25557 = (int) D.25556;
      D.25558 = D.25557 + -313;
      D.25559 = ins_sreg_counts[D.25558];
      num_sregs = (int) D.25559;
      i = 0;
      goto <D.23805>;
      <D.23804>:
      D.25556 = ins->opcode;
      D.25557 = (int) D.25556;
      D.25558 = D.25557 + -313;
      D.25562 = s390x_cpu_desc_idx[D.25558];
      D.25563 = (sizetype) D.25562;
      D.25564 = i + 1;
      D.25565 = (sizetype) D.25564;
      D.25566 = D.25563 + D.25565;
      D.25567 = &s390x_cpu_desc + D.25566;
      D.25568 = *D.25567;
      D.25569 = D.25568 + 154;
      D.25570 = D.25569 <= 1;
      D.25571 = (int) D.25570;
      if (D.25571 == bank) goto <D.25572>; else goto <D.25573>;
      <D.25572>:
      D.25574 = sregs[i];
      if (D.25574 != reg) goto <D.25575>; else goto <D.25576>;
      <D.25575>:
      D.25577 = bank != 0;
      D.25578 = (long int) D.25577;
      D.25579 = __builtin_expect (D.25578, 0);
      if (D.25579 != 0) goto <D.25580>; else goto <D.25581>;
      <D.25580>:
      D.25577 = bank != 0;
      D.25578 = (long int) D.25577;
      D.25579 = __builtin_expect (D.25578, 0);
      if (D.25579 != 0) goto <D.25585>; else goto <D.25586>;
      <D.25585>:
      D.25574 = sregs[i];
      if (D.25574 >= 0) goto <D.25590>; else goto <D.25588>;
      <D.25590>:
      D.25574 = sregs[i];
      D.25591 = regbank_size[bank];
      if (D.25574 < D.25591) goto <D.25592>; else goto <D.25588>;
      <D.25592>:
      iftmp.49 = 1;
      goto <D.25589>;
      <D.25588>:
      iftmp.49 = 0;
      <D.25589>:
      D.25593 = (_Bool) iftmp.49;
      if (D.25593 != 0) goto <D.25594>; else goto <D.25583>;
      <D.25594>:
      goto <D.25595>;
      <D.25586>:
      D.25574 = sregs[i];
      if (D.25574 <= 15) goto <D.25596>; else goto <D.25583>;
      <D.25596>:
      <D.25595>:
      D.25597 = regbank_callee_regs[bank];
      D.25574 = sregs[i];
      D.25598 = D.25597 >> D.25574;
      D.25599 = D.25598 & 1;
      if (D.25599 != 0) goto <D.25600>; else goto <D.25583>;
      <D.25600>:
      iftmp.48 = 1;
      goto <D.25584>;
      <D.25583>:
      iftmp.48 = 0;
      <D.25584>:
      D.25601 = (_Bool) iftmp.48;
      if (D.25601 != 0) goto <D.25560>; else goto <D.25602>;
      <D.25602>:
      goto <D.25603>;
      <D.25581>:
      D.25574 = sregs[i];
      D.25607 = (unsigned int) D.25574;
      if (D.25607 <= 15) goto <D.25608>; else goto <D.25605>;
      <D.25608>:
      D.25574 = sregs[i];
      D.25609 = 252 >> D.25574;
      D.25610 = D.25609 & 1;
      if (D.25610 != 0) goto <D.25611>; else goto <D.25605>;
      <D.25611>:
      iftmp.50 = 1;
      goto <D.25606>;
      <D.25605>:
      iftmp.50 = 0;
      <D.25606>:
      D.25612 = (_Bool) iftmp.50;
      if (D.25612 != 0) goto <D.25560>; else goto <D.25613>;
      <D.25613>:
      <D.25603>:
      D.25577 = bank != 0;
      D.25578 = (long int) D.25577;
      D.25579 = __builtin_expect (D.25578, 0);
      if (D.25579 != 0) goto <D.25614>; else goto <D.25615>;
      <D.25614>:
      D.25574 = sregs[i];
      if (D.25574 < 0) goto <D.25617>; else goto <D.25620>;
      <D.25620>:
      D.25574 = sregs[i];
      D.25591 = regbank_size[bank];
      if (D.25574 >= D.25591) goto <D.25617>; else goto <D.25618>;
      <D.25617>:
      iftmp.51 = 1;
      goto <D.25619>;
      <D.25618>:
      iftmp.51 = 0;
      <D.25619>:
      D.25621 = (_Bool) iftmp.51;
      if (D.25621 != 0) goto <D.25622>; else goto <D.25561>;
      <D.25622>:
      goto <D.25623>;
      <D.25615>:
      D.25574 = sregs[i];
      if (D.25574 > 15) goto <D.25624>; else goto <D.25561>;
      <D.25624>:
      <D.25623>:
      D.25625 = rs->vassign;
      D.25574 = sregs[i];
      D.25626 = (long unsigned int) D.25574;
      D.25627 = D.25626 * 4;
      D.25628 = D.25625 + D.25627;
      D.25629 = *D.25628;
      if (D.25629 >= 0) goto <D.25560>; else goto <D.25561>;
      <D.25560>:
      D.25577 = bank != 0;
      D.25578 = (long int) D.25577;
      D.25579 = __builtin_expect (D.25578, 0);
      if (D.25579 != 0) goto <D.25631>; else goto <D.25632>;
      <D.25631>:
      D.25574 = sregs[i];
      if (D.25574 < 0) goto <D.25634>; else goto <D.25637>;
      <D.25637>:
      D.25574 = sregs[i];
      D.25591 = regbank_size[bank];
      if (D.25574 >= D.25591) goto <D.25634>; else goto <D.25635>;
      <D.25634>:
      iftmp.53 = 1;
      goto <D.25636>;
      <D.25635>:
      iftmp.53 = 0;
      <D.25636>:
      iftmp.52 = (_Bool) iftmp.53;
      goto <D.25638>;
      <D.25632>:
      D.25574 = sregs[i];
      iftmp.52 = D.25574 > 15;
      <D.25638>:
      if (iftmp.52 != 0) goto <D.25639>; else goto <D.25640>;
      <D.25639>:
      D.25625 = rs->vassign;
      D.25574 = sregs[i];
      D.25626 = (long unsigned int) D.25574;
      D.25627 = D.25626 * 4;
      D.25628 = D.25625 + D.25627;
      D.25629 = *D.25628;
      D.25641 = 1 << D.25629;
      D.25642 = ~D.25641;
      regmask = D.25642 & regmask;
      goto <D.25643>;
      <D.25640>:
      D.25574 = sregs[i];
      D.25644 = 1 << D.25574;
      D.25645 = ~D.25644;
      regmask = D.25645 & regmask;
      <D.25643>:
      D.25546 = cfg->verbose_level;
      D.25547 = D.25546 > 2;
      D.25548 = (long int) D.25547;
      D.25549 = __builtin_expect (D.25548, 0);
      if (D.25549 != 0) goto <D.25646>; else goto <D.25647>;
      <D.25646>:
      D.25564 = i + 1;
      D.25574 = sregs[i];
      D.25648 = mono_regname_full (D.25574, bank);
      D.25574 = sregs[i];
      printf ("\t\texcluding sreg%d %s %d\n", D.25564, D.25648, D.25574);
      <D.25647>:
      <D.25561>:
      <D.25576>:
      <D.25573>:
      i = i + 1;
      <D.23805>:
      if (i < num_sregs) goto <D.23804>; else goto <D.23806>;
      <D.23806>:
      D.25556 = ins->opcode;
      D.25557 = (int) D.25556;
      D.25558 = D.25557 + -313;
      D.25562 = s390x_cpu_desc_idx[D.25558];
      D.25563 = (sizetype) D.25562;
      D.25649 = &s390x_cpu_desc + D.25563;
      D.25650 = *D.25649;
      D.25651 = D.25650 + 154;
      D.25652 = D.25651 <= 1;
      D.25653 = (int) D.25652;
      if (D.25653 == bank) goto <D.25654>; else goto <D.25655>;
      <D.25654>:
      D.25552 = ins->dreg;
      if (D.25552 != reg) goto <D.25656>; else goto <D.25657>;
      <D.25656>:
      D.25577 = bank != 0;
      D.25578 = (long int) D.25577;
      D.25579 = __builtin_expect (D.25578, 0);
      if (D.25579 != 0) goto <D.25659>; else goto <D.25660>;
      <D.25659>:
      D.25577 = bank != 0;
      D.25578 = (long int) D.25577;
      D.25579 = __builtin_expect (D.25578, 0);
      if (D.25579 != 0) goto <D.25664>; else goto <D.25665>;
      <D.25664>:
      D.25552 = ins->dreg;
      if (D.25552 >= 0) goto <D.25669>; else goto <D.25667>;
      <D.25669>:
      D.25552 = ins->dreg;
      D.25591 = regbank_size[bank];
      if (D.25552 < D.25591) goto <D.25670>; else goto <D.25667>;
      <D.25670>:
      iftmp.56 = 1;
      goto <D.25668>;
      <D.25667>:
      iftmp.56 = 0;
      <D.25668>:
      D.25671 = (_Bool) iftmp.56;
      if (D.25671 != 0) goto <D.25672>; else goto <D.25662>;
      <D.25672>:
      goto <D.25673>;
      <D.25665>:
      D.25552 = ins->dreg;
      if (D.25552 <= 15) goto <D.25674>; else goto <D.25662>;
      <D.25674>:
      <D.25673>:
      D.25597 = regbank_callee_regs[bank];
      D.25552 = ins->dreg;
      D.25675 = D.25597 >> D.25552;
      D.25676 = D.25675 & 1;
      if (D.25676 != 0) goto <D.25677>; else goto <D.25662>;
      <D.25677>:
      iftmp.55 = 1;
      goto <D.25663>;
      <D.25662>:
      iftmp.55 = 0;
      <D.25663>:
      iftmp.54 = (_Bool) iftmp.55;
      goto <D.25678>;
      <D.25660>:
      D.25552 = ins->dreg;
      D.25682 = (unsigned int) D.25552;
      if (D.25682 <= 15) goto <D.25683>; else goto <D.25680>;
      <D.25683>:
      D.25552 = ins->dreg;
      D.25684 = 252 >> D.25552;
      D.25685 = D.25684 & 1;
      if (D.25685 != 0) goto <D.25686>; else goto <D.25680>;
      <D.25686>:
      iftmp.57 = 1;
      goto <D.25681>;
      <D.25680>:
      iftmp.57 = 0;
      <D.25681>:
      iftmp.54 = (_Bool) iftmp.57;
      <D.25678>:
      if (iftmp.54 != 0) goto <D.25687>; else goto <D.25688>;
      <D.25687>:
      D.25552 = ins->dreg;
      D.25689 = 1 << D.25552;
      D.25690 = ~D.25689;
      regmask = D.25690 & regmask;
      D.25546 = cfg->verbose_level;
      D.25547 = D.25546 > 2;
      D.25548 = (long int) D.25547;
      D.25549 = __builtin_expect (D.25548, 0);
      if (D.25549 != 0) goto <D.25691>; else goto <D.25692>;
      <D.25691>:
      D.25552 = ins->dreg;
      D.25693 = mono_regname_full (D.25552, bank);
      printf ("\t\texcluding dreg %s\n", D.25693);
      <D.25692>:
      <D.25688>:
      <D.25657>:
      <D.25655>:
      D.25546 = cfg->verbose_level;
      D.25547 = D.25546 > 2;
      D.25548 = (long int) D.25547;
      D.25549 = __builtin_expect (D.25548, 0);
      if (D.25549 != 0) goto <D.25694>; else goto <D.25695>;
      <D.25694>:
      printf ("\t\tavailable regmask: 0x%08llu\n", regmask);
      <D.25695>:
      D.25696 = regmask == 0;
      D.25697 = (long int) D.25696;
      D.25698 = __builtin_expect (D.25697, 0);
      if (D.25698 != 0) goto <D.25699>; else goto <D.25700>;
      <D.25699>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 851, "regmask");
      <D.25700>:
      sel = 0;
      D.25577 = bank != 0;
      D.25578 = (long int) D.25577;
      D.25579 = __builtin_expect (D.25578, 0);
      if (D.25579 != 0) goto <D.25701>; else goto <D.25702>;
      <D.25701>:
      i = 0;
      goto <D.23809>;
      <D.23808>:
      D.25703 = regmask >> i;
      D.25704 = D.25703 & 1;
      if (D.25704 != 0) goto <D.25705>; else goto <D.25706>;
      <D.25705>:
      sel = i;
      D.25707 = cfg->rs;
      bank = translate_bank (D.25707, bank, sel);
      D.25546 = cfg->verbose_level;
      D.25547 = D.25546 > 2;
      D.25548 = (long int) D.25547;
      D.25549 = __builtin_expect (D.25548, 0);
      if (D.25549 != 0) goto <D.25708>; else goto <D.25709>;
      <D.25708>:
      D.25710 = mono_regname_full (sel, bank);
      D.25711 = rs->symbolic[bank];
      D.25712 = (long unsigned int) sel;
      D.25713 = D.25712 * 4;
      D.25714 = D.25711 + D.25713;
      D.25715 = *D.25714;
      printf ("\t\tselected register %s has assignment %d\n", D.25710, D.25715);
      <D.25709>:
      goto <D.23807>;
      <D.25706>:
      i = i + 1;
      <D.23809>:
      D.25591 = regbank_size[bank];
      if (D.25591 > i) goto <D.23808>; else goto <D.23807>;
      <D.23807>:
      D.25711 = rs->symbolic[bank];
      D.25712 = (long unsigned int) sel;
      D.25713 = D.25712 * 4;
      D.25714 = D.25711 + D.25713;
      i = *D.25714;
      D.25716 = cfg->spill_count;
      D.25717 = D.25716 + 1;
      cfg->spill_count = D.25717;
      spill = cfg->spill_count;
      D.25625 = rs->vassign;
      D.25718 = (long unsigned int) i;
      D.25719 = D.25718 * 4;
      D.25720 = D.25625 + D.25719;
      D.25721 = ~spill;
      *D.25720 = D.25721;
      mono_regstate_free_general (rs, sel, bank);
      goto <D.25722>;
      <D.25702>:
      i = 0;
      goto <D.23812>;
      <D.23811>:
      D.25703 = regmask >> i;
      D.25704 = D.25703 & 1;
      if (D.25704 != 0) goto <D.25723>; else goto <D.25724>;
      <D.25723>:
      sel = i;
      D.25546 = cfg->verbose_level;
      D.25547 = D.25546 > 2;
      D.25548 = (long int) D.25547;
      D.25549 = __builtin_expect (D.25548, 0);
      if (D.25549 != 0) goto <D.25725>; else goto <D.25726>;
      <D.25725>:
      D.25727 = mono_arch_regname (sel);
      D.25728 = rs->isymbolic[sel];
      printf ("\t\tselected register %s has assignment %d\n", D.25727, D.25728);
      <D.25726>:
      goto <D.23810>;
      <D.25724>:
      i = i + 1;
      <D.23812>:
      if (i <= 15) goto <D.23811>; else goto <D.23810>;
      <D.23810>:
      i = rs->isymbolic[sel];
      D.25716 = cfg->spill_count;
      D.25717 = D.25716 + 1;
      cfg->spill_count = D.25717;
      spill = cfg->spill_count;
      D.25625 = rs->vassign;
      D.25718 = (long unsigned int) i;
      D.25719 = D.25718 * 4;
      D.25720 = D.25625 + D.25719;
      D.25721 = ~spill;
      *D.25720 = D.25721;
      mono_regstate_free_int (rs, sel);
      <D.25722>:
      D.25729 = cfg->mempool;
      load = mono_mempool_alloc0 (D.25729, 80);
      D.25730 = regbank_load_ops[bank];
      D.25731 = (short unsigned int) D.25730;
      load->opcode = D.25731;
      load->dreg = -1;
      load->sreg3 = -1;
      D.25732 = load->sreg3;
      load->sreg2 = D.25732;
      D.25733 = load->sreg2;
      load->sreg1 = D.25733;
      D.25734 = cfg->ip;
      load->cil_code = D.25734;
      load->dreg = sel;
      D.25735 = cfg->frame_reg;
      D.25736 = (int) D.25735;
      load->sreg1 = D.25736;
      D.25737 = get_vreg_bank (cfg, i, bank);
      D.25738 = mono_spillvar_offset (cfg, spill, D.25737);
      D.25739 = (long int) D.25738;
      load->data.op[0].const_val = D.25739;
      insert_after_ins (bb, ins, last, load);
      D.25546 = cfg->verbose_level;
      D.25547 = D.25546 > 2;
      D.25548 = (long int) D.25547;
      D.25549 = __builtin_expect (D.25548, 0);
      if (D.25549 != 0) goto <D.25740>; else goto <D.25741>;
      <D.25740>:
      D.25742 = load->data.op[0].const_val;
      D.25743 = mono_regname_full (sel, bank);
      printf ("\tSPILLED LOAD (%d at 0x%08lx(%%ebp)) R%d (freed %s)\n", spill, D.25742, i, D.25743);
      <D.25741>:
      D.25577 = bank != 0;
      D.25578 = (long int) D.25577;
      D.25579 = __builtin_expect (D.25578, 0);
      if (D.25579 != 0) goto <D.25744>; else goto <D.25745>;
      <D.25744>:
      D.25746 = 1 << sel;
      i = mono_regstate_alloc_general (rs, D.25746, bank);
      goto <D.25747>;
      <D.25745>:
      D.25746 = 1 << sel;
      i = mono_regstate_alloc_int (rs, D.25746);
      <D.25747>:
      D.25748 = i != sel;
      D.25749 = (long int) D.25748;
      D.25750 = __builtin_expect (D.25749, 0);
      if (D.25750 != 0) goto <D.25751>; else goto <D.25752>;
      <D.25751>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 898, "i == sel");
      <D.25752>:
      D.25753 = sel;
      return D.25753;
    }
  finally
    {
      sregs = {CLOBBER};
    }
}


get_vreg_bank (struct MonoCompile * cfg, int reg, int bank)
{
  unsigned int D.25757;
  unsigned int reg.58;
  gboolean * D.25760;
  long unsigned int D.25761;
  long unsigned int D.25762;
  gboolean * D.25763;
  int D.25764;
  int D.25766;
  unsigned int D.25768;
  gboolean * D.25770;
  gboolean * D.25771;
  int D.25772;

  D.25757 = cfg->vreg_is_ref_len;
  reg.58 = (unsigned int) reg;
  if (D.25757 > reg.58) goto <D.25759>; else goto <D.25756>;
  <D.25759>:
  D.25760 = cfg->vreg_is_ref;
  D.25761 = (long unsigned int) reg;
  D.25762 = D.25761 * 4;
  D.25763 = D.25760 + D.25762;
  D.25764 = *D.25763;
  if (D.25764 != 0) goto <D.25765>; else goto <D.25756>;
  <D.25765>:
  D.25766 = 2;
  return D.25766;
  <D.25756>:
  D.25768 = cfg->vreg_is_mp_len;
  reg.58 = (unsigned int) reg;
  if (D.25768 > reg.58) goto <D.25769>; else goto <D.25767>;
  <D.25769>:
  D.25770 = cfg->vreg_is_mp;
  D.25761 = (long unsigned int) reg;
  D.25762 = D.25761 * 4;
  D.25771 = D.25770 + D.25762;
  D.25772 = *D.25771;
  if (D.25772 != 0) goto <D.25773>; else goto <D.25767>;
  <D.25773>:
  D.25766 = 3;
  return D.25766;
  <D.25767>:
  D.25766 = bank;
  return D.25766;
}


mono_spillvar_offset (struct MonoCompile * cfg, int spillvar, int bank)
{
  int D.25775;
  _Bool D.25776;
  long int D.25777;
  long int D.25778;
  struct MonoSpillInfo * D.25781;
  long unsigned int D.25782;
  long unsigned int D.25783;
  int D.25784;
  int D.25787;
  unsigned int D.25788;
  unsigned int D.25789;
  int D.25790;
  int D.25791;
  _Bool D.25792;
  long int D.25793;
  long int D.25794;
  _Bool D.25797;
  long int D.25798;
  long int D.25799;
  unsigned int D.25803;
  unsigned int D.25804;
  int D.25807;
  int D.25808;
  int D.25809;
  int D.25810;
  int D.25811;
  int D.25813;
  int D.25814;
  struct MonoSpillInfo * info;
  int size;

  D.25775 = cfg->spill_info_len[bank];
  D.25776 = D.25775 <= spillvar;
  D.25777 = (long int) D.25776;
  D.25778 = __builtin_expect (D.25777, 0);
  if (D.25778 != 0) goto <D.25779>; else goto <D.25780>;
  <D.25779>:
  goto <D.23616>;
  <D.23615>:
  resize_spill_info (cfg, bank);
  <D.23616>:
  D.25775 = cfg->spill_info_len[bank];
  if (D.25775 <= spillvar) goto <D.23615>; else goto <D.23617>;
  <D.23617>:
  <D.25780>:
  D.25781 = cfg->spill_info[bank];
  D.25782 = (long unsigned int) spillvar;
  D.25783 = D.25782 * 4;
  info = D.25781 + D.25783;
  D.25784 = info->offset;
  if (D.25784 == -1) goto <D.25785>; else goto <D.25786>;
  <D.25785>:
  D.25787 = cfg->stack_offset;
  D.25788 = (unsigned int) D.25787;
  D.25789 = D.25788 + 7;
  D.25790 = (int) D.25789;
  cfg->stack_offset = D.25790;
  D.25787 = cfg->stack_offset;
  D.25791 = D.25787 & -8;
  cfg->stack_offset = D.25791;
  D.25792 = bank > 3;
  D.25793 = (long int) D.25792;
  D.25794 = __builtin_expect (D.25793, 0);
  if (D.25794 != 0) goto <D.25795>; else goto <D.25796>;
  <D.25795>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 329, "bank < MONO_NUM_REGBANKS");
  <D.25796>:
  D.25797 = bank != 0;
  D.25798 = (long int) D.25797;
  D.25799 = __builtin_expect (D.25798, 0);
  if (D.25799 != 0) goto <D.25800>; else goto <D.25801>;
  <D.25800>:
  size = regbank_spill_var_size[bank];
  goto <D.25802>;
  <D.25801>:
  size = 8;
  <D.25802>:
  D.25803 = cfg->flags;
  D.25804 = D.25803 & 64;
  if (D.25804 != 0) goto <D.25805>; else goto <D.25806>;
  <D.25805>:
  D.25787 = cfg->stack_offset;
  D.25807 = size + -1;
  D.25808 = D.25787 + D.25807;
  cfg->stack_offset = D.25808;
  D.25787 = cfg->stack_offset;
  D.25809 = -size;
  D.25810 = D.25787 & D.25809;
  cfg->stack_offset = D.25810;
  D.25787 = cfg->stack_offset;
  info->offset = D.25787;
  D.25787 = cfg->stack_offset;
  D.25811 = D.25787 + size;
  cfg->stack_offset = D.25811;
  goto <D.25812>;
  <D.25806>:
  D.25787 = cfg->stack_offset;
  D.25807 = size + -1;
  D.25808 = D.25787 + D.25807;
  cfg->stack_offset = D.25808;
  D.25787 = cfg->stack_offset;
  D.25809 = -size;
  D.25810 = D.25787 & D.25809;
  cfg->stack_offset = D.25810;
  D.25787 = cfg->stack_offset;
  D.25811 = D.25787 + size;
  cfg->stack_offset = D.25811;
  D.25787 = cfg->stack_offset;
  D.25813 = -D.25787;
  info->offset = D.25813;
  <D.25812>:
  <D.25786>:
  D.25814 = info->offset;
  return D.25814;
}


resize_spill_info (struct MonoCompile * cfg, int bank)
{
  int iftmp.59;
  _Bool D.25820;
  long int D.25821;
  long int D.25822;
  struct MonoMemPool * D.25825;
  long unsigned int D.25826;
  unsigned int D.25827;
  unsigned int D.25828;
  long unsigned int D.25831;
  long unsigned int D.25832;
  long unsigned int D.25833;
  long unsigned int D.25834;
  struct MonoSpillInfo * D.25835;
  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.25817>; else goto <D.25818>;
  <D.25817>:
  iftmp.59 = orig_len * 2;
  goto <D.25819>;
  <D.25818>:
  iftmp.59 = 16;
  <D.25819>:
  new_len = iftmp.59;
  D.25820 = bank > 3;
  D.25821 = (long int) D.25820;
  D.25822 = __builtin_expect (D.25821, 0);
  if (D.25822 != 0) goto <D.25823>; else goto <D.25824>;
  <D.25823>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 294, "bank < MONO_NUM_REGBANKS");
  <D.25824>:
  D.25825 = cfg->mempool;
  D.25826 = (long unsigned int) new_len;
  D.25827 = (unsigned int) D.25826;
  D.25828 = D.25827 * 4;
  new_info = mono_mempool_alloc0 (D.25825, D.25828);
  if (orig_info != 0B) goto <D.25829>; else goto <D.25830>;
  <D.25829>:
  D.25831 = (long unsigned int) orig_len;
  D.25832 = D.25831 * 4;
  memcpy (new_info, orig_info, D.25832);
  <D.25830>:
  i = orig_len;
  goto <D.23606>;
  <D.23605>:
  D.25833 = (long unsigned int) i;
  D.25834 = D.25833 * 4;
  D.25835 = new_info + D.25834;
  D.25835->offset = -1;
  i = i + 1;
  <D.23606>:
  if (i < new_len) goto <D.23605>; else goto <D.23607>;
  <D.23607>:
  cfg->spill_info[bank] = new_info;
  cfg->spill_info_len[bank] = new_len;
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.25836;
  long unsigned int D.25837;

  D.25837 = __builtin_object_size (__dest, 0);
  D.25836 = __builtin___memcpy_chk (__dest, __src, __len, D.25837);
  return D.25836;
}


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

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


mono_regstate_alloc_general (struct MonoRegState * rs, regmask_t allow, int bank)
{
  long unsigned int D.25840;
  long unsigned int D.25841;
  long unsigned int D.25842;
  long unsigned int D.25845;
  long unsigned int D.25846;
  long unsigned int D.25847;
  int D.25850;
  int D.25851;
  int i;
  int mirrored_bank;
  regmask_t mask;

  D.25840 = rs->free_mask[bank];
  mask = D.25840 & allow;
  i = 0;
  goto <D.23571>;
  <D.23570>:
  D.25841 = mask >> i;
  D.25842 = D.25841 & 1;
  if (D.25842 != 0) goto <D.25843>; else goto <D.25844>;
  <D.25843>:
  D.25840 = rs->free_mask[bank];
  D.25845 = 1 << i;
  D.25846 = ~D.25845;
  D.25847 = D.25840 & D.25846;
  rs->free_mask[bank] = D.25847;
  mirrored_bank = -1;
  if (mirrored_bank == -1) goto <D.25848>; else goto <D.25849>;
  <D.25848>:
  D.25850 = i;
  return D.25850;
  <D.25849>:
  D.25840 = rs->free_mask[bank];
  rs->free_mask[mirrored_bank] = D.25840;
  D.25850 = i;
  return D.25850;
  <D.25844>:
  i = i + 1;
  <D.23571>:
  D.25851 = regbank_size[bank];
  if (D.25851 > i) goto <D.23570>; else goto <D.23572>;
  <D.23572>:
  D.25850 = -1;
  return D.25850;
}


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

  D.25853 = bank;
  return D.25853;
}


free_up_hreg (struct MonoCompile * cfg, struct MonoBasicBlock * bb, struct MonoInst * * last, struct MonoInst * ins, int hreg, int bank)
{
  _Bool D.25855;
  long int D.25856;
  long int D.25857;
  struct MonoRegState * D.25860;
  long unsigned int D.25861;
  long unsigned int D.25862;
  long unsigned int D.25863;
  unsigned int D.25866;
  _Bool D.25867;
  long int D.25868;
  long int D.25869;
  int * D.25872;
  long unsigned int D.25873;
  long unsigned int D.25874;
  int * D.25875;
  int D.25876;
  long unsigned int D.25878;
  long unsigned int D.25879;
  long unsigned int D.25880;
  int D.25885;

  D.25855 = bank != 0;
  D.25856 = (long int) D.25855;
  D.25857 = __builtin_expect (D.25856, 0);
  if (D.25857 != 0) goto <D.25858>; else goto <D.25859>;
  <D.25858>:
  D.25860 = cfg->rs;
  D.25861 = D.25860->free_mask[bank];
  D.25862 = D.25861 >> hreg;
  D.25863 = D.25862 & 1;
  if (D.25863 == 0) goto <D.25864>; else goto <D.25865>;
  <D.25864>:
  D.25860 = cfg->rs;
  bank = translate_bank (D.25860, bank, hreg);
  D.25866 = cfg->verbose_level;
  D.25867 = D.25866 > 2;
  D.25868 = (long int) D.25867;
  D.25869 = __builtin_expect (D.25868, 0);
  if (D.25869 != 0) goto <D.25870>; else goto <D.25871>;
  <D.25870>:
  D.25860 = cfg->rs;
  D.25872 = D.25860->symbolic[bank];
  D.25873 = (long unsigned int) hreg;
  D.25874 = D.25873 * 4;
  D.25875 = D.25872 + D.25874;
  D.25876 = *D.25875;
  printf ("\tforced spill of R%d\n", D.25876);
  <D.25871>:
  D.25860 = cfg->rs;
  D.25872 = D.25860->symbolic[bank];
  D.25873 = (long unsigned int) hreg;
  D.25874 = D.25873 * 4;
  D.25875 = D.25872 + D.25874;
  D.25876 = *D.25875;
  spill_vreg (cfg, bb, last, ins, D.25876, bank);
  <D.25865>:
  goto <D.25877>;
  <D.25859>:
  D.25860 = cfg->rs;
  D.25878 = D.25860->ifree_mask;
  D.25879 = D.25878 >> hreg;
  D.25880 = D.25879 & 1;
  if (D.25880 == 0) goto <D.25881>; else goto <D.25882>;
  <D.25881>:
  D.25866 = cfg->verbose_level;
  D.25867 = D.25866 > 2;
  D.25868 = (long int) D.25867;
  D.25869 = __builtin_expect (D.25868, 0);
  if (D.25869 != 0) goto <D.25883>; else goto <D.25884>;
  <D.25883>:
  D.25860 = cfg->rs;
  D.25885 = D.25860->isymbolic[hreg];
  printf ("\tforced spill of R%d\n", D.25885);
  <D.25884>:
  D.25860 = cfg->rs;
  D.25885 = D.25860->isymbolic[hreg];
  spill_vreg (cfg, bb, last, ins, D.25885, bank);
  <D.25882>:
  <D.25877>:
}


mono_regstate_free_general (struct MonoRegState * rs, int reg, int bank)
{
  long unsigned int D.25888;
  long unsigned int D.25889;
  long unsigned int D.25890;
  int * D.25891;
  long unsigned int D.25892;
  long unsigned int D.25893;
  int * D.25894;
  int * D.25897;
  int * D.25898;
  int mirrored_bank;

  if (reg >= 0) goto <D.25886>; else goto <D.25887>;
  <D.25886>:
  D.25888 = rs->free_mask[bank];
  D.25889 = 1 << reg;
  D.25890 = D.25888 | D.25889;
  rs->free_mask[bank] = D.25890;
  D.25891 = rs->symbolic[bank];
  D.25892 = (long unsigned int) reg;
  D.25893 = D.25892 * 4;
  D.25894 = D.25891 + D.25893;
  *D.25894 = 0;
  mirrored_bank = -1;
  if (mirrored_bank == -1) goto <D.25895>; else goto <D.25896>;
  <D.25895>:
  return;
  <D.25896>:
  D.25888 = rs->free_mask[bank];
  rs->free_mask[mirrored_bank] = D.25888;
  D.25897 = rs->symbolic[mirrored_bank];
  D.25892 = (long unsigned int) reg;
  D.25893 = D.25892 * 4;
  D.25898 = D.25897 + D.25893;
  *D.25898 = 0;
  <D.25887>:
}


mono_regstate_free_int (struct MonoRegState * rs, int reg)
{
  long unsigned int D.25902;
  long unsigned int D.25903;
  long unsigned int D.25904;

  if (reg >= 0) goto <D.25900>; else goto <D.25901>;
  <D.25900>:
  D.25902 = rs->ifree_mask;
  D.25903 = 1 << reg;
  D.25904 = D.25902 | D.25903;
  rs->ifree_mask = D.25904;
  rs->isymbolic[reg] = 0;
  <D.25901>:
}


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.25905;
  int D.25906;
  short unsigned int D.25907;
  int D.25908;
  int D.25909;
  const unsigned char * D.25910;
  unsigned int D.25913;
  _Bool D.25914;
  long int D.25915;
  long int D.25916;
  const char * D.25919;
  const char * D.25920;
  struct MonoInst * D.25921;
  struct MonoInst * copy;

  D.25905 = cfg->mempool;
  copy = mono_mempool_alloc0 (D.25905, 80);
  D.25906 = regbank_move_ops[bank];
  D.25907 = (short unsigned int) D.25906;
  copy->opcode = D.25907;
  copy->dreg = -1;
  copy->sreg3 = -1;
  D.25908 = copy->sreg3;
  copy->sreg2 = D.25908;
  D.25909 = copy->sreg2;
  copy->sreg1 = D.25909;
  D.25910 = cfg->ip;
  copy->cil_code = D.25910;
  copy->dreg = dest;
  copy->sreg1 = src;
  copy->cil_code = ip;
  if (ins != 0B) goto <D.25911>; else goto <D.25912>;
  <D.25911>:
  mono_bblock_insert_after_ins (bb, ins, copy);
  *last = copy;
  <D.25912>:
  D.25913 = cfg->verbose_level;
  D.25914 = D.25913 > 2;
  D.25915 = (long int) D.25914;
  D.25916 = __builtin_expect (D.25915, 0);
  if (D.25916 != 0) goto <D.25917>; else goto <D.25918>;
  <D.25917>:
  D.25919 = mono_regname_full (src, bank);
  D.25920 = mono_regname_full (dest, bank);
  printf ("\tforced copy from %s to %s\n", D.25919, D.25920);
  <D.25918>:
  D.25921 = copy;
  return D.25921;
}


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.25923;
  long unsigned int D.25924;
  long unsigned int D.25925;
  gint32 * D.25926;
  struct MonoRegState * D.25927;
  int D.25928;
  int D.25929;
  long unsigned int D.25930;
  long unsigned int D.25931;
  gint32 * D.25932;
  int D.25933;
  _Bool D.25934;
  long int D.25935;
  long int D.25936;
  struct MonoMemPool * D.25940;
  int D.25941;
  short unsigned int D.25942;
  int D.25943;
  int D.25944;
  const unsigned char * D.25945;
  unsigned int D.25946;
  int D.25947;
  int D.25948;
  int D.25949;
  long int D.25950;
  unsigned int D.25951;
  _Bool D.25952;
  long int D.25953;
  long int D.25954;
  long int D.25957;
  const char * D.25958;
  long unsigned int D.25961;
  _Bool D.25963;
  long int D.25964;
  long int D.25965;
  struct MonoInst * load;
  int i;
  int sel;
  int spill;
  int * symbolic;
  struct MonoRegState * rs;

  rs = cfg->rs;
  symbolic = rs->symbolic[bank];
  D.25923 = rs->vassign;
  D.25924 = (long unsigned int) reg;
  D.25925 = D.25924 * 4;
  D.25926 = D.25923 + D.25925;
  sel = *D.25926;
  D.25927 = cfg->rs;
  bank = translate_bank (D.25927, bank, sel);
  i = reg;
  D.25928 = cfg->spill_count;
  D.25929 = D.25928 + 1;
  cfg->spill_count = D.25929;
  spill = cfg->spill_count;
  D.25923 = rs->vassign;
  D.25930 = (long unsigned int) i;
  D.25931 = D.25930 * 4;
  D.25932 = D.25923 + D.25931;
  D.25933 = ~spill;
  *D.25932 = D.25933;
  D.25934 = bank != 0;
  D.25935 = (long int) D.25934;
  D.25936 = __builtin_expect (D.25935, 0);
  if (D.25936 != 0) goto <D.25937>; else goto <D.25938>;
  <D.25937>:
  mono_regstate_free_general (rs, sel, bank);
  goto <D.25939>;
  <D.25938>:
  mono_regstate_free_int (rs, sel);
  <D.25939>:
  D.25940 = cfg->mempool;
  load = mono_mempool_alloc0 (D.25940, 80);
  D.25941 = regbank_load_ops[bank];
  D.25942 = (short unsigned int) D.25941;
  load->opcode = D.25942;
  load->dreg = -1;
  load->sreg3 = -1;
  D.25943 = load->sreg3;
  load->sreg2 = D.25943;
  D.25944 = load->sreg2;
  load->sreg1 = D.25944;
  D.25945 = cfg->ip;
  load->cil_code = D.25945;
  load->dreg = sel;
  D.25946 = cfg->frame_reg;
  D.25947 = (int) D.25946;
  load->sreg1 = D.25947;
  D.25948 = get_vreg_bank (cfg, reg, bank);
  D.25949 = mono_spillvar_offset (cfg, spill, D.25948);
  D.25950 = (long int) D.25949;
  load->data.op[0].const_val = D.25950;
  insert_after_ins (bb, ins, last, load);
  D.25951 = cfg->verbose_level;
  D.25952 = D.25951 > 2;
  D.25953 = (long int) D.25952;
  D.25954 = __builtin_expect (D.25953, 0);
  if (D.25954 != 0) goto <D.25955>; else goto <D.25956>;
  <D.25955>:
  D.25957 = load->data.op[0].const_val;
  D.25958 = mono_regname_full (sel, bank);
  printf ("SPILLED LOAD (%d at 0x%08lx(%%ebp)) R%d (freed %s)\n", spill, D.25957, i, D.25958);
  <D.25956>:
  D.25934 = bank != 0;
  D.25935 = (long int) D.25934;
  D.25936 = __builtin_expect (D.25935, 0);
  if (D.25936 != 0) goto <D.25959>; else goto <D.25960>;
  <D.25959>:
  D.25961 = 1 << sel;
  i = mono_regstate_alloc_general (rs, D.25961, bank);
  goto <D.25962>;
  <D.25960>:
  D.25961 = 1 << sel;
  i = mono_regstate_alloc_int (rs, D.25961);
  <D.25962>:
  D.25963 = i != sel;
  D.25964 = (long int) D.25963;
  D.25965 = __builtin_expect (D.25964, 0);
  if (D.25965 != 0) goto <D.25966>; else goto <D.25967>;
  <D.25966>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 807, "i == sel");
  <D.25967>:
  D.25934 = bank != 0;
  D.25935 = (long int) D.25934;
  D.25936 = __builtin_expect (D.25935, 0);
  if (D.25936 != 0) goto <D.25968>; else goto <D.25969>;
  <D.25968>:
  mono_regstate_free_general (rs, sel, bank);
  goto <D.25970>;
  <D.25969>:
  mono_regstate_free_int (rs, sel);
  <D.25970>:
}


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.25971;
  long int D.25972;
  long int D.25973;
  int D.25976;

  D.25971 = bank != 0;
  D.25972 = (long int) D.25971;
  D.25973 = __builtin_expect (D.25972, 0);
  if (D.25973 != 0) goto <D.25974>; else goto <D.25975>;
  <D.25974>:
  D.25976 = alloc_general_reg (cfg, bb, last, ins, dest_mask, sym_reg, bank);
  return D.25976;
  <D.25975>:
  D.25976 = alloc_int_reg (cfg, bb, last, ins, dest_mask, sym_reg, info);
  return D.25976;
}


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.25978;
  int D.25981;
  int val;

  D.25978 = cfg->rs;
  val = mono_regstate_alloc_general (D.25978, dest_mask, bank);
  if (val < 0) goto <D.25979>; else goto <D.25980>;
  <D.25979>:
  val = get_register_spilling (cfg, bb, last, ins, dest_mask, sym_reg, bank);
  <D.25980>:
  D.25981 = val;
  return D.25981;
}


assign_reg (struct MonoCompile * cfg, struct MonoRegState * rs, int reg, int hreg, int bank)
{
  _Bool D.25983;
  long int D.25984;
  long int D.25985;
  int D.25988;
  _Bool D.25989;
  long int D.25990;
  long int D.25991;
  _Bool D.25994;
  long int D.25995;
  long int D.25996;
  gint32 * D.26001;
  long unsigned int D.26002;
  long unsigned int D.26003;
  gint32 * D.26004;
  int * D.26005;
  long unsigned int D.26006;
  long unsigned int D.26007;
  int * D.26008;
  long unsigned int D.26009;
  long unsigned int D.26010;
  long unsigned int D.26011;
  long unsigned int D.26012;
  int * D.26015;
  int * D.26016;
  _Bool D.26018;
  long int D.26019;
  long int D.26020;
  _Bool D.26023;
  long int D.26024;
  long int D.26025;
  long unsigned int D.26030;
  long unsigned int D.26031;

  D.25983 = bank != 0;
  D.25984 = (long int) D.25983;
  D.25985 = __builtin_expect (D.25984, 0);
  if (D.25985 != 0) goto <D.25986>; else goto <D.25987>;
  <D.25986>:
  {
    int mirrored_bank;

    D.25988 = regbank_size[bank];
    D.25989 = D.25988 > reg;
    D.25990 = (long int) D.25989;
    D.25991 = __builtin_expect (D.25990, 0);
    if (D.25991 != 0) goto <D.25992>; else goto <D.25993>;
    <D.25992>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1040, "reg >= regbank_size [bank]");
    <D.25993>:
    D.25988 = regbank_size[bank];
    D.25994 = D.25988 <= hreg;
    D.25995 = (long int) D.25994;
    D.25996 = __builtin_expect (D.25995, 0);
    if (D.25996 != 0) goto <D.25997>; else goto <D.25998>;
    <D.25997>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1041, "hreg < regbank_size [bank]");
    <D.25998>:
    if (0 != 0) goto <D.25999>; else goto <D.26000>;
    <D.25999>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1042, "! is_global_freg (hreg)");
    <D.26000>:
    D.26001 = rs->vassign;
    D.26002 = (long unsigned int) reg;
    D.26003 = D.26002 * 4;
    D.26004 = D.26001 + D.26003;
    *D.26004 = hreg;
    D.26005 = rs->symbolic[bank];
    D.26006 = (long unsigned int) hreg;
    D.26007 = D.26006 * 4;
    D.26008 = D.26005 + D.26007;
    *D.26008 = reg;
    D.26009 = rs->free_mask[bank];
    D.26010 = 1 << hreg;
    D.26011 = ~D.26010;
    D.26012 = D.26009 & D.26011;
    rs->free_mask[bank] = D.26012;
    mirrored_bank = -1;
    if (mirrored_bank == -1) goto <D.26013>; else goto <D.26014>;
    <D.26013>:
    return;
    <D.26014>:
    D.26009 = rs->free_mask[bank];
    rs->free_mask[mirrored_bank] = D.26009;
    D.26015 = rs->symbolic[mirrored_bank];
    D.26006 = (long unsigned int) hreg;
    D.26007 = D.26006 * 4;
    D.26016 = D.26015 + D.26007;
    *D.26016 = -2;
  }
  goto <D.26017>;
  <D.25987>:
  D.26018 = reg <= 15;
  D.26019 = (long int) D.26018;
  D.26020 = __builtin_expect (D.26019, 0);
  if (D.26020 != 0) goto <D.26021>; else goto <D.26022>;
  <D.26021>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1064, "reg >= MONO_MAX_IREGS");
  <D.26022>:
  D.26023 = hreg > 15;
  D.26024 = (long int) D.26023;
  D.26025 = __builtin_expect (D.26024, 0);
  if (D.26025 != 0) goto <D.26026>; else goto <D.26027>;
  <D.26026>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1065, "hreg < MONO_MAX_IREGS");
  <D.26027>:
  if (0 != 0) goto <D.26028>; else goto <D.26029>;
  <D.26028>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1068, "! is_global_ireg (hreg)");
  <D.26029>:
  D.26001 = rs->vassign;
  D.26002 = (long unsigned int) reg;
  D.26003 = D.26002 * 4;
  D.26004 = D.26001 + D.26003;
  *D.26004 = hreg;
  rs->isymbolic[hreg] = reg;
  D.26030 = rs->ifree_mask;
  D.26010 = 1 << hreg;
  D.26011 = ~D.26010;
  D.26031 = D.26030 & D.26011;
  rs->ifree_mask = D.26031;
  <D.26017>:
}


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.26033;
  int D.26034;
  short unsigned int D.26035;
  int D.26036;
  int D.26037;
  const unsigned char * D.26038;
  unsigned int D.26039;
  int D.26040;
  int D.26041;
  long int D.26042;
  unsigned int D.26049;
  _Bool D.26050;
  long int D.26051;
  long int D.26052;
  const char * D.26055;
  long int D.26056;
  const char * D.26057;
  unsigned int bank.60;
  unsigned int D.26059;
  long unsigned int D.26062;
  long unsigned int D.26063;
  _Bool D.26066;
  long int D.26067;
  long int D.26068;
  int D.26071;
  int D.26072;
  long int D.26073;
  long int D.26074;
  struct MonoInst * store;
  struct MonoInst * def;

  bank = get_vreg_bank (cfg, prev_reg, bank);
  D.26033 = cfg->mempool;
  store = mono_mempool_alloc0 (D.26033, 80);
  D.26034 = regbank_store_ops[bank];
  D.26035 = (short unsigned int) D.26034;
  store->opcode = D.26035;
  store->dreg = -1;
  store->sreg3 = -1;
  D.26036 = store->sreg3;
  store->sreg2 = D.26036;
  D.26037 = store->sreg2;
  store->sreg1 = D.26037;
  D.26038 = cfg->ip;
  store->cil_code = D.26038;
  store->sreg1 = reg;
  D.26039 = cfg->frame_reg;
  D.26040 = (int) D.26039;
  store->dreg = D.26040;
  D.26041 = mono_spillvar_offset (cfg, spill, bank);
  D.26042 = (long int) D.26041;
  store->data.op[0].const_val = D.26042;
  if (ins != 0B) goto <D.26043>; else goto <D.26044>;
  <D.26043>:
  mono_bblock_insert_after_ins (bb, ins, store);
  *last = store;
  goto <D.26045>;
  <D.26044>:
  if (insert_before != 0B) goto <D.26046>; else goto <D.26047>;
  <D.26046>:
  insert_before_ins (bb, insert_before, store);
  goto <D.26048>;
  <D.26047>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-codegen.c", 972);
  <D.26048>:
  <D.26045>:
  D.26049 = cfg->verbose_level;
  D.26050 = D.26049 > 2;
  D.26051 = (long int) D.26050;
  D.26052 = __builtin_expect (D.26051, 0);
  if (D.26052 != 0) goto <D.26053>; else goto <D.26054>;
  <D.26053>:
  D.26055 = regbank_to_string (bank);
  D.26056 = store->data.op[0].const_val;
  D.26057 = mono_regname_full (reg, bank);
  printf ("\t%sSPILLED STORE (%d at 0x%08lx(%%ebp)) R%d (from %s)\n", D.26055, spill, D.26056, prev_reg, D.26057);
  <D.26054>:
  bank.60 = (unsigned int) bank;
  D.26059 = bank.60 + 4294967294;
  if (D.26059 <= 1) goto <D.26060>; else goto <D.26061>;
  <D.26060>:
  D.26062 = BIT_FIELD_REF <*cfg, 64, 5632>;
  D.26063 = D.26062 & 72057594037927936;
  if (D.26063 != 0) goto <D.26064>; else goto <D.26065>;
  <D.26064>:
  D.26066 = prev_reg == -1;
  D.26067 = (long int) D.26066;
  D.26068 = __builtin_expect (D.26067, 0);
  if (D.26068 != 0) goto <D.26069>; else goto <D.26070>;
  <D.26069>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 977, "prev_reg != -1");
  <D.26070>:
  D.26033 = cfg->mempool;
  def = mono_mempool_alloc0 (D.26033, 80);
  def->opcode = 840;
  def->dreg = -1;
  def->sreg3 = -1;
  D.26071 = def->sreg3;
  def->sreg2 = D.26071;
  D.26072 = def->sreg2;
  def->sreg1 = D.26072;
  D.26038 = cfg->ip;
  def->cil_code = D.26038;
  D.26073 = (long int) spill;
  def->data.op[0].const_val = D.26073;
  D.26074 = (long int) bank;
  def->data.op[1].const_val = D.26074;
  mono_bblock_insert_after_ins (bb, store, def);
  <D.26065>:
  <D.26061>:
}


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

  if (bank == 2) goto <D.26075>; else goto <D.26076>;
  <D.26075>:
  D.26077 = "REF ";
  return D.26077;
  <D.26076>:
  if (bank == 3) goto <D.26078>; else goto <D.26079>;
  <D.26078>:
  D.26077 = "MP ";
  return D.26077;
  <D.26079>:
  D.26077 = "";
  return D.26077;
}


__attribute__((visibility ("hidden")))
mono_opcode_to_cond (int opcode)
{
  CompRelation D.26081;
  const char * D.26082;

  switch (opcode) <default: <D.24176>, case 446: <D.24084>, case 447: <D.24129>, case 448: <D.24165>, case 449: <D.24118>, case 450: <D.24154>, case 451: <D.24091>, case 453: <D.24136>, case 455: <D.24125>, case 456: <D.24100>, case 458: <D.24172>, case 459: <D.24144>, case 460: <D.24161>, case 465: <D.24092>, case 467: <D.24137>, case 469: <D.24126>, case 470: <D.24101>, case 472: <D.24173>, case 473: <D.24145>, case 474: <D.24162>, case 531: <D.24088>, case 532: <D.24133>, case 533: <D.24169>, case 534: <D.24122>, case 535: <D.24158>, case 551: <D.24087>, case 552: <D.24114>, case 553: <D.24132>, case 554: <D.24107>, case 555: <D.24121>, case 556: <D.24098>, case 557: <D.24150>, case 558: <D.24168>, case 559: <D.24142>, case 560: <D.24157>, case 638: <D.24086>, case 639: <D.24131>, case 640: <D.24167>, case 641: <D.24120>, case 642: <D.24156>, case 643: <D.24096>, case 644: <D.24112>, case 645: <D.24105>, case 646: <D.24148>, case 647: <D.24140>, case 648: <D.24085>, case 649: <D.24113>, case 650: <D.24130>, case 651: <D.24106>, case 652: <D.24119>, case 653: <D.24097>, case 654: <D.24149>, case 655: <D.24166>, case 656: <D.24141>, case 657: <D.24155>, case 658: <D.24089>, case 659: <D.24115>, case 660: <D.24134>, case 661: <D.24108>, case 662: <D.24123>, case 663: <D.24099>, case 664: <D.24151>, case 665: <D.24171>, case 666: <D.24143>, case 667: <D.24159>, case 714: <D.24090>, case 715: <D.24135>, case 716: <D.24170>, case 717: <D.24124>, case 718: <D.24160>, case 719: <D.24095>, case 720: <D.24111>, case 721: <D.24104>, case 816: <D.24093>, case 817: <D.24116>, case 818: <D.24138>, case 819: <D.24109>, case 820: <D.24127>, case 821: <D.24102>, case 822: <D.24152>, case 823: <D.24174>, case 824: <D.24146>, case 825: <D.24163>, case 826: <D.24094>, case 827: <D.24117>, case 828: <D.24139>, case 829: <D.24110>, case 830: <D.24128>, case 831: <D.24103>, case 832: <D.24153>, case 833: <D.24175>, case 834: <D.24147>, case 835: <D.24164>>
  <D.24084>:
  <D.24085>:
  <D.24086>:
  <D.24087>:
  <D.24088>:
  <D.24089>:
  <D.24090>:
  <D.24091>:
  <D.24092>:
  <D.24093>:
  <D.24094>:
  D.26081 = 0;
  return D.26081;
  <D.24095>:
  <D.24096>:
  <D.24097>:
  <D.24098>:
  <D.24099>:
  <D.24100>:
  <D.24101>:
  <D.24102>:
  <D.24103>:
  D.26081 = 1;
  return D.26081;
  <D.24104>:
  <D.24105>:
  <D.24106>:
  <D.24107>:
  <D.24108>:
  <D.24109>:
  <D.24110>:
  D.26081 = 2;
  return D.26081;
  <D.24111>:
  <D.24112>:
  <D.24113>:
  <D.24114>:
  <D.24115>:
  <D.24116>:
  <D.24117>:
  D.26081 = 3;
  return D.26081;
  <D.24118>:
  <D.24119>:
  <D.24120>:
  <D.24121>:
  <D.24122>:
  <D.24123>:
  <D.24124>:
  <D.24125>:
  <D.24126>:
  <D.24127>:
  <D.24128>:
  D.26081 = 4;
  return D.26081;
  <D.24129>:
  <D.24130>:
  <D.24131>:
  <D.24132>:
  <D.24133>:
  <D.24134>:
  <D.24135>:
  <D.24136>:
  <D.24137>:
  <D.24138>:
  <D.24139>:
  D.26081 = 5;
  return D.26081;
  <D.24140>:
  <D.24141>:
  <D.24142>:
  <D.24143>:
  <D.24144>:
  <D.24145>:
  <D.24146>:
  <D.24147>:
  D.26081 = 6;
  return D.26081;
  <D.24148>:
  <D.24149>:
  <D.24150>:
  <D.24151>:
  <D.24152>:
  <D.24153>:
  D.26081 = 7;
  return D.26081;
  <D.24154>:
  <D.24155>:
  <D.24156>:
  <D.24157>:
  <D.24158>:
  <D.24159>:
  <D.24160>:
  <D.24161>:
  <D.24162>:
  <D.24163>:
  <D.24164>:
  D.26081 = 8;
  return D.26081;
  <D.24165>:
  <D.24166>:
  <D.24167>:
  <D.24168>:
  <D.24169>:
  <D.24170>:
  <D.24171>:
  <D.24172>:
  <D.24173>:
  <D.24174>:
  <D.24175>:
  D.26081 = 9;
  return D.26081;
  <D.24176>:
  D.26082 = mono_inst_name (opcode);
  printf ("%s\n", D.26082);
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-codegen.c", 2447);
  D.26081 = 0;
  return D.26081;
}


__attribute__((visibility ("hidden")))
mono_negate_cond (CompRelation cond)
{
  CompRelation D.26084;

  switch (cond) <default: <D.24190>, case 0: <D.24180>, case 1: <D.24181>, case 2: <D.24182>, case 3: <D.24183>, case 4: <D.24184>, case 5: <D.24185>, case 6: <D.24186>, case 7: <D.24187>, case 8: <D.24188>, case 9: <D.24189>>
  <D.24180>:
  D.26084 = 1;
  return D.26084;
  <D.24181>:
  D.26084 = 0;
  return D.26084;
  <D.24182>:
  D.26084 = 5;
  return D.26084;
  <D.24183>:
  D.26084 = 4;
  return D.26084;
  <D.24184>:
  D.26084 = 3;
  return D.26084;
  <D.24185>:
  D.26084 = 2;
  return D.26084;
  <D.24186>:
  D.26084 = 9;
  return D.26084;
  <D.24187>:
  D.26084 = 8;
  return D.26084;
  <D.24188>:
  D.26084 = 7;
  return D.26084;
  <D.24189>:
  D.26084 = 6;
  return D.26084;
  <D.24190>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-codegen.c", 2477);
}


__attribute__((visibility ("hidden")))
mono_opcode_to_type (int opcode, int cmp_opcode)
{
  unsigned int opcode.61;
  unsigned int D.26087;
  CompType D.26090;
  unsigned int D.26091;
  unsigned int D.26094;
  unsigned int D.26097;
  unsigned int D.26100;
  unsigned int D.26103;
  unsigned int D.26106;
  unsigned int D.26109;
  unsigned int D.26112;
  const char * D.26115;

  opcode.61 = (unsigned int) opcode;
  D.26087 = opcode.61 + 4294966850;
  if (D.26087 <= 4) goto <D.26088>; else goto <D.26089>;
  <D.26088>:
  D.26090 = 0;
  return D.26090;
  <D.26089>:
  opcode.61 = (unsigned int) opcode;
  D.26091 = opcode.61 + 4294966648;
  if (D.26091 <= 9) goto <D.26092>; else goto <D.26093>;
  <D.26092>:
  D.26090 = 1;
  return D.26090;
  <D.26093>:
  opcode.61 = (unsigned int) opcode;
  D.26094 = opcode.61 + 4294966658;
  if (D.26094 <= 4) goto <D.26095>; else goto <D.26096>;
  <D.26095>:
  D.26090 = 1;
  return D.26090;
  <D.26096>:
  opcode.61 = (unsigned int) opcode;
  D.26097 = opcode.61 + 4294966745;
  if (D.26097 <= 9) goto <D.26098>; else goto <D.26099>;
  <D.26098>:
  D.26090 = 0;
  return D.26090;
  <D.26099>:
  opcode.61 = (unsigned int) opcode;
  D.26100 = opcode.61 + 4294966765;
  if (D.26100 <= 4) goto <D.26101>; else goto <D.26102>;
  <D.26101>:
  D.26090 = 0;
  return D.26090;
  <D.26102>:
  opcode.61 = (unsigned int) opcode;
  D.26103 = opcode.61 + 4294966638;
  if (D.26103 <= 9) goto <D.26104>; else goto <D.26105>;
  <D.26104>:
  D.26090 = 2;
  return D.26090;
  <D.26105>:
  opcode.61 = (unsigned int) opcode;
  D.26106 = opcode.61 + 4294966582;
  if (D.26106 <= 4) goto <D.26107>; else goto <D.26108>;
  <D.26107>:
  D.26090 = 2;
  return D.26090;
  <D.26108>:
  opcode.61 = (unsigned int) opcode;
  D.26109 = opcode.61 + 4294966831;
  if (D.26109 <= 9) goto <D.26110>; else goto <D.26111>;
  <D.26110>:
  D.26090 = 1;
  return D.26090;
  <D.26111>:
  opcode.61 = (unsigned int) opcode;
  D.26112 = opcode.61 + 4294966845;
  if (D.26112 <= 9) goto <D.26113>; else goto <D.26114>;
  <D.26113>:
  switch (cmp_opcode) <default: <D.24197>, case 326: <D.24195>, case 327: <D.24196>>
  <D.24195>:
  <D.24196>:
  D.26090 = 1;
  return D.26090;
  <D.24197>:
  D.26090 = 0;
  return D.26090;
  <D.26114>:
  D.26115 = mono_inst_name (opcode);
  monoeg_g_log (0B, 4, "Unknown opcode \'%s\' in opcode_to_type", D.26115);
  <D.24198>:
  goto <D.24198>;
  D.26090 = 0;
  return D.26090;
}


__attribute__((visibility ("hidden")))
mono_is_regsize_var (struct MonoType * t)
{
  long unsigned int D.26117;
  long unsigned int D.26118;
  gboolean D.26121;
  unsigned char D.26122;
  int D.26123;
  int D.26124;

  D.26117 = BIT_FIELD_REF <*t, 64, 64>;
  D.26118 = D.26117 & 8589934592;
  if (D.26118 != 0) goto <D.26119>; else goto <D.26120>;
  <D.26119>:
  D.26121 = 1;
  return D.26121;
  <D.26120>:
  t = mono_type_get_underlying_type (t);
  D.26122 = t->type;
  D.26123 = (int) D.26122;
  switch (D.26123) <default: <D.24223>, case 2: <D.24202>, case 3: <D.24203>, case 4: <D.24204>, case 5: <D.24205>, case 6: <D.24206>, case 7: <D.24207>, case 8: <D.24208>, case 9: <D.24209>, case 10: <D.24214>, case 11: <D.24215>, case 14: <D.24217>, case 15: <D.24212>, case 17: <D.24222>, case 18: <D.24218>, case 20: <D.24220>, case 21: <D.24221>, case 24: <D.24210>, case 25: <D.24211>, case 27: <D.24213>, case 28: <D.24216>, case 29: <D.24219>>
  <D.24202>:
  <D.24203>:
  <D.24204>:
  <D.24205>:
  <D.24206>:
  <D.24207>:
  <D.24208>:
  <D.24209>:
  <D.24210>:
  <D.24211>:
  <D.24212>:
  <D.24213>:
  <D.24214>:
  <D.24215>:
  D.26121 = 1;
  return D.26121;
  <D.24216>:
  <D.24217>:
  <D.24218>:
  <D.24219>:
  <D.24220>:
  D.26121 = 1;
  return D.26121;
  <D.24221>:
  D.26124 = mono_type_generic_inst_is_valuetype (t);
  if (D.26124 == 0) goto <D.26125>; else goto <D.26126>;
  <D.26125>:
  D.26121 = 1;
  return D.26121;
  <D.26126>:
  D.26121 = 0;
  return D.26121;
  <D.24222>:
  D.26121 = 0;
  return D.26121;
  <D.24223>:
  D.26121 = 0;
  return D.26121;
}


__attribute__((visibility ("hidden")))
mono_peephole_ins (struct MonoBasicBlock * bb, struct MonoInst * ins)
{
  short unsigned int D.26128;
  int D.26129;
  long int D.26130;
  int D.26133;
  int D.26134;
  struct MonoInst * D.26138;
  struct MonoInst * D.26141;
  struct MonoInst * D.26144;
  struct MonoInst * D.26147;
  int D.26150;
  int D.26151;
  short unsigned int D.26154;
  int D.26164;
  long int D.26167;
  long int D.26168;
  int D.26171;
  guint16 iftmp.62;
  guint16 iftmp.63;
  struct MonoInst * last_ins;

  last_ins = ins->prev;
  D.26128 = ins->opcode;
  D.26129 = (int) D.26128;
  switch (D.26129) <default: <D.26262>, case 316: <D.24239>, case 388: <D.24231>, case 389: <D.24233>, case 390: <D.24234>, case 391: <D.24235>, case 392: <D.24236>, case 393: <D.24232>, case 424: <D.24237>, case 426: <D.24238>, case 431: <D.24229>>
  <D.24229>:
  D.26130 = ins->data.op[1].const_val;
  if (D.26130 == 1) goto <D.26131>; else goto <D.26132>;
  <D.26131>:
  D.26133 = ins->dreg;
  D.26134 = ins->sreg1;
  if (D.26133 != D.26134) goto <D.26135>; else goto <D.26136>;
  <D.26135>:
  ins->opcode = 424;
  goto <D.26137>;
  <D.26136>:
  D.26138 = ins->prev;
  if (D.26138 != 0B) goto <D.26139>; else goto <D.26140>;
  <D.26139>:
  D.26138 = ins->prev;
  D.26141 = ins->next;
  D.26138->next = D.26141;
  <D.26140>:
  D.26141 = ins->next;
  if (D.26141 != 0B) goto <D.26142>; else goto <D.26143>;
  <D.26142>:
  D.26141 = ins->next;
  D.26138 = ins->prev;
  D.26141->prev = D.26138;
  <D.26143>:
  D.26144 = bb->code;
  if (D.26144 == ins) goto <D.26145>; else goto <D.26146>;
  <D.26145>:
  D.26141 = ins->next;
  bb->code = D.26141;
  <D.26146>:
  D.26147 = bb->last_ins;
  if (D.26147 == ins) goto <D.26148>; else goto <D.26149>;
  <D.26148>:
  D.26138 = ins->prev;
  bb->last_ins = D.26138;
  <D.26149>:
  ins->opcode = 316;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.26150 = ins->sreg3;
  ins->sreg2 = D.26150;
  D.26151 = ins->sreg2;
  ins->sreg1 = D.26151;
  <D.26137>:
  <D.26132>:
  goto <D.24230>;
  <D.24231>:
  <D.24232>:
  if (last_ins != 0B) goto <D.26152>; else goto <D.26153>;
  <D.26152>:
  D.26154 = last_ins->opcode;
  if (D.26154 == 838) goto <D.26155>; else goto <D.26156>;
  <D.26155>:
  last_ins = last_ins->prev;
  <D.26156>:
  <D.26153>:
  if (last_ins != 0B) goto <D.26160>; else goto <D.26161>;
  <D.26160>:
  D.26128 = ins->opcode;
  if (D.26128 == 393) goto <D.26162>; else goto <D.26157>;
  <D.26162>:
  D.26154 = last_ins->opcode;
  if (D.26154 == 377) goto <D.26158>; else goto <D.26157>;
  <D.26157>:
  D.26128 = ins->opcode;
  if (D.26128 == 388) goto <D.26163>; else goto <D.26159>;
  <D.26163>:
  D.26154 = last_ins->opcode;
  if (D.26154 == 374) goto <D.26158>; else goto <D.26159>;
  <D.26158>:
  D.26134 = ins->sreg1;
  D.26164 = last_ins->dreg;
  if (D.26134 == D.26164) goto <D.26165>; else goto <D.26166>;
  <D.26165>:
  D.26167 = ins->data.op[0].const_val;
  D.26168 = last_ins->data.op[0].const_val;
  if (D.26167 == D.26168) goto <D.26169>; else goto <D.26170>;
  <D.26169>:
  D.26133 = ins->dreg;
  D.26171 = last_ins->sreg1;
  if (D.26133 == D.26171) goto <D.26172>; else goto <D.26173>;
  <D.26172>:
  D.26138 = ins->prev;
  if (D.26138 != 0B) goto <D.26174>; else goto <D.26175>;
  <D.26174>:
  D.26138 = ins->prev;
  D.26141 = ins->next;
  D.26138->next = D.26141;
  <D.26175>:
  D.26141 = ins->next;
  if (D.26141 != 0B) goto <D.26176>; else goto <D.26177>;
  <D.26176>:
  D.26141 = ins->next;
  D.26138 = ins->prev;
  D.26141->prev = D.26138;
  <D.26177>:
  D.26144 = bb->code;
  if (D.26144 == ins) goto <D.26178>; else goto <D.26179>;
  <D.26178>:
  D.26141 = ins->next;
  bb->code = D.26141;
  <D.26179>:
  D.26147 = bb->last_ins;
  if (D.26147 == ins) goto <D.26180>; else goto <D.26181>;
  <D.26180>:
  D.26138 = ins->prev;
  bb->last_ins = D.26138;
  <D.26181>:
  ins->opcode = 316;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.26150 = ins->sreg3;
  ins->sreg2 = D.26150;
  D.26151 = ins->sreg2;
  ins->sreg1 = D.26151;
  goto <D.24230>;
  <D.26173>:
  ins->opcode = 424;
  D.26171 = last_ins->sreg1;
  ins->sreg1 = D.26171;
  <D.26170>:
  <D.26166>:
  <D.26159>:
  <D.26161>:
  if (last_ins != 0B) goto <D.26184>; else goto <D.26185>;
  <D.26184>:
  D.26154 = last_ins->opcode;
  if (D.26154 == 393) goto <D.26182>; else goto <D.26186>;
  <D.26186>:
  D.26154 = last_ins->opcode;
  if (D.26154 == 388) goto <D.26182>; else goto <D.26183>;
  <D.26182>:
  D.26134 = ins->sreg1;
  D.26164 = last_ins->dreg;
  if (D.26134 != D.26164) goto <D.26187>; else goto <D.26188>;
  <D.26187>:
  D.26134 = ins->sreg1;
  D.26171 = last_ins->sreg1;
  if (D.26134 == D.26171) goto <D.26189>; else goto <D.26190>;
  <D.26189>:
  D.26167 = ins->data.op[0].const_val;
  D.26168 = last_ins->data.op[0].const_val;
  if (D.26167 == D.26168) goto <D.26191>; else goto <D.26192>;
  <D.26191>:
  D.26133 = ins->dreg;
  D.26164 = last_ins->dreg;
  if (D.26133 == D.26164) goto <D.26193>; else goto <D.26194>;
  <D.26193>:
  D.26138 = ins->prev;
  if (D.26138 != 0B) goto <D.26195>; else goto <D.26196>;
  <D.26195>:
  D.26138 = ins->prev;
  D.26141 = ins->next;
  D.26138->next = D.26141;
  <D.26196>:
  D.26141 = ins->next;
  if (D.26141 != 0B) goto <D.26197>; else goto <D.26198>;
  <D.26197>:
  D.26141 = ins->next;
  D.26138 = ins->prev;
  D.26141->prev = D.26138;
  <D.26198>:
  D.26144 = bb->code;
  if (D.26144 == ins) goto <D.26199>; else goto <D.26200>;
  <D.26199>:
  D.26141 = ins->next;
  bb->code = D.26141;
  <D.26200>:
  D.26147 = bb->last_ins;
  if (D.26147 == ins) goto <D.26201>; else goto <D.26202>;
  <D.26201>:
  D.26138 = ins->prev;
  bb->last_ins = D.26138;
  <D.26202>:
  ins->opcode = 316;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.26150 = ins->sreg3;
  ins->sreg2 = D.26150;
  D.26151 = ins->sreg2;
  ins->sreg1 = D.26151;
  goto <D.26203>;
  <D.26194>:
  ins->opcode = 424;
  D.26164 = last_ins->dreg;
  ins->sreg1 = D.26164;
  <D.26203>:
  <D.26192>:
  <D.26190>:
  <D.26188>:
  <D.26183>:
  <D.26185>:
  goto <D.24230>;
  <D.24233>:
  <D.24234>:
  if (last_ins != 0B) goto <D.26204>; else goto <D.26205>;
  <D.26204>:
  D.26154 = last_ins->opcode;
  if (D.26154 == 375) goto <D.26206>; else goto <D.26207>;
  <D.26206>:
  D.26134 = ins->sreg1;
  D.26164 = last_ins->dreg;
  if (D.26134 == D.26164) goto <D.26208>; else goto <D.26209>;
  <D.26208>:
  D.26167 = ins->data.op[0].const_val;
  D.26168 = last_ins->data.op[0].const_val;
  if (D.26167 == D.26168) goto <D.26210>; else goto <D.26211>;
  <D.26210>:
  D.26128 = ins->opcode;
  if (D.26128 == 389) goto <D.26213>; else goto <D.26214>;
  <D.26213>:
  iftmp.62 = 494;
  goto <D.26215>;
  <D.26214>:
  iftmp.62 = 503;
  <D.26215>:
  ins->opcode = iftmp.62;
  D.26171 = last_ins->sreg1;
  ins->sreg1 = D.26171;
  <D.26211>:
  <D.26209>:
  <D.26207>:
  <D.26205>:
  goto <D.24230>;
  <D.24235>:
  <D.24236>:
  if (last_ins != 0B) goto <D.26216>; else goto <D.26217>;
  <D.26216>:
  D.26154 = last_ins->opcode;
  if (D.26154 == 376) goto <D.26218>; else goto <D.26219>;
  <D.26218>:
  D.26134 = ins->sreg1;
  D.26164 = last_ins->dreg;
  if (D.26134 == D.26164) goto <D.26220>; else goto <D.26221>;
  <D.26220>:
  D.26167 = ins->data.op[0].const_val;
  D.26168 = last_ins->data.op[0].const_val;
  if (D.26167 == D.26168) goto <D.26222>; else goto <D.26223>;
  <D.26222>:
  D.26128 = ins->opcode;
  if (D.26128 == 391) goto <D.26225>; else goto <D.26226>;
  <D.26225>:
  iftmp.63 = 495;
  goto <D.26227>;
  <D.26226>:
  iftmp.63 = 502;
  <D.26227>:
  ins->opcode = iftmp.63;
  D.26171 = last_ins->sreg1;
  ins->sreg1 = D.26171;
  <D.26223>:
  <D.26221>:
  <D.26219>:
  <D.26217>:
  goto <D.24230>;
  <D.24237>:
  <D.24238>:
  D.26133 = ins->dreg;
  D.26134 = ins->sreg1;
  if (D.26133 == D.26134) goto <D.26228>; else goto <D.26229>;
  <D.26228>:
  D.26138 = ins->prev;
  if (D.26138 != 0B) goto <D.26230>; else goto <D.26231>;
  <D.26230>:
  D.26138 = ins->prev;
  D.26141 = ins->next;
  D.26138->next = D.26141;
  <D.26231>:
  D.26141 = ins->next;
  if (D.26141 != 0B) goto <D.26232>; else goto <D.26233>;
  <D.26232>:
  D.26141 = ins->next;
  D.26138 = ins->prev;
  D.26141->prev = D.26138;
  <D.26233>:
  D.26144 = bb->code;
  if (D.26144 == ins) goto <D.26234>; else goto <D.26235>;
  <D.26234>:
  D.26141 = ins->next;
  bb->code = D.26141;
  <D.26235>:
  D.26147 = bb->last_ins;
  if (D.26147 == ins) goto <D.26236>; else goto <D.26237>;
  <D.26236>:
  D.26138 = ins->prev;
  bb->last_ins = D.26138;
  <D.26237>:
  ins->opcode = 316;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.26150 = ins->sreg3;
  ins->sreg2 = D.26150;
  D.26151 = ins->sreg2;
  ins->sreg1 = D.26151;
  goto <D.24230>;
  <D.26229>:
  if (last_ins != 0B) goto <D.26238>; else goto <D.26239>;
  <D.26238>:
  D.26154 = last_ins->opcode;
  D.26128 = ins->opcode;
  if (D.26154 == D.26128) goto <D.26240>; else goto <D.26241>;
  <D.26240>:
  D.26134 = ins->sreg1;
  D.26164 = last_ins->dreg;
  if (D.26134 == D.26164) goto <D.26242>; else goto <D.26243>;
  <D.26242>:
  D.26133 = ins->dreg;
  D.26171 = last_ins->sreg1;
  if (D.26133 == D.26171) goto <D.26244>; else goto <D.26245>;
  <D.26244>:
  D.26138 = ins->prev;
  if (D.26138 != 0B) goto <D.26246>; else goto <D.26247>;
  <D.26246>:
  D.26138 = ins->prev;
  D.26141 = ins->next;
  D.26138->next = D.26141;
  <D.26247>:
  D.26141 = ins->next;
  if (D.26141 != 0B) goto <D.26248>; else goto <D.26249>;
  <D.26248>:
  D.26141 = ins->next;
  D.26138 = ins->prev;
  D.26141->prev = D.26138;
  <D.26249>:
  D.26144 = bb->code;
  if (D.26144 == ins) goto <D.26250>; else goto <D.26251>;
  <D.26250>:
  D.26141 = ins->next;
  bb->code = D.26141;
  <D.26251>:
  D.26147 = bb->last_ins;
  if (D.26147 == ins) goto <D.26252>; else goto <D.26253>;
  <D.26252>:
  D.26138 = ins->prev;
  bb->last_ins = D.26138;
  <D.26253>:
  ins->opcode = 316;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.26150 = ins->sreg3;
  ins->sreg2 = D.26150;
  D.26151 = ins->sreg2;
  ins->sreg1 = D.26151;
  <D.26245>:
  <D.26243>:
  <D.26241>:
  <D.26239>:
  goto <D.24230>;
  <D.24239>:
  D.26138 = ins->prev;
  if (D.26138 != 0B) goto <D.26254>; else goto <D.26255>;
  <D.26254>:
  D.26138 = ins->prev;
  D.26141 = ins->next;
  D.26138->next = D.26141;
  <D.26255>:
  D.26141 = ins->next;
  if (D.26141 != 0B) goto <D.26256>; else goto <D.26257>;
  <D.26256>:
  D.26141 = ins->next;
  D.26138 = ins->prev;
  D.26141->prev = D.26138;
  <D.26257>:
  D.26144 = bb->code;
  if (D.26144 == ins) goto <D.26258>; else goto <D.26259>;
  <D.26258>:
  D.26141 = ins->next;
  bb->code = D.26141;
  <D.26259>:
  D.26147 = bb->last_ins;
  if (D.26147 == ins) goto <D.26260>; else goto <D.26261>;
  <D.26260>:
  D.26138 = ins->prev;
  bb->last_ins = D.26138;
  <D.26261>:
  ins->opcode = 316;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.26150 = ins->sreg3;
  ins->sreg2 = D.26150;
  D.26151 = ins->sreg2;
  ins->sreg1 = D.26151;
  goto <D.24230>;
  <D.26262>:
  <D.24230>:
}


__attribute__((visibility ("hidden")))
mini_exception_id_by_name (const char * name)
{
  int D.26263;
  int D.26266;
  int D.26267;
  int D.26270;
  int D.26273;
  int D.26276;
  int D.26279;
  int D.26282;
  int D.26285;

  D.26263 = strcmp (name, "IndexOutOfRangeException");
  if (D.26263 == 0) goto <D.26264>; else goto <D.26265>;
  <D.26264>:
  D.26266 = 0;
  return D.26266;
  <D.26265>:
  D.26267 = strcmp (name, "OverflowException");
  if (D.26267 == 0) goto <D.26268>; else goto <D.26269>;
  <D.26268>:
  D.26266 = 1;
  return D.26266;
  <D.26269>:
  D.26270 = strcmp (name, "ArithmeticException");
  if (D.26270 == 0) goto <D.26271>; else goto <D.26272>;
  <D.26271>:
  D.26266 = 2;
  return D.26266;
  <D.26272>:
  D.26273 = strcmp (name, "DivideByZeroException");
  if (D.26273 == 0) goto <D.26274>; else goto <D.26275>;
  <D.26274>:
  D.26266 = 3;
  return D.26266;
  <D.26275>:
  D.26276 = strcmp (name, "InvalidCastException");
  if (D.26276 == 0) goto <D.26277>; else goto <D.26278>;
  <D.26277>:
  D.26266 = 4;
  return D.26266;
  <D.26278>:
  D.26279 = strcmp (name, "NullReferenceException");
  if (D.26279 == 0) goto <D.26280>; else goto <D.26281>;
  <D.26280>:
  D.26266 = 5;
  return D.26266;
  <D.26281>:
  D.26282 = strcmp (name, "ArrayTypeMismatchException");
  if (D.26282 == 0) goto <D.26283>; else goto <D.26284>;
  <D.26283>:
  D.26266 = 6;
  return D.26266;
  <D.26284>:
  D.26285 = strcmp (name, "ArgumentException");
  if (D.26285 == 0) goto <D.26286>; else goto <D.26287>;
  <D.26286>:
  D.26266 = 7;
  return D.26266;
  <D.26287>:
  monoeg_g_log (0B, 4, "Unknown intrinsic exception %s\n", name);
  <D.24243>:
  goto <D.24243>;
  D.26266 = -1;
  return D.26266;
}


__attribute__((__gnu_inline__, nothrow, leaf, pure))
strcmp (const char * __s1, const char * __s2)
{
  int iftmp.64;
  int iftmp.65;
  int D.26297;
  char * __p1;
  char * __p2;
  int __ret;

  __p1 = __s1;
  __p2 = __s2;
  __asm__ __volatile__("   slr   0,0
0: clst  %1,%2
   jo    0b
   ipm   %0
   srl   %0,28" : "=d" __ret, "=&a" __p1, "=&a" __p2 : "1" __p1, "2" __p2 : "0", "memory", "cc");
  if (__ret != 0) goto <D.26290>; else goto <D.26291>;
  <D.26290>:
  if (__ret == 1) goto <D.26293>; else goto <D.26294>;
  <D.26293>:
  iftmp.65 = -1;
  goto <D.26295>;
  <D.26294>:
  iftmp.65 = 1;
  <D.26295>:
  iftmp.64 = iftmp.65;
  goto <D.26296>;
  <D.26291>:
  iftmp.64 = 0;
  <D.26296>:
  __ret = iftmp.64;
  D.26297 = __ret;
  return D.26297;
}