mono_regname_full (int reg, int bank)
{
  _Bool D.24237;
  long int D.24238;
  long int D.24239;
  unsigned int bank.0;
  unsigned int D.24243;
  const char * D.24246;
  _Bool D.24247;
  long int D.24248;
  long int D.24249;

  D.24237 = bank != 0;
  D.24238 = (long int) D.24237;
  D.24239 = __builtin_expect (D.24238, 0);
  if (D.24239 != 0) goto <D.24240>; else goto <D.24241>;
  <D.24240>:
  bank.0 = (unsigned int) bank;
  D.24243 = bank.0 + 4294967294;
  if (D.24243 <= 1) goto <D.24244>; else goto <D.24245>;
  <D.24244>:
  D.24246 = mono_arch_regname (reg);
  return D.24246;
  <D.24245>:
  D.24247 = bank != 1;
  D.24248 = (long int) D.24247;
  D.24249 = __builtin_expect (D.24248, 0);
  if (D.24249 != 0) goto <D.24250>; else goto <D.24251>;
  <D.24250>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 248, "bank == MONO_REG_DOUBLE");
  <D.24251>:
  D.24246 = mono_arch_fregname (reg);
  return D.24246;
  <D.24241>:
  D.24246 = mono_arch_regname (reg);
  return D.24246;
}


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.24254;
  unsigned int vreg.2;
  _Bool D.24256;
  long int D.24257;
  long int D.24258;
  int D.24261;
  _Bool D.24262;
  long int D.24263;
  long int D.24264;
  _Bool D.24267;
  long int D.24268;
  long int D.24269;
  long unsigned int D.24272;
  int D.24273;
  long unsigned int D.24274;
  long unsigned int D.24275;
  struct MonoMemPool * D.24276;
  struct GSList * D.24277;
  long int D.24278;
  void * D.24279;
  struct GSList * D.24280;
  _Bool D.24282;
  long int D.24283;
  long int D.24284;
  _Bool D.24287;
  long int D.24288;
  long int D.24289;
  long unsigned int D.24292;
  long unsigned int D.24293;
  struct GSList * D.24294;
  struct GSList * D.24295;
  guint32 regpair;

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


g_slist_append_mempool (struct MonoMemPool * mp, struct GSList * list, void * data)
{
  struct GSList * D.24298;
  struct GSList * D.24299;
  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.24296>; else goto <D.24297>;
  <D.24296>:
  last = list;
  goto <D.9140>;
  <D.9139>:
  last = last->next;
  <D.9140>:
  D.24298 = last->next;
  if (D.24298 != 0B) goto <D.9139>; else goto <D.9141>;
  <D.9141>:
  last->next = new_list;
  D.24299 = list;
  return D.24299;
  <D.24297>:
  D.24299 = new_list;
  return D.24299;
}


mono_call_inst_add_outarg_vt (struct MonoCompile * cfg, struct MonoCallInst * call, struct MonoInst * outarg_vt)
{
  struct MonoMemPool * D.24301;
  struct GSList * D.24302;
  struct GSList * D.24303;

  D.24301 = cfg->mempool;
  D.24302 = call->outarg_vts;
  D.24303 = g_slist_append_mempool (D.24301, D.24302, outarg_vt);
  call->outarg_vts = D.24303;
}


mono_print_ji (const struct MonoJumpInfo * ji)
{
  <unnamed type> D.24304;
  struct MonoJumpInfo * D.24305;
  <unnamed type> D.24306;
  const char * D.24307;
  struct MonoMethod * D.24308;
  const char * D.24309;

  D.24304 = ji->type;
  switch (D.24304) <default: <D.23552>, case 6: <D.23550>, case 35: <D.23547>>
  <D.23547>:
  {
    struct MonoJumpInfoRgctxEntry * entry;

    entry = ji->data.rgctx_entry;
    printf ("[RGCTX_FETCH ");
    D.24305 = entry->data;
    mono_print_ji (D.24305);
    D.24306 = entry->info_type;
    D.24307 = mono_rgctx_info_type_to_str (D.24306);
    printf (" - %s]", D.24307);
    goto <D.23549>;
  }
  <D.23550>:
  {
    char * s;

    D.24308 = ji->data.method;
    s = mono_method_full_name (D.24308, 1);
    printf ("[METHODCONST - %s]", s);
    monoeg_g_free (s);
    goto <D.23549>;
  }
  <D.23552>:
  D.24304 = ji->type;
  D.24309 = patch_info_str[D.24304];
  printf ("[%s]", D.24309);
  goto <D.23549>;
  <D.23549>:
}


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

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


mono_print_ins_index (int i, struct MonoInst * ins)
{
  short unsigned int D.24312;
  int D.24313;
  int D.24314;
  short unsigned int D.24315;
  sizetype D.24316;
  const char * D.24319;
  const char * D.24321;
  int D.24324;
  long int D.24329;
  int D.24331;
  int D.24334;
  int D.24337;
  struct MonoBasicBlock * * D.24340;
  struct MonoBasicBlock * * D.24341;
  struct MonoBasicBlock * D.24342;
  struct MonoBasicBlock * D.24345;
  int D.24346;
  int D.24348;
  int D.24349;
  int * D.24352;
  sizetype D.24353;
  sizetype D.24354;
  sizetype D.24355;
  int * D.24356;
  int D.24357;
  int D.24358;
  void * D.24359;
  int D.24360;
  char D.24361;
  char D.24364;
  _Bool D.24365;
  _Bool iftmp.3;
  _Bool D.24367;
  long int D.24368;
  long int D.24369;
  int iftmp.4;
  int D.24377;
  const char * D.24392;
  const char * D.24394;
  const char * D.24396;
  const char * D.24397;
  char D.24398;
  char D.24401;
  _Bool D.24402;
  _Bool iftmp.5;
  _Bool D.24404;
  long int D.24405;
  long int D.24406;
  int iftmp.6;
  int D.24414;
  const char * D.24424;
  const char * D.24426;
  signed char D.24427;
  int D.24428;
  sizetype D.24429;
  const char * D.24430;
  char D.24431;
  char D.24432;
  _Bool D.24433;
  _Bool iftmp.7;
  _Bool D.24435;
  long int D.24436;
  long int D.24437;
  int iftmp.8;
  int D.24444;
  int D.24446;
  const char * D.24451;
  long int D.24452;
  int D.24453;
  void * D.24454;
  long int D.24455;
  int D.24456;
  long int D.24457;
  double D.24458;
  float D.24459;
  double D.24460;
  short unsigned int D.24461;
  struct MonoMethod * D.24466;
  long unsigned int D.24470;
  long unsigned int D.24471;
  const void * D.24475;
  const char * D.24480;
  void * D.24481;
  long int D.24482;
  unsigned int D.24483;
  int regpair.9;
  const char * D.24485;
  struct GSList * iftmp.10;
  struct MonoBasicBlock * D.24490;
  int D.24491;
  const char * D.24495;
  char D.24496;
  int D.24499;
  const char * spec;
  int num_sregs;
  int j;
  int sregs[3];

  try
    {
      D.24312 = ins->opcode;
      D.24313 = (int) D.24312;
      D.24314 = D.24313 + -313;
      D.24315 = ppc64_cpu_desc_idx[D.24314];
      D.24316 = (sizetype) D.24315;
      spec = &ppc64_cpu_desc + D.24316;
      if (i != -1) goto <D.24317>; else goto <D.24318>;
      <D.24317>:
      D.24312 = ins->opcode;
      D.24313 = (int) D.24312;
      D.24319 = mono_inst_name (D.24313);
      printf ("\t%-2d %s", i, D.24319);
      goto <D.24320>;
      <D.24318>:
      D.24312 = ins->opcode;
      D.24313 = (int) D.24312;
      D.24321 = mono_inst_name (D.24313);
      printf (" %s", D.24321);
      <D.24320>:
      if (spec == &ppc64_cpu_desc) goto <D.24322>; else goto <D.24323>;
      <D.24322>:
      {
        gboolean dest_base;

        dest_base = 0;
        D.24312 = ins->opcode;
        D.24313 = (int) D.24312;
        switch (D.24313) <default: <D.23564>, case 387: <D.23562>>
        <D.23562>:
        dest_base = 1;
        goto <D.23563>;
        <D.23564>:
        goto <D.23563>;
        <D.23563>:
        D.24324 = ins->dreg;
        if (D.24324 != -1) goto <D.24325>; else goto <D.24326>;
        <D.24325>:
        if (dest_base != 0) goto <D.24327>; else goto <D.24328>;
        <D.24327>:
        D.24324 = ins->dreg;
        D.24329 = ins->data.op[0].const_val;
        printf (" [R%d + 0x%lx] <-", D.24324, D.24329);
        goto <D.24330>;
        <D.24328>:
        D.24324 = ins->dreg;
        printf (" R%d <-", D.24324);
        <D.24330>:
        <D.24326>:
        D.24331 = ins->sreg1;
        if (D.24331 != -1) goto <D.24332>; else goto <D.24333>;
        <D.24332>:
        D.24331 = ins->sreg1;
        printf (" R%d", D.24331);
        <D.24333>:
        D.24334 = ins->sreg2;
        if (D.24334 != -1) goto <D.24335>; else goto <D.24336>;
        <D.24335>:
        D.24334 = ins->sreg2;
        printf (" R%d", D.24334);
        <D.24336>:
        D.24337 = ins->sreg3;
        if (D.24337 != -1) goto <D.24338>; else goto <D.24339>;
        <D.24338>:
        D.24337 = ins->sreg3;
        printf (" R%d", D.24337);
        <D.24339>:
        D.24312 = ins->opcode;
        D.24313 = (int) D.24312;
        switch (D.24313) <default: <D.23588>, case 314: <D.23584>, case 319: <D.23576>, case 320: <D.23579>, case 321: <D.23577>, case 332: <D.23587>, case 334: <D.23585>, case 367: <D.23586>, case 551: <D.23566>, case 552: <D.23571>, case 553: <D.23569>, case 554: <D.23573>, case 555: <D.23567>, case 556: <D.23565>, case 557: <D.23572>, case 558: <D.23570>, case 559: <D.23574>, case 560: <D.23568>, case 802: <D.23578>>
        <D.23565>:
        <D.23566>:
        <D.23567>:
        <D.23568>:
        <D.23569>:
        <D.23570>:
        <D.23571>:
        <D.23572>:
        <D.23573>:
        <D.23574>:
        D.24340 = ins->data.op[1].many_blocks;
        D.24341 = D.24340 + 8;
        D.24342 = *D.24341;
        if (D.24342 == 0B) goto <D.24343>; else goto <D.24344>;
        <D.24343>:
        D.24340 = ins->data.op[1].many_blocks;
        D.24345 = *D.24340;
        D.24346 = D.24345->block_num;
        printf (" [B%d]", D.24346);
        goto <D.24347>;
        <D.24344>:
        D.24340 = ins->data.op[1].many_blocks;
        D.24345 = *D.24340;
        D.24346 = D.24345->block_num;
        D.24340 = ins->data.op[1].many_blocks;
        D.24341 = D.24340 + 8;
        D.24342 = *D.24341;
        D.24348 = D.24342->block_num;
        printf (" [B%dB%d]", D.24346, D.24348);
        <D.24347>:
        goto <D.23575>;
        <D.23576>:
        <D.23577>:
        <D.23578>:
        <D.23579>:
        {
          int i;

          D.24329 = ins->data.op[0].const_val;
          D.24349 = (int) D.24329;
          printf (" [%d (", D.24349);
          i = 0;
          goto <D.23582>;
          <D.23581>:
          if (i != 0) goto <D.24350>; else goto <D.24351>;
          <D.24350>:
          printf (", ");
          <D.24351>:
          D.24352 = ins->data.op[1].phi_args;
          D.24353 = (sizetype) i;
          D.24354 = D.24353 + 1;
          D.24355 = D.24354 * 4;
          D.24356 = D.24352 + D.24355;
          D.24357 = *D.24356;
          printf ("R%d", D.24357);
          i = i + 1;
          <D.23582>:
          D.24352 = ins->data.op[1].phi_args;
          D.24358 = *D.24352;
          if (D.24358 > i) goto <D.23581>; else goto <D.23583>;
          <D.23583>:
          printf (")]");
          goto <D.23575>;
        }
        <D.23584>:
        <D.23585>:
        D.24359 = ins->data.op[0].p;
        D.24360 = MEM[(struct MonoInst *)D.24359].dreg;
        printf (" R%d", D.24360);
        goto <D.23575>;
        <D.23586>:
        <D.23587>:
        D.24329 = ins->data.op[0].const_val;
        printf (" + 0x%lx", D.24329);
        goto <D.23575>;
        <D.23588>:
        goto <D.23575>;
        <D.23575>:
        printf ("\n");
        return;
      }
      <D.24323>:
      D.24361 = *spec;
      if (D.24361 != 0) goto <D.24362>; else goto <D.24363>;
      <D.24362>:
      {
        int bank;

        D.24361 = *spec;
        D.24364 = D.24361 + 154;
        D.24365 = D.24364 <= 1;
        bank = (int) D.24365;
        D.24367 = bank != 0;
        D.24368 = (long int) D.24367;
        D.24369 = __builtin_expect (D.24368, 0);
        if (D.24369 != 0) goto <D.24370>; else goto <D.24371>;
        <D.24370>:
        D.24324 = ins->dreg;
        if (D.24324 < 0) goto <D.24373>; else goto <D.24376>;
        <D.24376>:
        D.24324 = ins->dreg;
        D.24377 = regbank_size[bank];
        if (D.24324 >= D.24377) goto <D.24373>; else goto <D.24374>;
        <D.24373>:
        iftmp.4 = 1;
        goto <D.24375>;
        <D.24374>:
        iftmp.4 = 0;
        <D.24375>:
        iftmp.3 = (_Bool) iftmp.4;
        goto <D.24378>;
        <D.24371>:
        D.24324 = ins->dreg;
        iftmp.3 = D.24324 > 31;
        <D.24378>:
        if (iftmp.3 != 0) goto <D.24379>; else goto <D.24380>;
        <D.24379>:
        D.24361 = *spec;
        if (D.24361 == 98) goto <D.24381>; else goto <D.24382>;
        <D.24381>:
        D.24329 = ins->data.op[0].const_val;
        if (D.24329 == 0) goto <D.24383>; else goto <D.24384>;
        <D.24383>:
        D.24324 = ins->dreg;
        printf (" [R%d] <-", D.24324);
        goto <D.24385>;
        <D.24384>:
        D.24324 = ins->dreg;
        D.24329 = ins->data.op[0].const_val;
        printf (" [R%d + 0x%lx] <-", D.24324, D.24329);
        <D.24385>:
        goto <D.24386>;
        <D.24382>:
        D.24324 = ins->dreg;
        printf (" R%d <-", D.24324);
        <D.24386>:
        goto <D.24387>;
        <D.24380>:
        D.24361 = *spec;
        if (D.24361 == 98) goto <D.24388>; else goto <D.24389>;
        <D.24388>:
        D.24329 = ins->data.op[0].const_val;
        if (D.24329 == 0) goto <D.24390>; else goto <D.24391>;
        <D.24390>:
        D.24324 = ins->dreg;
        D.24392 = mono_arch_regname (D.24324);
        printf (" [%s] <-", D.24392);
        goto <D.24393>;
        <D.24391>:
        D.24324 = ins->dreg;
        D.24394 = mono_arch_regname (D.24324);
        D.24329 = ins->data.op[0].const_val;
        printf (" [%s + 0x%lx] <-", D.24394, D.24329);
        <D.24393>:
        goto <D.24395>;
        <D.24389>:
        D.24324 = ins->dreg;
        D.24396 = mono_regname_full (D.24324, bank);
        printf (" %s <-", D.24396);
        <D.24395>:
        <D.24387>:
      }
      <D.24363>:
      D.24397 = spec + 1;
      D.24398 = *D.24397;
      if (D.24398 != 0) goto <D.24399>; else goto <D.24400>;
      <D.24399>:
      {
        int bank;

        D.24397 = spec + 1;
        D.24398 = *D.24397;
        D.24401 = D.24398 + 154;
        D.24402 = D.24401 <= 1;
        bank = (int) D.24402;
        D.24404 = bank != 0;
        D.24405 = (long int) D.24404;
        D.24406 = __builtin_expect (D.24405, 0);
        if (D.24406 != 0) goto <D.24407>; else goto <D.24408>;
        <D.24407>:
        D.24331 = ins->sreg1;
        if (D.24331 < 0) goto <D.24410>; else goto <D.24413>;
        <D.24413>:
        D.24331 = ins->sreg1;
        D.24414 = regbank_size[bank];
        if (D.24331 >= D.24414) goto <D.24410>; else goto <D.24411>;
        <D.24410>:
        iftmp.6 = 1;
        goto <D.24412>;
        <D.24411>:
        iftmp.6 = 0;
        <D.24412>:
        iftmp.5 = (_Bool) iftmp.6;
        goto <D.24415>;
        <D.24408>:
        D.24331 = ins->sreg1;
        iftmp.5 = D.24331 > 31;
        <D.24415>:
        if (iftmp.5 != 0) goto <D.24416>; else goto <D.24417>;
        <D.24416>:
        D.24397 = spec + 1;
        D.24398 = *D.24397;
        if (D.24398 == 98) goto <D.24418>; else goto <D.24419>;
        <D.24418>:
        D.24331 = ins->sreg1;
        D.24329 = ins->data.op[0].const_val;
        printf (" [R%d + 0x%lx]", D.24331, D.24329);
        goto <D.24420>;
        <D.24419>:
        D.24331 = ins->sreg1;
        printf (" R%d", D.24331);
        <D.24420>:
        goto <D.24421>;
        <D.24417>:
        D.24397 = spec + 1;
        D.24398 = *D.24397;
        if (D.24398 == 98) goto <D.24422>; else goto <D.24423>;
        <D.24422>:
        D.24331 = ins->sreg1;
        D.24424 = mono_arch_regname (D.24331);
        D.24329 = ins->data.op[0].const_val;
        printf (" [%s + 0x%lx]", D.24424, D.24329);
        goto <D.24425>;
        <D.24423>:
        D.24331 = ins->sreg1;
        D.24426 = mono_regname_full (D.24331, bank);
        printf (" %s", D.24426);
        <D.24425>:
        <D.24421>:
      }
      <D.24400>:
      D.24331 = ins->sreg1;
      sregs[0] = D.24331;
      D.24334 = ins->sreg2;
      sregs[1] = D.24334;
      D.24337 = ins->sreg3;
      sregs[2] = D.24337;
      D.24312 = ins->opcode;
      D.24313 = (int) D.24312;
      D.24314 = D.24313 + -313;
      D.24427 = ins_sreg_counts[D.24314];
      num_sregs = (int) D.24427;
      j = 1;
      goto <D.23593>;
      <D.23592>:
      {
        int bank;

        D.24428 = j + 1;
        D.24429 = (sizetype) D.24428;
        D.24430 = spec + D.24429;
        D.24431 = *D.24430;
        D.24432 = D.24431 + 154;
        D.24433 = D.24432 <= 1;
        bank = (int) D.24433;
        D.24435 = bank != 0;
        D.24436 = (long int) D.24435;
        D.24437 = __builtin_expect (D.24436, 0);
        if (D.24437 != 0) goto <D.24438>; else goto <D.24439>;
        <D.24438>:
        D.24444 = sregs[j];
        if (D.24444 < 0) goto <D.24441>; else goto <D.24445>;
        <D.24445>:
        D.24444 = sregs[j];
        D.24446 = regbank_size[bank];
        if (D.24444 >= D.24446) goto <D.24441>; else goto <D.24442>;
        <D.24441>:
        iftmp.8 = 1;
        goto <D.24443>;
        <D.24442>:
        iftmp.8 = 0;
        <D.24443>:
        iftmp.7 = (_Bool) iftmp.8;
        goto <D.24447>;
        <D.24439>:
        D.24444 = sregs[j];
        iftmp.7 = D.24444 > 31;
        <D.24447>:
        if (iftmp.7 != 0) goto <D.24448>; else goto <D.24449>;
        <D.24448>:
        D.24444 = sregs[j];
        printf (" R%d", D.24444);
        goto <D.24450>;
        <D.24449>:
        D.24444 = sregs[j];
        D.24451 = mono_regname_full (D.24444, bank);
        printf (" %s", D.24451);
        <D.24450>:
      }
      j = j + 1;
      <D.23593>:
      if (j < num_sregs) goto <D.23592>; else goto <D.23594>;
      <D.23594>:
      D.24312 = ins->opcode;
      D.24313 = (int) D.24312;
      switch (D.24313) <default: <D.23662>, case 323: <D.23598>, case 327: <D.23597>, case 341: <D.23661>, case 343: <D.23621>, case 345: <D.23622>, case 346: <D.23610>, case 347: <D.23612>, case 348: <D.23611>, case 349: <D.23613>, case 352: <D.23614>, case 355: <D.23615>, case 356: <D.23616>, case 357: <D.23617>, case 358: <D.23618>, case 359: <D.23619>, case 360: <D.23620>, case 362: <D.23595>, case 363: <D.23607>, case 364: <D.23609>, case 365: <D.23608>, case 429: <D.23605>, case 430: <D.23604>, case 442: <D.23635>, case 444: <D.23623>, case 538: <D.23606>, case 551: <D.23648>, case 552: <D.23653>, case 553: <D.23651>, case 554: <D.23655>, case 555: <D.23649>, case 556: <D.23647>, case 557: <D.23654>, case 558: <D.23652>, case 559: <D.23656>, case 560: <D.23650>, case 625: <D.23599>, case 626: <D.23600>, case 632: <D.23601>, case 633: <D.23602>, case 634: <D.23603>, case 648: <D.23638>, case 649: <D.23643>, case 650: <D.23641>, case 651: <D.23645>, case 652: <D.23639>, case 653: <D.23637>, case 654: <D.23644>, case 655: <D.23642>, case 656: <D.23646>, case 657: <D.23640>, case 735: <D.23636>, case 836: <D.23657>, case 837: <D.23658>, case 838: <D.23659>, case 839: <D.23660>>
      <D.23595>:
      D.24329 = ins->data.op[0].const_val;
      D.24349 = (int) D.24329;
      printf (" [%d]", D.24349);
      goto <D.23596>;
      <D.23597>:
      <D.23598>:
      <D.23599>:
      <D.23600>:
      <D.23601>:
      <D.23602>:
      <D.23603>:
      <D.23604>:
      D.24452 = ins->data.op[1].const_val;
      D.24453 = (int) D.24452;
      printf (" [%d]", D.24453);
      goto <D.23596>;
      <D.23605>:
      <D.23606>:
      D.24454 = ins->data.op[1].p;
      D.24455 = (long int) D.24454;
      D.24456 = (int) D.24455;
      printf (" [%d]", D.24456);
      goto <D.23596>;
      <D.23607>:
      D.24457 = ins->data.i8const;
      printf (" [%lld]", D.24457);
      goto <D.23596>;
      <D.23608>:
      D.24359 = ins->data.op[0].p;
      D.24458 = MEM[(double *)D.24359];
      printf (" [%f]", D.24458);
      goto <D.23596>;
      <D.23609>:
      D.24359 = ins->data.op[0].p;
      D.24459 = MEM[(float *)D.24359];
      D.24460 = (double) D.24459;
      printf (" [%f]", D.24460);
      goto <D.23596>;
      <D.23610>:
      <D.23611>:
      <D.23612>:
      <D.23613>:
      <D.23614>:
      <D.23615>:
      <D.23616>:
      <D.23617>:
      <D.23618>:
      <D.23619>:
      <D.23620>:
      <D.23621>:
      <D.23622>:
      <D.23623>:
      {
        struct MonoCallInst * call;
        struct GSList * list;

        call = ins;
        D.24312 = ins->opcode;
        D.24461 = D.24312 + 65181;
        if (D.24461 <= 2) goto <D.24462>; else goto <D.24463>;
        <D.24462>:
        D.24324 = ins->dreg;
        if (D.24324 != -1) goto <D.24464>; else goto <D.24465>;
        <D.24464>:
        D.24324 = ins->dreg;
        printf (" R%d <-", D.24324);
        <D.24465>:
        <D.24463>:
        D.24466 = call->method;
        if (D.24466 != 0B) goto <D.24467>; else goto <D.24468>;
        <D.24467>:
        {
          char * full_name;

          D.24466 = call->method;
          full_name = mono_method_full_name (D.24466, 1);
          printf (" [%s]", full_name);
          monoeg_g_free (full_name);
        }
        goto <D.24469>;
        <D.24468>:
        D.24470 = BIT_FIELD_REF <*call, 64, 1088>;
        D.24471 = D.24470 & 4;
        if (D.24471 != 0) goto <D.24472>; else goto <D.24473>;
        <D.24472>:
        {
          struct MonoJumpInfo * ji;

          ji = call->fptr;
          printf (" ");
          mono_print_ji (ji);
        }
        goto <D.24474>;
        <D.24473>:
        D.24475 = call->fptr;
        if (D.24475 != 0B) goto <D.24476>; else goto <D.24477>;
        <D.24476>:
        {
          struct MonoJitICallInfo * info;

          D.24475 = call->fptr;
          info = mono_find_jit_icall_by_addr (D.24475);
          if (info != 0B) goto <D.24478>; else goto <D.24479>;
          <D.24478>:
          D.24480 = info->name;
          printf (" [%s]", D.24480);
          <D.24479>:
        }
        <D.24477>:
        <D.24474>:
        <D.24469>:
        list = call->out_ireg_args;
        goto <D.23633>;
        <D.23632>:
        {
          guint32 regpair;
          int reg;
          int hreg;

          D.24481 = list->data;
          D.24482 = (long int) D.24481;
          regpair = (guint32) D.24482;
          D.24483 = regpair >> 24;
          hreg = (int) D.24483;
          regpair.9 = (int) regpair;
          reg = regpair.9 & 16777215;
          D.24485 = mono_arch_regname (hreg);
          printf (" [%s <- R%d]", D.24485, reg);
          if (list != 0B) goto <D.24487>; else goto <D.24488>;
          <D.24487>:
          iftmp.10 = list->next;
          goto <D.24489>;
          <D.24488>:
          iftmp.10 = 0B;
          <D.24489>:
          list = iftmp.10;
        }
        <D.23633>:
        if (list != 0B) goto <D.23632>; else goto <D.23634>;
        <D.23634>:
        goto <D.23596>;
      }
      <D.23635>:
      <D.23636>:
      D.24490 = ins->data.op[0].target_block;
      D.24491 = D.24490->block_num;
      printf (" [B%d]", D.24491);
      goto <D.23596>;
      <D.23637>:
      <D.23638>:
      <D.23639>:
      <D.23640>:
      <D.23641>:
      <D.23642>:
      <D.23643>:
      <D.23644>:
      <D.23645>:
      <D.23646>:
      <D.23647>:
      <D.23648>:
      <D.23649>:
      <D.23650>:
      <D.23651>:
      <D.23652>:
      <D.23653>:
      <D.23654>:
      <D.23655>:
      <D.23656>:
      D.24340 = ins->data.op[1].many_blocks;
      D.24341 = D.24340 + 8;
      D.24342 = *D.24341;
      if (D.24342 == 0B) goto <D.24492>; else goto <D.24493>;
      <D.24492>:
      D.24340 = ins->data.op[1].many_blocks;
      D.24345 = *D.24340;
      D.24346 = D.24345->block_num;
      printf (" [B%d]", D.24346);
      goto <D.24494>;
      <D.24493>:
      D.24340 = ins->data.op[1].many_blocks;
      D.24345 = *D.24340;
      D.24346 = D.24345->block_num;
      D.24340 = ins->data.op[1].many_blocks;
      D.24341 = D.24340 + 8;
      D.24342 = *D.24341;
      D.24348 = D.24342->block_num;
      printf (" [B%dB%d]", D.24346, D.24348);
      <D.24494>:
      goto <D.23596>;
      <D.23657>:
      <D.23658>:
      <D.23659>:
      <D.23660>:
      D.24452 = ins->data.op[1].const_val;
      D.24453 = (int) D.24452;
      printf (" R%d", D.24453);
      goto <D.23596>;
      <D.23661>:
      D.24452 = ins->data.op[1].const_val;
      D.24453 = (int) D.24452;
      printf (" il: %x", D.24453);
      goto <D.23596>;
      <D.23662>:
      goto <D.23596>;
      <D.23596>:
      D.24495 = spec + 5;
      D.24496 = *D.24495;
      if (D.24496 != 0) goto <D.24497>; else goto <D.24498>;
      <D.24497>:
      D.24495 = spec + 5;
      D.24496 = *D.24495;
      D.24499 = (int) D.24496;
      printf (" clobbers: %c", D.24499);
      <D.24498>:
      printf ("\n");
    }
  finally
    {
      sregs = {CLOBBER};
    }
}


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


mono_local_regalloc (struct MonoCompile * cfg, struct MonoBasicBlock * bb)
{
  struct MonoInst * D.24506;
  int desc_to_fixed_reg_inited.11;
  gint8 iftmp.12;
  gint8 iftmp.13;
  unsigned int D.24520;
  int D.24521;
  long unsigned int D.24522;
  void * D.24523;
  int D.24526;
  int D.24531;
  int D.24532;
  struct MonoMemPool * D.24533;
  long unsigned int D.24534;
  unsigned int D.24535;
  unsigned int D.24536;
  void * D.24537;
  int D.24539;
  _Bool D.24540;
  long int D.24541;
  long int D.24542;
  unsigned int D.24545;
  long unsigned int D.24548;
  short unsigned int D.24549;
  int D.24550;
  int D.24551;
  short unsigned int D.24552;
  sizetype D.24553;
  int D.24554;
  long unsigned int D.24559;
  long unsigned int D.24560;
  void * D.24561;
  int D.24562;
  int D.24563;
  int D.24564;
  signed char D.24565;
  int D.24566;
  _Bool D.24567;
  long int D.24568;
  long int D.24569;
  long unsigned int D.24574;
  long unsigned int D.24575;
  void * D.24576;
  _Bool D.24577;
  long int D.24578;
  long int D.24579;
  int D.24582;
  _Bool D.24583;
  long int D.24584;
  long int D.24585;
  const char * D.24588;
  int D.24591;
  sizetype D.24592;
  const char * D.24593;
  char D.24594;
  char D.24597;
  _Bool D.24598;
  _Bool D.24599;
  long int D.24600;
  long int D.24601;
  _Bool iftmp.14;
  _Bool D.24605;
  long int D.24606;
  long int D.24607;
  int iftmp.15;
  int D.24615;
  long unsigned int D.24619;
  long unsigned int D.24620;
  struct RegTrack * D.24621;
  int D.24622;
  _Bool D.24623;
  long int D.24624;
  long int D.24625;
  gint32 * D.24628;
  long unsigned int D.24629;
  gint32 * D.24630;
  sizetype D.24633;
  sizetype D.24634;
  sizetype D.24635;
  gint32 * D.24636;
  sizetype D.24639;
  struct RegTrack * D.24640;
  int D.24641;
  char D.24646;
  char D.24647;
  _Bool D.24648;
  struct RegTrack * D.24651;
  _Bool D.24652;
  long int D.24653;
  long int D.24654;
  long unsigned int D.24657;
  gint32 * D.24658;
  int D.24661;
  int D.24663;
  signed char D.24664;
  long unsigned int D.24667;
  sizetype D.24670;
  sizetype D.24671;
  sizetype D.24672;
  gint32 * D.24673;
  sizetype D.24676;
  struct RegTrack * D.24677;
  int D.24678;
  const char * D.24685;
  char D.24686;
  short unsigned int D.24689;
  short unsigned int D.24691;
  short unsigned int D.24693;
  short unsigned int D.24695;
  short unsigned int D.24697;
  short unsigned int D.24699;
  void * D.24703;
  long int D.24704;
  unsigned int D.24705;
  int regpair.16;
  struct GSList * iftmp.17;
  unsigned int D.24713;
  int regpair.18;
  struct GSList * iftmp.19;
  struct MonoInst * iftmp.20;
  const char * D.24725;
  long unsigned int D.24726;
  int D.24727;
  signed char D.24728;
  int D.24729;
  int D.24734;
  signed char D.24735;
  long unsigned int D.24736;
  long unsigned int D.24741;
  long unsigned int D.24744;
  long unsigned int D.24745;
  long unsigned int D.24746;
  int D.24749;
  long unsigned int D.24752;
  long unsigned int D.24753;
  gint32 * D.24754;
  int D.24755;
  long unsigned int D.24760;
  long unsigned int D.24761;
  gint32 * D.24762;
  int D.24763;
  long unsigned int D.24768;
  long unsigned int D.24769;
  long unsigned int D.24770;
  unsigned int sreg.21;
  long unsigned int D.24777;
  long unsigned int D.24778;
  long unsigned int D.24782;
  long unsigned int D.24783;
  const char * D.24788;
  long unsigned int D.24794;
  long unsigned int D.24795;
  long unsigned int D.24799;
  long unsigned int D.24800;
  _Bool D.24808;
  long int D.24809;
  long int D.24810;
  const char * D.24815;
  const char * D.24816;
  _Bool iftmp.22;
  int iftmp.23;
  int D.24850;
  long unsigned int D.24853;
  long unsigned int D.24854;
  int D.24855;
  long unsigned int D.24858;
  long unsigned int D.24859;
  _Bool iftmp.24;
  int iftmp.25;
  long unsigned int D.24873;
  long unsigned int D.24874;
  long int iftmp.26;
  int iftmp.27;
  _Bool D.24887;
  int D.24888;
  _Bool D.24890;
  int D.24891;
  long int D.24892;
  int D.24897;
  int D.24900;
  long unsigned int D.24903;
  long unsigned int D.24904;
  gint32 * D.24905;
  int D.24906;
  unsigned int D.24907;
  int dest_dreg2.28;
  unsigned int D.24917;
  long unsigned int D.24919;
  long unsigned int D.24920;
  _Bool iftmp.29;
  int iftmp.30;
  const char * D.24943;
  _Bool D.24948;
  long int D.24949;
  long int D.24950;
  int iftmp.31;
  long unsigned int D.24956;
  long unsigned int D.24957;
  gint32 * D.24958;
  int D.24959;
  unsigned int D.24960;
  long unsigned int D.24962;
  long unsigned int D.24963;
  _Bool D.24965;
  long int D.24966;
  long int D.24967;
  long unsigned int D.24970;
  long unsigned int D.24971;
  gint32 * D.24972;
  long unsigned int D.24982;
  long unsigned int D.24983;
  int D.24988;
  const char * D.24991;
  _Bool iftmp.32;
  _Bool iftmp.33;
  int iftmp.34;
  int iftmp.35;
  _Bool D.25008;
  long unsigned int D.25012;
  long unsigned int D.25013;
  long unsigned int D.25014;
  int iftmp.36;
  unsigned int val.37;
  long unsigned int D.25022;
  long unsigned int D.25023;
  int iftmp.38;
  long unsigned int D.25035;
  struct RegTrack * D.25036;
  int D.25037;
  const char * D.25042;
  _Bool iftmp.39;
  int iftmp.40;
  _Bool D.25058;
  long int D.25059;
  long int D.25060;
  const char * D.25065;
  long unsigned int D.25066;
  struct RegTrack * D.25067;
  int D.25068;
  struct MonoRegState * D.25078;
  int * D.25079;
  long unsigned int D.25080;
  long unsigned int D.25081;
  int * D.25082;
  int D.25083;
  int D.25084;
  int D.25088;
  long unsigned int D.25095;
  long unsigned int D.25096;
  long unsigned int D.25097;
  long unsigned int D.25098;
  long unsigned int D.25101;
  long unsigned int D.25102;
  int D.25107;
  unsigned char D.25115;
  sizetype D.25119;
  sizetype D.25120;
  sizetype D.25121;
  gint32 * D.25122;
  long unsigned int D.25124;
  long unsigned int D.25125;
  long unsigned int D.25126;
  long unsigned int D.25129;
  long unsigned int D.25130;
  int D.25139;
  long unsigned int D.25142;
  long unsigned int D.25143;
  gint32 * D.25144;
  long unsigned int D.25145;
  long unsigned int D.25146;
  long unsigned int D.25157;
  int * D.25163;
  long unsigned int D.25164;
  long unsigned int D.25165;
  int * D.25166;
  int D.25167;
  long unsigned int D.25170;
  long unsigned int D.25171;
  gint32 * D.25172;
  int D.25173;
  void * D.25186;
  long int D.25187;
  unsigned int D.25188;
  int regpair.41;
  long unsigned int D.25190;
  long unsigned int D.25191;
  long unsigned int D.25192;
  long unsigned int D.25193;
  const char * D.25196;
  struct GSList * iftmp.42;
  unsigned int D.25203;
  int regpair.43;
  const char * D.25207;
  struct GSList * iftmp.44;
  char D.25212;
  char D.25213;
  _Bool D.25214;
  long int iftmp.45;
  int iftmp.46;
  _Bool D.25225;
  int D.25226;
  _Bool D.25228;
  int D.25229;
  long int D.25230;
  _Bool D.25235;
  long int D.25236;
  long int D.25237;
  _Bool D.25240;
  long int D.25241;
  long int D.25242;
  long unsigned int D.25245;
  long unsigned int D.25246;
  gint32 * D.25247;
  int D.25248;
  const char * D.25255;
  long unsigned int D.25256;
  long unsigned int D.25257;
  _Bool D.25258;
  long int D.25259;
  long int D.25260;
  long unsigned int D.25263;
  sizetype D.25266;
  sizetype D.25267;
  sizetype D.25268;
  gint32 * D.25269;
  int D.25270;
  int D.25275;
  const char * D.25278;
  long unsigned int D.25279;
  int D.25286;
  unsigned int D.25287;
  long unsigned int D.25289;
  long unsigned int D.25290;
  long unsigned int D.25294;
  long unsigned int D.25297;
  long unsigned int D.25298;
  gint32 * D.25299;
  int D.25300;
  long unsigned int D.25303;
  long unsigned int D.25304;
  _Bool iftmp.47;
  int iftmp.48;
  int D.25328;
  long unsigned int D.25333;
  long unsigned int D.25334;
  long unsigned int D.25337;
  long unsigned int D.25338;
  long unsigned int D.25347;
  struct RegTrack * D.25348;
  const char * D.25351;
  int D.25354;
  long unsigned int D.25360;
  long unsigned int D.25362;
  long unsigned int D.25363;
  long unsigned int D.25364;
  _Bool D.25369;
  long int D.25370;
  long int D.25371;
  int iftmp.49;
  long unsigned int D.25377;
  long unsigned int D.25378;
  gint32 * D.25379;
  int D.25380;
  unsigned int D.25381;
  long unsigned int D.25383;
  long unsigned int D.25384;
  _Bool D.25386;
  long int D.25387;
  long int D.25388;
  long unsigned int D.25391;
  long unsigned int D.25392;
  gint32 * D.25393;
  const char * D.25407;
  unsigned char D.25414;
  _Bool D.25415;
  int D.25416;
  const char * D.25421;
  const char * D.25422;
  _Bool D.25423;
  long int D.25424;
  long int D.25425;
  sizetype D.25431;
  sizetype D.25432;
  sizetype D.25433;
  gint32 * D.25434;
  int D.25435;
  _Bool D.25438;
  long int D.25439;
  long int D.25440;
  _Bool D.25443;
  long int D.25444;
  long int D.25445;
  const char * D.25450;
  const char * D.25451;
  long unsigned int D.25454;
  long unsigned int D.25455;
  unsigned int D.25461;
  long unsigned int D.25463;
  long unsigned int D.25464;
  _Bool iftmp.50;
  int iftmp.51;
  long unsigned int D.25477;
  gint32 * D.25478;
  struct RegTrack * D.25489;
  const char * D.25492;
  long unsigned int D.25495;
  long unsigned int D.25496;
  long unsigned int D.25497;
  long unsigned int D.25498;
  _Bool D.25504;
  long int D.25505;
  long int D.25506;
  int D.25511;
  _Bool D.25512;
  long int D.25513;
  long int D.25514;
  struct MonoInst * iftmp.52;
  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.24506 = bb->code;
      if (D.24506 == 0B) goto <D.24507>; else goto <D.24508>;
      <D.24507>:
      return;
      <D.24508>:
      desc_to_fixed_reg_inited.11 = desc_to_fixed_reg_inited;
      if (desc_to_fixed_reg_inited.11 == 0) goto <D.24510>; else goto <D.24511>;
      <D.24510>:
      i = 0;
      goto <D.23836>;
      <D.23835>:
      if (i != 97) goto <D.24513>; else goto <D.24514>;
      <D.24513>:
      if (i == 103) goto <D.24516>; else goto <D.24517>;
      <D.24516>:
      iftmp.13 = 1;
      goto <D.24518>;
      <D.24517>:
      iftmp.13 = -1;
      <D.24518>:
      iftmp.12 = iftmp.13;
      goto <D.24519>;
      <D.24514>:
      iftmp.12 = 3;
      <D.24519>:
      desc_to_fixed_reg[i] = iftmp.12;
      i = i + 1;
      <D.23836>:
      if (i <= 255) goto <D.23835>; else goto <D.23837>;
      <D.23837>:
      desc_to_fixed_reg_inited = 1;
      <D.24511>:
      D.24520 = bb->max_vreg;
      D.24521 = (int) D.24520;
      rs->next_vreg = D.24521;
      mono_regstate_assign (rs);
      rs->ifree_mask = 8184;
      i = 0;
      goto <D.23839>;
      <D.23838>:
      D.24522 = regbank_callee_regs[i];
      rs->free_mask[i] = D.24522;
      i = i + 1;
      <D.23839>:
      if (i <= 3) goto <D.23838>; else goto <D.23840>;
      <D.23840>:
      max = rs->next_vreg;
      D.24523 = cfg->reginfo;
      if (D.24523 != 0B) goto <D.24524>; else goto <D.24525>;
      <D.24524>:
      D.24526 = cfg->reginfo_len;
      if (D.24526 < max) goto <D.24527>; else goto <D.24528>;
      <D.24527>:
      cfg->reginfo = 0B;
      <D.24528>:
      <D.24525>:
      reginfo = cfg->reginfo;
      if (reginfo == 0B) goto <D.24529>; else goto <D.24530>;
      <D.24529>:
      D.24531 = max * 2;
      D.24532 = MAX_EXPR <D.24531, 1024>;
      cfg->reginfo_len = D.24532;
      D.24533 = cfg->mempool;
      D.24526 = cfg->reginfo_len;
      D.24534 = (long unsigned int) D.24526;
      D.24535 = (unsigned int) D.24534;
      D.24536 = D.24535 * 16;
      D.24537 = mono_mempool_alloc (D.24533, D.24536);
      cfg->reginfo = D.24537;
      reginfo = cfg->reginfo;
      goto <D.24538>;
      <D.24530>:
      D.24526 = cfg->reginfo_len;
      D.24539 = rs->next_vreg;
      D.24540 = D.24526 < D.24539;
      D.24541 = (long int) D.24540;
      D.24542 = __builtin_expect (D.24541, 0);
      if (D.24542 != 0) goto <D.24543>; else goto <D.24544>;
      <D.24543>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1160, "cfg->reginfo_len >= rs->next_vreg");
      <D.24544>:
      <D.24538>:
      D.24545 = cfg->verbose_level;
      if (D.24545 > 1) goto <D.24546>; else goto <D.24547>;
      <D.24546>:
      D.24523 = cfg->reginfo;
      D.24526 = cfg->reginfo_len;
      D.24534 = (long unsigned int) D.24526;
      D.24548 = D.24534 * 16;
      memset (D.24523, 0, D.24548);
      <D.24547>:
      ins = bb->code;
      goto <D.23845>;
      <D.23844>:
      D.24549 = ins->opcode;
      D.24550 = (int) D.24549;
      D.24551 = D.24550 + -313;
      D.24552 = ppc64_cpu_desc_idx[D.24551];
      D.24553 = (sizetype) D.24552;
      spec = &ppc64_cpu_desc + D.24553;
      D.24554 = ins->dreg;
      if (D.24554 != -1) goto <D.24555>; else goto <D.24556>;
      <D.24555>:
      D.24554 = ins->dreg;
      if (D.24554 < max) goto <D.24557>; else goto <D.24558>;
      <D.24557>:
      D.24554 = ins->dreg;
      D.24559 = (long unsigned int) D.24554;
      D.24560 = D.24559 * 16;
      D.24561 = reginfo + D.24560;
      memset (D.24561, 0, 16);
      <D.24558>:
      <D.24556>:
      D.24562 = ins->sreg1;
      sregs[0] = D.24562;
      D.24563 = ins->sreg2;
      sregs[1] = D.24563;
      D.24564 = ins->sreg3;
      sregs[2] = D.24564;
      D.24549 = ins->opcode;
      D.24550 = (int) D.24549;
      D.24551 = D.24550 + -313;
      D.24565 = ins_sreg_counts[D.24551];
      num_sregs = (int) D.24565;
      j = 0;
      goto <D.23842>;
      <D.23841>:
      D.24566 = sregs[j];
      D.24567 = D.24566 == -1;
      D.24568 = (long int) D.24567;
      D.24569 = __builtin_expect (D.24568, 0);
      if (D.24569 != 0) goto <D.24570>; else goto <D.24571>;
      <D.24570>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1192, "sregs [j] != -1");
      <D.24571>:
      D.24566 = sregs[j];
      if (D.24566 < max) goto <D.24572>; else goto <D.24573>;
      <D.24572>:
      D.24566 = sregs[j];
      D.24574 = (long unsigned int) D.24566;
      D.24575 = D.24574 * 16;
      D.24576 = reginfo + D.24575;
      memset (D.24576, 0, 16);
      <D.24573>:
      j = j + 1;
      <D.23842>:
      if (j < num_sregs) goto <D.23841>; else goto <D.23843>;
      <D.23843>:
      mono_inst_set_src_registers (ins, &sregs);
      ins = ins->next;
      <D.23845>:
      if (ins != 0B) goto <D.23844>; else goto <D.23846>;
      <D.23846>:
      i = 1;
      D.24545 = cfg->verbose_level;
      D.24577 = D.24545 > 2;
      D.24578 = (long int) D.24577;
      D.24579 = __builtin_expect (D.24578, 0);
      if (D.24579 != 0) goto <D.24580>; else goto <D.24581>;
      <D.24580>:
      D.24582 = bb->block_num;
      printf ("\nLOCAL REGALLOC BLOCK %d:\n", D.24582);
      <D.24581>:
      ins = bb->code;
      goto <D.23869>;
      <D.23868>:
      D.24549 = ins->opcode;
      D.24550 = (int) D.24549;
      D.24551 = D.24550 + -313;
      D.24552 = ppc64_cpu_desc_idx[D.24551];
      D.24553 = (sizetype) D.24552;
      spec = &ppc64_cpu_desc + D.24553;
      spec_dest = *spec;
      D.24583 = spec == &ppc64_cpu_desc;
      D.24584 = (long int) D.24583;
      D.24585 = __builtin_expect (D.24584, 0);
      if (D.24585 != 0) goto <D.24586>; else goto <D.24587>;
      <D.24586>:
      D.24549 = ins->opcode;
      D.24550 = (int) D.24549;
      D.24588 = mono_inst_name (D.24550);
      monoeg_g_log (0B, 4, "Opcode \'%s\' missing from machine description file.", D.24588);
      <D.23847>:
      goto <D.23847>;
      <D.24587>:
      D.24545 = cfg->verbose_level;
      D.24577 = D.24545 > 2;
      D.24578 = (long int) D.24577;
      D.24579 = __builtin_expect (D.24578, 0);
      if (D.24579 != 0) goto <D.24589>; else goto <D.24590>;
      <D.24589>:
      mono_print_ins_index (i, ins);
      <D.24590>:
      D.24562 = ins->sreg1;
      sregs[0] = D.24562;
      D.24563 = ins->sreg2;
      sregs[1] = D.24563;
      D.24564 = ins->sreg3;
      sregs[2] = D.24564;
      D.24549 = ins->opcode;
      D.24550 = (int) D.24549;
      D.24551 = D.24550 + -313;
      D.24565 = ins_sreg_counts[D.24551];
      num_sregs = (int) D.24565;
      j = 0;
      goto <D.23851>;
      <D.23850>:
      {
        int sreg;
        int sreg_spec;

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

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

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

          D.24703 = list->data;
          D.24704 = (long int) D.24703;
          regpair = (guint32) D.24704;
          D.24705 = regpair >> 24;
          hreg = (int) D.24705;
          regpair.16 = (int) regpair;
          reg = regpair.16 & 16777215;
          if (list != 0B) goto <D.24708>; else goto <D.24709>;
          <D.24708>:
          iftmp.17 = list->next;
          goto <D.24710>;
          <D.24709>:
          iftmp.17 = 0B;
          <D.24710>:
          list = iftmp.17;
        }
        <D.23860>:
        if (list != 0B) goto <D.23859>; else goto <D.23861>;
        <D.23861>:
        <D.24702>:
        list = call->out_freg_args;
        if (list != 0B) goto <D.24711>; else goto <D.24712>;
        <D.24711>:
        goto <D.23866>;
        <D.23865>:
        {
          guint32 regpair;
          int reg;
          int hreg;

          D.24703 = list->data;
          D.24704 = (long int) D.24703;
          regpair = (guint32) D.24704;
          D.24713 = regpair >> 24;
          hreg = (int) D.24713;
          regpair.18 = (int) regpair;
          reg = regpair.18 & 16777215;
          if (list != 0B) goto <D.24716>; else goto <D.24717>;
          <D.24716>:
          iftmp.19 = list->next;
          goto <D.24718>;
          <D.24717>:
          iftmp.19 = 0B;
          <D.24718>:
          list = iftmp.19;
        }
        <D.23866>:
        if (list != 0B) goto <D.23865>; else goto <D.23867>;
        <D.23867>:
        <D.24712>:
      }
      <D.24684>:
      <D.24688>:
      i = i + 1;
      ins = ins->next;
      <D.23869>:
      if (ins != 0B) goto <D.23868>; else goto <D.23870>;
      <D.23870>:
      tmp = &last;
      D.24545 = cfg->verbose_level;
      D.24577 = D.24545 > 2;
      D.24578 = (long int) D.24577;
      D.24579 = __builtin_expect (D.24578, 0);
      if (D.24579 != 0) goto <D.24719>; else goto <D.24720>;
      <D.24719>:
      D.24539 = rs->next_vreg;
      print_regtrack (reginfo, D.24539);
      <D.24720>:
      ins = bb->last_ins;
      if (ins != 0B) goto <D.24722>; else goto <D.24723>;
      <D.24722>:
      iftmp.20 = ins->prev;
      goto <D.24724>;
      <D.24723>:
      iftmp.20 = 0B;
      <D.24724>:
      prev = iftmp.20;
      goto <D.23999>;
      <D.23998>:
      {
        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.24549 = ins->opcode;
            D.24550 = (int) D.24549;
            D.24551 = D.24550 + -313;
            D.24552 = ppc64_cpu_desc_idx[D.24551];
            D.24553 = (sizetype) D.24552;
            spec = &ppc64_cpu_desc + D.24553;
            D.24725 = spec + 1;
            spec_src1 = *D.24725;
            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.23886>;
            <D.23885>:
            prev_sregs[j] = -1;
            D.24591 = j + 1;
            D.24592 = (sizetype) D.24591;
            D.24593 = spec + D.24592;
            D.24594 = *D.24593;
            D.24726 = get_callee_mask (D.24594);
            sreg_masks[j] = D.24726;
            D.24591 = j + 1;
            D.24592 = (sizetype) D.24591;
            D.24593 = spec + D.24592;
            D.24594 = *D.24593;
            D.24727 = (int) D.24594;
            D.24728 = desc_to_fixed_reg[D.24727];
            D.24729 = (int) D.24728;
            dest_sregs[j] = D.24729;
            sreg_fixed_masks[j] = 0;
            j = j + 1;
            <D.23886>:
            if (j <= 2) goto <D.23885>; else goto <D.23887>;
            <D.23887>:
            D.24545 = cfg->verbose_level;
            D.24577 = D.24545 > 2;
            D.24578 = (long int) D.24577;
            D.24579 = __builtin_expect (D.24578, 0);
            if (D.24579 != 0) goto <D.24730>; else goto <D.24731>;
            <D.24730>:
            printf ("processing:");
            <D.24731>:
            D.24545 = cfg->verbose_level;
            D.24577 = D.24545 > 2;
            D.24578 = (long int) D.24577;
            D.24579 = __builtin_expect (D.24578, 0);
            if (D.24579 != 0) goto <D.24732>; else goto <D.24733>;
            <D.24732>:
            mono_print_ins_index (i, ins);
            <D.24733>:
            ip = ins->cil_code;
            last = ins;
            D.24663 = (int) spec_dest;
            D.24664 = desc_to_fixed_reg[D.24663];
            dest_dreg = (int) D.24664;
            D.24685 = spec + 5;
            D.24686 = *D.24685;
            D.24734 = (int) D.24686;
            D.24735 = desc_to_fixed_reg[D.24734];
            clob_reg = (int) D.24735;
            D.24736 = sreg_masks[1];
            sreg_masks[1] = D.24736;
            dreg_fixed_mask = 0;
            D.24562 = ins->sreg1;
            sregs[0] = D.24562;
            D.24563 = ins->sreg2;
            sregs[1] = D.24563;
            D.24564 = ins->sreg3;
            sregs[2] = D.24564;
            D.24549 = ins->opcode;
            D.24550 = (int) D.24549;
            D.24551 = D.24550 + -313;
            D.24565 = ins_sreg_counts[D.24551];
            num_sregs = (int) D.24565;
            j = 1;
            goto <D.23918>;
            <D.23917>:
            {
              int sreg;
              int dest_sreg;

              sreg = sregs[j];
              dest_sreg = dest_sregs[j];
              if (dest_sreg == -1) goto <D.24737>; else goto <D.24738>;
              <D.24737>:
              // predicted unlikely by continue predictor.
              goto <D.23890>;
              <D.24738>:
              if (j == 2) goto <D.24739>; else goto <D.24740>;
              <D.24739>:
              {
                int k;

                D.24741 = 1 << dest_sreg;
                sreg_masks[j] = D.24741;
                k = 0;
                goto <D.23893>;
                <D.23892>:
                if (k != j) goto <D.24742>; else goto <D.24743>;
                <D.24742>:
                D.24744 = sreg_masks[k];
                D.24741 = 1 << dest_sreg;
                D.24745 = ~D.24741;
                D.24746 = D.24744 & D.24745;
                sreg_masks[k] = D.24746;
                <D.24743>:
                k = k + 1;
                <D.23893>:
                if (k < num_sregs) goto <D.23892>; else goto <D.23894>;
                <D.23894>:
                k = 0;
                goto <D.23896>;
                <D.23895>:
                if (k != j) goto <D.24747>; else goto <D.24748>;
                <D.24747>:
                D.24749 = sregs[k];
                if (D.24749 > 31) goto <D.24750>; else goto <D.24751>;
                <D.24750>:
                D.24628 = rs->vassign;
                D.24749 = sregs[k];
                D.24752 = (long unsigned int) D.24749;
                D.24753 = D.24752 * 4;
                D.24754 = D.24628 + D.24753;
                D.24755 = *D.24754;
                if (D.24755 == dest_sreg) goto <D.24756>; else goto <D.24757>;
                <D.24756>:
                free_up_hreg (cfg, bb, tmp, ins, dest_sreg, 0);
                <D.24757>:
                <D.24751>:
                <D.24748>:
                k = k + 1;
                <D.23896>:
                if (k < num_sregs) goto <D.23895>; else goto <D.23897>;
                <D.23897>:
                if (sreg > 31) goto <D.24758>; else goto <D.24759>;
                <D.24758>:
                D.24628 = rs->vassign;
                D.24760 = (long unsigned int) sreg;
                D.24761 = D.24760 * 4;
                D.24762 = D.24628 + D.24761;
                D.24763 = *D.24762;
                if (D.24763 >= 0) goto <D.24764>; else goto <D.24765>;
                <D.24764>:
                D.24628 = rs->vassign;
                D.24760 = (long unsigned int) sreg;
                D.24761 = D.24760 * 4;
                D.24762 = D.24628 + D.24761;
                D.24763 = *D.24762;
                if (D.24763 != dest_sreg) goto <D.24766>; else goto <D.24767>;
                <D.24766>:
                spill_vreg (cfg, bb, tmp, ins, sreg, 0);
                <D.24767>:
                <D.24765>:
                <D.24759>:
                // predicted unlikely by continue predictor.
                goto <D.23890>;
              }
              <D.24740>:
              D.24768 = rs->ifree_mask;
              D.24769 = D.24768 >> dest_sreg;
              D.24770 = D.24769 & 1;
              if (D.24770 != 0) goto <D.24771>; else goto <D.24772>;
              <D.24771>:
              sreg.21 = (unsigned int) sreg;
              if (sreg.21 <= 31) goto <D.24776>; else goto <D.24773>;
              <D.24776>:
              D.24777 = 18446744073709543424 >> sreg;
              D.24778 = D.24777 & 1;
              if (D.24778 != 0) goto <D.24779>; else goto <D.24773>;
              <D.24779>:
              {
                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.23901>;
                <D.23900>:
                if (k != j) goto <D.24780>; else goto <D.24781>;
                <D.24780>:
                D.24782 = sreg_masks[k];
                D.24741 = 1 << dest_sreg;
                D.24745 = ~D.24741;
                D.24783 = D.24782 & D.24745;
                sreg_masks[k] = D.24783;
                <D.24781>:
                k = k + 1;
                <D.23901>:
                if (k < num_sregs) goto <D.23900>; else goto <D.23902>;
                <D.23902>:
              }
              goto <D.24774>;
              <D.24773>:
              D.24628 = rs->vassign;
              D.24760 = (long unsigned int) sreg;
              D.24761 = D.24760 * 4;
              D.24762 = D.24628 + D.24761;
              val = *D.24762;
              if (val == -1) goto <D.24784>; else goto <D.24785>;
              <D.24784>:
              D.24545 = cfg->verbose_level;
              D.24577 = D.24545 > 2;
              D.24578 = (long int) D.24577;
              D.24579 = __builtin_expect (D.24578, 0);
              if (D.24579 != 0) goto <D.24786>; else goto <D.24787>;
              <D.24786>:
              D.24788 = mono_arch_regname (dest_sreg);
              printf ("\tshortcut assignment of R%d to %s\n", sreg, D.24788);
              <D.24787>:
              assign_reg (cfg, rs, sreg, dest_sreg, 0);
              goto <D.24789>;
              <D.24785>:
              if (val < -1) goto <D.24790>; else goto <D.24791>;
              <D.24790>:
              monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-codegen.c", 1459);
              <D.24791>:
              {
                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.23906>;
                <D.23905>:
                if (k != j) goto <D.24792>; else goto <D.24793>;
                <D.24792>:
                D.24794 = sreg_masks[k];
                D.24741 = 1 << dest_sreg;
                D.24745 = ~D.24741;
                D.24795 = D.24794 & D.24745;
                sreg_masks[k] = D.24795;
                <D.24793>:
                k = k + 1;
                <D.23906>:
                if (k < num_sregs) goto <D.23905>; else goto <D.23907>;
                <D.23907>:
                D.24741 = 1 << dest_sreg;
                D.24745 = ~D.24741;
                dreg_mask = D.24745 & dreg_mask;
              }
              <D.24789>:
              <D.24774>:
              goto <D.24796>;
              <D.24772>:
              {
                gboolean need_spill;
                gboolean need_assign;
                int k;

                need_spill = 1;
                need_assign = 1;
                D.24741 = 1 << dest_sreg;
                D.24745 = ~D.24741;
                dreg_mask = D.24745 & dreg_mask;
                k = 0;
                goto <D.23912>;
                <D.23911>:
                if (k != j) goto <D.24797>; else goto <D.24798>;
                <D.24797>:
                D.24799 = sreg_masks[k];
                D.24741 = 1 << dest_sreg;
                D.24745 = ~D.24741;
                D.24800 = D.24799 & D.24745;
                sreg_masks[k] = D.24800;
                <D.24798>:
                k = k + 1;
                <D.23912>:
                if (k < num_sregs) goto <D.23911>; else goto <D.23913>;
                <D.23913>:
                D.24646 = *spec;
                if (D.24646 != 0) goto <D.24801>; else goto <D.24802>;
                <D.24801>:
                D.24628 = rs->vassign;
                D.24554 = ins->dreg;
                D.24559 = (long unsigned int) D.24554;
                D.24657 = D.24559 * 4;
                D.24658 = D.24628 + D.24657;
                val = *D.24658;
                goto <D.24803>;
                <D.24802>:
                val = -1;
                <D.24803>:
                if (val == dest_sreg) goto <D.24804>; else goto <D.24805>;
                <D.24804>:
                D.24554 = ins->dreg;
                if (D.24554 != sreg) goto <D.24806>; else goto <D.24807>;
                <D.24806>:
                {
                  int new_dest;

                  D.24554 = ins->dreg;
                  D.24554 = ins->dreg;
                  D.24559 = (long unsigned int) D.24554;
                  D.24560 = D.24559 * 16;
                  D.24651 = reginfo + D.24560;
                  new_dest = alloc_int_reg (cfg, bb, tmp, ins, dreg_mask, D.24554, D.24651);
                  D.24808 = new_dest < 0;
                  D.24809 = (long int) D.24808;
                  D.24810 = __builtin_expect (D.24809, 0);
                  if (D.24810 != 0) goto <D.24811>; else goto <D.24812>;
                  <D.24811>:
                  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1505, "new_dest >= 0");
                  <D.24812>:
                  D.24545 = cfg->verbose_level;
                  D.24577 = D.24545 > 2;
                  D.24578 = (long int) D.24577;
                  D.24579 = __builtin_expect (D.24578, 0);
                  if (D.24579 != 0) goto <D.24813>; else goto <D.24814>;
                  <D.24813>:
                  D.24554 = ins->dreg;
                  D.24815 = mono_arch_regname (new_dest);
                  D.24816 = mono_arch_regname (dest_sreg);
                  printf ("\tchanging dreg R%d to %s from %s\n", D.24554, D.24815, D.24816);
                  <D.24814>:
                  prev_dreg = ins->dreg;
                  D.24554 = ins->dreg;
                  assign_reg (cfg, rs, D.24554, 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.24807>:
                <D.24805>:
                sreg.21 = (unsigned int) sreg;
                if (sreg.21 <= 31) goto <D.24819>; else goto <D.24817>;
                <D.24819>:
                D.24777 = 18446744073709543424 >> sreg;
                D.24778 = D.24777 & 1;
                if (D.24778 != 0) goto <D.24820>; else goto <D.24817>;
                <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.24818>;
                <D.24817>:
                D.24628 = rs->vassign;
                D.24760 = (long unsigned int) sreg;
                D.24761 = D.24760 * 4;
                D.24762 = D.24628 + D.24761;
                val = *D.24762;
                if (val == dest_sreg) goto <D.24821>; else goto <D.24822>;
                <D.24821>:
                need_spill = 0;
                goto <D.24823>;
                <D.24822>:
                if (val < -1) goto <D.24824>; else goto <D.24825>;
                <D.24824>:
                goto <D.24826>;
                <D.24825>:
                if (val >= 0) goto <D.24827>; else goto <D.24828>;
                <D.24827>:
                free_up_hreg (cfg, bb, tmp, ins, val, 0);
                <D.24828>:
                <D.24826>:
                <D.24823>:
                <D.24818>:
                if (need_spill != 0) goto <D.24829>; else goto <D.24830>;
                <D.24829>:
                free_up_hreg (cfg, bb, tmp, ins, dest_sreg, 0);
                <D.24830>:
                if (need_assign != 0) goto <D.24831>; else goto <D.24832>;
                <D.24831>:
                D.24628 = rs->vassign;
                D.24760 = (long unsigned int) sreg;
                D.24761 = D.24760 * 4;
                D.24762 = D.24628 + D.24761;
                D.24763 = *D.24762;
                if (D.24763 < -1) goto <D.24833>; else goto <D.24834>;
                <D.24833>:
                {
                  int spill;

                  D.24628 = rs->vassign;
                  D.24760 = (long unsigned int) sreg;
                  D.24761 = D.24760 * 4;
                  D.24762 = D.24628 + D.24761;
                  D.24763 = *D.24762;
                  spill = ~D.24763;
                  create_spilled_store (cfg, bb, spill, dest_sreg, sreg, tmp, 0B, ins, bank);
                }
                <D.24834>:
                D.24566 = sregs[j];
                assign_reg (cfg, rs, D.24566, dest_sreg, 0);
                <D.24832>:
              }
              <D.24796>:
              sregs[j] = dest_sreg;
            }
            <D.23890>:
            j = j + 1;
            <D.23918>:
            if (j < num_sregs) goto <D.23917>; else goto <D.23919>;
            <D.23919>:
            mono_inst_set_src_registers (ins, &sregs);
            D.24646 = *spec;
            D.24647 = D.24646 + 154;
            D.24648 = D.24647 <= 1;
            bank = (int) D.24648;
            if (spec_dest != 0) goto <D.24835>; else goto <D.24836>;
            <D.24835>:
            D.24605 = bank != 0;
            D.24606 = (long int) D.24605;
            D.24607 = __builtin_expect (D.24606, 0);
            if (D.24607 != 0) goto <D.24838>; else goto <D.24839>;
            <D.24838>:
            D.24554 = ins->dreg;
            if (D.24554 < 0) goto <D.24841>; else goto <D.24844>;
            <D.24844>:
            D.24554 = ins->dreg;
            D.24615 = regbank_size[bank];
            if (D.24554 >= D.24615) goto <D.24841>; else goto <D.24842>;
            <D.24841>:
            iftmp.23 = 1;
            goto <D.24843>;
            <D.24842>:
            iftmp.23 = 0;
            <D.24843>:
            iftmp.22 = (_Bool) iftmp.23;
            goto <D.24845>;
            <D.24839>:
            D.24554 = ins->dreg;
            iftmp.22 = D.24554 > 31;
            <D.24845>:
            if (iftmp.22 != 0) goto <D.24846>; else goto <D.24847>;
            <D.24846>:
            prev_dreg = ins->dreg;
            <D.24847>:
            <D.24836>:
            if (spec_dest == 98) goto <D.24848>; else goto <D.24849>;
            <D.24848>:
            D.24850 = dest_sregs[0];
            if (D.24850 != -1) goto <D.24851>; else goto <D.24852>;
            <D.24851>:
            D.24850 = dest_sregs[0];
            D.24853 = 1 << D.24850;
            D.24854 = ~D.24853;
            dreg_mask = D.24854 & dreg_mask;
            <D.24852>:
            j = 1;
            goto <D.23921>;
            <D.23920>:
            D.24855 = dest_sregs[j];
            if (D.24855 != -1) goto <D.24856>; else goto <D.24857>;
            <D.24856>:
            D.24855 = dest_sregs[j];
            D.24858 = 1 << D.24855;
            D.24859 = ~D.24858;
            dreg_mask = D.24859 & dreg_mask;
            <D.24857>:
            j = j + 1;
            <D.23921>:
            if (j < num_sregs) goto <D.23920>; else goto <D.23922>;
            <D.23922>:
            D.24628 = rs->vassign;
            D.24554 = ins->dreg;
            D.24559 = (long unsigned int) D.24554;
            D.24657 = D.24559 * 4;
            D.24658 = D.24628 + D.24657;
            val = *D.24658;
            D.24605 = bank != 0;
            D.24606 = (long int) D.24605;
            D.24607 = __builtin_expect (D.24606, 0);
            if (D.24607 != 0) goto <D.24861>; else goto <D.24862>;
            <D.24861>:
            D.24554 = ins->dreg;
            if (D.24554 < 0) goto <D.24864>; else goto <D.24867>;
            <D.24867>:
            D.24554 = ins->dreg;
            D.24615 = regbank_size[bank];
            if (D.24554 >= D.24615) goto <D.24864>; else goto <D.24865>;
            <D.24864>:
            iftmp.25 = 1;
            goto <D.24866>;
            <D.24865>:
            iftmp.25 = 0;
            <D.24866>:
            iftmp.24 = (_Bool) iftmp.25;
            goto <D.24868>;
            <D.24862>:
            D.24554 = ins->dreg;
            iftmp.24 = D.24554 > 31;
            <D.24868>:
            if (iftmp.24 != 0) goto <D.24869>; else goto <D.24870>;
            <D.24869>:
            if (val >= 0) goto <D.24871>; else goto <D.24872>;
            <D.24871>:
            D.24873 = dreg_mask >> val;
            D.24874 = D.24873 & 1;
            if (D.24874 == 0) goto <D.24875>; else goto <D.24876>;
            <D.24875>:
            D.24554 = ins->dreg;
            spill_vreg (cfg, bb, tmp, ins, D.24554, 0);
            <D.24876>:
            <D.24872>:
            <D.24870>:
            <D.24849>:
            if (0 != 0) goto <D.24877>; else goto <D.24878>;
            <D.24877>:
            {
              guint32 dreg2;
              guint32 dest_dreg2;

              D.24605 = bank != 0;
              D.24606 = (long int) D.24605;
              D.24607 = __builtin_expect (D.24606, 0);
              if (D.24607 != 0) goto <D.24880>; else goto <D.24881>;
              <D.24880>:
              D.24554 = ins->dreg;
              if (D.24554 >= 0) goto <D.24885>; else goto <D.24883>;
              <D.24885>:
              D.24554 = ins->dreg;
              D.24615 = regbank_size[bank];
              if (D.24554 < D.24615) goto <D.24886>; else goto <D.24883>;
              <D.24886>:
              iftmp.27 = 1;
              goto <D.24884>;
              <D.24883>:
              iftmp.27 = 0;
              <D.24884>:
              D.24887 = iftmp.27 != 0;
              D.24888 = (int) D.24887;
              iftmp.26 = (long int) D.24888;
              goto <D.24889>;
              <D.24881>:
              D.24554 = ins->dreg;
              D.24890 = D.24554 <= 31;
              D.24891 = (int) D.24890;
              iftmp.26 = (long int) D.24891;
              <D.24889>:
              D.24892 = __builtin_expect (iftmp.26, 0);
              if (D.24892 != 0) goto <D.24893>; else goto <D.24894>;
              <D.24893>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1594, "is_soft_reg (ins->dreg, bank)");
              <D.24894>:
              if (dest_dreg != -1) goto <D.24895>; else goto <D.24896>;
              <D.24895>:
              D.24628 = rs->vassign;
              D.24554 = ins->dreg;
              D.24559 = (long unsigned int) D.24554;
              D.24657 = D.24559 * 4;
              D.24658 = D.24628 + D.24657;
              D.24897 = *D.24658;
              if (D.24897 != dest_dreg) goto <D.24898>; else goto <D.24899>;
              <D.24898>:
              free_up_hreg (cfg, bb, tmp, ins, dest_dreg, 0);
              <D.24899>:
              D.24554 = ins->dreg;
              D.24900 = D.24554 + 1;
              dreg2 = (guint32) D.24900;
              dest_dreg2 = 4294967295;
              if (dest_dreg2 != 4294967295) goto <D.24901>; else goto <D.24902>;
              <D.24901>:
              D.24628 = rs->vassign;
              D.24903 = (long unsigned int) dreg2;
              D.24904 = D.24903 * 4;
              D.24905 = D.24628 + D.24904;
              D.24906 = *D.24905;
              D.24907 = (unsigned int) D.24906;
              if (D.24907 != dest_dreg2) goto <D.24908>; else goto <D.24909>;
              <D.24908>:
              dest_dreg2.28 = (int) dest_dreg2;
              free_up_hreg (cfg, bb, tmp, ins, dest_dreg2.28, 0);
              <D.24909>:
              <D.24902>:
              <D.24896>:
            }
            <D.24878>:
            if (dreg_fixed_mask != 0) goto <D.24911>; else goto <D.24912>;
            <D.24911>:
            D.24605 = bank != 0;
            D.24606 = (long int) D.24605;
            D.24607 = __builtin_expect (D.24606, 0);
            if (D.24607 != 0) goto <D.24913>; else goto <D.24914>;
            <D.24913>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1610, "!bank");
            <D.24914>:
            D.24554 = ins->dreg;
            D.24917 = (unsigned int) D.24554;
            if (D.24917 <= 31) goto <D.24918>; else goto <D.24915>;
            <D.24918>:
            D.24554 = ins->dreg;
            D.24919 = 18446744073709543424 >> D.24554;
            D.24920 = D.24919 & 1;
            if (D.24920 != 0) goto <D.24921>; else goto <D.24915>;
            <D.24921>:
            val = mono_regstate_alloc_int (rs, dreg_fixed_mask);
            if (val < 0) goto <D.24922>; else goto <D.24923>;
            <D.24922>:
            val = get_register_spilling (cfg, bb, tmp, ins, dreg_fixed_mask, -1, bank);
            <D.24923>:
            mono_regstate_free_int (rs, val);
            dest_dreg = val;
            goto <D.24916>;
            <D.24915>:
            dreg_mask = dreg_mask & dreg_fixed_mask;
            <D.24916>:
            <D.24912>:
            D.24605 = bank != 0;
            D.24606 = (long int) D.24605;
            D.24607 = __builtin_expect (D.24606, 0);
            if (D.24607 != 0) goto <D.24925>; else goto <D.24926>;
            <D.24925>:
            D.24554 = ins->dreg;
            if (D.24554 < 0) goto <D.24928>; else goto <D.24931>;
            <D.24931>:
            D.24554 = ins->dreg;
            D.24615 = regbank_size[bank];
            if (D.24554 >= D.24615) goto <D.24928>; else goto <D.24929>;
            <D.24928>:
            iftmp.30 = 1;
            goto <D.24930>;
            <D.24929>:
            iftmp.30 = 0;
            <D.24930>:
            iftmp.29 = (_Bool) iftmp.30;
            goto <D.24932>;
            <D.24926>:
            D.24554 = ins->dreg;
            iftmp.29 = D.24554 > 31;
            <D.24932>:
            if (iftmp.29 != 0) goto <D.24933>; else goto <D.24934>;
            <D.24933>:
            D.24628 = rs->vassign;
            D.24554 = ins->dreg;
            D.24559 = (long unsigned int) D.24554;
            D.24657 = D.24559 * 4;
            D.24658 = D.24628 + D.24657;
            val = *D.24658;
            if (val < 0) goto <D.24935>; else goto <D.24936>;
            <D.24935>:
            {
              int spill;

              spill = 0;
              if (val < -1) goto <D.24937>; else goto <D.24938>;
              <D.24937>:
              spill = ~val;
              <D.24938>:
              D.24554 = ins->dreg;
              D.24554 = ins->dreg;
              D.24559 = (long unsigned int) D.24554;
              D.24560 = D.24559 * 16;
              D.24651 = reginfo + D.24560;
              val = alloc_reg (cfg, bb, tmp, ins, dreg_mask, D.24554, D.24651, bank);
              D.24554 = ins->dreg;
              assign_reg (cfg, rs, D.24554, val, bank);
              if (spill != 0) goto <D.24939>; else goto <D.24940>;
              <D.24939>:
              create_spilled_store (cfg, bb, spill, val, prev_dreg, tmp, ins, 0B, bank);
              <D.24940>:
            }
            <D.24936>:
            D.24545 = cfg->verbose_level;
            D.24577 = D.24545 > 2;
            D.24578 = (long int) D.24577;
            D.24579 = __builtin_expect (D.24578, 0);
            if (D.24579 != 0) goto <D.24941>; else goto <D.24942>;
            <D.24941>:
            D.24943 = mono_regname_full (val, bank);
            D.24554 = ins->dreg;
            printf ("\tassigned dreg %s to dest R%d\n", D.24943, D.24554);
            <D.24942>:
            ins->dreg = val;
            <D.24934>:
            if (0 != 0) goto <D.24944>; else goto <D.24945>;
            <D.24944>:
            {
              int reg2;

              reg2 = prev_dreg + 1;
              D.24605 = bank != 0;
              D.24606 = (long int) D.24605;
              D.24607 = __builtin_expect (D.24606, 0);
              if (D.24607 != 0) goto <D.24946>; else goto <D.24947>;
              <D.24946>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1651, "!bank");
              <D.24947>:
              D.24948 = prev_dreg < 0;
              D.24949 = (long int) D.24948;
              D.24950 = __builtin_expect (D.24949, 0);
              if (D.24950 != 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", 1652, "prev_dreg > -1");
              <D.24952>:
              D.24628 = rs->vassign;
              D.24956 = (long unsigned int) prev_dreg;
              D.24957 = D.24956 * 4;
              D.24958 = D.24628 + D.24957;
              D.24959 = *D.24958;
              D.24960 = (unsigned int) D.24959;
              if (D.24960 <= 31) goto <D.24961>; else goto <D.24954>;
              <D.24961>:
              D.24628 = rs->vassign;
              D.24956 = (long unsigned int) prev_dreg;
              D.24957 = D.24956 * 4;
              D.24958 = D.24628 + D.24957;
              D.24959 = *D.24958;
              D.24962 = 18446744073709543424 >> D.24959;
              D.24963 = D.24962 & 1;
              if (D.24963 != 0) goto <D.24964>; else goto <D.24954>;
              <D.24964>:
              iftmp.31 = 1;
              goto <D.24955>;
              <D.24954>:
              iftmp.31 = 0;
              <D.24955>:
              D.24965 = iftmp.31 != 0;
              D.24966 = (long int) D.24965;
              D.24967 = __builtin_expect (D.24966, 0);
              if (D.24967 != 0) goto <D.24968>; else goto <D.24969>;
              <D.24968>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1653, "!is_global_ireg (rs->vassign [prev_dreg])");
              <D.24969>:
              mask = 8184;
              D.24628 = rs->vassign;
              D.24970 = (long unsigned int) reg2;
              D.24971 = D.24970 * 4;
              D.24972 = D.24628 + D.24971;
              val = *D.24972;
              if (val < 0) goto <D.24973>; else goto <D.24974>;
              <D.24973>:
              {
                int spill;

                spill = 0;
                if (val < -1) goto <D.24975>; else goto <D.24976>;
                <D.24975>:
                spill = ~val;
                <D.24976>:
                val = mono_regstate_alloc_int (rs, mask);
                if (val < 0) goto <D.24977>; else goto <D.24978>;
                <D.24977>:
                val = get_register_spilling (cfg, bb, tmp, ins, mask, reg2, bank);
                <D.24978>:
                if (spill != 0) goto <D.24979>; else goto <D.24980>;
                <D.24979>:
                create_spilled_store (cfg, bb, spill, val, reg2, tmp, ins, 0B, bank);
                <D.24980>:
              }
              goto <D.24981>;
              <D.24974>:
              D.24982 = mask >> val;
              D.24983 = D.24982 & 1;
              if (D.24983 == 0) goto <D.24984>; else goto <D.24985>;
              <D.24984>:
              val = mono_regstate_alloc_int (rs, mask);
              if (val < 0) goto <D.24986>; else goto <D.24987>;
              <D.24986>:
              val = get_register_spilling (cfg, bb, tmp, ins, mask, reg2, bank);
              <D.24987>:
              D.24628 = rs->vassign;
              D.24970 = (long unsigned int) reg2;
              D.24971 = D.24970 * 4;
              D.24972 = D.24628 + D.24971;
              D.24988 = *D.24972;
              create_copy_ins (cfg, bb, tmp, D.24988, val, ins, ip, bank);
              D.24628 = rs->vassign;
              D.24970 = (long unsigned int) reg2;
              D.24971 = D.24970 * 4;
              D.24972 = D.24628 + D.24971;
              D.24988 = *D.24972;
              mono_regstate_free_int (rs, D.24988);
              <D.24985>:
              <D.24981>:
              D.24545 = cfg->verbose_level;
              D.24577 = D.24545 > 2;
              D.24578 = (long int) D.24577;
              D.24579 = __builtin_expect (D.24578, 0);
              if (D.24579 != 0) goto <D.24989>; else goto <D.24990>;
              <D.24989>:
              D.24991 = mono_arch_regname (val);
              printf ("\tassigned dreg-high %s to dest R%d\n", D.24991, reg2);
              <D.24990>:
              assign_reg (cfg, rs, reg2, val, bank);
              dreg_high = val;
              ins->backend.reg3 = val;
              D.24605 = bank != 0;
              D.24606 = (long int) D.24605;
              D.24607 = __builtin_expect (D.24606, 0);
              if (D.24607 != 0) goto <D.24993>; else goto <D.24994>;
              <D.24993>:
              D.24605 = bank != 0;
              D.24606 = (long int) D.24605;
              D.24607 = __builtin_expect (D.24606, 0);
              if (D.24607 != 0) goto <D.24996>; else goto <D.24997>;
              <D.24996>:
              D.24605 = bank != 0;
              D.24606 = (long int) D.24605;
              D.24607 = __builtin_expect (D.24606, 0);
              if (D.24607 != 0) goto <D.25001>; else goto <D.25002>;
              <D.25001>:
              if (val >= 0) goto <D.25006>; else goto <D.25004>;
              <D.25006>:
              D.24615 = regbank_size[bank];
              if (D.24615 > val) goto <D.25007>; else goto <D.25004>;
              <D.25007>:
              iftmp.35 = 1;
              goto <D.25005>;
              <D.25004>:
              iftmp.35 = 0;
              <D.25005>:
              D.25008 = (_Bool) iftmp.35;
              if (D.25008 != 0) goto <D.25009>; else goto <D.24999>;
              <D.25009>:
              goto <D.25010>;
              <D.25002>:
              if (val <= 31) goto <D.25011>; else goto <D.24999>;
              <D.25011>:
              <D.25010>:
              D.25012 = regbank_callee_regs[bank];
              D.25013 = D.25012 >> val;
              D.25014 = D.25013 & 1;
              if (D.25014 != 0) goto <D.25015>; else goto <D.24999>;
              <D.25015>:
              iftmp.34 = 1;
              goto <D.25000>;
              <D.24999>:
              iftmp.34 = 0;
              <D.25000>:
              iftmp.33 = (_Bool) iftmp.34;
              goto <D.25016>;
              <D.24997>:
              val.37 = (unsigned int) val;
              if (val.37 <= 31) goto <D.25021>; else goto <D.25018>;
              <D.25021>:
              D.25022 = 8184 >> val;
              D.25023 = D.25022 & 1;
              if (D.25023 != 0) goto <D.25024>; else goto <D.25018>;
              <D.25024>:
              iftmp.36 = 1;
              goto <D.25019>;
              <D.25018>:
              iftmp.36 = 0;
              <D.25019>:
              iftmp.33 = (_Bool) iftmp.36;
              <D.25016>:
              iftmp.32 = iftmp.33;
              goto <D.25025>;
              <D.24994>:
              val.37 = (unsigned int) val;
              if (val.37 <= 31) goto <D.25029>; else goto <D.25027>;
              <D.25029>:
              D.25022 = 8184 >> val;
              D.25023 = D.25022 & 1;
              if (D.25023 != 0) goto <D.25030>; else goto <D.25027>;
              <D.25030>:
              iftmp.38 = 1;
              goto <D.25028>;
              <D.25027>:
              iftmp.38 = 0;
              <D.25028>:
              iftmp.32 = (_Bool) iftmp.38;
              <D.25025>:
              if (iftmp.32 != 0) goto <D.25031>; else goto <D.25032>;
              <D.25031>:
              if (reg2 >= 0) goto <D.25033>; else goto <D.25034>;
              <D.25033>:
              D.24970 = (long unsigned int) reg2;
              D.25035 = D.24970 * 16;
              D.25036 = reginfo + D.25035;
              D.25037 = D.25036->born_in;
              if (D.25037 >= i) goto <D.25038>; else goto <D.25039>;
              <D.25038>:
              D.24545 = cfg->verbose_level;
              D.24577 = D.24545 > 2;
              D.24578 = (long int) D.24577;
              D.24579 = __builtin_expect (D.24578, 0);
              if (D.24579 != 0) goto <D.25040>; else goto <D.25041>;
              <D.25040>:
              D.25042 = mono_arch_regname (val);
              printf ("\tfreeable %s (R%d)\n", D.25042, reg2);
              <D.25041>:
              mono_regstate_free_int (rs, val);
              <D.25039>:
              <D.25034>:
              <D.25032>:
            }
            <D.24945>:
            if (prev_dreg >= 0) goto <D.25043>; else goto <D.25044>;
            <D.25043>:
            D.24605 = bank != 0;
            D.24606 = (long int) D.24605;
            D.24607 = __builtin_expect (D.24606, 0);
            if (D.24607 != 0) goto <D.25046>; else goto <D.25047>;
            <D.25046>:
            if (prev_dreg < 0) goto <D.25049>; else goto <D.25052>;
            <D.25052>:
            D.24615 = regbank_size[bank];
            if (D.24615 <= prev_dreg) goto <D.25049>; else goto <D.25050>;
            <D.25049>:
            iftmp.40 = 1;
            goto <D.25051>;
            <D.25050>:
            iftmp.40 = 0;
            <D.25051>:
            iftmp.39 = (_Bool) iftmp.40;
            goto <D.25053>;
            <D.25047>:
            iftmp.39 = prev_dreg > 31;
            <D.25053>:
            if (iftmp.39 != 0) goto <D.25054>; else goto <D.25055>;
            <D.25054>:
            if (spec_dest != 98) goto <D.25056>; else goto <D.25057>;
            <D.25056>:
            {
              int dreg;

              D.24628 = rs->vassign;
              D.24956 = (long unsigned int) prev_dreg;
              D.24957 = D.24956 * 4;
              D.24958 = D.24628 + D.24957;
              dreg = *D.24958;
              D.25058 = dreg < 0;
              D.25059 = (long int) D.25058;
              D.25060 = __builtin_expect (D.25059, 0);
              if (D.25060 != 0) goto <D.25061>; else goto <D.25062>;
              <D.25061>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1704, "dreg >= 0");
              <D.25062>:
              D.24545 = cfg->verbose_level;
              D.24577 = D.24545 > 2;
              D.24578 = (long int) D.24577;
              D.24579 = __builtin_expect (D.24578, 0);
              if (D.24579 != 0) goto <D.25063>; else goto <D.25064>;
              <D.25063>:
              D.25065 = mono_regname_full (dreg, bank);
              D.24956 = (long unsigned int) prev_dreg;
              D.25066 = D.24956 * 16;
              D.25067 = reginfo + D.25066;
              D.25068 = D.25067->born_in;
              printf ("\tfreeable %s (R%d) (born in %d)\n", D.25065, prev_dreg, D.25068);
              <D.25064>:
              D.24605 = bank != 0;
              D.24606 = (long int) D.24605;
              D.24607 = __builtin_expect (D.24606, 0);
              if (D.24607 != 0) goto <D.25069>; else goto <D.25070>;
              <D.25069>:
              mono_regstate_free_general (rs, dreg, bank);
              goto <D.25071>;
              <D.25070>:
              mono_regstate_free_int (rs, dreg);
              <D.25071>:
              D.24628 = rs->vassign;
              D.24956 = (long unsigned int) prev_dreg;
              D.24957 = D.24956 * 4;
              D.24958 = D.24628 + D.24957;
              *D.24958 = -1;
            }
            <D.25057>:
            <D.25055>:
            <D.25044>:
            if (dest_dreg != -1) goto <D.25072>; else goto <D.25073>;
            <D.25072>:
            D.24554 = ins->dreg;
            if (D.24554 != dest_dreg) goto <D.25074>; else goto <D.25075>;
            <D.25074>:
            D.24554 = ins->dreg;
            create_copy_ins (cfg, bb, tmp, D.24554, dest_dreg, ins, ip, bank);
            ins->dreg = dest_dreg;
            D.24605 = bank != 0;
            D.24606 = (long int) D.24605;
            D.24607 = __builtin_expect (D.24606, 0);
            if (D.24607 != 0) goto <D.25076>; else goto <D.25077>;
            <D.25076>:
            {
              int translated_bank;

              D.25078 = cfg->rs;
              translated_bank = translate_bank (D.25078, bank, dest_dreg);
              D.25079 = rs->symbolic[translated_bank];
              D.25080 = (long unsigned int) dest_dreg;
              D.25081 = D.25080 * 4;
              D.25082 = D.25079 + D.25081;
              D.25083 = *D.25082;
              D.25084 = regbank_size[translated_bank];
              if (D.25083 >= D.25084) goto <D.25085>; else goto <D.25086>;
              <D.25085>:
              free_up_hreg (cfg, bb, tmp, ins, dest_dreg, translated_bank);
              <D.25086>:
            }
            goto <D.25087>;
            <D.25077>:
            D.25088 = rs->isymbolic[dest_dreg];
            if (D.25088 > 31) goto <D.25089>; else goto <D.25090>;
            <D.25089>:
            free_up_hreg (cfg, bb, tmp, ins, dest_dreg, bank);
            <D.25090>:
            <D.25087>:
            <D.25075>:
            <D.25073>:
            if (spec_dest == 98) goto <D.25091>; else goto <D.25092>;
            <D.25091>:
            j = 0;
            goto <D.23931>;
            <D.23930>:
            D.24591 = j + 1;
            D.24592 = (sizetype) D.24591;
            D.24593 = spec + D.24592;
            D.24594 = *D.24593;
            D.24597 = D.24594 + 154;
            if (D.24597 > 1) goto <D.25093>; else goto <D.25094>;
            <D.25093>:
            D.25095 = sreg_masks[j];
            D.24554 = ins->dreg;
            D.25096 = 1 << D.24554;
            D.25097 = ~D.25096;
            D.25098 = D.25095 & D.25097;
            sreg_masks[j] = D.25098;
            <D.25094>:
            j = j + 1;
            <D.23931>:
            if (j < num_sregs) goto <D.23930>; else goto <D.23932>;
            <D.23932>:
            <D.25092>:
            if (clob_reg != -1) goto <D.25099>; else goto <D.25100>;
            <D.25099>:
            D.24768 = rs->ifree_mask;
            D.25101 = D.24768 >> clob_reg;
            D.25102 = D.25101 & 1;
            if (D.25102 == 0) goto <D.25103>; else goto <D.25104>;
            <D.25103>:
            D.24545 = cfg->verbose_level;
            D.24577 = D.24545 > 2;
            D.24578 = (long int) D.24577;
            D.24579 = __builtin_expect (D.24578, 0);
            if (D.24579 != 0) goto <D.25105>; else goto <D.25106>;
            <D.25105>:
            D.25107 = rs->isymbolic[clob_reg];
            printf ("\tforced spill of clobbered reg R%d\n", D.25107);
            <D.25106>:
            free_up_hreg (cfg, bb, tmp, ins, clob_reg, 0);
            <D.25104>:
            <D.25100>:
            D.24685 = spec + 5;
            D.24686 = *D.24685;
            if (D.24686 == 99) goto <D.25108>; else goto <D.25109>;
            <D.25108>:
            {
              int j;
              int s;
              int dreg;
              int dreg2;
              int cur_bank;
              guint64 clob_mask;

              clob_mask = 8184;
              D.24768 = rs->ifree_mask;
              if (D.24768 != 8184) goto <D.25110>; else goto <D.25111>;
              <D.25110>:
              if (prev_dreg != -1) goto <D.25114>; else goto <D.25112>;
              <D.25114>:
              D.25115 = spec_dest + 154;
              if (D.25115 > 1) goto <D.25116>; else goto <D.25112>;
              <D.25116>:
              D.24628 = rs->vassign;
              D.24956 = (long unsigned int) prev_dreg;
              D.24957 = D.24956 * 4;
              D.24958 = D.24628 + D.24957;
              dreg = *D.24958;
              goto <D.25113>;
              <D.25112>:
              dreg = -1;
              <D.25113>:
              if (0 != 0) goto <D.25117>; else goto <D.25118>;
              <D.25117>:
              D.24628 = rs->vassign;
              D.25119 = (sizetype) prev_dreg;
              D.25120 = D.25119 + 1;
              D.25121 = D.25120 * 4;
              D.25122 = D.24628 + D.25121;
              dreg2 = *D.25122;
              goto <D.25123>;
              <D.25118>:
              dreg2 = -1;
              <D.25123>:
              j = 0;
              goto <D.23940>;
              <D.23939>:
              D.25124 = 1 << j;
              s = (int) D.25124;
              D.25125 = (long unsigned int) s;
              D.25126 = D.25125 & clob_mask;
              if (D.25126 != 0) goto <D.25127>; else goto <D.25128>;
              <D.25127>:
              D.24768 = rs->ifree_mask;
              D.25129 = (long unsigned int) s;
              D.25130 = D.24768 & D.25129;
              if (D.25130 == 0) goto <D.25131>; else goto <D.25132>;
              <D.25131>:
              D.24562 = ins->sreg1;
              if (D.24562 != j) goto <D.25133>; else goto <D.25134>;
              <D.25133>:
              if (j != dreg) goto <D.25137>; else goto <D.25135>;
              <D.25137>:
              if (j != dreg2) goto <D.25138>; else goto <D.25135>;
              <D.25138>:
              free_up_hreg (cfg, bb, tmp, ins, j, 0);
              goto <D.25136>;
              <D.25135>:
              D.25139 = rs->isymbolic[j];
              if (D.25139 != 0) goto <D.25140>; else goto <D.25141>;
              <D.25140>:
              D.24628 = rs->vassign;
              D.25139 = rs->isymbolic[j];
              D.25142 = (long unsigned int) D.25139;
              D.25143 = D.25142 * 4;
              D.25144 = D.24628 + D.25143;
              *D.25144 = -1;
              <D.25141>:
              <D.25136>:
              mono_regstate_free_int (rs, j);
              <D.25134>:
              <D.25132>:
              <D.25128>:
              j = j + 1;
              <D.23940>:
              if (j <= 31) goto <D.23939>; else goto <D.23941>;
              <D.23941>:
              <D.25111>:
              cur_bank = 1;
              goto <D.23947>;
              <D.23946>:
              D.25145 = rs->free_mask[cur_bank];
              D.25146 = regbank_callee_regs[cur_bank];
              if (D.25145 != D.25146) goto <D.25147>; else goto <D.25148>;
              <D.25147>:
              clob_mask = regbank_callee_regs[cur_bank];
              if (prev_dreg != -1) goto <D.25151>; else goto <D.25149>;
              <D.25151>:
              D.25115 = spec_dest + 154;
              if (D.25115 <= 1) goto <D.25152>; else goto <D.25149>;
              <D.25152>:
              D.24628 = rs->vassign;
              D.24956 = (long unsigned int) prev_dreg;
              D.24957 = D.24956 * 4;
              D.24958 = D.24628 + D.24957;
              dreg = *D.24958;
              goto <D.25150>;
              <D.25149>:
              dreg = -1;
              <D.25150>:
              j = 0;
              goto <D.23944>;
              <D.23943>:
              if (0 != 0) goto <D.25153>; else goto <D.25154>;
              <D.25153>:
              // predicted unlikely by continue predictor.
              goto <D.23942>;
              <D.25154>:
              D.25124 = 1 << j;
              s = (int) D.25124;
              D.25125 = (long unsigned int) s;
              D.25126 = D.25125 & clob_mask;
              if (D.25126 != 0) goto <D.25155>; else goto <D.25156>;
              <D.25155>:
              D.25145 = rs->free_mask[cur_bank];
              D.25129 = (long unsigned int) s;
              D.25157 = D.25145 & D.25129;
              if (D.25157 == 0) goto <D.25158>; else goto <D.25159>;
              <D.25158>:
              if (j != dreg) goto <D.25160>; else goto <D.25161>;
              <D.25160>:
              free_up_hreg (cfg, bb, tmp, ins, j, cur_bank);
              goto <D.25162>;
              <D.25161>:
              D.25163 = rs->symbolic[cur_bank];
              D.25164 = (long unsigned int) j;
              D.25165 = D.25164 * 4;
              D.25166 = D.25163 + D.25165;
              D.25167 = *D.25166;
              if (D.25167 != 0) goto <D.25168>; else goto <D.25169>;
              <D.25168>:
              D.24628 = rs->vassign;
              D.25163 = rs->symbolic[cur_bank];
              D.25164 = (long unsigned int) j;
              D.25165 = D.25164 * 4;
              D.25166 = D.25163 + D.25165;
              D.25167 = *D.25166;
              D.25170 = (long unsigned int) D.25167;
              D.25171 = D.25170 * 4;
              D.25172 = D.24628 + D.25171;
              *D.25172 = -1;
              <D.25169>:
              <D.25162>:
              mono_regstate_free_general (rs, j, cur_bank);
              <D.25159>:
              <D.25156>:
              <D.23942>:
              j = j + 1;
              <D.23944>:
              D.25173 = regbank_size[cur_bank];
              if (D.25173 > j) goto <D.23943>; else goto <D.23945>;
              <D.23945>:
              <D.25148>:
              cur_bank = cur_bank + 1;
              <D.23947>:
              if (cur_bank <= 3) goto <D.23946>; else goto <D.23948>;
              <D.23948>:
            }
            <D.25109>:
            D.24685 = spec + 5;
            D.24686 = *D.24685;
            if (D.24686 == 99) goto <D.25176>; else goto <D.25177>;
            <D.25176>:
            D.24549 = ins->opcode;
            D.24689 = D.24549 + 65193;
            if (D.24689 <= 2) goto <D.25174>; else goto <D.25178>;
            <D.25178>:
            D.24549 = ins->opcode;
            D.24691 = D.24549 + 65187;
            if (D.24691 <= 2) goto <D.25174>; else goto <D.25179>;
            <D.25179>:
            D.24549 = ins->opcode;
            D.24693 = D.24549 + 65184;
            if (D.24693 <= 2) goto <D.25174>; else goto <D.25180>;
            <D.25180>:
            D.24549 = ins->opcode;
            D.24695 = D.24549 + 65181;
            if (D.24695 <= 2) goto <D.25174>; else goto <D.25181>;
            <D.25181>:
            D.24549 = ins->opcode;
            D.24697 = D.24549 + 65190;
            if (D.24697 <= 2) goto <D.25174>; else goto <D.25182>;
            <D.25182>:
            D.24549 = ins->opcode;
            D.24699 = D.24549 + 65178;
            if (D.24699 <= 2) goto <D.25174>; else goto <D.25183>;
            <D.25183>:
            D.24549 = ins->opcode;
            if (D.24549 == 444) goto <D.25174>; else goto <D.25175>;
            <D.25174>:
            {
              struct MonoCallInst * call;
              struct GSList * list;

              call = ins;
              list = call->out_ireg_args;
              if (list != 0B) goto <D.25184>; else goto <D.25185>;
              <D.25184>:
              goto <D.23955>;
              <D.23954>:
              {
                guint32 regpair;
                int reg;
                int hreg;

                D.25186 = list->data;
                D.25187 = (long int) D.25186;
                regpair = (guint32) D.25187;
                D.25188 = regpair >> 24;
                hreg = (int) D.25188;
                regpair.41 = (int) regpair;
                reg = regpair.41 & 16777215;
                assign_reg (cfg, rs, reg, hreg, 0);
                D.25190 = sreg_masks[0];
                D.25191 = 1 << hreg;
                D.25192 = ~D.25191;
                D.25193 = D.25190 & D.25192;
                sreg_masks[0] = D.25193;
                D.24545 = cfg->verbose_level;
                D.24577 = D.24545 > 2;
                D.24578 = (long int) D.24577;
                D.24579 = __builtin_expect (D.24578, 0);
                if (D.24579 != 0) goto <D.25194>; else goto <D.25195>;
                <D.25194>:
                D.25196 = mono_arch_regname (hreg);
                printf ("\tassigned arg reg %s to R%d\n", D.25196, reg);
                <D.25195>:
                if (list != 0B) goto <D.25198>; else goto <D.25199>;
                <D.25198>:
                iftmp.42 = list->next;
                goto <D.25200>;
                <D.25199>:
                iftmp.42 = 0B;
                <D.25200>:
                list = iftmp.42;
              }
              <D.23955>:
              if (list != 0B) goto <D.23954>; else goto <D.23956>;
              <D.23956>:
              <D.25185>:
              list = call->out_freg_args;
              if (list != 0B) goto <D.25201>; else goto <D.25202>;
              <D.25201>:
              goto <D.23961>;
              <D.23960>:
              {
                guint32 regpair;
                int reg;
                int hreg;

                D.25186 = list->data;
                D.25187 = (long int) D.25186;
                regpair = (guint32) D.25187;
                D.25203 = regpair >> 24;
                hreg = (int) D.25203;
                regpair.43 = (int) regpair;
                reg = regpair.43 & 16777215;
                assign_reg (cfg, rs, reg, hreg, 1);
                D.24545 = cfg->verbose_level;
                D.24577 = D.24545 > 2;
                D.24578 = (long int) D.24577;
                D.24579 = __builtin_expect (D.24578, 0);
                if (D.24579 != 0) goto <D.25205>; else goto <D.25206>;
                <D.25205>:
                D.25207 = mono_regname_full (hreg, 1);
                printf ("\tassigned arg reg %s to R%d\n", D.25207, reg);
                <D.25206>:
                if (list != 0B) goto <D.25209>; else goto <D.25210>;
                <D.25209>:
                iftmp.44 = list->next;
                goto <D.25211>;
                <D.25210>:
                iftmp.44 = 0B;
                <D.25211>:
                list = iftmp.44;
              }
              <D.23961>:
              if (list != 0B) goto <D.23960>; else goto <D.23962>;
              <D.23962>:
              <D.25202>:
            }
            <D.25175>:
            <D.25177>:
            D.24725 = spec + 1;
            D.25212 = *D.24725;
            D.25213 = D.25212 + 154;
            D.25214 = D.25213 <= 1;
            bank = (int) D.25214;
            if (0 != 0) goto <D.25215>; else goto <D.25216>;
            <D.25215>:
            {
              int sreg1;
              int dest_sreg1;

              sreg1 = sregs[0];
              dest_sreg1 = dest_sregs[0];
              D.24605 = bank != 0;
              D.24606 = (long int) D.24605;
              D.24607 = __builtin_expect (D.24606, 0);
              if (D.24607 != 0) goto <D.25218>; else goto <D.25219>;
              <D.25218>:
              if (sreg1 >= 0) goto <D.25223>; else goto <D.25221>;
              <D.25223>:
              D.24615 = regbank_size[bank];
              if (D.24615 > sreg1) goto <D.25224>; else goto <D.25221>;
              <D.25224>:
              iftmp.46 = 1;
              goto <D.25222>;
              <D.25221>:
              iftmp.46 = 0;
              <D.25222>:
              D.25225 = iftmp.46 != 0;
              D.25226 = (int) D.25225;
              iftmp.45 = (long int) D.25226;
              goto <D.25227>;
              <D.25219>:
              D.25228 = sreg1 <= 31;
              D.25229 = (int) D.25228;
              iftmp.45 = (long int) D.25229;
              <D.25227>:
              D.25230 = __builtin_expect (iftmp.45, 0);
              if (D.25230 != 0) goto <D.25231>; else goto <D.25232>;
              <D.25231>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1879, "is_soft_reg (sreg1, bank)");
              <D.25232>:
              if (dest_sreg1 != -1) goto <D.25233>; else goto <D.25234>;
              <D.25233>:
              D.24554 = ins->dreg;
              D.25235 = D.24554 != dest_sreg1;
              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", 1883, "dest_sreg1 == ins->dreg");
              <D.25239>:
              <D.25234>:
              D.24554 = ins->dreg;
              D.25096 = 1 << D.24554;
              val = mono_regstate_alloc_int (rs, D.25096);
              D.25240 = val < 0;
              D.25241 = (long int) D.25240;
              D.25242 = __builtin_expect (D.25241, 0);
              if (D.25242 != 0) goto <D.25243>; else goto <D.25244>;
              <D.25243>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1885, "val >= 0");
              <D.25244>:
              D.24628 = rs->vassign;
              D.25245 = (long unsigned int) sreg1;
              D.25246 = D.25245 * 4;
              D.25247 = D.24628 + D.25246;
              D.25248 = *D.25247;
              if (D.25248 >= 0) goto <D.25249>; else goto <D.25250>;
              <D.25249>:
              D.24628 = rs->vassign;
              D.25245 = (long unsigned int) sreg1;
              D.25246 = D.25245 * 4;
              D.25247 = D.24628 + D.25246;
              D.25248 = *D.25247;
              if (D.25248 != val) goto <D.25251>; else goto <D.25252>;
              <D.25251>:
              monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-codegen.c", 1889);
              <D.25252>:
              <D.25250>:
              assign_reg (cfg, rs, sreg1, val, bank);
              D.24545 = cfg->verbose_level;
              D.24577 = D.24545 > 2;
              D.24578 = (long int) D.24577;
              D.24579 = __builtin_expect (D.24578, 0);
              if (D.24579 != 0) goto <D.25253>; else goto <D.25254>;
              <D.25253>:
              D.25255 = mono_regname_full (val, bank);
              printf ("\tassigned sreg1-low %s to R%d\n", D.25255, sreg1);
              <D.25254>:
              D.25256 = 8184 >> dreg_high;
              D.25257 = D.25256 & 1;
              D.25258 = D.25257 == 0;
              D.25259 = (long int) D.25258;
              D.25260 = __builtin_expect (D.25259, 0);
              if (D.25260 != 0) goto <D.25261>; else goto <D.25262>;
              <D.25261>:
              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.25262>:
              D.25263 = 1 << dreg_high;
              val = mono_regstate_alloc_int (rs, D.25263);
              D.25240 = val < 0;
              D.25241 = (long int) D.25240;
              D.25242 = __builtin_expect (D.25241, 0);
              if (D.25242 != 0) goto <D.25264>; else goto <D.25265>;
              <D.25264>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1897, "val >= 0");
              <D.25265>:
              D.24628 = rs->vassign;
              D.25266 = (sizetype) sreg1;
              D.25267 = D.25266 + 1;
              D.25268 = D.25267 * 4;
              D.25269 = D.24628 + D.25268;
              D.25270 = *D.25269;
              if (D.25270 >= 0) goto <D.25271>; else goto <D.25272>;
              <D.25271>:
              D.24628 = rs->vassign;
              D.25266 = (sizetype) sreg1;
              D.25267 = D.25266 + 1;
              D.25268 = D.25267 * 4;
              D.25269 = D.24628 + D.25268;
              D.25270 = *D.25269;
              if (D.25270 != val) goto <D.25273>; else goto <D.25274>;
              <D.25273>:
              monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-codegen.c", 1901);
              <D.25274>:
              <D.25272>:
              D.25275 = sreg1 + 1;
              assign_reg (cfg, rs, D.25275, val, bank);
              D.24545 = cfg->verbose_level;
              D.24577 = D.24545 > 2;
              D.24578 = (long int) D.24577;
              D.24579 = __builtin_expect (D.24578, 0);
              if (D.24579 != 0) goto <D.25276>; else goto <D.25277>;
              <D.25276>:
              D.25278 = mono_regname_full (val, bank);
              D.25275 = sreg1 + 1;
              printf ("\tassigned sreg1-high %s to R%d\n", D.25278, D.25275);
              <D.25277>:
              dest_sregs[0] = -1;
            }
            <D.25216>:
            D.25279 = sreg_fixed_masks[0];
            if (D.25279 != 0) goto <D.25280>; else goto <D.25281>;
            <D.25280>:
            D.24605 = bank != 0;
            D.24606 = (long int) D.24605;
            D.24607 = __builtin_expect (D.24606, 0);
            if (D.24607 != 0) goto <D.25282>; else goto <D.25283>;
            <D.25282>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1912, "!bank");
            <D.25283>:
            D.25286 = sregs[0];
            D.25287 = (unsigned int) D.25286;
            if (D.25287 <= 31) goto <D.25288>; else goto <D.25284>;
            <D.25288>:
            D.25286 = sregs[0];
            D.25289 = 18446744073709543424 >> D.25286;
            D.25290 = D.25289 & 1;
            if (D.25290 != 0) goto <D.25291>; else goto <D.25284>;
            <D.25291>:
            D.25279 = sreg_fixed_masks[0];
            val = mono_regstate_alloc_int (rs, D.25279);
            if (val < 0) goto <D.25292>; else goto <D.25293>;
            <D.25292>:
            D.25279 = sreg_fixed_masks[0];
            val = get_register_spilling (cfg, bb, tmp, ins, D.25279, -1, bank);
            <D.25293>:
            mono_regstate_free_int (rs, val);
            dest_sregs[0] = val;
            goto <D.25285>;
            <D.25284>:
            D.25190 = sreg_masks[0];
            D.25279 = sreg_fixed_masks[0];
            D.25294 = D.25190 & D.25279;
            sreg_masks[0] = D.25294;
            <D.25285>:
            <D.25281>:
            D.24850 = dest_sregs[0];
            if (D.24850 != -1) goto <D.25295>; else goto <D.25296>;
            <D.25295>:
            D.24850 = dest_sregs[0];
            D.24853 = 1 << D.24850;
            sreg_masks[0] = D.24853;
            D.24628 = rs->vassign;
            D.25286 = sregs[0];
            D.25297 = (long unsigned int) D.25286;
            D.25298 = D.25297 * 4;
            D.25299 = D.24628 + D.25298;
            D.25300 = *D.25299;
            D.24850 = dest_sregs[0];
            if (D.25300 != D.24850) goto <D.25301>; else goto <D.25302>;
            <D.25301>:
            D.24768 = rs->ifree_mask;
            D.24850 = dest_sregs[0];
            D.25303 = D.24768 >> D.24850;
            D.25304 = D.25303 & 1;
            if (D.25304 == 0) goto <D.25305>; else goto <D.25306>;
            <D.25305>:
            D.24850 = dest_sregs[0];
            free_up_hreg (cfg, bb, tmp, ins, D.24850, 0);
            <D.25306>:
            <D.25302>:
            D.25286 = sregs[0];
            D.25287 = (unsigned int) D.25286;
            if (D.25287 <= 31) goto <D.25307>; else goto <D.25308>;
            <D.25307>:
            D.25286 = sregs[0];
            D.25289 = 18446744073709543424 >> D.25286;
            D.25290 = D.25289 & 1;
            if (D.25290 != 0) goto <D.25309>; else goto <D.25310>;
            <D.25309>:
            {
              struct MonoInst * copy;

              D.24850 = dest_sregs[0];
              D.25286 = sregs[0];
              copy = create_copy_ins (cfg, bb, tmp, D.24850, D.25286, 0B, ip, 0);
              insert_before_ins (bb, ins, copy);
              D.24850 = dest_sregs[0];
              sregs[0] = D.24850;
            }
            <D.25310>:
            <D.25308>:
            <D.25296>:
            D.24605 = bank != 0;
            D.24606 = (long int) D.24605;
            D.24607 = __builtin_expect (D.24606, 0);
            if (D.24607 != 0) goto <D.25312>; else goto <D.25313>;
            <D.25312>:
            D.25286 = sregs[0];
            if (D.25286 < 0) goto <D.25315>; else goto <D.25318>;
            <D.25318>:
            D.25286 = sregs[0];
            D.24615 = regbank_size[bank];
            if (D.25286 >= D.24615) goto <D.25315>; else goto <D.25316>;
            <D.25315>:
            iftmp.48 = 1;
            goto <D.25317>;
            <D.25316>:
            iftmp.48 = 0;
            <D.25317>:
            iftmp.47 = (_Bool) iftmp.48;
            goto <D.25319>;
            <D.25313>:
            D.25286 = sregs[0];
            iftmp.47 = D.25286 > 31;
            <D.25319>:
            if (iftmp.47 != 0) goto <D.25320>; else goto <D.25321>;
            <D.25320>:
            D.24628 = rs->vassign;
            D.25286 = sregs[0];
            D.25297 = (long unsigned int) D.25286;
            D.25298 = D.25297 * 4;
            D.25299 = D.24628 + D.25298;
            val = *D.25299;
            D.25286 = sregs[0];
            prev_sregs[0] = D.25286;
            if (val < 0) goto <D.25322>; else goto <D.25323>;
            <D.25322>:
            {
              int spill;

              spill = 0;
              if (val < -1) goto <D.25324>; else goto <D.25325>;
              <D.25324>:
              spill = ~val;
              <D.25325>:
              D.24549 = ins->opcode;
              if (D.24549 == 424) goto <D.25326>; else goto <D.25327>;
              <D.25326>:
              D.25328 = spill | bank;
              if (D.25328 == 0) goto <D.25329>; else goto <D.25330>;
              <D.25329>:
              D.24554 = ins->dreg;
              D.24917 = (unsigned int) D.24554;
              if (D.24917 <= 31) goto <D.25331>; else goto <D.25332>;
              <D.25331>:
              D.24554 = ins->dreg;
              D.25333 = 8184 >> D.24554;
              D.25334 = D.25333 & 1;
              if (D.25334 != 0) goto <D.25335>; else goto <D.25336>;
              <D.25335>:
              D.24768 = rs->ifree_mask;
              D.24554 = ins->dreg;
              D.25337 = D.24768 >> D.24554;
              D.25338 = D.25337 & 1;
              if (D.25338 != 0) goto <D.25339>; else goto <D.25340>;
              <D.25339>:
              D.24554 = ins->dreg;
              D.25096 = 1 << D.24554;
              sreg_masks[0] = D.25096;
              <D.25340>:
              <D.25336>:
              <D.25332>:
              <D.25330>:
              <D.25327>:
              D.24685 = spec + 5;
              D.24686 = *D.24685;
              if (D.24686 == 49) goto <D.25341>; else goto <D.25342>;
              <D.25341>:
              D.24646 = *spec;
              D.24647 = D.24646 + 154;
              if (D.24647 > 1) goto <D.25343>; else goto <D.25344>;
              <D.25343>:
              D.24768 = rs->ifree_mask;
              D.24554 = ins->dreg;
              D.25337 = D.24768 >> D.24554;
              D.25338 = D.25337 & 1;
              if (D.25338 != 0) goto <D.25345>; else goto <D.25346>;
              <D.25345>:
              D.24554 = ins->dreg;
              D.25096 = 1 << D.24554;
              sreg_masks[0] = D.25096;
              <D.25346>:
              <D.25344>:
              <D.25342>:
              D.25190 = sreg_masks[0];
              D.25286 = sregs[0];
              D.25286 = sregs[0];
              D.25297 = (long unsigned int) D.25286;
              D.25347 = D.25297 * 16;
              D.25348 = reginfo + D.25347;
              val = alloc_reg (cfg, bb, tmp, ins, D.25190, D.25286, D.25348, bank);
              D.25286 = sregs[0];
              assign_reg (cfg, rs, D.25286, val, bank);
              D.24545 = cfg->verbose_level;
              D.24577 = D.24545 > 2;
              D.24578 = (long int) D.24577;
              D.24579 = __builtin_expect (D.24578, 0);
              if (D.24579 != 0) goto <D.25349>; else goto <D.25350>;
              <D.25349>:
              D.25351 = mono_regname_full (val, bank);
              D.25286 = sregs[0];
              printf ("\tassigned sreg1 %s to R%d\n", D.25351, D.25286);
              <D.25350>:
              if (spill != 0) goto <D.25352>; else goto <D.25353>;
              <D.25352>:
              D.25354 = prev_sregs[0];
              create_spilled_store (cfg, bb, spill, val, D.25354, tmp, 0B, ins, bank);
              <D.25353>:
            }
            goto <D.25355>;
            <D.25323>:
            D.24850 = dest_sregs[0];
            if (D.24850 != -1) goto <D.25356>; else goto <D.25357>;
            <D.25356>:
            D.24850 = dest_sregs[0];
            if (D.24850 != val) goto <D.25358>; else goto <D.25359>;
            <D.25358>:
            {
              struct MonoInst * copy;

              D.24850 = dest_sregs[0];
              copy = create_copy_ins (cfg, bb, tmp, D.24850, val, 0B, ip, bank);
              insert_before_ins (bb, ins, copy);
              j = 1;
              goto <D.23969>;
              <D.23968>:
              D.25095 = sreg_masks[j];
              D.24850 = dest_sregs[0];
              D.24853 = 1 << D.24850;
              D.24854 = ~D.24853;
              D.25360 = D.25095 & D.24854;
              sreg_masks[j] = D.25360;
              j = j + 1;
              <D.23969>:
              if (j < num_sregs) goto <D.23968>; else goto <D.23970>;
              <D.23970>:
              val = dest_sregs[0];
            }
            <D.25359>:
            <D.25357>:
            <D.25355>:
            sregs[0] = val;
            goto <D.25361>;
            <D.25321>:
            prev_sregs[0] = -1;
            <D.25361>:
            mono_inst_set_src_registers (ins, &sregs);
            j = 1;
            goto <D.23972>;
            <D.23971>:
            D.25095 = sreg_masks[j];
            D.25286 = sregs[0];
            D.25362 = 1 << D.25286;
            D.25363 = ~D.25362;
            D.25364 = D.25095 & D.25363;
            sreg_masks[j] = D.25364;
            j = j + 1;
            <D.23972>:
            if (j < num_sregs) goto <D.23971>; else goto <D.23973>;
            <D.23973>:
            if (0 != 0) goto <D.25365>; else goto <D.25366>;
            <D.25365>:
            {
              int reg2;

              D.25354 = prev_sregs[0];
              reg2 = D.25354 + 1;
              D.24605 = bank != 0;
              D.24606 = (long int) D.24605;
              D.24607 = __builtin_expect (D.24606, 0);
              if (D.24607 != 0) goto <D.25367>; else goto <D.25368>;
              <D.25367>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 2000, "!bank");
              <D.25368>:
              D.25354 = prev_sregs[0];
              D.25369 = D.25354 < 0;
              D.25370 = (long int) D.25369;
              D.25371 = __builtin_expect (D.25370, 0);
              if (D.25371 != 0) goto <D.25372>; else goto <D.25373>;
              <D.25372>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 2001, "prev_sregs [0] > -1");
              <D.25373>:
              D.24628 = rs->vassign;
              D.25354 = prev_sregs[0];
              D.25377 = (long unsigned int) D.25354;
              D.25378 = D.25377 * 4;
              D.25379 = D.24628 + D.25378;
              D.25380 = *D.25379;
              D.25381 = (unsigned int) D.25380;
              if (D.25381 <= 31) goto <D.25382>; else goto <D.25375>;
              <D.25382>:
              D.24628 = rs->vassign;
              D.25354 = prev_sregs[0];
              D.25377 = (long unsigned int) D.25354;
              D.25378 = D.25377 * 4;
              D.25379 = D.24628 + D.25378;
              D.25380 = *D.25379;
              D.25383 = 18446744073709543424 >> D.25380;
              D.25384 = D.25383 & 1;
              if (D.25384 != 0) goto <D.25385>; else goto <D.25375>;
              <D.25385>:
              iftmp.49 = 1;
              goto <D.25376>;
              <D.25375>:
              iftmp.49 = 0;
              <D.25376>:
              D.25386 = iftmp.49 != 0;
              D.25387 = (long int) D.25386;
              D.25388 = __builtin_expect (D.25387, 0);
              if (D.25388 != 0) goto <D.25389>; else goto <D.25390>;
              <D.25389>:
              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.25390>:
              mask = 8184;
              D.24628 = rs->vassign;
              D.25391 = (long unsigned int) reg2;
              D.25392 = D.25391 * 4;
              D.25393 = D.24628 + D.25392;
              val = *D.25393;
              if (val < 0) goto <D.25394>; else goto <D.25395>;
              <D.25394>:
              {
                int spill;

                spill = 0;
                if (val < -1) goto <D.25396>; else goto <D.25397>;
                <D.25396>:
                spill = ~val;
                <D.25397>:
                val = mono_regstate_alloc_int (rs, mask);
                if (val < 0) goto <D.25398>; else goto <D.25399>;
                <D.25398>:
                val = get_register_spilling (cfg, bb, tmp, ins, mask, reg2, bank);
                <D.25399>:
                if (spill != 0) goto <D.25400>; else goto <D.25401>;
                <D.25400>:
                monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-codegen.c", 2015);
                <D.25401>:
              }
              goto <D.25402>;
              <D.25395>:
              D.24982 = mask >> val;
              D.24983 = D.24982 & 1;
              if (D.24983 == 0) goto <D.25403>; else goto <D.25404>;
              <D.25403>:
              monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-codegen.c", 2021);
              <D.25404>:
              <D.25402>:
              sreg1_high = val;
              D.24545 = cfg->verbose_level;
              D.24577 = D.24545 > 2;
              D.24578 = (long int) D.24577;
              D.24579 = __builtin_expect (D.24578, 0);
              if (D.24579 != 0) goto <D.25405>; else goto <D.25406>;
              <D.25405>:
              D.25407 = mono_arch_regname (val);
              printf ("\tassigned sreg1 hreg %s to dest R%d\n", D.25407, reg2);
              <D.25406>:
              assign_reg (cfg, rs, reg2, val, bank);
            }
            <D.25366>:
            D.24646 = *spec;
            D.24647 = D.24646 + 154;
            if (D.24647 <= 1) goto <D.25411>; else goto <D.25408>;
            <D.25411>:
            D.24725 = spec + 1;
            D.25212 = *D.24725;
            D.25213 = D.25212 + 154;
            if (D.25213 <= 1) goto <D.25409>; else goto <D.25408>;
            <D.25408>:
            D.24685 = spec + 5;
            D.24686 = *D.24685;
            if (D.24686 == 49) goto <D.25409>; else goto <D.25410>;
            <D.25409>:
            D.24554 = ins->dreg;
            D.25286 = sregs[0];
            if (D.24554 != D.25286) goto <D.25412>; else goto <D.25413>;
            <D.25412>:
            {
              struct MonoInst * sreg2_copy;
              struct MonoInst * copy;
              int bank;

              sreg2_copy = 0B;
              D.25414 = spec_src1 + 154;
              D.25415 = D.25414 <= 1;
              bank = (int) D.25415;
              D.24554 = ins->dreg;
              D.25416 = sregs[1];
              if (D.24554 == D.25416) goto <D.25417>; else goto <D.25418>;
              <D.25417>:
              {
                int reg2;

                D.25416 = sregs[1];
                reg2 = alloc_reg (cfg, bb, tmp, ins, dreg_mask, D.25416, 0B, bank);
                D.24545 = cfg->verbose_level;
                D.24577 = D.24545 > 2;
                D.24578 = (long int) D.24577;
                D.24579 = __builtin_expect (D.24578, 0);
                if (D.24579 != 0) goto <D.25419>; else goto <D.25420>;
                <D.25419>:
                D.25416 = sregs[1];
                D.25421 = mono_regname_full (D.25416, bank);
                D.25422 = mono_regname_full (reg2, bank);
                printf ("\tneed to copy sreg2 %s to reg %s\n", D.25421, D.25422);
                <D.25420>:
                D.25416 = sregs[1];
                sreg2_copy = create_copy_ins (cfg, bb, tmp, reg2, D.25416, 0B, ip, bank);
                sregs[1] = reg2;
                D.25416 = sregs[1];
                prev_sregs[1] = D.25416;
                D.25423 = bank != 0;
                D.25424 = (long int) D.25423;
                D.25425 = __builtin_expect (D.25424, 0);
                if (D.25425 != 0) goto <D.25426>; else goto <D.25427>;
                <D.25426>:
                mono_regstate_free_general (rs, reg2, bank);
                goto <D.25428>;
                <D.25427>:
                mono_regstate_free_int (rs, reg2);
                <D.25428>:
              }
              <D.25418>:
              if (0 != 0) goto <D.25429>; else goto <D.25430>;
              <D.25429>:
              D.24628 = rs->vassign;
              D.25354 = prev_sregs[0];
              D.25431 = (sizetype) D.25354;
              D.25432 = D.25431 + 1;
              D.25433 = D.25432 * 4;
              D.25434 = D.24628 + D.25433;
              D.25435 = *D.25434;
              D.25416 = sregs[1];
              if (D.25435 == D.25416) goto <D.25436>; else goto <D.25437>;
              <D.25436>:
              monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-codegen.c", 2067);
              <D.25437>:
              D.25286 = sregs[0];
              D.24554 = ins->dreg;
              D.25438 = D.25286 != D.24554;
              D.25439 = (long int) D.25438;
              D.25440 = __builtin_expect (D.25439, 0);
              if (D.25440 != 0) goto <D.25441>; else goto <D.25442>;
              <D.25441>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 2073, "sregs [0] == ins->dreg");
              <D.25442>:
              D.25443 = dreg_high != sreg1_high;
              D.25444 = (long int) D.25443;
              D.25445 = __builtin_expect (D.25444, 0);
              if (D.25445 != 0) goto <D.25446>; else goto <D.25447>;
              <D.25446>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 2074, "dreg_high == sreg1_high");
              <D.25447>:
              <D.25430>:
              D.24545 = cfg->verbose_level;
              D.24577 = D.24545 > 2;
              D.24578 = (long int) D.24577;
              D.24579 = __builtin_expect (D.24578, 0);
              if (D.24579 != 0) goto <D.25448>; else goto <D.25449>;
              <D.25448>:
              D.25286 = sregs[0];
              D.25450 = mono_regname_full (D.25286, bank);
              D.24554 = ins->dreg;
              D.25451 = mono_regname_full (D.24554, bank);
              printf ("\tneed to copy sreg1 %s to dreg %s\n", D.25450, D.25451);
              <D.25449>:
              D.24554 = ins->dreg;
              D.25286 = sregs[0];
              copy = create_copy_ins (cfg, bb, tmp, D.24554, D.25286, 0B, ip, bank);
              insert_before_ins (bb, ins, copy);
              if (sreg2_copy != 0B) goto <D.25452>; else goto <D.25453>;
              <D.25452>:
              insert_before_ins (bb, copy, sreg2_copy);
              <D.25453>:
              D.24736 = sreg_masks[1];
              D.25286 = sregs[0];
              D.25362 = 1 << D.25286;
              D.25363 = ~D.25362;
              D.25454 = D.24736 & D.25363;
              sreg_masks[1] = D.25454;
              D.24554 = ins->dreg;
              sregs[0] = D.24554;
              D.25286 = sregs[0];
              prev_sregs[0] = D.25286;
              D.24736 = sreg_masks[1];
              D.24554 = ins->dreg;
              D.25096 = 1 << D.24554;
              D.25097 = ~D.25096;
              D.25455 = D.24736 & D.25097;
              sreg_masks[1] = D.25455;
            }
            <D.25413>:
            <D.25410>:
            mono_inst_set_src_registers (ins, &sregs);
            j = 1;
            goto <D.23987>;
            <D.23986>:
            {
              int k;

              D.24591 = j + 1;
              D.24592 = (sizetype) D.24591;
              D.24593 = spec + D.24592;
              D.24594 = *D.24593;
              D.24597 = D.24594 + 154;
              D.24598 = D.24597 <= 1;
              bank = (int) D.24598;
              if (0 != 0) goto <D.25456>; else goto <D.25457>;
              <D.25456>:
              monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-codegen.c", 2103);
              <D.25457>:
              D.24855 = dest_sregs[j];
              if (D.24855 != -1) goto <D.25460>; else goto <D.25458>;
              <D.25460>:
              D.24566 = sregs[j];
              D.25461 = (unsigned int) D.24566;
              if (D.25461 <= 31) goto <D.25462>; else goto <D.25458>;
              <D.25462>:
              D.24566 = sregs[j];
              D.25463 = 18446744073709543424 >> D.24566;
              D.25464 = D.25463 & 1;
              if (D.25464 != 0) goto <D.25465>; else goto <D.25458>;
              <D.25465>:
              {
                struct MonoInst * copy;

                D.24855 = dest_sregs[j];
                D.24566 = sregs[j];
                copy = create_copy_ins (cfg, bb, tmp, D.24855, D.24566, 0B, ip, 0);
                insert_before_ins (bb, ins, copy);
                D.24855 = dest_sregs[j];
                sregs[j] = D.24855;
              }
              goto <D.25459>;
              <D.25458>:
              D.24605 = bank != 0;
              D.24606 = (long int) D.24605;
              D.24607 = __builtin_expect (D.24606, 0);
              if (D.24607 != 0) goto <D.25467>; else goto <D.25468>;
              <D.25467>:
              D.24566 = sregs[j];
              if (D.24566 < 0) goto <D.25470>; else goto <D.25473>;
              <D.25473>:
              D.24566 = sregs[j];
              D.24615 = regbank_size[bank];
              if (D.24566 >= D.24615) goto <D.25470>; else goto <D.25471>;
              <D.25470>:
              iftmp.51 = 1;
              goto <D.25472>;
              <D.25471>:
              iftmp.51 = 0;
              <D.25472>:
              iftmp.50 = (_Bool) iftmp.51;
              goto <D.25474>;
              <D.25468>:
              D.24566 = sregs[j];
              iftmp.50 = D.24566 > 31;
              <D.25474>:
              if (iftmp.50 != 0) goto <D.25475>; else goto <D.25476>;
              <D.25475>:
              D.24628 = rs->vassign;
              D.24566 = sregs[j];
              D.24574 = (long unsigned int) D.24566;
              D.25477 = D.24574 * 4;
              D.25478 = D.24628 + D.25477;
              val = *D.25478;
              D.24855 = dest_sregs[j];
              if (D.24855 != -1) goto <D.25479>; else goto <D.25480>;
              <D.25479>:
              if (val >= 0) goto <D.25481>; else goto <D.25482>;
              <D.25481>:
              D.24855 = dest_sregs[j];
              if (D.24855 != val) goto <D.25483>; else goto <D.25484>;
              <D.25483>:
              D.24566 = sregs[j];
              spill_vreg (cfg, bb, tmp, ins, D.24566, 0);
              D.24628 = rs->vassign;
              D.24566 = sregs[j];
              D.24574 = (long unsigned int) D.24566;
              D.25477 = D.24574 * 4;
              D.25478 = D.24628 + D.25477;
              val = *D.25478;
              <D.25484>:
              <D.25482>:
              <D.25480>:
              if (val < 0) goto <D.25485>; else goto <D.25486>;
              <D.25485>:
              {
                int spill;

                spill = 0;
                if (val < -1) goto <D.25487>; else goto <D.25488>;
                <D.25487>:
                spill = ~val;
                <D.25488>:
                D.25095 = sreg_masks[j];
                D.24566 = sregs[j];
                D.24566 = sregs[j];
                D.24574 = (long unsigned int) D.24566;
                D.24575 = D.24574 * 16;
                D.25489 = reginfo + D.24575;
                val = alloc_reg (cfg, bb, tmp, ins, D.25095, D.24566, D.25489, bank);
                D.24566 = sregs[j];
                assign_reg (cfg, rs, D.24566, val, bank);
                D.24545 = cfg->verbose_level;
                D.24577 = D.24545 > 2;
                D.24578 = (long int) D.24577;
                D.24579 = __builtin_expect (D.24578, 0);
                if (D.24579 != 0) goto <D.25490>; else goto <D.25491>;
                <D.25490>:
                D.24591 = j + 1;
                D.25492 = mono_regname_full (val, bank);
                D.24566 = sregs[j];
                printf ("\tassigned sreg%d %s to R%d\n", D.24591, D.25492, D.24566);
                <D.25491>:
                if (spill != 0) goto <D.25493>; else goto <D.25494>;
                <D.25493>:
                D.24566 = sregs[j];
                create_spilled_store (cfg, bb, spill, val, D.24566, tmp, 0B, ins, bank);
                <D.25494>:
              }
              <D.25486>:
              sregs[j] = val;
              k = j + 1;
              goto <D.23984>;
              <D.23983>:
              D.25495 = sreg_masks[k];
              D.24566 = sregs[j];
              D.25496 = 1 << D.24566;
              D.25497 = ~D.25496;
              D.25498 = D.25495 & D.25497;
              sreg_masks[k] = D.25498;
              k = k + 1;
              <D.23984>:
              if (k < num_sregs) goto <D.23983>; else goto <D.23985>;
              <D.23985>:
              goto <D.25499>;
              <D.25476>:
              prev_sregs[j] = -1;
              <D.25499>:
              <D.25459>:
            }
            j = j + 1;
            <D.23987>:
            if (j < num_sregs) goto <D.23986>; else goto <D.23988>;
            <D.23988>:
            mono_inst_set_src_registers (ins, &sregs);
            j = 1;
            goto <D.23996>;
            <D.23995>:
            {
              int sreg;
              int dest_sreg;

              sreg = sregs[j];
              dest_sreg = dest_sregs[j];
              if (j == 2) goto <D.25500>; else goto <D.25501>;
              <D.25500>:
              if (dest_sreg != -1) goto <D.25502>; else goto <D.25503>;
              <D.25502>:
              {
                int k;

                D.25504 = sreg != dest_sreg;
                D.25505 = (long int) D.25504;
                D.25506 = __builtin_expect (D.25505, 0);
                if (D.25506 != 0) goto <D.25507>; else goto <D.25508>;
                <D.25507>:
                monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 2163, "sreg == dest_sreg");
                <D.25508>:
                k = 0;
                goto <D.23993>;
                <D.23992>:
                if (k != j) goto <D.25509>; else goto <D.25510>;
                <D.25509>:
                D.25511 = sregs[k];
                D.25512 = D.25511 == dest_sreg;
                D.25513 = (long int) D.25512;
                D.25514 = __builtin_expect (D.25513, 0);
                if (D.25514 != 0) goto <D.25515>; else goto <D.25516>;
                <D.25515>:
                monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 2167, "sregs [k] != dest_sreg");
                <D.25516>:
                <D.25510>:
                k = k + 1;
                <D.23993>:
                if (k < num_sregs) goto <D.23992>; else goto <D.23994>;
                <D.23994>:
              }
              <D.25503>:
              <D.25501>:
            }
            j = j + 1;
            <D.23996>:
            if (j < num_sregs) goto <D.23995>; else goto <D.23997>;
            <D.23997>:
            D.24545 = cfg->verbose_level;
            D.24577 = D.24545 > 2;
            D.24578 = (long int) D.24577;
            D.24579 = __builtin_expect (D.24578, 0);
            if (D.24579 != 0) goto <D.25517>; else goto <D.25518>;
            <D.25517>:
            mono_print_ins_index (i, ins);
            <D.25518>:
          }
        finally
          {
            dest_sregs = {CLOBBER};
            prev_sregs = {CLOBBER};
            sreg_masks = {CLOBBER};
            sreg_fixed_masks = {CLOBBER};
          }
      }
      ins = prev;
      if (ins != 0B) goto <D.25520>; else goto <D.25521>;
      <D.25520>:
      iftmp.52 = ins->prev;
      goto <D.25522>;
      <D.25521>:
      iftmp.52 = 0B;
      <D.25522>:
      prev = iftmp.52;
      <D.23999>:
      if (ins != 0B) goto <D.23998>; else goto <D.24000>;
      <D.24000>:
    }
  finally
    {
      last = {CLOBBER};
      sregs = {CLOBBER};
    }
}


mono_regstate_assign (struct MonoRegState * rs)
{
  int D.25526;
  int D.25527;
  gint32 * D.25530;
  int D.25531;
  long unsigned int D.25532;
  long unsigned int D.25533;
  void * D.25534;
  int[32] * D.25535;
  int[32] * D.25536;

  D.25526 = rs->next_vreg;
  D.25527 = rs->vassign_size;
  if (D.25526 > D.25527) goto <D.25528>; else goto <D.25529>;
  <D.25528>:
  D.25530 = rs->vassign;
  monoeg_g_free (D.25530);
  D.25526 = rs->next_vreg;
  D.25531 = MAX_EXPR <D.25526, 256>;
  rs->vassign_size = D.25531;
  D.25527 = rs->vassign_size;
  D.25532 = (long unsigned int) D.25527;
  D.25533 = D.25532 * 4;
  D.25534 = monoeg_malloc (D.25533);
  rs->vassign = D.25534;
  <D.25529>:
  D.25535 = &rs->isymbolic;
  memset (D.25535, 0, 128);
  D.25536 = &rs->fsymbolic;
  memset (D.25536, 0, 128);
  D.25535 = &rs->isymbolic;
  rs->symbolic[0] = D.25535;
  D.25536 = &rs->fsymbolic;
  rs->symbolic[1] = D.25536;
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.25539;
  int D.25544;
  void * D.25546;
  long unsigned int D.25547;

  D.25539 = __builtin_constant_p (__len);
  if (D.25539 != 0) goto <D.25540>; else goto <D.25541>;
  <D.25540>:
  if (__len == 0) goto <D.25542>; else goto <D.25543>;
  <D.25542>:
  D.25544 = __builtin_constant_p (__ch);
  if (D.25544 == 0) goto <D.25537>; else goto <D.25545>;
  <D.25545>:
  if (__ch != 0) goto <D.25537>; else goto <D.25538>;
  <D.25537>:
  __warn_memset_zero_len ();
  D.25546 = __dest;
  return D.25546;
  <D.25538>:
  <D.25543>:
  <D.25541>:
  D.25547 = __builtin_object_size (__dest, 0);
  D.25546 = __builtin___memset_chk (__dest, __ch, __len, D.25547);
  return D.25546;
}


print_regtrack (struct RegTrack * t, int num)
{
  long unsigned int D.25549;
  long unsigned int D.25550;
  struct RegTrack * D.25551;
  int D.25552;
  int D.25558;
  int i;
  char buf[32];
  const char * r;

  try
    {
      i = 0;
      goto <D.23672>;
      <D.23671>:
      D.25549 = (long unsigned int) i;
      D.25550 = D.25549 * 16;
      D.25551 = t + D.25550;
      D.25552 = D.25551->born_in;
      if (D.25552 == 0) goto <D.25553>; else goto <D.25554>;
      <D.25553>:
      // predicted unlikely by continue predictor.
      goto <D.23670>;
      <D.25554>:
      if (i > 31) goto <D.25555>; else goto <D.25556>;
      <D.25555>:
      monoeg_g_snprintf (&buf, 32, "R%d", i);
      r = &buf;
      goto <D.25557>;
      <D.25556>:
      r = mono_arch_regname (i);
      <D.25557>:
      D.25549 = (long unsigned int) i;
      D.25550 = D.25549 * 16;
      D.25551 = t + D.25550;
      D.25552 = D.25551->born_in;
      D.25549 = (long unsigned int) i;
      D.25550 = D.25549 * 16;
      D.25551 = t + D.25550;
      D.25558 = D.25551->killed_in;
      printf ("liveness: %s [%d - %d]\n", r, D.25552, D.25558);
      <D.23670>:
      i = i + 1;
      <D.23672>:
      if (i < num) goto <D.23671>; else goto <D.23673>;
      <D.23673>:
    }
  finally
    {
      buf = {CLOBBER};
    }
}


get_callee_mask (const char spec)
{
  char D.25559;
  _Bool D.25560;
  long int D.25561;
  long int D.25562;
  regmask_t D.25565;
  int D.25566;

  D.25559 = spec + 154;
  D.25560 = D.25559 <= 1;
  D.25561 = (long int) D.25560;
  D.25562 = __builtin_expect (D.25561, 0);
  if (D.25562 != 0) goto <D.25563>; else goto <D.25564>;
  <D.25563>:
  D.25559 = spec + 154;
  D.25560 = D.25559 <= 1;
  D.25566 = (int) D.25560;
  D.25565 = regbank_callee_regs[D.25566];
  return D.25565;
  <D.25564>:
  D.25565 = 8184;
  return D.25565;
}


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.25570;
  struct MonoRegState * D.25573;
  long unsigned int D.25574;
  unsigned int D.25577;
  _Bool D.25578;
  long int D.25579;
  long int D.25580;
  const char * D.25583;
  int D.25584;
  int val;

  if (info != 0B) goto <D.25568>; else goto <D.25569>;
  <D.25568>:
  D.25570 = info->preferred_mask;
  if (D.25570 != 0) goto <D.25571>; else goto <D.25572>;
  <D.25571>:
  D.25573 = cfg->rs;
  D.25570 = info->preferred_mask;
  D.25574 = D.25570 & dest_mask;
  val = mono_regstate_alloc_int (D.25573, D.25574);
  if (val >= 0) goto <D.25575>; else goto <D.25576>;
  <D.25575>:
  D.25577 = cfg->verbose_level;
  D.25578 = D.25577 > 2;
  D.25579 = (long int) D.25578;
  D.25580 = __builtin_expect (D.25579, 0);
  if (D.25580 != 0) goto <D.25581>; else goto <D.25582>;
  <D.25581>:
  D.25583 = mono_arch_regname (val);
  printf ("\tallocated preferred reg R%d to %s\n", sym_reg, D.25583);
  <D.25582>:
  D.25584 = val;
  return D.25584;
  <D.25576>:
  <D.25572>:
  <D.25569>:
  D.25573 = cfg->rs;
  val = mono_regstate_alloc_int (D.25573, dest_mask);
  if (val < 0) goto <D.25585>; else goto <D.25586>;
  <D.25585>:
  val = get_register_spilling (cfg, bb, last, ins, dest_mask, sym_reg, 0);
  <D.25586>:
  D.25584 = val;
  return D.25584;
}


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

  D.25588 = bank;
  return D.25588;
}


mono_regstate_alloc_int (struct MonoRegState * rs, regmask_t allow)
{
  long unsigned int D.25590;
  long unsigned int D.25591;
  long unsigned int D.25592;
  long unsigned int D.25595;
  long unsigned int D.25596;
  long unsigned int D.25597;
  int D.25598;
  regmask_t mask;
  int i;

  D.25590 = rs->ifree_mask;
  mask = D.25590 & allow;
  i = 0;
  goto <D.23476>;
  <D.23475>:
  D.25591 = mask >> i;
  D.25592 = D.25591 & 1;
  if (D.25592 != 0) goto <D.25593>; else goto <D.25594>;
  <D.25593>:
  D.25590 = rs->ifree_mask;
  D.25595 = 1 << i;
  D.25596 = ~D.25595;
  D.25597 = D.25590 & D.25596;
  rs->ifree_mask = D.25597;
  D.25598 = i;
  return D.25598;
  <D.25594>:
  i = i + 1;
  <D.23476>:
  if (i <= 31) goto <D.23475>; else goto <D.23477>;
  <D.23477>:
  D.25598 = -1;
  return D.25598;
}


get_register_spilling (struct MonoCompile * cfg, struct MonoBasicBlock * bb, struct MonoInst * * last, struct MonoInst * ins, regmask_t regmask, int reg, int bank)
{
  _Bool D.25600;
  long int D.25601;
  long int D.25602;
  unsigned int D.25605;
  _Bool D.25606;
  long int D.25607;
  long int D.25608;
  int D.25611;
  int D.25612;
  int D.25613;
  int D.25614;
  short unsigned int D.25615;
  int D.25616;
  int D.25617;
  signed char D.25618;
  short unsigned int D.25621;
  sizetype D.25622;
  int D.25623;
  sizetype D.25624;
  sizetype D.25625;
  const char * D.25626;
  char D.25627;
  char D.25628;
  _Bool D.25629;
  int D.25630;
  int D.25633;
  _Bool D.25636;
  long int D.25637;
  long int D.25638;
  int iftmp.53;
  int iftmp.54;
  int D.25652;
  _Bool D.25654;
  long unsigned int D.25658;
  long unsigned int D.25659;
  long unsigned int D.25660;
  _Bool D.25662;
  int iftmp.55;
  unsigned int D.25668;
  long unsigned int D.25670;
  long unsigned int D.25671;
  _Bool D.25673;
  int iftmp.56;
  _Bool D.25681;
  int iftmp.57;
  _Bool D.25690;
  gint32 * D.25694;
  long unsigned int D.25695;
  long unsigned int D.25696;
  gint32 * D.25697;
  int D.25698;
  _Bool iftmp.58;
  int iftmp.59;
  long unsigned int D.25710;
  long unsigned int D.25711;
  long unsigned int D.25713;
  long unsigned int D.25714;
  const char * D.25717;
  const char * D.25718;
  char D.25719;
  char D.25720;
  _Bool D.25721;
  int D.25722;
  _Bool iftmp.60;
  _Bool iftmp.61;
  int iftmp.62;
  int iftmp.63;
  _Bool D.25743;
  long unsigned int D.25747;
  long unsigned int D.25748;
  int iftmp.64;
  unsigned int D.25754;
  long unsigned int D.25756;
  long unsigned int D.25757;
  int iftmp.65;
  long unsigned int D.25767;
  long unsigned int D.25768;
  const char * D.25771;
  _Bool D.25774;
  long int D.25775;
  long int D.25776;
  long unsigned int D.25781;
  long unsigned int D.25782;
  struct MonoRegState * D.25785;
  const char * D.25788;
  int * D.25789;
  long unsigned int D.25790;
  long unsigned int D.25791;
  int * D.25792;
  int D.25793;
  int D.25794;
  int D.25795;
  long unsigned int D.25796;
  long unsigned int D.25797;
  gint32 * D.25798;
  int D.25799;
  const char * D.25805;
  int D.25806;
  struct MonoMemPool * D.25807;
  int D.25808;
  short unsigned int D.25809;
  int D.25810;
  int D.25811;
  const unsigned char * D.25812;
  unsigned int D.25813;
  int D.25814;
  int D.25815;
  int D.25816;
  long int D.25817;
  long int D.25820;
  const char * D.25821;
  long unsigned int D.25824;
  _Bool D.25826;
  long int D.25827;
  long int D.25828;
  int D.25831;
  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.25600 = bank > 3;
      D.25601 = (long int) D.25600;
      D.25602 = __builtin_expect (D.25601, 0);
      if (D.25602 != 0) goto <D.25603>; else goto <D.25604>;
      <D.25603>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 831, "bank < MONO_NUM_REGBANKS");
      <D.25604>:
      D.25605 = cfg->verbose_level;
      D.25606 = D.25605 > 2;
      D.25607 = (long int) D.25606;
      D.25608 = __builtin_expect (D.25607, 0);
      if (D.25608 != 0) goto <D.25609>; else goto <D.25610>;
      <D.25609>:
      D.25611 = ins->dreg;
      D.25612 = ins->sreg1;
      D.25613 = ins->sreg2;
      D.25614 = ins->sreg3;
      printf ("\tstart regmask to assign R%d: 0x%08llu (R%d <- R%d R%d R%d)\n", reg, regmask, D.25611, D.25612, D.25613, D.25614);
      <D.25610>:
      D.25612 = ins->sreg1;
      sregs[0] = D.25612;
      D.25613 = ins->sreg2;
      sregs[1] = D.25613;
      D.25614 = ins->sreg3;
      sregs[2] = D.25614;
      D.25615 = ins->opcode;
      D.25616 = (int) D.25615;
      D.25617 = D.25616 + -313;
      D.25618 = ins_sreg_counts[D.25617];
      num_sregs = (int) D.25618;
      i = 0;
      goto <D.23725>;
      <D.23724>:
      D.25615 = ins->opcode;
      D.25616 = (int) D.25615;
      D.25617 = D.25616 + -313;
      D.25621 = ppc64_cpu_desc_idx[D.25617];
      D.25622 = (sizetype) D.25621;
      D.25623 = i + 1;
      D.25624 = (sizetype) D.25623;
      D.25625 = D.25622 + D.25624;
      D.25626 = &ppc64_cpu_desc + D.25625;
      D.25627 = *D.25626;
      D.25628 = D.25627 + 154;
      D.25629 = D.25628 <= 1;
      D.25630 = (int) D.25629;
      if (D.25630 == bank) goto <D.25631>; else goto <D.25632>;
      <D.25631>:
      D.25633 = sregs[i];
      if (D.25633 != reg) goto <D.25634>; else goto <D.25635>;
      <D.25634>:
      D.25636 = bank != 0;
      D.25637 = (long int) D.25636;
      D.25638 = __builtin_expect (D.25637, 0);
      if (D.25638 != 0) goto <D.25639>; else goto <D.25640>;
      <D.25639>:
      D.25636 = bank != 0;
      D.25637 = (long int) D.25636;
      D.25638 = __builtin_expect (D.25637, 0);
      if (D.25638 != 0) goto <D.25641>; else goto <D.25642>;
      <D.25641>:
      D.25636 = bank != 0;
      D.25637 = (long int) D.25636;
      D.25638 = __builtin_expect (D.25637, 0);
      if (D.25638 != 0) goto <D.25646>; else goto <D.25647>;
      <D.25646>:
      D.25633 = sregs[i];
      if (D.25633 >= 0) goto <D.25651>; else goto <D.25649>;
      <D.25651>:
      D.25633 = sregs[i];
      D.25652 = regbank_size[bank];
      if (D.25633 < D.25652) goto <D.25653>; else goto <D.25649>;
      <D.25653>:
      iftmp.54 = 1;
      goto <D.25650>;
      <D.25649>:
      iftmp.54 = 0;
      <D.25650>:
      D.25654 = (_Bool) iftmp.54;
      if (D.25654 != 0) goto <D.25655>; else goto <D.25644>;
      <D.25655>:
      goto <D.25656>;
      <D.25647>:
      D.25633 = sregs[i];
      if (D.25633 <= 31) goto <D.25657>; else goto <D.25644>;
      <D.25657>:
      <D.25656>:
      D.25658 = regbank_callee_regs[bank];
      D.25633 = sregs[i];
      D.25659 = D.25658 >> D.25633;
      D.25660 = D.25659 & 1;
      if (D.25660 != 0) goto <D.25661>; else goto <D.25644>;
      <D.25661>:
      iftmp.53 = 1;
      goto <D.25645>;
      <D.25644>:
      iftmp.53 = 0;
      <D.25645>:
      D.25662 = (_Bool) iftmp.53;
      if (D.25662 != 0) goto <D.25619>; else goto <D.25663>;
      <D.25663>:
      goto <D.25664>;
      <D.25642>:
      D.25633 = sregs[i];
      D.25668 = (unsigned int) D.25633;
      if (D.25668 <= 31) goto <D.25669>; else goto <D.25666>;
      <D.25669>:
      D.25633 = sregs[i];
      D.25670 = 8184 >> D.25633;
      D.25671 = D.25670 & 1;
      if (D.25671 != 0) goto <D.25672>; else goto <D.25666>;
      <D.25672>:
      iftmp.55 = 1;
      goto <D.25667>;
      <D.25666>:
      iftmp.55 = 0;
      <D.25667>:
      D.25673 = (_Bool) iftmp.55;
      if (D.25673 != 0) goto <D.25619>; else goto <D.25674>;
      <D.25674>:
      <D.25664>:
      goto <D.25675>;
      <D.25640>:
      D.25633 = sregs[i];
      D.25668 = (unsigned int) D.25633;
      if (D.25668 <= 31) goto <D.25679>; else goto <D.25677>;
      <D.25679>:
      D.25633 = sregs[i];
      D.25670 = 8184 >> D.25633;
      D.25671 = D.25670 & 1;
      if (D.25671 != 0) goto <D.25680>; else goto <D.25677>;
      <D.25680>:
      iftmp.56 = 1;
      goto <D.25678>;
      <D.25677>:
      iftmp.56 = 0;
      <D.25678>:
      D.25681 = (_Bool) iftmp.56;
      if (D.25681 != 0) goto <D.25619>; else goto <D.25682>;
      <D.25682>:
      <D.25675>:
      D.25636 = bank != 0;
      D.25637 = (long int) D.25636;
      D.25638 = __builtin_expect (D.25637, 0);
      if (D.25638 != 0) goto <D.25683>; else goto <D.25684>;
      <D.25683>:
      D.25633 = sregs[i];
      if (D.25633 < 0) goto <D.25686>; else goto <D.25689>;
      <D.25689>:
      D.25633 = sregs[i];
      D.25652 = regbank_size[bank];
      if (D.25633 >= D.25652) goto <D.25686>; else goto <D.25687>;
      <D.25686>:
      iftmp.57 = 1;
      goto <D.25688>;
      <D.25687>:
      iftmp.57 = 0;
      <D.25688>:
      D.25690 = (_Bool) iftmp.57;
      if (D.25690 != 0) goto <D.25691>; else goto <D.25620>;
      <D.25691>:
      goto <D.25692>;
      <D.25684>:
      D.25633 = sregs[i];
      if (D.25633 > 31) goto <D.25693>; else goto <D.25620>;
      <D.25693>:
      <D.25692>:
      D.25694 = rs->vassign;
      D.25633 = sregs[i];
      D.25695 = (long unsigned int) D.25633;
      D.25696 = D.25695 * 4;
      D.25697 = D.25694 + D.25696;
      D.25698 = *D.25697;
      if (D.25698 >= 0) goto <D.25619>; else goto <D.25620>;
      <D.25619>:
      D.25636 = bank != 0;
      D.25637 = (long int) D.25636;
      D.25638 = __builtin_expect (D.25637, 0);
      if (D.25638 != 0) goto <D.25700>; else goto <D.25701>;
      <D.25700>:
      D.25633 = sregs[i];
      if (D.25633 < 0) goto <D.25703>; else goto <D.25706>;
      <D.25706>:
      D.25633 = sregs[i];
      D.25652 = regbank_size[bank];
      if (D.25633 >= D.25652) goto <D.25703>; else goto <D.25704>;
      <D.25703>:
      iftmp.59 = 1;
      goto <D.25705>;
      <D.25704>:
      iftmp.59 = 0;
      <D.25705>:
      iftmp.58 = (_Bool) iftmp.59;
      goto <D.25707>;
      <D.25701>:
      D.25633 = sregs[i];
      iftmp.58 = D.25633 > 31;
      <D.25707>:
      if (iftmp.58 != 0) goto <D.25708>; else goto <D.25709>;
      <D.25708>:
      D.25694 = rs->vassign;
      D.25633 = sregs[i];
      D.25695 = (long unsigned int) D.25633;
      D.25696 = D.25695 * 4;
      D.25697 = D.25694 + D.25696;
      D.25698 = *D.25697;
      D.25710 = 1 << D.25698;
      D.25711 = ~D.25710;
      regmask = D.25711 & regmask;
      goto <D.25712>;
      <D.25709>:
      D.25633 = sregs[i];
      D.25713 = 1 << D.25633;
      D.25714 = ~D.25713;
      regmask = D.25714 & regmask;
      <D.25712>:
      D.25605 = cfg->verbose_level;
      D.25606 = D.25605 > 2;
      D.25607 = (long int) D.25606;
      D.25608 = __builtin_expect (D.25607, 0);
      if (D.25608 != 0) goto <D.25715>; else goto <D.25716>;
      <D.25715>:
      D.25623 = i + 1;
      D.25633 = sregs[i];
      D.25717 = mono_regname_full (D.25633, bank);
      D.25633 = sregs[i];
      printf ("\t\texcluding sreg%d %s %d\n", D.25623, D.25717, D.25633);
      <D.25716>:
      <D.25620>:
      <D.25635>:
      <D.25632>:
      i = i + 1;
      <D.23725>:
      if (i < num_sregs) goto <D.23724>; else goto <D.23726>;
      <D.23726>:
      D.25615 = ins->opcode;
      D.25616 = (int) D.25615;
      D.25617 = D.25616 + -313;
      D.25621 = ppc64_cpu_desc_idx[D.25617];
      D.25622 = (sizetype) D.25621;
      D.25718 = &ppc64_cpu_desc + D.25622;
      D.25719 = *D.25718;
      D.25720 = D.25719 + 154;
      D.25721 = D.25720 <= 1;
      D.25722 = (int) D.25721;
      if (D.25722 == bank) goto <D.25723>; else goto <D.25724>;
      <D.25723>:
      D.25611 = ins->dreg;
      if (D.25611 != reg) goto <D.25725>; else goto <D.25726>;
      <D.25725>:
      D.25636 = bank != 0;
      D.25637 = (long int) D.25636;
      D.25638 = __builtin_expect (D.25637, 0);
      if (D.25638 != 0) goto <D.25728>; else goto <D.25729>;
      <D.25728>:
      D.25636 = bank != 0;
      D.25637 = (long int) D.25636;
      D.25638 = __builtin_expect (D.25637, 0);
      if (D.25638 != 0) goto <D.25731>; else goto <D.25732>;
      <D.25731>:
      D.25636 = bank != 0;
      D.25637 = (long int) D.25636;
      D.25638 = __builtin_expect (D.25637, 0);
      if (D.25638 != 0) goto <D.25736>; else goto <D.25737>;
      <D.25736>:
      D.25611 = ins->dreg;
      if (D.25611 >= 0) goto <D.25741>; else goto <D.25739>;
      <D.25741>:
      D.25611 = ins->dreg;
      D.25652 = regbank_size[bank];
      if (D.25611 < D.25652) goto <D.25742>; else goto <D.25739>;
      <D.25742>:
      iftmp.63 = 1;
      goto <D.25740>;
      <D.25739>:
      iftmp.63 = 0;
      <D.25740>:
      D.25743 = (_Bool) iftmp.63;
      if (D.25743 != 0) goto <D.25744>; else goto <D.25734>;
      <D.25744>:
      goto <D.25745>;
      <D.25737>:
      D.25611 = ins->dreg;
      if (D.25611 <= 31) goto <D.25746>; else goto <D.25734>;
      <D.25746>:
      <D.25745>:
      D.25658 = regbank_callee_regs[bank];
      D.25611 = ins->dreg;
      D.25747 = D.25658 >> D.25611;
      D.25748 = D.25747 & 1;
      if (D.25748 != 0) goto <D.25749>; else goto <D.25734>;
      <D.25749>:
      iftmp.62 = 1;
      goto <D.25735>;
      <D.25734>:
      iftmp.62 = 0;
      <D.25735>:
      iftmp.61 = (_Bool) iftmp.62;
      goto <D.25750>;
      <D.25732>:
      D.25611 = ins->dreg;
      D.25754 = (unsigned int) D.25611;
      if (D.25754 <= 31) goto <D.25755>; else goto <D.25752>;
      <D.25755>:
      D.25611 = ins->dreg;
      D.25756 = 8184 >> D.25611;
      D.25757 = D.25756 & 1;
      if (D.25757 != 0) goto <D.25758>; else goto <D.25752>;
      <D.25758>:
      iftmp.64 = 1;
      goto <D.25753>;
      <D.25752>:
      iftmp.64 = 0;
      <D.25753>:
      iftmp.61 = (_Bool) iftmp.64;
      <D.25750>:
      iftmp.60 = iftmp.61;
      goto <D.25759>;
      <D.25729>:
      D.25611 = ins->dreg;
      D.25754 = (unsigned int) D.25611;
      if (D.25754 <= 31) goto <D.25763>; else goto <D.25761>;
      <D.25763>:
      D.25611 = ins->dreg;
      D.25756 = 8184 >> D.25611;
      D.25757 = D.25756 & 1;
      if (D.25757 != 0) goto <D.25764>; else goto <D.25761>;
      <D.25764>:
      iftmp.65 = 1;
      goto <D.25762>;
      <D.25761>:
      iftmp.65 = 0;
      <D.25762>:
      iftmp.60 = (_Bool) iftmp.65;
      <D.25759>:
      if (iftmp.60 != 0) goto <D.25765>; else goto <D.25766>;
      <D.25765>:
      D.25611 = ins->dreg;
      D.25767 = 1 << D.25611;
      D.25768 = ~D.25767;
      regmask = D.25768 & regmask;
      D.25605 = cfg->verbose_level;
      D.25606 = D.25605 > 2;
      D.25607 = (long int) D.25606;
      D.25608 = __builtin_expect (D.25607, 0);
      if (D.25608 != 0) goto <D.25769>; else goto <D.25770>;
      <D.25769>:
      D.25611 = ins->dreg;
      D.25771 = mono_regname_full (D.25611, bank);
      printf ("\t\texcluding dreg %s\n", D.25771);
      <D.25770>:
      <D.25766>:
      <D.25726>:
      <D.25724>:
      D.25605 = cfg->verbose_level;
      D.25606 = D.25605 > 2;
      D.25607 = (long int) D.25606;
      D.25608 = __builtin_expect (D.25607, 0);
      if (D.25608 != 0) goto <D.25772>; else goto <D.25773>;
      <D.25772>:
      printf ("\t\tavailable regmask: 0x%08llu\n", regmask);
      <D.25773>:
      D.25774 = regmask == 0;
      D.25775 = (long int) D.25774;
      D.25776 = __builtin_expect (D.25775, 0);
      if (D.25776 != 0) goto <D.25777>; else goto <D.25778>;
      <D.25777>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 851, "regmask");
      <D.25778>:
      sel = 0;
      D.25636 = bank != 0;
      D.25637 = (long int) D.25636;
      D.25638 = __builtin_expect (D.25637, 0);
      if (D.25638 != 0) goto <D.25779>; else goto <D.25780>;
      <D.25779>:
      i = 0;
      goto <D.23729>;
      <D.23728>:
      D.25781 = regmask >> i;
      D.25782 = D.25781 & 1;
      if (D.25782 != 0) goto <D.25783>; else goto <D.25784>;
      <D.25783>:
      sel = i;
      D.25785 = cfg->rs;
      bank = translate_bank (D.25785, bank, sel);
      D.25605 = cfg->verbose_level;
      D.25606 = D.25605 > 2;
      D.25607 = (long int) D.25606;
      D.25608 = __builtin_expect (D.25607, 0);
      if (D.25608 != 0) goto <D.25786>; else goto <D.25787>;
      <D.25786>:
      D.25788 = mono_regname_full (sel, bank);
      D.25789 = rs->symbolic[bank];
      D.25790 = (long unsigned int) sel;
      D.25791 = D.25790 * 4;
      D.25792 = D.25789 + D.25791;
      D.25793 = *D.25792;
      printf ("\t\tselected register %s has assignment %d\n", D.25788, D.25793);
      <D.25787>:
      goto <D.23727>;
      <D.25784>:
      i = i + 1;
      <D.23729>:
      D.25652 = regbank_size[bank];
      if (D.25652 > i) goto <D.23728>; else goto <D.23727>;
      <D.23727>:
      D.25789 = rs->symbolic[bank];
      D.25790 = (long unsigned int) sel;
      D.25791 = D.25790 * 4;
      D.25792 = D.25789 + D.25791;
      i = *D.25792;
      D.25794 = cfg->spill_count;
      D.25795 = D.25794 + 1;
      cfg->spill_count = D.25795;
      spill = cfg->spill_count;
      D.25694 = rs->vassign;
      D.25796 = (long unsigned int) i;
      D.25797 = D.25796 * 4;
      D.25798 = D.25694 + D.25797;
      D.25799 = ~spill;
      *D.25798 = D.25799;
      mono_regstate_free_general (rs, sel, bank);
      goto <D.25800>;
      <D.25780>:
      i = 0;
      goto <D.23732>;
      <D.23731>:
      D.25781 = regmask >> i;
      D.25782 = D.25781 & 1;
      if (D.25782 != 0) goto <D.25801>; else goto <D.25802>;
      <D.25801>:
      sel = i;
      D.25605 = cfg->verbose_level;
      D.25606 = D.25605 > 2;
      D.25607 = (long int) D.25606;
      D.25608 = __builtin_expect (D.25607, 0);
      if (D.25608 != 0) goto <D.25803>; else goto <D.25804>;
      <D.25803>:
      D.25805 = mono_arch_regname (sel);
      D.25806 = rs->isymbolic[sel];
      printf ("\t\tselected register %s has assignment %d\n", D.25805, D.25806);
      <D.25804>:
      goto <D.23730>;
      <D.25802>:
      i = i + 1;
      <D.23732>:
      if (i <= 31) goto <D.23731>; else goto <D.23730>;
      <D.23730>:
      i = rs->isymbolic[sel];
      D.25794 = cfg->spill_count;
      D.25795 = D.25794 + 1;
      cfg->spill_count = D.25795;
      spill = cfg->spill_count;
      D.25694 = rs->vassign;
      D.25796 = (long unsigned int) i;
      D.25797 = D.25796 * 4;
      D.25798 = D.25694 + D.25797;
      D.25799 = ~spill;
      *D.25798 = D.25799;
      mono_regstate_free_int (rs, sel);
      <D.25800>:
      D.25807 = cfg->mempool;
      load = mono_mempool_alloc0 (D.25807, 80);
      D.25808 = regbank_load_ops[bank];
      D.25809 = (short unsigned int) D.25808;
      load->opcode = D.25809;
      load->dreg = -1;
      load->sreg3 = -1;
      D.25810 = load->sreg3;
      load->sreg2 = D.25810;
      D.25811 = load->sreg2;
      load->sreg1 = D.25811;
      D.25812 = cfg->ip;
      load->cil_code = D.25812;
      load->dreg = sel;
      D.25813 = cfg->frame_reg;
      D.25814 = (int) D.25813;
      load->sreg1 = D.25814;
      D.25815 = get_vreg_bank (cfg, i, bank);
      D.25816 = mono_spillvar_offset (cfg, spill, D.25815);
      D.25817 = (long int) D.25816;
      load->data.op[0].const_val = D.25817;
      insert_after_ins (bb, ins, last, load);
      D.25605 = cfg->verbose_level;
      D.25606 = D.25605 > 2;
      D.25607 = (long int) D.25606;
      D.25608 = __builtin_expect (D.25607, 0);
      if (D.25608 != 0) goto <D.25818>; else goto <D.25819>;
      <D.25818>:
      D.25820 = load->data.op[0].const_val;
      D.25821 = mono_regname_full (sel, bank);
      printf ("\tSPILLED LOAD (%d at 0x%08lx(%%ebp)) R%d (freed %s)\n", spill, D.25820, i, D.25821);
      <D.25819>:
      D.25636 = bank != 0;
      D.25637 = (long int) D.25636;
      D.25638 = __builtin_expect (D.25637, 0);
      if (D.25638 != 0) goto <D.25822>; else goto <D.25823>;
      <D.25822>:
      D.25824 = 1 << sel;
      i = mono_regstate_alloc_general (rs, D.25824, bank);
      goto <D.25825>;
      <D.25823>:
      D.25824 = 1 << sel;
      i = mono_regstate_alloc_int (rs, D.25824);
      <D.25825>:
      D.25826 = i != sel;
      D.25827 = (long int) D.25826;
      D.25828 = __builtin_expect (D.25827, 0);
      if (D.25828 != 0) goto <D.25829>; else goto <D.25830>;
      <D.25829>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 898, "i == sel");
      <D.25830>:
      D.25831 = sel;
      return D.25831;
    }
  finally
    {
      sregs = {CLOBBER};
    }
}


get_vreg_bank (struct MonoCompile * cfg, int reg, int bank)
{
  unsigned int reg.66;
  unsigned int D.25836;
  gboolean * D.25838;
  long unsigned int D.25839;
  long unsigned int D.25840;
  gboolean * D.25841;
  int D.25842;
  int D.25844;
  unsigned int D.25846;
  gboolean * D.25848;
  gboolean * D.25849;
  int D.25850;

  reg.66 = (unsigned int) reg;
  D.25836 = cfg->vreg_is_ref_len;
  if (reg.66 < D.25836) goto <D.25837>; else goto <D.25834>;
  <D.25837>:
  D.25838 = cfg->vreg_is_ref;
  D.25839 = (long unsigned int) reg;
  D.25840 = D.25839 * 4;
  D.25841 = D.25838 + D.25840;
  D.25842 = *D.25841;
  if (D.25842 != 0) goto <D.25843>; else goto <D.25834>;
  <D.25843>:
  D.25844 = 2;
  return D.25844;
  <D.25834>:
  reg.66 = (unsigned int) reg;
  D.25846 = cfg->vreg_is_mp_len;
  if (reg.66 < D.25846) goto <D.25847>; else goto <D.25845>;
  <D.25847>:
  D.25848 = cfg->vreg_is_mp;
  D.25839 = (long unsigned int) reg;
  D.25840 = D.25839 * 4;
  D.25849 = D.25848 + D.25840;
  D.25850 = *D.25849;
  if (D.25850 != 0) goto <D.25851>; else goto <D.25845>;
  <D.25851>:
  D.25844 = 3;
  return D.25844;
  <D.25845>:
  D.25844 = bank;
  return D.25844;
}


mono_spillvar_offset (struct MonoCompile * cfg, int spillvar, int bank)
{
  int D.25853;
  _Bool D.25854;
  long int D.25855;
  long int D.25856;
  struct MonoSpillInfo * D.25859;
  long unsigned int D.25860;
  long unsigned int D.25861;
  int D.25862;
  int D.25865;
  unsigned int D.25866;
  unsigned int D.25867;
  int D.25868;
  int D.25869;
  _Bool D.25870;
  long int D.25871;
  long int D.25872;
  _Bool D.25875;
  long int D.25876;
  long int D.25877;
  unsigned int D.25881;
  unsigned int D.25882;
  int D.25885;
  int D.25886;
  int D.25887;
  int D.25888;
  int D.25889;
  int D.25891;
  int D.25892;
  struct MonoSpillInfo * info;
  int size;

  D.25853 = cfg->spill_info_len[bank];
  D.25854 = D.25853 <= spillvar;
  D.25855 = (long int) D.25854;
  D.25856 = __builtin_expect (D.25855, 0);
  if (D.25856 != 0) goto <D.25857>; else goto <D.25858>;
  <D.25857>:
  goto <D.23536>;
  <D.23535>:
  resize_spill_info (cfg, bank);
  <D.23536>:
  D.25853 = cfg->spill_info_len[bank];
  if (D.25853 <= spillvar) goto <D.23535>; else goto <D.23537>;
  <D.23537>:
  <D.25858>:
  D.25859 = cfg->spill_info[bank];
  D.25860 = (long unsigned int) spillvar;
  D.25861 = D.25860 * 4;
  info = D.25859 + D.25861;
  D.25862 = info->offset;
  if (D.25862 == -1) goto <D.25863>; else goto <D.25864>;
  <D.25863>:
  D.25865 = cfg->stack_offset;
  D.25866 = (unsigned int) D.25865;
  D.25867 = D.25866 + 7;
  D.25868 = (int) D.25867;
  cfg->stack_offset = D.25868;
  D.25865 = cfg->stack_offset;
  D.25869 = D.25865 & -8;
  cfg->stack_offset = D.25869;
  D.25870 = bank > 3;
  D.25871 = (long int) D.25870;
  D.25872 = __builtin_expect (D.25871, 0);
  if (D.25872 != 0) goto <D.25873>; else goto <D.25874>;
  <D.25873>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 329, "bank < MONO_NUM_REGBANKS");
  <D.25874>:
  D.25875 = bank != 0;
  D.25876 = (long int) D.25875;
  D.25877 = __builtin_expect (D.25876, 0);
  if (D.25877 != 0) goto <D.25878>; else goto <D.25879>;
  <D.25878>:
  size = regbank_spill_var_size[bank];
  goto <D.25880>;
  <D.25879>:
  size = 8;
  <D.25880>:
  D.25881 = cfg->flags;
  D.25882 = D.25881 & 64;
  if (D.25882 != 0) goto <D.25883>; else goto <D.25884>;
  <D.25883>:
  D.25865 = cfg->stack_offset;
  D.25885 = size + -1;
  D.25886 = D.25865 + D.25885;
  cfg->stack_offset = D.25886;
  D.25865 = cfg->stack_offset;
  D.25887 = -size;
  D.25888 = D.25865 & D.25887;
  cfg->stack_offset = D.25888;
  D.25865 = cfg->stack_offset;
  info->offset = D.25865;
  D.25865 = cfg->stack_offset;
  D.25889 = D.25865 + size;
  cfg->stack_offset = D.25889;
  goto <D.25890>;
  <D.25884>:
  D.25865 = cfg->stack_offset;
  D.25885 = size + -1;
  D.25886 = D.25865 + D.25885;
  cfg->stack_offset = D.25886;
  D.25865 = cfg->stack_offset;
  D.25887 = -size;
  D.25888 = D.25865 & D.25887;
  cfg->stack_offset = D.25888;
  D.25865 = cfg->stack_offset;
  D.25889 = D.25865 + size;
  cfg->stack_offset = D.25889;
  D.25865 = cfg->stack_offset;
  D.25891 = -D.25865;
  info->offset = D.25891;
  <D.25890>:
  <D.25864>:
  D.25892 = info->offset;
  return D.25892;
}


resize_spill_info (struct MonoCompile * cfg, int bank)
{
  int iftmp.67;
  _Bool D.25898;
  long int D.25899;
  long int D.25900;
  struct MonoMemPool * D.25903;
  long unsigned int D.25904;
  unsigned int D.25905;
  unsigned int D.25906;
  long unsigned int D.25909;
  long unsigned int D.25910;
  long unsigned int D.25911;
  long unsigned int D.25912;
  struct MonoSpillInfo * D.25913;
  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.25895>; else goto <D.25896>;
  <D.25895>:
  iftmp.67 = orig_len * 2;
  goto <D.25897>;
  <D.25896>:
  iftmp.67 = 16;
  <D.25897>:
  new_len = iftmp.67;
  D.25898 = bank > 3;
  D.25899 = (long int) D.25898;
  D.25900 = __builtin_expect (D.25899, 0);
  if (D.25900 != 0) goto <D.25901>; else goto <D.25902>;
  <D.25901>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 294, "bank < MONO_NUM_REGBANKS");
  <D.25902>:
  D.25903 = cfg->mempool;
  D.25904 = (long unsigned int) new_len;
  D.25905 = (unsigned int) D.25904;
  D.25906 = D.25905 * 4;
  new_info = mono_mempool_alloc0 (D.25903, D.25906);
  if (orig_info != 0B) goto <D.25907>; else goto <D.25908>;
  <D.25907>:
  D.25909 = (long unsigned int) orig_len;
  D.25910 = D.25909 * 4;
  memcpy (new_info, orig_info, D.25910);
  <D.25908>:
  i = orig_len;
  goto <D.23526>;
  <D.23525>:
  D.25911 = (long unsigned int) i;
  D.25912 = D.25911 * 4;
  D.25913 = new_info + D.25912;
  D.25913->offset = -1;
  i = i + 1;
  <D.23526>:
  if (i < new_len) goto <D.23525>; else goto <D.23527>;
  <D.23527>:
  cfg->spill_info[bank] = new_info;
  cfg->spill_info_len[bank] = new_len;
}


memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.25914;
  long unsigned int D.25915;

  D.25915 = __builtin_object_size (__dest, 0);
  D.25914 = __builtin___memcpy_chk (__dest, __src, __len, D.25915);
  return D.25914;
}


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

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


mono_regstate_alloc_general (struct MonoRegState * rs, regmask_t allow, int bank)
{
  long unsigned int D.25918;
  long unsigned int D.25919;
  long unsigned int D.25920;
  long unsigned int D.25923;
  long unsigned int D.25924;
  long unsigned int D.25925;
  int D.25928;
  int D.25929;
  int i;
  int mirrored_bank;
  regmask_t mask;

  D.25918 = rs->free_mask[bank];
  mask = D.25918 & allow;
  i = 0;
  goto <D.23491>;
  <D.23490>:
  D.25919 = mask >> i;
  D.25920 = D.25919 & 1;
  if (D.25920 != 0) goto <D.25921>; else goto <D.25922>;
  <D.25921>:
  D.25918 = rs->free_mask[bank];
  D.25923 = 1 << i;
  D.25924 = ~D.25923;
  D.25925 = D.25918 & D.25924;
  rs->free_mask[bank] = D.25925;
  mirrored_bank = -1;
  if (mirrored_bank == -1) goto <D.25926>; else goto <D.25927>;
  <D.25926>:
  D.25928 = i;
  return D.25928;
  <D.25927>:
  D.25918 = rs->free_mask[bank];
  rs->free_mask[mirrored_bank] = D.25918;
  D.25928 = i;
  return D.25928;
  <D.25922>:
  i = i + 1;
  <D.23491>:
  D.25929 = regbank_size[bank];
  if (D.25929 > i) goto <D.23490>; else goto <D.23492>;
  <D.23492>:
  D.25928 = -1;
  return D.25928;
}


free_up_hreg (struct MonoCompile * cfg, struct MonoBasicBlock * bb, struct MonoInst * * last, struct MonoInst * ins, int hreg, int bank)
{
  _Bool D.25931;
  long int D.25932;
  long int D.25933;
  struct MonoRegState * D.25936;
  long unsigned int D.25937;
  long unsigned int D.25938;
  long unsigned int D.25939;
  unsigned int D.25942;
  _Bool D.25943;
  long int D.25944;
  long int D.25945;
  int * D.25948;
  long unsigned int D.25949;
  long unsigned int D.25950;
  int * D.25951;
  int D.25952;
  long unsigned int D.25954;
  long unsigned int D.25955;
  long unsigned int D.25956;
  int D.25961;

  D.25931 = bank != 0;
  D.25932 = (long int) D.25931;
  D.25933 = __builtin_expect (D.25932, 0);
  if (D.25933 != 0) goto <D.25934>; else goto <D.25935>;
  <D.25934>:
  D.25936 = cfg->rs;
  D.25937 = D.25936->free_mask[bank];
  D.25938 = D.25937 >> hreg;
  D.25939 = D.25938 & 1;
  if (D.25939 == 0) goto <D.25940>; else goto <D.25941>;
  <D.25940>:
  D.25936 = cfg->rs;
  bank = translate_bank (D.25936, bank, hreg);
  D.25942 = cfg->verbose_level;
  D.25943 = D.25942 > 2;
  D.25944 = (long int) D.25943;
  D.25945 = __builtin_expect (D.25944, 0);
  if (D.25945 != 0) goto <D.25946>; else goto <D.25947>;
  <D.25946>:
  D.25936 = cfg->rs;
  D.25948 = D.25936->symbolic[bank];
  D.25949 = (long unsigned int) hreg;
  D.25950 = D.25949 * 4;
  D.25951 = D.25948 + D.25950;
  D.25952 = *D.25951;
  printf ("\tforced spill of R%d\n", D.25952);
  <D.25947>:
  D.25936 = cfg->rs;
  D.25948 = D.25936->symbolic[bank];
  D.25949 = (long unsigned int) hreg;
  D.25950 = D.25949 * 4;
  D.25951 = D.25948 + D.25950;
  D.25952 = *D.25951;
  spill_vreg (cfg, bb, last, ins, D.25952, bank);
  <D.25941>:
  goto <D.25953>;
  <D.25935>:
  D.25936 = cfg->rs;
  D.25954 = D.25936->ifree_mask;
  D.25955 = D.25954 >> hreg;
  D.25956 = D.25955 & 1;
  if (D.25956 == 0) goto <D.25957>; else goto <D.25958>;
  <D.25957>:
  D.25942 = cfg->verbose_level;
  D.25943 = D.25942 > 2;
  D.25944 = (long int) D.25943;
  D.25945 = __builtin_expect (D.25944, 0);
  if (D.25945 != 0) goto <D.25959>; else goto <D.25960>;
  <D.25959>:
  D.25936 = cfg->rs;
  D.25961 = D.25936->isymbolic[hreg];
  printf ("\tforced spill of R%d\n", D.25961);
  <D.25960>:
  D.25936 = cfg->rs;
  D.25961 = D.25936->isymbolic[hreg];
  spill_vreg (cfg, bb, last, ins, D.25961, bank);
  <D.25958>:
  <D.25953>:
}


mono_regstate_free_general (struct MonoRegState * rs, int reg, int bank)
{
  long unsigned int D.25964;
  long unsigned int D.25965;
  long unsigned int D.25966;
  int * D.25967;
  long unsigned int D.25968;
  long unsigned int D.25969;
  int * D.25970;
  int * D.25973;
  int * D.25974;
  int mirrored_bank;

  if (reg >= 0) goto <D.25962>; else goto <D.25963>;
  <D.25962>:
  D.25964 = rs->free_mask[bank];
  D.25965 = 1 << reg;
  D.25966 = D.25964 | D.25965;
  rs->free_mask[bank] = D.25966;
  D.25967 = rs->symbolic[bank];
  D.25968 = (long unsigned int) reg;
  D.25969 = D.25968 * 4;
  D.25970 = D.25967 + D.25969;
  *D.25970 = 0;
  mirrored_bank = -1;
  if (mirrored_bank == -1) goto <D.25971>; else goto <D.25972>;
  <D.25971>:
  return;
  <D.25972>:
  D.25964 = rs->free_mask[bank];
  rs->free_mask[mirrored_bank] = D.25964;
  D.25973 = rs->symbolic[mirrored_bank];
  D.25968 = (long unsigned int) reg;
  D.25969 = D.25968 * 4;
  D.25974 = D.25973 + D.25969;
  *D.25974 = 0;
  <D.25963>:
}


mono_regstate_free_int (struct MonoRegState * rs, int reg)
{
  long unsigned int D.25978;
  long unsigned int D.25979;
  long unsigned int D.25980;

  if (reg >= 0) goto <D.25976>; else goto <D.25977>;
  <D.25976>:
  D.25978 = rs->ifree_mask;
  D.25979 = 1 << reg;
  D.25980 = D.25978 | D.25979;
  rs->ifree_mask = D.25980;
  rs->isymbolic[reg] = 0;
  <D.25977>:
}


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.25981;
  int D.25982;
  short unsigned int D.25983;
  int D.25984;
  int D.25985;
  const unsigned char * D.25986;
  unsigned int D.25989;
  _Bool D.25990;
  long int D.25991;
  long int D.25992;
  const char * D.25995;
  const char * D.25996;
  struct MonoInst * D.25997;
  struct MonoInst * copy;

  D.25981 = cfg->mempool;
  copy = mono_mempool_alloc0 (D.25981, 80);
  D.25982 = regbank_move_ops[bank];
  D.25983 = (short unsigned int) D.25982;
  copy->opcode = D.25983;
  copy->dreg = -1;
  copy->sreg3 = -1;
  D.25984 = copy->sreg3;
  copy->sreg2 = D.25984;
  D.25985 = copy->sreg2;
  copy->sreg1 = D.25985;
  D.25986 = cfg->ip;
  copy->cil_code = D.25986;
  copy->dreg = dest;
  copy->sreg1 = src;
  copy->cil_code = ip;
  if (ins != 0B) goto <D.25987>; else goto <D.25988>;
  <D.25987>:
  mono_bblock_insert_after_ins (bb, ins, copy);
  *last = copy;
  <D.25988>:
  D.25989 = cfg->verbose_level;
  D.25990 = D.25989 > 2;
  D.25991 = (long int) D.25990;
  D.25992 = __builtin_expect (D.25991, 0);
  if (D.25992 != 0) goto <D.25993>; else goto <D.25994>;
  <D.25993>:
  D.25995 = mono_regname_full (src, bank);
  D.25996 = mono_regname_full (dest, bank);
  printf ("\tforced copy from %s to %s\n", D.25995, D.25996);
  <D.25994>:
  D.25997 = copy;
  return D.25997;
}


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.25999;
  long unsigned int D.26000;
  long unsigned int D.26001;
  gint32 * D.26002;
  struct MonoRegState * D.26003;
  int D.26004;
  int D.26005;
  long unsigned int D.26006;
  long unsigned int D.26007;
  gint32 * D.26008;
  int D.26009;
  _Bool D.26010;
  long int D.26011;
  long int D.26012;
  struct MonoMemPool * D.26016;
  int D.26017;
  short unsigned int D.26018;
  int D.26019;
  int D.26020;
  const unsigned char * D.26021;
  unsigned int D.26022;
  int D.26023;
  int D.26024;
  int D.26025;
  long int D.26026;
  unsigned int D.26027;
  _Bool D.26028;
  long int D.26029;
  long int D.26030;
  long int D.26033;
  const char * D.26034;
  long unsigned int D.26037;
  _Bool D.26039;
  long int D.26040;
  long int D.26041;
  struct MonoInst * load;
  int i;
  int sel;
  int spill;
  int * symbolic;
  struct MonoRegState * rs;

  rs = cfg->rs;
  symbolic = rs->symbolic[bank];
  D.25999 = rs->vassign;
  D.26000 = (long unsigned int) reg;
  D.26001 = D.26000 * 4;
  D.26002 = D.25999 + D.26001;
  sel = *D.26002;
  D.26003 = cfg->rs;
  bank = translate_bank (D.26003, bank, sel);
  i = reg;
  D.26004 = cfg->spill_count;
  D.26005 = D.26004 + 1;
  cfg->spill_count = D.26005;
  spill = cfg->spill_count;
  D.25999 = rs->vassign;
  D.26006 = (long unsigned int) i;
  D.26007 = D.26006 * 4;
  D.26008 = D.25999 + D.26007;
  D.26009 = ~spill;
  *D.26008 = D.26009;
  D.26010 = bank != 0;
  D.26011 = (long int) D.26010;
  D.26012 = __builtin_expect (D.26011, 0);
  if (D.26012 != 0) goto <D.26013>; else goto <D.26014>;
  <D.26013>:
  mono_regstate_free_general (rs, sel, bank);
  goto <D.26015>;
  <D.26014>:
  mono_regstate_free_int (rs, sel);
  <D.26015>:
  D.26016 = cfg->mempool;
  load = mono_mempool_alloc0 (D.26016, 80);
  D.26017 = regbank_load_ops[bank];
  D.26018 = (short unsigned int) D.26017;
  load->opcode = D.26018;
  load->dreg = -1;
  load->sreg3 = -1;
  D.26019 = load->sreg3;
  load->sreg2 = D.26019;
  D.26020 = load->sreg2;
  load->sreg1 = D.26020;
  D.26021 = cfg->ip;
  load->cil_code = D.26021;
  load->dreg = sel;
  D.26022 = cfg->frame_reg;
  D.26023 = (int) D.26022;
  load->sreg1 = D.26023;
  D.26024 = get_vreg_bank (cfg, reg, bank);
  D.26025 = mono_spillvar_offset (cfg, spill, D.26024);
  D.26026 = (long int) D.26025;
  load->data.op[0].const_val = D.26026;
  insert_after_ins (bb, ins, last, load);
  D.26027 = cfg->verbose_level;
  D.26028 = D.26027 > 2;
  D.26029 = (long int) D.26028;
  D.26030 = __builtin_expect (D.26029, 0);
  if (D.26030 != 0) goto <D.26031>; else goto <D.26032>;
  <D.26031>:
  D.26033 = load->data.op[0].const_val;
  D.26034 = mono_regname_full (sel, bank);
  printf ("SPILLED LOAD (%d at 0x%08lx(%%ebp)) R%d (freed %s)\n", spill, D.26033, i, D.26034);
  <D.26032>:
  D.26010 = bank != 0;
  D.26011 = (long int) D.26010;
  D.26012 = __builtin_expect (D.26011, 0);
  if (D.26012 != 0) goto <D.26035>; else goto <D.26036>;
  <D.26035>:
  D.26037 = 1 << sel;
  i = mono_regstate_alloc_general (rs, D.26037, bank);
  goto <D.26038>;
  <D.26036>:
  D.26037 = 1 << sel;
  i = mono_regstate_alloc_int (rs, D.26037);
  <D.26038>:
  D.26039 = i != sel;
  D.26040 = (long int) D.26039;
  D.26041 = __builtin_expect (D.26040, 0);
  if (D.26041 != 0) goto <D.26042>; else goto <D.26043>;
  <D.26042>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 807, "i == sel");
  <D.26043>:
  D.26010 = bank != 0;
  D.26011 = (long int) D.26010;
  D.26012 = __builtin_expect (D.26011, 0);
  if (D.26012 != 0) goto <D.26044>; else goto <D.26045>;
  <D.26044>:
  mono_regstate_free_general (rs, sel, bank);
  goto <D.26046>;
  <D.26045>:
  mono_regstate_free_int (rs, sel);
  <D.26046>:
}


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.26047;
  long int D.26048;
  long int D.26049;
  int D.26052;

  D.26047 = bank != 0;
  D.26048 = (long int) D.26047;
  D.26049 = __builtin_expect (D.26048, 0);
  if (D.26049 != 0) goto <D.26050>; else goto <D.26051>;
  <D.26050>:
  D.26052 = alloc_general_reg (cfg, bb, last, ins, dest_mask, sym_reg, bank);
  return D.26052;
  <D.26051>:
  D.26052 = alloc_int_reg (cfg, bb, last, ins, dest_mask, sym_reg, info);
  return D.26052;
}


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.26054;
  int D.26057;
  int val;

  D.26054 = cfg->rs;
  val = mono_regstate_alloc_general (D.26054, dest_mask, bank);
  if (val < 0) goto <D.26055>; else goto <D.26056>;
  <D.26055>:
  val = get_register_spilling (cfg, bb, last, ins, dest_mask, sym_reg, bank);
  <D.26056>:
  D.26057 = val;
  return D.26057;
}


assign_reg (struct MonoCompile * cfg, struct MonoRegState * rs, int reg, int hreg, int bank)
{
  _Bool D.26059;
  long int D.26060;
  long int D.26061;
  int D.26064;
  _Bool D.26065;
  long int D.26066;
  long int D.26067;
  _Bool D.26070;
  long int D.26071;
  long int D.26072;
  int iftmp.68;
  unsigned int hreg.69;
  long unsigned int D.26080;
  long unsigned int D.26081;
  _Bool D.26083;
  long int D.26084;
  long int D.26085;
  gint32 * D.26088;
  long unsigned int D.26089;
  long unsigned int D.26090;
  gint32 * D.26091;
  int * D.26092;
  long unsigned int D.26093;
  long unsigned int D.26094;
  int * D.26095;
  long unsigned int D.26096;
  long unsigned int D.26097;
  long unsigned int D.26098;
  long unsigned int D.26099;
  int * D.26102;
  int * D.26103;
  _Bool D.26105;
  long int D.26106;
  long int D.26107;
  _Bool D.26110;
  long int D.26111;
  long int D.26112;
  int iftmp.70;
  long unsigned int D.26119;
  long unsigned int D.26120;
  _Bool D.26122;
  long int D.26123;
  long int D.26124;
  long unsigned int D.26127;
  long unsigned int D.26128;

  D.26059 = bank != 0;
  D.26060 = (long int) D.26059;
  D.26061 = __builtin_expect (D.26060, 0);
  if (D.26061 != 0) goto <D.26062>; else goto <D.26063>;
  <D.26062>:
  {
    int mirrored_bank;

    D.26064 = regbank_size[bank];
    D.26065 = D.26064 > reg;
    D.26066 = (long int) D.26065;
    D.26067 = __builtin_expect (D.26066, 0);
    if (D.26067 != 0) goto <D.26068>; else goto <D.26069>;
    <D.26068>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1040, "reg >= regbank_size [bank]");
    <D.26069>:
    D.26064 = regbank_size[bank];
    D.26070 = D.26064 <= hreg;
    D.26071 = (long int) D.26070;
    D.26072 = __builtin_expect (D.26071, 0);
    if (D.26072 != 0) goto <D.26073>; else goto <D.26074>;
    <D.26073>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1041, "hreg < regbank_size [bank]");
    <D.26074>:
    hreg.69 = (unsigned int) hreg;
    if (hreg.69 <= 31) goto <D.26079>; else goto <D.26076>;
    <D.26079>:
    D.26080 = 18446744073709535232 >> hreg;
    D.26081 = D.26080 & 1;
    if (D.26081 != 0) goto <D.26082>; else goto <D.26076>;
    <D.26082>:
    iftmp.68 = 1;
    goto <D.26077>;
    <D.26076>:
    iftmp.68 = 0;
    <D.26077>:
    D.26083 = iftmp.68 != 0;
    D.26084 = (long int) D.26083;
    D.26085 = __builtin_expect (D.26084, 0);
    if (D.26085 != 0) goto <D.26086>; else goto <D.26087>;
    <D.26086>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1042, "! is_global_freg (hreg)");
    <D.26087>:
    D.26088 = rs->vassign;
    D.26089 = (long unsigned int) reg;
    D.26090 = D.26089 * 4;
    D.26091 = D.26088 + D.26090;
    *D.26091 = hreg;
    D.26092 = rs->symbolic[bank];
    D.26093 = (long unsigned int) hreg;
    D.26094 = D.26093 * 4;
    D.26095 = D.26092 + D.26094;
    *D.26095 = reg;
    D.26096 = rs->free_mask[bank];
    D.26097 = 1 << hreg;
    D.26098 = ~D.26097;
    D.26099 = D.26096 & D.26098;
    rs->free_mask[bank] = D.26099;
    mirrored_bank = -1;
    if (mirrored_bank == -1) goto <D.26100>; else goto <D.26101>;
    <D.26100>:
    return;
    <D.26101>:
    D.26096 = rs->free_mask[bank];
    rs->free_mask[mirrored_bank] = D.26096;
    D.26102 = rs->symbolic[mirrored_bank];
    D.26093 = (long unsigned int) hreg;
    D.26094 = D.26093 * 4;
    D.26103 = D.26102 + D.26094;
    *D.26103 = -2;
  }
  goto <D.26104>;
  <D.26063>:
  D.26105 = reg <= 31;
  D.26106 = (long int) D.26105;
  D.26107 = __builtin_expect (D.26106, 0);
  if (D.26107 != 0) goto <D.26108>; else goto <D.26109>;
  <D.26108>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1064, "reg >= MONO_MAX_IREGS");
  <D.26109>:
  D.26110 = hreg > 31;
  D.26111 = (long int) D.26110;
  D.26112 = __builtin_expect (D.26111, 0);
  if (D.26112 != 0) goto <D.26113>; else goto <D.26114>;
  <D.26113>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1065, "hreg < MONO_MAX_IREGS");
  <D.26114>:
  hreg.69 = (unsigned int) hreg;
  if (hreg.69 <= 31) goto <D.26118>; else goto <D.26116>;
  <D.26118>:
  D.26119 = 18446744073709543424 >> hreg;
  D.26120 = D.26119 & 1;
  if (D.26120 != 0) goto <D.26121>; else goto <D.26116>;
  <D.26121>:
  iftmp.70 = 1;
  goto <D.26117>;
  <D.26116>:
  iftmp.70 = 0;
  <D.26117>:
  D.26122 = iftmp.70 != 0;
  D.26123 = (long int) D.26122;
  D.26124 = __builtin_expect (D.26123, 0);
  if (D.26124 != 0) goto <D.26125>; else goto <D.26126>;
  <D.26125>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 1068, "! is_global_ireg (hreg)");
  <D.26126>:
  D.26088 = rs->vassign;
  D.26089 = (long unsigned int) reg;
  D.26090 = D.26089 * 4;
  D.26091 = D.26088 + D.26090;
  *D.26091 = hreg;
  rs->isymbolic[hreg] = reg;
  D.26127 = rs->ifree_mask;
  D.26097 = 1 << hreg;
  D.26098 = ~D.26097;
  D.26128 = D.26127 & D.26098;
  rs->ifree_mask = D.26128;
  <D.26104>:
}


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.26130;
  int D.26131;
  short unsigned int D.26132;
  int D.26133;
  int D.26134;
  const unsigned char * D.26135;
  unsigned int D.26136;
  int D.26137;
  int D.26138;
  long int D.26139;
  unsigned int D.26146;
  _Bool D.26147;
  long int D.26148;
  long int D.26149;
  const char * D.26152;
  long int D.26153;
  const char * D.26154;
  unsigned int bank.71;
  unsigned int D.26156;
  long unsigned int D.26159;
  long unsigned int D.26160;
  _Bool D.26163;
  long int D.26164;
  long int D.26165;
  int D.26168;
  int D.26169;
  long int D.26170;
  long int D.26171;
  struct MonoInst * store;
  struct MonoInst * def;

  bank = get_vreg_bank (cfg, prev_reg, bank);
  D.26130 = cfg->mempool;
  store = mono_mempool_alloc0 (D.26130, 80);
  D.26131 = regbank_store_ops[bank];
  D.26132 = (short unsigned int) D.26131;
  store->opcode = D.26132;
  store->dreg = -1;
  store->sreg3 = -1;
  D.26133 = store->sreg3;
  store->sreg2 = D.26133;
  D.26134 = store->sreg2;
  store->sreg1 = D.26134;
  D.26135 = cfg->ip;
  store->cil_code = D.26135;
  store->sreg1 = reg;
  D.26136 = cfg->frame_reg;
  D.26137 = (int) D.26136;
  store->dreg = D.26137;
  D.26138 = mono_spillvar_offset (cfg, spill, bank);
  D.26139 = (long int) D.26138;
  store->data.op[0].const_val = D.26139;
  if (ins != 0B) goto <D.26140>; else goto <D.26141>;
  <D.26140>:
  mono_bblock_insert_after_ins (bb, ins, store);
  *last = store;
  goto <D.26142>;
  <D.26141>:
  if (insert_before != 0B) goto <D.26143>; else goto <D.26144>;
  <D.26143>:
  insert_before_ins (bb, insert_before, store);
  goto <D.26145>;
  <D.26144>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-codegen.c", 972);
  <D.26145>:
  <D.26142>:
  D.26146 = cfg->verbose_level;
  D.26147 = D.26146 > 2;
  D.26148 = (long int) D.26147;
  D.26149 = __builtin_expect (D.26148, 0);
  if (D.26149 != 0) goto <D.26150>; else goto <D.26151>;
  <D.26150>:
  D.26152 = regbank_to_string (bank);
  D.26153 = store->data.op[0].const_val;
  D.26154 = mono_regname_full (reg, bank);
  printf ("\t%sSPILLED STORE (%d at 0x%08lx(%%ebp)) R%d (from %s)\n", D.26152, spill, D.26153, prev_reg, D.26154);
  <D.26151>:
  bank.71 = (unsigned int) bank;
  D.26156 = bank.71 + 4294967294;
  if (D.26156 <= 1) goto <D.26157>; else goto <D.26158>;
  <D.26157>:
  D.26159 = BIT_FIELD_REF <*cfg, 64, 5632>;
  D.26160 = D.26159 & 128;
  if (D.26160 != 0) goto <D.26161>; else goto <D.26162>;
  <D.26161>:
  D.26163 = prev_reg == -1;
  D.26164 = (long int) D.26163;
  D.26165 = __builtin_expect (D.26164, 0);
  if (D.26165 != 0) goto <D.26166>; else goto <D.26167>;
  <D.26166>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-codegen.c", 977, "prev_reg != -1");
  <D.26167>:
  D.26130 = cfg->mempool;
  def = mono_mempool_alloc0 (D.26130, 80);
  def->opcode = 840;
  def->dreg = -1;
  def->sreg3 = -1;
  D.26168 = def->sreg3;
  def->sreg2 = D.26168;
  D.26169 = def->sreg2;
  def->sreg1 = D.26169;
  D.26135 = cfg->ip;
  def->cil_code = D.26135;
  D.26170 = (long int) spill;
  def->data.op[0].const_val = D.26170;
  D.26171 = (long int) bank;
  def->data.op[1].const_val = D.26171;
  mono_bblock_insert_after_ins (bb, store, def);
  <D.26162>:
  <D.26158>:
}


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

  if (bank == 2) goto <D.26172>; else goto <D.26173>;
  <D.26172>:
  D.26174 = "REF ";
  return D.26174;
  <D.26173>:
  if (bank == 3) goto <D.26175>; else goto <D.26176>;
  <D.26175>:
  D.26174 = "MP ";
  return D.26174;
  <D.26176>:
  D.26174 = "";
  return D.26174;
}


mono_opcode_to_cond (int opcode)
{
  CompRelation D.26178;
  const char * D.26179;

  switch (opcode) <default: <D.24096>, case 446: <D.24004>, case 447: <D.24049>, case 448: <D.24085>, case 449: <D.24038>, case 450: <D.24074>, case 451: <D.24011>, case 453: <D.24056>, case 455: <D.24045>, case 456: <D.24020>, case 458: <D.24092>, case 459: <D.24064>, case 460: <D.24081>, case 465: <D.24012>, case 467: <D.24057>, case 469: <D.24046>, case 470: <D.24021>, case 472: <D.24093>, case 473: <D.24065>, case 474: <D.24082>, case 531: <D.24008>, case 532: <D.24053>, case 533: <D.24089>, case 534: <D.24042>, case 535: <D.24078>, case 551: <D.24007>, case 552: <D.24034>, case 553: <D.24052>, case 554: <D.24027>, case 555: <D.24041>, case 556: <D.24018>, case 557: <D.24070>, case 558: <D.24088>, case 559: <D.24062>, case 560: <D.24077>, case 638: <D.24006>, case 639: <D.24051>, case 640: <D.24087>, case 641: <D.24040>, case 642: <D.24076>, case 643: <D.24016>, case 644: <D.24032>, case 645: <D.24025>, case 646: <D.24068>, case 647: <D.24060>, case 648: <D.24005>, case 649: <D.24033>, case 650: <D.24050>, case 651: <D.24026>, case 652: <D.24039>, case 653: <D.24017>, case 654: <D.24069>, case 655: <D.24086>, case 656: <D.24061>, case 657: <D.24075>, case 658: <D.24009>, case 659: <D.24035>, case 660: <D.24054>, case 661: <D.24028>, case 662: <D.24043>, case 663: <D.24019>, case 664: <D.24071>, case 665: <D.24091>, case 666: <D.24063>, case 667: <D.24079>, case 714: <D.24010>, case 715: <D.24055>, case 716: <D.24090>, case 717: <D.24044>, case 718: <D.24080>, case 719: <D.24015>, case 720: <D.24031>, case 721: <D.24024>, case 816: <D.24013>, case 817: <D.24036>, case 818: <D.24058>, case 819: <D.24029>, case 820: <D.24047>, case 821: <D.24022>, case 822: <D.24072>, case 823: <D.24094>, case 824: <D.24066>, case 825: <D.24083>, case 826: <D.24014>, case 827: <D.24037>, case 828: <D.24059>, case 829: <D.24030>, case 830: <D.24048>, case 831: <D.24023>, case 832: <D.24073>, case 833: <D.24095>, case 834: <D.24067>, case 835: <D.24084>>
  <D.24004>:
  <D.24005>:
  <D.24006>:
  <D.24007>:
  <D.24008>:
  <D.24009>:
  <D.24010>:
  <D.24011>:
  <D.24012>:
  <D.24013>:
  <D.24014>:
  D.26178 = 0;
  return D.26178;
  <D.24015>:
  <D.24016>:
  <D.24017>:
  <D.24018>:
  <D.24019>:
  <D.24020>:
  <D.24021>:
  <D.24022>:
  <D.24023>:
  D.26178 = 1;
  return D.26178;
  <D.24024>:
  <D.24025>:
  <D.24026>:
  <D.24027>:
  <D.24028>:
  <D.24029>:
  <D.24030>:
  D.26178 = 2;
  return D.26178;
  <D.24031>:
  <D.24032>:
  <D.24033>:
  <D.24034>:
  <D.24035>:
  <D.24036>:
  <D.24037>:
  D.26178 = 3;
  return D.26178;
  <D.24038>:
  <D.24039>:
  <D.24040>:
  <D.24041>:
  <D.24042>:
  <D.24043>:
  <D.24044>:
  <D.24045>:
  <D.24046>:
  <D.24047>:
  <D.24048>:
  D.26178 = 4;
  return D.26178;
  <D.24049>:
  <D.24050>:
  <D.24051>:
  <D.24052>:
  <D.24053>:
  <D.24054>:
  <D.24055>:
  <D.24056>:
  <D.24057>:
  <D.24058>:
  <D.24059>:
  D.26178 = 5;
  return D.26178;
  <D.24060>:
  <D.24061>:
  <D.24062>:
  <D.24063>:
  <D.24064>:
  <D.24065>:
  <D.24066>:
  <D.24067>:
  D.26178 = 6;
  return D.26178;
  <D.24068>:
  <D.24069>:
  <D.24070>:
  <D.24071>:
  <D.24072>:
  <D.24073>:
  D.26178 = 7;
  return D.26178;
  <D.24074>:
  <D.24075>:
  <D.24076>:
  <D.24077>:
  <D.24078>:
  <D.24079>:
  <D.24080>:
  <D.24081>:
  <D.24082>:
  <D.24083>:
  <D.24084>:
  D.26178 = 8;
  return D.26178;
  <D.24085>:
  <D.24086>:
  <D.24087>:
  <D.24088>:
  <D.24089>:
  <D.24090>:
  <D.24091>:
  <D.24092>:
  <D.24093>:
  <D.24094>:
  <D.24095>:
  D.26178 = 9;
  return D.26178;
  <D.24096>:
  D.26179 = mono_inst_name (opcode);
  printf ("%s\n", D.26179);
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-codegen.c", 2447);
  D.26178 = 0;
  return D.26178;
}


mono_negate_cond (CompRelation cond)
{
  CompRelation D.26181;

  switch (cond) <default: <D.24110>, case 0: <D.24100>, case 1: <D.24101>, case 2: <D.24102>, case 3: <D.24103>, case 4: <D.24104>, case 5: <D.24105>, case 6: <D.24106>, case 7: <D.24107>, case 8: <D.24108>, case 9: <D.24109>>
  <D.24100>:
  D.26181 = 1;
  return D.26181;
  <D.24101>:
  D.26181 = 0;
  return D.26181;
  <D.24102>:
  D.26181 = 5;
  return D.26181;
  <D.24103>:
  D.26181 = 4;
  return D.26181;
  <D.24104>:
  D.26181 = 3;
  return D.26181;
  <D.24105>:
  D.26181 = 2;
  return D.26181;
  <D.24106>:
  D.26181 = 9;
  return D.26181;
  <D.24107>:
  D.26181 = 8;
  return D.26181;
  <D.24108>:
  D.26181 = 7;
  return D.26181;
  <D.24109>:
  D.26181 = 6;
  return D.26181;
  <D.24110>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-codegen.c", 2477);
}


mono_opcode_to_type (int opcode, int cmp_opcode)
{
  unsigned int opcode.72;
  unsigned int D.26184;
  CompType D.26187;
  unsigned int D.26188;
  unsigned int D.26191;
  unsigned int D.26194;
  unsigned int D.26197;
  unsigned int D.26200;
  unsigned int D.26203;
  unsigned int D.26206;
  unsigned int D.26209;
  const char * D.26212;

  opcode.72 = (unsigned int) opcode;
  D.26184 = opcode.72 + 4294966850;
  if (D.26184 <= 4) goto <D.26185>; else goto <D.26186>;
  <D.26185>:
  D.26187 = 0;
  return D.26187;
  <D.26186>:
  opcode.72 = (unsigned int) opcode;
  D.26188 = opcode.72 + 4294966648;
  if (D.26188 <= 9) goto <D.26189>; else goto <D.26190>;
  <D.26189>:
  D.26187 = 1;
  return D.26187;
  <D.26190>:
  opcode.72 = (unsigned int) opcode;
  D.26191 = opcode.72 + 4294966658;
  if (D.26191 <= 4) goto <D.26192>; else goto <D.26193>;
  <D.26192>:
  D.26187 = 1;
  return D.26187;
  <D.26193>:
  opcode.72 = (unsigned int) opcode;
  D.26194 = opcode.72 + 4294966745;
  if (D.26194 <= 9) goto <D.26195>; else goto <D.26196>;
  <D.26195>:
  D.26187 = 0;
  return D.26187;
  <D.26196>:
  opcode.72 = (unsigned int) opcode;
  D.26197 = opcode.72 + 4294966765;
  if (D.26197 <= 4) goto <D.26198>; else goto <D.26199>;
  <D.26198>:
  D.26187 = 0;
  return D.26187;
  <D.26199>:
  opcode.72 = (unsigned int) opcode;
  D.26200 = opcode.72 + 4294966638;
  if (D.26200 <= 9) goto <D.26201>; else goto <D.26202>;
  <D.26201>:
  D.26187 = 2;
  return D.26187;
  <D.26202>:
  opcode.72 = (unsigned int) opcode;
  D.26203 = opcode.72 + 4294966582;
  if (D.26203 <= 4) goto <D.26204>; else goto <D.26205>;
  <D.26204>:
  D.26187 = 2;
  return D.26187;
  <D.26205>:
  opcode.72 = (unsigned int) opcode;
  D.26206 = opcode.72 + 4294966831;
  if (D.26206 <= 9) goto <D.26207>; else goto <D.26208>;
  <D.26207>:
  D.26187 = 1;
  return D.26187;
  <D.26208>:
  opcode.72 = (unsigned int) opcode;
  D.26209 = opcode.72 + 4294966845;
  if (D.26209 <= 9) goto <D.26210>; else goto <D.26211>;
  <D.26210>:
  switch (cmp_opcode) <default: <D.24117>, case 326: <D.24115>, case 327: <D.24116>>
  <D.24115>:
  <D.24116>:
  D.26187 = 1;
  return D.26187;
  <D.24117>:
  D.26187 = 0;
  return D.26187;
  <D.26211>:
  D.26212 = mono_inst_name (opcode);
  monoeg_g_log (0B, 4, "Unknown opcode \'%s\' in opcode_to_type", D.26212);
  <D.24118>:
  goto <D.24118>;
  D.26187 = 0;
  return D.26187;
}


mono_is_regsize_var (struct MonoType * t)
{
  long unsigned int D.26214;
  long unsigned int D.26215;
  gboolean D.26218;
  unsigned char D.26219;
  int D.26220;
  int D.26221;

  D.26214 = BIT_FIELD_REF <*t, 64, 64>;
  D.26215 = D.26214 & 1073741824;
  if (D.26215 != 0) goto <D.26216>; else goto <D.26217>;
  <D.26216>:
  D.26218 = 1;
  return D.26218;
  <D.26217>:
  t = mono_type_get_underlying_type (t);
  D.26219 = t->type;
  D.26220 = (int) D.26219;
  switch (D.26220) <default: <D.24143>, case 2: <D.24122>, case 3: <D.24123>, case 4: <D.24124>, case 5: <D.24125>, case 6: <D.24126>, case 7: <D.24127>, case 8: <D.24128>, case 9: <D.24129>, case 10: <D.24134>, case 11: <D.24135>, case 14: <D.24137>, case 15: <D.24132>, case 17: <D.24142>, case 18: <D.24138>, case 20: <D.24140>, case 21: <D.24141>, case 24: <D.24130>, case 25: <D.24131>, case 27: <D.24133>, case 28: <D.24136>, case 29: <D.24139>>
  <D.24122>:
  <D.24123>:
  <D.24124>:
  <D.24125>:
  <D.24126>:
  <D.24127>:
  <D.24128>:
  <D.24129>:
  <D.24130>:
  <D.24131>:
  <D.24132>:
  <D.24133>:
  <D.24134>:
  <D.24135>:
  D.26218 = 1;
  return D.26218;
  <D.24136>:
  <D.24137>:
  <D.24138>:
  <D.24139>:
  <D.24140>:
  D.26218 = 1;
  return D.26218;
  <D.24141>:
  D.26221 = mono_type_generic_inst_is_valuetype (t);
  if (D.26221 == 0) goto <D.26222>; else goto <D.26223>;
  <D.26222>:
  D.26218 = 1;
  return D.26218;
  <D.26223>:
  D.26218 = 0;
  return D.26218;
  <D.24142>:
  D.26218 = 0;
  return D.26218;
  <D.24143>:
  D.26218 = 0;
  return D.26218;
}


mono_peephole_ins (struct MonoBasicBlock * bb, struct MonoInst * ins)
{
  short unsigned int D.26225;
  int D.26226;
  long int D.26227;
  int D.26230;
  int D.26231;
  struct MonoInst * D.26235;
  struct MonoInst * D.26238;
  struct MonoInst * D.26241;
  struct MonoInst * D.26244;
  int D.26247;
  int D.26248;
  short unsigned int D.26251;
  int D.26261;
  long int D.26264;
  long int D.26265;
  int D.26268;
  guint16 iftmp.73;
  guint16 iftmp.74;
  struct MonoInst * last_ins;

  last_ins = ins->prev;
  D.26225 = ins->opcode;
  D.26226 = (int) D.26225;
  switch (D.26226) <default: <D.26359>, case 316: <D.24159>, case 388: <D.24151>, case 389: <D.24153>, case 390: <D.24154>, case 391: <D.24155>, case 392: <D.24156>, case 393: <D.24152>, case 424: <D.24157>, case 426: <D.24158>, case 431: <D.24149>>
  <D.24149>:
  D.26227 = ins->data.op[1].const_val;
  if (D.26227 == 1) goto <D.26228>; else goto <D.26229>;
  <D.26228>:
  D.26230 = ins->dreg;
  D.26231 = ins->sreg1;
  if (D.26230 != D.26231) goto <D.26232>; else goto <D.26233>;
  <D.26232>:
  ins->opcode = 424;
  goto <D.26234>;
  <D.26233>:
  D.26235 = ins->prev;
  if (D.26235 != 0B) goto <D.26236>; else goto <D.26237>;
  <D.26236>:
  D.26235 = ins->prev;
  D.26238 = ins->next;
  D.26235->next = D.26238;
  <D.26237>:
  D.26238 = ins->next;
  if (D.26238 != 0B) goto <D.26239>; else goto <D.26240>;
  <D.26239>:
  D.26238 = ins->next;
  D.26235 = ins->prev;
  D.26238->prev = D.26235;
  <D.26240>:
  D.26241 = bb->code;
  if (D.26241 == ins) goto <D.26242>; else goto <D.26243>;
  <D.26242>:
  D.26238 = ins->next;
  bb->code = D.26238;
  <D.26243>:
  D.26244 = bb->last_ins;
  if (D.26244 == ins) goto <D.26245>; else goto <D.26246>;
  <D.26245>:
  D.26235 = ins->prev;
  bb->last_ins = D.26235;
  <D.26246>:
  ins->opcode = 316;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.26247 = ins->sreg3;
  ins->sreg2 = D.26247;
  D.26248 = ins->sreg2;
  ins->sreg1 = D.26248;
  <D.26234>:
  <D.26229>:
  goto <D.24150>;
  <D.24151>:
  <D.24152>:
  if (last_ins != 0B) goto <D.26249>; else goto <D.26250>;
  <D.26249>:
  D.26251 = last_ins->opcode;
  if (D.26251 == 838) goto <D.26252>; else goto <D.26253>;
  <D.26252>:
  last_ins = last_ins->prev;
  <D.26253>:
  <D.26250>:
  if (last_ins != 0B) goto <D.26257>; else goto <D.26258>;
  <D.26257>:
  D.26225 = ins->opcode;
  if (D.26225 == 393) goto <D.26259>; else goto <D.26254>;
  <D.26259>:
  D.26251 = last_ins->opcode;
  if (D.26251 == 377) goto <D.26255>; else goto <D.26254>;
  <D.26254>:
  D.26225 = ins->opcode;
  if (D.26225 == 388) goto <D.26260>; else goto <D.26256>;
  <D.26260>:
  D.26251 = last_ins->opcode;
  if (D.26251 == 374) goto <D.26255>; else goto <D.26256>;
  <D.26255>:
  D.26231 = ins->sreg1;
  D.26261 = last_ins->dreg;
  if (D.26231 == D.26261) goto <D.26262>; else goto <D.26263>;
  <D.26262>:
  D.26264 = ins->data.op[0].const_val;
  D.26265 = last_ins->data.op[0].const_val;
  if (D.26264 == D.26265) goto <D.26266>; else goto <D.26267>;
  <D.26266>:
  D.26230 = ins->dreg;
  D.26268 = last_ins->sreg1;
  if (D.26230 == D.26268) goto <D.26269>; else goto <D.26270>;
  <D.26269>:
  D.26235 = ins->prev;
  if (D.26235 != 0B) goto <D.26271>; else goto <D.26272>;
  <D.26271>:
  D.26235 = ins->prev;
  D.26238 = ins->next;
  D.26235->next = D.26238;
  <D.26272>:
  D.26238 = ins->next;
  if (D.26238 != 0B) goto <D.26273>; else goto <D.26274>;
  <D.26273>:
  D.26238 = ins->next;
  D.26235 = ins->prev;
  D.26238->prev = D.26235;
  <D.26274>:
  D.26241 = bb->code;
  if (D.26241 == ins) goto <D.26275>; else goto <D.26276>;
  <D.26275>:
  D.26238 = ins->next;
  bb->code = D.26238;
  <D.26276>:
  D.26244 = bb->last_ins;
  if (D.26244 == ins) goto <D.26277>; else goto <D.26278>;
  <D.26277>:
  D.26235 = ins->prev;
  bb->last_ins = D.26235;
  <D.26278>:
  ins->opcode = 316;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.26247 = ins->sreg3;
  ins->sreg2 = D.26247;
  D.26248 = ins->sreg2;
  ins->sreg1 = D.26248;
  goto <D.24150>;
  <D.26270>:
  ins->opcode = 424;
  D.26268 = last_ins->sreg1;
  ins->sreg1 = D.26268;
  <D.26267>:
  <D.26263>:
  <D.26256>:
  <D.26258>:
  if (last_ins != 0B) goto <D.26281>; else goto <D.26282>;
  <D.26281>:
  D.26251 = last_ins->opcode;
  if (D.26251 == 393) goto <D.26279>; else goto <D.26283>;
  <D.26283>:
  D.26251 = last_ins->opcode;
  if (D.26251 == 388) goto <D.26279>; else goto <D.26280>;
  <D.26279>:
  D.26231 = ins->sreg1;
  D.26261 = last_ins->dreg;
  if (D.26231 != D.26261) goto <D.26284>; else goto <D.26285>;
  <D.26284>:
  D.26231 = ins->sreg1;
  D.26268 = last_ins->sreg1;
  if (D.26231 == D.26268) goto <D.26286>; else goto <D.26287>;
  <D.26286>:
  D.26264 = ins->data.op[0].const_val;
  D.26265 = last_ins->data.op[0].const_val;
  if (D.26264 == D.26265) goto <D.26288>; else goto <D.26289>;
  <D.26288>:
  D.26230 = ins->dreg;
  D.26261 = last_ins->dreg;
  if (D.26230 == D.26261) goto <D.26290>; else goto <D.26291>;
  <D.26290>:
  D.26235 = ins->prev;
  if (D.26235 != 0B) goto <D.26292>; else goto <D.26293>;
  <D.26292>:
  D.26235 = ins->prev;
  D.26238 = ins->next;
  D.26235->next = D.26238;
  <D.26293>:
  D.26238 = ins->next;
  if (D.26238 != 0B) goto <D.26294>; else goto <D.26295>;
  <D.26294>:
  D.26238 = ins->next;
  D.26235 = ins->prev;
  D.26238->prev = D.26235;
  <D.26295>:
  D.26241 = bb->code;
  if (D.26241 == ins) goto <D.26296>; else goto <D.26297>;
  <D.26296>:
  D.26238 = ins->next;
  bb->code = D.26238;
  <D.26297>:
  D.26244 = bb->last_ins;
  if (D.26244 == ins) goto <D.26298>; else goto <D.26299>;
  <D.26298>:
  D.26235 = ins->prev;
  bb->last_ins = D.26235;
  <D.26299>:
  ins->opcode = 316;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.26247 = ins->sreg3;
  ins->sreg2 = D.26247;
  D.26248 = ins->sreg2;
  ins->sreg1 = D.26248;
  goto <D.26300>;
  <D.26291>:
  ins->opcode = 424;
  D.26261 = last_ins->dreg;
  ins->sreg1 = D.26261;
  <D.26300>:
  <D.26289>:
  <D.26287>:
  <D.26285>:
  <D.26280>:
  <D.26282>:
  goto <D.24150>;
  <D.24153>:
  <D.24154>:
  if (last_ins != 0B) goto <D.26301>; else goto <D.26302>;
  <D.26301>:
  D.26251 = last_ins->opcode;
  if (D.26251 == 375) goto <D.26303>; else goto <D.26304>;
  <D.26303>:
  D.26231 = ins->sreg1;
  D.26261 = last_ins->dreg;
  if (D.26231 == D.26261) goto <D.26305>; else goto <D.26306>;
  <D.26305>:
  D.26264 = ins->data.op[0].const_val;
  D.26265 = last_ins->data.op[0].const_val;
  if (D.26264 == D.26265) goto <D.26307>; else goto <D.26308>;
  <D.26307>:
  D.26225 = ins->opcode;
  if (D.26225 == 389) goto <D.26310>; else goto <D.26311>;
  <D.26310>:
  iftmp.73 = 494;
  goto <D.26312>;
  <D.26311>:
  iftmp.73 = 503;
  <D.26312>:
  ins->opcode = iftmp.73;
  D.26268 = last_ins->sreg1;
  ins->sreg1 = D.26268;
  <D.26308>:
  <D.26306>:
  <D.26304>:
  <D.26302>:
  goto <D.24150>;
  <D.24155>:
  <D.24156>:
  if (last_ins != 0B) goto <D.26313>; else goto <D.26314>;
  <D.26313>:
  D.26251 = last_ins->opcode;
  if (D.26251 == 376) goto <D.26315>; else goto <D.26316>;
  <D.26315>:
  D.26231 = ins->sreg1;
  D.26261 = last_ins->dreg;
  if (D.26231 == D.26261) goto <D.26317>; else goto <D.26318>;
  <D.26317>:
  D.26264 = ins->data.op[0].const_val;
  D.26265 = last_ins->data.op[0].const_val;
  if (D.26264 == D.26265) goto <D.26319>; else goto <D.26320>;
  <D.26319>:
  D.26225 = ins->opcode;
  if (D.26225 == 391) goto <D.26322>; else goto <D.26323>;
  <D.26322>:
  iftmp.74 = 495;
  goto <D.26324>;
  <D.26323>:
  iftmp.74 = 502;
  <D.26324>:
  ins->opcode = iftmp.74;
  D.26268 = last_ins->sreg1;
  ins->sreg1 = D.26268;
  <D.26320>:
  <D.26318>:
  <D.26316>:
  <D.26314>:
  goto <D.24150>;
  <D.24157>:
  <D.24158>:
  D.26230 = ins->dreg;
  D.26231 = ins->sreg1;
  if (D.26230 == D.26231) goto <D.26325>; else goto <D.26326>;
  <D.26325>:
  D.26235 = ins->prev;
  if (D.26235 != 0B) goto <D.26327>; else goto <D.26328>;
  <D.26327>:
  D.26235 = ins->prev;
  D.26238 = ins->next;
  D.26235->next = D.26238;
  <D.26328>:
  D.26238 = ins->next;
  if (D.26238 != 0B) goto <D.26329>; else goto <D.26330>;
  <D.26329>:
  D.26238 = ins->next;
  D.26235 = ins->prev;
  D.26238->prev = D.26235;
  <D.26330>:
  D.26241 = bb->code;
  if (D.26241 == ins) goto <D.26331>; else goto <D.26332>;
  <D.26331>:
  D.26238 = ins->next;
  bb->code = D.26238;
  <D.26332>:
  D.26244 = bb->last_ins;
  if (D.26244 == ins) goto <D.26333>; else goto <D.26334>;
  <D.26333>:
  D.26235 = ins->prev;
  bb->last_ins = D.26235;
  <D.26334>:
  ins->opcode = 316;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.26247 = ins->sreg3;
  ins->sreg2 = D.26247;
  D.26248 = ins->sreg2;
  ins->sreg1 = D.26248;
  goto <D.24150>;
  <D.26326>:
  if (last_ins != 0B) goto <D.26335>; else goto <D.26336>;
  <D.26335>:
  D.26251 = last_ins->opcode;
  D.26225 = ins->opcode;
  if (D.26251 == D.26225) goto <D.26337>; else goto <D.26338>;
  <D.26337>:
  D.26231 = ins->sreg1;
  D.26261 = last_ins->dreg;
  if (D.26231 == D.26261) goto <D.26339>; else goto <D.26340>;
  <D.26339>:
  D.26230 = ins->dreg;
  D.26268 = last_ins->sreg1;
  if (D.26230 == D.26268) goto <D.26341>; else goto <D.26342>;
  <D.26341>:
  D.26235 = ins->prev;
  if (D.26235 != 0B) goto <D.26343>; else goto <D.26344>;
  <D.26343>:
  D.26235 = ins->prev;
  D.26238 = ins->next;
  D.26235->next = D.26238;
  <D.26344>:
  D.26238 = ins->next;
  if (D.26238 != 0B) goto <D.26345>; else goto <D.26346>;
  <D.26345>:
  D.26238 = ins->next;
  D.26235 = ins->prev;
  D.26238->prev = D.26235;
  <D.26346>:
  D.26241 = bb->code;
  if (D.26241 == ins) goto <D.26347>; else goto <D.26348>;
  <D.26347>:
  D.26238 = ins->next;
  bb->code = D.26238;
  <D.26348>:
  D.26244 = bb->last_ins;
  if (D.26244 == ins) goto <D.26349>; else goto <D.26350>;
  <D.26349>:
  D.26235 = ins->prev;
  bb->last_ins = D.26235;
  <D.26350>:
  ins->opcode = 316;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.26247 = ins->sreg3;
  ins->sreg2 = D.26247;
  D.26248 = ins->sreg2;
  ins->sreg1 = D.26248;
  <D.26342>:
  <D.26340>:
  <D.26338>:
  <D.26336>:
  goto <D.24150>;
  <D.24159>:
  D.26235 = ins->prev;
  if (D.26235 != 0B) goto <D.26351>; else goto <D.26352>;
  <D.26351>:
  D.26235 = ins->prev;
  D.26238 = ins->next;
  D.26235->next = D.26238;
  <D.26352>:
  D.26238 = ins->next;
  if (D.26238 != 0B) goto <D.26353>; else goto <D.26354>;
  <D.26353>:
  D.26238 = ins->next;
  D.26235 = ins->prev;
  D.26238->prev = D.26235;
  <D.26354>:
  D.26241 = bb->code;
  if (D.26241 == ins) goto <D.26355>; else goto <D.26356>;
  <D.26355>:
  D.26238 = ins->next;
  bb->code = D.26238;
  <D.26356>:
  D.26244 = bb->last_ins;
  if (D.26244 == ins) goto <D.26357>; else goto <D.26358>;
  <D.26357>:
  D.26235 = ins->prev;
  bb->last_ins = D.26235;
  <D.26358>:
  ins->opcode = 316;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.26247 = ins->sreg3;
  ins->sreg2 = D.26247;
  D.26248 = ins->sreg2;
  ins->sreg1 = D.26248;
  goto <D.24150>;
  <D.26359>:
  <D.24150>:
}


mini_exception_id_by_name (const char * name)
{
  int D.24171;
  int iftmp.75;
  int D.24170;
  const char[25] * D.26363;
  unsigned char D.26364;
  int D.26365;
  unsigned char D.26366;
  int D.26367;
  const unsigned char * D.26372;
  unsigned char D.26373;
  int D.26374;
  const unsigned char * D.26375;
  unsigned char D.26376;
  int D.26377;
  const unsigned char * D.26382;
  unsigned char D.26383;
  int D.26384;
  const unsigned char * D.26385;
  unsigned char D.26386;
  int D.26387;
  const unsigned char * D.26392;
  unsigned char D.26393;
  int D.26394;
  const unsigned char * D.26395;
  unsigned char D.26396;
  int D.26397;
  int D.26401;
  int D.24180;
  int iftmp.76;
  int D.24179;
  const char[18] * D.26405;
  unsigned char D.26406;
  int D.26407;
  unsigned char D.26408;
  int D.26409;
  const unsigned char * D.26414;
  unsigned char D.26415;
  int D.26416;
  const unsigned char * D.26417;
  unsigned char D.26418;
  int D.26419;
  const unsigned char * D.26424;
  unsigned char D.26425;
  int D.26426;
  const unsigned char * D.26427;
  unsigned char D.26428;
  int D.26429;
  const unsigned char * D.26434;
  unsigned char D.26435;
  int D.26436;
  const unsigned char * D.26437;
  unsigned char D.26438;
  int D.26439;
  int D.24189;
  int iftmp.77;
  int D.24188;
  const char[20] * D.26446;
  unsigned char D.26447;
  int D.26448;
  unsigned char D.26449;
  int D.26450;
  const unsigned char * D.26455;
  unsigned char D.26456;
  int D.26457;
  const unsigned char * D.26458;
  unsigned char D.26459;
  int D.26460;
  const unsigned char * D.26465;
  unsigned char D.26466;
  int D.26467;
  const unsigned char * D.26468;
  unsigned char D.26469;
  int D.26470;
  const unsigned char * D.26475;
  unsigned char D.26476;
  int D.26477;
  const unsigned char * D.26478;
  unsigned char D.26479;
  int D.26480;
  int D.24198;
  int iftmp.78;
  int D.24197;
  const char[22] * D.26487;
  unsigned char D.26488;
  int D.26489;
  unsigned char D.26490;
  int D.26491;
  const unsigned char * D.26496;
  unsigned char D.26497;
  int D.26498;
  const unsigned char * D.26499;
  unsigned char D.26500;
  int D.26501;
  const unsigned char * D.26506;
  unsigned char D.26507;
  int D.26508;
  const unsigned char * D.26509;
  unsigned char D.26510;
  int D.26511;
  const unsigned char * D.26516;
  unsigned char D.26517;
  int D.26518;
  const unsigned char * D.26519;
  unsigned char D.26520;
  int D.26521;
  int D.24207;
  int iftmp.79;
  int D.24206;
  const char[21] * D.26528;
  unsigned char D.26529;
  int D.26530;
  unsigned char D.26531;
  int D.26532;
  const unsigned char * D.26537;
  unsigned char D.26538;
  int D.26539;
  const unsigned char * D.26540;
  unsigned char D.26541;
  int D.26542;
  const unsigned char * D.26547;
  unsigned char D.26548;
  int D.26549;
  const unsigned char * D.26550;
  unsigned char D.26551;
  int D.26552;
  const unsigned char * D.26557;
  unsigned char D.26558;
  int D.26559;
  const unsigned char * D.26560;
  unsigned char D.26561;
  int D.26562;
  int D.24216;
  int iftmp.80;
  int D.24215;
  const char[23] * D.26569;
  unsigned char D.26570;
  int D.26571;
  unsigned char D.26572;
  int D.26573;
  const unsigned char * D.26578;
  unsigned char D.26579;
  int D.26580;
  const unsigned char * D.26581;
  unsigned char D.26582;
  int D.26583;
  const unsigned char * D.26588;
  unsigned char D.26589;
  int D.26590;
  const unsigned char * D.26591;
  unsigned char D.26592;
  int D.26593;
  const unsigned char * D.26598;
  unsigned char D.26599;
  int D.26600;
  const unsigned char * D.26601;
  unsigned char D.26602;
  int D.26603;
  int D.24225;
  int iftmp.81;
  int D.24224;
  const char[27] * D.26610;
  unsigned char D.26611;
  int D.26612;
  unsigned char D.26613;
  int D.26614;
  const unsigned char * D.26619;
  unsigned char D.26620;
  int D.26621;
  const unsigned char * D.26622;
  unsigned char D.26623;
  int D.26624;
  const unsigned char * D.26629;
  unsigned char D.26630;
  int D.26631;
  const unsigned char * D.26632;
  unsigned char D.26633;
  int D.26634;
  const unsigned char * D.26639;
  unsigned char D.26640;
  int D.26641;
  const unsigned char * D.26642;
  unsigned char D.26643;
  int D.26644;
  int D.24234;
  int iftmp.82;
  int D.24233;
  const char[18] * D.26651;
  unsigned char D.26652;
  int D.26653;
  unsigned char D.26654;
  int D.26655;
  const unsigned char * D.26660;
  unsigned char D.26661;
  int D.26662;
  const unsigned char * D.26663;
  unsigned char D.26664;
  int D.26665;
  const unsigned char * D.26670;
  unsigned char D.26671;
  int D.26672;
  const unsigned char * D.26673;
  unsigned char D.26674;
  int D.26675;
  const unsigned char * D.26680;
  unsigned char D.26681;
  int D.26682;
  const unsigned char * D.26683;
  unsigned char D.26684;
  int D.26685;

  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.26363 = "IndexOutOfRangeException";
      D.26364 = MEM[(const unsigned char *)D.26363];
      D.26365 = (int) D.26364;
      D.26366 = *__s2;
      D.26367 = (int) D.26366;
      __result = D.26365 - D.26367;
      {
        if (__s2_len != 0) goto <D.26368>; else goto <D.26369>;
        <D.26368>:
        if (__result == 0) goto <D.26370>; else goto <D.26371>;
        <D.26370>:
        D.26372 = &MEM[(void *)"IndexOutOfRangeException" + 1B];
        D.26373 = *D.26372;
        D.26374 = (int) D.26373;
        D.26375 = __s2 + 1;
        D.26376 = *D.26375;
        D.26377 = (int) D.26376;
        __result = D.26374 - D.26377;
        if (__s2_len > 1) goto <D.26378>; else goto <D.26379>;
        <D.26378>:
        if (__result == 0) goto <D.26380>; else goto <D.26381>;
        <D.26380>:
        D.26382 = &MEM[(void *)"IndexOutOfRangeException" + 2B];
        D.26383 = *D.26382;
        D.26384 = (int) D.26383;
        D.26385 = __s2 + 2;
        D.26386 = *D.26385;
        D.26387 = (int) D.26386;
        __result = D.26384 - D.26387;
        if (__s2_len > 2) goto <D.26388>; else goto <D.26389>;
        <D.26388>:
        if (__result == 0) goto <D.26390>; else goto <D.26391>;
        <D.26390>:
        D.26392 = &MEM[(void *)"IndexOutOfRangeException" + 3B];
        D.26393 = *D.26392;
        D.26394 = (int) D.26393;
        D.26395 = __s2 + 3;
        D.26396 = *D.26395;
        D.26397 = (int) D.26396;
        __result = D.26394 - D.26397;
        <D.26391>:
        <D.26389>:
        <D.26381>:
        <D.26379>:
        <D.26371>:
        <D.26369>:
      }
      D.24170 = __result;
    }
    iftmp.75 = -D.24170;
    goto <D.26398>;
    <D.26362>:
    iftmp.75 = __builtin_strcmp (name, "IndexOutOfRangeException");
    <D.26398>:
    D.24171 = iftmp.75;
  }
  if (D.24171 == 0) goto <D.26399>; else goto <D.26400>;
  <D.26399>:
  D.26401 = 0;
  return D.26401;
  <D.26400>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.26405 = "OverflowException";
      D.26406 = MEM[(const unsigned char *)D.26405];
      D.26407 = (int) D.26406;
      D.26408 = *__s2;
      D.26409 = (int) D.26408;
      __result = D.26407 - D.26409;
      {
        if (__s2_len != 0) goto <D.26410>; else goto <D.26411>;
        <D.26410>:
        if (__result == 0) goto <D.26412>; else goto <D.26413>;
        <D.26412>:
        D.26414 = &MEM[(void *)"OverflowException" + 1B];
        D.26415 = *D.26414;
        D.26416 = (int) D.26415;
        D.26417 = __s2 + 1;
        D.26418 = *D.26417;
        D.26419 = (int) D.26418;
        __result = D.26416 - D.26419;
        if (__s2_len > 1) goto <D.26420>; else goto <D.26421>;
        <D.26420>:
        if (__result == 0) goto <D.26422>; else goto <D.26423>;
        <D.26422>:
        D.26424 = &MEM[(void *)"OverflowException" + 2B];
        D.26425 = *D.26424;
        D.26426 = (int) D.26425;
        D.26427 = __s2 + 2;
        D.26428 = *D.26427;
        D.26429 = (int) D.26428;
        __result = D.26426 - D.26429;
        if (__s2_len > 2) goto <D.26430>; else goto <D.26431>;
        <D.26430>:
        if (__result == 0) goto <D.26432>; else goto <D.26433>;
        <D.26432>:
        D.26434 = &MEM[(void *)"OverflowException" + 3B];
        D.26435 = *D.26434;
        D.26436 = (int) D.26435;
        D.26437 = __s2 + 3;
        D.26438 = *D.26437;
        D.26439 = (int) D.26438;
        __result = D.26436 - D.26439;
        <D.26433>:
        <D.26431>:
        <D.26423>:
        <D.26421>:
        <D.26413>:
        <D.26411>:
      }
      D.24179 = __result;
    }
    iftmp.76 = -D.24179;
    goto <D.26440>;
    <D.26404>:
    iftmp.76 = __builtin_strcmp (name, "OverflowException");
    <D.26440>:
    D.24180 = iftmp.76;
  }
  if (D.24180 == 0) goto <D.26441>; else goto <D.26442>;
  <D.26441>:
  D.26401 = 1;
  return D.26401;
  <D.26442>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.26446 = "ArithmeticException";
      D.26447 = MEM[(const unsigned char *)D.26446];
      D.26448 = (int) D.26447;
      D.26449 = *__s2;
      D.26450 = (int) D.26449;
      __result = D.26448 - D.26450;
      {
        if (__s2_len != 0) goto <D.26451>; else goto <D.26452>;
        <D.26451>:
        if (__result == 0) goto <D.26453>; else goto <D.26454>;
        <D.26453>:
        D.26455 = &MEM[(void *)"ArithmeticException" + 1B];
        D.26456 = *D.26455;
        D.26457 = (int) D.26456;
        D.26458 = __s2 + 1;
        D.26459 = *D.26458;
        D.26460 = (int) D.26459;
        __result = D.26457 - D.26460;
        if (__s2_len > 1) goto <D.26461>; else goto <D.26462>;
        <D.26461>:
        if (__result == 0) goto <D.26463>; else goto <D.26464>;
        <D.26463>:
        D.26465 = &MEM[(void *)"ArithmeticException" + 2B];
        D.26466 = *D.26465;
        D.26467 = (int) D.26466;
        D.26468 = __s2 + 2;
        D.26469 = *D.26468;
        D.26470 = (int) D.26469;
        __result = D.26467 - D.26470;
        if (__s2_len > 2) goto <D.26471>; else goto <D.26472>;
        <D.26471>:
        if (__result == 0) goto <D.26473>; else goto <D.26474>;
        <D.26473>:
        D.26475 = &MEM[(void *)"ArithmeticException" + 3B];
        D.26476 = *D.26475;
        D.26477 = (int) D.26476;
        D.26478 = __s2 + 3;
        D.26479 = *D.26478;
        D.26480 = (int) D.26479;
        __result = D.26477 - D.26480;
        <D.26474>:
        <D.26472>:
        <D.26464>:
        <D.26462>:
        <D.26454>:
        <D.26452>:
      }
      D.24188 = __result;
    }
    iftmp.77 = -D.24188;
    goto <D.26481>;
    <D.26445>:
    iftmp.77 = __builtin_strcmp (name, "ArithmeticException");
    <D.26481>:
    D.24189 = iftmp.77;
  }
  if (D.24189 == 0) goto <D.26482>; else goto <D.26483>;
  <D.26482>:
  D.26401 = 2;
  return D.26401;
  <D.26483>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.26487 = "DivideByZeroException";
      D.26488 = MEM[(const unsigned char *)D.26487];
      D.26489 = (int) D.26488;
      D.26490 = *__s2;
      D.26491 = (int) D.26490;
      __result = D.26489 - D.26491;
      {
        if (__s2_len != 0) goto <D.26492>; else goto <D.26493>;
        <D.26492>:
        if (__result == 0) goto <D.26494>; else goto <D.26495>;
        <D.26494>:
        D.26496 = &MEM[(void *)"DivideByZeroException" + 1B];
        D.26497 = *D.26496;
        D.26498 = (int) D.26497;
        D.26499 = __s2 + 1;
        D.26500 = *D.26499;
        D.26501 = (int) D.26500;
        __result = D.26498 - D.26501;
        if (__s2_len > 1) goto <D.26502>; else goto <D.26503>;
        <D.26502>:
        if (__result == 0) goto <D.26504>; else goto <D.26505>;
        <D.26504>:
        D.26506 = &MEM[(void *)"DivideByZeroException" + 2B];
        D.26507 = *D.26506;
        D.26508 = (int) D.26507;
        D.26509 = __s2 + 2;
        D.26510 = *D.26509;
        D.26511 = (int) D.26510;
        __result = D.26508 - D.26511;
        if (__s2_len > 2) goto <D.26512>; else goto <D.26513>;
        <D.26512>:
        if (__result == 0) goto <D.26514>; else goto <D.26515>;
        <D.26514>:
        D.26516 = &MEM[(void *)"DivideByZeroException" + 3B];
        D.26517 = *D.26516;
        D.26518 = (int) D.26517;
        D.26519 = __s2 + 3;
        D.26520 = *D.26519;
        D.26521 = (int) D.26520;
        __result = D.26518 - D.26521;
        <D.26515>:
        <D.26513>:
        <D.26505>:
        <D.26503>:
        <D.26495>:
        <D.26493>:
      }
      D.24197 = __result;
    }
    iftmp.78 = -D.24197;
    goto <D.26522>;
    <D.26486>:
    iftmp.78 = __builtin_strcmp (name, "DivideByZeroException");
    <D.26522>:
    D.24198 = iftmp.78;
  }
  if (D.24198 == 0) goto <D.26523>; else goto <D.26524>;
  <D.26523>:
  D.26401 = 3;
  return D.26401;
  <D.26524>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.26528 = "InvalidCastException";
      D.26529 = MEM[(const unsigned char *)D.26528];
      D.26530 = (int) D.26529;
      D.26531 = *__s2;
      D.26532 = (int) D.26531;
      __result = D.26530 - D.26532;
      {
        if (__s2_len != 0) goto <D.26533>; else goto <D.26534>;
        <D.26533>:
        if (__result == 0) goto <D.26535>; else goto <D.26536>;
        <D.26535>:
        D.26537 = &MEM[(void *)"InvalidCastException" + 1B];
        D.26538 = *D.26537;
        D.26539 = (int) D.26538;
        D.26540 = __s2 + 1;
        D.26541 = *D.26540;
        D.26542 = (int) D.26541;
        __result = D.26539 - D.26542;
        if (__s2_len > 1) goto <D.26543>; else goto <D.26544>;
        <D.26543>:
        if (__result == 0) goto <D.26545>; else goto <D.26546>;
        <D.26545>:
        D.26547 = &MEM[(void *)"InvalidCastException" + 2B];
        D.26548 = *D.26547;
        D.26549 = (int) D.26548;
        D.26550 = __s2 + 2;
        D.26551 = *D.26550;
        D.26552 = (int) D.26551;
        __result = D.26549 - D.26552;
        if (__s2_len > 2) goto <D.26553>; else goto <D.26554>;
        <D.26553>:
        if (__result == 0) goto <D.26555>; else goto <D.26556>;
        <D.26555>:
        D.26557 = &MEM[(void *)"InvalidCastException" + 3B];
        D.26558 = *D.26557;
        D.26559 = (int) D.26558;
        D.26560 = __s2 + 3;
        D.26561 = *D.26560;
        D.26562 = (int) D.26561;
        __result = D.26559 - D.26562;
        <D.26556>:
        <D.26554>:
        <D.26546>:
        <D.26544>:
        <D.26536>:
        <D.26534>:
      }
      D.24206 = __result;
    }
    iftmp.79 = -D.24206;
    goto <D.26563>;
    <D.26527>:
    iftmp.79 = __builtin_strcmp (name, "InvalidCastException");
    <D.26563>:
    D.24207 = iftmp.79;
  }
  if (D.24207 == 0) goto <D.26564>; else goto <D.26565>;
  <D.26564>:
  D.26401 = 4;
  return D.26401;
  <D.26565>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.26569 = "NullReferenceException";
      D.26570 = MEM[(const unsigned char *)D.26569];
      D.26571 = (int) D.26570;
      D.26572 = *__s2;
      D.26573 = (int) D.26572;
      __result = D.26571 - D.26573;
      {
        if (__s2_len != 0) goto <D.26574>; else goto <D.26575>;
        <D.26574>:
        if (__result == 0) goto <D.26576>; else goto <D.26577>;
        <D.26576>:
        D.26578 = &MEM[(void *)"NullReferenceException" + 1B];
        D.26579 = *D.26578;
        D.26580 = (int) D.26579;
        D.26581 = __s2 + 1;
        D.26582 = *D.26581;
        D.26583 = (int) D.26582;
        __result = D.26580 - D.26583;
        if (__s2_len > 1) goto <D.26584>; else goto <D.26585>;
        <D.26584>:
        if (__result == 0) goto <D.26586>; else goto <D.26587>;
        <D.26586>:
        D.26588 = &MEM[(void *)"NullReferenceException" + 2B];
        D.26589 = *D.26588;
        D.26590 = (int) D.26589;
        D.26591 = __s2 + 2;
        D.26592 = *D.26591;
        D.26593 = (int) D.26592;
        __result = D.26590 - D.26593;
        if (__s2_len > 2) goto <D.26594>; else goto <D.26595>;
        <D.26594>:
        if (__result == 0) goto <D.26596>; else goto <D.26597>;
        <D.26596>:
        D.26598 = &MEM[(void *)"NullReferenceException" + 3B];
        D.26599 = *D.26598;
        D.26600 = (int) D.26599;
        D.26601 = __s2 + 3;
        D.26602 = *D.26601;
        D.26603 = (int) D.26602;
        __result = D.26600 - D.26603;
        <D.26597>:
        <D.26595>:
        <D.26587>:
        <D.26585>:
        <D.26577>:
        <D.26575>:
      }
      D.24215 = __result;
    }
    iftmp.80 = -D.24215;
    goto <D.26604>;
    <D.26568>:
    iftmp.80 = __builtin_strcmp (name, "NullReferenceException");
    <D.26604>:
    D.24216 = iftmp.80;
  }
  if (D.24216 == 0) goto <D.26605>; else goto <D.26606>;
  <D.26605>:
  D.26401 = 5;
  return D.26401;
  <D.26606>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.26610 = "ArrayTypeMismatchException";
      D.26611 = MEM[(const unsigned char *)D.26610];
      D.26612 = (int) D.26611;
      D.26613 = *__s2;
      D.26614 = (int) D.26613;
      __result = D.26612 - D.26614;
      {
        if (__s2_len != 0) goto <D.26615>; else goto <D.26616>;
        <D.26615>:
        if (__result == 0) goto <D.26617>; else goto <D.26618>;
        <D.26617>:
        D.26619 = &MEM[(void *)"ArrayTypeMismatchException" + 1B];
        D.26620 = *D.26619;
        D.26621 = (int) D.26620;
        D.26622 = __s2 + 1;
        D.26623 = *D.26622;
        D.26624 = (int) D.26623;
        __result = D.26621 - D.26624;
        if (__s2_len > 1) goto <D.26625>; else goto <D.26626>;
        <D.26625>:
        if (__result == 0) goto <D.26627>; else goto <D.26628>;
        <D.26627>:
        D.26629 = &MEM[(void *)"ArrayTypeMismatchException" + 2B];
        D.26630 = *D.26629;
        D.26631 = (int) D.26630;
        D.26632 = __s2 + 2;
        D.26633 = *D.26632;
        D.26634 = (int) D.26633;
        __result = D.26631 - D.26634;
        if (__s2_len > 2) goto <D.26635>; else goto <D.26636>;
        <D.26635>:
        if (__result == 0) goto <D.26637>; else goto <D.26638>;
        <D.26637>:
        D.26639 = &MEM[(void *)"ArrayTypeMismatchException" + 3B];
        D.26640 = *D.26639;
        D.26641 = (int) D.26640;
        D.26642 = __s2 + 3;
        D.26643 = *D.26642;
        D.26644 = (int) D.26643;
        __result = D.26641 - D.26644;
        <D.26638>:
        <D.26636>:
        <D.26628>:
        <D.26626>:
        <D.26618>:
        <D.26616>:
      }
      D.24224 = __result;
    }
    iftmp.81 = -D.24224;
    goto <D.26645>;
    <D.26609>:
    iftmp.81 = __builtin_strcmp (name, "ArrayTypeMismatchException");
    <D.26645>:
    D.24225 = iftmp.81;
  }
  if (D.24225 == 0) goto <D.26646>; else goto <D.26647>;
  <D.26646>:
  D.26401 = 6;
  return D.26401;
  <D.26647>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.26651 = "ArgumentException";
      D.26652 = MEM[(const unsigned char *)D.26651];
      D.26653 = (int) D.26652;
      D.26654 = *__s2;
      D.26655 = (int) D.26654;
      __result = D.26653 - D.26655;
      {
        if (__s2_len != 0) goto <D.26656>; else goto <D.26657>;
        <D.26656>:
        if (__result == 0) goto <D.26658>; else goto <D.26659>;
        <D.26658>:
        D.26660 = &MEM[(void *)"ArgumentException" + 1B];
        D.26661 = *D.26660;
        D.26662 = (int) D.26661;
        D.26663 = __s2 + 1;
        D.26664 = *D.26663;
        D.26665 = (int) D.26664;
        __result = D.26662 - D.26665;
        if (__s2_len > 1) goto <D.26666>; else goto <D.26667>;
        <D.26666>:
        if (__result == 0) goto <D.26668>; else goto <D.26669>;
        <D.26668>:
        D.26670 = &MEM[(void *)"ArgumentException" + 2B];
        D.26671 = *D.26670;
        D.26672 = (int) D.26671;
        D.26673 = __s2 + 2;
        D.26674 = *D.26673;
        D.26675 = (int) D.26674;
        __result = D.26672 - D.26675;
        if (__s2_len > 2) goto <D.26676>; else goto <D.26677>;
        <D.26676>:
        if (__result == 0) goto <D.26678>; else goto <D.26679>;
        <D.26678>:
        D.26680 = &MEM[(void *)"ArgumentException" + 3B];
        D.26681 = *D.26680;
        D.26682 = (int) D.26681;
        D.26683 = __s2 + 3;
        D.26684 = *D.26683;
        D.26685 = (int) D.26684;
        __result = D.26682 - D.26685;
        <D.26679>:
        <D.26677>:
        <D.26669>:
        <D.26667>:
        <D.26659>:
        <D.26657>:
      }
      D.24233 = __result;
    }
    iftmp.82 = -D.24233;
    goto <D.26686>;
    <D.26650>:
    iftmp.82 = __builtin_strcmp (name, "ArgumentException");
    <D.26686>:
    D.24234 = iftmp.82;
  }
  if (D.24234 == 0) goto <D.26687>; else goto <D.26688>;
  <D.26687>:
  D.26401 = 7;
  return D.26401;
  <D.26688>:
  monoeg_g_log (0B, 4, "Unknown intrinsic exception %s\n", name);
  <D.24235>:
  goto <D.24235>;
  D.26401 = -1;
  return D.26401;
}