mono_arch_flush_icache (guint8 * code, gint size)
{
  cacheflush (code, size, 3);
}


mono_arch_flush_register_windows ()
{

}


mono_arch_is_inst_imm (gint64 imm)
{
  gboolean D.23415;

  D.23415 = 1;
  return D.23415;
}


mips_emit_load_const (guint8 * code, int dreg, mgreg_t v)
{
  short int D.23417;
  int D.23418;
  int D.23421;
  unsigned int D.23422;
  unsigned int v.0;
  unsigned int D.23424;
  unsigned int D.23425;
  unsigned int D.23426;
  unsigned int D.23428;
  unsigned int D.23431;
  unsigned int D.23432;
  unsigned int D.23433;
  unsigned int D.23434;
  unsigned int D.23435;
  unsigned int D.23437;
  unsigned int D.23438;
  int D.23441;
  int D.23442;
  int D.23443;
  unsigned int D.23444;
  unsigned int D.23445;
  guint8 * D.23446;

  D.23417 = (short int) v;
  D.23418 = (int) D.23417;
  if (D.23418 == v) goto <D.23419>; else goto <D.23420>;
  <D.23419>:
  D.23421 = dreg << 16;
  D.23422 = (unsigned int) D.23421;
  v.0 = (unsigned int) v;
  D.23424 = v.0 & 65535;
  D.23425 = D.23422 | D.23424;
  D.23426 = D.23425 | 603979776;
  MEM[(guint32 *)code] = D.23426;
  code = code + 4;
  goto <D.23427>;
  <D.23420>:
  v.0 = (unsigned int) v;
  D.23428 = v.0 & 32768;
  if (D.23428 != 0) goto <D.23429>; else goto <D.23430>;
  <D.23429>:
  D.23421 = dreg << 16;
  D.23422 = (unsigned int) D.23421;
  v.0 = (unsigned int) v;
  D.23431 = v.0 >> 16;
  D.23432 = D.23431 + 1;
  D.23433 = D.23432 & 65535;
  D.23434 = D.23422 | D.23433;
  D.23435 = D.23434 | 1006632960;
  MEM[(guint32 *)code] = D.23435;
  code = code + 4;
  goto <D.23436>;
  <D.23430>:
  D.23421 = dreg << 16;
  D.23422 = (unsigned int) D.23421;
  v.0 = (unsigned int) v;
  D.23431 = v.0 >> 16;
  D.23437 = D.23422 | D.23431;
  D.23438 = D.23437 | 1006632960;
  MEM[(guint32 *)code] = D.23438;
  code = code + 4;
  <D.23436>:
  v.0 = (unsigned int) v;
  D.23424 = v.0 & 65535;
  if (D.23424 != 0) goto <D.23439>; else goto <D.23440>;
  <D.23439>:
  D.23441 = dreg << 21;
  D.23442 = D.23441 | 603979776;
  D.23421 = dreg << 16;
  D.23443 = D.23442 | D.23421;
  D.23444 = (unsigned int) D.23443;
  v.0 = (unsigned int) v;
  D.23424 = v.0 & 65535;
  D.23445 = D.23444 | D.23424;
  MEM[(guint32 *)code] = D.23445;
  code = code + 4;
  <D.23440>:
  <D.23427>:
  D.23446 = code;
  return D.23446;
}


mips_emit_cond_branch (struct MonoCompile * cfg, guint8 * code, int op, struct MonoInst * ins)
{
  _Bool D.23448;
  long int D.23449;
  long int D.23450;
  unsigned int D.23453;
  int D.23456;
  int D.23457;
  int D.23458;
  int D.23459;
  int D.23460;
  int D.23461;
  int D.23462;
  int D.23463;
  unsigned int D.23464;
  int D.23465;
  int D.23466;
  int D.23467;
  unsigned int D.23468;
  int D.23469;
  int D.23470;
  unsigned int D.23471;
  int D.23472;
  int D.23473;
  unsigned int D.23474;
  int D.23475;
  int D.23476;
  unsigned int D.23477;
  int D.23478;
  int D.23479;
  unsigned int D.23480;
  int code.1;
  unsigned char * D.23482;
  int D.23483;
  int D.23484;
  struct MonoBasicBlock * * D.23485;
  struct MonoBasicBlock * D.23486;
  unsigned int D.23488;
  unsigned int D.23489;
  unsigned int D.23490;
  unsigned int D.23491;
  unsigned int D.23492;
  unsigned int D.23493;
  guint8 * D.23494;

  D.23448 = ins == 0B;
  D.23449 = (long int) D.23448;
  D.23450 = __builtin_expect (D.23449, 0);
  if (D.23450 != 0) goto <D.23451>; else goto <D.23452>;
  <D.23451>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 266, "ins");
  <D.23452>:
  D.23453 = cfg->arch.long_branch;
  if (D.23453 != 0) goto <D.23454>; else goto <D.23455>;
  <D.23454>:
  {
    int br_offset;

    br_offset = 5;
    switch (op) <default: <D.21723>, case 842: <D.21716>, case 843: <D.21719>, case 844: <D.21720>, case 845: <D.21721>, case 846: <D.21722>, case 847: <D.21718>>
    <D.21716>:
    D.23456 = ins->sreg1;
    D.23457 = D.23456 << 21;
    D.23458 = D.23457 | 335544320;
    D.23459 = ins->sreg2;
    D.23460 = D.23459 << 16;
    D.23461 = D.23458 | D.23460;
    D.23462 = br_offset & 65535;
    D.23463 = D.23461 | D.23462;
    D.23464 = (unsigned int) D.23463;
    MEM[(guint32 *)code] = D.23464;
    code = code + 4;
    MEM[(guint32 *)code] = 2099237;
    code = code + 4;
    goto <D.21717>;
    <D.21718>:
    D.23456 = ins->sreg1;
    D.23457 = D.23456 << 21;
    D.23465 = D.23457 | 268435456;
    D.23459 = ins->sreg2;
    D.23460 = D.23459 << 16;
    D.23466 = D.23465 | D.23460;
    D.23462 = br_offset & 65535;
    D.23467 = D.23466 | D.23462;
    D.23468 = (unsigned int) D.23467;
    MEM[(guint32 *)code] = D.23468;
    code = code + 4;
    MEM[(guint32 *)code] = 2099237;
    code = code + 4;
    goto <D.21717>;
    <D.21719>:
    D.23456 = ins->sreg1;
    D.23457 = D.23456 << 21;
    D.23469 = D.23457 | 67108864;
    D.23462 = br_offset & 65535;
    D.23470 = D.23469 | D.23462;
    D.23471 = (unsigned int) D.23470;
    MEM[(guint32 *)code] = D.23471;
    code = code + 4;
    MEM[(guint32 *)code] = 2099237;
    code = code + 4;
    goto <D.21717>;
    <D.21720>:
    D.23456 = ins->sreg1;
    D.23457 = D.23456 << 21;
    D.23472 = D.23457 | 402653184;
    D.23462 = br_offset & 65535;
    D.23473 = D.23472 | D.23462;
    D.23474 = (unsigned int) D.23473;
    MEM[(guint32 *)code] = D.23474;
    code = code + 4;
    MEM[(guint32 *)code] = 2099237;
    code = code + 4;
    goto <D.21717>;
    <D.21721>:
    D.23456 = ins->sreg1;
    D.23457 = D.23456 << 21;
    D.23475 = D.23457 | 469762048;
    D.23462 = br_offset & 65535;
    D.23476 = D.23475 | D.23462;
    D.23477 = (unsigned int) D.23476;
    MEM[(guint32 *)code] = D.23477;
    code = code + 4;
    MEM[(guint32 *)code] = 2099237;
    code = code + 4;
    goto <D.21717>;
    <D.21722>:
    D.23456 = ins->sreg1;
    D.23457 = D.23456 << 21;
    D.23478 = D.23457 | 67174400;
    D.23462 = br_offset & 65535;
    D.23479 = D.23478 | D.23462;
    D.23480 = (unsigned int) D.23479;
    MEM[(guint32 *)code] = D.23480;
    code = code + 4;
    MEM[(guint32 *)code] = 2099237;
    code = code + 4;
    goto <D.21717>;
    <D.21723>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-mips.c", 297);
    <D.21717>:
    code.1 = (int) code;
    D.23482 = cfg->native_code;
    D.23483 = (int) D.23482;
    D.23484 = code.1 - D.23483;
    D.23485 = ins->data.op[1].many_blocks;
    D.23486 = *D.23485;
    mono_add_patch_info (cfg, D.23484, 0, D.23486);
    MEM[(guint32 *)code] = 1006698496;
    code = code + 4;
    MEM[(guint32 *)code] = 606142464;
    code = code + 4;
    MEM[(guint32 *)code] = 2097160;
    code = code + 4;
    MEM[(guint32 *)code] = 2099237;
    code = code + 4;
  }
  goto <D.23487>;
  <D.23455>:
  code.1 = (int) code;
  D.23482 = cfg->native_code;
  D.23483 = (int) D.23482;
  D.23484 = code.1 - D.23483;
  D.23485 = ins->data.op[1].many_blocks;
  D.23486 = *D.23485;
  mono_add_patch_info (cfg, D.23484, 0, D.23486);
  switch (op) <default: <D.21731>, case 842: <D.21724>, case 843: <D.21727>, case 844: <D.21728>, case 845: <D.21729>, case 846: <D.21730>, case 847: <D.21726>>
  <D.21724>:
  D.23456 = ins->sreg1;
  D.23457 = D.23456 << 21;
  D.23465 = D.23457 | 268435456;
  D.23459 = ins->sreg2;
  D.23460 = D.23459 << 16;
  D.23466 = D.23465 | D.23460;
  D.23488 = (unsigned int) D.23466;
  MEM[(guint32 *)code] = D.23488;
  code = code + 4;
  MEM[(guint32 *)code] = 2099237;
  code = code + 4;
  goto <D.21725>;
  <D.21726>:
  D.23456 = ins->sreg1;
  D.23457 = D.23456 << 21;
  D.23458 = D.23457 | 335544320;
  D.23459 = ins->sreg2;
  D.23460 = D.23459 << 16;
  D.23461 = D.23458 | D.23460;
  D.23489 = (unsigned int) D.23461;
  MEM[(guint32 *)code] = D.23489;
  code = code + 4;
  MEM[(guint32 *)code] = 2099237;
  code = code + 4;
  goto <D.21725>;
  <D.21727>:
  D.23456 = ins->sreg1;
  D.23457 = D.23456 << 21;
  D.23478 = D.23457 | 67174400;
  D.23490 = (unsigned int) D.23478;
  MEM[(guint32 *)code] = D.23490;
  code = code + 4;
  MEM[(guint32 *)code] = 2099237;
  code = code + 4;
  goto <D.21725>;
  <D.21728>:
  D.23456 = ins->sreg1;
  D.23457 = D.23456 << 21;
  D.23475 = D.23457 | 469762048;
  D.23491 = (unsigned int) D.23475;
  MEM[(guint32 *)code] = D.23491;
  code = code + 4;
  MEM[(guint32 *)code] = 2099237;
  code = code + 4;
  goto <D.21725>;
  <D.21729>:
  D.23456 = ins->sreg1;
  D.23457 = D.23456 << 21;
  D.23472 = D.23457 | 402653184;
  D.23492 = (unsigned int) D.23472;
  MEM[(guint32 *)code] = D.23492;
  code = code + 4;
  MEM[(guint32 *)code] = 2099237;
  code = code + 4;
  goto <D.21725>;
  <D.21730>:
  D.23456 = ins->sreg1;
  D.23457 = D.23456 << 21;
  D.23469 = D.23457 | 67108864;
  D.23493 = (unsigned int) D.23469;
  MEM[(guint32 *)code] = D.23493;
  code = code + 4;
  MEM[(guint32 *)code] = 2099237;
  code = code + 4;
  goto <D.21725>;
  <D.21731>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-mips.c", 335);
  <D.21725>:
  <D.23487>:
  D.23494 = code;
  return D.23494;
}


patch_lui_addiu (guint32 * ip, guint32 val)
{
  unsigned int D.23496;
  unsigned int D.23499;
  short unsigned int D.23500;
  short unsigned int D.23501;
  guint16 * D.23503;
  short unsigned int D.23504;
  guint16 * __lui_addiu;

  __lui_addiu = ip;
  D.23496 = val & 32768;
  if (D.23496 != 0) goto <D.23497>; else goto <D.23498>;
  <D.23497>:
  D.23499 = val >> 16;
  D.23500 = (short unsigned int) D.23499;
  D.23501 = D.23500 + 1;
  *__lui_addiu = D.23501;
  goto <D.23502>;
  <D.23498>:
  D.23499 = val >> 16;
  D.23500 = (short unsigned int) D.23499;
  *__lui_addiu = D.23500;
  <D.23502>:
  D.23503 = __lui_addiu + 4;
  D.23504 = (short unsigned int) val;
  *D.23503 = D.23504;
  mono_arch_flush_icache (ip, 8);
}


mips_patch (guint32 * code, guint32 target)
{
  unsigned int trap_target.2;
  _Bool D.23506;
  long int D.23507;
  long int D.23508;
  unsigned int D.23512;
  _Bool D.23513;
  long int D.23514;
  long int D.23515;
  unsigned int code.3;
  unsigned int D.23519;
  unsigned int D.23520;
  _Bool D.23521;
  long int D.23522;
  long int D.23523;
  unsigned int D.23526;
  unsigned int D.23527;
  unsigned int D.23528;
  guint32 * D.23529;
  unsigned int D.23530;
  int iftmp.4;
  unsigned int D.23534;
  unsigned int D.23536;
  _Bool D.23538;
  long int D.23539;
  long int D.23540;
  unsigned int D.23543;
  _Bool D.23544;
  long int D.23545;
  long int D.23546;
  int diff.5;
  int D.23550;
  int offset.6;
  short int D.23552;
  int D.23553;
  _Bool D.23556;
  long int D.23557;
  long int D.23558;
  unsigned int D.23561;
  unsigned int D.23562;
  unsigned int D.23563;
  unsigned int D.23564;
  _Bool D.23565;
  long int D.23566;
  long int D.23567;
  guint32 ins;
  guint32 op;
  guint32 diff;
  guint32 offset;

  ins = *code;
  op = ins >> 26;
  trap_target.2 = trap_target;
  D.23506 = trap_target.2 == target;
  D.23507 = (long int) D.23506;
  D.23508 = __builtin_expect (D.23507, 0);
  if (D.23508 != 0) goto <D.23509>; else goto <D.23510>;
  <D.23509>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 368, "trap_target != target");
  <D.23510>:
  switch (op) <default: <D.21757>, case 0: <D.21746>, case 1: <D.21750>, case 2: <D.21748>, case 3: <D.21749>, case 4: <D.21751>, case 5: <D.21752>, case 6: <D.21753>, case 7: <D.21754>, case 15: <D.21756>, case 17: <D.21755>>
  <D.21746>:
  if (ins == 65011720) goto <D.21747>; else goto <D.23511>;
  <D.23511>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-mips.c", 374);
  <D.21748>:
  <D.21749>:
  D.23512 = target & 3;
  D.23513 = D.23512 != 0;
  D.23514 = (long int) D.23513;
  D.23515 = __builtin_expect (D.23514, 0);
  if (D.23515 != 0) goto <D.23516>; else goto <D.23517>;
  <D.23516>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 378, "!(target & 0x03)");
  <D.23517>:
  code.3 = (unsigned int) code;
  D.23519 = target ^ code.3;
  D.23520 = D.23519 & 4227858432;
  D.23521 = D.23520 != 0;
  D.23522 = (long int) D.23521;
  D.23523 = __builtin_expect (D.23522, 0);
  if (D.23523 != 0) goto <D.23524>; else goto <D.23525>;
  <D.23524>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 379, "(target & 0xfc000000) == (((guint32)code) & 0xfc000000)");
  <D.23525>:
  D.23526 = ins & 4227858432;
  D.23527 = target >> 2;
  D.23528 = D.23527 & 67108863;
  ins = D.23526 | D.23528;
  *code = ins;
  mono_arch_flush_icache (code, 4);
  goto <D.21747>;
  <D.21750>:
  <D.21751>:
  <D.21752>:
  <D.21753>:
  <D.21754>:
  <D.21755>:
  D.23529 = code + 4;
  D.23530 = (unsigned int) D.23529;
  diff = target - D.23530;
  D.23534 = diff & 262143;
  if (D.23534 != diff) goto <D.23535>; else goto <D.23532>;
  <D.23535>:
  D.23536 = diff | 4294705152;
  if (D.23536 != diff) goto <D.23537>; else goto <D.23532>;
  <D.23537>:
  iftmp.4 = 1;
  goto <D.23533>;
  <D.23532>:
  iftmp.4 = 0;
  <D.23533>:
  D.23538 = iftmp.4 != 0;
  D.23539 = (long int) D.23538;
  D.23540 = __builtin_expect (D.23539, 0);
  if (D.23540 != 0) goto <D.23541>; else goto <D.23542>;
  <D.23541>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 391, "((diff & 0x0003ffff) == diff) || ((diff | 0xfffc0000) == diff)");
  <D.23542>:
  D.23543 = diff & 3;
  D.23544 = D.23543 != 0;
  D.23545 = (long int) D.23544;
  D.23546 = __builtin_expect (D.23545, 0);
  if (D.23546 != 0) goto <D.23547>; else goto <D.23548>;
  <D.23547>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 392, "!(diff & 0x03)");
  <D.23548>:
  diff.5 = (int) diff;
  D.23550 = diff.5 >> 2;
  offset = (guint32) D.23550;
  offset.6 = (int) offset;
  D.23552 = (short int) offset;
  D.23553 = (int) D.23552;
  if (offset.6 != D.23553) goto <D.23554>; else goto <D.23555>;
  <D.23554>:
  offset.6 = (int) offset;
  D.23552 = (short int) offset;
  D.23553 = (int) D.23552;
  D.23556 = offset.6 != D.23553;
  D.23557 = (long int) D.23556;
  D.23558 = __builtin_expect (D.23557, 0);
  if (D.23558 != 0) goto <D.23559>; else goto <D.23560>;
  <D.23559>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 395, "((int)offset) == ((int)(short)offset)");
  <D.23560>:
  <D.23555>:
  D.23561 = ins & 4294901760;
  D.23562 = offset & 65535;
  ins = D.23561 | D.23562;
  *code = ins;
  mono_arch_flush_icache (code, 4);
  goto <D.21747>;
  <D.21756>:
  D.23529 = code + 4;
  D.23563 = *D.23529;
  D.23564 = D.23563 >> 26;
  D.23565 = D.23564 != 9;
  D.23566 = (long int) D.23565;
  D.23567 = __builtin_expect (D.23566, 0);
  if (D.23567 != 0) goto <D.23568>; else goto <D.23569>;
  <D.23568>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 401, "(code[1] >> 26) == 0x9");
  <D.23569>:
  patch_lui_addiu (code, target);
  mono_arch_flush_icache (code, 8);
  goto <D.21747>;
  <D.21757>:
  printf ("unknown op 0x%02x (0x%08x) @ %p\n", op, ins, code);
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-mips.c", 408);
  <D.21747>:
}


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

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


mono_arch_regname (int reg)
{
  unsigned int reg.7;
  const char * D.23575;
  static const char * rnames[32] = {(const char *) "zero", (const char *) "at", (const char *) "v0", (const char *) "v1", (const char *) "a0", (const char *) "a1", (const char *) "a2", (const char *) "a3", (const char *) "t0", (const char *) "t1", (const char *) "t2", (const char *) "t3", (const char *) "t4", (const char *) "t5", (const char *) "t6", (const char *) "t7", (const char *) "s0", (const char *) "s1", (const char *) "s2", (const char *) "s3", (const char *) "s4", (const char *) "s5", (const char *) "s6", (const char *) "s7", (const char *) "t8", (const char *) "t9", (const char *) "k0", (const char *) "k1", (const char *) "gp", (const char *) "sp", (const char *) "fp", (const char *) "ra"};

  reg.7 = (unsigned int) reg;
  if (reg.7 <= 31) goto <D.23573>; else goto <D.23574>;
  <D.23573>:
  D.23575 = rnames[reg];
  return D.23575;
  <D.23574>:
  D.23575 = "unknown";
  return D.23575;
}


mono_arch_fregname (int reg)
{
  unsigned int reg.8;
  const char * D.23580;
  static const char * rnames[32] = {(const char *) "f0", (const char *) "f1", (const char *) "f2", (const char *) "f3", (const char *) "f4", (const char *) "f5", (const char *) "f6", (const char *) "f7", (const char *) "f8", (const char *) "f9", (const char *) "f10", (const char *) "f11", (const char *) "f12", (const char *) "f13", (const char *) "f14", (const char *) "f15", (const char *) "f16", (const char *) "f17", (const char *) "f18", (const char *) "f19", (const char *) "f20", (const char *) "f21", (const char *) "f22", (const char *) "f23", (const char *) "f24", (const char *) "f25", (const char *) "f26", (const char *) "f27", (const char *) "f28", (const char *) "f29", (const char *) "f30", (const char *) "f31"};

  reg.8 = (unsigned int) reg;
  if (reg.8 <= 31) goto <D.23578>; else goto <D.23579>;
  <D.23578>:
  D.23580 = rnames[reg];
  return D.23580;
  <D.23579>:
  D.23580 = "unknown";
  return D.23580;
}


mono_arch_get_argument_info (struct MonoGenericSharingContext * gsctx, struct MonoMethodSignature * csig, int param_count, struct MonoJitArgumentInfo * arg_info)
{
  struct MonoType * D.23582;
  int D.23583;
  unsigned int frame_size.9;
  unsigned int D.23587;
  short unsigned int D.23588;
  unsigned int D.23589;
  unsigned int D.23590;
  short unsigned int D.23593;
  struct MonoType * D.23594;
  <unnamed-unsigned:1> D.23595;
  int D.23596;
  int D.23597;
  unsigned int align.10;
  unsigned int D.23599;
  unsigned int frame_size.11;
  unsigned int D.23601;
  unsigned int D.23602;
  unsigned int pad.12;
  unsigned int D.23604;
  unsigned int k.13;
  unsigned int D.23606;
  struct MonoJitArgumentInfo * D.23607;
  unsigned char D.23608;
  unsigned int D.23609;
  sizetype k.14;
  sizetype D.23611;
  sizetype D.23612;
  struct MonoJitArgumentInfo * D.23613;
  short unsigned int D.23614;
  unsigned int offset.15;
  unsigned int D.23616;
  unsigned int D.23617;
  unsigned int pad.16;
  unsigned int D.23619;
  int D.23620;
  int k;
  int frame_size;
  guint32 size;
  guint32 align;
  guint32 pad;
  int offset;

  try
    {
      frame_size = 0;
      offset = 0;
      D.23582 = csig->ret;
      D.23583 = mono_type_is_struct (D.23582);
      if (D.23583 != 0) goto <D.23584>; else goto <D.23585>;
      <D.23584>:
      frame_size.9 = (unsigned int) frame_size;
      D.23587 = frame_size.9 + 4;
      frame_size = (int) D.23587;
      offset = offset + 4;
      <D.23585>:
      D.23588 = (short unsigned int) offset;
      arg_info->offset = D.23588;
      D.23589 = BIT_FIELD_REF <*csig, 32, 64>;
      D.23590 = D.23589 & 4194304;
      if (D.23590 != 0) goto <D.23591>; else goto <D.23592>;
      <D.23591>:
      frame_size.9 = (unsigned int) frame_size;
      D.23587 = frame_size.9 + 4;
      frame_size = (int) D.23587;
      offset = offset + 4;
      <D.23592>:
      D.23593 = (short unsigned int) frame_size;
      arg_info->size = D.23593;
      k = 0;
      goto <D.21792>;
      <D.21791>:
      D.23594 = csig->params[k];
      D.23595 = csig->pinvoke;
      D.23596 = (int) D.23595;
      D.23597 = mini_type_stack_size_full (0B, D.23594, &align, D.23596);
      size = (guint32) D.23597;
      align = 1;
      align.10 = align;
      align.10 = align;
      D.23599 = align.10 + 4294967295;
      frame_size.11 = (unsigned int) frame_size;
      D.23601 = D.23599 & frame_size.11;
      D.23602 = align.10 - D.23601;
      align.10 = align;
      D.23599 = align.10 + 4294967295;
      pad = D.23602 & D.23599;
      pad.12 = pad;
      frame_size.11 = (unsigned int) frame_size;
      D.23604 = pad.12 + frame_size.11;
      frame_size = (int) D.23604;
      k.13 = (unsigned int) k;
      D.23606 = k.13 * 6;
      D.23607 = arg_info + D.23606;
      D.23608 = (unsigned char) pad;
      D.23607->pad = D.23608;
      frame_size.11 = (unsigned int) frame_size;
      D.23609 = frame_size.11 + size;
      frame_size = (int) D.23609;
      k.14 = (sizetype) k;
      D.23611 = k.14 + 1;
      D.23612 = D.23611 * 6;
      D.23613 = arg_info + D.23612;
      D.23613->pad = 0;
      k.14 = (sizetype) k;
      D.23611 = k.14 + 1;
      D.23612 = D.23611 * 6;
      D.23613 = arg_info + D.23612;
      D.23614 = (short unsigned int) size;
      D.23613->size = D.23614;
      offset.15 = (unsigned int) offset;
      D.23616 = offset.15 + pad;
      offset = (int) D.23616;
      k.14 = (sizetype) k;
      D.23611 = k.14 + 1;
      D.23612 = D.23611 * 6;
      D.23613 = arg_info + D.23612;
      D.23588 = (short unsigned int) offset;
      D.23613->offset = D.23588;
      offset.15 = (unsigned int) offset;
      D.23617 = offset.15 + size;
      offset = (int) D.23617;
      k = k + 1;
      <D.21792>:
      if (k < param_count) goto <D.21791>; else goto <D.21793>;
      <D.21793>:
      align = 8;
      align.10 = align;
      align.10 = align;
      D.23599 = align.10 + 4294967295;
      frame_size.11 = (unsigned int) frame_size;
      D.23601 = D.23599 & frame_size.11;
      D.23602 = align.10 - D.23601;
      align.10 = align;
      D.23599 = align.10 + 4294967295;
      pad = D.23602 & D.23599;
      pad.16 = pad;
      frame_size.11 = (unsigned int) frame_size;
      D.23619 = pad.16 + frame_size.11;
      frame_size = (int) D.23619;
      k.13 = (unsigned int) k;
      D.23606 = k.13 * 6;
      D.23607 = arg_info + D.23606;
      D.23608 = (unsigned char) pad;
      D.23607->pad = D.23608;
      D.23620 = frame_size;
      return D.23620;
    }
  finally
    {
      align = {CLOBBER};
    }
}


mono_arch_get_delegate_invoke_impls ()
{
  unsigned int code_len.17;
  struct MonoTrampInfo * D.23624;
  struct MonoTrampInfo * D.23625;
  struct GSList * D.23626;
  struct GSList * res;
  guint8 * code;
  guint32 code_len;
  int i;
  char * tramp_name;

  try
    {
      res = 0B;
      code = get_delegate_invoke_impl (1, 0, &code_len);
      code_len.17 = code_len;
      D.23624 = mono_tramp_info_create ("delegate_invoke_impl_has_target", code, code_len.17, 0B, 0B);
      res = monoeg_g_slist_prepend (res, D.23624);
      i = 0;
      goto <D.21815>;
      <D.21814>:
      code = get_delegate_invoke_impl (0, i, &code_len);
      tramp_name = monoeg_g_strdup_printf ("delegate_invoke_impl_target_%d", i);
      code_len.17 = code_len;
      D.23625 = mono_tramp_info_create (tramp_name, code, code_len.17, 0B, 0B);
      res = monoeg_g_slist_prepend (res, D.23625);
      monoeg_g_free (tramp_name);
      i = i + 1;
      <D.21815>:
      if (i <= 3) goto <D.21814>; else goto <D.21816>;
      <D.21816>:
      D.23626 = res;
      return D.23626;
    }
  finally
    {
      code_len = {CLOBBER};
    }
}


get_delegate_invoke_impl (gboolean has_target, gboolean param_count, guint32 * code_size)
{
  int code.18;
  int start.19;
  int D.23633;
  _Bool D.23634;
  long int D.23635;
  long int D.23636;
  int D.23640;
  int D.23641;
  int D.23642;
  int D.23643;
  int D.23644;
  int D.23645;
  int D.23646;
  unsigned int D.23647;
  _Bool D.23648;
  long int D.23649;
  long int D.23650;
  unsigned int D.23655;
  void * D.23656;
  guint8 * code;
  guint8 * start;

  if (has_target != 0) goto <D.23629>; else goto <D.23630>;
  <D.23629>:
  code = mono_global_codeman_reserve (16);
  start = code;
  MEM[(guint32 *)code] = 2358771720;
  code = code + 4;
  MEM[(guint32 *)code] = 2357461008;
  code = code + 4;
  MEM[(guint32 *)code] = 50331656;
  code = code + 4;
  MEM[(guint32 *)code] = 2099237;
  code = code + 4;
  code.18 = (int) code;
  start.19 = (int) start;
  D.23633 = code.18 - start.19;
  D.23634 = D.23633 > 16;
  D.23635 = (long int) D.23634;
  D.23636 = __builtin_expect (D.23635, 0);
  if (D.23636 != 0) goto <D.23637>; else goto <D.23638>;
  <D.23637>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 559, "(code - start) <= 16");
  <D.23638>:
  mono_arch_flush_icache (start, 16);
  goto <D.23639>;
  <D.23630>:
  {
    int size;
    int i;

    D.23640 = param_count + 4;
    size = D.23640 * 4;
    code = mono_global_codeman_reserve (size);
    start = code;
    MEM[(guint32 *)code] = 2358771720;
    code = code + 4;
    i = 0;
    goto <D.21804>;
    <D.21803>:
    D.23641 = i + 5;
    D.23642 = D.23641 << 21;
    D.23643 = i + 4;
    D.23644 = D.23643 << 11;
    D.23645 = D.23642 | D.23644;
    D.23646 = D.23645 | 33;
    D.23647 = (unsigned int) D.23646;
    MEM[(guint32 *)code] = D.23647;
    code = code + 4;
    i = i + 1;
    <D.21804>:
    if (i < param_count) goto <D.21803>; else goto <D.21805>;
    <D.21805>:
    MEM[(guint32 *)code] = 50331656;
    code = code + 4;
    MEM[(guint32 *)code] = 2099237;
    code = code + 4;
    code.18 = (int) code;
    start.19 = (int) start;
    D.23633 = code.18 - start.19;
    D.23648 = D.23633 > size;
    D.23649 = (long int) D.23648;
    D.23650 = __builtin_expect (D.23649, 0);
    if (D.23650 != 0) goto <D.23651>; else goto <D.23652>;
    <D.23651>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 576, "(code - start) <= size");
    <D.23652>:
    mono_arch_flush_icache (start, size);
  }
  <D.23639>:
  if (code_size != 0B) goto <D.23653>; else goto <D.23654>;
  <D.23653>:
  code.18 = (int) code;
  start.19 = (int) start;
  D.23633 = code.18 - start.19;
  D.23655 = (unsigned int) D.23633;
  *code_size = D.23655;
  <D.23654>:
  D.23656 = start;
  return D.23656;
}


mono_arch_get_delegate_invoke_impl (struct MonoMethodSignature * sig, gboolean has_target)
{
  struct MonoType * D.23658;
  int D.23659;
  void * D.23662;
  _Bool D.23667;
  long int D.23668;
  long int D.23669;
  guint8 * cached.20;
  _Bool D.23677;
  long int D.23678;
  long int D.23679;
  int mono_aot_only.21;
  _Bool D.23688;
  long int D.23689;
  long int D.23690;
  short unsigned int D.23693;
  struct MonoType * D.23696;
  int D.23697;
  int D.23700;
  _Bool D.23703;
  long int D.23704;
  long int D.23705;
  _Bool D.23712;
  long int D.23713;
  long int D.23714;
  int D.23720;
  _Bool D.23723;
  long int D.23724;
  long int D.23725;
  guint8 * code;
  guint8 * start;

  D.23658 = sig->ret;
  D.23659 = mono_type_is_struct (D.23658);
  if (D.23659 != 0) goto <D.23660>; else goto <D.23661>;
  <D.23660>:
  D.23662 = 0B;
  return D.23662;
  <D.23661>:
  if (has_target != 0) goto <D.23663>; else goto <D.23664>;
  <D.23663>:
  {
    static guint8 * cached = 0B;

    {
      int ret;

      ret = pthread_mutex_lock (&mini_arch_mutex.mutex);
      if (ret != 0) goto <D.23665>; else goto <D.23666>;
      <D.23665>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
      <D.23666>:
      D.23667 = ret != 0;
      D.23668 = (long int) D.23667;
      D.23669 = __builtin_expect (D.23668, 0);
      if (D.23669 != 0) goto <D.23670>; else goto <D.23671>;
      <D.23670>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 626, "ret == 0");
      <D.23671>:
    }
    cached.20 = cached;
    if (cached.20 != 0B) goto <D.23673>; else goto <D.23674>;
    <D.23673>:
    {
      int ret;

      ret = pthread_mutex_unlock (&mini_arch_mutex.mutex);
      if (ret != 0) goto <D.23675>; else goto <D.23676>;
      <D.23675>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
      <D.23676>:
      D.23677 = ret != 0;
      D.23678 = (long int) D.23677;
      D.23679 = __builtin_expect (D.23678, 0);
      if (D.23679 != 0) goto <D.23680>; else goto <D.23681>;
      <D.23680>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 628, "ret == 0");
      <D.23681>:
    }
    D.23662 = cached;
    return D.23662;
    <D.23674>:
    mono_aot_only.21 = mono_aot_only;
    if (mono_aot_only.21 != 0) goto <D.23683>; else goto <D.23684>;
    <D.23683>:
    start = mono_aot_get_trampoline ("delegate_invoke_impl_has_target");
    goto <D.23685>;
    <D.23684>:
    start = get_delegate_invoke_impl (1, 0, 0B);
    <D.23685>:
    cached = start;
    {
      int ret;

      ret = pthread_mutex_unlock (&mini_arch_mutex.mutex);
      if (ret != 0) goto <D.23686>; else goto <D.23687>;
      <D.23686>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
      <D.23687>:
      D.23688 = ret != 0;
      D.23689 = (long int) D.23688;
      D.23690 = __builtin_expect (D.23689, 0);
      if (D.23690 != 0) goto <D.23691>; else goto <D.23692>;
      <D.23691>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 637, "ret == 0");
      <D.23692>:
    }
    D.23662 = cached;
    return D.23662;
  }
  <D.23664>:
  {
    static guint8 * cache[4] = {0B};
    int i;

    D.23693 = sig->param_count;
    if (D.23693 > 3) goto <D.23694>; else goto <D.23695>;
    <D.23694>:
    D.23662 = 0B;
    return D.23662;
    <D.23695>:
    i = 0;
    goto <D.21830>;
    <D.21829>:
    D.23696 = sig->params[i];
    D.23697 = mono_is_regsize_var (D.23696);
    if (D.23697 == 0) goto <D.23698>; else goto <D.23699>;
    <D.23698>:
    D.23662 = 0B;
    return D.23662;
    <D.23699>:
    i = i + 1;
    <D.21830>:
    D.23693 = sig->param_count;
    D.23700 = (int) D.23693;
    if (D.23700 > i) goto <D.21829>; else goto <D.21831>;
    <D.21831>:
    {
      int ret;

      ret = pthread_mutex_lock (&mini_arch_mutex.mutex);
      if (ret != 0) goto <D.23701>; else goto <D.23702>;
      <D.23701>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
      <D.23702>:
      D.23703 = ret != 0;
      D.23704 = (long int) D.23703;
      D.23705 = __builtin_expect (D.23704, 0);
      if (D.23705 != 0) goto <D.23706>; else goto <D.23707>;
      <D.23706>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 649, "ret == 0");
      <D.23707>:
    }
    D.23693 = sig->param_count;
    D.23700 = (int) D.23693;
    code = cache[D.23700];
    if (code != 0B) goto <D.23708>; else goto <D.23709>;
    <D.23708>:
    {
      int ret;

      ret = pthread_mutex_unlock (&mini_arch_mutex.mutex);
      if (ret != 0) goto <D.23710>; else goto <D.23711>;
      <D.23710>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
      <D.23711>:
      D.23712 = ret != 0;
      D.23713 = (long int) D.23712;
      D.23714 = __builtin_expect (D.23713, 0);
      if (D.23714 != 0) goto <D.23715>; else goto <D.23716>;
      <D.23715>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 652, "ret == 0");
      <D.23716>:
    }
    D.23662 = code;
    return D.23662;
    <D.23709>:
    mono_aot_only.21 = mono_aot_only;
    if (mono_aot_only.21 != 0) goto <D.23717>; else goto <D.23718>;
    <D.23717>:
    {
      char * name;

      D.23693 = sig->param_count;
      D.23700 = (int) D.23693;
      name = monoeg_g_strdup_printf ("delegate_invoke_impl_target_%d", D.23700);
      start = mono_aot_get_trampoline (name);
      monoeg_g_free (name);
    }
    goto <D.23719>;
    <D.23718>:
    D.23693 = sig->param_count;
    D.23720 = (int) D.23693;
    start = get_delegate_invoke_impl (0, D.23720, 0B);
    <D.23719>:
    D.23693 = sig->param_count;
    D.23700 = (int) D.23693;
    cache[D.23700] = start;
    {
      int ret;

      ret = pthread_mutex_unlock (&mini_arch_mutex.mutex);
      if (ret != 0) goto <D.23721>; else goto <D.23722>;
      <D.23721>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
      <D.23722>:
      D.23723 = ret != 0;
      D.23724 = (long int) D.23723;
      D.23725 = __builtin_expect (D.23724, 0);
      if (D.23725 != 0) goto <D.23726>; else goto <D.23727>;
      <D.23726>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 664, "ret == 0");
      <D.23727>:
    }
    D.23662 = start;
    return D.23662;
  }
  D.23662 = 0B;
  return D.23662;
}


mono_arch_get_this_arg_from_call (mgreg_t * regs, guint8 * code)
{
  _Bool D.23729;
  long int D.23730;
  long int D.23731;
  void * D.23734;
  mgreg_t * D.23735;
  int D.23736;

  D.23729 = regs == 0B;
  D.23730 = (long int) D.23729;
  D.23731 = __builtin_expect (D.23730, 0);
  if (D.23731 != 0) goto <D.23732>; else goto <D.23733>;
  <D.23732>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 674, "regs");
  <D.23733>:
  D.23735 = regs + 16;
  D.23736 = *D.23735;
  D.23734 = (void *) D.23736;
  return D.23734;
}


mono_arch_cpu_init ()
{
  int ls_word_idx.22;
  int ls_word_offset.23;
  int ms_word_idx.24;
  int ms_word_offset.25;

  little_endian = 1;
  ls_word_idx = 0;
  ms_word_idx = 1;
  ls_word_idx.22 = ls_word_idx;
  ls_word_offset.23 = ls_word_idx.22 * 4;
  ls_word_offset = ls_word_offset.23;
  ms_word_idx.24 = ms_word_idx;
  ms_word_offset.25 = ms_word_idx.24 * 4;
  ms_word_offset = ms_word_offset.25;
}


mono_arch_init ()
{
  int D.23742;
  unsigned int D.23743;
  void * ss_trigger_page.26;
  int D.23745;
  unsigned int D.23746;
  void * bp_trigger_page.27;
  void * bp_trigger_page.28;
  int D.23749;
  unsigned int D.23750;

  InitializeCriticalSection (&mini_arch_mutex);
  D.23742 = mono_pagesize ();
  D.23743 = (unsigned int) D.23742;
  ss_trigger_page.26 = mono_valloc (0B, D.23743, 257);
  ss_trigger_page = ss_trigger_page.26;
  D.23745 = mono_pagesize ();
  D.23746 = (unsigned int) D.23745;
  bp_trigger_page.27 = mono_valloc (0B, D.23746, 257);
  bp_trigger_page = bp_trigger_page.27;
  bp_trigger_page.28 = bp_trigger_page;
  D.23749 = mono_pagesize ();
  D.23750 = (unsigned int) D.23749;
  mono_mprotect (bp_trigger_page.28, D.23750, 0);
}


mono_arch_cleanup ()
{
  DeleteCriticalSection (&mini_arch_mutex);
}


mono_arch_cpu_optimizations (guint32 * exclude_mask)
{
  guint32 D.23751;
  guint32 opts;

  opts = 0;
  *exclude_mask = 0;
  D.23751 = opts;
  return D.23751;
}


mono_arch_cpu_enumerate_simd_versions ()
{
  guint32 D.23753;

  D.23753 = 0;
  return D.23753;
}


mono_arch_get_allocatable_int_vars (struct MonoCompile * cfg)
{
  struct MonoInst * * D.23755;
  unsigned int i.29;
  unsigned int D.23757;
  struct MonoInst * * D.23758;
  struct MonoMethodVar * D.23759;
  unsigned int D.23760;
  unsigned int D.23761;
  unsigned int D.23762;
  unsigned char D.23767;
  int D.23768;
  int D.23769;
  short unsigned int D.23771;
  short unsigned int D.23772;
  struct MonoType * D.23773;
  int D.23774;
  struct MonoMethodVar * D.23777;
  int D.23778;
  _Bool D.23779;
  long int D.23780;
  long int D.23781;
  unsigned int i.30;
  unsigned int D.23785;
  _Bool D.23786;
  long int D.23787;
  long int D.23788;
  unsigned int D.23791;
  struct GList * D.23792;
  struct GList * vars;
  int i;

  vars = 0B;
  i = 0;
  goto <D.21865>;
  <D.21864>:
  {
    struct MonoInst * ins;
    struct MonoMethodVar * vmv;

    D.23755 = cfg->varinfo;
    i.29 = (unsigned int) i;
    D.23757 = i.29 * 4;
    D.23758 = D.23755 + D.23757;
    ins = *D.23758;
    D.23759 = cfg->vars;
    i.29 = (unsigned int) i;
    D.23760 = i.29 * 56;
    vmv = D.23759 + D.23760;
    D.23761 = vmv->range.first_use.abs_pos;
    D.23762 = vmv->range.last_use.abs_pos;
    if (D.23761 >= D.23762) goto <D.23763>; else goto <D.23764>;
    <D.23763>:
    // predicted unlikely by continue predictor.
    goto <D.21863>;
    <D.23764>:
    D.23767 = ins->flags;
    D.23768 = (int) D.23767;
    D.23769 = D.23768 & 20;
    if (D.23769 != 0) goto <D.23765>; else goto <D.23770>;
    <D.23770>:
    D.23771 = ins->opcode;
    D.23772 = D.23771 + 65207;
    if (D.23772 > 1) goto <D.23765>; else goto <D.23766>;
    <D.23765>:
    // predicted unlikely by continue predictor.
    goto <D.21863>;
    <D.23766>:
    D.23773 = ins->data.op[1].vtype;
    D.23774 = mono_is_regsize_var (D.23773);
    if (D.23774 != 0) goto <D.23775>; else goto <D.23776>;
    <D.23775>:
    D.23759 = cfg->vars;
    i.29 = (unsigned int) i;
    D.23760 = i.29 * 56;
    D.23777 = D.23759 + D.23760;
    D.23778 = D.23777->reg;
    D.23779 = D.23778 != -1;
    D.23780 = (long int) D.23779;
    D.23781 = __builtin_expect (D.23780, 0);
    if (D.23781 != 0) goto <D.23782>; else goto <D.23783>;
    <D.23782>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 764, "MONO_VARINFO (cfg, i)->reg == -1");
    <D.23783>:
    i.30 = (unsigned int) i;
    D.23785 = vmv->idx;
    D.23786 = i.30 != D.23785;
    D.23787 = (long int) D.23786;
    D.23788 = __builtin_expect (D.23787, 0);
    if (D.23788 != 0) goto <D.23789>; else goto <D.23790>;
    <D.23789>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 765, "i == vmv->idx");
    <D.23790>:
    vars = mono_varlist_insert_sorted (cfg, vars, vmv, 0);
    <D.23776>:
  }
  <D.21863>:
  i = i + 1;
  <D.21865>:
  i.30 = (unsigned int) i;
  D.23791 = cfg->num_varinfo;
  if (i.30 < D.23791) goto <D.21864>; else goto <D.21866>;
  <D.21866>:
  D.23792 = vars;
  return D.23792;
}


mono_arch_get_global_int_regs (struct MonoCompile * cfg)
{
  struct GList * D.23794;
  struct GList * regs;

  regs = 0B;
  regs = monoeg_g_list_prepend (regs, 16B);
  regs = monoeg_g_list_prepend (regs, 17B);
  regs = monoeg_g_list_prepend (regs, 18B);
  regs = monoeg_g_list_prepend (regs, 19B);
  regs = monoeg_g_list_prepend (regs, 20B);
  regs = monoeg_g_list_prepend (regs, 22B);
  regs = monoeg_g_list_prepend (regs, 23B);
  D.23794 = regs;
  return D.23794;
}


mono_arch_regalloc_cost (struct MonoCompile * cfg, struct MonoMethodVar * vmv)
{
  guint32 D.23796;

  D.23796 = 2;
  return D.23796;
}


mono_arch_allocate_vars (struct MonoCompile * cfg)
{
  struct MonoMethod * D.23798;
  void * D.23799;
  struct MonoGenericSharingContext * D.23802;
  struct MonoMemPool * D.23803;
  struct CallInfo * D.23804;
  struct MonoTraceSpec * mono_jit_trace_calls.31;
  int D.23808;
  unsigned int D.23811;
  unsigned int D.23812;
  unsigned int D.23813;
  unsigned int D.23814;
  unsigned int D.23817;
  unsigned int D.23818;
  unsigned int D.23821;
  int D.23822;
  unsigned int frame_reg.32;
  unsigned int D.23829;
  int D.23830;
  unsigned int D.23831;
  unsigned int D.23832;
  struct MonoType * D.23833;
  int D.23834;
  struct MonoType * D.23837;
  unsigned char D.23838;
  int D.23839;
  struct MonoInst * D.23840;
  int D.23841;
  unsigned int offset.33;
  unsigned int D.23843;
  int D.23846;
  unsigned int D.23849;
  struct MonoInst * * D.23850;
  unsigned int i.34;
  unsigned int D.23852;
  struct MonoInst * * D.23853;
  unsigned char D.23856;
  int D.23857;
  int D.23858;
  short unsigned int D.23860;
  int D.23863;
  struct MonoType * D.23865;
  int D.23866;
  unsigned char D.23868;
  struct MonoClass * D.23870;
  int align.35;
  int D.23872;
  int D.23873;
  unsigned int i.36;
  unsigned int D.23875;
  unsigned int D.23876;
  int D.23879;
  unsigned int offset.37;
  unsigned int offset.38;
  unsigned int D.23882;
  unsigned int D.23883;
  unsigned int D.23884;
  int D.23889;
  unsigned int D.23890;
  unsigned int D.23891;
  int D.23894;
  unsigned int D.23895;
  int D.23896;
  struct MonoInst * D.23899;
  struct MonoInst * * D.23900;
  struct MonoInst * * D.23901;
  unsigned int D.23906;
  struct MonoClass * D.23909;
  <unnamed-unsigned:1> D.23910;
  int D.23911;
  int D.23912;
  int D.23915;
  int D.23916;
  unsigned int D.23917;
  int D.23920;
  short unsigned int D.23924;
  int D.23925;
  int D.23926;
  struct MonoMethodSignature * sig;
  struct MonoMethodHeader * header;
  struct MonoInst * inst;
  int i;
  int offset;
  int size;
  int align;
  int curinst;
  int frame_reg;
  guint32 iregs_to_save;
  struct CallInfo * cinfo;

  try
    {
      frame_reg = 29;
      iregs_to_save = 0;
      D.23798 = cfg->method;
      sig = mono_method_signature (D.23798);
      D.23799 = cfg->arch.cinfo;
      if (D.23799 == 0B) goto <D.23800>; else goto <D.23801>;
      <D.23800>:
      D.23802 = cfg->generic_sharing_context;
      D.23803 = cfg->mempool;
      D.23804 = get_call_info (D.23802, D.23803, sig);
      cfg->arch.cinfo = D.23804;
      <D.23801>:
      cinfo = cfg->arch.cinfo;
      mono_arch_compute_omit_fp (cfg);
      mono_jit_trace_calls.31 = mono_jit_trace_calls;
      if (mono_jit_trace_calls.31 != 0B) goto <D.23806>; else goto <D.23807>;
      <D.23806>:
      D.23798 = cfg->method;
      D.23808 = mono_trace_eval (D.23798);
      if (D.23808 != 0) goto <D.23809>; else goto <D.23810>;
      <D.23809>:
      D.23811 = cfg->param_area;
      D.23812 = MAX_EXPR <D.23811, 32>;
      cfg->param_area = D.23812;
      <D.23810>:
      <D.23807>:
      D.23813 = cfg->flags;
      D.23814 = D.23813 & 8;
      if (D.23814 != 0) goto <D.23815>; else goto <D.23816>;
      <D.23815>:
      D.23811 = cfg->param_area;
      D.23812 = MAX_EXPR <D.23811, 32>;
      cfg->param_area = D.23812;
      <D.23816>:
      D.23798 = cfg->method;
      D.23817 = BIT_FIELD_REF <*D.23798, 32, 160>;
      D.23818 = D.23817 & 124;
      if (D.23818 == 24) goto <D.23819>; else goto <D.23820>;
      <D.23819>:
      D.23811 = cfg->param_area;
      D.23812 = MAX_EXPR <D.23811, 32>;
      cfg->param_area = D.23812;
      <D.23820>:
      D.23811 = cfg->param_area;
      D.23821 = MAX_EXPR <D.23811, 16>;
      cfg->param_area = D.23821;
      header = cfg->header;
      D.23822 = cfg->arch.omit_fp;
      if (D.23822 != 0) goto <D.23823>; else goto <D.23824>;
      <D.23823>:
      frame_reg = 29;
      goto <D.23825>;
      <D.23824>:
      frame_reg = 30;
      <D.23825>:
      frame_reg.32 = (unsigned int) frame_reg;
      cfg->frame_reg = frame_reg.32;
      if (frame_reg != 29) goto <D.23827>; else goto <D.23828>;
      <D.23827>:
      D.23829 = cfg->used_int_regs;
      D.23830 = 1 << frame_reg;
      D.23831 = (unsigned int) D.23830;
      D.23832 = D.23829 | D.23831;
      cfg->used_int_regs = D.23832;
      <D.23828>:
      offset = 0;
      curinst = 0;
      D.23833 = sig->ret;
      D.23834 = mono_type_is_struct (D.23833);
      if (D.23834 == 0) goto <D.23835>; else goto <D.23836>;
      <D.23835>:
      D.23802 = cfg->generic_sharing_context;
      D.23833 = sig->ret;
      D.23837 = mini_type_get_underlying_type (D.23802, D.23833);
      D.23838 = D.23837->type;
      D.23839 = (int) D.23838;
      switch (D.23839) <default: <D.22007>, case 1: <D.22003>, case 12: <D.22005>, case 13: <D.22006>>
      <D.22003>:
      goto <D.22004>;
      <D.22005>:
      <D.22006>:
      D.23840 = cfg->ret;
      D.23840->opcode = 366;
      D.23840 = cfg->ret;
      D.23840 = cfg->ret;
      D.23840->dreg = 0;
      D.23841 = D.23840->dreg;
      D.23840->data.op[0].const_val = D.23841;
      goto <D.22004>;
      <D.22007>:
      D.23840 = cfg->ret;
      D.23840->opcode = 366;
      D.23840 = cfg->ret;
      D.23840->data.op[0].const_val = 2;
      goto <D.22004>;
      <D.22004>:
      <D.23836>:
      D.23811 = cfg->param_area;
      offset.33 = (unsigned int) offset;
      D.23843 = D.23811 + offset.33;
      offset = (int) D.23843;
      mono_jit_trace_calls.31 = mono_jit_trace_calls;
      if (mono_jit_trace_calls.31 != 0B) goto <D.23844>; else goto <D.23845>;
      <D.23844>:
      D.23798 = cfg->method;
      D.23846 = mono_trace_eval (D.23798);
      if (D.23846 != 0) goto <D.23847>; else goto <D.23848>;
      <D.23847>:
      offset = offset + 8;
      <D.23848>:
      <D.23845>:
      D.23849 = cfg->locals_start;
      curinst = (int) D.23849;
      i = curinst;
      goto <D.22010>;
      <D.22009>:
      D.23850 = cfg->varinfo;
      i.34 = (unsigned int) i;
      D.23852 = i.34 * 4;
      D.23853 = D.23850 + D.23852;
      inst = *D.23853;
      D.23856 = inst->flags;
      D.23857 = (int) D.23856;
      D.23858 = D.23857 & 2;
      if (D.23858 != 0) goto <D.23854>; else goto <D.23859>;
      <D.23859>:
      D.23860 = inst->opcode;
      if (D.23860 == 366) goto <D.23854>; else goto <D.23855>;
      <D.23854>:
      // predicted unlikely by continue predictor.
      goto <D.22008>;
      <D.23855>:
      D.23863 = inst->backend.is_pinvoke;
      if (D.23863 != 0) goto <D.23864>; else goto <D.23861>;
      <D.23864>:
      D.23865 = inst->data.op[1].vtype;
      D.23866 = mono_type_is_struct (D.23865);
      if (D.23866 != 0) goto <D.23867>; else goto <D.23861>;
      <D.23867>:
      D.23865 = inst->data.op[1].vtype;
      D.23868 = D.23865->type;
      if (D.23868 != 22) goto <D.23869>; else goto <D.23861>;
      <D.23869>:
      D.23865 = inst->data.op[1].vtype;
      D.23870 = mono_class_from_mono_type (D.23865);
      size = mono_class_native_size (D.23870, &align);
      goto <D.23862>;
      <D.23861>:
      D.23865 = inst->data.op[1].vtype;
      size = mono_type_size (D.23865, &align);
      <D.23862>:
      align.35 = align;
      D.23872 = align.35 + -1;
      offset = D.23872 + offset;
      align.35 = align;
      D.23873 = -align.35;
      offset = D.23873 & offset;
      inst->data.op[0].const_val = offset;
      inst->opcode = 367;
      inst->sreg1 = frame_reg;
      offset = offset + size;
      <D.22008>:
      i = i + 1;
      <D.22010>:
      i.36 = (unsigned int) i;
      D.23875 = cfg->num_varinfo;
      if (i.36 < D.23875) goto <D.22009>; else goto <D.22011>;
      <D.22011>:
      D.23798 = cfg->method;
      D.23817 = BIT_FIELD_REF <*D.23798, 32, 160>;
      D.23876 = D.23817 & 256;
      if (D.23876 != 0) goto <D.23877>; else goto <D.23878>;
      <D.23877>:
      D.23879 = offset + 15;
      offset = D.23879 & -16;
      offset.37 = (unsigned int) offset;
      cfg->arch.lmf_offset = offset.37;
      offset.38 = (unsigned int) offset;
      D.23882 = offset.38 + 276;
      offset = (int) D.23882;
      <D.23878>:
      D.23883 = BIT_FIELD_REF <*sig, 32, 64>;
      D.23884 = D.23883 & 4128768;
      if (D.23884 == 327680) goto <D.23885>; else goto <D.23886>;
      <D.23885>:
      size = 4;
      align = 4;
      align.35 = align;
      D.23872 = align.35 + -1;
      offset = D.23872 + offset;
      align.35 = align;
      D.23873 = -align.35;
      offset = D.23873 & offset;
      cfg->sig_cookie = offset;
      offset = offset + size;
      <D.23886>:
      offset = offset + 3;
      offset = offset & -4;
      offset.37 = (unsigned int) offset;
      cfg->arch.iregs_offset = offset.37;
      D.23829 = cfg->used_int_regs;
      iregs_to_save = D.23829 & 1090453504;
      if (iregs_to_save != 0) goto <D.23887>; else goto <D.23888>;
      <D.23887>:
      i = 31;
      goto <D.22013>;
      <D.22012>:
      D.23889 = 1 << i;
      D.23890 = (unsigned int) D.23889;
      D.23891 = D.23890 & iregs_to_save;
      if (D.23891 != 0) goto <D.23892>; else goto <D.23893>;
      <D.23892>:
      offset = offset + 4;
      <D.23893>:
      i = i + -1;
      <D.22013>:
      if (i >= 0) goto <D.22012>; else goto <D.22014>;
      <D.22014>:
      <D.23888>:
      offset = offset + 4;
      D.23879 = offset + 15;
      offset = D.23879 & -16;
      cfg->stack_offset = offset;
      D.23894 = cfg->stack_offset;
      D.23895 = (unsigned int) D.23894;
      cfg->arch.local_alloc_offset = D.23895;
      D.23833 = sig->ret;
      D.23896 = mono_type_is_struct (D.23833);
      if (D.23896 != 0) goto <D.23897>; else goto <D.23898>;
      <D.23897>:
      D.23899 = cfg->vret_addr;
      D.23899->opcode = 367;
      D.23899 = cfg->vret_addr;
      D.23899->data.op[0].const_val = 4;
      D.23899 = cfg->vret_addr;
      D.23899->data.op[0].const_val = offset;
      D.23899 = cfg->vret_addr;
      D.23899->sreg1 = frame_reg;
      offset = offset + 4;
      <D.23898>:
      i = 0;
      goto <D.22017>;
      <D.22016>:
      D.23900 = cfg->args;
      i.34 = (unsigned int) i;
      D.23852 = i.34 * 4;
      D.23901 = D.23900 + D.23852;
      inst = *D.23901;
      D.23860 = inst->opcode;
      if (D.23860 != 366) goto <D.23902>; else goto <D.23903>;
      <D.23902>:
      {
        struct MonoType * arg_type;

        D.23883 = BIT_FIELD_REF <*sig, 32, 64>;
        D.23906 = D.23883 & 4194304;
        if (D.23906 != 0) goto <D.23907>; else goto <D.23904>;
        <D.23907>:
        if (i == 0) goto <D.23908>; else goto <D.23904>;
        <D.23908>:
        D.23909 = mono_defaults.object_class;
        arg_type = &D.23909->byval_arg;
        goto <D.23905>;
        <D.23904>:
        D.23910 = sig->hasthis;
        D.23911 = (int) D.23910;
        D.23912 = i - D.23911;
        arg_type = sig->params[D.23912];
        <D.23905>:
        inst->opcode = 367;
        size = mono_type_size (arg_type, &align);
        if (size <= 3) goto <D.23913>; else goto <D.23914>;
        <D.23913>:
        size = 4;
        align = 4;
        <D.23914>:
        inst->sreg1 = frame_reg;
        align.35 = align;
        D.23915 = offset + align.35;
        D.23916 = D.23915 + -1;
        align.35 = align;
        D.23873 = -align.35;
        offset = D.23916 & D.23873;
        inst->data.op[0].const_val = offset;
        offset = offset + size;
        D.23917 = cfg->verbose_level;
        if (D.23917 > 1) goto <D.23918>; else goto <D.23919>;
        <D.23918>:
        D.23920 = inst->data.op[0].const_val;
        printf ("allocating param %d to fp[%d]\n", i, D.23920);
        <D.23919>:
      }
      goto <D.23921>;
      <D.23903>:
      size = 4;
      align = 4;
      inst->sreg1 = frame_reg;
      align.35 = align;
      D.23915 = offset + align.35;
      D.23916 = D.23915 + -1;
      align.35 = align;
      D.23873 = -align.35;
      offset = D.23916 & D.23873;
      inst->data.op[0].const_val = offset;
      offset = offset + size;
      D.23917 = cfg->verbose_level;
      if (D.23917 > 1) goto <D.23922>; else goto <D.23923>;
      <D.23922>:
      D.23920 = inst->data.op[0].const_val;
      printf ("allocating param %d to fp[%d]\n", i, D.23920);
      <D.23923>:
      <D.23921>:
      i = i + 1;
      <D.22017>:
      D.23924 = sig->param_count;
      D.23925 = (int) D.23924;
      D.23910 = sig->hasthis;
      D.23911 = (int) D.23910;
      D.23926 = D.23925 + D.23911;
      if (D.23926 > i) goto <D.22016>; else goto <D.22018>;
      <D.22018>:
    }
  finally
    {
      align = {CLOBBER};
    }
}


get_call_info (struct MonoGenericSharingContext * gsctx, struct MonoMemPool * mp, struct MonoMethodSignature * sig)
{
  <unnamed-unsigned:1> D.23928;
  int D.23929;
  short unsigned int D.23930;
  int D.23931;
  <unnamed-unsigned:1> D.23932;
  unsigned int n.39;
  unsigned int D.23936;
  unsigned int D.23937;
  struct MonoType * D.23939;
  int D.23940;
  _Bool D.23941;
  int D.23942;
  int D.23946;
  unsigned int D.23949;
  unsigned int D.23950;
  struct MonoType * D.23953;
  struct MonoType * D.23954;
  int D.23955;
  sizetype n.40;
  struct ArgInfo * D.23959;
  sizetype D.23961;
  struct ArgInfo * D.23962;
  struct ArgInfo * D.23963;
  unsigned char D.23964;
  unsigned int D.23965;
  unsigned int D.23970;
  short int D.23973;
  unsigned int D.23974;
  struct ArgInfo * D.23977;
  struct MonoType * D.23978;
  unsigned char D.23979;
  int D.23980;
  struct ArgInfo * D.23981;
  int D.23982;
  int D.23993;
  int D.23996;
  int D.23999;
  int D.24000;
  int D.24001;
  _Bool D.24004;
  long int D.24005;
  long int D.24006;
  unsigned int size.41;
  unsigned int D.24010;
  unsigned int D.24011;
  <unnamed-unsigned:4> D.24012;
  _Bool D.24013;
  long int D.24014;
  long int D.24015;
  short unsigned int D.24018;
  _Bool D.24019;
  long int D.24020;
  long int D.24021;
  int D.24033;
  short unsigned int D.24036;
  unsigned char D.24038;
  unsigned char D.24039;
  <unnamed-unsigned:4> D.24040;
  unsigned char D.24041;
  int D.24042;
  unsigned int D.24043;
  int D.24048;
  unsigned char D.24051;
  int D.24052;
  int D.24053;
  int D.24054;
  unsigned int D.24055;
  struct CallInfo * D.24056;
  guint i;
  int n;
  int pstart;
  struct MonoType * simpletype;
  struct CallInfo * cinfo;
  gboolean is_pinvoke;

  D.23928 = sig->hasthis;
  D.23929 = (int) D.23928;
  D.23930 = sig->param_count;
  D.23931 = (int) D.23930;
  n = D.23929 + D.23931;
  D.23932 = sig->pinvoke;
  is_pinvoke = (gboolean) D.23932;
  if (mp != 0B) goto <D.23933>; else goto <D.23934>;
  <D.23933>:
  n.39 = (unsigned int) n;
  D.23936 = n.39 * 16;
  D.23937 = D.23936 + 84;
  cinfo = mono_mempool_alloc0 (mp, D.23937);
  goto <D.23938>;
  <D.23934>:
  n.39 = (unsigned int) n;
  D.23936 = n.39 * 16;
  D.23937 = D.23936 + 84;
  cinfo = monoeg_malloc0 (D.23937);
  <D.23938>:
  cinfo->fr = 12;
  cinfo->gr = 4;
  cinfo->stack_size = 0;
  D.23939 = sig->ret;
  D.23940 = mono_type_is_struct (D.23939);
  D.23941 = D.23940 != 0;
  D.23942 = (int) D.23941;
  cinfo->vtype_retaddr = D.23942;
  pstart = 0;
  n = 0;
  D.23946 = cinfo->vtype_retaddr;
  if (D.23946 != 0) goto <D.23947>; else goto <D.23943>;
  <D.23947>:
  if (is_pinvoke == 0) goto <D.23948>; else goto <D.23943>;
  <D.23948>:
  D.23949 = BIT_FIELD_REF <*sig, 32, 64>;
  D.23950 = D.23949 & 4194304;
  if (D.23950 != 0) goto <D.23944>; else goto <D.23951>;
  <D.23951>:
  D.23930 = sig->param_count;
  if (D.23930 != 0) goto <D.23952>; else goto <D.23943>;
  <D.23952>:
  D.23953 = sig->params[0];
  D.23954 = mini_type_get_underlying_type (gsctx, D.23953);
  D.23955 = mono_type_is_reference (D.23954);
  if (D.23955 != 0) goto <D.23944>; else goto <D.23943>;
  <D.23944>:
  D.23949 = BIT_FIELD_REF <*sig, 32, 64>;
  D.23950 = D.23949 & 4194304;
  if (D.23950 != 0) goto <D.23956>; else goto <D.23957>;
  <D.23956>:
  n.40 = (sizetype) n;
  D.23959 = &cinfo->args[n.40];
  add_int32_arg (cinfo, D.23959);
  n = n + 1;
  goto <D.23960>;
  <D.23957>:
  D.23928 = sig->hasthis;
  D.23961 = (sizetype) D.23928;
  D.23962 = &cinfo->args[D.23961];
  add_int32_arg (cinfo, D.23962);
  pstart = 1;
  n = n + 1;
  <D.23960>:
  D.23963 = &cinfo->ret;
  add_int32_arg (cinfo, D.23963);
  D.23964 = cinfo->ret.reg;
  D.23965 = (unsigned int) D.23964;
  cinfo->struct_ret = D.23965;
  goto <D.23945>;
  <D.23943>:
  D.23949 = BIT_FIELD_REF <*sig, 32, 64>;
  D.23950 = D.23949 & 4194304;
  if (D.23950 != 0) goto <D.23966>; else goto <D.23967>;
  <D.23966>:
  n.40 = (sizetype) n;
  D.23959 = &cinfo->args[n.40];
  add_int32_arg (cinfo, D.23959);
  n = n + 1;
  <D.23967>:
  D.23946 = cinfo->vtype_retaddr;
  if (D.23946 != 0) goto <D.23968>; else goto <D.23969>;
  <D.23968>:
  D.23963 = &cinfo->ret;
  add_int32_arg (cinfo, D.23963);
  D.23964 = cinfo->ret.reg;
  D.23965 = (unsigned int) D.23964;
  cinfo->struct_ret = D.23965;
  <D.23969>:
  <D.23945>:
  i = (guint) pstart;
  goto <D.21943>;
  <D.21942>:
  D.23949 = BIT_FIELD_REF <*sig, 32, 64>;
  D.23970 = D.23949 & 4128768;
  if (D.23970 == 327680) goto <D.23971>; else goto <D.23972>;
  <D.23971>:
  D.23973 = sig->sentinelpos;
  D.23974 = (unsigned int) D.23973;
  if (D.23974 == i) goto <D.23975>; else goto <D.23976>;
  <D.23975>:
  args_onto_stack (cinfo);
  D.23977 = &cinfo->sig_cookie;
  add_int32_arg (cinfo, D.23977);
  <D.23976>:
  <D.23972>:
  D.23978 = sig->params[i];
  simpletype = mini_type_get_underlying_type (gsctx, D.23978);
  D.23979 = simpletype->type;
  D.23980 = (int) D.23979;
  switch (D.23980) <default: <D.21940>, case 2: <D.21905>, case 3: <D.21909>, case 4: <D.21906>, case 5: <D.21907>, case 6: <D.21910>, case 7: <D.21911>, case 8: <D.21912>, case 9: <D.21913>, case 10: <D.21937>, case 11: <D.21936>, case 12: <D.21938>, case 13: <D.21939>, case 14: <D.21920>, case 15: <D.21916>, case 17: <D.21925>, case 18: <D.21918>, case 20: <D.21922>, case 21: <D.21923>, case 22: <D.21924>, case 24: <D.21914>, case 25: <D.21915>, case 27: <D.21917>, case 28: <D.21919>, case 29: <D.21921>>
  <D.21905>:
  <D.21906>:
  <D.21907>:
  cinfo->args[n].size = 1;
  D.23981 = &cinfo->args[n];
  add_int32_arg (cinfo, D.23981);
  n = n + 1;
  goto <D.21908>;
  <D.21909>:
  <D.21910>:
  <D.21911>:
  cinfo->args[n].size = 2;
  D.23981 = &cinfo->args[n];
  add_int32_arg (cinfo, D.23981);
  n = n + 1;
  goto <D.21908>;
  <D.21912>:
  <D.21913>:
  cinfo->args[n].size = 4;
  D.23981 = &cinfo->args[n];
  add_int32_arg (cinfo, D.23981);
  n = n + 1;
  goto <D.21908>;
  <D.21914>:
  <D.21915>:
  <D.21916>:
  <D.21917>:
  <D.21918>:
  <D.21919>:
  <D.21920>:
  <D.21921>:
  <D.21922>:
  cinfo->args[n].size = 4;
  D.23981 = &cinfo->args[n];
  add_int32_arg (cinfo, D.23981);
  n = n + 1;
  goto <D.21908>;
  <D.21923>:
  D.23982 = mono_type_generic_inst_is_valuetype (simpletype);
  if (D.23982 == 0) goto <D.23983>; else goto <D.23984>;
  <D.23983>:
  cinfo->args[n].size = 4;
  D.23981 = &cinfo->args[n];
  add_int32_arg (cinfo, D.23981);
  n = n + 1;
  goto <D.21908>;
  <D.23984>:
  <D.21924>:
  <D.21925>:
  {
    int j;
    int nwords;
    int has_offset;
    struct ArgInfo dummy_arg;
    gint size;
    gint alignment;
    struct MonoClass * klass;

    try
      {
        nwords = 0;
        has_offset = 0;
        D.23979 = simpletype->type;
        if (D.23979 == 22) goto <D.23985>; else goto <D.23986>;
        <D.23985>:
        size = 12;
        alignment = 4;
        goto <D.23987>;
        <D.23986>:
        D.23978 = sig->params[i];
        klass = mono_class_from_mono_type (D.23978);
        if (is_pinvoke != 0) goto <D.23988>; else goto <D.23989>;
        <D.23988>:
        size = mono_class_native_size (klass, 0B);
        goto <D.23990>;
        <D.23989>:
        size = mono_class_value_size (klass, 0B);
        <D.23990>:
        alignment = mono_class_min_align (klass);
        <D.23987>:
        if (alignment > 4) goto <D.23991>; else goto <D.23992>;
        <D.23991>:
        D.23993 = cinfo->on_stack;
        if (D.23993 == 0) goto <D.23994>; else goto <D.23995>;
        <D.23994>:
        D.23996 = cinfo->gr;
        if (D.23996 > 7) goto <D.23997>; else goto <D.23998>;
        <D.23997>:
        args_onto_stack (cinfo);
        <D.23998>:
        <D.23995>:
        D.23999 = cinfo->stack_size;
        D.24000 = alignment + -1;
        D.24001 = D.23999 & D.24000;
        if (D.24001 != 0) goto <D.24002>; else goto <D.24003>;
        <D.24002>:
        add_int32_arg (cinfo, &dummy_arg);
        <D.24003>:
        D.23999 = cinfo->stack_size;
        D.24000 = alignment + -1;
        D.24001 = D.23999 & D.24000;
        D.24004 = D.24001 != 0;
        D.24005 = (long int) D.24004;
        D.24006 = __builtin_expect (D.24005, 0);
        if (D.24006 != 0) goto <D.24007>; else goto <D.24008>;
        <D.24007>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 1203, "!(cinfo->stack_size & (alignment - 1))");
        <D.24008>:
        <D.23992>:
        size.41 = (unsigned int) size;
        D.24010 = size.41 + 3;
        D.24011 = D.24010 / 4;
        nwords = (int) D.24011;
        D.24012 = cinfo->args[n].size;
        D.24013 = D.24012 != 0;
        D.24014 = (long int) D.24013;
        D.24015 = __builtin_expect (D.24014, 0);
        if (D.24015 != 0) goto <D.24016>; else goto <D.24017>;
        <D.24016>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 1212, "cinfo->args [n].size == 0");
        <D.24017>:
        D.24018 = cinfo->args[n].vtsize;
        D.24019 = D.24018 != 0;
        D.24020 = (long int) D.24019;
        D.24021 = __builtin_expect (D.24020, 0);
        if (D.24021 != 0) goto <D.24022>; else goto <D.24023>;
        <D.24022>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 1213, "cinfo->args [n].vtsize == 0");
        <D.24023>:
        j = 0;
        goto <D.21934>;
        <D.21933>:
        if (j == 0) goto <D.24024>; else goto <D.24025>;
        <D.24024>:
        D.23981 = &cinfo->args[n];
        add_int32_arg (cinfo, D.23981);
        D.23993 = cinfo->on_stack;
        if (D.23993 != 0) goto <D.24026>; else goto <D.24027>;
        <D.24026>:
        has_offset = 1;
        <D.24027>:
        goto <D.24028>;
        <D.24025>:
        add_int32_arg (cinfo, &dummy_arg);
        if (has_offset == 0) goto <D.24029>; else goto <D.24030>;
        <D.24029>:
        D.23993 = cinfo->on_stack;
        if (D.23993 != 0) goto <D.24031>; else goto <D.24032>;
        <D.24031>:
        D.24033 = dummy_arg.offset;
        cinfo->args[n].offset = D.24033;
        has_offset = 1;
        <D.24032>:
        <D.24030>:
        <D.24028>:
        D.23993 = cinfo->on_stack;
        if (D.23993 != 0) goto <D.24034>; else goto <D.24035>;
        <D.24034>:
        D.24018 = cinfo->args[n].vtsize;
        D.24036 = D.24018 + 1;
        cinfo->args[n].vtsize = D.24036;
        goto <D.24037>;
        <D.24035>:
        D.24012 = cinfo->args[n].size;
        D.24038 = (unsigned char) D.24012;
        D.24039 = D.24038 + 1;
        D.24040 = (<unnamed-unsigned:4>) D.24039;
        cinfo->args[n].size = D.24040;
        <D.24037>:
        j = j + 1;
        <D.21934>:
        if (j < nwords) goto <D.21933>; else goto <D.21935>;
        <D.21935>:
        cinfo->args[n].storage = 3;
        n = n + 1;
        goto <D.21908>;
      }
    finally
      {
        dummy_arg = {CLOBBER};
      }
  }
  <D.21936>:
  <D.21937>:
  cinfo->args[n].size = 8;
  D.23981 = &cinfo->args[n];
  add_int64_arg (cinfo, D.23981);
  n = n + 1;
  goto <D.21908>;
  <D.21938>:
  cinfo->args[n].size = 4;
  D.23981 = &cinfo->args[n];
  add_float32_arg (cinfo, D.23981);
  n = n + 1;
  goto <D.21908>;
  <D.21939>:
  cinfo->args[n].size = 8;
  D.23981 = &cinfo->args[n];
  add_float64_arg (cinfo, D.23981);
  n = n + 1;
  goto <D.21908>;
  <D.21940>:
  D.23978 = sig->params[i];
  D.24041 = D.23978->type;
  D.24042 = (int) D.24041;
  monoeg_g_log (0B, 4, "Can\'t trampoline 0x%x", D.24042);
  <D.21941>:
  goto <D.21941>;
  <D.21908>:
  i = i + 1;
  <D.21943>:
  D.23930 = sig->param_count;
  D.24043 = (unsigned int) D.23930;
  if (D.24043 > i) goto <D.21942>; else goto <D.21944>;
  <D.21944>:
  D.23949 = BIT_FIELD_REF <*sig, 32, 64>;
  D.23970 = D.23949 & 4128768;
  if (D.23970 == 327680) goto <D.24044>; else goto <D.24045>;
  <D.24044>:
  D.23973 = sig->sentinelpos;
  D.23974 = (unsigned int) D.23973;
  if (D.23974 == i) goto <D.24046>; else goto <D.24047>;
  <D.24046>:
  args_onto_stack (cinfo);
  D.23977 = &cinfo->sig_cookie;
  add_int32_arg (cinfo, D.23977);
  <D.24047>:
  <D.24045>:
  D.23939 = sig->ret;
  simpletype = mini_type_get_underlying_type (gsctx, D.23939);
  D.23979 = simpletype->type;
  D.23980 = (int) D.23979;
  switch (D.23980) <default: <D.21971>, case 1: <D.21970>, case 2: <D.21945>, case 3: <D.21950>, case 4: <D.21946>, case 5: <D.21947>, case 6: <D.21948>, case 7: <D.21949>, case 8: <D.21951>, case 9: <D.21952>, case 10: <D.21964>, case 11: <D.21963>, case 12: <D.21965>, case 13: <D.21966>, case 14: <D.21961>, case 15: <D.21955>, case 17: <D.21968>, case 18: <D.21957>, case 20: <D.21960>, case 21: <D.21967>, case 22: <D.21969>, case 24: <D.21953>, case 25: <D.21954>, case 27: <D.21956>, case 28: <D.21958>, case 29: <D.21959>>
  <D.21945>:
  <D.21946>:
  <D.21947>:
  <D.21948>:
  <D.21949>:
  <D.21950>:
  <D.21951>:
  <D.21952>:
  <D.21953>:
  <D.21954>:
  <D.21955>:
  <D.21956>:
  <D.21957>:
  <D.21958>:
  <D.21959>:
  <D.21960>:
  <D.21961>:
  cinfo->ret.reg = 2;
  goto <D.21962>;
  <D.21963>:
  <D.21964>:
  cinfo->ret.reg = 2;
  goto <D.21962>;
  <D.21965>:
  <D.21966>:
  cinfo->ret.reg = 0;
  cinfo->ret.storage = 2;
  goto <D.21962>;
  <D.21967>:
  D.24048 = mono_type_generic_inst_is_valuetype (simpletype);
  if (D.24048 == 0) goto <D.24049>; else goto <D.24050>;
  <D.24049>:
  cinfo->ret.reg = 2;
  goto <D.21962>;
  <D.24050>:
  goto <D.21962>;
  <D.21968>:
  <D.21969>:
  goto <D.21962>;
  <D.21970>:
  goto <D.21962>;
  <D.21971>:
  D.23939 = sig->ret;
  D.24051 = D.23939->type;
  D.24052 = (int) D.24051;
  monoeg_g_log (0B, 4, "Can\'t handle as return value 0x%x", D.24052);
  <D.21972>:
  goto <D.21972>;
  <D.21962>:
  D.23999 = cinfo->stack_size;
  D.24053 = D.23999 + 15;
  D.24054 = D.24053 & -16;
  cinfo->stack_size = D.24054;
  D.23999 = cinfo->stack_size;
  D.24055 = (unsigned int) D.23999;
  cinfo->stack_usage = D.24055;
  D.24056 = cinfo;
  return D.24056;
}


add_int64_arg (struct CallInfo * info, struct ArgInfo * ainfo)
{
  int D.24060;
  int D.24063;
  int D.24068;
  unsigned int D.24069;
  unsigned int D.24070;
  _Bool D.24071;
  long int D.24072;
  long int D.24073;
  int D.24076;
  int D.24077;
  int D.24079;
  int D.24080;
  int D.24081;
  _Bool D.24082;
  long int D.24083;
  long int D.24084;
  unsigned char D.24087;
  int D.24088;
  int D.24089;

  D.24060 = info->on_stack;
  if (D.24060 == 0) goto <D.24061>; else goto <D.24062>;
  <D.24061>:
  D.24063 = info->gr;
  if (D.24063 > 6) goto <D.24064>; else goto <D.24065>;
  <D.24064>:
  args_onto_stack (info);
  <D.24065>:
  <D.24062>:
  D.24060 = info->on_stack;
  if (D.24060 != 0) goto <D.24066>; else goto <D.24067>;
  <D.24066>:
  D.24068 = info->stack_size;
  D.24069 = (unsigned int) D.24068;
  D.24070 = D.24069 & 3;
  D.24071 = D.24070 != 0;
  D.24072 = (long int) D.24071;
  D.24073 = __builtin_expect (D.24072, 0);
  if (D.24073 != 0) goto <D.24074>; else goto <D.24075>;
  <D.24074>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 847, "info->stack_size % 4 == 0");
  <D.24075>:
  D.24068 = info->stack_size;
  D.24068 = info->stack_size;
  D.24076 = D.24068 % 8;
  D.24077 = D.24068 + D.24076;
  info->stack_size = D.24077;
  ainfo->storage = 1;
  ainfo->reg = 29;
  D.24068 = info->stack_size;
  ainfo->offset = D.24068;
  goto <D.24078>;
  <D.24067>:
  D.24063 = info->gr;
  D.24063 = info->gr;
  D.24079 = D.24063 + -4;
  D.24080 = D.24079 % 2;
  D.24081 = D.24063 + D.24080;
  info->gr = D.24081;
  D.24063 = info->gr;
  D.24082 = D.24063 > 7;
  D.24083 = (long int) D.24082;
  D.24084 = __builtin_expect (D.24083, 0);
  if (D.24084 != 0) goto <D.24085>; else goto <D.24086>;
  <D.24085>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 857, "info->gr <= MIPS_LAST_ARG_REG");
  <D.24086>:
  ainfo->storage = 0;
  D.24063 = info->gr;
  D.24087 = (unsigned char) D.24063;
  ainfo->reg = D.24087;
  D.24063 = info->gr;
  D.24088 = D.24063 + 2;
  info->gr = D.24088;
  info->gr_passed = 1;
  <D.24078>:
  D.24068 = info->stack_size;
  D.24089 = D.24068 + 8;
  info->stack_size = D.24089;
}


add_float32_arg (struct CallInfo * info, struct ArgInfo * ainfo)
{
  int D.24090;
  int D.24093;
  int D.24098;
  int D.24102;
  int D.24104;
  unsigned char D.24106;
  int D.24107;
  int D.24108;
  unsigned char D.24109;
  int D.24110;

  D.24090 = info->on_stack;
  if (D.24090 == 0) goto <D.24091>; else goto <D.24092>;
  <D.24091>:
  D.24093 = info->gr;
  if (D.24093 > 7) goto <D.24094>; else goto <D.24095>;
  <D.24094>:
  args_onto_stack (info);
  <D.24095>:
  <D.24092>:
  D.24090 = info->on_stack;
  if (D.24090 != 0) goto <D.24096>; else goto <D.24097>;
  <D.24096>:
  ainfo->storage = 1;
  ainfo->reg = 29;
  D.24098 = info->stack_size;
  ainfo->offset = D.24098;
  goto <D.24099>;
  <D.24097>:
  D.24102 = info->gr_passed;
  if (D.24102 == 0) goto <D.24103>; else goto <D.24100>;
  <D.24103>:
  D.24104 = info->fr;
  if (D.24104 <= 14) goto <D.24105>; else goto <D.24100>;
  <D.24105>:
  ainfo->storage = 2;
  D.24104 = info->fr;
  D.24106 = (unsigned char) D.24104;
  ainfo->reg = D.24106;
  D.24104 = info->fr;
  D.24107 = D.24104 + 2;
  info->fr = D.24107;
  D.24093 = info->gr;
  D.24108 = D.24093 + 1;
  info->gr = D.24108;
  goto <D.24101>;
  <D.24100>:
  ainfo->storage = 0;
  D.24093 = info->gr;
  D.24109 = (unsigned char) D.24093;
  ainfo->reg = D.24109;
  D.24093 = info->gr;
  D.24108 = D.24093 + 1;
  info->gr = D.24108;
  info->gr_passed = 1;
  <D.24101>:
  <D.24099>:
  D.24098 = info->stack_size;
  D.24110 = D.24098 + 4;
  info->stack_size = D.24110;
}


add_float64_arg (struct CallInfo * info, struct ArgInfo * ainfo)
{
  int D.24111;
  int D.24114;
  int D.24119;
  unsigned int D.24120;
  unsigned int D.24121;
  _Bool D.24122;
  long int D.24123;
  long int D.24124;
  int D.24127;
  int D.24128;
  int D.24132;
  int D.24134;
  unsigned char D.24136;
  int D.24137;
  int D.24138;
  int D.24139;
  int D.24140;
  int D.24141;
  _Bool D.24142;
  long int D.24143;
  long int D.24144;
  unsigned char D.24147;
  int D.24148;

  D.24111 = info->on_stack;
  if (D.24111 == 0) goto <D.24112>; else goto <D.24113>;
  <D.24112>:
  D.24114 = info->gr;
  if (D.24114 > 6) goto <D.24115>; else goto <D.24116>;
  <D.24115>:
  args_onto_stack (info);
  <D.24116>:
  <D.24113>:
  D.24111 = info->on_stack;
  if (D.24111 != 0) goto <D.24117>; else goto <D.24118>;
  <D.24117>:
  D.24119 = info->stack_size;
  D.24120 = (unsigned int) D.24119;
  D.24121 = D.24120 & 3;
  D.24122 = D.24121 != 0;
  D.24123 = (long int) D.24122;
  D.24124 = __builtin_expect (D.24123, 0);
  if (D.24124 != 0) goto <D.24125>; else goto <D.24126>;
  <D.24125>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 912, "info->stack_size % 4 == 0");
  <D.24126>:
  D.24119 = info->stack_size;
  D.24119 = info->stack_size;
  D.24127 = D.24119 % 8;
  D.24128 = D.24119 + D.24127;
  info->stack_size = D.24128;
  ainfo->storage = 1;
  ainfo->reg = 29;
  D.24119 = info->stack_size;
  ainfo->offset = D.24119;
  goto <D.24129>;
  <D.24118>:
  D.24132 = info->gr_passed;
  if (D.24132 == 0) goto <D.24133>; else goto <D.24130>;
  <D.24133>:
  D.24134 = info->fr;
  if (D.24134 <= 14) goto <D.24135>; else goto <D.24130>;
  <D.24135>:
  ainfo->storage = 2;
  D.24134 = info->fr;
  D.24136 = (unsigned char) D.24134;
  ainfo->reg = D.24136;
  D.24134 = info->fr;
  D.24137 = D.24134 + 2;
  info->fr = D.24137;
  D.24114 = info->gr;
  D.24138 = D.24114 + 2;
  info->gr = D.24138;
  goto <D.24131>;
  <D.24130>:
  D.24114 = info->gr;
  D.24114 = info->gr;
  D.24139 = D.24114 + -4;
  D.24140 = D.24139 % 2;
  D.24141 = D.24114 + D.24140;
  info->gr = D.24141;
  D.24114 = info->gr;
  D.24142 = D.24114 > 7;
  D.24143 = (long int) D.24142;
  D.24144 = __builtin_expect (D.24143, 0);
  if (D.24144 != 0) goto <D.24145>; else goto <D.24146>;
  <D.24145>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 931, "info->gr <= MIPS_LAST_ARG_REG");
  <D.24146>:
  ainfo->storage = 0;
  D.24114 = info->gr;
  D.24147 = (unsigned char) D.24114;
  ainfo->reg = D.24147;
  D.24114 = info->gr;
  D.24138 = D.24114 + 2;
  info->gr = D.24138;
  info->gr_passed = 1;
  <D.24131>:
  <D.24129>:
  D.24119 = info->stack_size;
  D.24148 = D.24119 + 8;
  info->stack_size = D.24148;
}


args_onto_stack (struct CallInfo * info)
{
  int D.24149;
  _Bool D.24150;
  long int D.24151;
  long int D.24152;
  int D.24155;
  _Bool D.24156;
  long int D.24157;
  long int D.24158;

  D.24149 = info->on_stack;
  D.24150 = D.24149 != 0;
  D.24151 = (long int) D.24150;
  D.24152 = __builtin_expect (D.24151, 0);
  if (D.24152 != 0) goto <D.24153>; else goto <D.24154>;
  <D.24153>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 807, "!info->on_stack");
  <D.24154>:
  D.24155 = info->stack_size;
  D.24156 = D.24155 > 16;
  D.24157 = (long int) D.24156;
  D.24158 = __builtin_expect (D.24157, 0);
  if (D.24158 != 0) goto <D.24159>; else goto <D.24160>;
  <D.24159>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 808, "info->stack_size <= MIPS_STACK_PARAM_OFFSET");
  <D.24160>:
  info->on_stack = 1;
  info->stack_size = 16;
}


add_int32_arg (struct CallInfo * info, struct ArgInfo * ainfo)
{
  int D.24161;
  int D.24164;
  int D.24169;
  unsigned char D.24171;
  int D.24172;
  int D.24173;

  D.24161 = info->on_stack;
  if (D.24161 == 0) goto <D.24162>; else goto <D.24163>;
  <D.24162>:
  D.24164 = info->gr;
  if (D.24164 > 7) goto <D.24165>; else goto <D.24166>;
  <D.24165>:
  args_onto_stack (info);
  <D.24166>:
  <D.24163>:
  D.24161 = info->on_stack;
  if (D.24161 != 0) goto <D.24167>; else goto <D.24168>;
  <D.24167>:
  ainfo->storage = 1;
  ainfo->reg = 29;
  D.24169 = info->stack_size;
  ainfo->offset = D.24169;
  goto <D.24170>;
  <D.24168>:
  ainfo->storage = 0;
  D.24164 = info->gr;
  D.24171 = (unsigned char) D.24164;
  ainfo->reg = D.24171;
  D.24164 = info->gr;
  D.24172 = D.24164 + 1;
  info->gr = D.24172;
  info->gr_passed = 1;
  <D.24170>:
  D.24169 = info->stack_size;
  D.24173 = D.24169 + 4;
  info->stack_size = D.24173;
}


mono_arch_compute_omit_fp (struct MonoCompile * cfg)
{
  int D.24174;
  struct MonoMethod * D.24177;
  void * D.24178;
  struct MonoGenericSharingContext * D.24181;
  struct MonoMemPool * D.24182;
  struct CallInfo * D.24183;
  unsigned int D.24184;
  unsigned int D.24185;
  int D.24188;
  unsigned int D.24191;
  unsigned int D.24192;
  unsigned int D.24195;
  unsigned int D.24196;
  unsigned int D.24199;
  unsigned int D.24200;
  unsigned int D.24203;
  unsigned int D.24204;
  struct MonoTraceSpec * mono_jit_trace_calls.42;
  int D.24212;
  unsigned int D.24213;
  unsigned int D.24214;
  unsigned int D.24215;
  struct MonoInst * * D.24216;
  unsigned int i.43;
  unsigned int D.24218;
  struct MonoInst * * D.24219;
  struct MonoType * D.24220;
  int D.24221;
  unsigned int i.44;
  unsigned int D.24223;
  struct MonoMethodSignature * sig;
  struct MonoMethodHeader * header;
  int i;
  int locals_size;
  struct CallInfo * cinfo;

  D.24174 = cfg->arch.omit_fp_computed;
  if (D.24174 != 0) goto <D.24175>; else goto <D.24176>;
  <D.24175>:
  return;
  <D.24176>:
  header = cfg->header;
  D.24177 = cfg->method;
  sig = mono_method_signature (D.24177);
  D.24178 = cfg->arch.cinfo;
  if (D.24178 == 0B) goto <D.24179>; else goto <D.24180>;
  <D.24179>:
  D.24181 = cfg->generic_sharing_context;
  D.24182 = cfg->mempool;
  D.24183 = get_call_info (D.24181, D.24182, sig);
  cfg->arch.cinfo = D.24183;
  <D.24180>:
  cinfo = cfg->arch.cinfo;
  cfg->arch.omit_fp = 1;
  cfg->arch.omit_fp_computed = 1;
  D.24184 = BIT_FIELD_REF <*cfg, 32, 3392>;
  D.24185 = D.24184 & 2097152;
  if (D.24185 != 0) goto <D.24186>; else goto <D.24187>;
  <D.24186>:
  cfg->arch.omit_fp = 0;
  <D.24187>:
  D.24188 = debug_omit_fp ();
  if (D.24188 == 0) goto <D.24189>; else goto <D.24190>;
  <D.24189>:
  cfg->arch.omit_fp = 0;
  <D.24190>:
  D.24177 = cfg->method;
  D.24191 = BIT_FIELD_REF <*D.24177, 32, 160>;
  D.24192 = D.24191 & 256;
  if (D.24192 != 0) goto <D.24193>; else goto <D.24194>;
  <D.24193>:
  cfg->arch.omit_fp = 0;
  <D.24194>:
  D.24195 = cfg->flags;
  D.24196 = D.24195 & 1;
  if (D.24196 != 0) goto <D.24197>; else goto <D.24198>;
  <D.24197>:
  cfg->arch.omit_fp = 0;
  <D.24198>:
  D.24199 = BIT_FIELD_REF <*header, 32, 64>;
  D.24200 = D.24199 & 2147418112;
  if (D.24200 != 0) goto <D.24201>; else goto <D.24202>;
  <D.24201>:
  cfg->arch.omit_fp = 0;
  <D.24202>:
  D.24203 = BIT_FIELD_REF <*sig, 32, 64>;
  D.24204 = D.24203 & 20905984;
  if (D.24204 == 327680) goto <D.24205>; else goto <D.24206>;
  <D.24205>:
  cfg->arch.omit_fp = 0;
  <D.24206>:
  mono_jit_trace_calls.42 = mono_jit_trace_calls;
  if (mono_jit_trace_calls.42 != 0B) goto <D.24211>; else goto <D.24207>;
  <D.24211>:
  D.24177 = cfg->method;
  D.24212 = mono_trace_eval (D.24177);
  if (D.24212 != 0) goto <D.24208>; else goto <D.24207>;
  <D.24207>:
  D.24213 = cfg->prof_options;
  D.24214 = D.24213 & 4096;
  if (D.24214 != 0) goto <D.24208>; else goto <D.24209>;
  <D.24208>:
  cfg->arch.omit_fp = 0;
  <D.24209>:
  locals_size = 0;
  D.24215 = cfg->locals_start;
  i = (int) D.24215;
  goto <D.21987>;
  <D.21986>:
  {
    struct MonoInst * ins;
    int ialign;

    try
      {
        D.24216 = cfg->varinfo;
        i.43 = (unsigned int) i;
        D.24218 = i.43 * 4;
        D.24219 = D.24216 + D.24218;
        ins = *D.24219;
        D.24220 = ins->data.op[1].vtype;
        D.24221 = mono_type_size (D.24220, &ialign);
        locals_size = D.24221 + locals_size;
      }
    finally
      {
        ialign = {CLOBBER};
      }
  }
  i = i + 1;
  <D.21987>:
  i.44 = (unsigned int) i;
  D.24223 = cfg->num_varinfo;
  if (i.44 < D.24223) goto <D.21986>; else goto <D.21988>;
  <D.21988>:
}


debug_omit_fp ()
{
  gboolean D.24225;

  D.24225 = 1;
  return D.24225;
}


mono_arch_create_vars (struct MonoCompile * cfg)
{
  struct MonoMethod * D.24227;
  struct MonoType * D.24228;
  int D.24229;
  struct MonoClass * D.24232;
  struct MonoType * D.24233;
  struct MonoInst * D.24234;
  unsigned int D.24235;
  _Bool D.24236;
  long int D.24237;
  long int D.24238;
  struct MonoInst * D.24241;
  struct MonoMethodSignature * sig;

  D.24227 = cfg->method;
  sig = mono_method_signature (D.24227);
  D.24228 = sig->ret;
  D.24229 = mono_type_is_struct (D.24228);
  if (D.24229 != 0) goto <D.24230>; else goto <D.24231>;
  <D.24230>:
  D.24232 = mono_defaults.int_class;
  D.24233 = &D.24232->byval_arg;
  D.24234 = mono_compile_create_var (cfg, D.24233, 330);
  cfg->vret_addr = D.24234;
  D.24235 = cfg->verbose_level;
  D.24236 = D.24235 > 1;
  D.24237 = (long int) D.24236;
  D.24238 = __builtin_expect (D.24237, 0);
  if (D.24238 != 0) goto <D.24239>; else goto <D.24240>;
  <D.24239>:
  printf ("vret_addr = ");
  D.24241 = cfg->vret_addr;
  mono_print_ins (D.24241);
  <D.24240>:
  <D.24231>:
}


mono_arch_emit_call (struct MonoCompile * cfg, struct MonoCallInst * call)
{
  short unsigned int D.24242;
  int D.24243;
  <unnamed-unsigned:1> D.24244;
  int D.24245;
  struct MonoMemPool * D.24246;
  unsigned int D.24247;
  unsigned int D.24250;
  int D.24251;
  int D.24252;
  unsigned int D.24253;
  unsigned int D.24254;
  sizetype i.45;
  int D.24258;
  struct MonoClass * D.24260;
  struct MonoGenericSharingContext * D.24261;
  unsigned int D.24262;
  unsigned int D.24263;
  short int D.24266;
  int D.24267;
  struct MonoInst * * D.24274;
  unsigned int i.46;
  unsigned int D.24276;
  struct MonoInst * * D.24277;
  unsigned char D.24278;
  int D.24279;
  int D.24280;
  unsigned int D.24281;
  unsigned int D.24282;
  <unnamed type> D.24283;
  unsigned int D.24288;
  unsigned int D.24289;
  unsigned char D.24291;
  unsigned char D.24292;
  int D.24294;
  struct MonoInst * D.24295;
  int D.24296;
  int D.24297;
  const unsigned char * D.24298;
  unsigned int D.24299;
  int D.24300;
  int D.24301;
  int D.24302;
  struct MonoBasicBlock * D.24303;
  struct MonoInst * D.24304;
  int D.24308;
  int ls_word_idx.47;
  int D.24310;
  unsigned int D.24311;
  int D.24312;
  int D.24313;
  int ms_word_idx.48;
  int D.24318;
  unsigned int D.24319;
  unsigned int D.24322;
  int D.24323;
  unsigned int D.24327;
  int D.24328;
  unsigned int D.24335;
  int D.24336;
  unsigned int D.24341;
  int D.24342;
  struct MonoClass * D.24349;
  void * D.24350;
  void * D.24351;
  void * D.24358;
  int D.24369;
  struct MonoInst * D.24370;
  int D.24371;
  int D.24372;
  int D.24373;
  unsigned char D.24380;
  int D.24384;
  struct MonoInst * D.24385;
  int D.24386;
  int D.24387;
  int D.24392;
  struct MonoInst * D.24393;
  int D.24394;
  int D.24395;
  int D.24399;
  struct MonoInst * D.24400;
  int D.24401;
  int D.24402;
  void * D.24411;
  unsigned int D.24415;
  unsigned int D.24416;
  unsigned int D.24418;
  unsigned int D.24419;
  unsigned int D.24420;
  int D.24423;
  struct MonoInst * D.24424;
  int D.24425;
  int D.24426;
  unsigned int D.24435;
  int D.24442;
  struct MonoInst * D.24443;
  int D.24444;
  int D.24445;
  struct MonoInst * D.24446;
  int D.24447;
  unsigned int D.24448;
  int D.24449;
  int D.24453;
  unsigned int D.24454;
  unsigned int D.24455;
  unsigned int D.24456;
  unsigned int D.24457;
  unsigned int D.24458;
  unsigned int D.24459;
  unsigned int D.24460;
  struct MonoInst * in;
  struct MonoInst * ins;
  struct MonoMethodSignature * sig;
  int i;
  int n;
  struct CallInfo * cinfo;
  int is_virtual;

  is_virtual = 0;
  sig = call->signature;
  D.24242 = sig->param_count;
  D.24243 = (int) D.24242;
  D.24244 = sig->hasthis;
  D.24245 = (int) D.24244;
  n = D.24243 + D.24245;
  D.24246 = cfg->mempool;
  cinfo = get_call_info (0B, D.24246, sig);
  D.24247 = cinfo->struct_ret;
  if (D.24247 != 0) goto <D.24248>; else goto <D.24249>;
  <D.24248>:
  D.24250 = call->used_iregs;
  D.24247 = cinfo->struct_ret;
  D.24251 = (int) D.24247;
  D.24252 = 1 << D.24251;
  D.24253 = (unsigned int) D.24252;
  D.24254 = D.24250 | D.24253;
  call->used_iregs = D.24254;
  <D.24249>:
  i = 0;
  goto <D.22053>;
  <D.22052>:
  {
    struct ArgInfo * ainfo;
    struct MonoType * t;

    i.45 = (sizetype) i;
    ainfo = &cinfo->args[i.45];
    D.24244 = sig->hasthis;
    D.24245 = (int) D.24244;
    if (D.24245 <= i) goto <D.24256>; else goto <D.24257>;
    <D.24256>:
    D.24244 = sig->hasthis;
    D.24245 = (int) D.24244;
    D.24258 = i - D.24245;
    t = sig->params[D.24258];
    goto <D.24259>;
    <D.24257>:
    D.24260 = mono_defaults.int_class;
    t = &D.24260->byval_arg;
    <D.24259>:
    D.24261 = cfg->generic_sharing_context;
    t = mini_type_get_underlying_type (D.24261, t);
    D.24262 = BIT_FIELD_REF <*sig, 32, 64>;
    D.24263 = D.24262 & 4128768;
    if (D.24263 == 327680) goto <D.24264>; else goto <D.24265>;
    <D.24264>:
    D.24266 = sig->sentinelpos;
    D.24267 = (int) D.24266;
    if (D.24267 == i) goto <D.24268>; else goto <D.24269>;
    <D.24268>:
    emit_sig_cookie (cfg, call, cinfo);
    <D.24269>:
    <D.24265>:
    if (is_virtual != 0) goto <D.24270>; else goto <D.24271>;
    <D.24270>:
    if (i == 0) goto <D.24272>; else goto <D.24273>;
    <D.24272>:
    D.24274 = call->args;
    i.46 = (unsigned int) i;
    D.24276 = i.46 * 4;
    D.24277 = D.24274 + D.24276;
    in = *D.24277;
    D.24250 = call->used_iregs;
    D.24278 = ainfo->reg;
    D.24279 = (int) D.24278;
    D.24280 = 1 << D.24279;
    D.24281 = (unsigned int) D.24280;
    D.24282 = D.24250 | D.24281;
    call->used_iregs = D.24282;
    // predicted unlikely by continue predictor.
    goto <D.22044>;
    <D.24273>:
    <D.24271>:
    D.24274 = call->args;
    i.46 = (unsigned int) i;
    D.24276 = i.46 * 4;
    D.24277 = D.24274 + D.24276;
    in = *D.24277;
    D.24283 = ainfo->storage;
    if (D.24283 == 0) goto <D.24284>; else goto <D.24285>;
    <D.24284>:
    D.24288 = BIT_FIELD_REF <*t, 32, 32>;
    D.24289 = D.24288 & 1073741824;
    if (D.24289 == 0) goto <D.24290>; else goto <D.24286>;
    <D.24290>:
    D.24291 = t->type;
    D.24292 = D.24291 + 246;
    if (D.24292 <= 1) goto <D.24293>; else goto <D.24286>;
    <D.24293>:
    D.24246 = cfg->mempool;
    ins = mono_mempool_alloc (D.24246, 56);
    ins->data.op[1].const_val = 0;
    D.24294 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.24294;
    ins->prev = 0B;
    D.24295 = ins->prev;
    ins->next = D.24295;
    ins->opcode = 424;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.24296 = ins->sreg3;
    ins->sreg2 = D.24296;
    D.24297 = ins->sreg2;
    ins->sreg1 = D.24297;
    D.24298 = cfg->ip;
    ins->cil_code = D.24298;
    D.24299 = mono_alloc_ireg (cfg);
    D.24300 = (int) D.24299;
    ins->dreg = D.24300;
    D.24301 = in->dreg;
    D.24302 = D.24301 + 1;
    ins->sreg1 = D.24302;
    D.24303 = cfg->cbb;
    D.24304 = D.24303->last_ins;
    if (D.24304 != 0B) goto <D.24305>; else goto <D.24306>;
    <D.24305>:
    D.24303 = cfg->cbb;
    D.24304 = D.24303->last_ins;
    D.24304->next = ins;
    D.24303 = cfg->cbb;
    D.24304 = D.24303->last_ins;
    ins->prev = D.24304;
    D.24303 = cfg->cbb;
    D.24303->last_ins = ins;
    goto <D.24307>;
    <D.24306>:
    D.24303 = cfg->cbb;
    D.24303 = cfg->cbb;
    D.24303->last_ins = ins;
    D.24304 = D.24303->last_ins;
    D.24303->code = D.24304;
    <D.24307>:
    D.24308 = ins->dreg;
    D.24278 = ainfo->reg;
    D.24279 = (int) D.24278;
    ls_word_idx.47 = ls_word_idx;
    D.24310 = D.24279 + ls_word_idx.47;
    mono_call_inst_add_outarg_reg (cfg, call, D.24308, D.24310, 0);
    D.24246 = cfg->mempool;
    ins = mono_mempool_alloc (D.24246, 56);
    ins->data.op[1].const_val = 0;
    D.24294 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.24294;
    ins->prev = 0B;
    D.24295 = ins->prev;
    ins->next = D.24295;
    ins->opcode = 424;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.24296 = ins->sreg3;
    ins->sreg2 = D.24296;
    D.24297 = ins->sreg2;
    ins->sreg1 = D.24297;
    D.24298 = cfg->ip;
    ins->cil_code = D.24298;
    D.24311 = mono_alloc_ireg (cfg);
    D.24312 = (int) D.24311;
    ins->dreg = D.24312;
    D.24301 = in->dreg;
    D.24313 = D.24301 + 2;
    ins->sreg1 = D.24313;
    D.24303 = cfg->cbb;
    D.24304 = D.24303->last_ins;
    if (D.24304 != 0B) goto <D.24314>; else goto <D.24315>;
    <D.24314>:
    D.24303 = cfg->cbb;
    D.24304 = D.24303->last_ins;
    D.24304->next = ins;
    D.24303 = cfg->cbb;
    D.24304 = D.24303->last_ins;
    ins->prev = D.24304;
    D.24303 = cfg->cbb;
    D.24303->last_ins = ins;
    goto <D.24316>;
    <D.24315>:
    D.24303 = cfg->cbb;
    D.24303 = cfg->cbb;
    D.24303->last_ins = ins;
    D.24304 = D.24303->last_ins;
    D.24303->code = D.24304;
    <D.24316>:
    D.24308 = ins->dreg;
    D.24278 = ainfo->reg;
    D.24279 = (int) D.24278;
    ms_word_idx.48 = ms_word_idx;
    D.24318 = D.24279 + ms_word_idx.48;
    mono_call_inst_add_outarg_reg (cfg, call, D.24308, D.24318, 0);
    goto <D.24287>;
    <D.24286>:
    D.24288 = BIT_FIELD_REF <*t, 32, 32>;
    D.24319 = D.24288 & 1090453504;
    if (D.24319 == 786432) goto <D.24320>; else goto <D.24321>;
    <D.24320>:
    {
      int freg;

      D.24246 = cfg->mempool;
      ins = mono_mempool_alloc (D.24246, 56);
      ins->data.op[1].const_val = 0;
      D.24294 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.24294;
      ins->prev = 0B;
      D.24295 = ins->prev;
      ins->next = D.24295;
      ins->opcode = 848;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.24296 = ins->sreg3;
      ins->sreg2 = D.24296;
      D.24297 = ins->sreg2;
      ins->sreg1 = D.24297;
      D.24298 = cfg->ip;
      ins->cil_code = D.24298;
      D.24322 = mono_alloc_freg (cfg);
      D.24323 = (int) D.24322;
      ins->dreg = D.24323;
      D.24301 = in->dreg;
      ins->sreg1 = D.24301;
      D.24303 = cfg->cbb;
      D.24304 = D.24303->last_ins;
      if (D.24304 != 0B) goto <D.24324>; else goto <D.24325>;
      <D.24324>:
      D.24303 = cfg->cbb;
      D.24304 = D.24303->last_ins;
      D.24304->next = ins;
      D.24303 = cfg->cbb;
      D.24304 = D.24303->last_ins;
      ins->prev = D.24304;
      D.24303 = cfg->cbb;
      D.24303->last_ins = ins;
      goto <D.24326>;
      <D.24325>:
      D.24303 = cfg->cbb;
      D.24303 = cfg->cbb;
      D.24303->last_ins = ins;
      D.24304 = D.24303->last_ins;
      D.24303->code = D.24304;
      <D.24326>:
      freg = ins->dreg;
      D.24246 = cfg->mempool;
      ins = mono_mempool_alloc (D.24246, 56);
      ins->data.op[1].const_val = 0;
      D.24294 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.24294;
      ins->prev = 0B;
      D.24295 = ins->prev;
      ins->next = D.24295;
      ins->opcode = 864;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.24296 = ins->sreg3;
      ins->sreg2 = D.24296;
      D.24297 = ins->sreg2;
      ins->sreg1 = D.24297;
      D.24298 = cfg->ip;
      ins->cil_code = D.24298;
      D.24327 = mono_alloc_ireg (cfg);
      D.24328 = (int) D.24327;
      ins->dreg = D.24328;
      ins->sreg1 = freg;
      D.24303 = cfg->cbb;
      D.24304 = D.24303->last_ins;
      if (D.24304 != 0B) goto <D.24329>; else goto <D.24330>;
      <D.24329>:
      D.24303 = cfg->cbb;
      D.24304 = D.24303->last_ins;
      D.24304->next = ins;
      D.24303 = cfg->cbb;
      D.24304 = D.24303->last_ins;
      ins->prev = D.24304;
      D.24303 = cfg->cbb;
      D.24303->last_ins = ins;
      goto <D.24331>;
      <D.24330>:
      D.24303 = cfg->cbb;
      D.24303 = cfg->cbb;
      D.24303->last_ins = ins;
      D.24304 = D.24303->last_ins;
      D.24303->code = D.24304;
      <D.24331>:
      D.24308 = ins->dreg;
      D.24278 = ainfo->reg;
      D.24279 = (int) D.24278;
      mono_call_inst_add_outarg_reg (cfg, call, D.24308, D.24279, 0);
    }
    goto <D.24332>;
    <D.24321>:
    D.24288 = BIT_FIELD_REF <*t, 32, 32>;
    D.24319 = D.24288 & 1090453504;
    if (D.24319 == 851968) goto <D.24333>; else goto <D.24334>;
    <D.24333>:
    D.24246 = cfg->mempool;
    ins = mono_mempool_alloc (D.24246, 56);
    ins->data.op[1].const_val = 0;
    D.24294 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.24294;
    ins->prev = 0B;
    D.24295 = ins->prev;
    ins->next = D.24295;
    ins->opcode = 866;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.24296 = ins->sreg3;
    ins->sreg2 = D.24296;
    D.24297 = ins->sreg2;
    ins->sreg1 = D.24297;
    D.24298 = cfg->ip;
    ins->cil_code = D.24298;
    D.24335 = mono_alloc_ireg (cfg);
    D.24336 = (int) D.24335;
    ins->dreg = D.24336;
    D.24301 = in->dreg;
    ins->sreg1 = D.24301;
    D.24303 = cfg->cbb;
    D.24304 = D.24303->last_ins;
    if (D.24304 != 0B) goto <D.24337>; else goto <D.24338>;
    <D.24337>:
    D.24303 = cfg->cbb;
    D.24304 = D.24303->last_ins;
    D.24304->next = ins;
    D.24303 = cfg->cbb;
    D.24304 = D.24303->last_ins;
    ins->prev = D.24304;
    D.24303 = cfg->cbb;
    D.24303->last_ins = ins;
    goto <D.24339>;
    <D.24338>:
    D.24303 = cfg->cbb;
    D.24303 = cfg->cbb;
    D.24303->last_ins = ins;
    D.24304 = D.24303->last_ins;
    D.24303->code = D.24304;
    <D.24339>:
    D.24308 = ins->dreg;
    D.24278 = ainfo->reg;
    D.24279 = (int) D.24278;
    mono_call_inst_add_outarg_reg (cfg, call, D.24308, D.24279, 0);
    goto <D.24340>;
    <D.24334>:
    D.24246 = cfg->mempool;
    ins = mono_mempool_alloc (D.24246, 56);
    ins->data.op[1].const_val = 0;
    D.24294 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.24294;
    ins->prev = 0B;
    D.24295 = ins->prev;
    ins->next = D.24295;
    ins->opcode = 424;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.24296 = ins->sreg3;
    ins->sreg2 = D.24296;
    D.24297 = ins->sreg2;
    ins->sreg1 = D.24297;
    D.24298 = cfg->ip;
    ins->cil_code = D.24298;
    D.24341 = mono_alloc_ireg (cfg);
    D.24342 = (int) D.24341;
    ins->dreg = D.24342;
    D.24301 = in->dreg;
    ins->sreg1 = D.24301;
    D.24303 = cfg->cbb;
    D.24304 = D.24303->last_ins;
    if (D.24304 != 0B) goto <D.24343>; else goto <D.24344>;
    <D.24343>:
    D.24303 = cfg->cbb;
    D.24304 = D.24303->last_ins;
    D.24304->next = ins;
    D.24303 = cfg->cbb;
    D.24304 = D.24303->last_ins;
    ins->prev = D.24304;
    D.24303 = cfg->cbb;
    D.24303->last_ins = ins;
    goto <D.24345>;
    <D.24344>:
    D.24303 = cfg->cbb;
    D.24303 = cfg->cbb;
    D.24303->last_ins = ins;
    D.24304 = D.24303->last_ins;
    D.24303->code = D.24304;
    <D.24345>:
    D.24308 = ins->dreg;
    D.24278 = ainfo->reg;
    D.24279 = (int) D.24278;
    mono_call_inst_add_outarg_reg (cfg, call, D.24308, D.24279, 0);
    <D.24340>:
    <D.24332>:
    <D.24287>:
    goto <D.24346>;
    <D.24285>:
    D.24283 = ainfo->storage;
    if (D.24283 == 4) goto <D.24347>; else goto <D.24348>;
    <D.24347>:
    D.24246 = cfg->mempool;
    ins = mono_mempool_alloc (D.24246, 56);
    ins->data.op[1].const_val = 0;
    D.24294 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.24294;
    ins->prev = 0B;
    D.24295 = ins->prev;
    ins->next = D.24295;
    ins->opcode = 333;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.24296 = ins->sreg3;
    ins->sreg2 = D.24296;
    D.24297 = ins->sreg2;
    ins->sreg1 = D.24297;
    D.24298 = cfg->ip;
    ins->cil_code = D.24298;
    ins->opcode = 333;
    D.24301 = in->dreg;
    ins->sreg1 = D.24301;
    D.24349 = in->klass;
    ins->klass = D.24349;
    ins->data.op[0].p = call;
    D.24246 = cfg->mempool;
    D.24350 = mono_mempool_alloc (D.24246, 16);
    ins->data.op[1].p = D.24350;
    D.24351 = ins->data.op[1].p;
    memcpy (D.24351, ainfo, 16);
    D.24303 = cfg->cbb;
    D.24304 = D.24303->last_ins;
    if (D.24304 != 0B) goto <D.24352>; else goto <D.24353>;
    <D.24352>:
    D.24303 = cfg->cbb;
    D.24304 = D.24303->last_ins;
    D.24304->next = ins;
    D.24303 = cfg->cbb;
    D.24304 = D.24303->last_ins;
    ins->prev = D.24304;
    D.24303 = cfg->cbb;
    D.24303->last_ins = ins;
    goto <D.24354>;
    <D.24353>:
    D.24303 = cfg->cbb;
    D.24303 = cfg->cbb;
    D.24303->last_ins = ins;
    D.24304 = D.24303->last_ins;
    D.24303->code = D.24304;
    <D.24354>:
    goto <D.24355>;
    <D.24348>:
    D.24283 = ainfo->storage;
    if (D.24283 == 3) goto <D.24356>; else goto <D.24357>;
    <D.24356>:
    D.24246 = cfg->mempool;
    ins = mono_mempool_alloc (D.24246, 56);
    ins->data.op[1].const_val = 0;
    D.24294 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.24294;
    ins->prev = 0B;
    D.24295 = ins->prev;
    ins->next = D.24295;
    ins->opcode = 333;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.24296 = ins->sreg3;
    ins->sreg2 = D.24296;
    D.24297 = ins->sreg2;
    ins->sreg1 = D.24297;
    D.24298 = cfg->ip;
    ins->cil_code = D.24298;
    ins->opcode = 333;
    D.24301 = in->dreg;
    ins->sreg1 = D.24301;
    D.24349 = in->klass;
    ins->klass = D.24349;
    ins->data.op[0].p = call;
    D.24246 = cfg->mempool;
    D.24358 = mono_mempool_alloc (D.24246, 16);
    ins->data.op[1].p = D.24358;
    D.24351 = ins->data.op[1].p;
    memcpy (D.24351, ainfo, 16);
    D.24303 = cfg->cbb;
    D.24304 = D.24303->last_ins;
    if (D.24304 != 0B) goto <D.24359>; else goto <D.24360>;
    <D.24359>:
    D.24303 = cfg->cbb;
    D.24304 = D.24303->last_ins;
    D.24304->next = ins;
    D.24303 = cfg->cbb;
    D.24304 = D.24303->last_ins;
    ins->prev = D.24304;
    D.24303 = cfg->cbb;
    D.24303->last_ins = ins;
    goto <D.24361>;
    <D.24360>:
    D.24303 = cfg->cbb;
    D.24303 = cfg->cbb;
    D.24303->last_ins = ins;
    D.24304 = D.24303->last_ins;
    D.24303->code = D.24304;
    <D.24361>:
    goto <D.24362>;
    <D.24357>:
    D.24283 = ainfo->storage;
    if (D.24283 == 1) goto <D.24363>; else goto <D.24364>;
    <D.24363>:
    D.24288 = BIT_FIELD_REF <*t, 32, 32>;
    D.24289 = D.24288 & 1073741824;
    if (D.24289 == 0) goto <D.24367>; else goto <D.24365>;
    <D.24367>:
    D.24291 = t->type;
    D.24292 = D.24291 + 246;
    if (D.24292 <= 1) goto <D.24368>; else goto <D.24365>;
    <D.24368>:
    {
      struct MonoInst * inst;

      D.24246 = cfg->mempool;
      inst = mono_mempool_alloc (D.24246, 56);
      inst->data.op[1].const_val = 0;
      D.24369 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.24369;
      inst->prev = 0B;
      D.24370 = inst->prev;
      inst->next = D.24370;
      inst->opcode = 378;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.24371 = inst->sreg3;
      inst->sreg2 = D.24371;
      D.24372 = inst->sreg2;
      inst->sreg1 = D.24372;
      D.24298 = cfg->ip;
      inst->cil_code = D.24298;
      D.24301 = in->dreg;
      inst->sreg1 = D.24301;
      inst->dreg = 29;
      D.24373 = ainfo->offset;
      inst->data.op[0].const_val = D.24373;
      D.24303 = cfg->cbb;
      D.24304 = D.24303->last_ins;
      if (D.24304 != 0B) goto <D.24374>; else goto <D.24375>;
      <D.24374>:
      D.24303 = cfg->cbb;
      D.24304 = D.24303->last_ins;
      D.24304->next = inst;
      D.24303 = cfg->cbb;
      D.24304 = D.24303->last_ins;
      inst->prev = D.24304;
      D.24303 = cfg->cbb;
      D.24303->last_ins = inst;
      goto <D.24376>;
      <D.24375>:
      D.24303 = cfg->cbb;
      D.24303 = cfg->cbb;
      D.24303->last_ins = inst;
      D.24304 = D.24303->last_ins;
      D.24303->code = D.24304;
      <D.24376>:
    }
    goto <D.24366>;
    <D.24365>:
    D.24288 = BIT_FIELD_REF <*t, 32, 32>;
    D.24289 = D.24288 & 1073741824;
    if (D.24289 == 0) goto <D.24379>; else goto <D.24377>;
    <D.24379>:
    D.24291 = t->type;
    D.24380 = D.24291 + 244;
    if (D.24380 <= 1) goto <D.24381>; else goto <D.24377>;
    <D.24381>:
    D.24291 = t->type;
    if (D.24291 == 13) goto <D.24382>; else goto <D.24383>;
    <D.24382>:
    {
      struct MonoInst * inst;

      D.24246 = cfg->mempool;
      inst = mono_mempool_alloc (D.24246, 56);
      inst->data.op[1].const_val = 0;
      D.24384 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.24384;
      inst->prev = 0B;
      D.24385 = inst->prev;
      inst->next = D.24385;
      inst->opcode = 380;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.24386 = inst->sreg3;
      inst->sreg2 = D.24386;
      D.24387 = inst->sreg2;
      inst->sreg1 = D.24387;
      D.24298 = cfg->ip;
      inst->cil_code = D.24298;
      D.24301 = in->dreg;
      inst->sreg1 = D.24301;
      inst->dreg = 29;
      D.24373 = ainfo->offset;
      inst->data.op[0].const_val = D.24373;
      D.24303 = cfg->cbb;
      D.24304 = D.24303->last_ins;
      if (D.24304 != 0B) goto <D.24388>; else goto <D.24389>;
      <D.24388>:
      D.24303 = cfg->cbb;
      D.24304 = D.24303->last_ins;
      D.24304->next = inst;
      D.24303 = cfg->cbb;
      D.24304 = D.24303->last_ins;
      inst->prev = D.24304;
      D.24303 = cfg->cbb;
      D.24303->last_ins = inst;
      goto <D.24390>;
      <D.24389>:
      D.24303 = cfg->cbb;
      D.24303 = cfg->cbb;
      D.24303->last_ins = inst;
      D.24304 = D.24303->last_ins;
      D.24303->code = D.24304;
      <D.24390>:
    }
    goto <D.24391>;
    <D.24383>:
    {
      struct MonoInst * inst;

      D.24246 = cfg->mempool;
      inst = mono_mempool_alloc (D.24246, 56);
      inst->data.op[1].const_val = 0;
      D.24392 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.24392;
      inst->prev = 0B;
      D.24393 = inst->prev;
      inst->next = D.24393;
      inst->opcode = 379;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.24394 = inst->sreg3;
      inst->sreg2 = D.24394;
      D.24395 = inst->sreg2;
      inst->sreg1 = D.24395;
      D.24298 = cfg->ip;
      inst->cil_code = D.24298;
      D.24301 = in->dreg;
      inst->sreg1 = D.24301;
      inst->dreg = 29;
      D.24373 = ainfo->offset;
      inst->data.op[0].const_val = D.24373;
      D.24303 = cfg->cbb;
      D.24304 = D.24303->last_ins;
      if (D.24304 != 0B) goto <D.24396>; else goto <D.24397>;
      <D.24396>:
      D.24303 = cfg->cbb;
      D.24304 = D.24303->last_ins;
      D.24304->next = inst;
      D.24303 = cfg->cbb;
      D.24304 = D.24303->last_ins;
      inst->prev = D.24304;
      D.24303 = cfg->cbb;
      D.24303->last_ins = inst;
      goto <D.24398>;
      <D.24397>:
      D.24303 = cfg->cbb;
      D.24303 = cfg->cbb;
      D.24303->last_ins = inst;
      D.24304 = D.24303->last_ins;
      D.24303->code = D.24304;
      <D.24398>:
    }
    <D.24391>:
    goto <D.24378>;
    <D.24377>:
    {
      struct MonoInst * inst;

      D.24246 = cfg->mempool;
      inst = mono_mempool_alloc (D.24246, 56);
      inst->data.op[1].const_val = 0;
      D.24399 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.24399;
      inst->prev = 0B;
      D.24400 = inst->prev;
      inst->next = D.24400;
      inst->opcode = 374;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.24401 = inst->sreg3;
      inst->sreg2 = D.24401;
      D.24402 = inst->sreg2;
      inst->sreg1 = D.24402;
      D.24298 = cfg->ip;
      inst->cil_code = D.24298;
      D.24301 = in->dreg;
      inst->sreg1 = D.24301;
      inst->dreg = 29;
      D.24373 = ainfo->offset;
      inst->data.op[0].const_val = D.24373;
      D.24303 = cfg->cbb;
      D.24304 = D.24303->last_ins;
      if (D.24304 != 0B) goto <D.24403>; else goto <D.24404>;
      <D.24403>:
      D.24303 = cfg->cbb;
      D.24304 = D.24303->last_ins;
      D.24304->next = inst;
      D.24303 = cfg->cbb;
      D.24304 = D.24303->last_ins;
      inst->prev = D.24304;
      D.24303 = cfg->cbb;
      D.24303->last_ins = inst;
      goto <D.24405>;
      <D.24404>:
      D.24303 = cfg->cbb;
      D.24303 = cfg->cbb;
      D.24303->last_ins = inst;
      D.24304 = D.24303->last_ins;
      D.24303->code = D.24304;
      <D.24405>:
    }
    <D.24378>:
    <D.24366>:
    goto <D.24406>;
    <D.24364>:
    D.24283 = ainfo->storage;
    if (D.24283 == 2) goto <D.24407>; else goto <D.24408>;
    <D.24407>:
    D.24291 = t->type;
    if (D.24291 == 17) goto <D.24409>; else goto <D.24410>;
    <D.24409>:
    D.24246 = cfg->mempool;
    ins = mono_mempool_alloc (D.24246, 56);
    ins->data.op[1].const_val = 0;
    D.24294 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.24294;
    ins->prev = 0B;
    D.24295 = ins->prev;
    ins->next = D.24295;
    ins->opcode = 333;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.24296 = ins->sreg3;
    ins->sreg2 = D.24296;
    D.24297 = ins->sreg2;
    ins->sreg1 = D.24297;
    D.24298 = cfg->ip;
    ins->cil_code = D.24298;
    ins->opcode = 333;
    D.24301 = in->dreg;
    ins->sreg1 = D.24301;
    D.24349 = in->klass;
    ins->klass = D.24349;
    ins->data.op[0].p = call;
    D.24246 = cfg->mempool;
    D.24411 = mono_mempool_alloc (D.24246, 16);
    ins->data.op[1].p = D.24411;
    D.24351 = ins->data.op[1].p;
    memcpy (D.24351, ainfo, 16);
    D.24303 = cfg->cbb;
    D.24304 = D.24303->last_ins;
    if (D.24304 != 0B) goto <D.24412>; else goto <D.24413>;
    <D.24412>:
    D.24303 = cfg->cbb;
    D.24304 = D.24303->last_ins;
    D.24304->next = ins;
    D.24303 = cfg->cbb;
    D.24304 = D.24303->last_ins;
    ins->prev = D.24304;
    D.24303 = cfg->cbb;
    D.24303->last_ins = ins;
    goto <D.24414>;
    <D.24413>:
    D.24303 = cfg->cbb;
    D.24303 = cfg->cbb;
    D.24303->last_ins = ins;
    D.24304 = D.24303->last_ins;
    D.24303->code = D.24304;
    <D.24414>:
    D.24415 = cfg->flags;
    D.24416 = D.24415 | 32;
    cfg->flags = D.24416;
    goto <D.24417>;
    <D.24410>:
    {
      int dreg;

      D.24418 = mono_alloc_freg (cfg);
      dreg = (int) D.24418;
      D.24419 = BIT_FIELD_REF <*ainfo, 32, 96>;
      D.24420 = D.24419 & 15;
      if (D.24420 == 4) goto <D.24421>; else goto <D.24422>;
      <D.24421>:
      {
        struct MonoInst * inst;

        D.24246 = cfg->mempool;
        inst = mono_mempool_alloc (D.24246, 56);
        inst->data.op[1].const_val = 0;
        D.24423 = inst->data.op[1].const_val;
        inst->data.op[0].const_val = D.24423;
        inst->prev = 0B;
        D.24424 = inst->prev;
        inst->next = D.24424;
        inst->opcode = 848;
        inst->flags = 0;
        inst->type = 0;
        inst->dreg = -1;
        inst->sreg3 = -1;
        D.24425 = inst->sreg3;
        inst->sreg2 = D.24425;
        D.24426 = inst->sreg2;
        inst->sreg1 = D.24426;
        D.24298 = cfg->ip;
        inst->cil_code = D.24298;
        inst->dreg = dreg;
        D.24301 = in->dreg;
        inst->sreg1 = D.24301;
        D.24303 = cfg->cbb;
        D.24304 = D.24303->last_ins;
        if (D.24304 != 0B) goto <D.24427>; else goto <D.24428>;
        <D.24427>:
        D.24303 = cfg->cbb;
        D.24304 = D.24303->last_ins;
        D.24304->next = inst;
        D.24303 = cfg->cbb;
        D.24304 = D.24303->last_ins;
        inst->prev = D.24304;
        D.24303 = cfg->cbb;
        D.24303->last_ins = inst;
        goto <D.24429>;
        <D.24428>:
        D.24303 = cfg->cbb;
        D.24303 = cfg->cbb;
        D.24303->last_ins = inst;
        D.24304 = D.24303->last_ins;
        D.24303->code = D.24304;
        <D.24429>:
      }
      goto <D.24430>;
      <D.24422>:
      D.24246 = cfg->mempool;
      ins = mono_mempool_alloc (D.24246, 56);
      ins->data.op[1].const_val = 0;
      D.24294 = ins->data.op[1].const_val;
      ins->data.op[0].const_val = D.24294;
      ins->prev = 0B;
      D.24295 = ins->prev;
      ins->next = D.24295;
      ins->opcode = 426;
      ins->flags = 0;
      ins->type = 0;
      ins->dreg = -1;
      ins->sreg3 = -1;
      D.24296 = ins->sreg3;
      ins->sreg2 = D.24296;
      D.24297 = ins->sreg2;
      ins->sreg1 = D.24297;
      D.24298 = cfg->ip;
      ins->cil_code = D.24298;
      ins->dreg = dreg;
      D.24301 = in->dreg;
      ins->sreg1 = D.24301;
      D.24303 = cfg->cbb;
      D.24304 = D.24303->last_ins;
      if (D.24304 != 0B) goto <D.24431>; else goto <D.24432>;
      <D.24431>:
      D.24303 = cfg->cbb;
      D.24304 = D.24303->last_ins;
      D.24304->next = ins;
      D.24303 = cfg->cbb;
      D.24304 = D.24303->last_ins;
      ins->prev = D.24304;
      D.24303 = cfg->cbb;
      D.24303->last_ins = ins;
      goto <D.24433>;
      <D.24432>:
      D.24303 = cfg->cbb;
      D.24303 = cfg->cbb;
      D.24303->last_ins = ins;
      D.24304 = D.24303->last_ins;
      D.24303->code = D.24304;
      <D.24433>:
      <D.24430>:
      D.24278 = ainfo->reg;
      D.24279 = (int) D.24278;
      mono_call_inst_add_outarg_reg (cfg, call, dreg, D.24279, 1);
      D.24415 = cfg->flags;
      D.24416 = D.24415 | 32;
      cfg->flags = D.24416;
    }
    <D.24417>:
    goto <D.24434>;
    <D.24408>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-mips.c", 1835);
    <D.24434>:
    <D.24406>:
    <D.24362>:
    <D.24355>:
    <D.24346>:
  }
  <D.22044>:
  i = i + 1;
  <D.22053>:
  if (i < n) goto <D.22052>; else goto <D.22054>;
  <D.22054>:
  D.24262 = BIT_FIELD_REF <*sig, 32, 64>;
  D.24435 = D.24262 & 20905984;
  if (D.24435 == 327680) goto <D.24436>; else goto <D.24437>;
  <D.24436>:
  D.24266 = sig->sentinelpos;
  D.24267 = (int) D.24266;
  if (D.24267 == n) goto <D.24438>; else goto <D.24439>;
  <D.24438>:
  emit_sig_cookie (cfg, call, cinfo);
  <D.24439>:
  <D.24437>:
  D.24247 = cinfo->struct_ret;
  if (D.24247 != 0) goto <D.24440>; else goto <D.24441>;
  <D.24440>:
  {
    struct MonoInst * vtarg;

    D.24246 = cfg->mempool;
    vtarg = mono_mempool_alloc (D.24246, 56);
    vtarg->data.op[1].const_val = 0;
    D.24442 = vtarg->data.op[1].const_val;
    vtarg->data.op[0].const_val = D.24442;
    vtarg->prev = 0B;
    D.24443 = vtarg->prev;
    vtarg->next = D.24443;
    vtarg->opcode = 424;
    vtarg->flags = 0;
    vtarg->type = 0;
    vtarg->dreg = -1;
    vtarg->sreg3 = -1;
    D.24444 = vtarg->sreg3;
    vtarg->sreg2 = D.24444;
    D.24445 = vtarg->sreg2;
    vtarg->sreg1 = D.24445;
    D.24298 = cfg->ip;
    vtarg->cil_code = D.24298;
    D.24446 = call->vret_var;
    D.24447 = D.24446->dreg;
    vtarg->sreg1 = D.24447;
    D.24448 = mono_alloc_preg (cfg);
    D.24449 = (int) D.24448;
    vtarg->dreg = D.24449;
    D.24303 = cfg->cbb;
    D.24304 = D.24303->last_ins;
    if (D.24304 != 0B) goto <D.24450>; else goto <D.24451>;
    <D.24450>:
    D.24303 = cfg->cbb;
    D.24304 = D.24303->last_ins;
    D.24304->next = vtarg;
    D.24303 = cfg->cbb;
    D.24304 = D.24303->last_ins;
    vtarg->prev = D.24304;
    D.24303 = cfg->cbb;
    D.24303->last_ins = vtarg;
    goto <D.24452>;
    <D.24451>:
    D.24303 = cfg->cbb;
    D.24303 = cfg->cbb;
    D.24303->last_ins = vtarg;
    D.24304 = D.24303->last_ins;
    D.24303->code = D.24304;
    <D.24452>:
    D.24453 = vtarg->dreg;
    D.24247 = cinfo->struct_ret;
    D.24251 = (int) D.24247;
    mono_call_inst_add_outarg_reg (cfg, call, D.24453, D.24251, 0);
  }
  <D.24441>:
  D.24454 = cinfo->stack_usage;
  call->stack_usage = D.24454;
  D.24454 = cinfo->stack_usage;
  D.24455 = cfg->param_area;
  D.24456 = MAX_EXPR <D.24454, D.24455>;
  cfg->param_area = D.24456;
  D.24455 = cfg->param_area;
  D.24457 = MAX_EXPR <D.24455, 16>;
  cfg->param_area = D.24457;
  D.24455 = cfg->param_area;
  D.24458 = D.24455 + 15;
  D.24459 = D.24458 & 4294967280;
  cfg->param_area = D.24459;
  D.24415 = cfg->flags;
  D.24460 = D.24415 | 2;
  cfg->flags = D.24460;
}


memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.24461;
  unsigned int D.24462;

  D.24462 = __builtin_object_size (__dest, 0);
  D.24461 = __builtin___memcpy_chk (__dest, __src, __len, D.24462);
  return D.24461;
}


emit_sig_cookie (struct MonoCompile * cfg, struct MonoCallInst * call, struct CallInfo * cinfo)
{
  unsigned int D.24464;
  unsigned int D.24465;
  struct MonoMethodSignature * D.24468;
  short unsigned int D.24469;
  short int D.24470;
  short unsigned int D.24471;
  short unsigned int D.24472;
  struct MonoType *[0:] * D.24473;
  sizetype D.24474;
  struct MonoType * * D.24475;
  unsigned int D.24476;
  unsigned int D.24477;
  struct MonoMemPool * D.24478;
  int D.24479;
  struct MonoInst * D.24480;
  int D.24481;
  int D.24482;
  const unsigned char * D.24483;
  unsigned int D.24484;
  int D.24485;
  struct MonoBasicBlock * D.24486;
  struct MonoInst * D.24487;
  int D.24491;
  struct MonoInst * D.24492;
  int D.24493;
  int D.24494;
  int D.24495;
  int D.24496;
  struct MonoMethodSignature * tmp_sig;
  struct MonoInst * sig_arg;

  D.24464 = BIT_FIELD_REF <*call, 32, 704>;
  D.24465 = D.24464 & 2;
  if (D.24465 != 0) goto <D.24466>; else goto <D.24467>;
  <D.24466>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-mips.c", 1665);
  <D.24467>:
  cfg->disable_aot = 1;
  D.24468 = call->signature;
  tmp_sig = mono_metadata_signature_dup (D.24468);
  D.24469 = tmp_sig->param_count;
  D.24468 = call->signature;
  D.24470 = D.24468->sentinelpos;
  D.24471 = (short unsigned int) D.24470;
  D.24472 = D.24469 - D.24471;
  tmp_sig->param_count = D.24472;
  tmp_sig->sentinelpos = 0;
  D.24473 = &tmp_sig->params;
  D.24468 = call->signature;
  D.24468 = call->signature;
  D.24470 = D.24468->sentinelpos;
  D.24474 = (sizetype) D.24470;
  D.24475 = &D.24468->params[D.24474];
  D.24469 = tmp_sig->param_count;
  D.24476 = (unsigned int) D.24469;
  D.24477 = D.24476 * 4;
  memcpy (D.24473, D.24475, D.24477);
  D.24478 = cfg->mempool;
  sig_arg = mono_mempool_alloc (D.24478, 56);
  sig_arg->data.op[1].const_val = 0;
  D.24479 = sig_arg->data.op[1].const_val;
  sig_arg->data.op[0].const_val = D.24479;
  sig_arg->prev = 0B;
  D.24480 = sig_arg->prev;
  sig_arg->next = D.24480;
  sig_arg->opcode = 362;
  sig_arg->flags = 0;
  sig_arg->type = 0;
  sig_arg->dreg = -1;
  sig_arg->sreg3 = -1;
  D.24481 = sig_arg->sreg3;
  sig_arg->sreg2 = D.24481;
  D.24482 = sig_arg->sreg2;
  sig_arg->sreg1 = D.24482;
  D.24483 = cfg->ip;
  sig_arg->cil_code = D.24483;
  D.24484 = mono_alloc_ireg (cfg);
  D.24485 = (int) D.24484;
  sig_arg->dreg = D.24485;
  sig_arg->data.op[0].p = tmp_sig;
  D.24486 = cfg->cbb;
  D.24487 = D.24486->last_ins;
  if (D.24487 != 0B) goto <D.24488>; else goto <D.24489>;
  <D.24488>:
  D.24486 = cfg->cbb;
  D.24487 = D.24486->last_ins;
  D.24487->next = sig_arg;
  D.24486 = cfg->cbb;
  D.24487 = D.24486->last_ins;
  sig_arg->prev = D.24487;
  D.24486 = cfg->cbb;
  D.24486->last_ins = sig_arg;
  goto <D.24490>;
  <D.24489>:
  D.24486 = cfg->cbb;
  D.24486 = cfg->cbb;
  D.24486->last_ins = sig_arg;
  D.24487 = D.24486->last_ins;
  D.24486->code = D.24487;
  <D.24490>:
  {
    struct MonoInst * inst;

    D.24478 = cfg->mempool;
    inst = mono_mempool_alloc (D.24478, 56);
    inst->data.op[1].const_val = 0;
    D.24491 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.24491;
    inst->prev = 0B;
    D.24492 = inst->prev;
    inst->next = D.24492;
    inst->opcode = 374;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.24493 = inst->sreg3;
    inst->sreg2 = D.24493;
    D.24494 = inst->sreg2;
    inst->sreg1 = D.24494;
    D.24483 = cfg->ip;
    inst->cil_code = D.24483;
    D.24495 = sig_arg->dreg;
    inst->sreg1 = D.24495;
    inst->dreg = 29;
    D.24496 = cinfo->sig_cookie.offset;
    inst->data.op[0].const_val = D.24496;
    D.24486 = cfg->cbb;
    D.24487 = D.24486->last_ins;
    if (D.24487 != 0B) goto <D.24497>; else goto <D.24498>;
    <D.24497>:
    D.24486 = cfg->cbb;
    D.24487 = D.24486->last_ins;
    D.24487->next = inst;
    D.24486 = cfg->cbb;
    D.24487 = D.24486->last_ins;
    inst->prev = D.24487;
    D.24486 = cfg->cbb;
    D.24486->last_ins = inst;
    goto <D.24499>;
    <D.24498>:
    D.24486 = cfg->cbb;
    D.24486 = cfg->cbb;
    D.24486->last_ins = inst;
    D.24487 = D.24486->last_ins;
    D.24486->code = D.24487;
    <D.24499>:
  }
}


mono_arch_emit_outarg_vt (struct MonoCompile * cfg, struct MonoInst * ins, struct MonoInst * src)
{
  short unsigned int D.24500;
  <unnamed type> D.24501;
  unsigned int D.24504;
  struct MonoMemPool * D.24505;
  int D.24506;
  struct MonoInst * D.24507;
  int D.24508;
  int D.24509;
  const unsigned char * D.24510;
  int D.24511;
  struct MonoBasicBlock * D.24512;
  struct MonoInst * D.24513;
  unsigned char D.24517;
  int D.24518;
  int D.24519;
  <unnamed-unsigned:4> D.24520;
  int D.24521;
  unsigned int ovf_size.49;
  unsigned int D.24525;
  int D.24526;
  unsigned int D.24530;
  unsigned int D.24531;
  unsigned int D.24532;
  int D.24535;
  struct MonoInst * D.24536;
  int D.24537;
  int D.24538;
  int D.24543;
  struct MonoInst * D.24544;
  int D.24545;
  int D.24546;
  unsigned int D.24550;
  int D.24551;
  struct MonoInst * D.24552;
  int D.24553;
  int D.24554;
  struct MonoClass * D.24559;
  struct MonoType * D.24560;
  struct MonoMethodSignature * D.24561;
  unsigned int D.24562;
  unsigned int D.24563;
  int D.24566;
  struct MonoGenericSharingContext * D.24568;
  int D.24569;
  _Bool D.24572;
  long int D.24573;
  long int D.24574;
  int D.24577;
  struct MonoInst * D.24578;
  int D.24579;
  int D.24580;
  unsigned char D.24581;
  unsigned char D.24582;
  struct MonoClass * D.24583;
  unsigned int D.24584;
  int D.24585;
  int D.24586;
  _Bool D.24587;
  long int D.24588;
  long int D.24589;
  struct MonoType * D.24592;
  int D.24593;
  _Bool iftmp.50;
  int D.24597;
  int iftmp.51;
  unsigned char D.24604;
  struct MonoInst * iftmp.52;
  int D.24610;
  int D.24611;
  unsigned int D.24612;
  unsigned int D.24613;
  struct MonoInst * * D.24616;
  sizetype D.24617;
  sizetype D.24618;
  sizetype D.24619;
  struct MonoInst * * D.24620;
  struct MonoInst * iftmp.53;
  int D.24623;
  unsigned int D.24624;
  sizetype D.24627;
  sizetype D.24628;
  struct MonoInst * * D.24629;
  _Bool D.24631;
  long int D.24632;
  long int D.24633;
  _Bool D.24636;
  long int D.24637;
  long int D.24638;
  unsigned char D.24641;
  unsigned char D.24642;
  unsigned char D.24643;
  unsigned char D.24644;
  int D.24648;
  int size.54;
  int D.24650;
  int D.24653;
  struct MonoInst * D.24654;
  int D.24655;
  int D.24656;
  struct MonoCallInst * call;
  struct ArgInfo * ainfo;
  int ovf_size;
  int doffset;
  int i;
  int soffset;
  int dreg;

  call = ins->data.op[0].p;
  ainfo = ins->data.op[1].p;
  D.24500 = ainfo->vtsize;
  ovf_size = (int) D.24500;
  doffset = ainfo->offset;
  D.24501 = ainfo->storage;
  if (D.24501 == 3) goto <D.24502>; else goto <D.24503>;
  <D.24502>:
  soffset = 0;
  i = 0;
  goto <D.22070>;
  <D.22069>:
  D.24504 = mono_alloc_ireg (cfg);
  dreg = (int) D.24504;
  {
    struct MonoInst * inst;

    D.24505 = cfg->mempool;
    inst = mono_mempool_alloc (D.24505, 56);
    inst->data.op[1].const_val = 0;
    D.24506 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.24506;
    inst->prev = 0B;
    D.24507 = inst->prev;
    inst->next = D.24507;
    inst->opcode = 388;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.24508 = inst->sreg3;
    inst->sreg2 = D.24508;
    D.24509 = inst->sreg2;
    inst->sreg1 = D.24509;
    D.24510 = cfg->ip;
    inst->cil_code = D.24510;
    inst->dreg = dreg;
    D.24511 = src->dreg;
    inst->sreg1 = D.24511;
    inst->data.op[0].const_val = soffset;
    D.24512 = cfg->cbb;
    D.24513 = D.24512->last_ins;
    if (D.24513 != 0B) goto <D.24514>; else goto <D.24515>;
    <D.24514>:
    D.24512 = cfg->cbb;
    D.24513 = D.24512->last_ins;
    D.24513->next = inst;
    D.24512 = cfg->cbb;
    D.24513 = D.24512->last_ins;
    inst->prev = D.24513;
    D.24512 = cfg->cbb;
    D.24512->last_ins = inst;
    goto <D.24516>;
    <D.24515>:
    D.24512 = cfg->cbb;
    D.24512 = cfg->cbb;
    D.24512->last_ins = inst;
    D.24513 = D.24512->last_ins;
    D.24512->code = D.24513;
    <D.24516>:
  }
  D.24517 = ainfo->reg;
  D.24518 = (int) D.24517;
  D.24519 = D.24518 + i;
  mono_call_inst_add_outarg_reg (cfg, call, dreg, D.24519, 0);
  soffset = soffset + 4;
  i = i + 1;
  <D.22070>:
  D.24520 = ainfo->size;
  D.24521 = (int) D.24520;
  if (D.24521 > i) goto <D.22069>; else goto <D.22071>;
  <D.22071>:
  if (ovf_size != 0) goto <D.24522>; else goto <D.24523>;
  <D.24522>:
  D.24511 = src->dreg;
  ovf_size.49 = (unsigned int) ovf_size;
  D.24525 = ovf_size.49 * 4;
  D.24526 = (int) D.24525;
  mini_emit_memcpy (cfg, 29, doffset, D.24511, soffset, D.24526, 0);
  <D.24523>:
  goto <D.24527>;
  <D.24503>:
  D.24501 = ainfo->storage;
  if (D.24501 == 2) goto <D.24528>; else goto <D.24529>;
  <D.24528>:
  {
    int tmpr;

    D.24530 = mono_alloc_freg (cfg);
    tmpr = (int) D.24530;
    D.24531 = BIT_FIELD_REF <*ainfo, 32, 96>;
    D.24532 = D.24531 & 15;
    if (D.24532 == 4) goto <D.24533>; else goto <D.24534>;
    <D.24533>:
    {
      struct MonoInst * inst;

      D.24505 = cfg->mempool;
      inst = mono_mempool_alloc (D.24505, 56);
      inst->data.op[1].const_val = 0;
      D.24535 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.24535;
      inst->prev = 0B;
      D.24536 = inst->prev;
      inst->next = D.24536;
      inst->opcode = 396;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.24537 = inst->sreg3;
      inst->sreg2 = D.24537;
      D.24538 = inst->sreg2;
      inst->sreg1 = D.24538;
      D.24510 = cfg->ip;
      inst->cil_code = D.24510;
      inst->dreg = tmpr;
      D.24511 = src->dreg;
      inst->sreg1 = D.24511;
      inst->data.op[0].const_val = 0;
      D.24512 = cfg->cbb;
      D.24513 = D.24512->last_ins;
      if (D.24513 != 0B) goto <D.24539>; else goto <D.24540>;
      <D.24539>:
      D.24512 = cfg->cbb;
      D.24513 = D.24512->last_ins;
      D.24513->next = inst;
      D.24512 = cfg->cbb;
      D.24513 = D.24512->last_ins;
      inst->prev = D.24513;
      D.24512 = cfg->cbb;
      D.24512->last_ins = inst;
      goto <D.24541>;
      <D.24540>:
      D.24512 = cfg->cbb;
      D.24512 = cfg->cbb;
      D.24512->last_ins = inst;
      D.24513 = D.24512->last_ins;
      D.24512->code = D.24513;
      <D.24541>:
    }
    goto <D.24542>;
    <D.24534>:
    {
      struct MonoInst * inst;

      D.24505 = cfg->mempool;
      inst = mono_mempool_alloc (D.24505, 56);
      inst->data.op[1].const_val = 0;
      D.24543 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.24543;
      inst->prev = 0B;
      D.24544 = inst->prev;
      inst->next = D.24544;
      inst->opcode = 397;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.24545 = inst->sreg3;
      inst->sreg2 = D.24545;
      D.24546 = inst->sreg2;
      inst->sreg1 = D.24546;
      D.24510 = cfg->ip;
      inst->cil_code = D.24510;
      inst->dreg = tmpr;
      D.24511 = src->dreg;
      inst->sreg1 = D.24511;
      inst->data.op[0].const_val = 0;
      D.24512 = cfg->cbb;
      D.24513 = D.24512->last_ins;
      if (D.24513 != 0B) goto <D.24547>; else goto <D.24548>;
      <D.24547>:
      D.24512 = cfg->cbb;
      D.24513 = D.24512->last_ins;
      D.24513->next = inst;
      D.24512 = cfg->cbb;
      D.24513 = D.24512->last_ins;
      inst->prev = D.24513;
      D.24512 = cfg->cbb;
      D.24512->last_ins = inst;
      goto <D.24549>;
      <D.24548>:
      D.24512 = cfg->cbb;
      D.24512 = cfg->cbb;
      D.24512->last_ins = inst;
      D.24513 = D.24512->last_ins;
      D.24512->code = D.24513;
      <D.24549>:
    }
    <D.24542>:
    D.24550 = mono_alloc_freg (cfg);
    dreg = (int) D.24550;
    {
      struct MonoInst * inst;

      D.24505 = cfg->mempool;
      inst = mono_mempool_alloc (D.24505, 56);
      inst->data.op[1].const_val = 0;
      D.24551 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.24551;
      inst->prev = 0B;
      D.24552 = inst->prev;
      inst->next = D.24552;
      inst->opcode = 426;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.24553 = inst->sreg3;
      inst->sreg2 = D.24553;
      D.24554 = inst->sreg2;
      inst->sreg1 = D.24554;
      D.24510 = cfg->ip;
      inst->cil_code = D.24510;
      inst->dreg = dreg;
      inst->sreg1 = tmpr;
      D.24512 = cfg->cbb;
      D.24513 = D.24512->last_ins;
      if (D.24513 != 0B) goto <D.24555>; else goto <D.24556>;
      <D.24555>:
      D.24512 = cfg->cbb;
      D.24513 = D.24512->last_ins;
      D.24513->next = inst;
      D.24512 = cfg->cbb;
      D.24513 = D.24512->last_ins;
      inst->prev = D.24513;
      D.24512 = cfg->cbb;
      D.24512->last_ins = inst;
      goto <D.24557>;
      <D.24556>:
      D.24512 = cfg->cbb;
      D.24512 = cfg->cbb;
      D.24512->last_ins = inst;
      D.24513 = D.24512->last_ins;
      D.24512->code = D.24513;
      <D.24557>:
    }
    D.24517 = ainfo->reg;
    D.24518 = (int) D.24517;
    mono_call_inst_add_outarg_reg (cfg, call, dreg, D.24518, 1);
  }
  goto <D.24558>;
  <D.24529>:
  {
    struct MonoInst * vtcopy;
    struct MonoInst * load;
    guint32 size;

    D.24559 = src->klass;
    D.24560 = &D.24559->byval_arg;
    vtcopy = mono_compile_create_var (cfg, D.24560, 329);
    D.24561 = call->signature;
    D.24562 = BIT_FIELD_REF <*D.24561, 32, 64>;
    D.24563 = D.24562 & 16777216;
    if (D.24563 != 0) goto <D.24564>; else goto <D.24565>;
    <D.24564>:
    D.24559 = src->klass;
    D.24560 = &D.24559->byval_arg;
    D.24566 = mono_type_native_stack_size (D.24560, 0B);
    size = (guint32) D.24566;
    vtcopy->backend.is_pinvoke = 1;
    goto <D.24567>;
    <D.24565>:
    D.24568 = cfg->generic_sharing_context;
    D.24559 = src->klass;
    D.24560 = &D.24559->byval_arg;
    D.24569 = mini_type_stack_size (D.24568, D.24560, 0B);
    size = (guint32) D.24569;
    <D.24567>:
    if (size != 0) goto <D.24570>; else goto <D.24571>;
    <D.24570>:
    D.24572 = ovf_size <= 0;
    D.24573 = (long int) D.24572;
    D.24574 = __builtin_expect (D.24573, 0);
    if (D.24574 != 0) goto <D.24575>; else goto <D.24576>;
    <D.24575>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 1934, "ovf_size > 0");
    <D.24576>:
    <D.24571>:
    D.24505 = cfg->mempool;
    load = mono_mempool_alloc (D.24505, 56);
    load->data.op[1].const_val = 0;
    D.24577 = load->data.op[1].const_val;
    load->data.op[0].const_val = D.24577;
    load->prev = 0B;
    D.24578 = load->prev;
    load->next = D.24578;
    load->opcode = 314;
    load->flags = 0;
    load->type = 0;
    load->dreg = -1;
    load->sreg3 = -1;
    D.24579 = load->sreg3;
    load->sreg2 = D.24579;
    D.24580 = load->sreg2;
    load->sreg1 = D.24580;
    D.24510 = cfg->ip;
    load->cil_code = D.24510;
    load->data.op[0].p = vtcopy;
    D.24581 = vtcopy->flags;
    D.24582 = D.24581 | 16;
    vtcopy->flags = D.24582;
    load->type = 5;
    D.24583 = vtcopy->klass;
    load->klass = D.24583;
    D.24584 = alloc_dreg (cfg, 5);
    D.24585 = (int) D.24584;
    load->dreg = D.24585;
    cfg->has_indirection = 1;
    D.24586 = cfg->gsharedvt;
    D.24587 = D.24586 != 0;
    D.24588 = (long int) D.24587;
    D.24589 = __builtin_expect (D.24588, 0);
    if (D.24589 != 0) goto <D.24590>; else goto <D.24591>;
    <D.24590>:
    D.24592 = vtcopy->data.op[1].vtype;
    D.24593 = mini_is_gsharedvt_variable_type (cfg, D.24592);
    if (D.24593 != 0) goto <D.24594>; else goto <D.24595>;
    <D.24594>:
    handle_gsharedvt_ldaddr (cfg);
    <D.24595>:
    <D.24591>:
    D.24597 = mono_arch_is_soft_float ();
    if (D.24597 != 0) goto <D.24598>; else goto <D.24599>;
    <D.24598>:
    D.24604 = vtcopy->type;
    if (D.24604 == 2) goto <D.24601>; else goto <D.24605>;
    <D.24605>:
    D.24604 = vtcopy->type;
    if (D.24604 == 4) goto <D.24601>; else goto <D.24602>;
    <D.24601>:
    iftmp.51 = 1;
    goto <D.24603>;
    <D.24602>:
    iftmp.51 = 0;
    <D.24603>:
    iftmp.50 = (_Bool) iftmp.51;
    goto <D.24606>;
    <D.24599>:
    D.24604 = vtcopy->type;
    iftmp.50 = D.24604 == 2;
    <D.24606>:
    if (iftmp.50 != 0) goto <D.24607>; else goto <D.24608>;
    <D.24607>:
    {
      struct MonoInst * var1;
      struct MonoInst * var2;

      D.24610 = vtcopy->dreg;
      D.24611 = D.24610 + 1;
      D.24612 = (unsigned int) D.24611;
      D.24613 = cfg->vreg_to_inst_len;
      if (D.24612 < D.24613) goto <D.24614>; else goto <D.24615>;
      <D.24614>:
      D.24616 = cfg->vreg_to_inst;
      D.24610 = vtcopy->dreg;
      D.24617 = (sizetype) D.24610;
      D.24618 = D.24617 + 1;
      D.24619 = D.24618 * 4;
      D.24620 = D.24616 + D.24619;
      iftmp.52 = *D.24620;
      goto <D.24621>;
      <D.24615>:
      iftmp.52 = 0B;
      <D.24621>:
      var1 = iftmp.52;
      D.24610 = vtcopy->dreg;
      D.24623 = D.24610 + 2;
      D.24624 = (unsigned int) D.24623;
      D.24613 = cfg->vreg_to_inst_len;
      if (D.24624 < D.24613) goto <D.24625>; else goto <D.24626>;
      <D.24625>:
      D.24616 = cfg->vreg_to_inst;
      D.24610 = vtcopy->dreg;
      D.24617 = (sizetype) D.24610;
      D.24627 = D.24617 + 2;
      D.24628 = D.24627 * 4;
      D.24629 = D.24616 + D.24628;
      iftmp.53 = *D.24629;
      goto <D.24630>;
      <D.24626>:
      iftmp.53 = 0B;
      <D.24630>:
      var2 = iftmp.53;
      D.24631 = var1 == 0B;
      D.24632 = (long int) D.24631;
      D.24633 = __builtin_expect (D.24632, 0);
      if (D.24633 != 0) goto <D.24634>; else goto <D.24635>;
      <D.24634>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 1936, "var1");
      <D.24635>:
      D.24636 = var2 == 0B;
      D.24637 = (long int) D.24636;
      D.24638 = __builtin_expect (D.24637, 0);
      if (D.24638 != 0) goto <D.24639>; else goto <D.24640>;
      <D.24639>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 1936, "var2");
      <D.24640>:
      D.24641 = var1->flags;
      D.24642 = D.24641 | 16;
      var1->flags = D.24642;
      D.24643 = var2->flags;
      D.24644 = D.24643 | 16;
      var2->flags = D.24644;
    }
    <D.24608>:
    D.24512 = cfg->cbb;
    D.24513 = D.24512->last_ins;
    if (D.24513 != 0B) goto <D.24645>; else goto <D.24646>;
    <D.24645>:
    D.24512 = cfg->cbb;
    D.24513 = D.24512->last_ins;
    D.24513->next = load;
    D.24512 = cfg->cbb;
    D.24513 = D.24512->last_ins;
    load->prev = D.24513;
    D.24512 = cfg->cbb;
    D.24512->last_ins = load;
    goto <D.24647>;
    <D.24646>:
    D.24512 = cfg->cbb;
    D.24512 = cfg->cbb;
    D.24512->last_ins = load;
    D.24513 = D.24512->last_ins;
    D.24512->code = D.24513;
    <D.24647>:
    D.24648 = load->dreg;
    D.24511 = src->dreg;
    size.54 = (int) size;
    mini_emit_memcpy (cfg, D.24648, 0, D.24511, 0, size.54, 0);
    D.24650 = ainfo->offset;
    if (D.24650 != 0) goto <D.24651>; else goto <D.24652>;
    <D.24651>:
    {
      struct MonoInst * inst;

      D.24505 = cfg->mempool;
      inst = mono_mempool_alloc (D.24505, 56);
      inst->data.op[1].const_val = 0;
      D.24653 = inst->data.op[1].const_val;
      inst->data.op[0].const_val = D.24653;
      inst->prev = 0B;
      D.24654 = inst->prev;
      inst->next = D.24654;
      inst->opcode = 374;
      inst->flags = 0;
      inst->type = 0;
      inst->dreg = -1;
      inst->sreg3 = -1;
      D.24655 = inst->sreg3;
      inst->sreg2 = D.24655;
      D.24656 = inst->sreg2;
      inst->sreg1 = D.24656;
      D.24510 = cfg->ip;
      inst->cil_code = D.24510;
      D.24648 = load->dreg;
      inst->sreg1 = D.24648;
      inst->dreg = 1;
      D.24650 = ainfo->offset;
      inst->data.op[0].const_val = D.24650;
      D.24512 = cfg->cbb;
      D.24513 = D.24512->last_ins;
      if (D.24513 != 0B) goto <D.24657>; else goto <D.24658>;
      <D.24657>:
      D.24512 = cfg->cbb;
      D.24513 = D.24512->last_ins;
      D.24513->next = inst;
      D.24512 = cfg->cbb;
      D.24513 = D.24512->last_ins;
      inst->prev = D.24513;
      D.24512 = cfg->cbb;
      D.24512->last_ins = inst;
      goto <D.24659>;
      <D.24658>:
      D.24512 = cfg->cbb;
      D.24512 = cfg->cbb;
      D.24512->last_ins = inst;
      D.24513 = D.24512->last_ins;
      D.24512->code = D.24513;
      <D.24659>:
    }
    goto <D.24660>;
    <D.24652>:
    D.24648 = load->dreg;
    D.24517 = ainfo->reg;
    D.24518 = (int) D.24517;
    mono_call_inst_add_outarg_reg (cfg, call, D.24648, D.24518, 0);
    <D.24660>:
  }
  <D.24558>:
  <D.24527>:
}


alloc_dreg (struct MonoCompile * cfg, MonoStackType stack_type)
{
  guint32 D.24661;

  switch (stack_type) <default: <D.21603>, case 1: <D.21596>, case 2: <D.21601>, case 3: <D.21597>, case 4: <D.21600>, case 5: <D.21598>, case 6: <D.21599>, case 7: <D.21602>>
  <D.21596>:
  <D.21597>:
  D.24661 = alloc_ireg (cfg);
  return D.24661;
  <D.21598>:
  D.24661 = alloc_ireg_mp (cfg);
  return D.24661;
  <D.21599>:
  D.24661 = alloc_ireg_ref (cfg);
  return D.24661;
  <D.21600>:
  D.24661 = alloc_freg (cfg);
  return D.24661;
  <D.21601>:
  D.24661 = alloc_lreg (cfg);
  return D.24661;
  <D.21602>:
  D.24661 = alloc_ireg (cfg);
  return D.24661;
  <D.21603>:
  monoeg_g_log (0B, 16, "Unknown stack type %x\n", stack_type);
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "ir-emit.h", 97);
  D.24661 = 4294967295;
  return D.24661;
}


alloc_ireg_mp (struct MonoCompile * cfg)
{
  unsigned int D.24663;
  unsigned int D.24664;
  unsigned int D.24665;
  guint32 D.24668;
  int vreg;

  D.24663 = alloc_ireg (cfg);
  vreg = (int) D.24663;
  D.24664 = BIT_FIELD_REF <*cfg, 32, 3424>;
  D.24665 = D.24664 & 128;
  if (D.24665 != 0) goto <D.24666>; else goto <D.24667>;
  <D.24666>:
  mono_mark_vreg_as_mp (cfg, vreg);
  <D.24667>:
  D.24668 = (guint32) vreg;
  return D.24668;
}


alloc_ireg_ref (struct MonoCompile * cfg)
{
  unsigned int D.24670;
  unsigned int D.24671;
  unsigned int D.24672;
  guint32 D.24675;
  int vreg;

  D.24670 = alloc_ireg (cfg);
  vreg = (int) D.24670;
  D.24671 = BIT_FIELD_REF <*cfg, 32, 3424>;
  D.24672 = D.24671 & 128;
  if (D.24672 != 0) goto <D.24673>; else goto <D.24674>;
  <D.24673>:
  mono_mark_vreg_as_ref (cfg, vreg);
  <D.24674>:
  D.24675 = (guint32) vreg;
  return D.24675;
}


alloc_freg (struct MonoCompile * cfg)
{
  int D.24677;
  guint32 D.24680;
  unsigned int D.24681;
  unsigned int D.24682;
  unsigned int D.24683;

  D.24677 = mono_arch_is_soft_float ();
  if (D.24677 != 0) goto <D.24678>; else goto <D.24679>;
  <D.24678>:
  D.24680 = alloc_lreg (cfg);
  return D.24680;
  <D.24679>:
  D.24681 = cfg->next_vreg;
  D.24682 = D.24681;
  D.24683 = D.24682 + 1;
  cfg->next_vreg = D.24683;
  D.24680 = D.24682;
  return D.24680;
}


alloc_lreg (struct MonoCompile * cfg)
{
  unsigned int D.24685;
  unsigned int D.24686;
  guint32 D.24687;
  guint32 res;

  res = cfg->next_vreg;
  D.24685 = cfg->next_vreg;
  D.24686 = D.24685 + 3;
  cfg->next_vreg = D.24686;
  D.24687 = res;
  return D.24687;
}


alloc_ireg (struct MonoCompile * cfg)
{
  guint32 D.24689;
  unsigned int D.24690;
  unsigned int D.24691;
  unsigned int D.24692;

  D.24690 = cfg->next_vreg;
  D.24691 = D.24690;
  D.24692 = D.24691 + 1;
  cfg->next_vreg = D.24692;
  D.24689 = D.24691;
  return D.24689;
}


handle_gsharedvt_ldaddr (struct MonoCompile * cfg)
{
  struct MonoMemPool * D.24694;
  int D.24695;
  struct MonoInst * D.24696;
  int D.24697;
  int D.24698;
  const unsigned char * D.24699;
  struct MonoInst * D.24700;
  int D.24701;
  struct MonoBasicBlock * D.24702;
  struct MonoInst * D.24703;
  struct MonoInst * D.24707;
  int D.24708;
  struct MonoInst * use;

  D.24694 = cfg->mempool;
  use = mono_mempool_alloc (D.24694, 56);
  use->data.op[1].const_val = 0;
  D.24695 = use->data.op[1].const_val;
  use->data.op[0].const_val = D.24695;
  use->prev = 0B;
  D.24696 = use->prev;
  use->next = D.24696;
  use->opcode = 796;
  use->flags = 0;
  use->type = 0;
  use->dreg = -1;
  use->sreg3 = -1;
  D.24697 = use->sreg3;
  use->sreg2 = D.24697;
  D.24698 = use->sreg2;
  use->sreg1 = D.24698;
  D.24699 = cfg->ip;
  use->cil_code = D.24699;
  D.24700 = cfg->gsharedvt_info_var;
  D.24701 = D.24700->dreg;
  use->sreg1 = D.24701;
  D.24702 = cfg->cbb;
  D.24703 = D.24702->last_ins;
  if (D.24703 != 0B) goto <D.24704>; else goto <D.24705>;
  <D.24704>:
  D.24702 = cfg->cbb;
  D.24703 = D.24702->last_ins;
  D.24703->next = use;
  D.24702 = cfg->cbb;
  D.24703 = D.24702->last_ins;
  use->prev = D.24703;
  D.24702 = cfg->cbb;
  D.24702->last_ins = use;
  goto <D.24706>;
  <D.24705>:
  D.24702 = cfg->cbb;
  D.24702 = cfg->cbb;
  D.24702->last_ins = use;
  D.24703 = D.24702->last_ins;
  D.24702->code = D.24703;
  <D.24706>:
  D.24694 = cfg->mempool;
  use = mono_mempool_alloc (D.24694, 56);
  use->data.op[1].const_val = 0;
  D.24695 = use->data.op[1].const_val;
  use->data.op[0].const_val = D.24695;
  use->prev = 0B;
  D.24696 = use->prev;
  use->next = D.24696;
  use->opcode = 796;
  use->flags = 0;
  use->type = 0;
  use->dreg = -1;
  use->sreg3 = -1;
  D.24697 = use->sreg3;
  use->sreg2 = D.24697;
  D.24698 = use->sreg2;
  use->sreg1 = D.24698;
  D.24699 = cfg->ip;
  use->cil_code = D.24699;
  D.24707 = cfg->gsharedvt_locals_var;
  D.24708 = D.24707->dreg;
  use->sreg1 = D.24708;
  D.24702 = cfg->cbb;
  D.24703 = D.24702->last_ins;
  if (D.24703 != 0B) goto <D.24709>; else goto <D.24710>;
  <D.24709>:
  D.24702 = cfg->cbb;
  D.24703 = D.24702->last_ins;
  D.24703->next = use;
  D.24702 = cfg->cbb;
  D.24703 = D.24702->last_ins;
  use->prev = D.24703;
  D.24702 = cfg->cbb;
  D.24702->last_ins = use;
  goto <D.24711>;
  <D.24710>:
  D.24702 = cfg->cbb;
  D.24702 = cfg->cbb;
  D.24702->last_ins = use;
  D.24703 = D.24702->last_ins;
  D.24702->code = D.24703;
  <D.24711>:
}


mono_arch_is_soft_float ()
{
  gboolean D.24712;

  D.24712 = 0;
  return D.24712;
}


mono_arch_emit_setret (struct MonoCompile * cfg, struct MonoMethod * method, struct MonoInst * val)
{
  struct MonoGenericSharingContext * D.24714;
  struct MonoMethodSignature * D.24715;
  struct MonoType * D.24716;
  unsigned int D.24717;
  unsigned int D.24718;
  unsigned char D.24721;
  unsigned char D.24722;
  struct MonoMemPool * D.24725;
  int D.24726;
  struct MonoInst * D.24727;
  int D.24728;
  int D.24729;
  const unsigned char * D.24730;
  int D.24731;
  int D.24732;
  int D.24733;
  struct MonoBasicBlock * D.24734;
  struct MonoInst * D.24735;
  int D.24741;
  struct MonoInst * D.24742;
  int D.24743;
  int D.24744;
  struct MonoInst * D.24745;
  int D.24746;
  int D.24752;
  struct MonoInst * D.24753;
  int D.24754;
  int D.24755;
  int D.24759;
  struct MonoInst * D.24760;
  int D.24761;
  int D.24762;
  struct MonoType * ret;

  D.24714 = cfg->generic_sharing_context;
  D.24715 = mono_method_signature (method);
  D.24716 = D.24715->ret;
  ret = mini_type_get_underlying_type (D.24714, D.24716);
  D.24717 = BIT_FIELD_REF <*ret, 32, 32>;
  D.24718 = D.24717 & 1073741824;
  if (D.24718 == 0) goto <D.24719>; else goto <D.24720>;
  <D.24719>:
  D.24721 = ret->type;
  D.24722 = D.24721 + 246;
  if (D.24722 <= 1) goto <D.24723>; else goto <D.24724>;
  <D.24723>:
  {
    struct MonoInst * ins;

    D.24725 = cfg->mempool;
    ins = mono_mempool_alloc (D.24725, 56);
    ins->data.op[1].const_val = 0;
    D.24726 = ins->data.op[1].const_val;
    ins->data.op[0].const_val = D.24726;
    ins->prev = 0B;
    D.24727 = ins->prev;
    ins->next = D.24727;
    ins->opcode = 337;
    ins->flags = 0;
    ins->type = 0;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.24728 = ins->sreg3;
    ins->sreg2 = D.24728;
    D.24729 = ins->sreg2;
    ins->sreg1 = D.24729;
    D.24730 = cfg->ip;
    ins->cil_code = D.24730;
    D.24731 = val->dreg;
    D.24732 = D.24731 + 1;
    ins->sreg1 = D.24732;
    D.24731 = val->dreg;
    D.24733 = D.24731 + 2;
    ins->sreg2 = D.24733;
    D.24734 = cfg->cbb;
    D.24735 = D.24734->last_ins;
    if (D.24735 != 0B) goto <D.24736>; else goto <D.24737>;
    <D.24736>:
    D.24734 = cfg->cbb;
    D.24735 = D.24734->last_ins;
    D.24735->next = ins;
    D.24734 = cfg->cbb;
    D.24735 = D.24734->last_ins;
    ins->prev = D.24735;
    D.24734 = cfg->cbb;
    D.24734->last_ins = ins;
    goto <D.24738>;
    <D.24737>:
    D.24734 = cfg->cbb;
    D.24734 = cfg->cbb;
    D.24734->last_ins = ins;
    D.24735 = D.24734->last_ins;
    D.24734->code = D.24735;
    <D.24738>:
    return;
  }
  <D.24724>:
  D.24721 = ret->type;
  if (D.24721 == 13) goto <D.24739>; else goto <D.24740>;
  <D.24739>:
  {
    struct MonoInst * inst;

    D.24725 = cfg->mempool;
    inst = mono_mempool_alloc (D.24725, 56);
    inst->data.op[1].const_val = 0;
    D.24741 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.24741;
    inst->prev = 0B;
    D.24742 = inst->prev;
    inst->next = D.24742;
    inst->opcode = 426;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.24743 = inst->sreg3;
    inst->sreg2 = D.24743;
    D.24744 = inst->sreg2;
    inst->sreg1 = D.24744;
    D.24730 = cfg->ip;
    inst->cil_code = D.24730;
    D.24745 = cfg->ret;
    D.24746 = D.24745->dreg;
    inst->dreg = D.24746;
    D.24731 = val->dreg;
    inst->sreg1 = D.24731;
    D.24734 = cfg->cbb;
    D.24735 = D.24734->last_ins;
    if (D.24735 != 0B) goto <D.24747>; else goto <D.24748>;
    <D.24747>:
    D.24734 = cfg->cbb;
    D.24735 = D.24734->last_ins;
    D.24735->next = inst;
    D.24734 = cfg->cbb;
    D.24735 = D.24734->last_ins;
    inst->prev = D.24735;
    D.24734 = cfg->cbb;
    D.24734->last_ins = inst;
    goto <D.24749>;
    <D.24748>:
    D.24734 = cfg->cbb;
    D.24734 = cfg->cbb;
    D.24734->last_ins = inst;
    D.24735 = D.24734->last_ins;
    D.24734->code = D.24735;
    <D.24749>:
  }
  return;
  <D.24740>:
  D.24721 = ret->type;
  if (D.24721 == 12) goto <D.24750>; else goto <D.24751>;
  <D.24750>:
  {
    struct MonoInst * inst;

    D.24725 = cfg->mempool;
    inst = mono_mempool_alloc (D.24725, 56);
    inst->data.op[1].const_val = 0;
    D.24752 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.24752;
    inst->prev = 0B;
    D.24753 = inst->prev;
    inst->next = D.24753;
    inst->opcode = 848;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.24754 = inst->sreg3;
    inst->sreg2 = D.24754;
    D.24755 = inst->sreg2;
    inst->sreg1 = D.24755;
    D.24730 = cfg->ip;
    inst->cil_code = D.24730;
    D.24745 = cfg->ret;
    D.24746 = D.24745->dreg;
    inst->dreg = D.24746;
    D.24731 = val->dreg;
    inst->sreg1 = D.24731;
    D.24734 = cfg->cbb;
    D.24735 = D.24734->last_ins;
    if (D.24735 != 0B) goto <D.24756>; else goto <D.24757>;
    <D.24756>:
    D.24734 = cfg->cbb;
    D.24735 = D.24734->last_ins;
    D.24735->next = inst;
    D.24734 = cfg->cbb;
    D.24735 = D.24734->last_ins;
    inst->prev = D.24735;
    D.24734 = cfg->cbb;
    D.24734->last_ins = inst;
    goto <D.24758>;
    <D.24757>:
    D.24734 = cfg->cbb;
    D.24734 = cfg->cbb;
    D.24734->last_ins = inst;
    D.24735 = D.24734->last_ins;
    D.24734->code = D.24735;
    <D.24758>:
  }
  return;
  <D.24751>:
  <D.24720>:
  {
    struct MonoInst * inst;

    D.24725 = cfg->mempool;
    inst = mono_mempool_alloc (D.24725, 56);
    inst->data.op[1].const_val = 0;
    D.24759 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.24759;
    inst->prev = 0B;
    D.24760 = inst->prev;
    inst->next = D.24760;
    inst->opcode = 424;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.24761 = inst->sreg3;
    inst->sreg2 = D.24761;
    D.24762 = inst->sreg2;
    inst->sreg1 = D.24762;
    D.24730 = cfg->ip;
    inst->cil_code = D.24730;
    D.24745 = cfg->ret;
    D.24746 = D.24745->dreg;
    inst->dreg = D.24746;
    D.24731 = val->dreg;
    inst->sreg1 = D.24731;
    D.24734 = cfg->cbb;
    D.24735 = D.24734->last_ins;
    if (D.24735 != 0B) goto <D.24763>; else goto <D.24764>;
    <D.24763>:
    D.24734 = cfg->cbb;
    D.24735 = D.24734->last_ins;
    D.24735->next = inst;
    D.24734 = cfg->cbb;
    D.24735 = D.24734->last_ins;
    inst->prev = D.24735;
    D.24734 = cfg->cbb;
    D.24734->last_ins = inst;
    goto <D.24765>;
    <D.24764>:
    D.24734 = cfg->cbb;
    D.24734 = cfg->cbb;
    D.24734->last_ins = inst;
    D.24735 = D.24734->last_ins;
    D.24734->code = D.24735;
    <D.24765>:
  }
}


mono_arch_peephole_pass_1 (struct MonoCompile * cfg, struct MonoBasicBlock * bb)
{
  unsigned int D.24767;
  int D.24770;
  struct MonoInst * iftmp.55;
  short unsigned int D.24777;
  int D.24778;
  struct MonoInst * iftmp.56;
  struct MonoInst * ins;
  struct MonoInst * n;
  struct MonoInst * last_ins;

  last_ins = 0B;
  D.24767 = cfg->verbose_level;
  if (D.24767 > 2) goto <D.24768>; else goto <D.24769>;
  <D.24768>:
  D.24770 = bb->block_num;
  monoeg_g_print ("Basic block %d peephole pass 1\n", D.24770);
  <D.24769>:
  ins = bb->code;
  ins = bb->code;
  if (ins != 0B) goto <D.24772>; else goto <D.24773>;
  <D.24772>:
  iftmp.55 = ins->next;
  goto <D.24774>;
  <D.24773>:
  iftmp.55 = 0B;
  <D.24774>:
  n = iftmp.55;
  goto <D.22100>;
  <D.22099>:
  D.24767 = cfg->verbose_level;
  if (D.24767 > 2) goto <D.24775>; else goto <D.24776>;
  <D.24775>:
  mono_print_ins_index (0, ins);
  <D.24776>:
  D.24777 = ins->opcode;
  D.24778 = (int) D.24777;
  switch (D.24778) <default: <D.24779>>
  <D.24779>:
  last_ins = ins;
  ins = ins->next;
  ins = n;
  if (ins != 0B) goto <D.24781>; else goto <D.24782>;
  <D.24781>:
  iftmp.56 = ins->next;
  goto <D.24783>;
  <D.24782>:
  iftmp.56 = 0B;
  <D.24783>:
  n = iftmp.56;
  <D.22100>:
  if (ins != 0B) goto <D.22099>; else goto <D.22101>;
  <D.22101>:
  bb->last_ins = last_ins;
}


mono_arch_peephole_pass_2 (struct MonoCompile * cfg, struct MonoBasicBlock * bb)
{
  struct MonoInst * iftmp.57;
  short unsigned int D.24788;
  int D.24789;
  int D.24790;
  int D.24793;
  int D.24794;
  struct MonoInst * D.24798;
  struct MonoInst * D.24801;
  struct MonoInst * D.24804;
  struct MonoInst * D.24807;
  int D.24810;
  int D.24811;
  unsigned int D.24813;
  short unsigned int D.24820;
  int D.24822;
  int D.24825;
  int D.24826;
  int D.24829;
  guint16 iftmp.58;
  guint16 iftmp.59;
  struct MonoInst * iftmp.60;
  struct MonoInst * ins;
  struct MonoInst * n;
  struct MonoInst * last_ins;

  last_ins = 0B;
  ins = bb->code;
  ins = bb->code;
  if (ins != 0B) goto <D.24785>; else goto <D.24786>;
  <D.24785>:
  iftmp.57 = ins->next;
  goto <D.24787>;
  <D.24786>:
  iftmp.57 = 0B;
  <D.24787>:
  n = iftmp.57;
  goto <D.22124>;
  <D.22123>:
  {
    struct MonoInst * last_ins;

    last_ins = ins->prev;
    D.24788 = ins->opcode;
    D.24789 = (int) D.24788;
    switch (D.24789) <default: <D.24911>, case 388: <D.22114>, case 389: <D.22117>, case 390: <D.22116>, case 391: <D.22119>, case 392: <D.22118>, case 393: <D.22115>, case 424: <D.22122>, case 431: <D.22110>, case 582: <D.22120>, case 586: <D.22121>>
    <D.22110>:
    D.24790 = ins->data.op[1].const_val;
    if (D.24790 == 1) goto <D.24791>; else goto <D.24792>;
    <D.24791>:
    D.24793 = ins->dreg;
    D.24794 = ins->sreg1;
    if (D.24793 != D.24794) goto <D.24795>; else goto <D.24796>;
    <D.24795>:
    ins->opcode = 424;
    goto <D.24797>;
    <D.24796>:
    D.24798 = ins->prev;
    if (D.24798 != 0B) goto <D.24799>; else goto <D.24800>;
    <D.24799>:
    D.24798 = ins->prev;
    D.24801 = ins->next;
    D.24798->next = D.24801;
    <D.24800>:
    D.24801 = ins->next;
    if (D.24801 != 0B) goto <D.24802>; else goto <D.24803>;
    <D.24802>:
    D.24801 = ins->next;
    D.24798 = ins->prev;
    D.24801->prev = D.24798;
    <D.24803>:
    D.24804 = bb->code;
    if (D.24804 == ins) goto <D.24805>; else goto <D.24806>;
    <D.24805>:
    D.24801 = ins->next;
    bb->code = D.24801;
    <D.24806>:
    D.24807 = bb->last_ins;
    if (D.24807 == ins) goto <D.24808>; else goto <D.24809>;
    <D.24808>:
    D.24798 = ins->prev;
    bb->last_ins = D.24798;
    <D.24809>:
    ins->opcode = 316;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.24810 = ins->sreg3;
    ins->sreg2 = D.24810;
    D.24811 = ins->sreg2;
    ins->sreg1 = D.24811;
    // predicted unlikely by continue predictor.
    goto <D.22111>;
    <D.24797>:
    goto <D.24812>;
    <D.24792>:
    {
      int power2;

      D.24790 = ins->data.op[1].const_val;
      D.24813 = (unsigned int) D.24790;
      power2 = mono_is_power_of_two (D.24813);
      if (power2 > 0) goto <D.24814>; else goto <D.24815>;
      <D.24814>:
      ins->opcode = 439;
      ins->data.op[1].const_val = power2;
      <D.24815>:
    }
    <D.24812>:
    goto <D.22113>;
    <D.22114>:
    <D.22115>:
    if (last_ins != 0B) goto <D.24818>; else goto <D.24819>;
    <D.24818>:
    D.24820 = last_ins->opcode;
    if (D.24820 == 377) goto <D.24816>; else goto <D.24821>;
    <D.24821>:
    D.24820 = last_ins->opcode;
    if (D.24820 == 374) goto <D.24816>; else goto <D.24817>;
    <D.24816>:
    D.24794 = ins->sreg1;
    D.24822 = last_ins->dreg;
    if (D.24794 == D.24822) goto <D.24823>; else goto <D.24824>;
    <D.24823>:
    D.24825 = ins->data.op[0].const_val;
    D.24826 = last_ins->data.op[0].const_val;
    if (D.24825 == D.24826) goto <D.24827>; else goto <D.24828>;
    <D.24827>:
    D.24793 = ins->dreg;
    D.24829 = last_ins->sreg1;
    if (D.24793 == D.24829) goto <D.24830>; else goto <D.24831>;
    <D.24830>:
    D.24798 = ins->prev;
    if (D.24798 != 0B) goto <D.24832>; else goto <D.24833>;
    <D.24832>:
    D.24798 = ins->prev;
    D.24801 = ins->next;
    D.24798->next = D.24801;
    <D.24833>:
    D.24801 = ins->next;
    if (D.24801 != 0B) goto <D.24834>; else goto <D.24835>;
    <D.24834>:
    D.24801 = ins->next;
    D.24798 = ins->prev;
    D.24801->prev = D.24798;
    <D.24835>:
    D.24804 = bb->code;
    if (D.24804 == ins) goto <D.24836>; else goto <D.24837>;
    <D.24836>:
    D.24801 = ins->next;
    bb->code = D.24801;
    <D.24837>:
    D.24807 = bb->last_ins;
    if (D.24807 == ins) goto <D.24838>; else goto <D.24839>;
    <D.24838>:
    D.24798 = ins->prev;
    bb->last_ins = D.24798;
    <D.24839>:
    ins->opcode = 316;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.24810 = ins->sreg3;
    ins->sreg2 = D.24810;
    D.24811 = ins->sreg2;
    ins->sreg1 = D.24811;
    // predicted unlikely by continue predictor.
    goto <D.22111>;
    <D.24831>:
    ins->opcode = 424;
    D.24829 = last_ins->sreg1;
    ins->sreg1 = D.24829;
    goto <D.22113>;
    <D.24828>:
    <D.24824>:
    <D.24817>:
    <D.24819>:
    if (last_ins != 0B) goto <D.24842>; else goto <D.24843>;
    <D.24842>:
    D.24820 = last_ins->opcode;
    if (D.24820 == 393) goto <D.24840>; else goto <D.24844>;
    <D.24844>:
    D.24820 = last_ins->opcode;
    if (D.24820 == 388) goto <D.24840>; else goto <D.24841>;
    <D.24840>:
    D.24794 = ins->sreg1;
    D.24822 = last_ins->dreg;
    if (D.24794 != D.24822) goto <D.24845>; else goto <D.24846>;
    <D.24845>:
    D.24794 = ins->sreg1;
    D.24829 = last_ins->sreg1;
    if (D.24794 == D.24829) goto <D.24847>; else goto <D.24848>;
    <D.24847>:
    D.24825 = ins->data.op[0].const_val;
    D.24826 = last_ins->data.op[0].const_val;
    if (D.24825 == D.24826) goto <D.24849>; else goto <D.24850>;
    <D.24849>:
    D.24793 = ins->dreg;
    D.24822 = last_ins->dreg;
    if (D.24793 == D.24822) goto <D.24851>; else goto <D.24852>;
    <D.24851>:
    D.24798 = ins->prev;
    if (D.24798 != 0B) goto <D.24853>; else goto <D.24854>;
    <D.24853>:
    D.24798 = ins->prev;
    D.24801 = ins->next;
    D.24798->next = D.24801;
    <D.24854>:
    D.24801 = ins->next;
    if (D.24801 != 0B) goto <D.24855>; else goto <D.24856>;
    <D.24855>:
    D.24801 = ins->next;
    D.24798 = ins->prev;
    D.24801->prev = D.24798;
    <D.24856>:
    D.24804 = bb->code;
    if (D.24804 == ins) goto <D.24857>; else goto <D.24858>;
    <D.24857>:
    D.24801 = ins->next;
    bb->code = D.24801;
    <D.24858>:
    D.24807 = bb->last_ins;
    if (D.24807 == ins) goto <D.24859>; else goto <D.24860>;
    <D.24859>:
    D.24798 = ins->prev;
    bb->last_ins = D.24798;
    <D.24860>:
    ins->opcode = 316;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.24810 = ins->sreg3;
    ins->sreg2 = D.24810;
    D.24811 = ins->sreg2;
    ins->sreg1 = D.24811;
    // predicted unlikely by continue predictor.
    goto <D.22111>;
    <D.24852>:
    ins->opcode = 424;
    D.24822 = last_ins->dreg;
    ins->sreg1 = D.24822;
    goto <D.22113>;
    <D.24850>:
    <D.24848>:
    <D.24846>:
    <D.24841>:
    <D.24843>:
    goto <D.22113>;
    <D.22116>:
    <D.22117>:
    if (last_ins != 0B) goto <D.24861>; else goto <D.24862>;
    <D.24861>:
    D.24820 = last_ins->opcode;
    if (D.24820 == 375) goto <D.24863>; else goto <D.24864>;
    <D.24863>:
    D.24794 = ins->sreg1;
    D.24822 = last_ins->dreg;
    if (D.24794 == D.24822) goto <D.24865>; else goto <D.24866>;
    <D.24865>:
    D.24825 = ins->data.op[0].const_val;
    D.24826 = last_ins->data.op[0].const_val;
    if (D.24825 == D.24826) goto <D.24867>; else goto <D.24868>;
    <D.24867>:
    D.24788 = ins->opcode;
    if (D.24788 == 389) goto <D.24870>; else goto <D.24871>;
    <D.24870>:
    iftmp.58 = 580;
    goto <D.24872>;
    <D.24871>:
    iftmp.58 = 591;
    <D.24872>:
    ins->opcode = iftmp.58;
    D.24829 = last_ins->sreg1;
    ins->sreg1 = D.24829;
    <D.24868>:
    <D.24866>:
    <D.24864>:
    <D.24862>:
    goto <D.22113>;
    <D.22118>:
    <D.22119>:
    if (last_ins != 0B) goto <D.24873>; else goto <D.24874>;
    <D.24873>:
    D.24820 = last_ins->opcode;
    if (D.24820 == 376) goto <D.24875>; else goto <D.24876>;
    <D.24875>:
    D.24794 = ins->sreg1;
    D.24822 = last_ins->dreg;
    if (D.24794 == D.24822) goto <D.24877>; else goto <D.24878>;
    <D.24877>:
    D.24825 = ins->data.op[0].const_val;
    D.24826 = last_ins->data.op[0].const_val;
    if (D.24825 == D.24826) goto <D.24879>; else goto <D.24880>;
    <D.24879>:
    D.24788 = ins->opcode;
    if (D.24788 == 391) goto <D.24882>; else goto <D.24883>;
    <D.24882>:
    iftmp.59 = 581;
    goto <D.24884>;
    <D.24883>:
    iftmp.59 = 590;
    <D.24884>:
    ins->opcode = iftmp.59;
    D.24829 = last_ins->sreg1;
    ins->sreg1 = D.24829;
    <D.24880>:
    <D.24878>:
    <D.24876>:
    <D.24874>:
    goto <D.22113>;
    <D.22120>:
    <D.22121>:
    <D.22122>:
    ins->opcode = 424;
    D.24793 = ins->dreg;
    D.24794 = ins->sreg1;
    if (D.24793 == D.24794) goto <D.24885>; else goto <D.24886>;
    <D.24885>:
    D.24798 = ins->prev;
    if (D.24798 != 0B) goto <D.24887>; else goto <D.24888>;
    <D.24887>:
    D.24798 = ins->prev;
    D.24801 = ins->next;
    D.24798->next = D.24801;
    <D.24888>:
    D.24801 = ins->next;
    if (D.24801 != 0B) goto <D.24889>; else goto <D.24890>;
    <D.24889>:
    D.24801 = ins->next;
    D.24798 = ins->prev;
    D.24801->prev = D.24798;
    <D.24890>:
    D.24804 = bb->code;
    if (D.24804 == ins) goto <D.24891>; else goto <D.24892>;
    <D.24891>:
    D.24801 = ins->next;
    bb->code = D.24801;
    <D.24892>:
    D.24807 = bb->last_ins;
    if (D.24807 == ins) goto <D.24893>; else goto <D.24894>;
    <D.24893>:
    D.24798 = ins->prev;
    bb->last_ins = D.24798;
    <D.24894>:
    ins->opcode = 316;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.24810 = ins->sreg3;
    ins->sreg2 = D.24810;
    D.24811 = ins->sreg2;
    ins->sreg1 = D.24811;
    // predicted unlikely by continue predictor.
    goto <D.22111>;
    <D.24886>:
    if (last_ins != 0B) goto <D.24895>; else goto <D.24896>;
    <D.24895>:
    D.24820 = last_ins->opcode;
    if (D.24820 == 424) goto <D.24897>; else goto <D.24898>;
    <D.24897>:
    D.24794 = ins->sreg1;
    D.24822 = last_ins->dreg;
    if (D.24794 == D.24822) goto <D.24899>; else goto <D.24900>;
    <D.24899>:
    D.24793 = ins->dreg;
    D.24829 = last_ins->sreg1;
    if (D.24793 == D.24829) goto <D.24901>; else goto <D.24902>;
    <D.24901>:
    D.24798 = ins->prev;
    if (D.24798 != 0B) goto <D.24903>; else goto <D.24904>;
    <D.24903>:
    D.24798 = ins->prev;
    D.24801 = ins->next;
    D.24798->next = D.24801;
    <D.24904>:
    D.24801 = ins->next;
    if (D.24801 != 0B) goto <D.24905>; else goto <D.24906>;
    <D.24905>:
    D.24801 = ins->next;
    D.24798 = ins->prev;
    D.24801->prev = D.24798;
    <D.24906>:
    D.24804 = bb->code;
    if (D.24804 == ins) goto <D.24907>; else goto <D.24908>;
    <D.24907>:
    D.24801 = ins->next;
    bb->code = D.24801;
    <D.24908>:
    D.24807 = bb->last_ins;
    if (D.24807 == ins) goto <D.24909>; else goto <D.24910>;
    <D.24909>:
    D.24798 = ins->prev;
    bb->last_ins = D.24798;
    <D.24910>:
    ins->opcode = 316;
    ins->dreg = -1;
    ins->sreg3 = -1;
    D.24810 = ins->sreg3;
    ins->sreg2 = D.24810;
    D.24811 = ins->sreg2;
    ins->sreg1 = D.24811;
    // predicted unlikely by continue predictor.
    goto <D.22111>;
    <D.24902>:
    <D.24900>:
    <D.24898>:
    <D.24896>:
    goto <D.22113>;
    <D.24911>:
    <D.22113>:
    last_ins = ins;
    ins = ins->next;
  }
  <D.22111>:
  ins = n;
  if (ins != 0B) goto <D.24913>; else goto <D.24914>;
  <D.24913>:
  iftmp.60 = ins->next;
  goto <D.24915>;
  <D.24914>:
  iftmp.60 = 0B;
  <D.24915>:
  n = iftmp.60;
  <D.22124>:
  if (ins != 0B) goto <D.22123>; else goto <D.22125>;
  <D.22125>:
  bb->last_ins = last_ins;
}


mono_arch_decompose_long_opts (struct MonoCompile * cfg, struct MonoInst * ins)
{
  short unsigned int D.24916;
  int D.24917;
  unsigned int D.24918;
  struct MonoMemPool * D.24919;
  int D.24920;
  struct MonoInst * D.24921;
  int D.24922;
  int D.24923;
  const unsigned char * D.24924;
  int D.24925;
  int D.24926;
  int D.24927;
  int D.24928;
  int D.24929;
  int D.24930;
  struct MonoBasicBlock * D.24931;
  struct MonoInst * D.24932;
  int D.24936;
  struct MonoInst * D.24937;
  int D.24938;
  int D.24939;
  int D.24943;
  struct MonoInst * D.24944;
  int D.24945;
  int D.24946;
  int D.24947;
  int D.24948;
  int D.24949;
  int D.24953;
  struct MonoInst * D.24954;
  int D.24955;
  int D.24956;
  int D.24960;
  unsigned int D.24961;
  int D.24962;
  struct MonoInst * D.24963;
  int D.24964;
  int D.24965;
  int D.24966;
  int D.24970;
  struct MonoInst * D.24971;
  int D.24972;
  int D.24973;
  int D.24977;
  struct MonoInst * D.24978;
  int D.24979;
  int D.24980;
  int D.24981;
  int D.24985;
  struct MonoInst * D.24986;
  int D.24987;
  int D.24988;
  unsigned int D.24992;
  int D.24993;
  struct MonoInst * D.24994;
  int D.24995;
  int D.24996;
  int D.25000;
  struct MonoInst * D.25001;
  int D.25002;
  int D.25003;
  int D.25007;
  struct MonoInst * D.25008;
  int D.25009;
  int D.25010;
  int D.25014;
  struct MonoInst * D.25015;
  int D.25016;
  int D.25017;
  unsigned int D.25021;
  int D.25022;
  struct MonoInst * D.25023;
  int D.25024;
  int D.25025;
  int D.25029;
  struct MonoInst * D.25030;
  int D.25031;
  int D.25032;
  int D.25036;
  struct MonoInst * D.25037;
  int D.25038;
  int D.25039;
  int D.25043;
  struct MonoInst * D.25044;
  int D.25045;
  int D.25046;
  unsigned int D.25050;
  int D.25051;
  struct MonoInst * D.25052;
  int D.25053;
  int D.25054;
  int D.25058;
  struct MonoInst * D.25059;
  int D.25060;
  int D.25061;
  int D.25065;
  struct MonoInst * D.25066;
  int D.25067;
  int D.25068;
  int D.25072;
  struct MonoInst * D.25073;
  int D.25074;
  int D.25075;
  unsigned int D.25079;
  unsigned int D.25080;
  unsigned int D.25081;
  unsigned int D.25082;
  unsigned int D.25083;
  int D.25084;
  struct MonoInst * D.25085;
  int D.25086;
  int D.25087;
  int D.25091;
  struct MonoInst * D.25092;
  int D.25093;
  int D.25094;
  int D.25098;
  struct MonoInst * D.25099;
  int D.25100;
  int D.25101;
  int D.25105;
  struct MonoInst * D.25106;
  int D.25107;
  int D.25108;
  int D.25112;
  struct MonoInst * D.25113;
  int D.25114;
  int D.25115;
  int D.25119;
  struct MonoInst * D.25120;
  int D.25121;
  int D.25122;
  int D.25126;
  struct MonoInst * D.25127;
  int D.25128;
  int D.25129;
  int D.25133;
  struct MonoInst * D.25134;
  int D.25135;
  int D.25136;
  int D.25140;
  struct MonoInst * D.25141;
  int D.25142;
  int D.25143;
  int D.25147;
  struct MonoInst * D.25148;
  int D.25149;
  int D.25150;
  int D.25154;
  struct MonoInst * D.25155;
  int D.25156;
  int D.25157;
  int D.25161;
  struct MonoInst * D.25162;
  int D.25163;
  int D.25164;
  int D.25168;
  struct MonoInst * D.25169;
  int D.25170;
  int D.25171;
  int D.25175;
  struct MonoInst * D.25176;
  int D.25177;
  int D.25178;
  int D.25182;
  struct MonoInst * D.25183;
  int D.25184;
  int D.25185;
  int D.25189;
  struct MonoInst * D.25190;
  int D.25191;
  int D.25192;
  int D.25196;
  struct MonoInst * D.25197;
  int D.25198;
  int D.25199;
  int D.25203;
  struct MonoInst * D.25204;
  int D.25205;
  int D.25206;
  int D.25210;
  struct MonoInst * D.25211;
  int D.25212;
  int D.25213;
  int D.25217;
  struct MonoInst * D.25218;
  int D.25219;
  int D.25220;
  int D.25224;
  struct MonoInst * D.25225;
  int D.25226;
  int D.25227;
  int D.25231;
  struct MonoInst * D.25232;
  int D.25233;
  int D.25234;
  int D.25238;
  struct MonoInst * D.25239;
  int D.25240;
  int D.25241;
  unsigned int D.25245;
  unsigned int D.25246;
  int D.25247;
  struct MonoInst * D.25248;
  int D.25249;
  int D.25250;
  int D.25254;
  struct MonoInst * D.25255;
  int D.25256;
  int D.25257;
  int D.25261;
  struct MonoInst * D.25262;
  int D.25263;
  int D.25264;
  int D.25268;
  struct MonoInst * D.25269;
  int D.25270;
  int D.25271;
  int D.25275;
  struct MonoInst * D.25276;
  int D.25277;
  int D.25278;
  int D.25282;
  struct MonoInst * D.25283;
  int D.25284;
  int D.25285;
  int D.25289;
  struct MonoInst * D.25290;
  int D.25291;
  int D.25292;
  int D.25296;
  struct MonoInst * D.25297;
  int D.25298;
  int D.25299;
  int D.25303;
  struct MonoInst * D.25304;
  int D.25305;
  int D.25306;
  int D.25310;
  struct MonoInst * D.25311;
  int D.25312;
  int D.25313;
  int D.25317;
  struct MonoInst * D.25318;
  int D.25319;
  int D.25320;
  int D.25324;
  struct MonoInst * D.25325;
  int D.25326;
  int D.25327;
  int D.25331;
  struct MonoInst * D.25332;
  int D.25333;
  int D.25334;
  int D.25338;
  struct MonoInst * D.25339;
  int D.25340;
  int D.25341;
  int D.25345;
  struct MonoInst * D.25346;
  int D.25347;
  int D.25348;
  int D.25352;
  struct MonoInst * D.25353;
  int D.25354;
  int D.25355;
  int D.25359;
  struct MonoInst * D.25360;
  int D.25361;
  int D.25362;
  int D.25366;
  struct MonoInst * D.25367;
  int D.25368;
  int D.25369;
  int D.25373;
  struct MonoInst * D.25374;
  int D.25375;
  int D.25376;
  unsigned int D.25380;
  unsigned int D.25381;
  unsigned int D.25382;
  unsigned int D.25383;
  unsigned int D.25384;
  int D.25385;
  struct MonoInst * D.25386;
  int D.25387;
  int D.25388;
  int D.25392;
  struct MonoInst * D.25393;
  int D.25394;
  int D.25395;
  int D.25399;
  struct MonoInst * D.25400;
  int D.25401;
  int D.25402;
  int D.25406;
  struct MonoInst * D.25407;
  int D.25408;
  int D.25409;
  int D.25413;
  struct MonoInst * D.25414;
  int D.25415;
  int D.25416;
  int D.25420;
  struct MonoInst * D.25421;
  int D.25422;
  int D.25423;
  int D.25427;
  struct MonoInst * D.25428;
  int D.25429;
  int D.25430;
  int D.25434;
  struct MonoInst * D.25435;
  int D.25436;
  int D.25437;
  int D.25441;
  struct MonoInst * D.25442;
  int D.25443;
  int D.25444;
  int D.25448;
  struct MonoInst * D.25449;
  int D.25450;
  int D.25451;
  int D.25455;
  struct MonoInst * D.25456;
  int D.25457;
  int D.25458;
  int D.25462;
  struct MonoInst * D.25463;
  int D.25464;
  int D.25465;
  int D.25469;
  struct MonoInst * D.25470;
  int D.25471;
  int D.25472;
  int D.25476;
  struct MonoInst * D.25477;
  int D.25478;
  int D.25479;
  int D.25483;
  struct MonoInst * D.25484;
  int D.25485;
  int D.25486;
  int D.25490;
  struct MonoInst * D.25491;
  int D.25492;
  int D.25493;
  int D.25497;
  struct MonoInst * D.25498;
  int D.25499;
  int D.25500;
  int D.25504;
  struct MonoInst * D.25505;
  int D.25506;
  int D.25507;
  int D.25511;
  struct MonoInst * D.25512;
  int D.25513;
  int D.25514;
  int D.25518;
  struct MonoInst * D.25519;
  int D.25520;
  int D.25521;
  int D.25525;
  struct MonoInst * D.25526;
  int D.25527;
  int D.25528;
  int D.25532;
  struct MonoInst * D.25533;
  int D.25534;
  int D.25535;
  unsigned int D.25539;
  unsigned int D.25540;
  int D.25541;
  struct MonoInst * D.25542;
  int D.25543;
  int D.25544;
  int D.25548;
  struct MonoInst * D.25549;
  int D.25550;
  int D.25551;
  int D.25555;
  struct MonoInst * D.25556;
  int D.25557;
  int D.25558;
  int D.25562;
  struct MonoInst * D.25563;
  int D.25564;
  int D.25565;
  int D.25569;
  struct MonoInst * D.25570;
  int D.25571;
  int D.25572;
  int D.25576;
  struct MonoInst * D.25577;
  int D.25578;
  int D.25579;
  int D.25583;
  struct MonoInst * D.25584;
  int D.25585;
  int D.25586;
  int D.25590;
  struct MonoInst * D.25591;
  int D.25592;
  int D.25593;
  int D.25597;
  struct MonoInst * D.25598;
  int D.25599;
  int D.25600;
  int D.25604;
  struct MonoInst * D.25605;
  int D.25606;
  int D.25607;
  int D.25611;
  struct MonoInst * D.25612;
  int D.25613;
  int D.25614;
  int D.25618;
  struct MonoInst * D.25619;
  int D.25620;
  int D.25621;
  int D.25625;
  struct MonoInst * D.25626;
  int D.25627;
  int D.25628;
  int D.25632;
  struct MonoInst * D.25633;
  int D.25634;
  int D.25635;
  int D.25639;
  struct MonoInst * D.25640;
  int D.25641;
  int D.25642;
  int D.25646;
  struct MonoInst * D.25647;
  int D.25648;
  int D.25649;
  int D.25653;
  struct MonoInst * D.25654;
  int D.25655;
  int D.25656;
  int D.25660;
  struct MonoInst * D.25661;
  int D.25662;
  int D.25663;
  int D.25667;
  struct MonoInst * D.25668;
  int D.25669;
  int D.25670;
  unsigned int D.25674;
  int D.25675;
  struct MonoInst * D.25676;
  int D.25677;
  int D.25678;
  int D.25682;
  struct MonoInst * D.25683;
  int D.25684;
  int D.25685;
  int D.25689;
  struct MonoInst * D.25690;
  int D.25691;
  int D.25692;
  int D.25696;
  struct MonoInst * D.25697;
  int D.25698;
  int D.25699;
  int D.25703;
  struct MonoInst * D.25704;
  int D.25705;
  int D.25706;
  int D.25710;
  struct MonoInst * D.25711;
  int D.25712;
  int D.25713;
  int D.25717;
  struct MonoInst * D.25718;
  int D.25719;
  int D.25720;
  int D.25724;
  struct MonoInst * D.25725;
  int D.25726;
  int D.25727;
  int D.25731;
  struct MonoInst * D.25732;
  int D.25733;
  int D.25734;
  int D.25738;
  struct MonoInst * D.25739;
  int D.25740;
  int D.25741;
  int D.25745;
  struct MonoInst * D.25746;
  int D.25747;
  int D.25748;
  int D.25752;
  struct MonoInst * D.25753;
  int D.25754;
  int D.25755;
  int D.25759;
  struct MonoInst * D.25760;
  int D.25761;
  int D.25762;
  int D.25766;
  struct MonoInst * D.25767;
  int D.25768;
  int D.25769;
  int D.25773;
  struct MonoInst * D.25774;
  int D.25775;
  int D.25776;
  int D.25780;
  struct MonoInst * D.25781;
  int D.25782;
  int D.25783;
  int tmp1;
  int tmp2;
  int tmp3;
  int tmp4;
  int tmp5;

  tmp1 = -1;
  tmp2 = -1;
  tmp3 = -1;
  tmp4 = -1;
  tmp5 = -1;
  D.24916 = ins->opcode;
  D.24917 = (int) D.24916;
  switch (D.24917) <default: <D.22352>, case 479: <D.22135>, case 480: <D.22146>, case 481: <D.22156>, case 482: <D.22157>, case 483: <D.22158>, case 484: <D.22159>, case 485: <D.22160>, case 489: <D.22161>, case 490: <D.22162>, case 491: <D.22163>, case 492: <D.22164>, case 507: <D.22169>, case 508: <D.22203>, case 509: <D.22233>, case 510: <D.22234>, case 511: <D.22235>, case 512: <D.22268>, case 531: <D.22298>, case 532: <D.22299>, case 533: <D.22300>, case 534: <D.22301>, case 535: <D.22302>, case 538: <D.22141>, case 539: <D.22151>, case 540: <D.22303>, case 544: <D.22304>, case 545: <D.22305>, case 546: <D.22306>, case 547: <D.22307>, case 548: <D.22308>, case 549: <D.22309>, case 550: <D.22310>, case 551: <D.22311>, case 552: <D.22312>, case 553: <D.22313>, case 554: <D.22314>, case 555: <D.22315>, case 556: <D.22316>, case 557: <D.22317>, case 558: <D.22318>, case 559: <D.22319>, case 560: <D.22320>, case 564: <D.22321>, case 743: <D.22348>, case 744: <D.22349>, case 749: <D.22350>, case 750: <D.22351>>
  <D.22135>:
  D.24918 = mono_alloc_ireg (cfg);
  tmp1 = (int) D.24918;
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.24920 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.24920;
    inst->prev = 0B;
    D.24921 = inst->prev;
    inst->next = D.24921;
    inst->opcode = 565;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.24922 = inst->sreg3;
    inst->sreg2 = D.24922;
    D.24923 = inst->sreg2;
    inst->sreg1 = D.24923;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    D.24925 = ins->dreg;
    D.24926 = D.24925 + 1;
    inst->dreg = D.24926;
    D.24927 = ins->sreg1;
    D.24928 = D.24927 + 1;
    inst->sreg1 = D.24928;
    D.24929 = ins->sreg2;
    D.24930 = D.24929 + 1;
    inst->sreg2 = D.24930;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.24933>; else goto <D.24934>;
    <D.24933>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.24935>;
    <D.24934>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.24935>:
  }
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.24936 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.24936;
    inst->prev = 0B;
    D.24937 = inst->prev;
    inst->next = D.24937;
    inst->opcode = 871;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.24938 = inst->sreg3;
    inst->sreg2 = D.24938;
    D.24939 = inst->sreg2;
    inst->sreg1 = D.24939;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->dreg = tmp1;
    D.24925 = ins->dreg;
    D.24926 = D.24925 + 1;
    inst->sreg1 = D.24926;
    D.24927 = ins->sreg1;
    D.24928 = D.24927 + 1;
    inst->sreg2 = D.24928;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.24940>; else goto <D.24941>;
    <D.24940>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.24942>;
    <D.24941>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.24942>:
  }
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.24943 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.24943;
    inst->prev = 0B;
    D.24944 = inst->prev;
    inst->next = D.24944;
    inst->opcode = 565;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.24945 = inst->sreg3;
    inst->sreg2 = D.24945;
    D.24946 = inst->sreg2;
    inst->sreg1 = D.24946;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    D.24925 = ins->dreg;
    D.24947 = D.24925 + 2;
    inst->dreg = D.24947;
    D.24927 = ins->sreg1;
    D.24948 = D.24927 + 2;
    inst->sreg1 = D.24948;
    D.24929 = ins->sreg2;
    D.24949 = D.24929 + 2;
    inst->sreg2 = D.24949;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.24950>; else goto <D.24951>;
    <D.24950>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.24952>;
    <D.24951>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.24952>:
  }
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.24953 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.24953;
    inst->prev = 0B;
    D.24954 = inst->prev;
    inst->next = D.24954;
    inst->opcode = 565;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.24955 = inst->sreg3;
    inst->sreg2 = D.24955;
    D.24956 = inst->sreg2;
    inst->sreg1 = D.24956;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    D.24925 = ins->dreg;
    D.24947 = D.24925 + 2;
    inst->dreg = D.24947;
    D.24925 = ins->dreg;
    D.24947 = D.24925 + 2;
    inst->sreg1 = D.24947;
    inst->sreg2 = tmp1;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.24957>; else goto <D.24958>;
    <D.24957>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.24959>;
    <D.24958>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.24959>:
  }
  ins->opcode = 316;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.24960 = ins->sreg3;
  ins->sreg2 = D.24960;
  D.24929 = ins->sreg2;
  ins->sreg1 = D.24929;
  goto <D.22140>;
  <D.22141>:
  D.24961 = mono_alloc_ireg (cfg);
  tmp1 = (int) D.24961;
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.24962 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.24962;
    inst->prev = 0B;
    D.24963 = inst->prev;
    inst->next = D.24963;
    inst->opcode = 625;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.24964 = inst->sreg3;
    inst->sreg2 = D.24964;
    D.24965 = inst->sreg2;
    inst->sreg1 = D.24965;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    D.24925 = ins->dreg;
    D.24926 = D.24925 + 1;
    inst->dreg = D.24926;
    D.24927 = ins->sreg1;
    D.24928 = D.24927 + 1;
    inst->sreg1 = D.24928;
    D.24966 = ins->data.op[0].const_val;
    inst->data.op[1].const_val = D.24966;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.24967>; else goto <D.24968>;
    <D.24967>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.24969>;
    <D.24968>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.24969>:
  }
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.24970 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.24970;
    inst->prev = 0B;
    D.24971 = inst->prev;
    inst->next = D.24971;
    inst->opcode = 871;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.24972 = inst->sreg3;
    inst->sreg2 = D.24972;
    D.24973 = inst->sreg2;
    inst->sreg1 = D.24973;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->dreg = tmp1;
    D.24925 = ins->dreg;
    D.24926 = D.24925 + 1;
    inst->sreg1 = D.24926;
    D.24927 = ins->sreg1;
    D.24928 = D.24927 + 1;
    inst->sreg2 = D.24928;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.24974>; else goto <D.24975>;
    <D.24974>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.24976>;
    <D.24975>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.24976>:
  }
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.24977 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.24977;
    inst->prev = 0B;
    D.24978 = inst->prev;
    inst->next = D.24978;
    inst->opcode = 625;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.24979 = inst->sreg3;
    inst->sreg2 = D.24979;
    D.24980 = inst->sreg2;
    inst->sreg1 = D.24980;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    D.24925 = ins->dreg;
    D.24947 = D.24925 + 2;
    inst->dreg = D.24947;
    D.24927 = ins->sreg1;
    D.24948 = D.24927 + 2;
    inst->sreg1 = D.24948;
    D.24981 = ins->data.op[1].const_val;
    inst->data.op[1].const_val = D.24981;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.24982>; else goto <D.24983>;
    <D.24982>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.24984>;
    <D.24983>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.24984>:
  }
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.24985 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.24985;
    inst->prev = 0B;
    D.24986 = inst->prev;
    inst->next = D.24986;
    inst->opcode = 565;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.24987 = inst->sreg3;
    inst->sreg2 = D.24987;
    D.24988 = inst->sreg2;
    inst->sreg1 = D.24988;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    D.24925 = ins->dreg;
    D.24947 = D.24925 + 2;
    inst->dreg = D.24947;
    D.24925 = ins->dreg;
    D.24947 = D.24925 + 2;
    inst->sreg1 = D.24947;
    inst->sreg2 = tmp1;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.24989>; else goto <D.24990>;
    <D.24989>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.24991>;
    <D.24990>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.24991>:
  }
  ins->opcode = 316;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.24960 = ins->sreg3;
  ins->sreg2 = D.24960;
  D.24929 = ins->sreg2;
  ins->sreg1 = D.24929;
  goto <D.22140>;
  <D.22146>:
  D.24992 = mono_alloc_ireg (cfg);
  tmp1 = (int) D.24992;
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.24993 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.24993;
    inst->prev = 0B;
    D.24994 = inst->prev;
    inst->next = D.24994;
    inst->opcode = 566;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.24995 = inst->sreg3;
    inst->sreg2 = D.24995;
    D.24996 = inst->sreg2;
    inst->sreg1 = D.24996;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    D.24925 = ins->dreg;
    D.24926 = D.24925 + 1;
    inst->dreg = D.24926;
    D.24927 = ins->sreg1;
    D.24928 = D.24927 + 1;
    inst->sreg1 = D.24928;
    D.24929 = ins->sreg2;
    D.24930 = D.24929 + 1;
    inst->sreg2 = D.24930;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.24997>; else goto <D.24998>;
    <D.24997>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.24999>;
    <D.24998>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.24999>:
  }
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25000 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25000;
    inst->prev = 0B;
    D.25001 = inst->prev;
    inst->next = D.25001;
    inst->opcode = 871;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25002 = inst->sreg3;
    inst->sreg2 = D.25002;
    D.25003 = inst->sreg2;
    inst->sreg1 = D.25003;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->dreg = tmp1;
    D.24927 = ins->sreg1;
    D.24928 = D.24927 + 1;
    inst->sreg1 = D.24928;
    D.24925 = ins->dreg;
    D.24926 = D.24925 + 1;
    inst->sreg2 = D.24926;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25004>; else goto <D.25005>;
    <D.25004>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25006>;
    <D.25005>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25006>:
  }
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25007 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25007;
    inst->prev = 0B;
    D.25008 = inst->prev;
    inst->next = D.25008;
    inst->opcode = 566;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25009 = inst->sreg3;
    inst->sreg2 = D.25009;
    D.25010 = inst->sreg2;
    inst->sreg1 = D.25010;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    D.24925 = ins->dreg;
    D.24947 = D.24925 + 2;
    inst->dreg = D.24947;
    D.24927 = ins->sreg1;
    D.24948 = D.24927 + 2;
    inst->sreg1 = D.24948;
    D.24929 = ins->sreg2;
    D.24949 = D.24929 + 2;
    inst->sreg2 = D.24949;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25011>; else goto <D.25012>;
    <D.25011>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25013>;
    <D.25012>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25013>:
  }
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25014 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25014;
    inst->prev = 0B;
    D.25015 = inst->prev;
    inst->next = D.25015;
    inst->opcode = 566;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25016 = inst->sreg3;
    inst->sreg2 = D.25016;
    D.25017 = inst->sreg2;
    inst->sreg1 = D.25017;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    D.24925 = ins->dreg;
    D.24947 = D.24925 + 2;
    inst->dreg = D.24947;
    D.24925 = ins->dreg;
    D.24947 = D.24925 + 2;
    inst->sreg1 = D.24947;
    inst->sreg2 = tmp1;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25018>; else goto <D.25019>;
    <D.25018>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25020>;
    <D.25019>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25020>:
  }
  ins->opcode = 316;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.24960 = ins->sreg3;
  ins->sreg2 = D.24960;
  D.24929 = ins->sreg2;
  ins->sreg1 = D.24929;
  goto <D.22140>;
  <D.22151>:
  D.25021 = mono_alloc_ireg (cfg);
  tmp1 = (int) D.25021;
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25022 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25022;
    inst->prev = 0B;
    D.25023 = inst->prev;
    inst->next = D.25023;
    inst->opcode = 626;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25024 = inst->sreg3;
    inst->sreg2 = D.25024;
    D.25025 = inst->sreg2;
    inst->sreg1 = D.25025;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    D.24925 = ins->dreg;
    D.24926 = D.24925 + 1;
    inst->dreg = D.24926;
    D.24927 = ins->sreg1;
    D.24928 = D.24927 + 1;
    inst->sreg1 = D.24928;
    D.24966 = ins->data.op[0].const_val;
    inst->data.op[1].const_val = D.24966;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25026>; else goto <D.25027>;
    <D.25026>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25028>;
    <D.25027>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25028>:
  }
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25029 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25029;
    inst->prev = 0B;
    D.25030 = inst->prev;
    inst->next = D.25030;
    inst->opcode = 871;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25031 = inst->sreg3;
    inst->sreg2 = D.25031;
    D.25032 = inst->sreg2;
    inst->sreg1 = D.25032;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->dreg = tmp1;
    D.24927 = ins->sreg1;
    D.24928 = D.24927 + 1;
    inst->sreg1 = D.24928;
    D.24925 = ins->dreg;
    D.24926 = D.24925 + 1;
    inst->sreg2 = D.24926;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25033>; else goto <D.25034>;
    <D.25033>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25035>;
    <D.25034>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25035>:
  }
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25036 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25036;
    inst->prev = 0B;
    D.25037 = inst->prev;
    inst->next = D.25037;
    inst->opcode = 626;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25038 = inst->sreg3;
    inst->sreg2 = D.25038;
    D.25039 = inst->sreg2;
    inst->sreg1 = D.25039;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    D.24925 = ins->dreg;
    D.24947 = D.24925 + 2;
    inst->dreg = D.24947;
    D.24927 = ins->sreg1;
    D.24948 = D.24927 + 2;
    inst->sreg1 = D.24948;
    D.24981 = ins->data.op[1].const_val;
    inst->data.op[1].const_val = D.24981;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25040>; else goto <D.25041>;
    <D.25040>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25042>;
    <D.25041>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25042>:
  }
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25043 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25043;
    inst->prev = 0B;
    D.25044 = inst->prev;
    inst->next = D.25044;
    inst->opcode = 566;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25045 = inst->sreg3;
    inst->sreg2 = D.25045;
    D.25046 = inst->sreg2;
    inst->sreg1 = D.25046;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    D.24925 = ins->dreg;
    D.24947 = D.24925 + 2;
    inst->dreg = D.24947;
    D.24925 = ins->dreg;
    D.24947 = D.24925 + 2;
    inst->sreg1 = D.24947;
    inst->sreg2 = tmp1;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25047>; else goto <D.25048>;
    <D.25047>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25049>;
    <D.25048>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25049>:
  }
  ins->opcode = 316;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.24960 = ins->sreg3;
  ins->sreg2 = D.24960;
  D.24929 = ins->sreg2;
  ins->sreg1 = D.24929;
  goto <D.22140>;
  <D.22156>:
  <D.22157>:
  <D.22158>:
  <D.22159>:
  <D.22160>:
  <D.22161>:
  <D.22162>:
  <D.22163>:
  mono_print_ins (ins);
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-mips.c", 2218);
  <D.22164>:
  D.25050 = mono_alloc_ireg (cfg);
  tmp1 = (int) D.25050;
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25051 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25051;
    inst->prev = 0B;
    D.25052 = inst->prev;
    inst->next = D.25052;
    inst->opcode = 566;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25053 = inst->sreg3;
    inst->sreg2 = D.25053;
    D.25054 = inst->sreg2;
    inst->sreg1 = D.25054;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    D.24925 = ins->dreg;
    D.24926 = D.24925 + 1;
    inst->dreg = D.24926;
    inst->sreg1 = 0;
    D.24927 = ins->sreg1;
    D.24928 = D.24927 + 1;
    inst->sreg2 = D.24928;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25055>; else goto <D.25056>;
    <D.25055>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25057>;
    <D.25056>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25057>:
  }
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25058 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25058;
    inst->prev = 0B;
    D.25059 = inst->prev;
    inst->next = D.25059;
    inst->opcode = 871;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25060 = inst->sreg3;
    inst->sreg2 = D.25060;
    D.25061 = inst->sreg2;
    inst->sreg1 = D.25061;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->dreg = tmp1;
    inst->sreg1 = 0;
    D.24925 = ins->dreg;
    D.24926 = D.24925 + 1;
    inst->sreg2 = D.24926;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25062>; else goto <D.25063>;
    <D.25062>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25064>;
    <D.25063>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25064>:
  }
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25065 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25065;
    inst->prev = 0B;
    D.25066 = inst->prev;
    inst->next = D.25066;
    inst->opcode = 566;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25067 = inst->sreg3;
    inst->sreg2 = D.25067;
    D.25068 = inst->sreg2;
    inst->sreg1 = D.25068;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    D.24925 = ins->dreg;
    D.24947 = D.24925 + 2;
    inst->dreg = D.24947;
    inst->sreg1 = 0;
    D.24927 = ins->sreg1;
    D.24948 = D.24927 + 2;
    inst->sreg2 = D.24948;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25069>; else goto <D.25070>;
    <D.25069>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25071>;
    <D.25070>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25071>:
  }
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25072 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25072;
    inst->prev = 0B;
    D.25073 = inst->prev;
    inst->next = D.25073;
    inst->opcode = 566;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25074 = inst->sreg3;
    inst->sreg2 = D.25074;
    D.25075 = inst->sreg2;
    inst->sreg1 = D.25075;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    D.24925 = ins->dreg;
    D.24947 = D.24925 + 2;
    inst->dreg = D.24947;
    D.24925 = ins->dreg;
    D.24947 = D.24925 + 2;
    inst->sreg1 = D.24947;
    inst->sreg2 = tmp1;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25076>; else goto <D.25077>;
    <D.25076>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25078>;
    <D.25077>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25078>:
  }
  ins->opcode = 316;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.24960 = ins->sreg3;
  ins->sreg2 = D.24960;
  D.24929 = ins->sreg2;
  ins->sreg1 = D.24929;
  goto <D.22140>;
  mono_print_ins (ins);
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-mips.c", 2248);
  <D.22169>:
  D.25079 = mono_alloc_ireg (cfg);
  tmp1 = (int) D.25079;
  D.25080 = mono_alloc_ireg (cfg);
  tmp2 = (int) D.25080;
  D.25081 = mono_alloc_ireg (cfg);
  tmp3 = (int) D.25081;
  D.25082 = mono_alloc_ireg (cfg);
  tmp4 = (int) D.25082;
  D.25083 = mono_alloc_ireg (cfg);
  tmp5 = (int) D.25083;
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25084 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25084;
    inst->prev = 0B;
    D.25085 = inst->prev;
    inst->next = D.25085;
    inst->opcode = 565;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25086 = inst->sreg3;
    inst->sreg2 = D.25086;
    D.25087 = inst->sreg2;
    inst->sreg1 = D.25087;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    D.24925 = ins->dreg;
    D.24926 = D.24925 + 1;
    inst->dreg = D.24926;
    D.24927 = ins->sreg1;
    D.24928 = D.24927 + 1;
    inst->sreg1 = D.24928;
    D.24929 = ins->sreg2;
    D.24930 = D.24929 + 1;
    inst->sreg2 = D.24930;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25088>; else goto <D.25089>;
    <D.25088>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25090>;
    <D.25089>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25090>:
  }
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25091 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25091;
    inst->prev = 0B;
    D.25092 = inst->prev;
    inst->next = D.25092;
    inst->opcode = 871;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25093 = inst->sreg3;
    inst->sreg2 = D.25093;
    D.25094 = inst->sreg2;
    inst->sreg1 = D.25094;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->dreg = tmp5;
    D.24925 = ins->dreg;
    D.24926 = D.24925 + 1;
    inst->sreg1 = D.24926;
    D.24927 = ins->sreg1;
    D.24928 = D.24927 + 1;
    inst->sreg2 = D.24928;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25095>; else goto <D.25096>;
    <D.25095>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25097>;
    <D.25096>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25097>:
  }
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25098 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25098;
    inst->prev = 0B;
    D.25099 = inst->prev;
    inst->next = D.25099;
    inst->opcode = 565;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25100 = inst->sreg3;
    inst->sreg2 = D.25100;
    D.25101 = inst->sreg2;
    inst->sreg1 = D.25101;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    D.24925 = ins->dreg;
    D.24947 = D.24925 + 2;
    inst->dreg = D.24947;
    D.24927 = ins->sreg1;
    D.24948 = D.24927 + 2;
    inst->sreg1 = D.24948;
    D.24929 = ins->sreg2;
    D.24949 = D.24929 + 2;
    inst->sreg2 = D.24949;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25102>; else goto <D.25103>;
    <D.25102>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25104>;
    <D.25103>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25104>:
  }
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25105 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25105;
    inst->prev = 0B;
    D.25106 = inst->prev;
    inst->next = D.25106;
    inst->opcode = 565;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25107 = inst->sreg3;
    inst->sreg2 = D.25107;
    D.25108 = inst->sreg2;
    inst->sreg1 = D.25108;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    D.24925 = ins->dreg;
    D.24947 = D.24925 + 2;
    inst->dreg = D.24947;
    inst->sreg1 = tmp5;
    D.24925 = ins->dreg;
    D.24947 = D.24925 + 2;
    inst->sreg2 = D.24947;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25109>; else goto <D.25110>;
    <D.25109>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25111>;
    <D.25110>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25111>:
  }
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25112 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25112;
    inst->prev = 0B;
    D.25113 = inst->prev;
    inst->next = D.25113;
    inst->opcode = 574;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25114 = inst->sreg3;
    inst->sreg2 = D.25114;
    D.25115 = inst->sreg2;
    inst->sreg1 = D.25115;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->dreg = tmp1;
    D.24927 = ins->sreg1;
    D.24948 = D.24927 + 2;
    inst->sreg1 = D.24948;
    D.24929 = ins->sreg2;
    D.24949 = D.24929 + 2;
    inst->sreg2 = D.24949;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25116>; else goto <D.25117>;
    <D.25116>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25118>;
    <D.25117>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25118>:
  }
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25119 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25119;
    inst->prev = 0B;
    D.25120 = inst->prev;
    inst->next = D.25120;
    inst->opcode = 574;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25121 = inst->sreg3;
    inst->sreg2 = D.25121;
    D.25122 = inst->sreg2;
    inst->sreg1 = D.25122;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->dreg = tmp2;
    D.24925 = ins->dreg;
    D.24947 = D.24925 + 2;
    inst->sreg1 = D.24947;
    D.24929 = ins->sreg2;
    D.24949 = D.24929 + 2;
    inst->sreg2 = D.24949;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25123>; else goto <D.25124>;
    <D.25123>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25125>;
    <D.25124>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25125>:
  }
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25126 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25126;
    inst->prev = 0B;
    D.25127 = inst->prev;
    inst->next = D.25127;
    inst->opcode = 579;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25128 = inst->sreg3;
    inst->sreg2 = D.25128;
    D.25129 = inst->sreg2;
    inst->sreg1 = D.25129;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->dreg = tmp2;
    inst->sreg1 = tmp2;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25130>; else goto <D.25131>;
    <D.25130>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25132>;
    <D.25131>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25132>:
  }
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25133 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25133;
    inst->prev = 0B;
    D.25134 = inst->prev;
    inst->next = D.25134;
    inst->opcode = 573;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25135 = inst->sreg3;
    inst->sreg2 = D.25135;
    D.25136 = inst->sreg2;
    inst->sreg1 = D.25136;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->dreg = tmp3;
    inst->sreg1 = tmp2;
    inst->sreg2 = tmp1;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25137>; else goto <D.25138>;
    <D.25137>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25139>;
    <D.25138>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25139>:
  }
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25140 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25140;
    inst->prev = 0B;
    D.25141 = inst->prev;
    inst->next = D.25141;
    inst->opcode = 440;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25142 = inst->sreg3;
    inst->sreg2 = D.25142;
    D.25143 = inst->sreg2;
    inst->sreg1 = D.25143;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->dreg = tmp4;
    inst->sreg1 = tmp3;
    inst->data.op[1].const_val = 31;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25144>; else goto <D.25145>;
    <D.25144>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25146>;
    <D.25145>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25146>:
  }
  switch (872) <default: <D.22202>, case 872: <D.22179>, case 874: <D.22184>, case 875: <D.22190>, case 876: <D.22196>, case 877: <D.22182>, case 879: <D.22187>, case 880: <D.22193>, case 881: <D.22199>>
  <D.22179>:
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25147 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25147;
    inst->prev = 0B;
    D.25148 = inst->prev;
    inst->next = D.25148;
    inst->opcode = 872;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25149 = inst->sreg3;
    inst->sreg2 = D.25149;
    D.25150 = inst->sreg2;
    inst->sreg1 = D.25150;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = tmp4;
    inst->sreg2 = 0;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25151>; else goto <D.25152>;
    <D.25151>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25153>;
    <D.25152>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25153>:
  }
  goto <D.22181>;
  <D.22182>:
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25154 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25154;
    inst->prev = 0B;
    D.25155 = inst->prev;
    inst->next = D.25155;
    inst->opcode = 877;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25156 = inst->sreg3;
    inst->sreg2 = D.25156;
    D.25157 = inst->sreg2;
    inst->sreg1 = D.25157;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = tmp4;
    inst->sreg2 = 0;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25158>; else goto <D.25159>;
    <D.25158>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25160>;
    <D.25159>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25160>:
  }
  goto <D.22181>;
  <D.22184>:
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25161 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25161;
    inst->prev = 0B;
    D.25162 = inst->prev;
    inst->next = D.25162;
    inst->opcode = 869;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25163 = inst->sreg3;
    inst->sreg2 = D.25163;
    D.25164 = inst->sreg2;
    inst->sreg1 = D.25164;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->dreg = 1;
    inst->sreg1 = 0;
    inst->sreg2 = tmp4;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25165>; else goto <D.25166>;
    <D.25165>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25167>;
    <D.25166>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25167>:
  }
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25168 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25168;
    inst->prev = 0B;
    D.25169 = inst->prev;
    inst->next = D.25169;
    inst->opcode = 877;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25170 = inst->sreg3;
    inst->sreg2 = D.25170;
    D.25171 = inst->sreg2;
    inst->sreg1 = D.25171;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = 1;
    inst->sreg2 = 0;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25172>; else goto <D.25173>;
    <D.25172>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25174>;
    <D.25173>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25174>:
  }
  goto <D.22181>;
  <D.22187>:
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25175 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25175;
    inst->prev = 0B;
    D.25176 = inst->prev;
    inst->next = D.25176;
    inst->opcode = 871;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25177 = inst->sreg3;
    inst->sreg2 = D.25177;
    D.25178 = inst->sreg2;
    inst->sreg1 = D.25178;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->dreg = 1;
    inst->sreg1 = 0;
    inst->sreg2 = tmp4;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25179>; else goto <D.25180>;
    <D.25179>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25181>;
    <D.25180>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25181>:
  }
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25182 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25182;
    inst->prev = 0B;
    D.25183 = inst->prev;
    inst->next = D.25183;
    inst->opcode = 877;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25184 = inst->sreg3;
    inst->sreg2 = D.25184;
    D.25185 = inst->sreg2;
    inst->sreg1 = D.25185;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = 1;
    inst->sreg2 = 0;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25186>; else goto <D.25187>;
    <D.25186>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25188>;
    <D.25187>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25188>:
  }
  goto <D.22181>;
  <D.22190>:
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25189 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25189;
    inst->prev = 0B;
    D.25190 = inst->prev;
    inst->next = D.25190;
    inst->opcode = 869;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25191 = inst->sreg3;
    inst->sreg2 = D.25191;
    D.25192 = inst->sreg2;
    inst->sreg1 = D.25192;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->dreg = 1;
    inst->sreg1 = 0;
    inst->sreg2 = tmp4;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25193>; else goto <D.25194>;
    <D.25193>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25195>;
    <D.25194>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25195>:
  }
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25196 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25196;
    inst->prev = 0B;
    D.25197 = inst->prev;
    inst->next = D.25197;
    inst->opcode = 872;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25198 = inst->sreg3;
    inst->sreg2 = D.25198;
    D.25199 = inst->sreg2;
    inst->sreg1 = D.25199;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = 1;
    inst->sreg2 = 0;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25200>; else goto <D.25201>;
    <D.25200>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25202>;
    <D.25201>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25202>:
  }
  goto <D.22181>;
  <D.22193>:
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25203 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25203;
    inst->prev = 0B;
    D.25204 = inst->prev;
    inst->next = D.25204;
    inst->opcode = 871;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25205 = inst->sreg3;
    inst->sreg2 = D.25205;
    D.25206 = inst->sreg2;
    inst->sreg1 = D.25206;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->dreg = 1;
    inst->sreg1 = 0;
    inst->sreg2 = tmp4;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25207>; else goto <D.25208>;
    <D.25207>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25209>;
    <D.25208>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25209>:
  }
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25210 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25210;
    inst->prev = 0B;
    D.25211 = inst->prev;
    inst->next = D.25211;
    inst->opcode = 872;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25212 = inst->sreg3;
    inst->sreg2 = D.25212;
    D.25213 = inst->sreg2;
    inst->sreg1 = D.25213;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = 1;
    inst->sreg2 = 0;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25214>; else goto <D.25215>;
    <D.25214>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25216>;
    <D.25215>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25216>:
  }
  goto <D.22181>;
  <D.22196>:
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25217 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25217;
    inst->prev = 0B;
    D.25218 = inst->prev;
    inst->next = D.25218;
    inst->opcode = 869;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25219 = inst->sreg3;
    inst->sreg2 = D.25219;
    D.25220 = inst->sreg2;
    inst->sreg1 = D.25220;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->dreg = 1;
    inst->sreg1 = tmp4;
    inst->sreg2 = 0;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25221>; else goto <D.25222>;
    <D.25221>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25223>;
    <D.25222>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25223>:
  }
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25224 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25224;
    inst->prev = 0B;
    D.25225 = inst->prev;
    inst->next = D.25225;
    inst->opcode = 877;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25226 = inst->sreg3;
    inst->sreg2 = D.25226;
    D.25227 = inst->sreg2;
    inst->sreg1 = D.25227;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = 1;
    inst->sreg2 = 0;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25228>; else goto <D.25229>;
    <D.25228>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25230>;
    <D.25229>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25230>:
  }
  goto <D.22181>;
  <D.22199>:
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25231 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25231;
    inst->prev = 0B;
    D.25232 = inst->prev;
    inst->next = D.25232;
    inst->opcode = 871;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25233 = inst->sreg3;
    inst->sreg2 = D.25233;
    D.25234 = inst->sreg2;
    inst->sreg1 = D.25234;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->dreg = 1;
    inst->sreg1 = tmp4;
    inst->sreg2 = 0;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25235>; else goto <D.25236>;
    <D.25235>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25237>;
    <D.25236>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25237>:
  }
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25238 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25238;
    inst->prev = 0B;
    D.25239 = inst->prev;
    inst->next = D.25239;
    inst->opcode = 877;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25240 = inst->sreg3;
    inst->sreg2 = D.25240;
    D.25241 = inst->sreg2;
    inst->sreg1 = D.25241;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = 1;
    inst->sreg2 = 0;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25242>; else goto <D.25243>;
    <D.25242>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25244>;
    <D.25243>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25244>:
  }
  goto <D.22181>;
  <D.22202>:
  monoeg_g_log (0B, 16, "unknown comparison %s\n", "EQ");
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-mips.c", 2285);
  <D.22181>:
  ins->opcode = 316;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.24960 = ins->sreg3;
  ins->sreg2 = D.24960;
  D.24929 = ins->sreg2;
  ins->sreg1 = D.24929;
  goto <D.22140>;
  <D.22203>:
  D.25245 = mono_alloc_ireg (cfg);
  tmp1 = (int) D.25245;
  D.25246 = mono_alloc_ireg (cfg);
  tmp2 = (int) D.25246;
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25247 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25247;
    inst->prev = 0B;
    D.25248 = inst->prev;
    inst->next = D.25248;
    inst->opcode = 565;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25249 = inst->sreg3;
    inst->sreg2 = D.25249;
    D.25250 = inst->sreg2;
    inst->sreg1 = D.25250;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    D.24925 = ins->dreg;
    D.24926 = D.24925 + 1;
    inst->dreg = D.24926;
    D.24927 = ins->sreg1;
    D.24928 = D.24927 + 1;
    inst->sreg1 = D.24928;
    D.24929 = ins->sreg2;
    D.24930 = D.24929 + 1;
    inst->sreg2 = D.24930;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25251>; else goto <D.25252>;
    <D.25251>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25253>;
    <D.25252>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25253>:
  }
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25254 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25254;
    inst->prev = 0B;
    D.25255 = inst->prev;
    inst->next = D.25255;
    inst->opcode = 871;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25256 = inst->sreg3;
    inst->sreg2 = D.25256;
    D.25257 = inst->sreg2;
    inst->sreg1 = D.25257;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->dreg = tmp1;
    D.24925 = ins->dreg;
    D.24926 = D.24925 + 1;
    inst->sreg1 = D.24926;
    D.24927 = ins->sreg1;
    D.24928 = D.24927 + 1;
    inst->sreg2 = D.24928;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25258>; else goto <D.25259>;
    <D.25258>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25260>;
    <D.25259>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25260>:
  }
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25261 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25261;
    inst->prev = 0B;
    D.25262 = inst->prev;
    inst->next = D.25262;
    inst->opcode = 565;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25263 = inst->sreg3;
    inst->sreg2 = D.25263;
    D.25264 = inst->sreg2;
    inst->sreg1 = D.25264;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    D.24925 = ins->dreg;
    D.24947 = D.24925 + 2;
    inst->dreg = D.24947;
    D.24927 = ins->sreg1;
    D.24948 = D.24927 + 2;
    inst->sreg1 = D.24948;
    D.24929 = ins->sreg2;
    D.24949 = D.24929 + 2;
    inst->sreg2 = D.24949;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25265>; else goto <D.25266>;
    <D.25265>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25267>;
    <D.25266>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25267>:
  }
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25268 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25268;
    inst->prev = 0B;
    D.25269 = inst->prev;
    inst->next = D.25269;
    inst->opcode = 565;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25270 = inst->sreg3;
    inst->sreg2 = D.25270;
    D.25271 = inst->sreg2;
    inst->sreg1 = D.25271;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    D.24925 = ins->dreg;
    D.24947 = D.24925 + 2;
    inst->dreg = D.24947;
    inst->sreg1 = tmp1;
    D.24925 = ins->dreg;
    D.24947 = D.24925 + 2;
    inst->sreg2 = D.24947;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25272>; else goto <D.25273>;
    <D.25272>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25274>;
    <D.25273>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25274>:
  }
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25275 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25275;
    inst->prev = 0B;
    D.25276 = inst->prev;
    inst->next = D.25276;
    inst->opcode = 871;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25277 = inst->sreg3;
    inst->sreg2 = D.25277;
    D.25278 = inst->sreg2;
    inst->sreg1 = D.25278;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->dreg = tmp2;
    D.24925 = ins->dreg;
    D.24947 = D.24925 + 2;
    inst->sreg1 = D.24947;
    D.24927 = ins->sreg1;
    D.24948 = D.24927 + 2;
    inst->sreg2 = D.24948;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25279>; else goto <D.25280>;
    <D.25279>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25281>;
    <D.25280>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25281>:
  }
  switch (877) <default: <D.22232>, case 872: <D.22209>, case 874: <D.22214>, case 875: <D.22220>, case 876: <D.22226>, case 877: <D.22212>, case 879: <D.22217>, case 880: <D.22223>, case 881: <D.22229>>
  <D.22209>:
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25282 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25282;
    inst->prev = 0B;
    D.25283 = inst->prev;
    inst->next = D.25283;
    inst->opcode = 872;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25284 = inst->sreg3;
    inst->sreg2 = D.25284;
    D.25285 = inst->sreg2;
    inst->sreg1 = D.25285;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = tmp2;
    inst->sreg2 = 0;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25286>; else goto <D.25287>;
    <D.25286>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25288>;
    <D.25287>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25288>:
  }
  goto <D.22211>;
  <D.22212>:
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25289 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25289;
    inst->prev = 0B;
    D.25290 = inst->prev;
    inst->next = D.25290;
    inst->opcode = 877;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25291 = inst->sreg3;
    inst->sreg2 = D.25291;
    D.25292 = inst->sreg2;
    inst->sreg1 = D.25292;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = tmp2;
    inst->sreg2 = 0;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25293>; else goto <D.25294>;
    <D.25293>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25295>;
    <D.25294>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25295>:
  }
  goto <D.22211>;
  <D.22214>:
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25296 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25296;
    inst->prev = 0B;
    D.25297 = inst->prev;
    inst->next = D.25297;
    inst->opcode = 869;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25298 = inst->sreg3;
    inst->sreg2 = D.25298;
    D.25299 = inst->sreg2;
    inst->sreg1 = D.25299;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->dreg = 1;
    inst->sreg1 = 0;
    inst->sreg2 = tmp2;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25300>; else goto <D.25301>;
    <D.25300>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25302>;
    <D.25301>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25302>:
  }
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25303 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25303;
    inst->prev = 0B;
    D.25304 = inst->prev;
    inst->next = D.25304;
    inst->opcode = 877;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25305 = inst->sreg3;
    inst->sreg2 = D.25305;
    D.25306 = inst->sreg2;
    inst->sreg1 = D.25306;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = 1;
    inst->sreg2 = 0;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25307>; else goto <D.25308>;
    <D.25307>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25309>;
    <D.25308>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25309>:
  }
  goto <D.22211>;
  <D.22217>:
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25310 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25310;
    inst->prev = 0B;
    D.25311 = inst->prev;
    inst->next = D.25311;
    inst->opcode = 871;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25312 = inst->sreg3;
    inst->sreg2 = D.25312;
    D.25313 = inst->sreg2;
    inst->sreg1 = D.25313;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->dreg = 1;
    inst->sreg1 = 0;
    inst->sreg2 = tmp2;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25314>; else goto <D.25315>;
    <D.25314>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25316>;
    <D.25315>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25316>:
  }
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25317 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25317;
    inst->prev = 0B;
    D.25318 = inst->prev;
    inst->next = D.25318;
    inst->opcode = 877;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25319 = inst->sreg3;
    inst->sreg2 = D.25319;
    D.25320 = inst->sreg2;
    inst->sreg1 = D.25320;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = 1;
    inst->sreg2 = 0;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25321>; else goto <D.25322>;
    <D.25321>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25323>;
    <D.25322>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25323>:
  }
  goto <D.22211>;
  <D.22220>:
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25324 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25324;
    inst->prev = 0B;
    D.25325 = inst->prev;
    inst->next = D.25325;
    inst->opcode = 869;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25326 = inst->sreg3;
    inst->sreg2 = D.25326;
    D.25327 = inst->sreg2;
    inst->sreg1 = D.25327;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->dreg = 1;
    inst->sreg1 = 0;
    inst->sreg2 = tmp2;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25328>; else goto <D.25329>;
    <D.25328>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25330>;
    <D.25329>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25330>:
  }
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25331 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25331;
    inst->prev = 0B;
    D.25332 = inst->prev;
    inst->next = D.25332;
    inst->opcode = 872;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25333 = inst->sreg3;
    inst->sreg2 = D.25333;
    D.25334 = inst->sreg2;
    inst->sreg1 = D.25334;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = 1;
    inst->sreg2 = 0;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25335>; else goto <D.25336>;
    <D.25335>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25337>;
    <D.25336>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25337>:
  }
  goto <D.22211>;
  <D.22223>:
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25338 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25338;
    inst->prev = 0B;
    D.25339 = inst->prev;
    inst->next = D.25339;
    inst->opcode = 871;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25340 = inst->sreg3;
    inst->sreg2 = D.25340;
    D.25341 = inst->sreg2;
    inst->sreg1 = D.25341;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->dreg = 1;
    inst->sreg1 = 0;
    inst->sreg2 = tmp2;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25342>; else goto <D.25343>;
    <D.25342>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25344>;
    <D.25343>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25344>:
  }
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25345 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25345;
    inst->prev = 0B;
    D.25346 = inst->prev;
    inst->next = D.25346;
    inst->opcode = 872;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25347 = inst->sreg3;
    inst->sreg2 = D.25347;
    D.25348 = inst->sreg2;
    inst->sreg1 = D.25348;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = 1;
    inst->sreg2 = 0;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25349>; else goto <D.25350>;
    <D.25349>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25351>;
    <D.25350>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25351>:
  }
  goto <D.22211>;
  <D.22226>:
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25352 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25352;
    inst->prev = 0B;
    D.25353 = inst->prev;
    inst->next = D.25353;
    inst->opcode = 869;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25354 = inst->sreg3;
    inst->sreg2 = D.25354;
    D.25355 = inst->sreg2;
    inst->sreg1 = D.25355;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->dreg = 1;
    inst->sreg1 = tmp2;
    inst->sreg2 = 0;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25356>; else goto <D.25357>;
    <D.25356>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25358>;
    <D.25357>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25358>:
  }
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25359 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25359;
    inst->prev = 0B;
    D.25360 = inst->prev;
    inst->next = D.25360;
    inst->opcode = 877;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25361 = inst->sreg3;
    inst->sreg2 = D.25361;
    D.25362 = inst->sreg2;
    inst->sreg1 = D.25362;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = 1;
    inst->sreg2 = 0;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25363>; else goto <D.25364>;
    <D.25363>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25365>;
    <D.25364>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25365>:
  }
  goto <D.22211>;
  <D.22229>:
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25366 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25366;
    inst->prev = 0B;
    D.25367 = inst->prev;
    inst->next = D.25367;
    inst->opcode = 871;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25368 = inst->sreg3;
    inst->sreg2 = D.25368;
    D.25369 = inst->sreg2;
    inst->sreg1 = D.25369;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->dreg = 1;
    inst->sreg1 = tmp2;
    inst->sreg2 = 0;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25370>; else goto <D.25371>;
    <D.25370>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25372>;
    <D.25371>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25372>:
  }
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25373 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25373;
    inst->prev = 0B;
    D.25374 = inst->prev;
    inst->next = D.25374;
    inst->opcode = 877;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25375 = inst->sreg3;
    inst->sreg2 = D.25375;
    D.25376 = inst->sreg2;
    inst->sreg1 = D.25376;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = 1;
    inst->sreg2 = 0;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25377>; else goto <D.25378>;
    <D.25377>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25379>;
    <D.25378>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25379>:
  }
  goto <D.22211>;
  <D.22232>:
  monoeg_g_log (0B, 16, "unknown comparison %s\n", "NE_UN");
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-mips.c", 2298);
  <D.22211>:
  ins->opcode = 316;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.24960 = ins->sreg3;
  ins->sreg2 = D.24960;
  D.24929 = ins->sreg2;
  ins->sreg1 = D.24929;
  goto <D.22140>;
  <D.22233>:
  <D.22234>:
  mono_print_ins (ins);
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-mips.c", 2305);
  <D.22235>:
  D.25380 = mono_alloc_ireg (cfg);
  tmp1 = (int) D.25380;
  D.25381 = mono_alloc_ireg (cfg);
  tmp2 = (int) D.25381;
  D.25382 = mono_alloc_ireg (cfg);
  tmp3 = (int) D.25382;
  D.25383 = mono_alloc_ireg (cfg);
  tmp4 = (int) D.25383;
  D.25384 = mono_alloc_ireg (cfg);
  tmp5 = (int) D.25384;
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25385 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25385;
    inst->prev = 0B;
    D.25386 = inst->prev;
    inst->next = D.25386;
    inst->opcode = 566;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25387 = inst->sreg3;
    inst->sreg2 = D.25387;
    D.25388 = inst->sreg2;
    inst->sreg1 = D.25388;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    D.24925 = ins->dreg;
    D.24926 = D.24925 + 1;
    inst->dreg = D.24926;
    D.24927 = ins->sreg1;
    D.24928 = D.24927 + 1;
    inst->sreg1 = D.24928;
    D.24929 = ins->sreg2;
    D.24930 = D.24929 + 1;
    inst->sreg2 = D.24930;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25389>; else goto <D.25390>;
    <D.25389>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25391>;
    <D.25390>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25391>:
  }
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25392 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25392;
    inst->prev = 0B;
    D.25393 = inst->prev;
    inst->next = D.25393;
    inst->opcode = 871;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25394 = inst->sreg3;
    inst->sreg2 = D.25394;
    D.25395 = inst->sreg2;
    inst->sreg1 = D.25395;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->dreg = tmp5;
    D.24927 = ins->sreg1;
    D.24928 = D.24927 + 1;
    inst->sreg1 = D.24928;
    D.24925 = ins->dreg;
    D.24926 = D.24925 + 1;
    inst->sreg2 = D.24926;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25396>; else goto <D.25397>;
    <D.25396>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25398>;
    <D.25397>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25398>:
  }
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25399 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25399;
    inst->prev = 0B;
    D.25400 = inst->prev;
    inst->next = D.25400;
    inst->opcode = 566;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25401 = inst->sreg3;
    inst->sreg2 = D.25401;
    D.25402 = inst->sreg2;
    inst->sreg1 = D.25402;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    D.24925 = ins->dreg;
    D.24947 = D.24925 + 2;
    inst->dreg = D.24947;
    D.24927 = ins->sreg1;
    D.24948 = D.24927 + 2;
    inst->sreg1 = D.24948;
    D.24929 = ins->sreg2;
    D.24949 = D.24929 + 2;
    inst->sreg2 = D.24949;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25403>; else goto <D.25404>;
    <D.25403>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25405>;
    <D.25404>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25405>:
  }
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25406 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25406;
    inst->prev = 0B;
    D.25407 = inst->prev;
    inst->next = D.25407;
    inst->opcode = 566;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25408 = inst->sreg3;
    inst->sreg2 = D.25408;
    D.25409 = inst->sreg2;
    inst->sreg1 = D.25409;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    D.24925 = ins->dreg;
    D.24947 = D.24925 + 2;
    inst->dreg = D.24947;
    D.24925 = ins->dreg;
    D.24947 = D.24925 + 2;
    inst->sreg1 = D.24947;
    inst->sreg2 = tmp5;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25410>; else goto <D.25411>;
    <D.25410>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25412>;
    <D.25411>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25412>:
  }
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25413 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25413;
    inst->prev = 0B;
    D.25414 = inst->prev;
    inst->next = D.25414;
    inst->opcode = 574;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25415 = inst->sreg3;
    inst->sreg2 = D.25415;
    D.25416 = inst->sreg2;
    inst->sreg1 = D.25416;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->dreg = tmp1;
    D.24927 = ins->sreg1;
    D.24948 = D.24927 + 2;
    inst->sreg1 = D.24948;
    D.24929 = ins->sreg2;
    D.24949 = D.24929 + 2;
    inst->sreg2 = D.24949;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25417>; else goto <D.25418>;
    <D.25417>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25419>;
    <D.25418>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25419>:
  }
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25420 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25420;
    inst->prev = 0B;
    D.25421 = inst->prev;
    inst->next = D.25421;
    inst->opcode = 574;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25422 = inst->sreg3;
    inst->sreg2 = D.25422;
    D.25423 = inst->sreg2;
    inst->sreg1 = D.25423;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->dreg = tmp2;
    D.24927 = ins->sreg1;
    D.24948 = D.24927 + 2;
    inst->sreg1 = D.24948;
    D.24925 = ins->dreg;
    D.24947 = D.24925 + 2;
    inst->sreg2 = D.24947;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25424>; else goto <D.25425>;
    <D.25424>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25426>;
    <D.25425>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25426>:
  }
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25427 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25427;
    inst->prev = 0B;
    D.25428 = inst->prev;
    inst->next = D.25428;
    inst->opcode = 572;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25429 = inst->sreg3;
    inst->sreg2 = D.25429;
    D.25430 = inst->sreg2;
    inst->sreg1 = D.25430;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->dreg = tmp3;
    inst->sreg1 = tmp2;
    inst->sreg2 = tmp1;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25431>; else goto <D.25432>;
    <D.25431>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25433>;
    <D.25432>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25433>:
  }
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25434 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25434;
    inst->prev = 0B;
    D.25435 = inst->prev;
    inst->next = D.25435;
    inst->opcode = 440;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25436 = inst->sreg3;
    inst->sreg2 = D.25436;
    D.25437 = inst->sreg2;
    inst->sreg1 = D.25437;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->dreg = tmp4;
    inst->sreg1 = tmp3;
    inst->data.op[1].const_val = 31;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25438>; else goto <D.25439>;
    <D.25438>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25440>;
    <D.25439>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25440>:
  }
  switch (877) <default: <D.22267>, case 872: <D.22244>, case 874: <D.22249>, case 875: <D.22255>, case 876: <D.22261>, case 877: <D.22247>, case 879: <D.22252>, case 880: <D.22258>, case 881: <D.22264>>
  <D.22244>:
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25441 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25441;
    inst->prev = 0B;
    D.25442 = inst->prev;
    inst->next = D.25442;
    inst->opcode = 872;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25443 = inst->sreg3;
    inst->sreg2 = D.25443;
    D.25444 = inst->sreg2;
    inst->sreg1 = D.25444;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = tmp4;
    inst->sreg2 = 0;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25445>; else goto <D.25446>;
    <D.25445>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25447>;
    <D.25446>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25447>:
  }
  goto <D.22246>;
  <D.22247>:
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25448 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25448;
    inst->prev = 0B;
    D.25449 = inst->prev;
    inst->next = D.25449;
    inst->opcode = 877;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25450 = inst->sreg3;
    inst->sreg2 = D.25450;
    D.25451 = inst->sreg2;
    inst->sreg1 = D.25451;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = tmp4;
    inst->sreg2 = 0;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25452>; else goto <D.25453>;
    <D.25452>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25454>;
    <D.25453>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25454>:
  }
  goto <D.22246>;
  <D.22249>:
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25455 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25455;
    inst->prev = 0B;
    D.25456 = inst->prev;
    inst->next = D.25456;
    inst->opcode = 869;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25457 = inst->sreg3;
    inst->sreg2 = D.25457;
    D.25458 = inst->sreg2;
    inst->sreg1 = D.25458;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->dreg = 1;
    inst->sreg1 = 0;
    inst->sreg2 = tmp4;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25459>; else goto <D.25460>;
    <D.25459>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25461>;
    <D.25460>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25461>:
  }
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25462 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25462;
    inst->prev = 0B;
    D.25463 = inst->prev;
    inst->next = D.25463;
    inst->opcode = 877;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25464 = inst->sreg3;
    inst->sreg2 = D.25464;
    D.25465 = inst->sreg2;
    inst->sreg1 = D.25465;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = 1;
    inst->sreg2 = 0;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25466>; else goto <D.25467>;
    <D.25466>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25468>;
    <D.25467>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25468>:
  }
  goto <D.22246>;
  <D.22252>:
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25469 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25469;
    inst->prev = 0B;
    D.25470 = inst->prev;
    inst->next = D.25470;
    inst->opcode = 871;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25471 = inst->sreg3;
    inst->sreg2 = D.25471;
    D.25472 = inst->sreg2;
    inst->sreg1 = D.25472;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->dreg = 1;
    inst->sreg1 = 0;
    inst->sreg2 = tmp4;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25473>; else goto <D.25474>;
    <D.25473>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25475>;
    <D.25474>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25475>:
  }
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25476 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25476;
    inst->prev = 0B;
    D.25477 = inst->prev;
    inst->next = D.25477;
    inst->opcode = 877;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25478 = inst->sreg3;
    inst->sreg2 = D.25478;
    D.25479 = inst->sreg2;
    inst->sreg1 = D.25479;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = 1;
    inst->sreg2 = 0;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25480>; else goto <D.25481>;
    <D.25480>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25482>;
    <D.25481>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25482>:
  }
  goto <D.22246>;
  <D.22255>:
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25483 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25483;
    inst->prev = 0B;
    D.25484 = inst->prev;
    inst->next = D.25484;
    inst->opcode = 869;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25485 = inst->sreg3;
    inst->sreg2 = D.25485;
    D.25486 = inst->sreg2;
    inst->sreg1 = D.25486;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->dreg = 1;
    inst->sreg1 = 0;
    inst->sreg2 = tmp4;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25487>; else goto <D.25488>;
    <D.25487>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25489>;
    <D.25488>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25489>:
  }
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25490 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25490;
    inst->prev = 0B;
    D.25491 = inst->prev;
    inst->next = D.25491;
    inst->opcode = 872;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25492 = inst->sreg3;
    inst->sreg2 = D.25492;
    D.25493 = inst->sreg2;
    inst->sreg1 = D.25493;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = 1;
    inst->sreg2 = 0;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25494>; else goto <D.25495>;
    <D.25494>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25496>;
    <D.25495>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25496>:
  }
  goto <D.22246>;
  <D.22258>:
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25497 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25497;
    inst->prev = 0B;
    D.25498 = inst->prev;
    inst->next = D.25498;
    inst->opcode = 871;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25499 = inst->sreg3;
    inst->sreg2 = D.25499;
    D.25500 = inst->sreg2;
    inst->sreg1 = D.25500;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->dreg = 1;
    inst->sreg1 = 0;
    inst->sreg2 = tmp4;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25501>; else goto <D.25502>;
    <D.25501>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25503>;
    <D.25502>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25503>:
  }
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25504 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25504;
    inst->prev = 0B;
    D.25505 = inst->prev;
    inst->next = D.25505;
    inst->opcode = 872;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25506 = inst->sreg3;
    inst->sreg2 = D.25506;
    D.25507 = inst->sreg2;
    inst->sreg1 = D.25507;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = 1;
    inst->sreg2 = 0;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25508>; else goto <D.25509>;
    <D.25508>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25510>;
    <D.25509>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25510>:
  }
  goto <D.22246>;
  <D.22261>:
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25511 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25511;
    inst->prev = 0B;
    D.25512 = inst->prev;
    inst->next = D.25512;
    inst->opcode = 869;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25513 = inst->sreg3;
    inst->sreg2 = D.25513;
    D.25514 = inst->sreg2;
    inst->sreg1 = D.25514;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->dreg = 1;
    inst->sreg1 = tmp4;
    inst->sreg2 = 0;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25515>; else goto <D.25516>;
    <D.25515>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25517>;
    <D.25516>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25517>:
  }
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25518 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25518;
    inst->prev = 0B;
    D.25519 = inst->prev;
    inst->next = D.25519;
    inst->opcode = 877;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25520 = inst->sreg3;
    inst->sreg2 = D.25520;
    D.25521 = inst->sreg2;
    inst->sreg1 = D.25521;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = 1;
    inst->sreg2 = 0;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25522>; else goto <D.25523>;
    <D.25522>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25524>;
    <D.25523>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25524>:
  }
  goto <D.22246>;
  <D.22264>:
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25525 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25525;
    inst->prev = 0B;
    D.25526 = inst->prev;
    inst->next = D.25526;
    inst->opcode = 871;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25527 = inst->sreg3;
    inst->sreg2 = D.25527;
    D.25528 = inst->sreg2;
    inst->sreg1 = D.25528;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->dreg = 1;
    inst->sreg1 = tmp4;
    inst->sreg2 = 0;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25529>; else goto <D.25530>;
    <D.25529>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25531>;
    <D.25530>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25531>:
  }
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25532 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25532;
    inst->prev = 0B;
    D.25533 = inst->prev;
    inst->next = D.25533;
    inst->opcode = 877;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25534 = inst->sreg3;
    inst->sreg2 = D.25534;
    D.25535 = inst->sreg2;
    inst->sreg1 = D.25535;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = 1;
    inst->sreg2 = 0;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25536>; else goto <D.25537>;
    <D.25536>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25538>;
    <D.25537>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25538>:
  }
  goto <D.22246>;
  <D.22267>:
  monoeg_g_log (0B, 16, "unknown comparison %s\n", "NE_UN");
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-mips.c", 2336);
  <D.22246>:
  ins->opcode = 316;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.24960 = ins->sreg3;
  ins->sreg2 = D.24960;
  D.24929 = ins->sreg2;
  ins->sreg1 = D.24929;
  goto <D.22140>;
  <D.22268>:
  D.25539 = mono_alloc_ireg (cfg);
  tmp1 = (int) D.25539;
  D.25540 = mono_alloc_ireg (cfg);
  tmp2 = (int) D.25540;
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25541 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25541;
    inst->prev = 0B;
    D.25542 = inst->prev;
    inst->next = D.25542;
    inst->opcode = 566;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25543 = inst->sreg3;
    inst->sreg2 = D.25543;
    D.25544 = inst->sreg2;
    inst->sreg1 = D.25544;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    D.24925 = ins->dreg;
    D.24926 = D.24925 + 1;
    inst->dreg = D.24926;
    D.24927 = ins->sreg1;
    D.24928 = D.24927 + 1;
    inst->sreg1 = D.24928;
    D.24929 = ins->sreg2;
    D.24930 = D.24929 + 1;
    inst->sreg2 = D.24930;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25545>; else goto <D.25546>;
    <D.25545>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25547>;
    <D.25546>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25547>:
  }
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25548 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25548;
    inst->prev = 0B;
    D.25549 = inst->prev;
    inst->next = D.25549;
    inst->opcode = 871;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25550 = inst->sreg3;
    inst->sreg2 = D.25550;
    D.25551 = inst->sreg2;
    inst->sreg1 = D.25551;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->dreg = tmp1;
    D.24927 = ins->sreg1;
    D.24928 = D.24927 + 1;
    inst->sreg1 = D.24928;
    D.24925 = ins->dreg;
    D.24926 = D.24925 + 1;
    inst->sreg2 = D.24926;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25552>; else goto <D.25553>;
    <D.25552>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25554>;
    <D.25553>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25554>:
  }
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25555 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25555;
    inst->prev = 0B;
    D.25556 = inst->prev;
    inst->next = D.25556;
    inst->opcode = 566;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25557 = inst->sreg3;
    inst->sreg2 = D.25557;
    D.25558 = inst->sreg2;
    inst->sreg1 = D.25558;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    D.24925 = ins->dreg;
    D.24947 = D.24925 + 2;
    inst->dreg = D.24947;
    D.24927 = ins->sreg1;
    D.24948 = D.24927 + 2;
    inst->sreg1 = D.24948;
    D.24929 = ins->sreg2;
    D.24949 = D.24929 + 2;
    inst->sreg2 = D.24949;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25559>; else goto <D.25560>;
    <D.25559>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25561>;
    <D.25560>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25561>:
  }
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25562 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25562;
    inst->prev = 0B;
    D.25563 = inst->prev;
    inst->next = D.25563;
    inst->opcode = 566;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25564 = inst->sreg3;
    inst->sreg2 = D.25564;
    D.25565 = inst->sreg2;
    inst->sreg1 = D.25565;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    D.24925 = ins->dreg;
    D.24947 = D.24925 + 2;
    inst->dreg = D.24947;
    D.24925 = ins->dreg;
    D.24947 = D.24925 + 2;
    inst->sreg1 = D.24947;
    inst->sreg2 = tmp1;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25566>; else goto <D.25567>;
    <D.25566>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25568>;
    <D.25567>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25568>:
  }
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25569 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25569;
    inst->prev = 0B;
    D.25570 = inst->prev;
    inst->next = D.25570;
    inst->opcode = 871;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25571 = inst->sreg3;
    inst->sreg2 = D.25571;
    D.25572 = inst->sreg2;
    inst->sreg1 = D.25572;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->dreg = tmp2;
    D.24927 = ins->sreg1;
    D.24948 = D.24927 + 2;
    inst->sreg1 = D.24948;
    D.24925 = ins->dreg;
    D.24947 = D.24925 + 2;
    inst->sreg2 = D.24947;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25573>; else goto <D.25574>;
    <D.25573>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25575>;
    <D.25574>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25575>:
  }
  switch (877) <default: <D.22297>, case 872: <D.22274>, case 874: <D.22279>, case 875: <D.22285>, case 876: <D.22291>, case 877: <D.22277>, case 879: <D.22282>, case 880: <D.22288>, case 881: <D.22294>>
  <D.22274>:
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25576 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25576;
    inst->prev = 0B;
    D.25577 = inst->prev;
    inst->next = D.25577;
    inst->opcode = 872;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25578 = inst->sreg3;
    inst->sreg2 = D.25578;
    D.25579 = inst->sreg2;
    inst->sreg1 = D.25579;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = tmp2;
    inst->sreg2 = 0;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25580>; else goto <D.25581>;
    <D.25580>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25582>;
    <D.25581>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25582>:
  }
  goto <D.22276>;
  <D.22277>:
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25583 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25583;
    inst->prev = 0B;
    D.25584 = inst->prev;
    inst->next = D.25584;
    inst->opcode = 877;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25585 = inst->sreg3;
    inst->sreg2 = D.25585;
    D.25586 = inst->sreg2;
    inst->sreg1 = D.25586;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = tmp2;
    inst->sreg2 = 0;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25587>; else goto <D.25588>;
    <D.25587>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25589>;
    <D.25588>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25589>:
  }
  goto <D.22276>;
  <D.22279>:
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25590 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25590;
    inst->prev = 0B;
    D.25591 = inst->prev;
    inst->next = D.25591;
    inst->opcode = 869;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25592 = inst->sreg3;
    inst->sreg2 = D.25592;
    D.25593 = inst->sreg2;
    inst->sreg1 = D.25593;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->dreg = 1;
    inst->sreg1 = 0;
    inst->sreg2 = tmp2;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25594>; else goto <D.25595>;
    <D.25594>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25596>;
    <D.25595>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25596>:
  }
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25597 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25597;
    inst->prev = 0B;
    D.25598 = inst->prev;
    inst->next = D.25598;
    inst->opcode = 877;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25599 = inst->sreg3;
    inst->sreg2 = D.25599;
    D.25600 = inst->sreg2;
    inst->sreg1 = D.25600;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = 1;
    inst->sreg2 = 0;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25601>; else goto <D.25602>;
    <D.25601>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25603>;
    <D.25602>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25603>:
  }
  goto <D.22276>;
  <D.22282>:
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25604 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25604;
    inst->prev = 0B;
    D.25605 = inst->prev;
    inst->next = D.25605;
    inst->opcode = 871;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25606 = inst->sreg3;
    inst->sreg2 = D.25606;
    D.25607 = inst->sreg2;
    inst->sreg1 = D.25607;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->dreg = 1;
    inst->sreg1 = 0;
    inst->sreg2 = tmp2;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25608>; else goto <D.25609>;
    <D.25608>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25610>;
    <D.25609>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25610>:
  }
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25611 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25611;
    inst->prev = 0B;
    D.25612 = inst->prev;
    inst->next = D.25612;
    inst->opcode = 877;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25613 = inst->sreg3;
    inst->sreg2 = D.25613;
    D.25614 = inst->sreg2;
    inst->sreg1 = D.25614;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = 1;
    inst->sreg2 = 0;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25615>; else goto <D.25616>;
    <D.25615>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25617>;
    <D.25616>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25617>:
  }
  goto <D.22276>;
  <D.22285>:
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25618 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25618;
    inst->prev = 0B;
    D.25619 = inst->prev;
    inst->next = D.25619;
    inst->opcode = 869;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25620 = inst->sreg3;
    inst->sreg2 = D.25620;
    D.25621 = inst->sreg2;
    inst->sreg1 = D.25621;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->dreg = 1;
    inst->sreg1 = 0;
    inst->sreg2 = tmp2;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25622>; else goto <D.25623>;
    <D.25622>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25624>;
    <D.25623>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25624>:
  }
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25625 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25625;
    inst->prev = 0B;
    D.25626 = inst->prev;
    inst->next = D.25626;
    inst->opcode = 872;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25627 = inst->sreg3;
    inst->sreg2 = D.25627;
    D.25628 = inst->sreg2;
    inst->sreg1 = D.25628;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = 1;
    inst->sreg2 = 0;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25629>; else goto <D.25630>;
    <D.25629>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25631>;
    <D.25630>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25631>:
  }
  goto <D.22276>;
  <D.22288>:
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25632 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25632;
    inst->prev = 0B;
    D.25633 = inst->prev;
    inst->next = D.25633;
    inst->opcode = 871;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25634 = inst->sreg3;
    inst->sreg2 = D.25634;
    D.25635 = inst->sreg2;
    inst->sreg1 = D.25635;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->dreg = 1;
    inst->sreg1 = 0;
    inst->sreg2 = tmp2;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25636>; else goto <D.25637>;
    <D.25636>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25638>;
    <D.25637>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25638>:
  }
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25639 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25639;
    inst->prev = 0B;
    D.25640 = inst->prev;
    inst->next = D.25640;
    inst->opcode = 872;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25641 = inst->sreg3;
    inst->sreg2 = D.25641;
    D.25642 = inst->sreg2;
    inst->sreg1 = D.25642;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = 1;
    inst->sreg2 = 0;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25643>; else goto <D.25644>;
    <D.25643>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25645>;
    <D.25644>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25645>:
  }
  goto <D.22276>;
  <D.22291>:
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25646 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25646;
    inst->prev = 0B;
    D.25647 = inst->prev;
    inst->next = D.25647;
    inst->opcode = 869;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25648 = inst->sreg3;
    inst->sreg2 = D.25648;
    D.25649 = inst->sreg2;
    inst->sreg1 = D.25649;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->dreg = 1;
    inst->sreg1 = tmp2;
    inst->sreg2 = 0;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25650>; else goto <D.25651>;
    <D.25650>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25652>;
    <D.25651>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25652>:
  }
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25653 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25653;
    inst->prev = 0B;
    D.25654 = inst->prev;
    inst->next = D.25654;
    inst->opcode = 877;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25655 = inst->sreg3;
    inst->sreg2 = D.25655;
    D.25656 = inst->sreg2;
    inst->sreg1 = D.25656;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = 1;
    inst->sreg2 = 0;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25657>; else goto <D.25658>;
    <D.25657>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25659>;
    <D.25658>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25659>:
  }
  goto <D.22276>;
  <D.22294>:
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25660 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25660;
    inst->prev = 0B;
    D.25661 = inst->prev;
    inst->next = D.25661;
    inst->opcode = 871;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25662 = inst->sreg3;
    inst->sreg2 = D.25662;
    D.25663 = inst->sreg2;
    inst->sreg1 = D.25663;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->dreg = 1;
    inst->sreg1 = tmp2;
    inst->sreg2 = 0;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25664>; else goto <D.25665>;
    <D.25664>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25666>;
    <D.25665>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25666>:
  }
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25667 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25667;
    inst->prev = 0B;
    D.25668 = inst->prev;
    inst->next = D.25668;
    inst->opcode = 877;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25669 = inst->sreg3;
    inst->sreg2 = D.25669;
    D.25670 = inst->sreg2;
    inst->sreg1 = D.25670;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = 1;
    inst->sreg2 = 0;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25671>; else goto <D.25672>;
    <D.25671>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25673>;
    <D.25672>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25673>:
  }
  goto <D.22276>;
  <D.22297>:
  monoeg_g_log (0B, 16, "unknown comparison %s\n", "NE_UN");
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-mips.c", 2350);
  <D.22276>:
  ins->opcode = 316;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.24960 = ins->sreg3;
  ins->sreg2 = D.24960;
  D.24929 = ins->sreg2;
  ins->sreg1 = D.24929;
  goto <D.22140>;
  <D.22298>:
  <D.22299>:
  <D.22300>:
  <D.22301>:
  <D.22302>:
  <D.22303>:
  <D.22304>:
  <D.22305>:
  <D.22306>:
  <D.22307>:
  <D.22308>:
  <D.22309>:
  <D.22310>:
  <D.22311>:
  <D.22312>:
  <D.22313>:
  <D.22314>:
  <D.22315>:
  <D.22316>:
  <D.22317>:
  <D.22318>:
  <D.22319>:
  <D.22320>:
  mono_print_ins (ins);
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-mips.c", 2401);
  <D.22321>:
  D.25674 = mono_alloc_ireg (cfg);
  tmp1 = (int) D.25674;
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25675 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25675;
    inst->prev = 0B;
    D.25676 = inst->prev;
    inst->next = D.25676;
    inst->opcode = 440;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25677 = inst->sreg3;
    inst->sreg2 = D.25677;
    D.25678 = inst->sreg2;
    inst->sreg1 = D.25678;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->dreg = tmp1;
    D.24927 = ins->sreg1;
    inst->sreg1 = D.24927;
    inst->data.op[1].const_val = 31;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25679>; else goto <D.25680>;
    <D.25679>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25681>;
    <D.25680>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25681>:
  }
  switch (877) <default: <D.22346>, case 872: <D.22323>, case 874: <D.22328>, case 875: <D.22334>, case 876: <D.22340>, case 877: <D.22326>, case 879: <D.22331>, case 880: <D.22337>, case 881: <D.22343>>
  <D.22323>:
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25682 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25682;
    inst->prev = 0B;
    D.25683 = inst->prev;
    inst->next = D.25683;
    inst->opcode = 872;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25684 = inst->sreg3;
    inst->sreg2 = D.25684;
    D.25685 = inst->sreg2;
    inst->sreg1 = D.25685;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->data.op[1].p = "OverflowException";
    D.24929 = ins->sreg2;
    inst->sreg1 = D.24929;
    inst->sreg2 = tmp1;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25686>; else goto <D.25687>;
    <D.25686>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25688>;
    <D.25687>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25688>:
  }
  goto <D.22325>;
  <D.22326>:
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25689 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25689;
    inst->prev = 0B;
    D.25690 = inst->prev;
    inst->next = D.25690;
    inst->opcode = 877;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25691 = inst->sreg3;
    inst->sreg2 = D.25691;
    D.25692 = inst->sreg2;
    inst->sreg1 = D.25692;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->data.op[1].p = "OverflowException";
    D.24929 = ins->sreg2;
    inst->sreg1 = D.24929;
    inst->sreg2 = tmp1;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25693>; else goto <D.25694>;
    <D.25693>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25695>;
    <D.25694>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25695>:
  }
  goto <D.22325>;
  <D.22328>:
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25696 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25696;
    inst->prev = 0B;
    D.25697 = inst->prev;
    inst->next = D.25697;
    inst->opcode = 869;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25698 = inst->sreg3;
    inst->sreg2 = D.25698;
    D.25699 = inst->sreg2;
    inst->sreg1 = D.25699;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->dreg = 1;
    inst->sreg1 = tmp1;
    D.24929 = ins->sreg2;
    inst->sreg2 = D.24929;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25700>; else goto <D.25701>;
    <D.25700>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25702>;
    <D.25701>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25702>:
  }
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25703 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25703;
    inst->prev = 0B;
    D.25704 = inst->prev;
    inst->next = D.25704;
    inst->opcode = 877;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25705 = inst->sreg3;
    inst->sreg2 = D.25705;
    D.25706 = inst->sreg2;
    inst->sreg1 = D.25706;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = 1;
    inst->sreg2 = 0;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25707>; else goto <D.25708>;
    <D.25707>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25709>;
    <D.25708>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25709>:
  }
  goto <D.22325>;
  <D.22331>:
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25710 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25710;
    inst->prev = 0B;
    D.25711 = inst->prev;
    inst->next = D.25711;
    inst->opcode = 871;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25712 = inst->sreg3;
    inst->sreg2 = D.25712;
    D.25713 = inst->sreg2;
    inst->sreg1 = D.25713;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->dreg = 1;
    inst->sreg1 = tmp1;
    D.24929 = ins->sreg2;
    inst->sreg2 = D.24929;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25714>; else goto <D.25715>;
    <D.25714>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25716>;
    <D.25715>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25716>:
  }
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25717 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25717;
    inst->prev = 0B;
    D.25718 = inst->prev;
    inst->next = D.25718;
    inst->opcode = 877;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25719 = inst->sreg3;
    inst->sreg2 = D.25719;
    D.25720 = inst->sreg2;
    inst->sreg1 = D.25720;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = 1;
    inst->sreg2 = 0;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25721>; else goto <D.25722>;
    <D.25721>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25723>;
    <D.25722>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25723>:
  }
  goto <D.22325>;
  <D.22334>:
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25724 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25724;
    inst->prev = 0B;
    D.25725 = inst->prev;
    inst->next = D.25725;
    inst->opcode = 869;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25726 = inst->sreg3;
    inst->sreg2 = D.25726;
    D.25727 = inst->sreg2;
    inst->sreg1 = D.25727;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->dreg = 1;
    inst->sreg1 = tmp1;
    D.24929 = ins->sreg2;
    inst->sreg2 = D.24929;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25728>; else goto <D.25729>;
    <D.25728>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25730>;
    <D.25729>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25730>:
  }
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25731 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25731;
    inst->prev = 0B;
    D.25732 = inst->prev;
    inst->next = D.25732;
    inst->opcode = 872;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25733 = inst->sreg3;
    inst->sreg2 = D.25733;
    D.25734 = inst->sreg2;
    inst->sreg1 = D.25734;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = 1;
    inst->sreg2 = 0;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25735>; else goto <D.25736>;
    <D.25735>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25737>;
    <D.25736>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25737>:
  }
  goto <D.22325>;
  <D.22337>:
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25738 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25738;
    inst->prev = 0B;
    D.25739 = inst->prev;
    inst->next = D.25739;
    inst->opcode = 871;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25740 = inst->sreg3;
    inst->sreg2 = D.25740;
    D.25741 = inst->sreg2;
    inst->sreg1 = D.25741;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->dreg = 1;
    inst->sreg1 = tmp1;
    D.24929 = ins->sreg2;
    inst->sreg2 = D.24929;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25742>; else goto <D.25743>;
    <D.25742>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25744>;
    <D.25743>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25744>:
  }
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25745 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25745;
    inst->prev = 0B;
    D.25746 = inst->prev;
    inst->next = D.25746;
    inst->opcode = 872;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25747 = inst->sreg3;
    inst->sreg2 = D.25747;
    D.25748 = inst->sreg2;
    inst->sreg1 = D.25748;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = 1;
    inst->sreg2 = 0;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25749>; else goto <D.25750>;
    <D.25749>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25751>;
    <D.25750>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25751>:
  }
  goto <D.22325>;
  <D.22340>:
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25752 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25752;
    inst->prev = 0B;
    D.25753 = inst->prev;
    inst->next = D.25753;
    inst->opcode = 869;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25754 = inst->sreg3;
    inst->sreg2 = D.25754;
    D.25755 = inst->sreg2;
    inst->sreg1 = D.25755;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->dreg = 1;
    D.24929 = ins->sreg2;
    inst->sreg1 = D.24929;
    inst->sreg2 = tmp1;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25756>; else goto <D.25757>;
    <D.25756>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25758>;
    <D.25757>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25758>:
  }
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25759 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25759;
    inst->prev = 0B;
    D.25760 = inst->prev;
    inst->next = D.25760;
    inst->opcode = 877;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25761 = inst->sreg3;
    inst->sreg2 = D.25761;
    D.25762 = inst->sreg2;
    inst->sreg1 = D.25762;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = 1;
    inst->sreg2 = 0;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25763>; else goto <D.25764>;
    <D.25763>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25765>;
    <D.25764>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25765>:
  }
  goto <D.22325>;
  <D.22343>:
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25766 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25766;
    inst->prev = 0B;
    D.25767 = inst->prev;
    inst->next = D.25767;
    inst->opcode = 871;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25768 = inst->sreg3;
    inst->sreg2 = D.25768;
    D.25769 = inst->sreg2;
    inst->sreg1 = D.25769;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->dreg = 1;
    D.24929 = ins->sreg2;
    inst->sreg1 = D.24929;
    inst->sreg2 = tmp1;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25770>; else goto <D.25771>;
    <D.25770>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25772>;
    <D.25771>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25772>:
  }
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25773 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25773;
    inst->prev = 0B;
    D.25774 = inst->prev;
    inst->next = D.25774;
    inst->opcode = 877;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25775 = inst->sreg3;
    inst->sreg2 = D.25775;
    D.25776 = inst->sreg2;
    inst->sreg1 = D.25776;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = 1;
    inst->sreg2 = 0;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25777>; else goto <D.25778>;
    <D.25777>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25779>;
    <D.25778>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25779>:
  }
  goto <D.22325>;
  <D.22346>:
  monoeg_g_log (0B, 16, "unknown comparison %s\n", "NE_UN");
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-mips.c", 2412);
  <D.22325>:
  {
    struct MonoInst * inst;

    D.24919 = cfg->mempool;
    inst = mono_mempool_alloc (D.24919, 56);
    inst->data.op[1].const_val = 0;
    D.25780 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25780;
    inst->prev = 0B;
    D.25781 = inst->prev;
    inst->next = D.25781;
    inst->opcode = 424;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25782 = inst->sreg3;
    inst->sreg2 = D.25782;
    D.25783 = inst->sreg2;
    inst->sreg1 = D.25783;
    D.24924 = cfg->ip;
    inst->cil_code = D.24924;
    D.24925 = ins->dreg;
    inst->dreg = D.24925;
    D.24927 = ins->sreg1;
    inst->sreg1 = D.24927;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    if (D.24932 != 0B) goto <D.25784>; else goto <D.25785>;
    <D.25784>:
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    D.24932->next = inst;
    D.24931 = cfg->cbb;
    D.24932 = D.24931->last_ins;
    inst->prev = D.24932;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    goto <D.25786>;
    <D.25785>:
    D.24931 = cfg->cbb;
    D.24931 = cfg->cbb;
    D.24931->last_ins = inst;
    D.24932 = D.24931->last_ins;
    D.24931->code = D.24932;
    <D.25786>:
  }
  ins->opcode = 316;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.24960 = ins->sreg3;
  ins->sreg2 = D.24960;
  D.24929 = ins->sreg2;
  ins->sreg1 = D.24929;
  goto <D.22140>;
  <D.22348>:
  <D.22349>:
  <D.22350>:
  <D.22351>:
  mono_print_ins (ins);
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-mips.c", 2422);
  <D.22352>:
  goto <D.22140>;
  <D.22140>:
}


mono_arch_decompose_opts (struct MonoCompile * cfg, struct MonoInst * ins)
{
  short unsigned int D.25788;
  int D.25789;
  unsigned int D.25790;
  unsigned int D.25791;
  unsigned int D.25792;
  unsigned int D.25793;
  unsigned int D.25794;
  struct MonoMemPool * D.25795;
  int D.25796;
  struct MonoInst * D.25797;
  int D.25798;
  int D.25799;
  const unsigned char * D.25800;
  int D.25801;
  int D.25802;
  int D.25803;
  struct MonoBasicBlock * D.25804;
  struct MonoInst * D.25805;
  int D.25809;
  struct MonoInst * D.25810;
  int D.25811;
  int D.25812;
  int D.25816;
  struct MonoInst * D.25817;
  int D.25818;
  int D.25819;
  int D.25823;
  struct MonoInst * D.25824;
  int D.25825;
  int D.25826;
  int D.25830;
  struct MonoInst * D.25831;
  int D.25832;
  int D.25833;
  int D.25837;
  struct MonoInst * D.25838;
  int D.25839;
  int D.25840;
  int D.25844;
  struct MonoInst * D.25845;
  int D.25846;
  int D.25847;
  int D.25851;
  struct MonoInst * D.25852;
  int D.25853;
  int D.25854;
  int D.25858;
  struct MonoInst * D.25859;
  int D.25860;
  int D.25861;
  int D.25865;
  struct MonoInst * D.25866;
  int D.25867;
  int D.25868;
  int D.25872;
  struct MonoInst * D.25873;
  int D.25874;
  int D.25875;
  int D.25879;
  struct MonoInst * D.25880;
  int D.25881;
  int D.25882;
  int D.25886;
  struct MonoInst * D.25887;
  int D.25888;
  int D.25889;
  int D.25893;
  struct MonoInst * D.25894;
  int D.25895;
  int D.25896;
  int D.25900;
  struct MonoInst * D.25901;
  int D.25902;
  int D.25903;
  int D.25907;
  struct MonoInst * D.25908;
  int D.25909;
  int D.25910;
  int D.25914;
  struct MonoInst * D.25915;
  int D.25916;
  int D.25917;
  int D.25921;
  struct MonoInst * D.25922;
  int D.25923;
  int D.25924;
  int D.25928;
  struct MonoInst * D.25929;
  int D.25930;
  int D.25931;
  int D.25935;
  struct MonoInst * D.25936;
  int D.25937;
  int D.25938;
  int D.25942;
  struct MonoInst * D.25943;
  int D.25944;
  int D.25945;
  int D.25949;
  unsigned int D.25950;
  int D.25951;
  struct MonoInst * D.25952;
  int D.25953;
  int D.25954;
  int D.25958;
  struct MonoInst * D.25959;
  int D.25960;
  int D.25961;
  int D.25965;
  struct MonoInst * D.25966;
  int D.25967;
  int D.25968;
  int D.25972;
  struct MonoInst * D.25973;
  int D.25974;
  int D.25975;
  int D.25979;
  struct MonoInst * D.25980;
  int D.25981;
  int D.25982;
  int D.25986;
  struct MonoInst * D.25987;
  int D.25988;
  int D.25989;
  int D.25993;
  struct MonoInst * D.25994;
  int D.25995;
  int D.25996;
  int D.26000;
  struct MonoInst * D.26001;
  int D.26002;
  int D.26003;
  int D.26007;
  struct MonoInst * D.26008;
  int D.26009;
  int D.26010;
  int D.26014;
  struct MonoInst * D.26015;
  int D.26016;
  int D.26017;
  int D.26021;
  struct MonoInst * D.26022;
  int D.26023;
  int D.26024;
  int D.26028;
  struct MonoInst * D.26029;
  int D.26030;
  int D.26031;
  int D.26035;
  struct MonoInst * D.26036;
  int D.26037;
  int D.26038;
  int D.26042;
  struct MonoInst * D.26043;
  int D.26044;
  int D.26045;
  int D.26049;
  struct MonoInst * D.26050;
  int D.26051;
  int D.26052;
  int D.26056;
  struct MonoInst * D.26057;
  int D.26058;
  int D.26059;
  int D.26063;
  struct MonoInst * D.26064;
  int D.26065;
  int D.26066;
  unsigned int D.26070;
  unsigned int D.26071;
  unsigned int D.26072;
  unsigned int D.26073;
  unsigned int D.26074;
  int D.26075;
  struct MonoInst * D.26076;
  int D.26077;
  int D.26078;
  int D.26082;
  struct MonoInst * D.26083;
  int D.26084;
  int D.26085;
  int D.26089;
  struct MonoInst * D.26090;
  int D.26091;
  int D.26092;
  int D.26096;
  struct MonoInst * D.26097;
  int D.26098;
  int D.26099;
  int D.26103;
  struct MonoInst * D.26104;
  int D.26105;
  int D.26106;
  int D.26110;
  struct MonoInst * D.26111;
  int D.26112;
  int D.26113;
  int D.26117;
  struct MonoInst * D.26118;
  int D.26119;
  int D.26120;
  int D.26124;
  struct MonoInst * D.26125;
  int D.26126;
  int D.26127;
  int D.26131;
  struct MonoInst * D.26132;
  int D.26133;
  int D.26134;
  int D.26138;
  struct MonoInst * D.26139;
  int D.26140;
  int D.26141;
  int D.26145;
  struct MonoInst * D.26146;
  int D.26147;
  int D.26148;
  int D.26152;
  struct MonoInst * D.26153;
  int D.26154;
  int D.26155;
  int D.26159;
  struct MonoInst * D.26160;
  int D.26161;
  int D.26162;
  int D.26166;
  struct MonoInst * D.26167;
  int D.26168;
  int D.26169;
  int D.26173;
  struct MonoInst * D.26174;
  int D.26175;
  int D.26176;
  int D.26180;
  struct MonoInst * D.26181;
  int D.26182;
  int D.26183;
  int D.26187;
  struct MonoInst * D.26188;
  int D.26189;
  int D.26190;
  int D.26194;
  struct MonoInst * D.26195;
  int D.26196;
  int D.26197;
  int D.26201;
  struct MonoInst * D.26202;
  int D.26203;
  int D.26204;
  int D.26208;
  struct MonoInst * D.26209;
  int D.26210;
  int D.26211;
  int D.26215;
  struct MonoInst * D.26216;
  int D.26217;
  int D.26218;
  unsigned int D.26222;
  int D.26223;
  struct MonoInst * D.26224;
  int D.26225;
  int D.26226;
  int D.26230;
  struct MonoInst * D.26231;
  int D.26232;
  int D.26233;
  int D.26237;
  struct MonoInst * D.26238;
  int D.26239;
  int D.26240;
  int D.26244;
  struct MonoInst * D.26245;
  int D.26246;
  int D.26247;
  int D.26251;
  struct MonoInst * D.26252;
  int D.26253;
  int D.26254;
  int D.26258;
  struct MonoInst * D.26259;
  int D.26260;
  int D.26261;
  int D.26265;
  struct MonoInst * D.26266;
  int D.26267;
  int D.26268;
  int D.26272;
  struct MonoInst * D.26273;
  int D.26274;
  int D.26275;
  int D.26279;
  struct MonoInst * D.26280;
  int D.26281;
  int D.26282;
  int D.26286;
  struct MonoInst * D.26287;
  int D.26288;
  int D.26289;
  int D.26293;
  struct MonoInst * D.26294;
  int D.26295;
  int D.26296;
  int D.26300;
  struct MonoInst * D.26301;
  int D.26302;
  int D.26303;
  int D.26307;
  struct MonoInst * D.26308;
  int D.26309;
  int D.26310;
  int D.26314;
  struct MonoInst * D.26315;
  int D.26316;
  int D.26317;
  int D.26321;
  struct MonoInst * D.26322;
  int D.26323;
  int D.26324;
  int D.26328;
  struct MonoInst * D.26329;
  int D.26330;
  int D.26331;
  int D.26335;
  struct MonoInst * D.26336;
  int D.26337;
  int D.26338;
  int tmp1;
  int tmp2;
  int tmp3;
  int tmp4;
  int tmp5;

  tmp1 = -1;
  tmp2 = -1;
  tmp3 = -1;
  tmp4 = -1;
  tmp5 = -1;
  D.25788 = ins->opcode;
  D.25789 = (int) D.25788;
  switch (D.25789) <default: <D.26342>, case 595: <D.22362>, case 596: <D.22395>, case 599: <D.22423>, case 600: <D.22455>>
  <D.22362>:
  D.25790 = mono_alloc_ireg (cfg);
  tmp1 = (int) D.25790;
  D.25791 = mono_alloc_ireg (cfg);
  tmp2 = (int) D.25791;
  D.25792 = mono_alloc_ireg (cfg);
  tmp3 = (int) D.25792;
  D.25793 = mono_alloc_ireg (cfg);
  tmp4 = (int) D.25793;
  D.25794 = mono_alloc_ireg (cfg);
  tmp5 = (int) D.25794;
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.25796 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25796;
    inst->prev = 0B;
    D.25797 = inst->prev;
    inst->next = D.25797;
    inst->opcode = 565;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25798 = inst->sreg3;
    inst->sreg2 = D.25798;
    D.25799 = inst->sreg2;
    inst->sreg1 = D.25799;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    D.25801 = ins->dreg;
    inst->dreg = D.25801;
    D.25802 = ins->sreg1;
    inst->sreg1 = D.25802;
    D.25803 = ins->sreg2;
    inst->sreg2 = D.25803;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.25806>; else goto <D.25807>;
    <D.25806>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.25808>;
    <D.25807>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.25808>:
  }
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.25809 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25809;
    inst->prev = 0B;
    D.25810 = inst->prev;
    inst->next = D.25810;
    inst->opcode = 574;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25811 = inst->sreg3;
    inst->sreg2 = D.25811;
    D.25812 = inst->sreg2;
    inst->sreg1 = D.25812;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    inst->dreg = tmp1;
    D.25802 = ins->sreg1;
    inst->sreg1 = D.25802;
    D.25803 = ins->sreg2;
    inst->sreg2 = D.25803;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.25813>; else goto <D.25814>;
    <D.25813>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.25815>;
    <D.25814>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.25815>:
  }
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.25816 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25816;
    inst->prev = 0B;
    D.25817 = inst->prev;
    inst->next = D.25817;
    inst->opcode = 574;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25818 = inst->sreg3;
    inst->sreg2 = D.25818;
    D.25819 = inst->sreg2;
    inst->sreg1 = D.25819;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    inst->dreg = tmp2;
    D.25801 = ins->dreg;
    inst->sreg1 = D.25801;
    D.25803 = ins->sreg2;
    inst->sreg2 = D.25803;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.25820>; else goto <D.25821>;
    <D.25820>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.25822>;
    <D.25821>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.25822>:
  }
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.25823 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25823;
    inst->prev = 0B;
    D.25824 = inst->prev;
    inst->next = D.25824;
    inst->opcode = 579;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25825 = inst->sreg3;
    inst->sreg2 = D.25825;
    D.25826 = inst->sreg2;
    inst->sreg1 = D.25826;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    inst->dreg = tmp3;
    inst->sreg1 = tmp2;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.25827>; else goto <D.25828>;
    <D.25827>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.25829>;
    <D.25828>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.25829>:
  }
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.25830 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25830;
    inst->prev = 0B;
    D.25831 = inst->prev;
    inst->next = D.25831;
    inst->opcode = 573;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25832 = inst->sreg3;
    inst->sreg2 = D.25832;
    D.25833 = inst->sreg2;
    inst->sreg1 = D.25833;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    inst->dreg = tmp4;
    inst->sreg1 = tmp3;
    inst->sreg2 = tmp1;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.25834>; else goto <D.25835>;
    <D.25834>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.25836>;
    <D.25835>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.25836>:
  }
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.25837 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25837;
    inst->prev = 0B;
    D.25838 = inst->prev;
    inst->next = D.25838;
    inst->opcode = 440;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25839 = inst->sreg3;
    inst->sreg2 = D.25839;
    D.25840 = inst->sreg2;
    inst->sreg1 = D.25840;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    inst->dreg = tmp5;
    inst->sreg1 = tmp4;
    inst->data.op[1].const_val = 31;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.25841>; else goto <D.25842>;
    <D.25841>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.25843>;
    <D.25842>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.25843>:
  }
  switch (872) <default: <D.22392>, case 872: <D.22369>, case 874: <D.22374>, case 875: <D.22380>, case 876: <D.22386>, case 877: <D.22372>, case 879: <D.22377>, case 880: <D.22383>, case 881: <D.22389>>
  <D.22369>:
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.25844 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25844;
    inst->prev = 0B;
    D.25845 = inst->prev;
    inst->next = D.25845;
    inst->opcode = 872;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25846 = inst->sreg3;
    inst->sreg2 = D.25846;
    D.25847 = inst->sreg2;
    inst->sreg1 = D.25847;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = tmp5;
    inst->sreg2 = 0;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.25848>; else goto <D.25849>;
    <D.25848>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.25850>;
    <D.25849>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.25850>:
  }
  goto <D.22371>;
  <D.22372>:
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.25851 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25851;
    inst->prev = 0B;
    D.25852 = inst->prev;
    inst->next = D.25852;
    inst->opcode = 877;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25853 = inst->sreg3;
    inst->sreg2 = D.25853;
    D.25854 = inst->sreg2;
    inst->sreg1 = D.25854;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = tmp5;
    inst->sreg2 = 0;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.25855>; else goto <D.25856>;
    <D.25855>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.25857>;
    <D.25856>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.25857>:
  }
  goto <D.22371>;
  <D.22374>:
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.25858 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25858;
    inst->prev = 0B;
    D.25859 = inst->prev;
    inst->next = D.25859;
    inst->opcode = 869;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25860 = inst->sreg3;
    inst->sreg2 = D.25860;
    D.25861 = inst->sreg2;
    inst->sreg1 = D.25861;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    inst->dreg = 1;
    inst->sreg1 = 0;
    inst->sreg2 = tmp5;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.25862>; else goto <D.25863>;
    <D.25862>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.25864>;
    <D.25863>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.25864>:
  }
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.25865 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25865;
    inst->prev = 0B;
    D.25866 = inst->prev;
    inst->next = D.25866;
    inst->opcode = 877;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25867 = inst->sreg3;
    inst->sreg2 = D.25867;
    D.25868 = inst->sreg2;
    inst->sreg1 = D.25868;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = 1;
    inst->sreg2 = 0;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.25869>; else goto <D.25870>;
    <D.25869>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.25871>;
    <D.25870>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.25871>:
  }
  goto <D.22371>;
  <D.22377>:
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.25872 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25872;
    inst->prev = 0B;
    D.25873 = inst->prev;
    inst->next = D.25873;
    inst->opcode = 871;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25874 = inst->sreg3;
    inst->sreg2 = D.25874;
    D.25875 = inst->sreg2;
    inst->sreg1 = D.25875;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    inst->dreg = 1;
    inst->sreg1 = 0;
    inst->sreg2 = tmp5;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.25876>; else goto <D.25877>;
    <D.25876>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.25878>;
    <D.25877>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.25878>:
  }
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.25879 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25879;
    inst->prev = 0B;
    D.25880 = inst->prev;
    inst->next = D.25880;
    inst->opcode = 877;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25881 = inst->sreg3;
    inst->sreg2 = D.25881;
    D.25882 = inst->sreg2;
    inst->sreg1 = D.25882;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = 1;
    inst->sreg2 = 0;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.25883>; else goto <D.25884>;
    <D.25883>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.25885>;
    <D.25884>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.25885>:
  }
  goto <D.22371>;
  <D.22380>:
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.25886 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25886;
    inst->prev = 0B;
    D.25887 = inst->prev;
    inst->next = D.25887;
    inst->opcode = 869;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25888 = inst->sreg3;
    inst->sreg2 = D.25888;
    D.25889 = inst->sreg2;
    inst->sreg1 = D.25889;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    inst->dreg = 1;
    inst->sreg1 = 0;
    inst->sreg2 = tmp5;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.25890>; else goto <D.25891>;
    <D.25890>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.25892>;
    <D.25891>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.25892>:
  }
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.25893 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25893;
    inst->prev = 0B;
    D.25894 = inst->prev;
    inst->next = D.25894;
    inst->opcode = 872;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25895 = inst->sreg3;
    inst->sreg2 = D.25895;
    D.25896 = inst->sreg2;
    inst->sreg1 = D.25896;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = 1;
    inst->sreg2 = 0;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.25897>; else goto <D.25898>;
    <D.25897>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.25899>;
    <D.25898>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.25899>:
  }
  goto <D.22371>;
  <D.22383>:
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.25900 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25900;
    inst->prev = 0B;
    D.25901 = inst->prev;
    inst->next = D.25901;
    inst->opcode = 871;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25902 = inst->sreg3;
    inst->sreg2 = D.25902;
    D.25903 = inst->sreg2;
    inst->sreg1 = D.25903;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    inst->dreg = 1;
    inst->sreg1 = 0;
    inst->sreg2 = tmp5;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.25904>; else goto <D.25905>;
    <D.25904>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.25906>;
    <D.25905>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.25906>:
  }
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.25907 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25907;
    inst->prev = 0B;
    D.25908 = inst->prev;
    inst->next = D.25908;
    inst->opcode = 872;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25909 = inst->sreg3;
    inst->sreg2 = D.25909;
    D.25910 = inst->sreg2;
    inst->sreg1 = D.25910;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = 1;
    inst->sreg2 = 0;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.25911>; else goto <D.25912>;
    <D.25911>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.25913>;
    <D.25912>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.25913>:
  }
  goto <D.22371>;
  <D.22386>:
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.25914 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25914;
    inst->prev = 0B;
    D.25915 = inst->prev;
    inst->next = D.25915;
    inst->opcode = 869;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25916 = inst->sreg3;
    inst->sreg2 = D.25916;
    D.25917 = inst->sreg2;
    inst->sreg1 = D.25917;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    inst->dreg = 1;
    inst->sreg1 = tmp5;
    inst->sreg2 = 0;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.25918>; else goto <D.25919>;
    <D.25918>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.25920>;
    <D.25919>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.25920>:
  }
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.25921 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25921;
    inst->prev = 0B;
    D.25922 = inst->prev;
    inst->next = D.25922;
    inst->opcode = 877;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25923 = inst->sreg3;
    inst->sreg2 = D.25923;
    D.25924 = inst->sreg2;
    inst->sreg1 = D.25924;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = 1;
    inst->sreg2 = 0;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.25925>; else goto <D.25926>;
    <D.25925>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.25927>;
    <D.25926>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.25927>:
  }
  goto <D.22371>;
  <D.22389>:
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.25928 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25928;
    inst->prev = 0B;
    D.25929 = inst->prev;
    inst->next = D.25929;
    inst->opcode = 871;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25930 = inst->sreg3;
    inst->sreg2 = D.25930;
    D.25931 = inst->sreg2;
    inst->sreg1 = D.25931;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    inst->dreg = 1;
    inst->sreg1 = tmp5;
    inst->sreg2 = 0;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.25932>; else goto <D.25933>;
    <D.25932>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.25934>;
    <D.25933>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.25934>:
  }
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.25935 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25935;
    inst->prev = 0B;
    D.25936 = inst->prev;
    inst->next = D.25936;
    inst->opcode = 877;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25937 = inst->sreg3;
    inst->sreg2 = D.25937;
    D.25938 = inst->sreg2;
    inst->sreg1 = D.25938;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = 1;
    inst->sreg2 = 0;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.25939>; else goto <D.25940>;
    <D.25939>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.25941>;
    <D.25940>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.25941>:
  }
  goto <D.22371>;
  <D.22392>:
  monoeg_g_log (0B, 16, "unknown comparison %s\n", "EQ");
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-mips.c", 2472);
  <D.22371>:
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.25942 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25942;
    inst->prev = 0B;
    D.25943 = inst->prev;
    inst->next = D.25943;
    inst->opcode = 424;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25944 = inst->sreg3;
    inst->sreg2 = D.25944;
    D.25945 = inst->sreg2;
    inst->sreg1 = D.25945;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    D.25801 = ins->dreg;
    inst->dreg = D.25801;
    D.25801 = ins->dreg;
    inst->sreg1 = D.25801;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.25946>; else goto <D.25947>;
    <D.25946>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.25948>;
    <D.25947>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.25948>:
  }
  ins->opcode = 316;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.25949 = ins->sreg3;
  ins->sreg2 = D.25949;
  D.25803 = ins->sreg2;
  ins->sreg1 = D.25803;
  goto <D.22394>;
  <D.22395>:
  D.25950 = mono_alloc_ireg (cfg);
  tmp1 = (int) D.25950;
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.25951 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25951;
    inst->prev = 0B;
    D.25952 = inst->prev;
    inst->next = D.25952;
    inst->opcode = 565;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25953 = inst->sreg3;
    inst->sreg2 = D.25953;
    D.25954 = inst->sreg2;
    inst->sreg1 = D.25954;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    D.25801 = ins->dreg;
    inst->dreg = D.25801;
    D.25802 = ins->sreg1;
    inst->sreg1 = D.25802;
    D.25803 = ins->sreg2;
    inst->sreg2 = D.25803;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.25955>; else goto <D.25956>;
    <D.25955>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.25957>;
    <D.25956>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.25957>:
  }
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.25958 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25958;
    inst->prev = 0B;
    D.25959 = inst->prev;
    inst->next = D.25959;
    inst->opcode = 871;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25960 = inst->sreg3;
    inst->sreg2 = D.25960;
    D.25961 = inst->sreg2;
    inst->sreg1 = D.25961;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    inst->dreg = tmp1;
    D.25801 = ins->dreg;
    inst->sreg1 = D.25801;
    D.25802 = ins->sreg1;
    inst->sreg2 = D.25802;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.25962>; else goto <D.25963>;
    <D.25962>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.25964>;
    <D.25963>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.25964>:
  }
  switch (877) <default: <D.22421>, case 872: <D.22398>, case 874: <D.22403>, case 875: <D.22409>, case 876: <D.22415>, case 877: <D.22401>, case 879: <D.22406>, case 880: <D.22412>, case 881: <D.22418>>
  <D.22398>:
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.25965 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25965;
    inst->prev = 0B;
    D.25966 = inst->prev;
    inst->next = D.25966;
    inst->opcode = 872;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25967 = inst->sreg3;
    inst->sreg2 = D.25967;
    D.25968 = inst->sreg2;
    inst->sreg1 = D.25968;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = tmp1;
    inst->sreg2 = 0;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.25969>; else goto <D.25970>;
    <D.25969>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.25971>;
    <D.25970>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.25971>:
  }
  goto <D.22400>;
  <D.22401>:
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.25972 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25972;
    inst->prev = 0B;
    D.25973 = inst->prev;
    inst->next = D.25973;
    inst->opcode = 877;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25974 = inst->sreg3;
    inst->sreg2 = D.25974;
    D.25975 = inst->sreg2;
    inst->sreg1 = D.25975;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = tmp1;
    inst->sreg2 = 0;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.25976>; else goto <D.25977>;
    <D.25976>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.25978>;
    <D.25977>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.25978>:
  }
  goto <D.22400>;
  <D.22403>:
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.25979 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25979;
    inst->prev = 0B;
    D.25980 = inst->prev;
    inst->next = D.25980;
    inst->opcode = 869;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25981 = inst->sreg3;
    inst->sreg2 = D.25981;
    D.25982 = inst->sreg2;
    inst->sreg1 = D.25982;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    inst->dreg = 1;
    inst->sreg1 = 0;
    inst->sreg2 = tmp1;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.25983>; else goto <D.25984>;
    <D.25983>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.25985>;
    <D.25984>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.25985>:
  }
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.25986 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25986;
    inst->prev = 0B;
    D.25987 = inst->prev;
    inst->next = D.25987;
    inst->opcode = 877;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25988 = inst->sreg3;
    inst->sreg2 = D.25988;
    D.25989 = inst->sreg2;
    inst->sreg1 = D.25989;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = 1;
    inst->sreg2 = 0;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.25990>; else goto <D.25991>;
    <D.25990>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.25992>;
    <D.25991>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.25992>:
  }
  goto <D.22400>;
  <D.22406>:
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.25993 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.25993;
    inst->prev = 0B;
    D.25994 = inst->prev;
    inst->next = D.25994;
    inst->opcode = 871;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.25995 = inst->sreg3;
    inst->sreg2 = D.25995;
    D.25996 = inst->sreg2;
    inst->sreg1 = D.25996;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    inst->dreg = 1;
    inst->sreg1 = 0;
    inst->sreg2 = tmp1;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.25997>; else goto <D.25998>;
    <D.25997>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.25999>;
    <D.25998>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.25999>:
  }
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.26000 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.26000;
    inst->prev = 0B;
    D.26001 = inst->prev;
    inst->next = D.26001;
    inst->opcode = 877;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.26002 = inst->sreg3;
    inst->sreg2 = D.26002;
    D.26003 = inst->sreg2;
    inst->sreg1 = D.26003;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = 1;
    inst->sreg2 = 0;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.26004>; else goto <D.26005>;
    <D.26004>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.26006>;
    <D.26005>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.26006>:
  }
  goto <D.22400>;
  <D.22409>:
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.26007 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.26007;
    inst->prev = 0B;
    D.26008 = inst->prev;
    inst->next = D.26008;
    inst->opcode = 869;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.26009 = inst->sreg3;
    inst->sreg2 = D.26009;
    D.26010 = inst->sreg2;
    inst->sreg1 = D.26010;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    inst->dreg = 1;
    inst->sreg1 = 0;
    inst->sreg2 = tmp1;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.26011>; else goto <D.26012>;
    <D.26011>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.26013>;
    <D.26012>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.26013>:
  }
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.26014 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.26014;
    inst->prev = 0B;
    D.26015 = inst->prev;
    inst->next = D.26015;
    inst->opcode = 872;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.26016 = inst->sreg3;
    inst->sreg2 = D.26016;
    D.26017 = inst->sreg2;
    inst->sreg1 = D.26017;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = 1;
    inst->sreg2 = 0;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.26018>; else goto <D.26019>;
    <D.26018>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.26020>;
    <D.26019>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.26020>:
  }
  goto <D.22400>;
  <D.22412>:
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.26021 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.26021;
    inst->prev = 0B;
    D.26022 = inst->prev;
    inst->next = D.26022;
    inst->opcode = 871;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.26023 = inst->sreg3;
    inst->sreg2 = D.26023;
    D.26024 = inst->sreg2;
    inst->sreg1 = D.26024;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    inst->dreg = 1;
    inst->sreg1 = 0;
    inst->sreg2 = tmp1;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.26025>; else goto <D.26026>;
    <D.26025>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.26027>;
    <D.26026>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.26027>:
  }
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.26028 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.26028;
    inst->prev = 0B;
    D.26029 = inst->prev;
    inst->next = D.26029;
    inst->opcode = 872;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.26030 = inst->sreg3;
    inst->sreg2 = D.26030;
    D.26031 = inst->sreg2;
    inst->sreg1 = D.26031;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = 1;
    inst->sreg2 = 0;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.26032>; else goto <D.26033>;
    <D.26032>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.26034>;
    <D.26033>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.26034>:
  }
  goto <D.22400>;
  <D.22415>:
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.26035 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.26035;
    inst->prev = 0B;
    D.26036 = inst->prev;
    inst->next = D.26036;
    inst->opcode = 869;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.26037 = inst->sreg3;
    inst->sreg2 = D.26037;
    D.26038 = inst->sreg2;
    inst->sreg1 = D.26038;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    inst->dreg = 1;
    inst->sreg1 = tmp1;
    inst->sreg2 = 0;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.26039>; else goto <D.26040>;
    <D.26039>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.26041>;
    <D.26040>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.26041>:
  }
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.26042 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.26042;
    inst->prev = 0B;
    D.26043 = inst->prev;
    inst->next = D.26043;
    inst->opcode = 877;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.26044 = inst->sreg3;
    inst->sreg2 = D.26044;
    D.26045 = inst->sreg2;
    inst->sreg1 = D.26045;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = 1;
    inst->sreg2 = 0;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.26046>; else goto <D.26047>;
    <D.26046>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.26048>;
    <D.26047>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.26048>:
  }
  goto <D.22400>;
  <D.22418>:
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.26049 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.26049;
    inst->prev = 0B;
    D.26050 = inst->prev;
    inst->next = D.26050;
    inst->opcode = 871;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.26051 = inst->sreg3;
    inst->sreg2 = D.26051;
    D.26052 = inst->sreg2;
    inst->sreg1 = D.26052;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    inst->dreg = 1;
    inst->sreg1 = tmp1;
    inst->sreg2 = 0;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.26053>; else goto <D.26054>;
    <D.26053>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.26055>;
    <D.26054>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.26055>:
  }
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.26056 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.26056;
    inst->prev = 0B;
    D.26057 = inst->prev;
    inst->next = D.26057;
    inst->opcode = 877;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.26058 = inst->sreg3;
    inst->sreg2 = D.26058;
    D.26059 = inst->sreg2;
    inst->sreg1 = D.26059;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = 1;
    inst->sreg2 = 0;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.26060>; else goto <D.26061>;
    <D.26060>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.26062>;
    <D.26061>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.26062>:
  }
  goto <D.22400>;
  <D.22421>:
  monoeg_g_log (0B, 16, "unknown comparison %s\n", "NE_UN");
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-mips.c", 2483);
  <D.22400>:
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.26063 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.26063;
    inst->prev = 0B;
    D.26064 = inst->prev;
    inst->next = D.26064;
    inst->opcode = 424;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.26065 = inst->sreg3;
    inst->sreg2 = D.26065;
    D.26066 = inst->sreg2;
    inst->sreg1 = D.26066;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    D.25801 = ins->dreg;
    inst->dreg = D.25801;
    D.25801 = ins->dreg;
    inst->sreg1 = D.25801;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.26067>; else goto <D.26068>;
    <D.26067>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.26069>;
    <D.26068>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.26069>:
  }
  ins->opcode = 316;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.25949 = ins->sreg3;
  ins->sreg2 = D.25949;
  D.25803 = ins->sreg2;
  ins->sreg1 = D.25803;
  goto <D.22394>;
  <D.22423>:
  D.26070 = mono_alloc_ireg (cfg);
  tmp1 = (int) D.26070;
  D.26071 = mono_alloc_ireg (cfg);
  tmp2 = (int) D.26071;
  D.26072 = mono_alloc_ireg (cfg);
  tmp3 = (int) D.26072;
  D.26073 = mono_alloc_ireg (cfg);
  tmp4 = (int) D.26073;
  D.26074 = mono_alloc_ireg (cfg);
  tmp5 = (int) D.26074;
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.26075 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.26075;
    inst->prev = 0B;
    D.26076 = inst->prev;
    inst->next = D.26076;
    inst->opcode = 566;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.26077 = inst->sreg3;
    inst->sreg2 = D.26077;
    D.26078 = inst->sreg2;
    inst->sreg1 = D.26078;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    D.25801 = ins->dreg;
    inst->dreg = D.25801;
    D.25802 = ins->sreg1;
    inst->sreg1 = D.25802;
    D.25803 = ins->sreg2;
    inst->sreg2 = D.25803;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.26079>; else goto <D.26080>;
    <D.26079>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.26081>;
    <D.26080>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.26081>:
  }
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.26082 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.26082;
    inst->prev = 0B;
    D.26083 = inst->prev;
    inst->next = D.26083;
    inst->opcode = 574;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.26084 = inst->sreg3;
    inst->sreg2 = D.26084;
    D.26085 = inst->sreg2;
    inst->sreg1 = D.26085;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    inst->dreg = tmp1;
    D.25802 = ins->sreg1;
    inst->sreg1 = D.25802;
    D.25803 = ins->sreg2;
    inst->sreg2 = D.25803;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.26086>; else goto <D.26087>;
    <D.26086>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.26088>;
    <D.26087>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.26088>:
  }
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.26089 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.26089;
    inst->prev = 0B;
    D.26090 = inst->prev;
    inst->next = D.26090;
    inst->opcode = 574;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.26091 = inst->sreg3;
    inst->sreg2 = D.26091;
    D.26092 = inst->sreg2;
    inst->sreg1 = D.26092;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    inst->dreg = tmp2;
    D.25802 = ins->sreg1;
    inst->sreg1 = D.25802;
    D.25801 = ins->dreg;
    inst->sreg2 = D.25801;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.26093>; else goto <D.26094>;
    <D.26093>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.26095>;
    <D.26094>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.26095>:
  }
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.26096 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.26096;
    inst->prev = 0B;
    D.26097 = inst->prev;
    inst->next = D.26097;
    inst->opcode = 868;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.26098 = inst->sreg3;
    inst->sreg2 = D.26098;
    D.26099 = inst->sreg2;
    inst->sreg1 = D.26099;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    inst->dreg = tmp3;
    inst->sreg1 = tmp1;
    inst->data.op[1].const_val = 0;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.26100>; else goto <D.26101>;
    <D.26100>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.26102>;
    <D.26101>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.26102>:
  }
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.26103 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.26103;
    inst->prev = 0B;
    D.26104 = inst->prev;
    inst->next = D.26104;
    inst->opcode = 868;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.26105 = inst->sreg3;
    inst->sreg2 = D.26105;
    D.26106 = inst->sreg2;
    inst->sreg1 = D.26106;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    inst->dreg = tmp4;
    inst->sreg1 = tmp2;
    inst->data.op[1].const_val = 0;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.26107>; else goto <D.26108>;
    <D.26107>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.26109>;
    <D.26108>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.26109>:
  }
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.26110 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.26110;
    inst->prev = 0B;
    D.26111 = inst->prev;
    inst->next = D.26111;
    inst->opcode = 572;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.26112 = inst->sreg3;
    inst->sreg2 = D.26112;
    D.26113 = inst->sreg2;
    inst->sreg1 = D.26113;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    inst->dreg = tmp5;
    inst->sreg1 = tmp4;
    inst->sreg2 = tmp3;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.26114>; else goto <D.26115>;
    <D.26114>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.26116>;
    <D.26115>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.26116>:
  }
  switch (877) <default: <D.22453>, case 872: <D.22430>, case 874: <D.22435>, case 875: <D.22441>, case 876: <D.22447>, case 877: <D.22433>, case 879: <D.22438>, case 880: <D.22444>, case 881: <D.22450>>
  <D.22430>:
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.26117 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.26117;
    inst->prev = 0B;
    D.26118 = inst->prev;
    inst->next = D.26118;
    inst->opcode = 872;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.26119 = inst->sreg3;
    inst->sreg2 = D.26119;
    D.26120 = inst->sreg2;
    inst->sreg1 = D.26120;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = tmp5;
    inst->sreg2 = 0;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.26121>; else goto <D.26122>;
    <D.26121>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.26123>;
    <D.26122>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.26123>:
  }
  goto <D.22432>;
  <D.22433>:
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.26124 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.26124;
    inst->prev = 0B;
    D.26125 = inst->prev;
    inst->next = D.26125;
    inst->opcode = 877;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.26126 = inst->sreg3;
    inst->sreg2 = D.26126;
    D.26127 = inst->sreg2;
    inst->sreg1 = D.26127;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = tmp5;
    inst->sreg2 = 0;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.26128>; else goto <D.26129>;
    <D.26128>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.26130>;
    <D.26129>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.26130>:
  }
  goto <D.22432>;
  <D.22435>:
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.26131 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.26131;
    inst->prev = 0B;
    D.26132 = inst->prev;
    inst->next = D.26132;
    inst->opcode = 869;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.26133 = inst->sreg3;
    inst->sreg2 = D.26133;
    D.26134 = inst->sreg2;
    inst->sreg1 = D.26134;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    inst->dreg = 1;
    inst->sreg1 = 0;
    inst->sreg2 = tmp5;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.26135>; else goto <D.26136>;
    <D.26135>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.26137>;
    <D.26136>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.26137>:
  }
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.26138 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.26138;
    inst->prev = 0B;
    D.26139 = inst->prev;
    inst->next = D.26139;
    inst->opcode = 877;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.26140 = inst->sreg3;
    inst->sreg2 = D.26140;
    D.26141 = inst->sreg2;
    inst->sreg1 = D.26141;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = 1;
    inst->sreg2 = 0;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.26142>; else goto <D.26143>;
    <D.26142>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.26144>;
    <D.26143>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.26144>:
  }
  goto <D.22432>;
  <D.22438>:
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.26145 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.26145;
    inst->prev = 0B;
    D.26146 = inst->prev;
    inst->next = D.26146;
    inst->opcode = 871;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.26147 = inst->sreg3;
    inst->sreg2 = D.26147;
    D.26148 = inst->sreg2;
    inst->sreg1 = D.26148;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    inst->dreg = 1;
    inst->sreg1 = 0;
    inst->sreg2 = tmp5;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.26149>; else goto <D.26150>;
    <D.26149>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.26151>;
    <D.26150>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.26151>:
  }
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.26152 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.26152;
    inst->prev = 0B;
    D.26153 = inst->prev;
    inst->next = D.26153;
    inst->opcode = 877;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.26154 = inst->sreg3;
    inst->sreg2 = D.26154;
    D.26155 = inst->sreg2;
    inst->sreg1 = D.26155;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = 1;
    inst->sreg2 = 0;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.26156>; else goto <D.26157>;
    <D.26156>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.26158>;
    <D.26157>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.26158>:
  }
  goto <D.22432>;
  <D.22441>:
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.26159 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.26159;
    inst->prev = 0B;
    D.26160 = inst->prev;
    inst->next = D.26160;
    inst->opcode = 869;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.26161 = inst->sreg3;
    inst->sreg2 = D.26161;
    D.26162 = inst->sreg2;
    inst->sreg1 = D.26162;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    inst->dreg = 1;
    inst->sreg1 = 0;
    inst->sreg2 = tmp5;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.26163>; else goto <D.26164>;
    <D.26163>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.26165>;
    <D.26164>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.26165>:
  }
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.26166 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.26166;
    inst->prev = 0B;
    D.26167 = inst->prev;
    inst->next = D.26167;
    inst->opcode = 872;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.26168 = inst->sreg3;
    inst->sreg2 = D.26168;
    D.26169 = inst->sreg2;
    inst->sreg1 = D.26169;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = 1;
    inst->sreg2 = 0;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.26170>; else goto <D.26171>;
    <D.26170>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.26172>;
    <D.26171>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.26172>:
  }
  goto <D.22432>;
  <D.22444>:
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.26173 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.26173;
    inst->prev = 0B;
    D.26174 = inst->prev;
    inst->next = D.26174;
    inst->opcode = 871;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.26175 = inst->sreg3;
    inst->sreg2 = D.26175;
    D.26176 = inst->sreg2;
    inst->sreg1 = D.26176;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    inst->dreg = 1;
    inst->sreg1 = 0;
    inst->sreg2 = tmp5;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.26177>; else goto <D.26178>;
    <D.26177>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.26179>;
    <D.26178>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.26179>:
  }
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.26180 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.26180;
    inst->prev = 0B;
    D.26181 = inst->prev;
    inst->next = D.26181;
    inst->opcode = 872;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.26182 = inst->sreg3;
    inst->sreg2 = D.26182;
    D.26183 = inst->sreg2;
    inst->sreg1 = D.26183;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = 1;
    inst->sreg2 = 0;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.26184>; else goto <D.26185>;
    <D.26184>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.26186>;
    <D.26185>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.26186>:
  }
  goto <D.22432>;
  <D.22447>:
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.26187 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.26187;
    inst->prev = 0B;
    D.26188 = inst->prev;
    inst->next = D.26188;
    inst->opcode = 869;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.26189 = inst->sreg3;
    inst->sreg2 = D.26189;
    D.26190 = inst->sreg2;
    inst->sreg1 = D.26190;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    inst->dreg = 1;
    inst->sreg1 = tmp5;
    inst->sreg2 = 0;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.26191>; else goto <D.26192>;
    <D.26191>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.26193>;
    <D.26192>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.26193>:
  }
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.26194 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.26194;
    inst->prev = 0B;
    D.26195 = inst->prev;
    inst->next = D.26195;
    inst->opcode = 877;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.26196 = inst->sreg3;
    inst->sreg2 = D.26196;
    D.26197 = inst->sreg2;
    inst->sreg1 = D.26197;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = 1;
    inst->sreg2 = 0;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.26198>; else goto <D.26199>;
    <D.26198>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.26200>;
    <D.26199>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.26200>:
  }
  goto <D.22432>;
  <D.22450>:
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.26201 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.26201;
    inst->prev = 0B;
    D.26202 = inst->prev;
    inst->next = D.26202;
    inst->opcode = 871;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.26203 = inst->sreg3;
    inst->sreg2 = D.26203;
    D.26204 = inst->sreg2;
    inst->sreg1 = D.26204;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    inst->dreg = 1;
    inst->sreg1 = tmp5;
    inst->sreg2 = 0;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.26205>; else goto <D.26206>;
    <D.26205>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.26207>;
    <D.26206>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.26207>:
  }
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.26208 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.26208;
    inst->prev = 0B;
    D.26209 = inst->prev;
    inst->next = D.26209;
    inst->opcode = 877;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.26210 = inst->sreg3;
    inst->sreg2 = D.26210;
    D.26211 = inst->sreg2;
    inst->sreg1 = D.26211;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = 1;
    inst->sreg2 = 0;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.26212>; else goto <D.26213>;
    <D.26212>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.26214>;
    <D.26213>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.26214>:
  }
  goto <D.22432>;
  <D.22453>:
  monoeg_g_log (0B, 16, "unknown comparison %s\n", "NE_UN");
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-mips.c", 2517);
  <D.22432>:
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.26215 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.26215;
    inst->prev = 0B;
    D.26216 = inst->prev;
    inst->next = D.26216;
    inst->opcode = 424;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.26217 = inst->sreg3;
    inst->sreg2 = D.26217;
    D.26218 = inst->sreg2;
    inst->sreg1 = D.26218;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    D.25801 = ins->dreg;
    inst->dreg = D.25801;
    D.25801 = ins->dreg;
    inst->sreg1 = D.25801;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.26219>; else goto <D.26220>;
    <D.26219>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.26221>;
    <D.26220>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.26221>:
  }
  ins->opcode = 316;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.25949 = ins->sreg3;
  ins->sreg2 = D.25949;
  D.25803 = ins->sreg2;
  ins->sreg1 = D.25803;
  goto <D.22394>;
  <D.22455>:
  D.26222 = mono_alloc_ireg (cfg);
  tmp1 = (int) D.26222;
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.26223 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.26223;
    inst->prev = 0B;
    D.26224 = inst->prev;
    inst->next = D.26224;
    inst->opcode = 566;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.26225 = inst->sreg3;
    inst->sreg2 = D.26225;
    D.26226 = inst->sreg2;
    inst->sreg1 = D.26226;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    D.25801 = ins->dreg;
    inst->dreg = D.25801;
    D.25802 = ins->sreg1;
    inst->sreg1 = D.25802;
    D.25803 = ins->sreg2;
    inst->sreg2 = D.25803;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.26227>; else goto <D.26228>;
    <D.26227>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.26229>;
    <D.26228>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.26229>:
  }
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.26230 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.26230;
    inst->prev = 0B;
    D.26231 = inst->prev;
    inst->next = D.26231;
    inst->opcode = 871;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.26232 = inst->sreg3;
    inst->sreg2 = D.26232;
    D.26233 = inst->sreg2;
    inst->sreg1 = D.26233;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    inst->dreg = tmp1;
    D.25802 = ins->sreg1;
    inst->sreg1 = D.25802;
    D.25801 = ins->dreg;
    inst->sreg2 = D.25801;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.26234>; else goto <D.26235>;
    <D.26234>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.26236>;
    <D.26235>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.26236>:
  }
  switch (877) <default: <D.22481>, case 872: <D.22458>, case 874: <D.22463>, case 875: <D.22469>, case 876: <D.22475>, case 877: <D.22461>, case 879: <D.22466>, case 880: <D.22472>, case 881: <D.22478>>
  <D.22458>:
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.26237 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.26237;
    inst->prev = 0B;
    D.26238 = inst->prev;
    inst->next = D.26238;
    inst->opcode = 872;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.26239 = inst->sreg3;
    inst->sreg2 = D.26239;
    D.26240 = inst->sreg2;
    inst->sreg1 = D.26240;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = tmp1;
    inst->sreg2 = 0;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.26241>; else goto <D.26242>;
    <D.26241>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.26243>;
    <D.26242>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.26243>:
  }
  goto <D.22460>;
  <D.22461>:
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.26244 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.26244;
    inst->prev = 0B;
    D.26245 = inst->prev;
    inst->next = D.26245;
    inst->opcode = 877;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.26246 = inst->sreg3;
    inst->sreg2 = D.26246;
    D.26247 = inst->sreg2;
    inst->sreg1 = D.26247;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = tmp1;
    inst->sreg2 = 0;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.26248>; else goto <D.26249>;
    <D.26248>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.26250>;
    <D.26249>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.26250>:
  }
  goto <D.22460>;
  <D.22463>:
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.26251 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.26251;
    inst->prev = 0B;
    D.26252 = inst->prev;
    inst->next = D.26252;
    inst->opcode = 869;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.26253 = inst->sreg3;
    inst->sreg2 = D.26253;
    D.26254 = inst->sreg2;
    inst->sreg1 = D.26254;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    inst->dreg = 1;
    inst->sreg1 = 0;
    inst->sreg2 = tmp1;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.26255>; else goto <D.26256>;
    <D.26255>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.26257>;
    <D.26256>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.26257>:
  }
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.26258 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.26258;
    inst->prev = 0B;
    D.26259 = inst->prev;
    inst->next = D.26259;
    inst->opcode = 877;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.26260 = inst->sreg3;
    inst->sreg2 = D.26260;
    D.26261 = inst->sreg2;
    inst->sreg1 = D.26261;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = 1;
    inst->sreg2 = 0;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.26262>; else goto <D.26263>;
    <D.26262>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.26264>;
    <D.26263>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.26264>:
  }
  goto <D.22460>;
  <D.22466>:
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.26265 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.26265;
    inst->prev = 0B;
    D.26266 = inst->prev;
    inst->next = D.26266;
    inst->opcode = 871;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.26267 = inst->sreg3;
    inst->sreg2 = D.26267;
    D.26268 = inst->sreg2;
    inst->sreg1 = D.26268;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    inst->dreg = 1;
    inst->sreg1 = 0;
    inst->sreg2 = tmp1;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.26269>; else goto <D.26270>;
    <D.26269>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.26271>;
    <D.26270>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.26271>:
  }
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.26272 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.26272;
    inst->prev = 0B;
    D.26273 = inst->prev;
    inst->next = D.26273;
    inst->opcode = 877;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.26274 = inst->sreg3;
    inst->sreg2 = D.26274;
    D.26275 = inst->sreg2;
    inst->sreg1 = D.26275;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = 1;
    inst->sreg2 = 0;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.26276>; else goto <D.26277>;
    <D.26276>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.26278>;
    <D.26277>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.26278>:
  }
  goto <D.22460>;
  <D.22469>:
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.26279 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.26279;
    inst->prev = 0B;
    D.26280 = inst->prev;
    inst->next = D.26280;
    inst->opcode = 869;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.26281 = inst->sreg3;
    inst->sreg2 = D.26281;
    D.26282 = inst->sreg2;
    inst->sreg1 = D.26282;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    inst->dreg = 1;
    inst->sreg1 = 0;
    inst->sreg2 = tmp1;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.26283>; else goto <D.26284>;
    <D.26283>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.26285>;
    <D.26284>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.26285>:
  }
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.26286 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.26286;
    inst->prev = 0B;
    D.26287 = inst->prev;
    inst->next = D.26287;
    inst->opcode = 872;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.26288 = inst->sreg3;
    inst->sreg2 = D.26288;
    D.26289 = inst->sreg2;
    inst->sreg1 = D.26289;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = 1;
    inst->sreg2 = 0;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.26290>; else goto <D.26291>;
    <D.26290>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.26292>;
    <D.26291>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.26292>:
  }
  goto <D.22460>;
  <D.22472>:
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.26293 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.26293;
    inst->prev = 0B;
    D.26294 = inst->prev;
    inst->next = D.26294;
    inst->opcode = 871;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.26295 = inst->sreg3;
    inst->sreg2 = D.26295;
    D.26296 = inst->sreg2;
    inst->sreg1 = D.26296;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    inst->dreg = 1;
    inst->sreg1 = 0;
    inst->sreg2 = tmp1;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.26297>; else goto <D.26298>;
    <D.26297>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.26299>;
    <D.26298>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.26299>:
  }
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.26300 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.26300;
    inst->prev = 0B;
    D.26301 = inst->prev;
    inst->next = D.26301;
    inst->opcode = 872;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.26302 = inst->sreg3;
    inst->sreg2 = D.26302;
    D.26303 = inst->sreg2;
    inst->sreg1 = D.26303;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = 1;
    inst->sreg2 = 0;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.26304>; else goto <D.26305>;
    <D.26304>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.26306>;
    <D.26305>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.26306>:
  }
  goto <D.22460>;
  <D.22475>:
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.26307 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.26307;
    inst->prev = 0B;
    D.26308 = inst->prev;
    inst->next = D.26308;
    inst->opcode = 869;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.26309 = inst->sreg3;
    inst->sreg2 = D.26309;
    D.26310 = inst->sreg2;
    inst->sreg1 = D.26310;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    inst->dreg = 1;
    inst->sreg1 = tmp1;
    inst->sreg2 = 0;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.26311>; else goto <D.26312>;
    <D.26311>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.26313>;
    <D.26312>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.26313>:
  }
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.26314 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.26314;
    inst->prev = 0B;
    D.26315 = inst->prev;
    inst->next = D.26315;
    inst->opcode = 877;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.26316 = inst->sreg3;
    inst->sreg2 = D.26316;
    D.26317 = inst->sreg2;
    inst->sreg1 = D.26317;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = 1;
    inst->sreg2 = 0;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.26318>; else goto <D.26319>;
    <D.26318>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.26320>;
    <D.26319>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.26320>:
  }
  goto <D.22460>;
  <D.22478>:
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.26321 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.26321;
    inst->prev = 0B;
    D.26322 = inst->prev;
    inst->next = D.26322;
    inst->opcode = 871;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.26323 = inst->sreg3;
    inst->sreg2 = D.26323;
    D.26324 = inst->sreg2;
    inst->sreg1 = D.26324;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    inst->dreg = 1;
    inst->sreg1 = tmp1;
    inst->sreg2 = 0;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.26325>; else goto <D.26326>;
    <D.26325>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.26327>;
    <D.26326>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.26327>:
  }
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.26328 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.26328;
    inst->prev = 0B;
    D.26329 = inst->prev;
    inst->next = D.26329;
    inst->opcode = 877;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.26330 = inst->sreg3;
    inst->sreg2 = D.26330;
    D.26331 = inst->sreg2;
    inst->sreg1 = D.26331;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    inst->data.op[1].p = "OverflowException";
    inst->sreg1 = 1;
    inst->sreg2 = 0;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.26332>; else goto <D.26333>;
    <D.26332>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.26334>;
    <D.26333>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.26334>:
  }
  goto <D.22460>;
  <D.22481>:
  monoeg_g_log (0B, 16, "unknown comparison %s\n", "NE_UN");
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-mips.c", 2528);
  <D.22460>:
  {
    struct MonoInst * inst;

    D.25795 = cfg->mempool;
    inst = mono_mempool_alloc (D.25795, 56);
    inst->data.op[1].const_val = 0;
    D.26335 = inst->data.op[1].const_val;
    inst->data.op[0].const_val = D.26335;
    inst->prev = 0B;
    D.26336 = inst->prev;
    inst->next = D.26336;
    inst->opcode = 424;
    inst->flags = 0;
    inst->type = 0;
    inst->dreg = -1;
    inst->sreg3 = -1;
    D.26337 = inst->sreg3;
    inst->sreg2 = D.26337;
    D.26338 = inst->sreg2;
    inst->sreg1 = D.26338;
    D.25800 = cfg->ip;
    inst->cil_code = D.25800;
    D.25801 = ins->dreg;
    inst->dreg = D.25801;
    D.25801 = ins->dreg;
    inst->sreg1 = D.25801;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    if (D.25805 != 0B) goto <D.26339>; else goto <D.26340>;
    <D.26339>:
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    D.25805->next = inst;
    D.25804 = cfg->cbb;
    D.25805 = D.25804->last_ins;
    inst->prev = D.25805;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    goto <D.26341>;
    <D.26340>:
    D.25804 = cfg->cbb;
    D.25804 = cfg->cbb;
    D.25804->last_ins = inst;
    D.25805 = D.25804->last_ins;
    D.25804->code = D.25805;
    <D.26341>:
  }
  ins->opcode = 316;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.25949 = ins->sreg3;
  ins->sreg2 = D.25949;
  D.25803 = ins->sreg2;
  ins->sreg1 = D.25803;
  goto <D.22394>;
  <D.26342>:
  <D.22394>:
}


mono_arch_lowering_pass (struct MonoCompile * cfg, struct MonoBasicBlock * bb)
{
  unsigned int D.26343;
  int D.26346;
  int idx.61;
  short unsigned int D.26348;
  int D.26349;
  short unsigned int D.26353;
  short unsigned int D.26354;
  short unsigned int D.26356;
  short unsigned int D.26358;
  short unsigned int D.26360;
  short unsigned int D.26362;
  short unsigned int D.26364;
  short unsigned int D.26366;
  short unsigned int D.26368;
  short unsigned int D.26370;
  int D.26371;
  int D.26372;
  int D.26384;
  struct MonoMemPool * D.26387;
  int D.26388;
  struct MonoInst * D.26389;
  int D.26390;
  int D.26391;
  const unsigned char * D.26392;
  unsigned int D.26393;
  int D.26394;
  int D.26395;
  unsigned int D.26405;
  int D.26406;
  unsigned int D.26418;
  unsigned int D.26419;
  unsigned int D.26422;
  int D.26423;
  int D.26424;
  short unsigned int D.26425;
  short int D.26426;
  int D.26427;
  unsigned int D.26430;
  int D.26431;
  int D.26432;
  short unsigned int D.26433;
  unsigned short D.26434;
  unsigned short D.26435;
  short int D.26436;
  int D.26437;
  int D.26438;
  unsigned int D.26441;
  int D.26442;
  int D.26443;
  short unsigned int D.26444;
  unsigned int D.26449;
  unsigned int D.26452;
  int D.26453;
  int D.26454;
  short unsigned int D.26455;
  unsigned int D.26456;
  int D.26457;
  int D.26458;
  short int D.26459;
  int D.26460;
  unsigned int D.26462;
  int D.26463;
  int D.26464;
  short unsigned int D.26465;
  int D.26468;
  short unsigned int D.26469;
  unsigned int D.26471;
  int D.26472;
  int D.26473;
  short unsigned int D.26474;
  _Bool D.26486;
  long int D.26487;
  long int D.26488;
  int D.26491;
  int D.26492;
  short unsigned int D.26493;
  int D.26494;
  int iftmp.62;
  short unsigned int D.26500;
  _Bool D.26503;
  long int D.26504;
  long int D.26505;
  int D.26508;
  int D.26509;
  int iftmp.63;
  _Bool D.26517;
  long int D.26518;
  long int D.26519;
  int iftmp.64;
  _Bool D.26529;
  long int D.26530;
  long int D.26531;
  unsigned int D.26534;
  int D.26535;
  int iftmp.65;
  _Bool D.26543;
  long int D.26544;
  long int D.26545;
  unsigned int D.26548;
  int D.26549;
  int iftmp.66;
  _Bool D.26557;
  long int D.26558;
  long int D.26559;
  unsigned int D.26562;
  int D.26563;
  int iftmp.67;
  _Bool D.26571;
  long int D.26572;
  long int D.26573;
  unsigned int D.26576;
  int D.26577;
  int iftmp.68;
  _Bool D.26585;
  long int D.26586;
  long int D.26587;
  unsigned int D.26590;
  int D.26591;
  int iftmp.69;
  _Bool D.26599;
  long int D.26600;
  long int D.26601;
  unsigned int D.26604;
  int D.26605;
  int iftmp.70;
  _Bool D.26613;
  long int D.26614;
  long int D.26615;
  unsigned int D.26618;
  int D.26619;
  int iftmp.71;
  _Bool D.26627;
  long int D.26628;
  long int D.26629;
  unsigned int D.26632;
  int D.26633;
  int iftmp.72;
  _Bool D.26641;
  long int D.26642;
  long int D.26643;
  unsigned int D.26646;
  int D.26647;
  int iftmp.73;
  _Bool D.26655;
  long int D.26656;
  long int D.26657;
  struct MonoInst * D.26660;
  struct MonoInst * D.26663;
  struct MonoInst * D.26666;
  struct MonoInst * D.26669;
  int iftmp.74;
  _Bool D.26679;
  long int D.26680;
  long int D.26681;
  int iftmp.75;
  _Bool D.26699;
  long int D.26700;
  long int D.26701;
  int iftmp.76;
  _Bool D.26719;
  long int D.26720;
  long int D.26721;
  int iftmp.77;
  _Bool D.26739;
  long int D.26740;
  long int D.26741;
  int iftmp.78;
  _Bool D.26759;
  long int D.26760;
  long int D.26761;
  int iftmp.79;
  _Bool D.26779;
  long int D.26780;
  long int D.26781;
  int iftmp.80;
  _Bool D.26799;
  long int D.26800;
  long int D.26801;
  int iftmp.81;
  _Bool D.26819;
  long int D.26820;
  long int D.26821;
  int iftmp.82;
  _Bool D.26839;
  long int D.26840;
  long int D.26841;
  int iftmp.83;
  _Bool D.26859;
  long int D.26860;
  long int D.26861;
  int iftmp.84;
  _Bool D.26879;
  long int D.26880;
  long int D.26881;
  _Bool D.26892;
  long int D.26893;
  long int D.26894;
  unsigned int D.26897;
  unsigned int D.26898;
  unsigned int D.26899;
  unsigned int D.26900;
  unsigned int D.26901;
  int D.26902;
  struct MonoInst * D.26903;
  int D.26904;
  int D.26905;
  int D.26906;
  int D.26907;
  struct MonoInst * D.26908;
  int D.26909;
  int D.26910;
  int D.26911;
  int D.26912;
  struct MonoInst * D.26913;
  int D.26914;
  int D.26915;
  int D.26916;
  struct MonoInst * D.26917;
  int D.26918;
  int D.26919;
  int D.26920;
  struct MonoInst * D.26921;
  int D.26922;
  int D.26923;
  unsigned int D.26925;
  int idx.85;
  struct MonoInst * ins;
  struct MonoInst * next;
  struct MonoInst * temp;
  struct MonoInst * last_ins;
  int imm;
  void loop_start = <<< error >>>;

  last_ins = 0B;
  D.26343 = cfg->verbose_level;
  if (D.26343 > 2) goto <D.26344>; else goto <D.26345>;
  <D.26344>:
  {
    int idx;

    idx = 0;
    D.26346 = bb->block_num;
    monoeg_g_print ("BASIC BLOCK %d (before lowering)\n", D.26346);
    ins = bb->code;
    goto <D.22550>;
    <D.22549>:
    idx.61 = idx;
    idx = idx.61 + 1;
    mono_print_ins_index (idx.61, ins);
    ins = ins->next;
    <D.22550>:
    if (ins != 0B) goto <D.22549>; else goto <D.22551>;
    <D.22551>:
  }
  <D.26345>:
  ins = bb->code;
  goto <D.22713>;
  <D.22712>:
  loop_start:
  D.26348 = ins->opcode;
  D.26349 = (int) D.26348;
  switch (D.26349) <default: <D.26924>, case 322: <D.22553>, case 323: <D.22557>, case 324: <D.22585>, case 325: <D.22555>, case 326: <D.22554>, case 327: <D.22558>, case 328: <D.22559>, case 339: <D.22577>, case 379: <D.22579>, case 381: <D.22580>, case 382: <D.22581>, case 383: <D.22582>, case 384: <D.22583>, case 385: <D.22584>, case 396: <D.22578>, case 429: <D.22571>, case 430: <D.22573>, case 431: <D.22575>, case 436: <D.22564>, case 437: <D.22566>, case 438: <D.22568>, case 446: <D.22632>, case 447: <D.22643>, case 448: <D.22647>, case 449: <D.22635>, case 450: <D.22639>, case 451: <D.22651>, case 452: <D.22655>, case 453: <D.22659>, case 454: <D.22663>, case 455: <D.22667>, case 456: <D.22671>, case 457: <D.22675>, case 458: <D.22679>, case 459: <D.22683>, case 460: <D.22687>, case 461: <D.22691>, case 462: <D.22706>, case 463: <D.22708>, case 464: <D.22710>, case 465: <D.22652>, case 466: <D.22656>, case 467: <D.22660>, case 468: <D.22664>, case 469: <D.22668>, case 470: <D.22672>, case 471: <D.22676>, case 472: <D.22680>, case 473: <D.22684>, case 474: <D.22688>, case 475: <D.22692>, case 476: <D.22707>, case 477: <D.22709>, case 478: <D.22711>, case 625: <D.22570>, case 626: <D.22574>, case 627: <D.22576>, case 628: <D.22561>, case 629: <D.22560>, case 630: <D.22562>, case 631: <D.22563>, case 632: <D.22565>, case 633: <D.22567>, case 634: <D.22569>, case 638: <D.22633>, case 639: <D.22644>, case 640: <D.22648>, case 641: <D.22636>, case 642: <D.22640>, case 648: <D.22586>, case 649: <D.22592>, case 650: <D.22622>, case 651: <D.22612>, case 652: <D.22602>, case 653: <D.22589>, case 654: <D.22597>, case 655: <D.22627>, case 656: <D.22617>, case 657: <D.22607>, case 756: <D.22572>>
  <D.22553>:
  <D.22554>:
  <D.22555>:
  next = ins->next;
  if (next == 0B) goto <D.26350>; else goto <D.26352>;
  <D.26352>:
  D.26353 = next->opcode;
  D.26354 = D.26353 + 64985;
  if (D.26354 > 9) goto <D.26355>; else goto <D.26351>;
  <D.26355>:
  D.26353 = next->opcode;
  D.26356 = D.26353 + 64878;
  if (D.26356 > 9) goto <D.26357>; else goto <D.26351>;
  <D.26357>:
  D.26353 = next->opcode;
  D.26358 = D.26353 + 64888;
  if (D.26358 > 9) goto <D.26359>; else goto <D.26351>;
  <D.26359>:
  D.26353 = next->opcode;
  D.26360 = D.26353 + 65085;
  if (D.26360 > 9) goto <D.26361>; else goto <D.26351>;
  <D.26361>:
  D.26353 = next->opcode;
  D.26362 = D.26353 + 65071;
  if (D.26362 > 9) goto <D.26363>; else goto <D.26351>;
  <D.26363>:
  D.26353 = next->opcode;
  D.26364 = D.26353 + 65090;
  if (D.26364 > 4) goto <D.26365>; else goto <D.26351>;
  <D.26365>:
  D.26353 = next->opcode;
  D.26366 = D.26353 + 64898;
  if (D.26366 > 4) goto <D.26367>; else goto <D.26351>;
  <D.26367>:
  D.26353 = next->opcode;
  D.26368 = D.26353 + 65005;
  if (D.26368 > 4) goto <D.26369>; else goto <D.26351>;
  <D.26369>:
  D.26353 = next->opcode;
  D.26370 = D.26353 + 64822;
  if (D.26370 > 4) goto <D.26350>; else goto <D.26351>;
  <D.26350>:
  ins->opcode = 316;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.26371 = ins->sreg3;
  ins->sreg2 = D.26371;
  D.26372 = ins->sreg2;
  ins->sreg1 = D.26372;
  goto <D.22556>;
  <D.26351>:
  goto <D.22556>;
  <D.22557>:
  <D.22558>:
  <D.22559>:
  next = ins->next;
  if (next == 0B) goto <D.26373>; else goto <D.26375>;
  <D.26375>:
  D.26353 = next->opcode;
  D.26354 = D.26353 + 64985;
  if (D.26354 > 9) goto <D.26376>; else goto <D.26374>;
  <D.26376>:
  D.26353 = next->opcode;
  D.26356 = D.26353 + 64878;
  if (D.26356 > 9) goto <D.26377>; else goto <D.26374>;
  <D.26377>:
  D.26353 = next->opcode;
  D.26358 = D.26353 + 64888;
  if (D.26358 > 9) goto <D.26378>; else goto <D.26374>;
  <D.26378>:
  D.26353 = next->opcode;
  D.26360 = D.26353 + 65085;
  if (D.26360 > 9) goto <D.26379>; else goto <D.26374>;
  <D.26379>:
  D.26353 = next->opcode;
  D.26362 = D.26353 + 65071;
  if (D.26362 > 9) goto <D.26380>; else goto <D.26374>;
  <D.26380>:
  D.26353 = next->opcode;
  D.26364 = D.26353 + 65090;
  if (D.26364 > 4) goto <D.26381>; else goto <D.26374>;
  <D.26381>:
  D.26353 = next->opcode;
  D.26366 = D.26353 + 64898;
  if (D.26366 > 4) goto <D.26382>; else goto <D.26374>;
  <D.26382>:
  D.26353 = next->opcode;
  D.26368 = D.26353 + 65005;
  if (D.26368 > 4) goto <D.26383>; else goto <D.26374>;
  <D.26383>:
  D.26353 = next->opcode;
  D.26370 = D.26353 + 64822;
  if (D.26370 > 4) goto <D.26373>; else goto <D.26374>;
  <D.26373>:
  ins->opcode = 316;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.26371 = ins->sreg3;
  ins->sreg2 = D.26371;
  D.26372 = ins->sreg2;
  ins->sreg1 = D.26372;
  goto <D.22556>;
  <D.26374>:
  D.26384 = ins->data.op[1].const_val;
  if (D.26384 != 0) goto <D.26385>; else goto <D.26386>;
  <D.26385>:
  D.26387 = cfg->mempool;
  temp = mono_mempool_alloc (D.26387, 56);
  temp->data.op[1].const_val = 0;
  D.26388 = temp->data.op[1].const_val;
  temp->data.op[0].const_val = D.26388;
  temp->prev = 0B;
  D.26389 = temp->prev;
  temp->next = D.26389;
  temp->opcode = 362;
  temp->flags = 0;
  temp->type = 0;
  temp->dreg = -1;
  temp->sreg3 = -1;
  D.26390 = temp->sreg3;
  temp->sreg2 = D.26390;
  D.26391 = temp->sreg2;
  temp->sreg1 = D.26391;
  D.26392 = cfg->ip;
  temp->cil_code = D.26392;
  mono_bblock_insert_after_ins (bb, last_ins, temp);
  D.26384 = ins->data.op[1].const_val;
  temp->data.op[0].const_val = D.26384;
  D.26393 = mono_alloc_ireg (cfg);
  D.26394 = (int) D.26393;
  temp->dreg = D.26394;
  D.26395 = temp->dreg;
  ins->sreg2 = D.26395;
  last_ins = temp;
  goto <D.26396>;
  <D.26386>:
  ins->sreg2 = 0;
  <D.26396>:
  D.26348 = ins->opcode;
  if (D.26348 == 323) goto <D.26397>; else goto <D.26398>;
  <D.26397>:
  ins->opcode = 322;
  goto <D.26399>;
  <D.26398>:
  D.26348 = ins->opcode;
  if (D.26348 == 327) goto <D.26400>; else goto <D.26401>;
  <D.26400>:
  ins->opcode = 326;
  goto <D.26402>;
  <D.26401>:
  D.26348 = ins->opcode;
  if (D.26348 == 328) goto <D.26403>; else goto <D.26404>;
  <D.26403>:
  ins->opcode = 325;
  <D.26404>:
  <D.26402>:
  <D.26399>:
  goto loop_start;
  <D.22560>:
  <D.22561>:
  <D.22562>:
  <D.22563>:
  D.26387 = cfg->mempool;
  temp = mono_mempool_alloc (D.26387, 56);
  temp->data.op[1].const_val = 0;
  D.26388 = temp->data.op[1].const_val;
  temp->data.op[0].const_val = D.26388;
  temp->prev = 0B;
  D.26389 = temp->prev;
  temp->next = D.26389;
  temp->opcode = 362;
  temp->flags = 0;
  temp->type = 0;
  temp->dreg = -1;
  temp->sreg3 = -1;
  D.26390 = temp->sreg3;
  temp->sreg2 = D.26390;
  D.26391 = temp->sreg2;
  temp->sreg1 = D.26391;
  D.26392 = cfg->ip;
  temp->cil_code = D.26392;
  mono_bblock_insert_after_ins (bb, last_ins, temp);
  D.26384 = ins->data.op[1].const_val;
  temp->data.op[0].const_val = D.26384;
  D.26405 = mono_alloc_ireg (cfg);
  D.26406 = (int) D.26405;
  temp->dreg = D.26406;
  D.26395 = temp->dreg;
  ins->sreg2 = D.26395;
  D.26348 = ins->opcode;
  if (D.26348 == 628) goto <D.26407>; else goto <D.26408>;
  <D.26407>:
  ins->opcode = 568;
  goto <D.26409>;
  <D.26408>:
  D.26348 = ins->opcode;
  if (D.26348 == 630) goto <D.26410>; else goto <D.26411>;
  <D.26410>:
  ins->opcode = 570;
  goto <D.26412>;
  <D.26411>:
  D.26348 = ins->opcode;
  if (D.26348 == 629) goto <D.26413>; else goto <D.26414>;
  <D.26413>:
  ins->opcode = 569;
  goto <D.26415>;
  <D.26414>:
  D.26348 = ins->opcode;
  if (D.26348 == 631) goto <D.26416>; else goto <D.26417>;
  <D.26416>:
  ins->opcode = 571;
  <D.26417>:
  <D.26415>:
  <D.26412>:
  <D.26409>:
  last_ins = temp;
  goto loop_start;
  <D.22564>:
  <D.22565>:
  <D.22566>:
  <D.22567>:
  <D.22568>:
  <D.22569>:
  D.26384 = ins->data.op[1].const_val;
  D.26418 = (unsigned int) D.26384;
  D.26419 = D.26418 & 4294901760;
  if (D.26419 != 0) goto <D.26420>; else goto <D.26421>;
  <D.26420>:
  D.26387 = cfg->mempool;
  temp = mono_mempool_alloc (D.26387, 56);
  temp->data.op[1].const_val = 0;
  D.26388 = temp->data.op[1].const_val;
  temp->data.op[0].const_val = D.26388;
  temp->prev = 0B;
  D.26389 = temp->prev;
  temp->next = D.26389;
  temp->opcode = 362;
  temp->flags = 0;
  temp->type = 0;
  temp->dreg = -1;
  temp->sreg3 = -1;
  D.26390 = temp->sreg3;
  temp->sreg2 = D.26390;
  D.26391 = temp->sreg2;
  temp->sreg1 = D.26391;
  D.26392 = cfg->ip;
  temp->cil_code = D.26392;
  mono_bblock_insert_after_ins (bb, last_ins, temp);
  D.26384 = ins->data.op[1].const_val;
  temp->data.op[0].const_val = D.26384;
  D.26422 = mono_alloc_ireg (cfg);
  D.26423 = (int) D.26422;
  temp->dreg = D.26423;
  D.26395 = temp->dreg;
  ins->sreg2 = D.26395;
  D.26348 = ins->opcode;
  D.26349 = (int) D.26348;
  D.26424 = map_to_reg_reg_op (D.26349);
  D.26425 = (short unsigned int) D.26424;
  ins->opcode = D.26425;
  <D.26421>:
  goto <D.22556>;
  <D.22570>:
  <D.22571>:
  <D.22572>:
  D.26384 = ins->data.op[1].const_val;
  D.26426 = (short int) D.26384;
  D.26427 = (int) D.26426;
  D.26384 = ins->data.op[1].const_val;
  if (D.26427 != D.26384) goto <D.26428>; else goto <D.26429>;
  <D.26428>:
  D.26387 = cfg->mempool;
  temp = mono_mempool_alloc (D.26387, 56);
  temp->data.op[1].const_val = 0;
  D.26388 = temp->data.op[1].const_val;
  temp->data.op[0].const_val = D.26388;
  temp->prev = 0B;
  D.26389 = temp->prev;
  temp->next = D.26389;
  temp->opcode = 362;
  temp->flags = 0;
  temp->type = 0;
  temp->dreg = -1;
  temp->sreg3 = -1;
  D.26390 = temp->sreg3;
  temp->sreg2 = D.26390;
  D.26391 = temp->sreg2;
  temp->sreg1 = D.26391;
  D.26392 = cfg->ip;
  temp->cil_code = D.26392;
  mono_bblock_insert_after_ins (bb, last_ins, temp);
  D.26384 = ins->data.op[1].const_val;
  temp->data.op[0].const_val = D.26384;
  D.26430 = mono_alloc_ireg (cfg);
  D.26431 = (int) D.26430;
  temp->dreg = D.26431;
  D.26395 = temp->dreg;
  ins->sreg2 = D.26395;
  D.26348 = ins->opcode;
  D.26349 = (int) D.26348;
  D.26432 = map_to_reg_reg_op (D.26349);
  D.26433 = (short unsigned int) D.26432;
  ins->opcode = D.26433;
  <D.26429>:
  goto <D.22556>;
  <D.22573>:
  <D.22574>:
  D.26384 = ins->data.op[1].const_val;
  D.26434 = (unsigned short) D.26384;
  D.26435 = -D.26434;
  D.26436 = (short int) D.26435;
  D.26437 = (int) D.26436;
  D.26384 = ins->data.op[1].const_val;
  D.26438 = -D.26384;
  if (D.26437 != D.26438) goto <D.26439>; else goto <D.26440>;
  <D.26439>:
  D.26387 = cfg->mempool;
  temp = mono_mempool_alloc (D.26387, 56);
  temp->data.op[1].const_val = 0;
  D.26388 = temp->data.op[1].const_val;
  temp->data.op[0].const_val = D.26388;
  temp->prev = 0B;
  D.26389 = temp->prev;
  temp->next = D.26389;
  temp->opcode = 362;
  temp->flags = 0;
  temp->type = 0;
  temp->dreg = -1;
  temp->sreg3 = -1;
  D.26390 = temp->sreg3;
  temp->sreg2 = D.26390;
  D.26391 = temp->sreg2;
  temp->sreg1 = D.26391;
  D.26392 = cfg->ip;
  temp->cil_code = D.26392;
  mono_bblock_insert_after_ins (bb, last_ins, temp);
  D.26384 = ins->data.op[1].const_val;
  temp->data.op[0].const_val = D.26384;
  D.26441 = mono_alloc_ireg (cfg);
  D.26442 = (int) D.26441;
  temp->dreg = D.26442;
  D.26395 = temp->dreg;
  ins->sreg2 = D.26395;
  D.26348 = ins->opcode;
  D.26349 = (int) D.26348;
  D.26443 = map_to_reg_reg_op (D.26349);
  D.26444 = (short unsigned int) D.26443;
  ins->opcode = D.26444;
  <D.26440>:
  goto <D.22556>;
  <D.22575>:
  <D.22576>:
  D.26384 = ins->data.op[1].const_val;
  if (D.26384 == 1) goto <D.26445>; else goto <D.26446>;
  <D.26445>:
  ins->opcode = 424;
  goto <D.22556>;
  <D.26446>:
  D.26384 = ins->data.op[1].const_val;
  if (D.26384 == 0) goto <D.26447>; else goto <D.26448>;
  <D.26447>:
  ins->opcode = 362;
  ins->data.op[0].const_val = 0;
  goto <D.22556>;
  <D.26448>:
  D.26384 = ins->data.op[1].const_val;
  D.26449 = (unsigned int) D.26384;
  imm = mono_is_power_of_two (D.26449);
  if (imm > 0) goto <D.26450>; else goto <D.26451>;
  <D.26450>:
  ins->opcode = 439;
  ins->data.op[1].const_val = imm;
  goto <D.22556>;
  <D.26451>:
  D.26387 = cfg->mempool;
  temp = mono_mempool_alloc (D.26387, 56);
  temp->data.op[1].const_val = 0;
  D.26388 = temp->data.op[1].const_val;
  temp->data.op[0].const_val = D.26388;
  temp->prev = 0B;
  D.26389 = temp->prev;
  temp->next = D.26389;
  temp->opcode = 362;
  temp->flags = 0;
  temp->type = 0;
  temp->dreg = -1;
  temp->sreg3 = -1;
  D.26390 = temp->sreg3;
  temp->sreg2 = D.26390;
  D.26391 = temp->sreg2;
  temp->sreg1 = D.26391;
  D.26392 = cfg->ip;
  temp->cil_code = D.26392;
  mono_bblock_insert_after_ins (bb, last_ins, temp);
  D.26384 = ins->data.op[1].const_val;
  temp->data.op[0].const_val = D.26384;
  D.26452 = mono_alloc_ireg (cfg);
  D.26453 = (int) D.26452;
  temp->dreg = D.26453;
  D.26395 = temp->dreg;
  ins->sreg2 = D.26395;
  D.26348 = ins->opcode;
  D.26349 = (int) D.26348;
  D.26454 = map_to_reg_reg_op (D.26349);
  D.26455 = (short unsigned int) D.26454;
  ins->opcode = D.26455;
  goto <D.22556>;
  <D.22577>:
  D.26387 = cfg->mempool;
  temp = mono_mempool_alloc (D.26387, 56);
  temp->data.op[1].const_val = 0;
  D.26388 = temp->data.op[1].const_val;
  temp->data.op[0].const_val = D.26388;
  temp->prev = 0B;
  D.26389 = temp->prev;
  temp->next = D.26389;
  temp->opcode = 362;
  temp->flags = 0;
  temp->type = 0;
  temp->dreg = -1;
  temp->sreg3 = -1;
  D.26390 = temp->sreg3;
  temp->sreg2 = D.26390;
  D.26391 = temp->sreg2;
  temp->sreg1 = D.26391;
  D.26392 = cfg->ip;
  temp->cil_code = D.26392;
  mono_bblock_insert_after_ins (bb, last_ins, temp);
  D.26384 = ins->data.op[1].const_val;
  temp->data.op[0].const_val = D.26384;
  D.26456 = mono_alloc_ireg (cfg);
  D.26457 = (int) D.26456;
  temp->dreg = D.26457;
  D.26395 = temp->dreg;
  ins->sreg1 = D.26395;
  ins->opcode = 338;
  goto <D.22556>;
  <D.22578>:
  <D.22579>:
  D.26458 = ins->data.op[0].const_val;
  D.26459 = (short int) D.26458;
  D.26460 = (int) D.26459;
  D.26458 = ins->data.op[0].const_val;
  if (D.26460 == D.26458) goto <D.22556>; else goto <D.26461>;
  <D.26461>:
  D.26387 = cfg->mempool;
  temp = mono_mempool_alloc (D.26387, 56);
  temp->data.op[1].const_val = 0;
  D.26388 = temp->data.op[1].const_val;
  temp->data.op[0].const_val = D.26388;
  temp->prev = 0B;
  D.26389 = temp->prev;
  temp->next = D.26389;
  temp->opcode = 362;
  temp->flags = 0;
  temp->type = 0;
  temp->dreg = -1;
  temp->sreg3 = -1;
  D.26390 = temp->sreg3;
  temp->sreg2 = D.26390;
  D.26391 = temp->sreg2;
  temp->sreg1 = D.26391;
  D.26392 = cfg->ip;
  temp->cil_code = D.26392;
  mono_bblock_insert_after_ins (bb, last_ins, temp);
  D.26458 = ins->data.op[0].const_val;
  temp->data.op[0].const_val = D.26458;
  D.26462 = mono_alloc_ireg (cfg);
  D.26463 = (int) D.26462;
  temp->dreg = D.26463;
  D.26395 = temp->dreg;
  ins->sreg2 = D.26395;
  D.26348 = ins->opcode;
  D.26349 = (int) D.26348;
  D.26464 = map_to_reg_reg_op (D.26349);
  D.26465 = (short unsigned int) D.26464;
  ins->opcode = D.26465;
  goto <D.22556>;
  <D.22580>:
  <D.22581>:
  <D.22582>:
  <D.22583>:
  <D.22584>:
  D.26384 = ins->data.op[1].const_val;
  if (D.26384 == 0) goto <D.26466>; else goto <D.26467>;
  <D.26466>:
  ins->sreg1 = 0;
  D.26348 = ins->opcode;
  D.26349 = (int) D.26348;
  D.26468 = map_to_reg_reg_op (D.26349);
  D.26469 = (short unsigned int) D.26468;
  ins->opcode = D.26469;
  goto <D.26470>;
  <D.26467>:
  D.26387 = cfg->mempool;
  temp = mono_mempool_alloc (D.26387, 56);
  temp->data.op[1].const_val = 0;
  D.26388 = temp->data.op[1].const_val;
  temp->data.op[0].const_val = D.26388;
  temp->prev = 0B;
  D.26389 = temp->prev;
  temp->next = D.26389;
  temp->opcode = 362;
  temp->flags = 0;
  temp->type = 0;
  temp->dreg = -1;
  temp->sreg3 = -1;
  D.26390 = temp->sreg3;
  temp->sreg2 = D.26390;
  D.26391 = temp->sreg2;
  temp->sreg1 = D.26391;
  D.26392 = cfg->ip;
  temp->cil_code = D.26392;
  mono_bblock_insert_after_ins (bb, last_ins, temp);
  D.26384 = ins->data.op[1].const_val;
  temp->data.op[0].const_val = D.26384;
  D.26471 = mono_alloc_ireg (cfg);
  D.26472 = (int) D.26471;
  temp->dreg = D.26472;
  D.26395 = temp->dreg;
  ins->sreg1 = D.26395;
  D.26348 = ins->opcode;
  D.26349 = (int) D.26348;
  D.26473 = map_to_reg_reg_op (D.26349);
  D.26474 = (short unsigned int) D.26473;
  ins->opcode = D.26474;
  last_ins = temp;
  goto loop_start;
  <D.26470>:
  goto <D.22556>;
  <D.22585>:
  next = ins->next;
  if (next == 0B) goto <D.26475>; else goto <D.26477>;
  <D.26477>:
  D.26353 = next->opcode;
  D.26354 = D.26353 + 64985;
  if (D.26354 > 9) goto <D.26478>; else goto <D.26476>;
  <D.26478>:
  D.26353 = next->opcode;
  D.26356 = D.26353 + 64878;
  if (D.26356 > 9) goto <D.26479>; else goto <D.26476>;
  <D.26479>:
  D.26353 = next->opcode;
  D.26358 = D.26353 + 64888;
  if (D.26358 > 9) goto <D.26480>; else goto <D.26476>;
  <D.26480>:
  D.26353 = next->opcode;
  D.26360 = D.26353 + 65085;
  if (D.26360 > 9) goto <D.26481>; else goto <D.26476>;
  <D.26481>:
  D.26353 = next->opcode;
  D.26362 = D.26353 + 65071;
  if (D.26362 > 9) goto <D.26482>; else goto <D.26476>;
  <D.26482>:
  D.26353 = next->opcode;
  D.26364 = D.26353 + 65090;
  if (D.26364 > 4) goto <D.26483>; else goto <D.26476>;
  <D.26483>:
  D.26353 = next->opcode;
  D.26366 = D.26353 + 64898;
  if (D.26366 > 4) goto <D.26484>; else goto <D.26476>;
  <D.26484>:
  D.26353 = next->opcode;
  D.26368 = D.26353 + 65005;
  if (D.26368 > 4) goto <D.26485>; else goto <D.26476>;
  <D.26485>:
  D.26353 = next->opcode;
  D.26370 = D.26353 + 64822;
  if (D.26370 > 4) goto <D.26475>; else goto <D.26476>;
  <D.26475>:
  ins->opcode = 316;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.26371 = ins->sreg3;
  ins->sreg2 = D.26371;
  D.26372 = ins->sreg2;
  ins->sreg1 = D.26372;
  goto <D.22556>;
  <D.26476>:
  D.26486 = next == 0B;
  D.26487 = (long int) D.26486;
  D.26488 = __builtin_expect (D.26487, 0);
  if (D.26488 != 0) goto <D.26489>; else goto <D.26490>;
  <D.26489>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 2883, "next");
  <D.26490>:
  D.26353 = next->opcode;
  D.26491 = (int) D.26353;
  D.26492 = map_to_mips_op (D.26491);
  D.26493 = (short unsigned int) D.26492;
  next->opcode = D.26493;
  D.26494 = ins->sreg1;
  next->sreg1 = D.26494;
  D.26372 = ins->sreg2;
  next->sreg2 = D.26372;
  ins->opcode = 316;
  ins->dreg = -1;
  ins->sreg3 = -1;
  D.26371 = ins->sreg3;
  ins->sreg2 = D.26371;
  D.26372 = ins->sreg2;
  ins->sreg1 = D.26372;
  goto <D.22556>;
  <D.22586>:
  if (last_ins == 0B) goto <D.26496>; else goto <D.26499>;
  <D.26499>:
  D.26500 = last_ins->opcode;
  if (D.26500 != 322) goto <D.26501>; else goto <D.26497>;
  <D.26501>:
  D.26500 = last_ins->opcode;
  if (D.26500 != 326) goto <D.26502>; else goto <D.26497>;
  <D.26502>:
  D.26500 = last_ins->opcode;
  if (D.26500 != 325) goto <D.26496>; else goto <D.26497>;
  <D.26496>:
  iftmp.62 = 1;
  goto <D.26498>;
  <D.26497>:
  iftmp.62 = 0;
  <D.26498>:
  D.26503 = iftmp.62 != 0;
  D.26504 = (long int) D.26503;
  D.26505 = __builtin_expect (D.26504, 0);
  if (D.26505 != 0) goto <D.26506>; else goto <D.26507>;
  <D.26506>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 2911, "ins_is_compare(last_ins)");
  <D.26507>:
  {
    int s1;
    int s2;

    s1 = last_ins->sreg1;
    s2 = last_ins->sreg2;
    ins->opcode = 842;
    ins->sreg1 = s1;
    ins->sreg2 = s2;
  }
  last_ins->opcode = 316;
  last_ins->dreg = -1;
  last_ins->sreg3 = -1;
  D.26508 = last_ins->sreg3;
  last_ins->sreg2 = D.26508;
  D.26509 = last_ins->sreg2;
  last_ins->sreg1 = D.26509;
  goto <D.22556>;
  <D.22589>:
  if (last_ins == 0B) goto <D.26511>; else goto <D.26514>;
  <D.26514>:
  D.26500 = last_ins->opcode;
  if (D.26500 != 322) goto <D.26515>; else goto <D.26512>;
  <D.26515>:
  D.26500 = last_ins->opcode;
  if (D.26500 != 326) goto <D.26516>; else goto <D.26512>;
  <D.26516>:
  D.26500 = last_ins->opcode;
  if (D.26500 != 325) goto <D.26511>; else goto <D.26512>;
  <D.26511>:
  iftmp.63 = 1;
  goto <D.26513>;
  <D.26512>:
  iftmp.63 = 0;
  <D.26513>:
  D.26517 = iftmp.63 != 0;
  D.26518 = (long int) D.26517;
  D.26519 = __builtin_expect (D.26518, 0);
  if (D.26519 != 0) goto <D.26520>; else goto <D.26521>;
  <D.26520>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 2917, "ins_is_compare(last_ins)");
  <D.26521>:
  {
    int s1;
    int s2;

    s1 = last_ins->sreg1;
    s2 = last_ins->sreg2;
    ins->opcode = 847;
    ins->sreg1 = s1;
    ins->sreg2 = s2;
  }
  last_ins->opcode = 316;
  last_ins->dreg = -1;
  last_ins->sreg3 = -1;
  D.26508 = last_ins->sreg3;
  last_ins->sreg2 = D.26508;
  D.26509 = last_ins->sreg2;
  last_ins->sreg1 = D.26509;
  goto <D.22556>;
  <D.22592>:
  if (last_ins == 0B) goto <D.26523>; else goto <D.26526>;
  <D.26526>:
  D.26500 = last_ins->opcode;
  if (D.26500 != 322) goto <D.26527>; else goto <D.26524>;
  <D.26527>:
  D.26500 = last_ins->opcode;
  if (D.26500 != 326) goto <D.26528>; else goto <D.26524>;
  <D.26528>:
  D.26500 = last_ins->opcode;
  if (D.26500 != 325) goto <D.26523>; else goto <D.26524>;
  <D.26523>:
  iftmp.64 = 1;
  goto <D.26525>;
  <D.26524>:
  iftmp.64 = 0;
  <D.26525>:
  D.26529 = iftmp.64 != 0;
  D.26530 = (long int) D.26529;
  D.26531 = __builtin_expect (D.26530, 0);
  if (D.26531 != 0) goto <D.26532>; else goto <D.26533>;
  <D.26532>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 2923, "ins_is_compare(last_ins)");
  <D.26533>:
  {
    int s1;
    int s2;

    s1 = last_ins->sreg1;
    s2 = last_ins->sreg2;
    last_ins->opcode = 869;
    last_ins->sreg1 = s1;
    last_ins->sreg2 = s2;
  }
  D.26534 = mono_alloc_ireg (cfg);
  D.26535 = (int) D.26534;
  last_ins->dreg = D.26535;
  {
    int s1;
    int s2;

    s1 = last_ins->dreg;
    s2 = 0;
    ins->opcode = 842;
    ins->sreg1 = s1;
    ins->sreg2 = s2;
  }
  goto <D.22556>;
  <D.22597>:
  if (last_ins == 0B) goto <D.26537>; else goto <D.26540>;
  <D.26540>:
  D.26500 = last_ins->opcode;
  if (D.26500 != 322) goto <D.26541>; else goto <D.26538>;
  <D.26541>:
  D.26500 = last_ins->opcode;
  if (D.26500 != 326) goto <D.26542>; else goto <D.26538>;
  <D.26542>:
  D.26500 = last_ins->opcode;
  if (D.26500 != 325) goto <D.26537>; else goto <D.26538>;
  <D.26537>:
  iftmp.65 = 1;
  goto <D.26539>;
  <D.26538>:
  iftmp.65 = 0;
  <D.26539>:
  D.26543 = iftmp.65 != 0;
  D.26544 = (long int) D.26543;
  D.26545 = __builtin_expect (D.26544, 0);
  if (D.26545 != 0) goto <D.26546>; else goto <D.26547>;
  <D.26546>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 2930, "ins_is_compare(last_ins)");
  <D.26547>:
  {
    int s1;
    int s2;

    s1 = last_ins->sreg1;
    s2 = last_ins->sreg2;
    last_ins->opcode = 871;
    last_ins->sreg1 = s1;
    last_ins->sreg2 = s2;
  }
  D.26548 = mono_alloc_ireg (cfg);
  D.26549 = (int) D.26548;
  last_ins->dreg = D.26549;
  {
    int s1;
    int s2;

    s1 = last_ins->dreg;
    s2 = 0;
    ins->opcode = 842;
    ins->sreg1 = s1;
    ins->sreg2 = s2;
  }
  goto <D.22556>;
  <D.22602>:
  if (last_ins == 0B) goto <D.26551>; else goto <D.26554>;
  <D.26554>:
  D.26500 = last_ins->opcode;
  if (D.26500 != 322) goto <D.26555>; else goto <D.26552>;
  <D.26555>:
  D.26500 = last_ins->opcode;
  if (D.26500 != 326) goto <D.26556>; else goto <D.26552>;
  <D.26556>:
  D.26500 = last_ins->opcode;
  if (D.26500 != 325) goto <D.26551>; else goto <D.26552>;
  <D.26551>:
  iftmp.66 = 1;
  goto <D.26553>;
  <D.26552>:
  iftmp.66 = 0;
  <D.26553>:
  D.26557 = iftmp.66 != 0;
  D.26558 = (long int) D.26557;
  D.26559 = __builtin_expect (D.26558, 0);
  if (D.26559 != 0) goto <D.26560>; else goto <D.26561>;
  <D.26560>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 2937, "ins_is_compare(last_ins)");
  <D.26561>:
  {
    int s1;
    int s2;

    s1 = last_ins->sreg1;
    s2 = last_ins->sreg2;
    last_ins->opcode = 869;
    last_ins->sreg1 = s1;
    last_ins->sreg2 = s2;
  }
  D.26562 = mono_alloc_ireg (cfg);
  D.26563 = (int) D.26562;
  last_ins->dreg = D.26563;
  {
    int s1;
    int s2;

    s1 = last_ins->dreg;
    s2 = 0;
    ins->opcode = 847;
    ins->sreg1 = s1;
    ins->sreg2 = s2;
  }
  goto <D.22556>;
  <D.22607>:
  if (last_ins == 0B) goto <D.26565>; else goto <D.26568>;
  <D.26568>:
  D.26500 = last_ins->opcode;
  if (D.26500 != 322) goto <D.26569>; else goto <D.26566>;
  <D.26569>:
  D.26500 = last_ins->opcode;
  if (D.26500 != 326) goto <D.26570>; else goto <D.26566>;
  <D.26570>:
  D.26500 = last_ins->opcode;
  if (D.26500 != 325) goto <D.26565>; else goto <D.26566>;
  <D.26565>:
  iftmp.67 = 1;
  goto <D.26567>;
  <D.26566>:
  iftmp.67 = 0;
  <D.26567>:
  D.26571 = iftmp.67 != 0;
  D.26572 = (long int) D.26571;
  D.26573 = __builtin_expect (D.26572, 0);
  if (D.26573 != 0) goto <D.26574>; else goto <D.26575>;
  <D.26574>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 2944, "ins_is_compare(last_ins)");
  <D.26575>:
  {
    int s1;
    int s2;

    s1 = last_ins->sreg1;
    s2 = last_ins->sreg2;
    last_ins->opcode = 871;
    last_ins->sreg1 = s1;
    last_ins->sreg2 = s2;
  }
  D.26576 = mono_alloc_ireg (cfg);
  D.26577 = (int) D.26576;
  last_ins->dreg = D.26577;
  {
    int s1;
    int s2;

    s1 = last_ins->dreg;
    s2 = 0;
    ins->opcode = 847;
    ins->sreg1 = s1;
    ins->sreg2 = s2;
  }
  goto <D.22556>;
  <D.22612>:
  if (last_ins == 0B) goto <D.26579>; else goto <D.26582>;
  <D.26582>:
  D.26500 = last_ins->opcode;
  if (D.26500 != 322) goto <D.26583>; else goto <D.26580>;
  <D.26583>:
  D.26500 = last_ins->opcode;
  if (D.26500 != 326) goto <D.26584>; else goto <D.26580>;
  <D.26584>:
  D.26500 = last_ins->opcode;
  if (D.26500 != 325) goto <D.26579>; else goto <D.26580>;
  <D.26579>:
  iftmp.68 = 1;
  goto <D.26581>;
  <D.26580>:
  iftmp.68 = 0;
  <D.26581>:
  D.26585 = iftmp.68 != 0;
  D.26586 = (long int) D.26585;
  D.26587 = __builtin_expect (D.26586, 0);
  if (D.26587 != 0) goto <D.26588>; else goto <D.26589>;
  <D.26588>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 2951, "ins_is_compare(last_ins)");
  <D.26589>:
  {
    int s1;
    int s2;

    s1 = last_ins->sreg2;
    s2 = last_ins->sreg1;
    last_ins->opcode = 869;
    last_ins->sreg1 = s1;
    last_ins->sreg2 = s2;
  }
  D.26590 = mono_alloc_ireg (cfg);
  D.26591 = (int) D.26590;
  last_ins->dreg = D.26591;
  {
    int s1;
    int s2;

    s1 = last_ins->dreg;
    s2 = 0;
    ins->opcode = 842;
    ins->sreg1 = s1;
    ins->sreg2 = s2;
  }
  goto <D.22556>;
  <D.22617>:
  if (last_ins == 0B) goto <D.26593>; else goto <D.26596>;
  <D.26596>:
  D.26500 = last_ins->opcode;
  if (D.26500 != 322) goto <D.26597>; else goto <D.26594>;
  <D.26597>:
  D.26500 = last_ins->opcode;
  if (D.26500 != 326) goto <D.26598>; else goto <D.26594>;
  <D.26598>:
  D.26500 = last_ins->opcode;
  if (D.26500 != 325) goto <D.26593>; else goto <D.26594>;
  <D.26593>:
  iftmp.69 = 1;
  goto <D.26595>;
  <D.26594>:
  iftmp.69 = 0;
  <D.26595>:
  D.26599 = iftmp.69 != 0;
  D.26600 = (long int) D.26599;
  D.26601 = __builtin_expect (D.26600, 0);
  if (D.26601 != 0) goto <D.26602>; else goto <D.26603>;
  <D.26602>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 2958, "ins_is_compare(last_ins)");
  <D.26603>:
  {
    int s1;
    int s2;

    s1 = last_ins->sreg2;
    s2 = last_ins->sreg1;
    last_ins->opcode = 871;
    last_ins->sreg1 = s1;
    last_ins->sreg2 = s2;
  }
  D.26604 = mono_alloc_ireg (cfg);
  D.26605 = (int) D.26604;
  last_ins->dreg = D.26605;
  {
    int s1;
    int s2;

    s1 = last_ins->dreg;
    s2 = 0;
    ins->opcode = 842;
    ins->sreg1 = s1;
    ins->sreg2 = s2;
  }
  goto <D.22556>;
  <D.22622>:
  if (last_ins == 0B) goto <D.26607>; else goto <D.26610>;
  <D.26610>:
  D.26500 = last_ins->opcode;
  if (D.26500 != 322) goto <D.26611>; else goto <D.26608>;
  <D.26611>:
  D.26500 = last_ins->opcode;
  if (D.26500 != 326) goto <D.26612>; else goto <D.26608>;
  <D.26612>:
  D.26500 = last_ins->opcode;
  if (D.26500 != 325) goto <D.26607>; else goto <D.26608>;
  <D.26607>:
  iftmp.70 = 1;
  goto <D.26609>;
  <D.26608>:
  iftmp.70 = 0;
  <D.26609>:
  D.26613 = iftmp.70 != 0;
  D.26614 = (long int) D.26613;
  D.26615 = __builtin_expect (D.26614, 0);
  if (D.26615 != 0) goto <D.26616>; else goto <D.26617>;
  <D.26616>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 2965, "ins_is_compare(last_ins)");
  <D.26617>:
  {
    int s1;
    int s2;

    s1 = last_ins->sreg2;
    s2 = last_ins->sreg1;
    last_ins->opcode = 869;
    last_ins->sreg1 = s1;
    last_ins->sreg2 = s2;
  }
  D.26618 = mono_alloc_ireg (cfg);
  D.26619 = (int) D.26618;
  last_ins->dreg = D.26619;
  {
    int s1;
    int s2;

    s1 = last_ins->dreg;
    s2 = 0;
    ins->opcode = 847;
    ins->sreg1 = s1;
    ins->sreg2 = s2;
  }
  goto <D.22556>;
  <D.22627>:
  if (last_ins == 0B) goto <D.26621>; else goto <D.26624>;
  <D.26624>:
  D.26500 = last_ins->opcode;
  if (D.26500 != 322) goto <D.26625>; else goto <D.26622>;
  <D.26625>:
  D.26500 = last_ins->opcode;
  if (D.26500 != 326) goto <D.26626>; else goto <D.26622>;
  <D.26626>:
  D.26500 = last_ins->opcode;
  if (D.26500 != 325) goto <D.26621>; else goto <D.26622>;
  <D.26621>:
  iftmp.71 = 1;
  goto <D.26623>;
  <D.26622>:
  iftmp.71 = 0;
  <D.26623>:
  D.26627 = iftmp.71 != 0;
  D.26628 = (long int) D.26627;
  D.26629 = __builtin_expect (D.26628, 0);
  if (D.26629 != 0) goto <D.26630>; else goto <D.26631>;
  <D.26630>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 2972, "ins_is_compare(last_ins)");
  <D.26631>:
  {
    int s1;
    int s2;

    s1 = last_ins->sreg2;
    s2 = last_ins->sreg1;
    last_ins->opcode = 871;
    last_ins->sreg1 = s1;
    last_ins->sreg2 = s2;
  }
  D.26632 = mono_alloc_ireg (cfg);
  D.26633 = (int) D.26632;
  last_ins->dreg = D.26633;
  {
    int s1;
    int s2;

    s1 = last_ins->dreg;
    s2 = 0;
    ins->opcode = 847;
    ins->sreg1 = s1;
    ins->sreg2 = s2;
  }
  goto <D.22556>;
  <D.22632>:
  <D.22633>:
  if (last_ins == 0B) goto <D.26635>; else goto <D.26638>;
  <D.26638>:
  D.26500 = last_ins->opcode;
  if (D.26500 != 322) goto <D.26639>; else goto <D.26636>;
  <D.26639>:
  D.26500 = last_ins->opcode;
  if (D.26500 != 326) goto <D.26640>; else goto <D.26636>;
  <D.26640>:
  D.26500 = last_ins->opcode;
  if (D.26500 != 325) goto <D.26635>; else goto <D.26636>;
  <D.26635>:
  iftmp.72 = 1;
  goto <D.26637>;
  <D.26636>:
  iftmp.72 = 0;
  <D.26637>:
  D.26641 = iftmp.72 != 0;
  D.26642 = (long int) D.26641;
  D.26643 = __builtin_expect (D.26642, 0);
  if (D.26643 != 0) goto <D.26644>; else goto <D.26645>;
  <D.26644>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 2980, "ins_is_compare(last_ins)");
  <D.26645>:
  last_ins->opcode = 574;
  D.26646 = mono_alloc_ireg (cfg);
  D.26647 = (int) D.26646;
  last_ins->dreg = D.26647;
  {
    int s1;

    s1 = last_ins->dreg;
    ins->opcode = 870;
    ins->sreg1 = s1;
    ins->data.op[1].const_val = 1;
  }
  goto <D.22556>;
  <D.22635>:
  <D.22636>:
  {
    int s1;
    int s2;

    s1 = last_ins->sreg1;
    s2 = last_ins->sreg2;
    ins->opcode = 869;
    ins->sreg1 = s1;
    ins->sreg2 = s2;
  }
  last_ins->opcode = 316;
  last_ins->dreg = -1;
  last_ins->sreg3 = -1;
  D.26508 = last_ins->sreg3;
  last_ins->sreg2 = D.26508;
  D.26509 = last_ins->sreg2;
  last_ins->sreg1 = D.26509;
  goto <D.22556>;
  <D.22639>:
  <D.22640>:
  {
    int s1;
    int s2;

    s1 = last_ins->sreg1;
    s2 = last_ins->sreg2;
    ins->opcode = 871;
    ins->sreg1 = s1;
    ins->sreg2 = s2;
  }
  last_ins->opcode = 316;
  last_ins->dreg = -1;
  last_ins->sreg3 = -1;
  D.26508 = last_ins->sreg3;
  last_ins->sreg2 = D.26508;
  D.26509 = last_ins->sreg2;
  last_ins->sreg1 = D.26509;
  goto <D.22556>;
  <D.22643>:
  <D.22644>:
  if (last_ins == 0B) goto <D.26649>; else goto <D.26652>;
  <D.26652>:
  D.26500 = last_ins->opcode;
  if (D.26500 != 322) goto <D.26653>; else goto <D.26650>;
  <D.26653>:
  D.26500 = last_ins->opcode;
  if (D.26500 != 326) goto <D.26654>; else goto <D.26650>;
  <D.26654>:
  D.26500 = last_ins->opcode;
  if (D.26500 != 325) goto <D.26649>; else goto <D.26650>;
  <D.26649>:
  iftmp.73 = 1;
  goto <D.26651>;
  <D.26650>:
  iftmp.73 = 0;
  <D.26651>:
  D.26655 = iftmp.73 != 0;
  D.26656 = (long int) D.26655;
  D.26657 = __builtin_expect (D.26656, 0);
  if (D.26657 != 0) goto <D.26658>; else goto <D.26659>;
  <D.26658>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 3001, "ins_is_compare(last_ins)");
  <D.26659>:
  {
    int s1;
    int s2;

    s1 = last_ins->sreg2;
    s2 = last_ins->sreg1;
    ins->opcode = 869;
    ins->sreg1 = s1;
    ins->sreg2 = s2;
  }
  D.26660 = last_ins->prev;
  if (D.26660 != 0B) goto <D.26661>; else goto <D.26662>;
  <D.26661>:
  D.26660 = last_ins->prev;
  D.26663 = last_ins->next;
  D.26660->next = D.26663;
  <D.26662>:
  D.26663 = last_ins->next;
  if (D.26663 != 0B) goto <D.26664>; else goto <D.26665>;
  <D.26664>:
  D.26663 = last_ins->next;
  D.26660 = last_ins->prev;
  D.26663->prev = D.26660;
  <D.26665>:
  D.26666 = bb->code;
  if (D.26666 == last_ins) goto <D.26667>; else goto <D.26668>;
  <D.26667>:
  D.26663 = last_ins->next;
  bb->code = D.26663;
  <D.26668>:
  D.26669 = bb->last_ins;
  if (D.26669 == last_ins) goto <D.26670>; else goto <D.26671>;
  <D.26670>:
  D.26660 = last_ins->prev;
  bb->last_ins = D.26660;
  <D.26671>:
  last_ins->opcode = 316;
  last_ins->dreg = -1;
  last_ins->sreg3 = -1;
  D.26508 = last_ins->sreg3;
  last_ins->sreg2 = D.26508;
  D.26509 = last_ins->sreg2;
  last_ins->sreg1 = D.26509;
  goto <D.22556>;
  <D.22647>:
  <D.22648>:
  if (last_ins == 0B) goto <D.26673>; else goto <D.26676>;
  <D.26676>:
  D.26500 = last_ins->opcode;
  if (D.26500 != 322) goto <D.26677>; else goto <D.26674>;
  <D.26677>:
  D.26500 = last_ins->opcode;
  if (D.26500 != 326) goto <D.26678>; else goto <D.26674>;
  <D.26678>:
  D.26500 = last_ins->opcode;
  if (D.26500 != 325) goto <D.26673>; else goto <D.26674>;
  <D.26673>:
  iftmp.74 = 1;
  goto <D.26675>;
  <D.26674>:
  iftmp.74 = 0;
  <D.26675>:
  D.26679 = iftmp.74 != 0;
  D.26680 = (long int) D.26679;
  D.26681 = __builtin_expect (D.26680, 0);
  if (D.26681 != 0) goto <D.26682>; else goto <D.26683>;
  <D.26682>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 3008, "ins_is_compare(last_ins)");
  <D.26683>:
  {
    int s1;
    int s2;

    s1 = last_ins->sreg2;
    s2 = last_ins->sreg1;
    ins->opcode = 871;
    ins->sreg1 = s1;
    ins->sreg2 = s2;
  }
  D.26660 = last_ins->prev;
  if (D.26660 != 0B) goto <D.26684>; else goto <D.26685>;
  <D.26684>:
  D.26660 = last_ins->prev;
  D.26663 = last_ins->next;
  D.26660->next = D.26663;
  <D.26685>:
  D.26663 = last_ins->next;
  if (D.26663 != 0B) goto <D.26686>; else goto <D.26687>;
  <D.26686>:
  D.26663 = last_ins->next;
  D.26660 = last_ins->prev;
  D.26663->prev = D.26660;
  <D.26687>:
  D.26666 = bb->code;
  if (D.26666 == last_ins) goto <D.26688>; else goto <D.26689>;
  <D.26688>:
  D.26663 = last_ins->next;
  bb->code = D.26663;
  <D.26689>:
  D.26669 = bb->last_ins;
  if (D.26669 == last_ins) goto <D.26690>; else goto <D.26691>;
  <D.26690>:
  D.26660 = last_ins->prev;
  bb->last_ins = D.26660;
  <D.26691>:
  last_ins->opcode = 316;
  last_ins->dreg = -1;
  last_ins->sreg3 = -1;
  D.26508 = last_ins->sreg3;
  last_ins->sreg2 = D.26508;
  D.26509 = last_ins->sreg2;
  last_ins->sreg1 = D.26509;
  goto <D.22556>;
  <D.22651>:
  <D.22652>:
  if (last_ins == 0B) goto <D.26693>; else goto <D.26696>;
  <D.26696>:
  D.26500 = last_ins->opcode;
  if (D.26500 != 322) goto <D.26697>; else goto <D.26694>;
  <D.26697>:
  D.26500 = last_ins->opcode;
  if (D.26500 != 326) goto <D.26698>; else goto <D.26694>;
  <D.26698>:
  D.26500 = last_ins->opcode;
  if (D.26500 != 325) goto <D.26693>; else goto <D.26694>;
  <D.26693>:
  iftmp.75 = 1;
  goto <D.26695>;
  <D.26694>:
  iftmp.75 = 0;
  <D.26695>:
  D.26699 = iftmp.75 != 0;
  D.26700 = (long int) D.26699;
  D.26701 = __builtin_expect (D.26700, 0);
  if (D.26701 != 0) goto <D.26702>; else goto <D.26703>;
  <D.26702>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 3015, "ins_is_compare(last_ins)");
  <D.26703>:
  {
    int s1;
    int s2;

    s1 = last_ins->sreg1;
    s2 = last_ins->sreg2;
    ins->opcode = 872;
    ins->sreg1 = s1;
    ins->sreg2 = s2;
  }
  D.26660 = last_ins->prev;
  if (D.26660 != 0B) goto <D.26704>; else goto <D.26705>;
  <D.26704>:
  D.26660 = last_ins->prev;
  D.26663 = last_ins->next;
  D.26660->next = D.26663;
  <D.26705>:
  D.26663 = last_ins->next;
  if (D.26663 != 0B) goto <D.26706>; else goto <D.26707>;
  <D.26706>:
  D.26663 = last_ins->next;
  D.26660 = last_ins->prev;
  D.26663->prev = D.26660;
  <D.26707>:
  D.26666 = bb->code;
  if (D.26666 == last_ins) goto <D.26708>; else goto <D.26709>;
  <D.26708>:
  D.26663 = last_ins->next;
  bb->code = D.26663;
  <D.26709>:
  D.26669 = bb->last_ins;
  if (D.26669 == last_ins) goto <D.26710>; else goto <D.26711>;
  <D.26710>:
  D.26660 = last_ins->prev;
  bb->last_ins = D.26660;
  <D.26711>:
  last_ins->opcode = 316;
  last_ins->dreg = -1;
  last_ins->sreg3 = -1;
  D.26508 = last_ins->sreg3;
  last_ins->sreg2 = D.26508;
  D.26509 = last_ins->sreg2;
  last_ins->sreg1 = D.26509;
  goto <D.22556>;
  <D.22655>:
  <D.22656>:
  if (last_ins == 0B) goto <D.26713>; else goto <D.26716>;
  <D.26716>:
  D.26500 = last_ins->opcode;
  if (D.26500 != 322) goto <D.26717>; else goto <D.26714>;
  <D.26717>:
  D.26500 = last_ins->opcode;
  if (D.26500 != 326) goto <D.26718>; else goto <D.26714>;
  <D.26718>:
  D.26500 = last_ins->opcode;
  if (D.26500 != 325) goto <D.26713>; else goto <D.26714>;
  <D.26713>:
  iftmp.76 = 1;
  goto <D.26715>;
  <D.26714>:
  iftmp.76 = 0;
  <D.26715>:
  D.26719 = iftmp.76 != 0;
  D.26720 = (long int) D.26719;
  D.26721 = __builtin_expect (D.26720, 0);
  if (D.26721 != 0) goto <D.26722>; else goto <D.26723>;
  <D.26722>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 3022, "ins_is_compare(last_ins)");
  <D.26723>:
  {
    int s1;
    int s2;

    s1 = last_ins->sreg1;
    s2 = last_ins->sreg2;
    ins->opcode = 873;
    ins->sreg1 = s1;
    ins->sreg2 = s2;
  }
  D.26660 = last_ins->prev;
  if (D.26660 != 0B) goto <D.26724>; else goto <D.26725>;
  <D.26724>:
  D.26660 = last_ins->prev;
  D.26663 = last_ins->next;
  D.26660->next = D.26663;
  <D.26725>:
  D.26663 = last_ins->next;
  if (D.26663 != 0B) goto <D.26726>; else goto <D.26727>;
  <D.26726>:
  D.26663 = last_ins->next;
  D.26660 = last_ins->prev;
  D.26663->prev = D.26660;
  <D.26727>:
  D.26666 = bb->code;
  if (D.26666 == last_ins) goto <D.26728>; else goto <D.26729>;
  <D.26728>:
  D.26663 = last_ins->next;
  bb->code = D.26663;
  <D.26729>:
  D.26669 = bb->last_ins;
  if (D.26669 == last_ins) goto <D.26730>; else goto <D.26731>;
  <D.26730>:
  D.26660 = last_ins->prev;
  bb->last_ins = D.26660;
  <D.26731>:
  last_ins->opcode = 316;
  last_ins->dreg = -1;
  last_ins->sreg3 = -1;
  D.26508 = last_ins->sreg3;
  last_ins->sreg2 = D.26508;
  D.26509 = last_ins->sreg2;
  last_ins->sreg1 = D.26509;
  goto <D.22556>;
  <D.22659>:
  <D.22660>:
  if (last_ins == 0B) goto <D.26733>; else goto <D.26736>;
  <D.26736>:
  D.26500 = last_ins->opcode;
  if (D.26500 != 322) goto <D.26737>; else goto <D.26734>;
  <D.26737>:
  D.26500 = last_ins->opcode;
  if (D.26500 != 326) goto <D.26738>; else goto <D.26734>;
  <D.26738>:
  D.26500 = last_ins->opcode;
  if (D.26500 != 325) goto <D.26733>; else goto <D.26734>;
  <D.26733>:
  iftmp.77 = 1;
  goto <D.26735>;
  <D.26734>:
  iftmp.77 = 0;
  <D.26735>:
  D.26739 = iftmp.77 != 0;
  D.26740 = (long int) D.26739;
  D.26741 = __builtin_expect (D.26740, 0);
  if (D.26741 != 0) goto <D.26742>; else goto <D.26743>;
  <D.26742>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 3029, "ins_is_compare(last_ins)");
  <D.26743>:
  {
    int s1;
    int s2;

    s1 = last_ins->sreg1;
    s2 = last_ins->sreg2;
    ins->opcode = 874;
    ins->sreg1 = s1;
    ins->sreg2 = s2;
  }
  D.26660 = last_ins->prev;
  if (D.26660 != 0B) goto <D.26744>; else goto <D.26745>;
  <D.26744>:
  D.26660 = last_ins->prev;
  D.26663 = last_ins->next;
  D.26660->next = D.26663;
  <D.26745>:
  D.26663 = last_ins->next;
  if (D.26663 != 0B) goto <D.26746>; else goto <D.26747>;
  <D.26746>:
  D.26663 = last_ins->next;
  D.26660 = last_ins->prev;
  D.26663->prev = D.26660;
  <D.26747>:
  D.26666 = bb->code;
  if (D.26666 == last_ins) goto <D.26748>; else goto <D.26749>;
  <D.26748>:
  D.26663 = last_ins->next;
  bb->code = D.26663;
  <D.26749>:
  D.26669 = bb->last_ins;
  if (D.26669 == last_ins) goto <D.26750>; else goto <D.26751>;
  <D.26750>:
  D.26660 = last_ins->prev;
  bb->last_ins = D.26660;
  <D.26751>:
  last_ins->opcode = 316;
  last_ins->dreg = -1;
  last_ins->sreg3 = -1;
  D.26508 = last_ins->sreg3;
  last_ins->sreg2 = D.26508;
  D.26509 = last_ins->sreg2;
  last_ins->sreg1 = D.26509;
  goto <D.22556>;
  <D.22663>:
  <D.22664>:
  if (last_ins == 0B) goto <D.26753>; else goto <D.26756>;
  <D.26756>:
  D.26500 = last_ins->opcode;
  if (D.26500 != 322) goto <D.26757>; else goto <D.26754>;
  <D.26757>:
  D.26500 = last_ins->opcode;
  if (D.26500 != 326) goto <D.26758>; else goto <D.26754>;
  <D.26758>:
  D.26500 = last_ins->opcode;
  if (D.26500 != 325) goto <D.26753>; else goto <D.26754>;
  <D.26753>:
  iftmp.78 = 1;
  goto <D.26755>;
  <D.26754>:
  iftmp.78 = 0;
  <D.26755>:
  D.26759 = iftmp.78 != 0;
  D.26760 = (long int) D.26759;
  D.26761 = __builtin_expect (D.26760, 0);
  if (D.26761 != 0) goto <D.26762>; else goto <D.26763>;
  <D.26762>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 3036, "ins_is_compare(last_ins)");
  <D.26763>:
  {
    int s1;
    int s2;

    s1 = last_ins->sreg1;
    s2 = last_ins->sreg2;
    ins->opcode = 875;
    ins->sreg1 = s1;
    ins->sreg2 = s2;
  }
  D.26660 = last_ins->prev;
  if (D.26660 != 0B) goto <D.26764>; else goto <D.26765>;
  <D.26764>:
  D.26660 = last_ins->prev;
  D.26663 = last_ins->next;
  D.26660->next = D.26663;
  <D.26765>:
  D.26663 = last_ins->next;
  if (D.26663 != 0B) goto <D.26766>; else goto <D.26767>;
  <D.26766>:
  D.26663 = last_ins->next;
  D.26660 = last_ins->prev;
  D.26663->prev = D.26660;
  <D.26767>:
  D.26666 = bb->code;
  if (D.26666 == last_ins) goto <D.26768>; else goto <D.26769>;
  <D.26768>:
  D.26663 = last_ins->next;
  bb->code = D.26663;
  <D.26769>:
  D.26669 = bb->last_ins;
  if (D.26669 == last_ins) goto <D.26770>; else goto <D.26771>;
  <D.26770>:
  D.26660 = last_ins->prev;
  bb->last_ins = D.26660;
  <D.26771>:
  last_ins->opcode = 316;
  last_ins->dreg = -1;
  last_ins->sreg3 = -1;
  D.26508 = last_ins->sreg3;
  last_ins->sreg2 = D.26508;
  D.26509 = last_ins->sreg2;
  last_ins->sreg1 = D.26509;
  goto <D.22556>;
  <D.22667>:
  <D.22668>:
  if (last_ins == 0B) goto <D.26773>; else goto <D.26776>;
  <D.26776>:
  D.26500 = last_ins->opcode;
  if (D.26500 != 322) goto <D.26777>; else goto <D.26774>;
  <D.26777>:
  D.26500 = last_ins->opcode;
  if (D.26500 != 326) goto <D.26778>; else goto <D.26774>;
  <D.26778>:
  D.26500 = last_ins->opcode;
  if (D.26500 != 325) goto <D.26773>; else goto <D.26774>;
  <D.26773>:
  iftmp.79 = 1;
  goto <D.26775>;
  <D.26774>:
  iftmp.79 = 0;
  <D.26775>:
  D.26779 = iftmp.79 != 0;
  D.26780 = (long int) D.26779;
  D.26781 = __builtin_expect (D.26780, 0);
  if (D.26781 != 0) goto <D.26782>; else goto <D.26783>;
  <D.26782>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 3043, "ins_is_compare(last_ins)");
  <D.26783>:
  {
    int s1;
    int s2;

    s1 = last_ins->sreg1;
    s2 = last_ins->sreg2;
    ins->opcode = 876;
    ins->sreg1 = s1;
    ins->sreg2 = s2;
  }
  D.26660 = last_ins->prev;
  if (D.26660 != 0B) goto <D.26784>; else goto <D.26785>;
  <D.26784>:
  D.26660 = last_ins->prev;
  D.26663 = last_ins->next;
  D.26660->next = D.26663;
  <D.26785>:
  D.26663 = last_ins->next;
  if (D.26663 != 0B) goto <D.26786>; else goto <D.26787>;
  <D.26786>:
  D.26663 = last_ins->next;
  D.26660 = last_ins->prev;
  D.26663->prev = D.26660;
  <D.26787>:
  D.26666 = bb->code;
  if (D.26666 == last_ins) goto <D.26788>; else goto <D.26789>;
  <D.26788>:
  D.26663 = last_ins->next;
  bb->code = D.26663;
  <D.26789>:
  D.26669 = bb->last_ins;
  if (D.26669 == last_ins) goto <D.26790>; else goto <D.26791>;
  <D.26790>:
  D.26660 = last_ins->prev;
  bb->last_ins = D.26660;
  <D.26791>:
  last_ins->opcode = 316;
  last_ins->dreg = -1;
  last_ins->sreg3 = -1;
  D.26508 = last_ins->sreg3;
  last_ins->sreg2 = D.26508;
  D.26509 = last_ins->sreg2;
  last_ins->sreg1 = D.26509;
  goto <D.22556>;
  <D.22671>:
  <D.22672>:
  if (last_ins == 0B) goto <D.26793>; else goto <D.26796>;
  <D.26796>:
  D.26500 = last_ins->opcode;
  if (D.26500 != 322) goto <D.26797>; else goto <D.26794>;
  <D.26797>:
  D.26500 = last_ins->opcode;
  if (D.26500 != 326) goto <D.26798>; else goto <D.26794>;
  <D.26798>:
  D.26500 = last_ins->opcode;
  if (D.26500 != 325) goto <D.26793>; else goto <D.26794>;
  <D.26793>:
  iftmp.80 = 1;
  goto <D.26795>;
  <D.26794>:
  iftmp.80 = 0;
  <D.26795>:
  D.26799 = iftmp.80 != 0;
  D.26800 = (long int) D.26799;
  D.26801 = __builtin_expect (D.26800, 0);
  if (D.26801 != 0) goto <D.26802>; else goto <D.26803>;
  <D.26802>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 3050, "ins_is_compare(last_ins)");
  <D.26803>:
  {
    int s1;
    int s2;

    s1 = last_ins->sreg1;
    s2 = last_ins->sreg2;
    ins->opcode = 877;
    ins->sreg1 = s1;
    ins->sreg2 = s2;
  }
  D.26660 = last_ins->prev;
  if (D.26660 != 0B) goto <D.26804>; else goto <D.26805>;
  <D.26804>:
  D.26660 = last_ins->prev;
  D.26663 = last_ins->next;
  D.26660->next = D.26663;
  <D.26805>:
  D.26663 = last_ins->next;
  if (D.26663 != 0B) goto <D.26806>; else goto <D.26807>;
  <D.26806>:
  D.26663 = last_ins->next;
  D.26660 = last_ins->prev;
  D.26663->prev = D.26660;
  <D.26807>:
  D.26666 = bb->code;
  if (D.26666 == last_ins) goto <D.26808>; else goto <D.26809>;
  <D.26808>:
  D.26663 = last_ins->next;
  bb->code = D.26663;
  <D.26809>:
  D.26669 = bb->last_ins;
  if (D.26669 == last_ins) goto <D.26810>; else goto <D.26811>;
  <D.26810>:
  D.26660 = last_ins->prev;
  bb->last_ins = D.26660;
  <D.26811>:
  last_ins->opcode = 316;
  last_ins->dreg = -1;
  last_ins->sreg3 = -1;
  D.26508 = last_ins->sreg3;
  last_ins->sreg2 = D.26508;
  D.26509 = last_ins->sreg2;
  last_ins->sreg1 = D.26509;
  goto <D.22556>;
  <D.22675>:
  <D.22676>:
  if (last_ins == 0B) goto <D.26813>; else goto <D.26816>;
  <D.26816>:
  D.26500 = last_ins->opcode;
  if (D.26500 != 322) goto <D.26817>; else goto <D.26814>;
  <D.26817>:
  D.26500 = last_ins->opcode;
  if (D.26500 != 326) goto <D.26818>; else goto <D.26814>;
  <D.26818>:
  D.26500 = last_ins->opcode;
  if (D.26500 != 325) goto <D.26813>; else goto <D.26814>;
  <D.26813>:
  iftmp.81 = 1;
  goto <D.26815>;
  <D.26814>:
  iftmp.81 = 0;
  <D.26815>:
  D.26819 = iftmp.81 != 0;
  D.26820 = (long int) D.26819;
  D.26821 = __builtin_expect (D.26820, 0);
  if (D.26821 != 0) goto <D.26822>; else goto <D.26823>;
  <D.26822>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 3057, "ins_is_compare(last_ins)");
  <D.26823>:
  {
    int s1;
    int s2;

    s1 = last_ins->sreg1;
    s2 = last_ins->sreg2;
    ins->opcode = 878;
    ins->sreg1 = s1;
    ins->sreg2 = s2;
  }
  D.26660 = last_ins->prev;
  if (D.26660 != 0B) goto <D.26824>; else goto <D.26825>;
  <D.26824>:
  D.26660 = last_ins->prev;
  D.26663 = last_ins->next;
  D.26660->next = D.26663;
  <D.26825>:
  D.26663 = last_ins->next;
  if (D.26663 != 0B) goto <D.26826>; else goto <D.26827>;
  <D.26826>:
  D.26663 = last_ins->next;
  D.26660 = last_ins->prev;
  D.26663->prev = D.26660;
  <D.26827>:
  D.26666 = bb->code;
  if (D.26666 == last_ins) goto <D.26828>; else goto <D.26829>;
  <D.26828>:
  D.26663 = last_ins->next;
  bb->code = D.26663;
  <D.26829>:
  D.26669 = bb->last_ins;
  if (D.26669 == last_ins) goto <D.26830>; else goto <D.26831>;
  <D.26830>:
  D.26660 = last_ins->prev;
  bb->last_ins = D.26660;
  <D.26831>:
  last_ins->opcode = 316;
  last_ins->dreg = -1;
  last_ins->sreg3 = -1;
  D.26508 = last_ins->sreg3;
  last_ins->sreg2 = D.26508;
  D.26509 = last_ins->sreg2;
  last_ins->sreg1 = D.26509;
  goto <D.22556>;
  <D.22679>:
  <D.22680>:
  if (last_ins == 0B) goto <D.26833>; else goto <D.26836>;
  <D.26836>:
  D.26500 = last_ins->opcode;
  if (D.26500 != 322) goto <D.26837>; else goto <D.26834>;
  <D.26837>:
  D.26500 = last_ins->opcode;
  if (D.26500 != 326) goto <D.26838>; else goto <D.26834>;
  <D.26838>:
  D.26500 = last_ins->opcode;
  if (D.26500 != 325) goto <D.26833>; else goto <D.26834>;
  <D.26833>:
  iftmp.82 = 1;
  goto <D.26835>;
  <D.26834>:
  iftmp.82 = 0;
  <D.26835>:
  D.26839 = iftmp.82 != 0;
  D.26840 = (long int) D.26839;
  D.26841 = __builtin_expect (D.26840, 0);
  if (D.26841 != 0) goto <D.26842>; else goto <D.26843>;
  <D.26842>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 3064, "ins_is_compare(last_ins)");
  <D.26843>:
  {
    int s1;
    int s2;

    s1 = last_ins->sreg1;
    s2 = last_ins->sreg2;
    ins->opcode = 879;
    ins->sreg1 = s1;
    ins->sreg2 = s2;
  }
  D.26660 = last_ins->prev;
  if (D.26660 != 0B) goto <D.26844>; else goto <D.26845>;
  <D.26844>:
  D.26660 = last_ins->prev;
  D.26663 = last_ins->next;
  D.26660->next = D.26663;
  <D.26845>:
  D.26663 = last_ins->next;
  if (D.26663 != 0B) goto <D.26846>; else goto <D.26847>;
  <D.26846>:
  D.26663 = last_ins->next;
  D.26660 = last_ins->prev;
  D.26663->prev = D.26660;
  <D.26847>:
  D.26666 = bb->code;
  if (D.26666 == last_ins) goto <D.26848>; else goto <D.26849>;
  <D.26848>:
  D.26663 = last_ins->next;
  bb->code = D.26663;
  <D.26849>:
  D.26669 = bb->last_ins;
  if (D.26669 == last_ins) goto <D.26850>; else goto <D.26851>;
  <D.26850>:
  D.26660 = last_ins->prev;
  bb->last_ins = D.26660;
  <D.26851>:
  last_ins->opcode = 316;
  last_ins->dreg = -1;
  last_ins->sreg3 = -1;
  D.26508 = last_ins->sreg3;
  last_ins->sreg2 = D.26508;
  D.26509 = last_ins->sreg2;
  last_ins->sreg1 = D.26509;
  goto <D.22556>;
  <D.22683>:
  <D.22684>:
  if (last_ins == 0B) goto <D.26853>; else goto <D.26856>;
  <D.26856>:
  D.26500 = last_ins->opcode;
  if (D.26500 != 322) goto <D.26857>; else goto <D.26854>;
  <D.26857>:
  D.26500 = last_ins->opcode;
  if (D.26500 != 326) goto <D.26858>; else goto <D.26854>;
  <D.26858>:
  D.26500 = last_ins->opcode;
  if (D.26500 != 325) goto <D.26853>; else goto <D.26854>;
  <D.26853>:
  iftmp.83 = 1;
  goto <D.26855>;
  <D.26854>:
  iftmp.83 = 0;
  <D.26855>:
  D.26859 = iftmp.83 != 0;
  D.26860 = (long int) D.26859;
  D.26861 = __builtin_expect (D.26860, 0);
  if (D.26861 != 0) goto <D.26862>; else goto <D.26863>;
  <D.26862>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 3071, "ins_is_compare(last_ins)");
  <D.26863>:
  {
    int s1;
    int s2;

    s1 = last_ins->sreg1;
    s2 = last_ins->sreg2;
    ins->opcode = 880;
    ins->sreg1 = s1;
    ins->sreg2 = s2;
  }
  D.26660 = last_ins->prev;
  if (D.26660 != 0B) goto <D.26864>; else goto <D.26865>;
  <D.26864>:
  D.26660 = last_ins->prev;
  D.26663 = last_ins->next;
  D.26660->next = D.26663;
  <D.26865>:
  D.26663 = last_ins->next;
  if (D.26663 != 0B) goto <D.26866>; else goto <D.26867>;
  <D.26866>:
  D.26663 = last_ins->next;
  D.26660 = last_ins->prev;
  D.26663->prev = D.26660;
  <D.26867>:
  D.26666 = bb->code;
  if (D.26666 == last_ins) goto <D.26868>; else goto <D.26869>;
  <D.26868>:
  D.26663 = last_ins->next;
  bb->code = D.26663;
  <D.26869>:
  D.26669 = bb->last_ins;
  if (D.26669 == last_ins) goto <D.26870>; else goto <D.26871>;
  <D.26870>:
  D.26660 = last_ins->prev;
  bb->last_ins = D.26660;
  <D.26871>:
  last_ins->opcode = 316;
  last_ins->dreg = -1;
  last_ins->sreg3 = -1;
  D.26508 = last_ins->sreg3;
  last_ins->sreg2 = D.26508;
  D.26509 = last_ins->sreg2;
  last_ins->sreg1 = D.26509;
  goto <D.22556>;
  <D.22687>:
  <D.22688>:
  if (last_ins == 0B) goto <D.26873>; else goto <D.26876>;
  <D.26876>:
  D.26500 = last_ins->opcode;
  if (D.26500 != 322) goto <D.26877>; else goto <D.26874>;
  <D.26877>:
  D.26500 = last_ins->opcode;
  if (D.26500 != 326) goto <D.26878>; else goto <D.26874>;
  <D.26878>:
  D.26500 = last_ins->opcode;
  if (D.26500 != 325) goto <D.26873>; else goto <D.26874>;
  <D.26873>:
  iftmp.84 = 1;
  goto <D.26875>;
  <D.26874>:
  iftmp.84 = 0;
  <D.26875>:
  D.26879 = iftmp.84 != 0;
  D.26880 = (long int) D.26879;
  D.26881 = __builtin_expect (D.26880, 0);
  if (D.26881 != 0) goto <D.26882>; else goto <D.26883>;
  <D.26882>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 3078, "ins_is_compare(last_ins)");
  <D.26883>:
  {
    int s1;
    int s2;

    s1 = last_ins->sreg1;
    s2 = last_ins->sreg2;
    ins->opcode = 881;
    ins->sreg1 = s1;
    ins->sreg2 = s2;
  }
  D.26660 = last_ins->prev;
  if (D.26660 != 0B) goto <D.26884>; else goto <D.26885>;
  <D.26884>:
  D.26660 = last_ins->prev;
  D.26663 = last_ins->next;
  D.26660->next = D.26663;
  <D.26885>:
  D.26663 = last_ins->next;
  if (D.26663 != 0B) goto <D.26886>; else goto <D.26887>;
  <D.26886>:
  D.26663 = last_ins->next;
  D.26660 = last_ins->prev;
  D.26663->prev = D.26660;
  <D.26887>:
  D.26666 = bb->code;
  if (D.26666 == last_ins) goto <D.26888>; else goto <D.26889>;
  <D.26888>:
  D.26663 = last_ins->next;
  bb->code = D.26663;
  <D.26889>:
  D.26669 = bb->last_ins;
  if (D.26669 == last_ins) goto <D.26890>; else goto <D.26891>;
  <D.26890>:
  D.26660 = last_ins->prev;
  bb->last_ins = D.26660;
  <D.26891>:
  last_ins->opcode = 316;
  last_ins->dreg = -1;
  last_ins->sreg3 = -1;
  D.26508 = last_ins->sreg3;
  last_ins->sreg2 = D.26508;
  D.26509 = last_ins->sreg2;
  last_ins->sreg1 = D.26509;
  goto <D.22556>;
  <D.22691>:
  <D.22692>:
  {
    int tmp1;
    int tmp2;
    int tmp3;
    int tmp4;
    int tmp5;
    struct MonoInst * pos;

    pos = last_ins;
    D.26500 = last_ins->opcode;
    D.26892 = D.26500 != 619;
    D.26893 = (long int) D.26892;
    D.26894 = __builtin_expect (D.26893, 0);
    if (D.26894 != 0) goto <D.26895>; else goto <D.26896>;
    <D.26895>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 3098, "last_ins->opcode == OP_IADC");
    <D.26896>:
    D.26897 = mono_alloc_ireg (cfg);
    tmp1 = (int) D.26897;
    D.26898 = mono_alloc_ireg (cfg);
    tmp2 = (int) D.26898;
    D.26899 = mono_alloc_ireg (cfg);
    tmp3 = (int) D.26899;
    D.26900 = mono_alloc_ireg (cfg);
    tmp4 = (int) D.26900;
    D.26901 = mono_alloc_ireg (cfg);
    tmp5 = (int) D.26901;
    {
      struct MonoInst * temp;

      D.26387 = cfg->mempool;
      temp = mono_mempool_alloc (D.26387, 56);
      temp->data.op[1].const_val = 0;
      D.26902 = temp->data.op[1].const_val;
      temp->data.op[0].const_val = D.26902;
      temp->prev = 0B;
      D.26903 = temp->prev;
      temp->next = D.26903;
      temp->opcode = 574;
      temp->flags = 0;
      temp->type = 0;
      temp->dreg = -1;
      temp->sreg3 = -1;
      D.26904 = temp->sreg3;
      temp->sreg2 = D.26904;
      D.26905 = temp->sreg2;
      temp->sreg1 = D.26905;
      D.26392 = cfg->ip;
      temp->cil_code = D.26392;
      mono_bblock_insert_after_ins (bb, pos, temp);
      temp->dreg = tmp1;
      D.26906 = last_ins->sreg1;
      temp->sreg1 = D.26906;
      D.26509 = last_ins->sreg2;
      temp->sreg2 = D.26509;
      pos = temp;
    }
    {
      struct MonoInst * temp;

      D.26387 = cfg->mempool;
      temp = mono_mempool_alloc (D.26387, 56);
      temp->data.op[1].const_val = 0;
      D.26907 = temp->data.op[1].const_val;
      temp->data.op[0].const_val = D.26907;
      temp->prev = 0B;
      D.26908 = temp->prev;
      temp->next = D.26908;
      temp->opcode = 574;
      temp->flags = 0;
      temp->type = 0;
      temp->dreg = -1;
      temp->sreg3 = -1;
      D.26909 = temp->sreg3;
      temp->sreg2 = D.26909;
      D.26910 = temp->sreg2;
      temp->sreg1 = D.26910;
      D.26392 = cfg->ip;
      temp->cil_code = D.26392;
      mono_bblock_insert_after_ins (bb, pos, temp);
      temp->dreg = tmp2;
      D.26911 = last_ins->dreg;
      temp->sreg1 = D.26911;
      D.26509 = last_ins->sreg2;
      temp->sreg2 = D.26509;
      pos = temp;
    }
    {
      struct MonoInst * temp;

      D.26387 = cfg->mempool;
      temp = mono_mempool_alloc (D.26387, 56);
      temp->data.op[1].const_val = 0;
      D.26912 = temp->data.op[1].const_val;
      temp->data.op[0].const_val = D.26912;
      temp->prev = 0B;
      D.26913 = temp->prev;
      temp->next = D.26913;
      temp->opcode = 579;
      temp->flags = 0;
      temp->type = 0;
      temp->dreg = -1;
      temp->sreg3 = -1;
      D.26914 = temp->sreg3;
      temp->sreg2 = D.26914;
      D.26915 = temp->sreg2;
      temp->sreg1 = D.26915;
      D.26392 = cfg->ip;
      temp->cil_code = D.26392;
      mono_bblock_insert_after_ins (bb, pos, temp);
      temp->dreg = tmp3;
      temp->sreg1 = tmp2;
      temp->sreg2 = -1;
      pos = temp;
    }
    {
      struct MonoInst * temp;

      D.26387 = cfg->mempool;
      temp = mono_mempool_alloc (D.26387, 56);
      temp->data.op[1].const_val = 0;
      D.26916 = temp->data.op[1].const_val;
      temp->data.op[0].const_val = D.26916;
      temp->prev = 0B;
      D.26917 = temp->prev;
      temp->next = D.26917;
      temp->opcode = 573;
      temp->flags = 0;
      temp->type = 0;
      temp->dreg = -1;
      temp->sreg3 = -1;
      D.26918 = temp->sreg3;
      temp->sreg2 = D.26918;
      D.26919 = temp->sreg2;
      temp->sreg1 = D.26919;
      D.26392 = cfg->ip;
      temp->cil_code = D.26392;
      mono_bblock_insert_after_ins (bb, pos, temp);
      temp->dreg = tmp4;
      temp->sreg1 = tmp3;
      temp->sreg2 = tmp1;
      pos = temp;
    }
    {
      struct MonoInst * temp;

      D.26387 = cfg->mempool;
      temp = mono_mempool_alloc (D.26387, 56);
      temp->data.op[1].const_val = 0;
      D.26920 = temp->data.op[1].const_val;
      temp->data.op[0].const_val = D.26920;
      temp->prev = 0B;
      D.26921 = temp->prev;
      temp->next = D.26921;
      temp->opcode = 440;
      temp->flags = 0;
      temp->type = 0;
      temp->dreg = -1;
      temp->sreg3 = -1;
      D.26922 = temp->sreg3;
      temp->sreg2 = D.26922;
      D.26923 = temp->sreg2;
      temp->sreg1 = D.26923;
      D.26392 = cfg->ip;
      temp->cil_code = D.26392;
      mono_bblock_insert_after_ins (bb, pos, temp);
      temp->dreg = tmp5;
      temp->sreg1 = tmp4;
      temp->data.op[0].const_val = 31;
      pos = temp;
    }
    {
      int s1;
      int s2;

      s1 = tmp5;
      s2 = 0;
      ins->opcode = 872;
      ins->sreg1 = s1;
      ins->sreg2 = s2;
    }
    ins->dreg = -1;
    goto <D.22556>;
  }
  <D.22706>:
  <D.22707>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-mips.c", 3125);
  <D.22708>:
  <D.22709>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-mips.c", 3130);
  <D.22710>:
  <D.22711>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-mips.c", 3135);
  <D.26924>:
  <D.22556>:
  last_ins = ins;
  ins = ins->next;
  <D.22713>:
  if (ins != 0B) goto <D.22712>; else goto <D.22714>;
  <D.22714>:
  bb->last_ins = last_ins;
  D.26925 = cfg->next_vreg;
  bb->max_vreg = D.26925;
  D.26343 = cfg->verbose_level;
  if (D.26343 > 2) goto <D.26926>; else goto <D.26927>;
  <D.26926>:
  {
    int idx;

    idx = 0;
    D.26346 = bb->block_num;
    monoeg_g_print ("BASIC BLOCK %d (after lowering)\n", D.26346);
    ins = bb->code;
    goto <D.22717>;
    <D.22716>:
    idx.85 = idx;
    idx = idx.85 + 1;
    mono_print_ins_index (idx.85, ins);
    ins = ins->next;
    <D.22717>:
    if (ins != 0B) goto <D.22716>; else goto <D.22718>;
    <D.22718>:
  }
  <D.26927>:
}


map_to_reg_reg_op (int op)
{
  int D.26929;

  switch (op) <default: <D.26930>, case 323: <D.22489>, case 327: <D.22490>, case 328: <D.22491>, case 374: <D.22511>, case 375: <D.22508>, case 376: <D.22509>, case 377: <D.22510>, case 379: <D.22512>, case 380: <D.22513>, case 381: <D.22514>, case 382: <D.22515>, case 383: <D.22516>, case 384: <D.22517>, case 385: <D.22518>, case 388: <D.22499>, case 389: <D.22505>, case 390: <D.22502>, case 391: <D.22503>, case 392: <D.22504>, case 393: <D.22500>, case 394: <D.22501>, case 396: <D.22506>, case 397: <D.22507>, case 429: <D.22486>, case 430: <D.22487>, case 431: <D.22498>, case 436: <D.22488>, case 437: <D.22496>, case 438: <D.22497>, case 752: <D.22493>, case 754: <D.22495>, case 756: <D.22492>, case 758: <D.22494>>
  <D.22486>:
  D.26929 = 565;
  return D.26929;
  <D.22487>:
  D.26929 = 566;
  return D.26929;
  <D.22488>:
  D.26929 = 572;
  return D.26929;
  <D.22489>:
  D.26929 = 322;
  return D.26929;
  <D.22490>:
  D.26929 = 326;
  return D.26929;
  <D.22491>:
  D.26929 = 325;
  return D.26929;
  <D.22492>:
  D.26929 = 623;
  return D.26929;
  <D.22493>:
  D.26929 = 619;
  return D.26929;
  <D.22494>:
  D.26929 = 624;
  return D.26929;
  <D.22495>:
  D.26929 = 621;
  return D.26929;
  <D.22496>:
  D.26929 = 573;
  return D.26929;
  <D.22497>:
  D.26929 = 574;
  return D.26929;
  <D.22498>:
  D.26929 = 567;
  return D.26929;
  <D.22499>:
  D.26929 = 400;
  return D.26929;
  <D.22500>:
  D.26929 = 405;
  return D.26929;
  <D.22501>:
  D.26929 = 406;
  return D.26929;
  <D.22502>:
  D.26929 = 402;
  return D.26929;
  <D.22503>:
  D.26929 = 403;
  return D.26929;
  <D.22504>:
  D.26929 = 404;
  return D.26929;
  <D.22505>:
  D.26929 = 401;
  return D.26929;
  <D.22506>:
  D.26929 = 408;
  return D.26929;
  <D.22507>:
  D.26929 = 409;
  return D.26929;
  <D.22508>:
  D.26929 = 411;
  return D.26929;
  <D.22509>:
  D.26929 = 412;
  return D.26929;
  <D.22510>:
  D.26929 = 413;
  return D.26929;
  <D.22511>:
  D.26929 = 410;
  return D.26929;
  <D.22512>:
  D.26929 = 415;
  return D.26929;
  <D.22513>:
  D.26929 = 416;
  return D.26929;
  <D.22514>:
  D.26929 = 374;
  return D.26929;
  <D.22515>:
  D.26929 = 375;
  return D.26929;
  <D.22516>:
  D.26929 = 376;
  return D.26929;
  <D.22517>:
  D.26929 = 377;
  return D.26929;
  <D.22518>:
  D.26929 = 378;
  return D.26929;
  <D.26930>:
  D.26929 = mono_op_imm_to_op (op);
  return D.26929;
}


map_to_mips_op (int op)
{
  int D.26932;
  const char * D.26933;
  static const char __FUNCTION__[15] = "map_to_mips_op";

  switch (op) <default: <D.22537>, case 658: <D.22522>, case 659: <D.22523>, case 660: <D.22524>, case 661: <D.22525>, case 662: <D.22526>, case 663: <D.22527>, case 664: <D.22528>, case 665: <D.22529>, case 666: <D.22530>, case 667: <D.22531>, case 714: <D.22532>, case 715: <D.22533>, case 716: <D.22534>, case 717: <D.22535>, case 718: <D.22536>>
  <D.22522>:
  D.26932 = 849;
  return D.26932;
  <D.22523>:
  D.26932 = 850;
  return D.26932;
  <D.22524>:
  D.26932 = 852;
  return D.26932;
  <D.22525>:
  D.26932 = 854;
  return D.26932;
  <D.22526>:
  D.26932 = 856;
  return D.26932;
  <D.22527>:
  D.26932 = 858;
  return D.26932;
  <D.22528>:
  D.26932 = 851;
  return D.26932;
  <D.22529>:
  D.26932 = 853;
  return D.26932;
  <D.22530>:
  D.26932 = 855;
  return D.26932;
  <D.22531>:
  D.26932 = 857;
  return D.26932;
  <D.22532>:
  <D.22533>:
  <D.22534>:
  <D.22535>:
  <D.22536>:
  <D.22537>:
  D.26933 = mono_inst_name (op);
  monoeg_g_log (0B, 16, "unknown opcode %s in %s()\n", D.26933, &__FUNCTION__);
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-mips.c", 2642);
}


mono_arch_output_basic_block (struct MonoCompile * cfg, struct MonoBasicBlock * bb)
{
  unsigned char * D.26935;
  unsigned int D.26936;
  unsigned int D.26937;
  int D.26940;
  int D.26941;
  int code.86;
  int D.26943;
  int D.26944;
  short unsigned int D.26945;
  int D.26946;
  int D.26947;
  short unsigned int D.26948;
  sizetype D.26949;
  sizetype D.26950;
  guint8 * D.26951;
  unsigned char D.26952;
  unsigned int D.26953;
  unsigned int max_len.87;
  unsigned int D.26955;
  unsigned int D.26956;
  unsigned int D.26959;
  void * D.26960;
  int ins_cnt.88;
  int D.26964;
  unsigned int D.26965;
  unsigned int D.26966;
  _Bool D.26967;
  long int D.26968;
  long int D.26969;
  unsigned char D.26972;
  int D.26973;
  int D.26974;
  void * ss_trigger_page.89;
  short int D.26978;
  int D.26979;
  int addr.90;
  unsigned int D.26983;
  unsigned int D.26986;
  unsigned int D.26987;
  unsigned int D.26988;
  unsigned int D.26989;
  unsigned int D.26991;
  unsigned int D.26992;
  unsigned int D.26995;
  unsigned int D.26997;
  int D.26998;
  int D.26999;
  int D.27000;
  int D.27001;
  int D.27002;
  int D.27003;
  unsigned int D.27004;
  int D.27005;
  int D.27006;
  unsigned int D.27007;
  int D.27008;
  int D.27009;
  int D.27010;
  unsigned int D.27011;
  int D.27012;
  unsigned int D.27013;
  int D.27014;
  short int D.27015;
  int D.27016;
  unsigned int D.27019;
  unsigned int D.27020;
  unsigned int D.27023;
  unsigned int D.27024;
  unsigned int D.27025;
  unsigned int D.27026;
  unsigned int D.27028;
  unsigned int D.27029;
  unsigned int D.27032;
  unsigned int D.27034;
  int D.27035;
  short int D.27036;
  int D.27037;
  int D.27040;
  int D.27041;
  int D.27042;
  int D.27043;
  unsigned int D.27044;
  unsigned int D.27048;
  unsigned int D.27049;
  unsigned int D.27052;
  unsigned int D.27053;
  unsigned int D.27054;
  unsigned int D.27055;
  unsigned int D.27057;
  unsigned int D.27058;
  unsigned int D.27061;
  unsigned int D.27063;
  int D.27064;
  int D.27065;
  unsigned int D.27066;
  int D.27077;
  int D.27078;
  unsigned int D.27079;
  int D.27089;
  unsigned int D.27090;
  int D.27101;
  int D.27102;
  unsigned int D.27103;
  int D.27113;
  unsigned int D.27114;
  int D.27125;
  int D.27126;
  unsigned int D.27127;
  int D.27137;
  unsigned int D.27138;
  int D.27141;
  int D.27142;
  int D.27143;
  int D.27144;
  unsigned int D.27145;
  int D.27155;
  int D.27156;
  unsigned int D.27157;
  int D.27158;
  unsigned int D.27159;
  int D.27162;
  int D.27163;
  int D.27164;
  unsigned int D.27165;
  int D.27175;
  unsigned int D.27176;
  int D.27179;
  int D.27180;
  int D.27181;
  unsigned int D.27182;
  int D.27192;
  unsigned int D.27193;
  int D.27196;
  int D.27197;
  int D.27198;
  unsigned int D.27199;
  int D.27209;
  unsigned int D.27210;
  int D.27213;
  int D.27214;
  int D.27215;
  unsigned int D.27216;
  int D.27226;
  unsigned int D.27227;
  int D.27228;
  unsigned int D.27229;
  _Bool D.27230;
  long int D.27231;
  long int D.27232;
  int D.27237;
  int D.27238;
  int D.27239;
  unsigned int D.27240;
  int D.27250;
  unsigned int D.27251;
  int D.27254;
  int D.27255;
  int D.27256;
  unsigned int D.27257;
  int D.27267;
  unsigned int D.27268;
  int D.27271;
  int D.27272;
  int D.27273;
  unsigned int D.27274;
  int D.27284;
  unsigned int D.27285;
  int D.27288;
  int D.27289;
  int D.27290;
  unsigned int D.27291;
  int D.27301;
  unsigned int D.27302;
  int D.27305;
  int D.27306;
  int D.27307;
  unsigned int D.27308;
  int D.27318;
  unsigned int D.27319;
  int D.27320;
  unsigned int D.27321;
  int D.27322;
  unsigned int D.27323;
  int D.27324;
  unsigned int D.27325;
  int D.27326;
  unsigned int D.27327;
  int D.27328;
  int D.27329;
  int D.27330;
  unsigned int D.27331;
  int D.27332;
  unsigned int D.27333;
  int D.27334;
  int D.27335;
  unsigned int D.27336;
  _Bool D.27337;
  long int D.27338;
  long int D.27339;
  int D.27342;
  int D.27343;
  int D.27344;
  int D.27345;
  unsigned int D.27346;
  int D.27347;
  unsigned int D.27348;
  int D.27351;
  int D.27352;
  int D.27353;
  unsigned int D.27354;
  int D.27358;
  unsigned int D.27359;
  int D.27360;
  unsigned int D.27361;
  int D.27364;
  int D.27365;
  int D.27366;
  unsigned int D.27367;
  int D.27370;
  int D.27371;
  int D.27372;
  unsigned int D.27373;
  int D.27374;
  unsigned int D.27375;
  int D.27376;
  unsigned int D.27377;
  unsigned short D.27378;
  unsigned short D.27379;
  short int D.27380;
  int D.27381;
  int D.27382;
  _Bool D.27383;
  long int D.27384;
  long int D.27385;
  int D.27388;
  int D.27389;
  unsigned int D.27390;
  int D.27393;
  unsigned int D.27394;
  int D.27395;
  unsigned int D.27396;
  unsigned int D.27397;
  _Bool D.27398;
  long int D.27399;
  long int D.27400;
  int D.27403;
  unsigned int D.27404;
  int D.27413;
  int D.27414;
  unsigned int D.27415;
  int D.27416;
  unsigned int D.27417;
  struct MonoBasicBlock * D.27418;
  int D.27419;
  int D.27420;
  unsigned int code.91;
  int D.27422;
  unsigned int D.27423;
  int D.27424;
  unsigned int D.27425;
  int D.27429;
  unsigned int D.27430;
  int D.27431;
  unsigned int D.27432;
  int D.27436;
  unsigned int D.27437;
  int D.27440;
  int D.27441;
  int D.27442;
  unsigned int D.27443;
  int D.27444;
  unsigned int D.27445;
  int D.27448;
  int D.27449;
  int D.27450;
  unsigned int D.27451;
  int D.27452;
  int D.27453;
  int D.27454;
  unsigned int D.27455;
  int D.27456;
  int D.27457;
  int D.27458;
  int D.27459;
  unsigned int D.27460;
  int D.27461;
  unsigned int D.27462;
  int D.27463;
  unsigned int D.27464;
  int D.27465;
  unsigned int D.27466;
  int D.27467;
  int D.27468;
  int D.27469;
  int D.27470;
  unsigned int D.27471;
  int D.27472;
  unsigned int D.27473;
  int D.27474;
  unsigned int D.27475;
  int D.27476;
  unsigned int D.27477;
  int D.27478;
  unsigned int D.27479;
  int D.27480;
  unsigned int D.27481;
  int D.27482;
  unsigned int D.27483;
  int D.27484;
  unsigned int D.27485;
  int D.27486;
  unsigned int D.27487;
  unsigned int D.27492;
  unsigned int D.27493;
  unsigned int D.27494;
  unsigned int D.27496;
  unsigned int D.27497;
  int D.27500;
  int D.27501;
  unsigned int D.27502;
  unsigned int D.27503;
  unsigned int D.27505;
  unsigned int D.27506;
  int offset.92;
  struct MonoInst * D.27508;
  <unnamed type> D.27509;
  void * D.27510;
  unsigned int D.27513;
  int D.27515;
  unsigned int D.27516;
  int D.27517;
  int D.27518;
  unsigned int D.27519;
  int D.27520;
  int D.27521;
  unsigned int D.27522;
  int D.27523;
  int D.27524;
  int D.27525;
  unsigned int D.27526;
  int D.27527;
  int D.27528;
  int D.27529;
  unsigned int D.27530;
  int ls_word_idx.93;
  int D.27532;
  int D.27533;
  int D.27534;
  unsigned int D.27535;
  int D.27536;
  int D.27537;
  int ms_word_idx.94;
  int D.27539;
  int D.27540;
  int D.27541;
  unsigned int D.27542;
  int D.27545;
  int D.27546;
  unsigned int D.27547;
  int D.27552;
  unsigned int D.27553;
  int D.27556;
  int D.27557;
  int D.27558;
  unsigned int D.27559;
  int D.27560;
  int D.27561;
  unsigned int D.27562;
  int D.27568;
  int D.27569;
  unsigned int D.27570;
  int D.27573;
  int D.27574;
  int D.27575;
  unsigned int D.27576;
  int D.27577;
  unsigned int D.27578;
  unsigned int D.27584;
  int D.27585;
  short int D.27586;
  int D.27587;
  _Bool D.27588;
  long int D.27589;
  long int D.27590;
  unsigned int D.27593;
  unsigned int D.27594;
  unsigned int D.27595;
  unsigned int D.27596;
  unsigned int D.27597;
  unsigned int D.27598;
  int D.27599;
  unsigned int D.27600;
  struct MonoMethod * D.27603;
  unsigned int D.27604;
  unsigned int D.27605;
  unsigned int D.27608;
  unsigned int D.27609;
  unsigned int D.27610;
  unsigned int D.27611;
  unsigned int D.27613;
  unsigned int D.27614;
  unsigned int D.27615;
  const void * D.27617;
  unsigned int D.27618;
  unsigned int D.27619;
  unsigned int D.27622;
  unsigned int D.27623;
  unsigned int D.27624;
  unsigned int D.27625;
  unsigned int D.27627;
  unsigned int D.27628;
  unsigned int D.27629;
  int D.27630;
  unsigned int D.27631;
  int D.27632;
  int D.27633;
  unsigned int D.27634;
  struct MonoMethodSignature * D.27636;
  struct MonoType * D.27637;
  unsigned char D.27638;
  unsigned int D.27641;
  int D.27642;
  unsigned int D.27643;
  short int D.27644;
  int D.27645;
  _Bool D.27646;
  long int D.27647;
  long int D.27648;
  int D.27651;
  int D.27652;
  int D.27653;
  unsigned int D.27654;
  int D.27657;
  unsigned int D.27658;
  int D.27659;
  unsigned int D.27660;
  short int D.27663;
  int D.27664;
  int _target.95;
  unsigned int D.27668;
  unsigned int D.27671;
  unsigned int D.27672;
  unsigned int D.27673;
  unsigned int D.27674;
  unsigned int D.27676;
  unsigned int D.27677;
  unsigned int D.27680;
  unsigned int D.27682;
  unsigned int D.27684;
  unsigned int D.27685;
  unsigned int D.27686;
  short int D.27689;
  int D.27690;
  int _target.96;
  unsigned int D.27694;
  unsigned int D.27697;
  unsigned int D.27698;
  unsigned int D.27699;
  unsigned int D.27700;
  unsigned int D.27702;
  unsigned int D.27703;
  unsigned int D.27706;
  unsigned int D.27708;
  unsigned int D.27710;
  unsigned int D.27711;
  unsigned int D.27712;
  unsigned int D.27713;
  int D.27714;
  int D.27715;
  _Bool D.27716;
  long int D.27717;
  long int D.27718;
  int D.27721;
  short int D.27722;
  int D.27723;
  int D.27726;
  int D.27727;
  int D.27728;
  int D.27729;
  unsigned int D.27730;
  unsigned int D.27734;
  unsigned int D.27735;
  unsigned int D.27738;
  unsigned int D.27739;
  unsigned int D.27740;
  unsigned int D.27741;
  unsigned int D.27743;
  unsigned int D.27744;
  unsigned int D.27747;
  unsigned int D.27749;
  int D.27750;
  int D.27751;
  unsigned int D.27752;
  int D.27753;
  _Bool D.27754;
  long int D.27755;
  long int D.27756;
  int D.27761;
  unsigned int D.27762;
  int D.27763;
  short int D.27764;
  int D.27765;
  int D.27768;
  int D.27769;
  int D.27770;
  int D.27771;
  unsigned int D.27772;
  unsigned int D.27776;
  unsigned int D.27777;
  unsigned int D.27780;
  unsigned int D.27781;
  unsigned int D.27782;
  unsigned int D.27783;
  unsigned int D.27785;
  unsigned int D.27786;
  unsigned int D.27789;
  unsigned int D.27791;
  int D.27792;
  int D.27793;
  unsigned int D.27794;
  int D.27795;
  _Bool D.27796;
  long int D.27797;
  long int D.27798;
  int D.27801;
  int D.27802;
  int D.27803;
  int D.27804;
  int D.27805;
  unsigned int D.27806;
  struct MonoBasicBlock * D.27807;
  struct MonoExceptionClause * D.27808;
  unsigned int D.27809;
  int D.27813;
  unsigned int D.27814;
  struct MonoClass * D.27815;
  int D.27816;
  int D.27817;
  unsigned int D.27820;
  void * D.27821;
  _Bool D.27822;
  long int D.27823;
  long int D.27824;
  int D.27827;
  unsigned int D.27828;
  int D.27834;
  unsigned int D.27835;
  int D.27836;
  unsigned int D.27837;
  int D.27838;
  int D.27839;
  unsigned int D.27840;
  int D.27841;
  int D.27842;
  unsigned int D.27843;
  int D.27844;
  unsigned int D.27845;
  int D.27846;
  unsigned int D.27847;
  int D.27848;
  unsigned int D.27849;
  int D.27850;
  unsigned int D.27851;
  const char * D.27852;
  void * D.27853;
  int D.27854;
  int D.27855;
  short int D.27856;
  int D.27857;
  unsigned int D.27860;
  unsigned int D.27861;
  unsigned int D.27864;
  unsigned int D.27865;
  unsigned int D.27866;
  unsigned int D.27867;
  unsigned int D.27869;
  unsigned int D.27870;
  unsigned int D.27873;
  unsigned int D.27875;
  int D.27876;
  int ls_word_offset.97;
  int D.27878;
  int D.27879;
  unsigned int D.27880;
  int D.27881;
  int ms_word_offset.98;
  int D.27883;
  int D.27884;
  unsigned int D.27885;
  unsigned int D.27889;
  unsigned int D.27890;
  int D.27891;
  int D.27892;
  int D.27893;
  unsigned int D.27894;
  int D.27897;
  int D.27898;
  int D.27899;
  int D.27900;
  int D.27901;
  unsigned int D.27902;
  int D.27903;
  int D.27904;
  int D.27905;
  int D.27906;
  int D.27907;
  int D.27908;
  unsigned int D.27909;
  int D.27919;
  int D.27920;
  unsigned int D.27921;
  int D.27922;
  int D.27923;
  unsigned int D.27924;
  int D.27927;
  int D.27928;
  int D.27929;
  unsigned int D.27930;
  int D.27931;
  int D.27932;
  unsigned int D.27933;
  _Bool D.27943;
  long int D.27944;
  long int D.27945;
  int D.27948;
  unsigned int D.27949;
  int D.27950;
  int D.27951;
  unsigned int D.27952;
  int D.27955;
  unsigned int D.27956;
  int D.27959;
  unsigned int D.27960;
  unsigned int D.27961;
  int D.27962;
  int D.27963;
  unsigned int D.27964;
  int D.27965;
  unsigned int D.27966;
  int D.27967;
  unsigned int D.27968;
  int D.27969;
  unsigned int D.27970;
  unsigned int adjust_val.99;
  unsigned int D.27972;
  unsigned int D.27975;
  unsigned int D.27976;
  unsigned int D.27977;
  unsigned int D.27978;
  unsigned int D.27980;
  unsigned int D.27981;
  unsigned int D.27982;
  int D.27983;
  int D.27984;
  unsigned int D.27985;
  int D.27986;
  unsigned int D.27987;
  int D.27988;
  unsigned int D.27989;
  int D.27990;
  int D.27991;
  int D.27992;
  unsigned int D.27993;
  int D.27994;
  unsigned int D.27995;
  int D.27996;
  unsigned int D.27997;
  int D.27998;
  unsigned int D.27999;
  int D.28000;
  unsigned int D.28001;
  int D.28002;
  unsigned int D.28003;
  int D.28004;
  unsigned int D.28005;
  int D.28006;
  unsigned int D.28007;
  int D.28008;
  unsigned int D.28009;
  int D.28010;
  unsigned int D.28011;
  int D.28014;
  unsigned int D.28015;
  int D.28016;
  int D.28017;
  unsigned int D.28018;
  struct MonoBasicBlock * * D.28019;
  struct MonoBasicBlock * D.28020;
  int D.28026;
  int D.28027;
  unsigned int D.28028;
  <unnamed type> D.28029;
  unsigned int D.28032;
  unsigned int D.28034;
  unsigned int D.28035;
  const char * D.28036;
  unsigned int D.28037;
  unsigned int D.28038;
  unsigned int D.28041;
  unsigned int D.28042;
  const char * D.28045;
  struct MonoInst * ins;
  struct MonoCallInst * call;
  guint offset;
  guint8 * code;
  struct MonoInst * last_ins;
  guint last_offset;
  int max_len;
  int cpos;
  int ins_cnt;
  static const char __FUNCTION__[29] = "mono_arch_output_basic_block";

  D.26935 = cfg->native_code;
  D.26936 = cfg->code_len;
  code = D.26935 + D.26936;
  last_ins = 0B;
  last_offset = 0;
  ins_cnt = 0;
  D.26937 = cfg->verbose_level;
  if (D.26937 > 2) goto <D.26938>; else goto <D.26939>;
  <D.26938>:
  D.26940 = bb->block_num;
  D.26941 = bb->native_offset;
  monoeg_g_print ("Basic block %d starting at offset 0x%x\n", D.26940, D.26941);
  <D.26939>:
  cpos = bb->max_offset;
  ins = bb->code;
  goto <D.23076>;
  <D.23075>:
  code.86 = (int) code;
  D.26935 = cfg->native_code;
  D.26943 = (int) D.26935;
  D.26944 = code.86 - D.26943;
  offset = (guint) D.26944;
  D.26945 = ins->opcode;
  D.26946 = (int) D.26945;
  D.26947 = D.26946 + -313;
  D.26948 = mips_desc_idx[D.26947];
  D.26949 = (sizetype) D.26948;
  D.26950 = D.26949 + 4;
  D.26951 = &mips_desc + D.26950;
  D.26952 = *D.26951;
  max_len = (int) D.26952;
  D.26953 = cfg->code_size;
  max_len.87 = (unsigned int) max_len;
  D.26955 = D.26953 - max_len.87;
  D.26956 = D.26955 + 4294967280;
  if (D.26956 < offset) goto <D.26957>; else goto <D.26958>;
  <D.26957>:
  D.26953 = cfg->code_size;
  D.26959 = D.26953 * 2;
  cfg->code_size = D.26959;
  D.26935 = cfg->native_code;
  D.26953 = cfg->code_size;
  D.26960 = monoeg_realloc (D.26935, D.26953);
  cfg->native_code = D.26960;
  D.26935 = cfg->native_code;
  code = D.26935 + offset;
  <D.26958>:
  mono_debug_record_line_number (cfg, ins, offset);
  D.26937 = cfg->verbose_level;
  if (D.26937 > 2) goto <D.26961>; else goto <D.26962>;
  <D.26961>:
  monoeg_g_print ("    @ 0x%x\t", offset);
  ins_cnt.88 = ins_cnt;
  ins_cnt = ins_cnt.88 + 1;
  mono_print_ins_index (ins_cnt.88, ins);
  <D.26962>:
  D.26964 = ins->dreg;
  D.26965 = (unsigned int) D.26964;
  D.26966 = D.26965 + 1;
  D.26967 = D.26966 > 32;
  D.26968 = (long int) D.26967;
  D.26969 = __builtin_expect (D.26968, 0);
  if (D.26969 != 0) goto <D.26970>; else goto <D.26971>;
  <D.26970>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 3380, "(ins->dreg >= -1) && (ins->dreg < 32)");
  <D.26971>:
  D.26945 = ins->opcode;
  D.26946 = (int) D.26945;
  switch (D.26946) <default: <D.23073>, case 316: <D.22777>, case 318: <D.22776>, case 337: <D.22880>, case 338: <D.22931>, case 340: <D.22887>, case 341: <D.22783>, case 343: <D.22893>, case 344: <D.22899>, case 345: <D.22905>, case 346: <D.22894>, case 347: <D.22900>, case 348: <D.22906>, case 349: <D.22889>, case 350: <D.22895>, case 351: <D.22901>, case 352: <D.22890>, case 353: <D.22896>, case 354: <D.22902>, case 355: <D.22891>, case 356: <D.22897>, case 357: <D.22903>, case 358: <D.22892>, case 359: <D.22898>, case 360: <D.22904>, case 362: <D.22870>, case 364: <D.23011>, case 365: <D.23010>, case 369: <D.22947>, case 370: <D.22950>, case 371: <D.22934>, case 372: <D.22937>, case 373: <D.22888>, case 374: <D.22796>, case 375: <D.22794>, case 376: <D.22795>, case 377: <D.22797>, case 378: <D.22798>, case 379: <D.23014>, case 380: <D.23012>, case 381: <D.22792>, case 382: <D.22789>, case 383: <D.22790>, case 384: <D.22793>, case 385: <D.22791>, case 388: <D.22801>, case 389: <D.22804>, case 390: <D.22805>, case 391: <D.22806>, case 392: <D.22807>, case 393: <D.22802>, case 394: <D.22803>, case 395: <D.22800>, case 396: <D.23016>, case 397: <D.23013>, case 408: <D.23017>, case 409: <D.23018>, case 415: <D.23019>, case 416: <D.23020>, case 421: <D.22799>, case 424: <D.22879>, case 426: <D.22883>, case 429: <D.22819>, case 430: <D.22825>, case 432: <D.22840>, case 434: <D.22841>, case 436: <D.22829>, case 437: <D.22843>, case 438: <D.22846>, case 439: <D.22849>, case 440: <D.22853>, case 441: <D.22856>, case 442: <D.22948>, case 443: <D.22886>, case 445: <D.22816>, case 446: <D.22955>, case 447: <D.22961>, case 448: <D.22962>, case 449: <D.22957>, case 450: <D.22958>, case 479: <D.22818>, case 480: <D.22823>, case 486: <D.22828>, case 490: <D.22852>, case 491: <D.22860>, case 492: <D.22864>, case 493: <D.22862>, case 538: <D.22821>, case 539: <D.22826>, case 541: <D.22831>, case 545: <D.22855>, case 546: <D.22858>, case 565: <D.22817>, case 566: <D.22822>, case 567: <D.22865>, case 568: <D.22832>, case 569: <D.22837>, case 570: <D.22833>, case 571: <D.22838>, case 572: <D.22827>, case 573: <D.22842>, case 574: <D.22845>, case 575: <D.22848>, case 576: <D.22851>, case 577: <D.22859>, case 578: <D.22863>, case 579: <D.22861>, case 580: <D.22808>, case 581: <D.22809>, case 582: <D.22877>, case 584: <D.23023>, case 585: <D.23024>, case 586: <D.22878>, case 588: <D.23021>, case 590: <D.22811>, case 591: <D.22810>, case 597: <D.22866>, case 598: <D.22868>, case 625: <D.22820>, case 626: <D.22824>, case 632: <D.22830>, case 633: <D.22844>, case 634: <D.22847>, case 635: <D.22850>, case 636: <D.22854>, case 637: <D.22857>, case 638: <D.22956>, case 639: <D.22963>, case 640: <D.22964>, case 641: <D.22959>, case 642: <D.22960>, case 668: <D.23034>, case 669: <D.23035>, case 670: <D.23036>, case 671: <D.23037>, case 675: <D.23038>, case 677: <D.23025>, case 678: <D.23027>, case 679: <D.23029>, case 681: <D.22885>, case 683: <D.23031>, case 685: <D.23028>, case 686: <D.23026>, case 687: <D.23030>, case 714: <D.23039>, case 715: <D.23042>, case 716: <D.23043>, case 717: <D.23040>, case 718: <D.23041>, case 727: <D.23032>, case 728: <D.23070>, case 731: <D.23072>, case 732: <D.22871>, case 735: <D.22946>, case 736: <D.22940>, case 737: <D.22942>, case 738: <D.22944>, case 739: <D.22786>, case 740: <D.22787>, case 759: <D.22949>, case 779: <D.23033>, case 791: <D.22785>, case 796: <D.22778>, case 797: <D.22779>, case 798: <D.22780>, case 799: <D.22781>, case 813: <D.22788>, case 842: <D.23004>, case 843: <D.23006>, case 844: <D.23007>, case 845: <D.23008>, case 846: <D.23009>, case 847: <D.23005>, case 848: <D.22884>, case 849: <D.23044>, case 850: <D.23050>, case 851: <D.23051>, case 852: <D.23048>, case 853: <D.23049>, case 854: <D.23052>, case 855: <D.23053>, case 856: <D.23046>, case 857: <D.23047>, case 858: <D.23045>, case 861: <D.23015>, case 862: <D.22872>, case 863: <D.22873>, case 864: <D.22874>, case 865: <D.22875>, case 866: <D.22876>, case 868: <D.22813>, case 869: <D.22812>, case 870: <D.22815>, case 871: <D.22814>, case 872: <D.22965>, case 873: <D.22966>, case 874: <D.22967>, case 875: <D.22968>, case 876: <D.22969>, case 877: <D.22970>, case 878: <D.22971>, case 879: <D.22972>, case 880: <D.22973>, case 881: <D.22974>, case 882: <D.22975>, case 883: <D.22976>, case 884: <D.22977>, case 885: <D.22978>, case 886: <D.22979>, case 887: <D.22980>, case 888: <D.22981>, case 889: <D.22982>, case 890: <D.22983>, case 891: <D.22984>, case 892: <D.22985>, case 893: <D.22986>, case 894: <D.22987>, case 895: <D.22988>, case 896: <D.22989>, case 897: <D.22990>, case 898: <D.22991>, case 899: <D.22992>>
  <D.22776>:
  <D.22777>:
  <D.22778>:
  <D.22779>:
  <D.22780>:
  <D.22781>:
  goto <D.22782>;
  <D.22783>:
  D.26972 = ins->flags;
  D.26973 = (int) D.26972;
  D.26974 = D.26973 & 1;
  if (D.26974 != 0) goto <D.26975>; else goto <D.26976>;
  <D.26975>:
  {
    guint32 addr;

    ss_trigger_page.89 = ss_trigger_page;
    addr = (guint32) ss_trigger_page.89;
    D.26978 = (short int) addr;
    D.26979 = (int) D.26978;
    addr.90 = (int) addr;
    if (D.26979 != addr.90) goto <D.26981>; else goto <D.26982>;
    <D.26981>:
    D.26983 = addr & 32768;
    if (D.26983 != 0) goto <D.26984>; else goto <D.26985>;
    <D.26984>:
    D.26986 = addr >> 16;
    D.26987 = D.26986 + 1;
    D.26988 = D.26987 & 65535;
    D.26989 = D.26988 | 1008271360;
    MEM[(guint32 *)code] = D.26989;
    code = code + 4;
    goto <D.26990>;
    <D.26985>:
    D.26986 = addr >> 16;
    D.26991 = D.26986 | 1008271360;
    MEM[(guint32 *)code] = D.26991;
    code = code + 4;
    <D.26990>:
    D.26992 = addr & 65535;
    if (D.26992 != 0) goto <D.26993>; else goto <D.26994>;
    <D.26993>:
    D.26992 = addr & 65535;
    D.26995 = D.26992 | 658046976;
    MEM[(guint32 *)code] = D.26995;
    code = code + 4;
    <D.26994>:
    goto <D.26996>;
    <D.26982>:
    D.26992 = addr & 65535;
    D.26997 = D.26992 | 605618176;
    MEM[(guint32 *)code] = D.26997;
    code = code + 4;
    <D.26996>:
    MEM[(guint32 *)code] = 2402877440;
    code = code + 4;
  }
  <D.26976>:
  code.86 = (int) code;
  D.26935 = cfg->native_code;
  D.26943 = (int) D.26935;
  D.26944 = code.86 - D.26943;
  mono_add_seq_point (cfg, bb, ins, D.26944);
  MEM[(guint32 *)code] = 2099237;
  code = code + 4;
  MEM[(guint32 *)code] = 2099237;
  code = code + 4;
  MEM[(guint32 *)code] = 2099237;
  code = code + 4;
  goto <D.22782>;
  <D.22785>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-mips.c", 3411);
  <D.22786>:
  D.26998 = ins->sreg1;
  D.26999 = D.26998 << 21;
  D.27000 = ins->sreg2;
  D.27001 = D.27000 << 16;
  D.27002 = D.26999 | D.27001;
  D.27003 = D.27002 | 24;
  D.27004 = (unsigned int) D.27003;
  MEM[(guint32 *)code] = D.27004;
  code = code + 4;
  D.26964 = ins->dreg;
  D.27005 = D.26964 << 11;
  D.27006 = D.27005 | 18;
  D.27007 = (unsigned int) D.27006;
  MEM[(guint32 *)code] = D.27007;
  code = code + 4;
  D.26964 = ins->dreg;
  D.27008 = D.26964 + 1;
  D.27009 = D.27008 << 11;
  D.27010 = D.27009 | 16;
  D.27011 = (unsigned int) D.27010;
  MEM[(guint32 *)code] = D.27011;
  code = code + 4;
  goto <D.22782>;
  <D.22787>:
  D.26998 = ins->sreg1;
  D.26999 = D.26998 << 21;
  D.27000 = ins->sreg2;
  D.27001 = D.27000 << 16;
  D.27002 = D.26999 | D.27001;
  D.27012 = D.27002 | 25;
  D.27013 = (unsigned int) D.27012;
  MEM[(guint32 *)code] = D.27013;
  code = code + 4;
  D.26964 = ins->dreg;
  D.27005 = D.26964 << 11;
  D.27006 = D.27005 | 18;
  D.27007 = (unsigned int) D.27006;
  MEM[(guint32 *)code] = D.27007;
  code = code + 4;
  D.26964 = ins->dreg;
  D.27008 = D.26964 + 1;
  D.27009 = D.27008 << 11;
  D.27010 = D.27009 | 16;
  D.27011 = (unsigned int) D.27010;
  MEM[(guint32 *)code] = D.27011;
  code = code + 4;
  goto <D.22782>;
  <D.22788>:
  goto <D.22782>;
  <D.22789>:
  D.27014 = ins->data.op[1].const_val;
  D.27015 = (short int) D.27014;
  D.27016 = (int) D.27015;
  D.27014 = ins->data.op[1].const_val;
  if (D.27016 != D.27014) goto <D.27017>; else goto <D.27018>;
  <D.27017>:
  D.27014 = ins->data.op[1].const_val;
  D.27019 = (unsigned int) D.27014;
  D.27020 = D.27019 & 32768;
  if (D.27020 != 0) goto <D.27021>; else goto <D.27022>;
  <D.27021>:
  D.27014 = ins->data.op[1].const_val;
  D.27019 = (unsigned int) D.27014;
  D.27023 = D.27019 >> 16;
  D.27024 = D.27023 + 1;
  D.27025 = D.27024 & 65535;
  D.27026 = D.27025 | 1008205824;
  MEM[(guint32 *)code] = D.27026;
  code = code + 4;
  goto <D.27027>;
  <D.27022>:
  D.27014 = ins->data.op[1].const_val;
  D.27019 = (unsigned int) D.27014;
  D.27023 = D.27019 >> 16;
  D.27028 = D.27023 | 1008205824;
  MEM[(guint32 *)code] = D.27028;
  code = code + 4;
  <D.27027>:
  D.27014 = ins->data.op[1].const_val;
  D.27019 = (unsigned int) D.27014;
  D.27029 = D.27019 & 65535;
  if (D.27029 != 0) goto <D.27030>; else goto <D.27031>;
  <D.27030>:
  D.27014 = ins->data.op[1].const_val;
  D.27019 = (unsigned int) D.27014;
  D.27029 = D.27019 & 65535;
  D.27032 = D.27029 | 655884288;
  MEM[(guint32 *)code] = D.27032;
  code = code + 4;
  <D.27031>:
  goto <D.27033>;
  <D.27018>:
  D.27014 = ins->data.op[1].const_val;
  D.27019 = (unsigned int) D.27014;
  D.27029 = D.27019 & 65535;
  D.27034 = D.27029 | 605552640;
  MEM[(guint32 *)code] = D.27034;
  code = code + 4;
  <D.27033>:
  D.27035 = ins->data.op[0].const_val;
  D.27036 = (short int) D.27035;
  D.27037 = (int) D.27036;
  D.27035 = ins->data.op[0].const_val;
  if (D.27037 == D.27035) goto <D.27038>; else goto <D.27039>;
  <D.27038>:
  D.26964 = ins->dreg;
  D.27040 = D.26964 << 21;
  D.27041 = D.27040 | -1609039872;
  D.27035 = ins->data.op[0].const_val;
  D.27042 = D.27035 & 65535;
  D.27043 = D.27041 | D.27042;
  D.27044 = (unsigned int) D.27043;
  MEM[(guint32 *)code] = D.27044;
  code = code + 4;
  goto <D.27045>;
  <D.27039>:
  D.27035 = ins->data.op[0].const_val;
  D.27036 = (short int) D.27035;
  D.27037 = (int) D.27036;
  D.27035 = ins->data.op[0].const_val;
  if (D.27037 != D.27035) goto <D.27046>; else goto <D.27047>;
  <D.27046>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27049 = D.27048 & 32768;
  if (D.27049 != 0) goto <D.27050>; else goto <D.27051>;
  <D.27050>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27052 = D.27048 >> 16;
  D.27053 = D.27052 + 1;
  D.27054 = D.27053 & 65535;
  D.27055 = D.27054 | 1006698496;
  MEM[(guint32 *)code] = D.27055;
  code = code + 4;
  goto <D.27056>;
  <D.27051>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27052 = D.27048 >> 16;
  D.27057 = D.27052 | 1006698496;
  MEM[(guint32 *)code] = D.27057;
  code = code + 4;
  <D.27056>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27058 = D.27048 & 65535;
  if (D.27058 != 0) goto <D.27059>; else goto <D.27060>;
  <D.27059>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27058 = D.27048 & 65535;
  D.27061 = D.27058 | 606142464;
  MEM[(guint32 *)code] = D.27061;
  code = code + 4;
  <D.27060>:
  goto <D.27062>;
  <D.27047>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27058 = D.27048 & 65535;
  D.27063 = D.27058 | 604045312;
  MEM[(guint32 *)code] = D.27063;
  code = code + 4;
  <D.27062>:
  D.26964 = ins->dreg;
  D.27064 = D.26964 & 65535;
  D.27065 = D.27064 | -1606942720;
  D.27066 = (unsigned int) D.27065;
  MEM[(guint32 *)code] = D.27066;
  code = code + 4;
  <D.27045>:
  goto <D.22782>;
  <D.22790>:
  D.27014 = ins->data.op[1].const_val;
  D.27015 = (short int) D.27014;
  D.27016 = (int) D.27015;
  D.27014 = ins->data.op[1].const_val;
  if (D.27016 != D.27014) goto <D.27067>; else goto <D.27068>;
  <D.27067>:
  D.27014 = ins->data.op[1].const_val;
  D.27019 = (unsigned int) D.27014;
  D.27020 = D.27019 & 32768;
  if (D.27020 != 0) goto <D.27069>; else goto <D.27070>;
  <D.27069>:
  D.27014 = ins->data.op[1].const_val;
  D.27019 = (unsigned int) D.27014;
  D.27023 = D.27019 >> 16;
  D.27024 = D.27023 + 1;
  D.27025 = D.27024 & 65535;
  D.27026 = D.27025 | 1008205824;
  MEM[(guint32 *)code] = D.27026;
  code = code + 4;
  goto <D.27071>;
  <D.27070>:
  D.27014 = ins->data.op[1].const_val;
  D.27019 = (unsigned int) D.27014;
  D.27023 = D.27019 >> 16;
  D.27028 = D.27023 | 1008205824;
  MEM[(guint32 *)code] = D.27028;
  code = code + 4;
  <D.27071>:
  D.27014 = ins->data.op[1].const_val;
  D.27019 = (unsigned int) D.27014;
  D.27029 = D.27019 & 65535;
  if (D.27029 != 0) goto <D.27072>; else goto <D.27073>;
  <D.27072>:
  D.27014 = ins->data.op[1].const_val;
  D.27019 = (unsigned int) D.27014;
  D.27029 = D.27019 & 65535;
  D.27032 = D.27029 | 655884288;
  MEM[(guint32 *)code] = D.27032;
  code = code + 4;
  <D.27073>:
  goto <D.27074>;
  <D.27068>:
  D.27014 = ins->data.op[1].const_val;
  D.27019 = (unsigned int) D.27014;
  D.27029 = D.27019 & 65535;
  D.27034 = D.27029 | 605552640;
  MEM[(guint32 *)code] = D.27034;
  code = code + 4;
  <D.27074>:
  D.27035 = ins->data.op[0].const_val;
  D.27036 = (short int) D.27035;
  D.27037 = (int) D.27036;
  D.27035 = ins->data.op[0].const_val;
  if (D.27037 == D.27035) goto <D.27075>; else goto <D.27076>;
  <D.27075>:
  D.26964 = ins->dreg;
  D.27040 = D.26964 << 21;
  D.27077 = D.27040 | -1541931008;
  D.27035 = ins->data.op[0].const_val;
  D.27042 = D.27035 & 65535;
  D.27078 = D.27077 | D.27042;
  D.27079 = (unsigned int) D.27078;
  MEM[(guint32 *)code] = D.27079;
  code = code + 4;
  goto <D.27080>;
  <D.27076>:
  D.27035 = ins->data.op[0].const_val;
  D.27036 = (short int) D.27035;
  D.27037 = (int) D.27036;
  D.27035 = ins->data.op[0].const_val;
  if (D.27037 != D.27035) goto <D.27081>; else goto <D.27082>;
  <D.27081>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27049 = D.27048 & 32768;
  if (D.27049 != 0) goto <D.27083>; else goto <D.27084>;
  <D.27083>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27052 = D.27048 >> 16;
  D.27053 = D.27052 + 1;
  D.27054 = D.27053 & 65535;
  D.27055 = D.27054 | 1006698496;
  MEM[(guint32 *)code] = D.27055;
  code = code + 4;
  goto <D.27085>;
  <D.27084>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27052 = D.27048 >> 16;
  D.27057 = D.27052 | 1006698496;
  MEM[(guint32 *)code] = D.27057;
  code = code + 4;
  <D.27085>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27058 = D.27048 & 65535;
  if (D.27058 != 0) goto <D.27086>; else goto <D.27087>;
  <D.27086>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27058 = D.27048 & 65535;
  D.27061 = D.27058 | 606142464;
  MEM[(guint32 *)code] = D.27061;
  code = code + 4;
  <D.27087>:
  goto <D.27088>;
  <D.27082>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27058 = D.27048 & 65535;
  D.27063 = D.27058 | 604045312;
  MEM[(guint32 *)code] = D.27063;
  code = code + 4;
  <D.27088>:
  D.26964 = ins->dreg;
  D.27064 = D.26964 & 65535;
  D.27089 = D.27064 | -1539833856;
  D.27090 = (unsigned int) D.27089;
  MEM[(guint32 *)code] = D.27090;
  code = code + 4;
  <D.27080>:
  goto <D.22782>;
  <D.22791>:
  D.27014 = ins->data.op[1].const_val;
  D.27015 = (short int) D.27014;
  D.27016 = (int) D.27015;
  D.27014 = ins->data.op[1].const_val;
  if (D.27016 != D.27014) goto <D.27091>; else goto <D.27092>;
  <D.27091>:
  D.27014 = ins->data.op[1].const_val;
  D.27019 = (unsigned int) D.27014;
  D.27020 = D.27019 & 32768;
  if (D.27020 != 0) goto <D.27093>; else goto <D.27094>;
  <D.27093>:
  D.27014 = ins->data.op[1].const_val;
  D.27019 = (unsigned int) D.27014;
  D.27023 = D.27019 >> 16;
  D.27024 = D.27023 + 1;
  D.27025 = D.27024 & 65535;
  D.27026 = D.27025 | 1008205824;
  MEM[(guint32 *)code] = D.27026;
  code = code + 4;
  goto <D.27095>;
  <D.27094>:
  D.27014 = ins->data.op[1].const_val;
  D.27019 = (unsigned int) D.27014;
  D.27023 = D.27019 >> 16;
  D.27028 = D.27023 | 1008205824;
  MEM[(guint32 *)code] = D.27028;
  code = code + 4;
  <D.27095>:
  D.27014 = ins->data.op[1].const_val;
  D.27019 = (unsigned int) D.27014;
  D.27029 = D.27019 & 65535;
  if (D.27029 != 0) goto <D.27096>; else goto <D.27097>;
  <D.27096>:
  D.27014 = ins->data.op[1].const_val;
  D.27019 = (unsigned int) D.27014;
  D.27029 = D.27019 & 65535;
  D.27032 = D.27029 | 655884288;
  MEM[(guint32 *)code] = D.27032;
  code = code + 4;
  <D.27097>:
  goto <D.27098>;
  <D.27092>:
  D.27014 = ins->data.op[1].const_val;
  D.27019 = (unsigned int) D.27014;
  D.27029 = D.27019 & 65535;
  D.27034 = D.27029 | 605552640;
  MEM[(guint32 *)code] = D.27034;
  code = code + 4;
  <D.27098>:
  D.27035 = ins->data.op[0].const_val;
  D.27036 = (short int) D.27035;
  D.27037 = (int) D.27036;
  D.27035 = ins->data.op[0].const_val;
  if (D.27037 == D.27035) goto <D.27099>; else goto <D.27100>;
  <D.27099>:
  D.26964 = ins->dreg;
  D.27040 = D.26964 << 21;
  D.27101 = D.27040 | -65536000;
  D.27035 = ins->data.op[0].const_val;
  D.27042 = D.27035 & 65535;
  D.27102 = D.27101 | D.27042;
  D.27103 = (unsigned int) D.27102;
  MEM[(guint32 *)code] = D.27103;
  code = code + 4;
  goto <D.27104>;
  <D.27100>:
  D.27035 = ins->data.op[0].const_val;
  D.27036 = (short int) D.27035;
  D.27037 = (int) D.27036;
  D.27035 = ins->data.op[0].const_val;
  if (D.27037 != D.27035) goto <D.27105>; else goto <D.27106>;
  <D.27105>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27049 = D.27048 & 32768;
  if (D.27049 != 0) goto <D.27107>; else goto <D.27108>;
  <D.27107>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27052 = D.27048 >> 16;
  D.27053 = D.27052 + 1;
  D.27054 = D.27053 & 65535;
  D.27055 = D.27054 | 1006698496;
  MEM[(guint32 *)code] = D.27055;
  code = code + 4;
  goto <D.27109>;
  <D.27108>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27052 = D.27048 >> 16;
  D.27057 = D.27052 | 1006698496;
  MEM[(guint32 *)code] = D.27057;
  code = code + 4;
  <D.27109>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27058 = D.27048 & 65535;
  if (D.27058 != 0) goto <D.27110>; else goto <D.27111>;
  <D.27110>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27058 = D.27048 & 65535;
  D.27061 = D.27058 | 606142464;
  MEM[(guint32 *)code] = D.27061;
  code = code + 4;
  <D.27111>:
  goto <D.27112>;
  <D.27106>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27058 = D.27048 & 65535;
  D.27063 = D.27058 | 604045312;
  MEM[(guint32 *)code] = D.27063;
  code = code + 4;
  <D.27112>:
  D.26964 = ins->dreg;
  D.27064 = D.26964 & 65535;
  D.27113 = D.27064 | -63438848;
  D.27114 = (unsigned int) D.27113;
  MEM[(guint32 *)code] = D.27114;
  code = code + 4;
  <D.27104>:
  goto <D.22782>;
  <D.22792>:
  <D.22793>:
  D.27014 = ins->data.op[1].const_val;
  D.27015 = (short int) D.27014;
  D.27016 = (int) D.27015;
  D.27014 = ins->data.op[1].const_val;
  if (D.27016 != D.27014) goto <D.27115>; else goto <D.27116>;
  <D.27115>:
  D.27014 = ins->data.op[1].const_val;
  D.27019 = (unsigned int) D.27014;
  D.27020 = D.27019 & 32768;
  if (D.27020 != 0) goto <D.27117>; else goto <D.27118>;
  <D.27117>:
  D.27014 = ins->data.op[1].const_val;
  D.27019 = (unsigned int) D.27014;
  D.27023 = D.27019 >> 16;
  D.27024 = D.27023 + 1;
  D.27025 = D.27024 & 65535;
  D.27026 = D.27025 | 1008205824;
  MEM[(guint32 *)code] = D.27026;
  code = code + 4;
  goto <D.27119>;
  <D.27118>:
  D.27014 = ins->data.op[1].const_val;
  D.27019 = (unsigned int) D.27014;
  D.27023 = D.27019 >> 16;
  D.27028 = D.27023 | 1008205824;
  MEM[(guint32 *)code] = D.27028;
  code = code + 4;
  <D.27119>:
  D.27014 = ins->data.op[1].const_val;
  D.27019 = (unsigned int) D.27014;
  D.27029 = D.27019 & 65535;
  if (D.27029 != 0) goto <D.27120>; else goto <D.27121>;
  <D.27120>:
  D.27014 = ins->data.op[1].const_val;
  D.27019 = (unsigned int) D.27014;
  D.27029 = D.27019 & 65535;
  D.27032 = D.27029 | 655884288;
  MEM[(guint32 *)code] = D.27032;
  code = code + 4;
  <D.27121>:
  goto <D.27122>;
  <D.27116>:
  D.27014 = ins->data.op[1].const_val;
  D.27019 = (unsigned int) D.27014;
  D.27029 = D.27019 & 65535;
  D.27034 = D.27029 | 605552640;
  MEM[(guint32 *)code] = D.27034;
  code = code + 4;
  <D.27122>:
  D.27035 = ins->data.op[0].const_val;
  D.27036 = (short int) D.27035;
  D.27037 = (int) D.27036;
  D.27035 = ins->data.op[0].const_val;
  if (D.27037 == D.27035) goto <D.27123>; else goto <D.27124>;
  <D.27123>:
  D.26964 = ins->dreg;
  D.27040 = D.26964 << 21;
  D.27125 = D.27040 | -1407713280;
  D.27035 = ins->data.op[0].const_val;
  D.27042 = D.27035 & 65535;
  D.27126 = D.27125 | D.27042;
  D.27127 = (unsigned int) D.27126;
  MEM[(guint32 *)code] = D.27127;
  code = code + 4;
  goto <D.27128>;
  <D.27124>:
  D.27035 = ins->data.op[0].const_val;
  D.27036 = (short int) D.27035;
  D.27037 = (int) D.27036;
  D.27035 = ins->data.op[0].const_val;
  if (D.27037 != D.27035) goto <D.27129>; else goto <D.27130>;
  <D.27129>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27049 = D.27048 & 32768;
  if (D.27049 != 0) goto <D.27131>; else goto <D.27132>;
  <D.27131>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27052 = D.27048 >> 16;
  D.27053 = D.27052 + 1;
  D.27054 = D.27053 & 65535;
  D.27055 = D.27054 | 1006698496;
  MEM[(guint32 *)code] = D.27055;
  code = code + 4;
  goto <D.27133>;
  <D.27132>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27052 = D.27048 >> 16;
  D.27057 = D.27052 | 1006698496;
  MEM[(guint32 *)code] = D.27057;
  code = code + 4;
  <D.27133>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27058 = D.27048 & 65535;
  if (D.27058 != 0) goto <D.27134>; else goto <D.27135>;
  <D.27134>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27058 = D.27048 & 65535;
  D.27061 = D.27058 | 606142464;
  MEM[(guint32 *)code] = D.27061;
  code = code + 4;
  <D.27135>:
  goto <D.27136>;
  <D.27130>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27058 = D.27048 & 65535;
  D.27063 = D.27058 | 604045312;
  MEM[(guint32 *)code] = D.27063;
  code = code + 4;
  <D.27136>:
  D.26964 = ins->dreg;
  D.27064 = D.26964 & 65535;
  D.27137 = D.27064 | -1405616128;
  D.27138 = (unsigned int) D.27137;
  MEM[(guint32 *)code] = D.27138;
  code = code + 4;
  <D.27128>:
  goto <D.22782>;
  <D.22794>:
  D.27035 = ins->data.op[0].const_val;
  D.27036 = (short int) D.27035;
  D.27037 = (int) D.27036;
  D.27035 = ins->data.op[0].const_val;
  if (D.27037 == D.27035) goto <D.27139>; else goto <D.27140>;
  <D.27139>:
  D.26964 = ins->dreg;
  D.27040 = D.26964 << 21;
  D.27141 = D.27040 | -1610612736;
  D.26998 = ins->sreg1;
  D.27142 = D.26998 << 16;
  D.27143 = D.27141 | D.27142;
  D.27035 = ins->data.op[0].const_val;
  D.27042 = D.27035 & 65535;
  D.27144 = D.27143 | D.27042;
  D.27145 = (unsigned int) D.27144;
  MEM[(guint32 *)code] = D.27145;
  code = code + 4;
  goto <D.27146>;
  <D.27140>:
  D.27035 = ins->data.op[0].const_val;
  D.27036 = (short int) D.27035;
  D.27037 = (int) D.27036;
  D.27035 = ins->data.op[0].const_val;
  if (D.27037 != D.27035) goto <D.27147>; else goto <D.27148>;
  <D.27147>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27049 = D.27048 & 32768;
  if (D.27049 != 0) goto <D.27149>; else goto <D.27150>;
  <D.27149>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27052 = D.27048 >> 16;
  D.27053 = D.27052 + 1;
  D.27054 = D.27053 & 65535;
  D.27055 = D.27054 | 1006698496;
  MEM[(guint32 *)code] = D.27055;
  code = code + 4;
  goto <D.27151>;
  <D.27150>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27052 = D.27048 >> 16;
  D.27057 = D.27052 | 1006698496;
  MEM[(guint32 *)code] = D.27057;
  code = code + 4;
  <D.27151>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27058 = D.27048 & 65535;
  if (D.27058 != 0) goto <D.27152>; else goto <D.27153>;
  <D.27152>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27058 = D.27048 & 65535;
  D.27061 = D.27058 | 606142464;
  MEM[(guint32 *)code] = D.27061;
  code = code + 4;
  <D.27153>:
  goto <D.27154>;
  <D.27148>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27058 = D.27048 & 65535;
  D.27063 = D.27058 | 604045312;
  MEM[(guint32 *)code] = D.27063;
  code = code + 4;
  <D.27154>:
  D.26964 = ins->dreg;
  D.27155 = D.26964 << 16;
  D.27156 = D.27155 | 2099233;
  D.27157 = (unsigned int) D.27156;
  MEM[(guint32 *)code] = D.27157;
  code = code + 4;
  D.26998 = ins->sreg1;
  D.27142 = D.26998 << 16;
  D.27158 = D.27142 | -1608515584;
  D.27159 = (unsigned int) D.27158;
  MEM[(guint32 *)code] = D.27159;
  code = code + 4;
  <D.27146>:
  goto <D.22782>;
  <D.22795>:
  D.27035 = ins->data.op[0].const_val;
  D.27036 = (short int) D.27035;
  D.27037 = (int) D.27036;
  D.27035 = ins->data.op[0].const_val;
  if (D.27037 == D.27035) goto <D.27160>; else goto <D.27161>;
  <D.27160>:
  D.26964 = ins->dreg;
  D.27040 = D.26964 << 21;
  D.27162 = D.27040 | -1543503872;
  D.26998 = ins->sreg1;
  D.27142 = D.26998 << 16;
  D.27163 = D.27162 | D.27142;
  D.27035 = ins->data.op[0].const_val;
  D.27042 = D.27035 & 65535;
  D.27164 = D.27163 | D.27042;
  D.27165 = (unsigned int) D.27164;
  MEM[(guint32 *)code] = D.27165;
  code = code + 4;
  goto <D.27166>;
  <D.27161>:
  D.27035 = ins->data.op[0].const_val;
  D.27036 = (short int) D.27035;
  D.27037 = (int) D.27036;
  D.27035 = ins->data.op[0].const_val;
  if (D.27037 != D.27035) goto <D.27167>; else goto <D.27168>;
  <D.27167>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27049 = D.27048 & 32768;
  if (D.27049 != 0) goto <D.27169>; else goto <D.27170>;
  <D.27169>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27052 = D.27048 >> 16;
  D.27053 = D.27052 + 1;
  D.27054 = D.27053 & 65535;
  D.27055 = D.27054 | 1006698496;
  MEM[(guint32 *)code] = D.27055;
  code = code + 4;
  goto <D.27171>;
  <D.27170>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27052 = D.27048 >> 16;
  D.27057 = D.27052 | 1006698496;
  MEM[(guint32 *)code] = D.27057;
  code = code + 4;
  <D.27171>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27058 = D.27048 & 65535;
  if (D.27058 != 0) goto <D.27172>; else goto <D.27173>;
  <D.27172>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27058 = D.27048 & 65535;
  D.27061 = D.27058 | 606142464;
  MEM[(guint32 *)code] = D.27061;
  code = code + 4;
  <D.27173>:
  goto <D.27174>;
  <D.27168>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27058 = D.27048 & 65535;
  D.27063 = D.27058 | 604045312;
  MEM[(guint32 *)code] = D.27063;
  code = code + 4;
  <D.27174>:
  D.26964 = ins->dreg;
  D.27155 = D.26964 << 16;
  D.27156 = D.27155 | 2099233;
  D.27157 = (unsigned int) D.27156;
  MEM[(guint32 *)code] = D.27157;
  code = code + 4;
  D.26998 = ins->sreg1;
  D.27142 = D.26998 << 16;
  D.27175 = D.27142 | -1541406720;
  D.27176 = (unsigned int) D.27175;
  MEM[(guint32 *)code] = D.27176;
  code = code + 4;
  <D.27166>:
  goto <D.22782>;
  <D.22796>:
  <D.22797>:
  D.27035 = ins->data.op[0].const_val;
  D.27036 = (short int) D.27035;
  D.27037 = (int) D.27036;
  D.27035 = ins->data.op[0].const_val;
  if (D.27037 == D.27035) goto <D.27177>; else goto <D.27178>;
  <D.27177>:
  D.26964 = ins->dreg;
  D.27040 = D.26964 << 21;
  D.27179 = D.27040 | -1409286144;
  D.26998 = ins->sreg1;
  D.27142 = D.26998 << 16;
  D.27180 = D.27179 | D.27142;
  D.27035 = ins->data.op[0].const_val;
  D.27042 = D.27035 & 65535;
  D.27181 = D.27180 | D.27042;
  D.27182 = (unsigned int) D.27181;
  MEM[(guint32 *)code] = D.27182;
  code = code + 4;
  goto <D.27183>;
  <D.27178>:
  D.27035 = ins->data.op[0].const_val;
  D.27036 = (short int) D.27035;
  D.27037 = (int) D.27036;
  D.27035 = ins->data.op[0].const_val;
  if (D.27037 != D.27035) goto <D.27184>; else goto <D.27185>;
  <D.27184>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27049 = D.27048 & 32768;
  if (D.27049 != 0) goto <D.27186>; else goto <D.27187>;
  <D.27186>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27052 = D.27048 >> 16;
  D.27053 = D.27052 + 1;
  D.27054 = D.27053 & 65535;
  D.27055 = D.27054 | 1006698496;
  MEM[(guint32 *)code] = D.27055;
  code = code + 4;
  goto <D.27188>;
  <D.27187>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27052 = D.27048 >> 16;
  D.27057 = D.27052 | 1006698496;
  MEM[(guint32 *)code] = D.27057;
  code = code + 4;
  <D.27188>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27058 = D.27048 & 65535;
  if (D.27058 != 0) goto <D.27189>; else goto <D.27190>;
  <D.27189>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27058 = D.27048 & 65535;
  D.27061 = D.27058 | 606142464;
  MEM[(guint32 *)code] = D.27061;
  code = code + 4;
  <D.27190>:
  goto <D.27191>;
  <D.27185>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27058 = D.27048 & 65535;
  D.27063 = D.27058 | 604045312;
  MEM[(guint32 *)code] = D.27063;
  code = code + 4;
  <D.27191>:
  D.26964 = ins->dreg;
  D.27155 = D.26964 << 16;
  D.27156 = D.27155 | 2099233;
  D.27157 = (unsigned int) D.27156;
  MEM[(guint32 *)code] = D.27157;
  code = code + 4;
  D.26998 = ins->sreg1;
  D.27142 = D.26998 << 16;
  D.27192 = D.27142 | -1407188992;
  D.27193 = (unsigned int) D.27192;
  MEM[(guint32 *)code] = D.27193;
  code = code + 4;
  <D.27183>:
  goto <D.22782>;
  <D.22798>:
  D.27035 = ins->data.op[0].const_val;
  D.27036 = (short int) D.27035;
  D.27037 = (int) D.27036;
  D.27035 = ins->data.op[0].const_val;
  if (D.27037 == D.27035) goto <D.27194>; else goto <D.27195>;
  <D.27194>:
  D.26964 = ins->dreg;
  D.27040 = D.26964 << 21;
  D.27196 = D.27040 | -67108864;
  D.26998 = ins->sreg1;
  D.27142 = D.26998 << 16;
  D.27197 = D.27196 | D.27142;
  D.27035 = ins->data.op[0].const_val;
  D.27042 = D.27035 & 65535;
  D.27198 = D.27197 | D.27042;
  D.27199 = (unsigned int) D.27198;
  MEM[(guint32 *)code] = D.27199;
  code = code + 4;
  goto <D.27200>;
  <D.27195>:
  D.27035 = ins->data.op[0].const_val;
  D.27036 = (short int) D.27035;
  D.27037 = (int) D.27036;
  D.27035 = ins->data.op[0].const_val;
  if (D.27037 != D.27035) goto <D.27201>; else goto <D.27202>;
  <D.27201>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27049 = D.27048 & 32768;
  if (D.27049 != 0) goto <D.27203>; else goto <D.27204>;
  <D.27203>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27052 = D.27048 >> 16;
  D.27053 = D.27052 + 1;
  D.27054 = D.27053 & 65535;
  D.27055 = D.27054 | 1006698496;
  MEM[(guint32 *)code] = D.27055;
  code = code + 4;
  goto <D.27205>;
  <D.27204>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27052 = D.27048 >> 16;
  D.27057 = D.27052 | 1006698496;
  MEM[(guint32 *)code] = D.27057;
  code = code + 4;
  <D.27205>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27058 = D.27048 & 65535;
  if (D.27058 != 0) goto <D.27206>; else goto <D.27207>;
  <D.27206>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27058 = D.27048 & 65535;
  D.27061 = D.27058 | 606142464;
  MEM[(guint32 *)code] = D.27061;
  code = code + 4;
  <D.27207>:
  goto <D.27208>;
  <D.27202>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27058 = D.27048 & 65535;
  D.27063 = D.27058 | 604045312;
  MEM[(guint32 *)code] = D.27063;
  code = code + 4;
  <D.27208>:
  D.26964 = ins->dreg;
  D.27155 = D.26964 << 16;
  D.27156 = D.27155 | 2099233;
  D.27157 = (unsigned int) D.27156;
  MEM[(guint32 *)code] = D.27157;
  code = code + 4;
  D.26998 = ins->sreg1;
  D.27142 = D.26998 << 16;
  D.27209 = D.27142 | -65011712;
  D.27210 = (unsigned int) D.27209;
  MEM[(guint32 *)code] = D.27210;
  code = code + 4;
  <D.27200>:
  goto <D.22782>;
  <D.22799>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-mips.c", 3506);
  <D.22800>:
  D.27035 = ins->data.op[0].const_val;
  D.27036 = (short int) D.27035;
  D.27037 = (int) D.27036;
  D.27035 = ins->data.op[0].const_val;
  if (D.27037 == D.27035) goto <D.27211>; else goto <D.27212>;
  <D.27211>:
  D.26998 = ins->sreg1;
  D.26999 = D.26998 << 21;
  D.27213 = D.26999 | -603979776;
  D.26964 = ins->dreg;
  D.27155 = D.26964 << 16;
  D.27214 = D.27213 | D.27155;
  D.27035 = ins->data.op[0].const_val;
  D.27042 = D.27035 & 65535;
  D.27215 = D.27214 | D.27042;
  D.27216 = (unsigned int) D.27215;
  MEM[(guint32 *)code] = D.27216;
  code = code + 4;
  goto <D.27217>;
  <D.27212>:
  D.27035 = ins->data.op[0].const_val;
  D.27036 = (short int) D.27035;
  D.27037 = (int) D.27036;
  D.27035 = ins->data.op[0].const_val;
  if (D.27037 != D.27035) goto <D.27218>; else goto <D.27219>;
  <D.27218>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27049 = D.27048 & 32768;
  if (D.27049 != 0) goto <D.27220>; else goto <D.27221>;
  <D.27220>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27052 = D.27048 >> 16;
  D.27053 = D.27052 + 1;
  D.27054 = D.27053 & 65535;
  D.27055 = D.27054 | 1006698496;
  MEM[(guint32 *)code] = D.27055;
  code = code + 4;
  goto <D.27222>;
  <D.27221>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27052 = D.27048 >> 16;
  D.27057 = D.27052 | 1006698496;
  MEM[(guint32 *)code] = D.27057;
  code = code + 4;
  <D.27222>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27058 = D.27048 & 65535;
  if (D.27058 != 0) goto <D.27223>; else goto <D.27224>;
  <D.27223>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27058 = D.27048 & 65535;
  D.27061 = D.27058 | 606142464;
  MEM[(guint32 *)code] = D.27061;
  code = code + 4;
  <D.27224>:
  goto <D.27225>;
  <D.27219>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27058 = D.27048 & 65535;
  D.27063 = D.27058 | 604045312;
  MEM[(guint32 *)code] = D.27063;
  code = code + 4;
  <D.27225>:
  D.26998 = ins->sreg1;
  D.27142 = D.26998 << 16;
  D.27226 = D.27142 | 2099233;
  D.27227 = (unsigned int) D.27226;
  MEM[(guint32 *)code] = D.27227;
  code = code + 4;
  D.26964 = ins->dreg;
  D.27155 = D.26964 << 16;
  D.27228 = D.27155 | -601882624;
  D.27229 = (unsigned int) D.27228;
  MEM[(guint32 *)code] = D.27229;
  code = code + 4;
  <D.27217>:
  goto <D.22782>;
  <D.22801>:
  <D.22802>:
  <D.22803>:
  D.26964 = ins->dreg;
  D.27230 = D.26964 == -1;
  D.27231 = (long int) D.27230;
  D.27232 = __builtin_expect (D.27231, 0);
  if (D.27232 != 0) goto <D.27233>; else goto <D.27234>;
  <D.27233>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 3522, "ins->dreg != -1");
  <D.27234>:
  D.27035 = ins->data.op[0].const_val;
  D.27036 = (short int) D.27035;
  D.27037 = (int) D.27036;
  D.27035 = ins->data.op[0].const_val;
  if (D.27037 == D.27035) goto <D.27235>; else goto <D.27236>;
  <D.27235>:
  D.26998 = ins->sreg1;
  D.26999 = D.26998 << 21;
  D.27237 = D.26999 | -1946157056;
  D.26964 = ins->dreg;
  D.27155 = D.26964 << 16;
  D.27238 = D.27237 | D.27155;
  D.27035 = ins->data.op[0].const_val;
  D.27042 = D.27035 & 65535;
  D.27239 = D.27238 | D.27042;
  D.27240 = (unsigned int) D.27239;
  MEM[(guint32 *)code] = D.27240;
  code = code + 4;
  goto <D.27241>;
  <D.27236>:
  D.27035 = ins->data.op[0].const_val;
  D.27036 = (short int) D.27035;
  D.27037 = (int) D.27036;
  D.27035 = ins->data.op[0].const_val;
  if (D.27037 != D.27035) goto <D.27242>; else goto <D.27243>;
  <D.27242>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27049 = D.27048 & 32768;
  if (D.27049 != 0) goto <D.27244>; else goto <D.27245>;
  <D.27244>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27052 = D.27048 >> 16;
  D.27053 = D.27052 + 1;
  D.27054 = D.27053 & 65535;
  D.27055 = D.27054 | 1006698496;
  MEM[(guint32 *)code] = D.27055;
  code = code + 4;
  goto <D.27246>;
  <D.27245>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27052 = D.27048 >> 16;
  D.27057 = D.27052 | 1006698496;
  MEM[(guint32 *)code] = D.27057;
  code = code + 4;
  <D.27246>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27058 = D.27048 & 65535;
  if (D.27058 != 0) goto <D.27247>; else goto <D.27248>;
  <D.27247>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27058 = D.27048 & 65535;
  D.27061 = D.27058 | 606142464;
  MEM[(guint32 *)code] = D.27061;
  code = code + 4;
  <D.27248>:
  goto <D.27249>;
  <D.27243>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27058 = D.27048 & 65535;
  D.27063 = D.27058 | 604045312;
  MEM[(guint32 *)code] = D.27063;
  code = code + 4;
  <D.27249>:
  D.26998 = ins->sreg1;
  D.27142 = D.26998 << 16;
  D.27226 = D.27142 | 2099233;
  D.27227 = (unsigned int) D.27226;
  MEM[(guint32 *)code] = D.27227;
  code = code + 4;
  D.26964 = ins->dreg;
  D.27155 = D.26964 << 16;
  D.27250 = D.27155 | -1944059904;
  D.27251 = (unsigned int) D.27250;
  MEM[(guint32 *)code] = D.27251;
  code = code + 4;
  <D.27241>:
  goto <D.22782>;
  <D.22804>:
  D.27035 = ins->data.op[0].const_val;
  D.27036 = (short int) D.27035;
  D.27037 = (int) D.27036;
  D.27035 = ins->data.op[0].const_val;
  if (D.27037 == D.27035) goto <D.27252>; else goto <D.27253>;
  <D.27252>:
  D.26998 = ins->sreg1;
  D.26999 = D.26998 << 21;
  D.27254 = D.26999 | -2147483648;
  D.26964 = ins->dreg;
  D.27155 = D.26964 << 16;
  D.27255 = D.27254 | D.27155;
  D.27035 = ins->data.op[0].const_val;
  D.27042 = D.27035 & 65535;
  D.27256 = D.27255 | D.27042;
  D.27257 = (unsigned int) D.27256;
  MEM[(guint32 *)code] = D.27257;
  code = code + 4;
  goto <D.27258>;
  <D.27253>:
  D.27035 = ins->data.op[0].const_val;
  D.27036 = (short int) D.27035;
  D.27037 = (int) D.27036;
  D.27035 = ins->data.op[0].const_val;
  if (D.27037 != D.27035) goto <D.27259>; else goto <D.27260>;
  <D.27259>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27049 = D.27048 & 32768;
  if (D.27049 != 0) goto <D.27261>; else goto <D.27262>;
  <D.27261>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27052 = D.27048 >> 16;
  D.27053 = D.27052 + 1;
  D.27054 = D.27053 & 65535;
  D.27055 = D.27054 | 1006698496;
  MEM[(guint32 *)code] = D.27055;
  code = code + 4;
  goto <D.27263>;
  <D.27262>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27052 = D.27048 >> 16;
  D.27057 = D.27052 | 1006698496;
  MEM[(guint32 *)code] = D.27057;
  code = code + 4;
  <D.27263>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27058 = D.27048 & 65535;
  if (D.27058 != 0) goto <D.27264>; else goto <D.27265>;
  <D.27264>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27058 = D.27048 & 65535;
  D.27061 = D.27058 | 606142464;
  MEM[(guint32 *)code] = D.27061;
  code = code + 4;
  <D.27265>:
  goto <D.27266>;
  <D.27260>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27058 = D.27048 & 65535;
  D.27063 = D.27058 | 604045312;
  MEM[(guint32 *)code] = D.27063;
  code = code + 4;
  <D.27266>:
  D.26998 = ins->sreg1;
  D.27142 = D.26998 << 16;
  D.27226 = D.27142 | 2099233;
  D.27227 = (unsigned int) D.27226;
  MEM[(guint32 *)code] = D.27227;
  code = code + 4;
  D.26964 = ins->dreg;
  D.27155 = D.26964 << 16;
  D.27267 = D.27155 | -2145386496;
  D.27268 = (unsigned int) D.27267;
  MEM[(guint32 *)code] = D.27268;
  code = code + 4;
  <D.27258>:
  goto <D.22782>;
  <D.22805>:
  D.27035 = ins->data.op[0].const_val;
  D.27036 = (short int) D.27035;
  D.27037 = (int) D.27036;
  D.27035 = ins->data.op[0].const_val;
  if (D.27037 == D.27035) goto <D.27269>; else goto <D.27270>;
  <D.27269>:
  D.26998 = ins->sreg1;
  D.26999 = D.26998 << 21;
  D.27271 = D.26999 | -1879048192;
  D.26964 = ins->dreg;
  D.27155 = D.26964 << 16;
  D.27272 = D.27271 | D.27155;
  D.27035 = ins->data.op[0].const_val;
  D.27042 = D.27035 & 65535;
  D.27273 = D.27272 | D.27042;
  D.27274 = (unsigned int) D.27273;
  MEM[(guint32 *)code] = D.27274;
  code = code + 4;
  goto <D.27275>;
  <D.27270>:
  D.27035 = ins->data.op[0].const_val;
  D.27036 = (short int) D.27035;
  D.27037 = (int) D.27036;
  D.27035 = ins->data.op[0].const_val;
  if (D.27037 != D.27035) goto <D.27276>; else goto <D.27277>;
  <D.27276>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27049 = D.27048 & 32768;
  if (D.27049 != 0) goto <D.27278>; else goto <D.27279>;
  <D.27278>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27052 = D.27048 >> 16;
  D.27053 = D.27052 + 1;
  D.27054 = D.27053 & 65535;
  D.27055 = D.27054 | 1006698496;
  MEM[(guint32 *)code] = D.27055;
  code = code + 4;
  goto <D.27280>;
  <D.27279>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27052 = D.27048 >> 16;
  D.27057 = D.27052 | 1006698496;
  MEM[(guint32 *)code] = D.27057;
  code = code + 4;
  <D.27280>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27058 = D.27048 & 65535;
  if (D.27058 != 0) goto <D.27281>; else goto <D.27282>;
  <D.27281>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27058 = D.27048 & 65535;
  D.27061 = D.27058 | 606142464;
  MEM[(guint32 *)code] = D.27061;
  code = code + 4;
  <D.27282>:
  goto <D.27283>;
  <D.27277>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27058 = D.27048 & 65535;
  D.27063 = D.27058 | 604045312;
  MEM[(guint32 *)code] = D.27063;
  code = code + 4;
  <D.27283>:
  D.26998 = ins->sreg1;
  D.27142 = D.26998 << 16;
  D.27226 = D.27142 | 2099233;
  D.27227 = (unsigned int) D.27226;
  MEM[(guint32 *)code] = D.27227;
  code = code + 4;
  D.26964 = ins->dreg;
  D.27155 = D.26964 << 16;
  D.27284 = D.27155 | -1876951040;
  D.27285 = (unsigned int) D.27284;
  MEM[(guint32 *)code] = D.27285;
  code = code + 4;
  <D.27275>:
  goto <D.22782>;
  <D.22806>:
  D.27035 = ins->data.op[0].const_val;
  D.27036 = (short int) D.27035;
  D.27037 = (int) D.27036;
  D.27035 = ins->data.op[0].const_val;
  if (D.27037 == D.27035) goto <D.27286>; else goto <D.27287>;
  <D.27286>:
  D.26998 = ins->sreg1;
  D.26999 = D.26998 << 21;
  D.27288 = D.26999 | -2080374784;
  D.26964 = ins->dreg;
  D.27155 = D.26964 << 16;
  D.27289 = D.27288 | D.27155;
  D.27035 = ins->data.op[0].const_val;
  D.27042 = D.27035 & 65535;
  D.27290 = D.27289 | D.27042;
  D.27291 = (unsigned int) D.27290;
  MEM[(guint32 *)code] = D.27291;
  code = code + 4;
  goto <D.27292>;
  <D.27287>:
  D.27035 = ins->data.op[0].const_val;
  D.27036 = (short int) D.27035;
  D.27037 = (int) D.27036;
  D.27035 = ins->data.op[0].const_val;
  if (D.27037 != D.27035) goto <D.27293>; else goto <D.27294>;
  <D.27293>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27049 = D.27048 & 32768;
  if (D.27049 != 0) goto <D.27295>; else goto <D.27296>;
  <D.27295>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27052 = D.27048 >> 16;
  D.27053 = D.27052 + 1;
  D.27054 = D.27053 & 65535;
  D.27055 = D.27054 | 1006698496;
  MEM[(guint32 *)code] = D.27055;
  code = code + 4;
  goto <D.27297>;
  <D.27296>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27052 = D.27048 >> 16;
  D.27057 = D.27052 | 1006698496;
  MEM[(guint32 *)code] = D.27057;
  code = code + 4;
  <D.27297>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27058 = D.27048 & 65535;
  if (D.27058 != 0) goto <D.27298>; else goto <D.27299>;
  <D.27298>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27058 = D.27048 & 65535;
  D.27061 = D.27058 | 606142464;
  MEM[(guint32 *)code] = D.27061;
  code = code + 4;
  <D.27299>:
  goto <D.27300>;
  <D.27294>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27058 = D.27048 & 65535;
  D.27063 = D.27058 | 604045312;
  MEM[(guint32 *)code] = D.27063;
  code = code + 4;
  <D.27300>:
  D.26998 = ins->sreg1;
  D.27142 = D.26998 << 16;
  D.27226 = D.27142 | 2099233;
  D.27227 = (unsigned int) D.27226;
  MEM[(guint32 *)code] = D.27227;
  code = code + 4;
  D.26964 = ins->dreg;
  D.27155 = D.26964 << 16;
  D.27301 = D.27155 | -2078277632;
  D.27302 = (unsigned int) D.27301;
  MEM[(guint32 *)code] = D.27302;
  code = code + 4;
  <D.27292>:
  goto <D.22782>;
  <D.22807>:
  D.27035 = ins->data.op[0].const_val;
  D.27036 = (short int) D.27035;
  D.27037 = (int) D.27036;
  D.27035 = ins->data.op[0].const_val;
  if (D.27037 == D.27035) goto <D.27303>; else goto <D.27304>;
  <D.27303>:
  D.26998 = ins->sreg1;
  D.26999 = D.26998 << 21;
  D.27305 = D.26999 | -1811939328;
  D.26964 = ins->dreg;
  D.27155 = D.26964 << 16;
  D.27306 = D.27305 | D.27155;
  D.27035 = ins->data.op[0].const_val;
  D.27042 = D.27035 & 65535;
  D.27307 = D.27306 | D.27042;
  D.27308 = (unsigned int) D.27307;
  MEM[(guint32 *)code] = D.27308;
  code = code + 4;
  goto <D.27309>;
  <D.27304>:
  D.27035 = ins->data.op[0].const_val;
  D.27036 = (short int) D.27035;
  D.27037 = (int) D.27036;
  D.27035 = ins->data.op[0].const_val;
  if (D.27037 != D.27035) goto <D.27310>; else goto <D.27311>;
  <D.27310>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27049 = D.27048 & 32768;
  if (D.27049 != 0) goto <D.27312>; else goto <D.27313>;
  <D.27312>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27052 = D.27048 >> 16;
  D.27053 = D.27052 + 1;
  D.27054 = D.27053 & 65535;
  D.27055 = D.27054 | 1006698496;
  MEM[(guint32 *)code] = D.27055;
  code = code + 4;
  goto <D.27314>;
  <D.27313>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27052 = D.27048 >> 16;
  D.27057 = D.27052 | 1006698496;
  MEM[(guint32 *)code] = D.27057;
  code = code + 4;
  <D.27314>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27058 = D.27048 & 65535;
  if (D.27058 != 0) goto <D.27315>; else goto <D.27316>;
  <D.27315>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27058 = D.27048 & 65535;
  D.27061 = D.27058 | 606142464;
  MEM[(guint32 *)code] = D.27061;
  code = code + 4;
  <D.27316>:
  goto <D.27317>;
  <D.27311>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27058 = D.27048 & 65535;
  D.27063 = D.27058 | 604045312;
  MEM[(guint32 *)code] = D.27063;
  code = code + 4;
  <D.27317>:
  D.26998 = ins->sreg1;
  D.27142 = D.26998 << 16;
  D.27226 = D.27142 | 2099233;
  D.27227 = (unsigned int) D.27226;
  MEM[(guint32 *)code] = D.27227;
  code = code + 4;
  D.26964 = ins->dreg;
  D.27155 = D.26964 << 16;
  D.27318 = D.27155 | -1809842176;
  D.27319 = (unsigned int) D.27318;
  MEM[(guint32 *)code] = D.27319;
  code = code + 4;
  <D.27309>:
  goto <D.22782>;
  <D.22808>:
  D.26998 = ins->sreg1;
  D.27142 = D.26998 << 16;
  D.27320 = D.27142 | 3584;
  D.27321 = (unsigned int) D.27320;
  MEM[(guint32 *)code] = D.27321;
  code = code + 4;
  D.26964 = ins->dreg;
  D.27005 = D.26964 << 11;
  D.27322 = D.27005 | 67075;
  D.27323 = (unsigned int) D.27322;
  MEM[(guint32 *)code] = D.27323;
  code = code + 4;
  goto <D.22782>;
  <D.22809>:
  D.26998 = ins->sreg1;
  D.27142 = D.26998 << 16;
  D.27324 = D.27142 | 3072;
  D.27325 = (unsigned int) D.27324;
  MEM[(guint32 *)code] = D.27325;
  code = code + 4;
  D.26964 = ins->dreg;
  D.27005 = D.26964 << 11;
  D.27326 = D.27005 | 66563;
  D.27327 = (unsigned int) D.27326;
  MEM[(guint32 *)code] = D.27327;
  code = code + 4;
  goto <D.22782>;
  <D.22810>:
  D.26998 = ins->sreg1;
  D.26999 = D.26998 << 21;
  D.27328 = D.26999 | 805306368;
  D.26964 = ins->dreg;
  D.27155 = D.26964 << 16;
  D.27329 = D.27328 | D.27155;
  D.27330 = D.27329 | 255;
  D.27331 = (unsigned int) D.27330;
  MEM[(guint32 *)code] = D.27331;
  code = code + 4;
  goto <D.22782>;
  <D.22811>:
  D.26998 = ins->sreg1;
  D.27142 = D.26998 << 16;
  D.27324 = D.27142 | 3072;
  D.27325 = (unsigned int) D.27324;
  MEM[(guint32 *)code] = D.27325;
  code = code + 4;
  D.26964 = ins->dreg;
  D.27005 = D.26964 << 11;
  D.27332 = D.27005 | 66562;
  D.27333 = (unsigned int) D.27332;
  MEM[(guint32 *)code] = D.27333;
  code = code + 4;
  goto <D.22782>;
  <D.22812>:
  D.26998 = ins->sreg1;
  D.26999 = D.26998 << 21;
  D.27000 = ins->sreg2;
  D.27001 = D.27000 << 16;
  D.27002 = D.26999 | D.27001;
  D.26964 = ins->dreg;
  D.27005 = D.26964 << 11;
  D.27334 = D.27002 | D.27005;
  D.27335 = D.27334 | 42;
  D.27336 = (unsigned int) D.27335;
  MEM[(guint32 *)code] = D.27336;
  code = code + 4;
  goto <D.22782>;
  <D.22813>:
  D.27014 = ins->data.op[1].const_val;
  D.27015 = (short int) D.27014;
  D.27016 = (int) D.27015;
  D.27014 = ins->data.op[1].const_val;
  D.27337 = D.27016 != D.27014;
  D.27338 = (long int) D.27337;
  D.27339 = __builtin_expect (D.27338, 0);
  if (D.27339 != 0) goto <D.27340>; else goto <D.27341>;
  <D.27340>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 3586, "mips_is_imm16 (ins->inst_imm)");
  <D.27341>:
  D.26998 = ins->sreg1;
  D.26999 = D.26998 << 21;
  D.27342 = D.26999 | 671088640;
  D.26964 = ins->dreg;
  D.27155 = D.26964 << 16;
  D.27343 = D.27342 | D.27155;
  D.27014 = ins->data.op[1].const_val;
  D.27344 = D.27014 & 65535;
  D.27345 = D.27343 | D.27344;
  D.27346 = (unsigned int) D.27345;
  MEM[(guint32 *)code] = D.27346;
  code = code + 4;
  goto <D.22782>;
  <D.22814>:
  D.26998 = ins->sreg1;
  D.26999 = D.26998 << 21;
  D.27000 = ins->sreg2;
  D.27001 = D.27000 << 16;
  D.27002 = D.26999 | D.27001;
  D.26964 = ins->dreg;
  D.27005 = D.26964 << 11;
  D.27334 = D.27002 | D.27005;
  D.27347 = D.27334 | 43;
  D.27348 = (unsigned int) D.27347;
  MEM[(guint32 *)code] = D.27348;
  code = code + 4;
  goto <D.22782>;
  <D.22815>:
  D.27014 = ins->data.op[1].const_val;
  D.27015 = (short int) D.27014;
  D.27016 = (int) D.27015;
  D.27014 = ins->data.op[1].const_val;
  D.27337 = D.27016 != D.27014;
  D.27338 = (long int) D.27337;
  D.27339 = __builtin_expect (D.27338, 0);
  if (D.27339 != 0) goto <D.27349>; else goto <D.27350>;
  <D.27349>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 3593, "mips_is_imm16 (ins->inst_imm)");
  <D.27350>:
  D.26998 = ins->sreg1;
  D.26999 = D.26998 << 21;
  D.27351 = D.26999 | 738197504;
  D.26964 = ins->dreg;
  D.27155 = D.26964 << 16;
  D.27352 = D.27351 | D.27155;
  D.27014 = ins->data.op[1].const_val;
  D.27344 = D.27014 & 65535;
  D.27353 = D.27352 | D.27344;
  D.27354 = (unsigned int) D.27353;
  MEM[(guint32 *)code] = D.27354;
  code = code + 4;
  goto <D.22782>;
  <D.22816>:
  code.86 = (int) code;
  D.26935 = cfg->native_code;
  D.26943 = (int) D.26935;
  D.26944 = code.86 - D.26943;
  mono_add_patch_info (cfg, D.26944, 7, "mono_break");
  if (0 != 0) goto <D.27355>; else goto <D.27356>;
  <D.27355>:
  MEM[(guint32 *)code] = 1008279328;
  code = code + 4;
  goto <D.27357>;
  <D.27356>:
  MEM[(guint32 *)code] = 1008279327;
  code = code + 4;
  <D.27357>:
  MEM[(guint32 *)code] = 658054943;
  code = code + 4;
  MEM[(guint32 *)code] = 52492297;
  code = code + 4;
  MEM[(guint32 *)code] = 2099237;
  code = code + 4;
  goto <D.22782>;
  <D.22817>:
  D.26998 = ins->sreg1;
  D.26999 = D.26998 << 21;
  D.27000 = ins->sreg2;
  D.27001 = D.27000 << 16;
  D.27002 = D.26999 | D.27001;
  D.26964 = ins->dreg;
  D.27005 = D.26964 << 11;
  D.27334 = D.27002 | D.27005;
  D.27358 = D.27334 | 33;
  D.27359 = (unsigned int) D.27358;
  MEM[(guint32 *)code] = D.27359;
  code = code + 4;
  goto <D.22782>;
  <D.22818>:
  D.26998 = ins->sreg1;
  D.26999 = D.26998 << 21;
  D.27000 = ins->sreg2;
  D.27001 = D.27000 << 16;
  D.27002 = D.26999 | D.27001;
  D.26964 = ins->dreg;
  D.27005 = D.26964 << 11;
  D.27334 = D.27002 | D.27005;
  D.27360 = D.27334 | 45;
  D.27361 = (unsigned int) D.27360;
  MEM[(guint32 *)code] = D.27361;
  code = code + 4;
  goto <D.22782>;
  <D.22819>:
  <D.22820>:
  D.27014 = ins->data.op[1].const_val;
  D.27015 = (short int) D.27014;
  D.27016 = (int) D.27015;
  D.27014 = ins->data.op[1].const_val;
  D.27337 = D.27016 != D.27014;
  D.27338 = (long int) D.27337;
  D.27339 = __builtin_expect (D.27338, 0);
  if (D.27339 != 0) goto <D.27362>; else goto <D.27363>;
  <D.27362>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 3617, "mips_is_imm16 (ins->inst_imm)");
  <D.27363>:
  D.26998 = ins->sreg1;
  D.26999 = D.26998 << 21;
  D.27364 = D.26999 | 603979776;
  D.26964 = ins->dreg;
  D.27155 = D.26964 << 16;
  D.27365 = D.27364 | D.27155;
  D.27014 = ins->data.op[1].const_val;
  D.27344 = D.27014 & 65535;
  D.27366 = D.27365 | D.27344;
  D.27367 = (unsigned int) D.27366;
  MEM[(guint32 *)code] = D.27367;
  code = code + 4;
  goto <D.22782>;
  <D.22821>:
  D.27014 = ins->data.op[1].const_val;
  D.27015 = (short int) D.27014;
  D.27016 = (int) D.27015;
  D.27014 = ins->data.op[1].const_val;
  D.27337 = D.27016 != D.27014;
  D.27338 = (long int) D.27337;
  D.27339 = __builtin_expect (D.27338, 0);
  if (D.27339 != 0) goto <D.27368>; else goto <D.27369>;
  <D.27368>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 3621, "mips_is_imm16 (ins->inst_imm)");
  <D.27369>:
  D.26998 = ins->sreg1;
  D.26999 = D.26998 << 21;
  D.27370 = D.26999 | 1677721600;
  D.26964 = ins->dreg;
  D.27155 = D.26964 << 16;
  D.27371 = D.27370 | D.27155;
  D.27014 = ins->data.op[1].const_val;
  D.27344 = D.27014 & 65535;
  D.27372 = D.27371 | D.27344;
  D.27373 = (unsigned int) D.27372;
  MEM[(guint32 *)code] = D.27373;
  code = code + 4;
  goto <D.22782>;
  <D.22822>:
  D.26998 = ins->sreg1;
  D.26999 = D.26998 << 21;
  D.27000 = ins->sreg2;
  D.27001 = D.27000 << 16;
  D.27002 = D.26999 | D.27001;
  D.26964 = ins->dreg;
  D.27005 = D.26964 << 11;
  D.27334 = D.27002 | D.27005;
  D.27374 = D.27334 | 35;
  D.27375 = (unsigned int) D.27374;
  MEM[(guint32 *)code] = D.27375;
  code = code + 4;
  goto <D.22782>;
  <D.22823>:
  D.26998 = ins->sreg1;
  D.26999 = D.26998 << 21;
  D.27000 = ins->sreg2;
  D.27001 = D.27000 << 16;
  D.27002 = D.26999 | D.27001;
  D.26964 = ins->dreg;
  D.27005 = D.26964 << 11;
  D.27334 = D.27002 | D.27005;
  D.27376 = D.27334 | 47;
  D.27377 = (unsigned int) D.27376;
  MEM[(guint32 *)code] = D.27377;
  code = code + 4;
  goto <D.22782>;
  <D.22824>:
  <D.22825>:
  D.27014 = ins->data.op[1].const_val;
  D.27378 = (unsigned short) D.27014;
  D.27379 = -D.27378;
  D.27380 = (short int) D.27379;
  D.27381 = (int) D.27380;
  D.27014 = ins->data.op[1].const_val;
  D.27382 = -D.27014;
  D.27383 = D.27381 != D.27382;
  D.27384 = (long int) D.27383;
  D.27385 = __builtin_expect (D.27384, 0);
  if (D.27385 != 0) goto <D.27386>; else goto <D.27387>;
  <D.27386>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 3635, "mips_is_imm16 (-ins->inst_imm)");
  <D.27387>:
  D.26998 = ins->sreg1;
  D.26999 = D.26998 << 21;
  D.27364 = D.26999 | 603979776;
  D.26964 = ins->dreg;
  D.27155 = D.26964 << 16;
  D.27365 = D.27364 | D.27155;
  D.27014 = ins->data.op[1].const_val;
  D.27382 = -D.27014;
  D.27388 = D.27382 & 65535;
  D.27389 = D.27365 | D.27388;
  D.27390 = (unsigned int) D.27389;
  MEM[(guint32 *)code] = D.27390;
  code = code + 4;
  goto <D.22782>;
  <D.22826>:
  D.27014 = ins->data.op[1].const_val;
  D.27378 = (unsigned short) D.27014;
  D.27379 = -D.27378;
  D.27380 = (short int) D.27379;
  D.27381 = (int) D.27380;
  D.27014 = ins->data.op[1].const_val;
  D.27382 = -D.27014;
  D.27383 = D.27381 != D.27382;
  D.27384 = (long int) D.27383;
  D.27385 = __builtin_expect (D.27384, 0);
  if (D.27385 != 0) goto <D.27391>; else goto <D.27392>;
  <D.27391>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 3641, "mips_is_imm16 (-ins->inst_imm)");
  <D.27392>:
  D.26998 = ins->sreg1;
  D.26999 = D.26998 << 21;
  D.27370 = D.26999 | 1677721600;
  D.26964 = ins->dreg;
  D.27155 = D.26964 << 16;
  D.27371 = D.27370 | D.27155;
  D.27014 = ins->data.op[1].const_val;
  D.27382 = -D.27014;
  D.27388 = D.27382 & 65535;
  D.27393 = D.27371 | D.27388;
  D.27394 = (unsigned int) D.27393;
  MEM[(guint32 *)code] = D.27394;
  code = code + 4;
  goto <D.22782>;
  <D.22827>:
  <D.22828>:
  D.26998 = ins->sreg1;
  D.26999 = D.26998 << 21;
  D.27000 = ins->sreg2;
  D.27001 = D.27000 << 16;
  D.27002 = D.26999 | D.27001;
  D.26964 = ins->dreg;
  D.27005 = D.26964 << 11;
  D.27334 = D.27002 | D.27005;
  D.27395 = D.27334 | 36;
  D.27396 = (unsigned int) D.27395;
  MEM[(guint32 *)code] = D.27396;
  code = code + 4;
  goto <D.22782>;
  <D.22829>:
  <D.22830>:
  <D.22831>:
  D.27014 = ins->data.op[1].const_val;
  D.27019 = (unsigned int) D.27014;
  D.27397 = D.27019 & 4294901760;
  D.27398 = D.27397 != 0;
  D.27399 = (long int) D.27398;
  D.27400 = __builtin_expect (D.27399, 0);
  if (D.27400 != 0) goto <D.27401>; else goto <D.27402>;
  <D.27401>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 3653, "!(ins->inst_imm & 0xffff0000)");
  <D.27402>:
  D.26998 = ins->sreg1;
  D.26999 = D.26998 << 21;
  D.27328 = D.26999 | 805306368;
  D.26964 = ins->dreg;
  D.27155 = D.26964 << 16;
  D.27329 = D.27328 | D.27155;
  D.27014 = ins->data.op[1].const_val;
  D.27344 = D.27014 & 65535;
  D.27403 = D.27329 | D.27344;
  D.27404 = (unsigned int) D.27403;
  MEM[(guint32 *)code] = D.27404;
  code = code + 4;
  goto <D.22782>;
  <D.22832>:
  <D.22833>:
  {
    guint32 * divisor_is_m1;
    guint32 * dividend_is_minvalue;
    guint32 * divisor_is_zero;

    if (0 != 0) goto <D.27405>; else goto <D.27406>;
    <D.27405>:
    if (1 != 0) goto <D.27407>; else goto <D.27408>;
    <D.27407>:
    MEM[(guint32 *)code] = 1006698496;
    code = code + 4;
    goto <D.27409>;
    <D.27408>:
    MEM[(guint32 *)code] = 1006764031;
    code = code + 4;
    <D.27409>:
    if (1 != 0) goto <D.27410>; else goto <D.27411>;
    <D.27410>:
    MEM[(guint32 *)code] = 606207999;
    code = code + 4;
    <D.27411>:
    goto <D.27412>;
    <D.27406>:
    MEM[(guint32 *)code] = 604110847;
    code = code + 4;
    <D.27412>:
    divisor_is_m1 = code;
    D.27000 = ins->sreg2;
    D.27413 = D.27000 << 21;
    D.27414 = D.27413 | 335609856;
    D.27415 = (unsigned int) D.27414;
    MEM[(guint32 *)code] = D.27415;
    code = code + 4;
    MEM[(guint32 *)code] = 1006731264;
    code = code + 4;
    dividend_is_minvalue = code;
    D.26998 = ins->sreg1;
    D.26999 = D.26998 << 21;
    D.27416 = D.26999 | 335609856;
    D.27417 = (unsigned int) D.27416;
    MEM[(guint32 *)code] = D.27417;
    code = code + 4;
    MEM[(guint32 *)code] = 2099237;
    code = code + 4;
    code = mips_emit_exc_by_name (code, "OverflowException");
    D.27418 = cfg->bb_exit;
    D.27418 = cfg->bb_exit;
    D.27419 = D.27418->max_offset;
    D.27420 = D.27419 + 16;
    D.27418->max_offset = D.27420;
    code.91 = (unsigned int) code;
    mips_patch (divisor_is_m1, code.91);
    code.91 = (unsigned int) code;
    mips_patch (dividend_is_minvalue, code.91);
    divisor_is_zero = code;
    D.27000 = ins->sreg2;
    D.27413 = D.27000 << 21;
    D.27422 = D.27413 | 335544320;
    D.27423 = (unsigned int) D.27422;
    MEM[(guint32 *)code] = D.27423;
    code = code + 4;
    MEM[(guint32 *)code] = 2099237;
    code = code + 4;
    code = mips_emit_exc_by_name (code, "DivideByZeroException");
    D.27418 = cfg->bb_exit;
    D.27418 = cfg->bb_exit;
    D.27419 = D.27418->max_offset;
    D.27420 = D.27419 + 16;
    D.27418->max_offset = D.27420;
    code.91 = (unsigned int) code;
    mips_patch (divisor_is_zero, code.91);
    D.26998 = ins->sreg1;
    D.26999 = D.26998 << 21;
    D.27000 = ins->sreg2;
    D.27001 = D.27000 << 16;
    D.27002 = D.26999 | D.27001;
    D.27424 = D.27002 | 26;
    D.27425 = (unsigned int) D.27424;
    MEM[(guint32 *)code] = D.27425;
    code = code + 4;
    D.26945 = ins->opcode;
    if (D.26945 == 568) goto <D.27426>; else goto <D.27427>;
    <D.27426>:
    D.26964 = ins->dreg;
    D.27005 = D.26964 << 11;
    D.27006 = D.27005 | 18;
    D.27007 = (unsigned int) D.27006;
    MEM[(guint32 *)code] = D.27007;
    code = code + 4;
    goto <D.27428>;
    <D.27427>:
    D.26964 = ins->dreg;
    D.27005 = D.26964 << 11;
    D.27429 = D.27005 | 16;
    D.27430 = (unsigned int) D.27429;
    MEM[(guint32 *)code] = D.27430;
    code = code + 4;
    <D.27428>:
    goto <D.22782>;
  }
  <D.22837>:
  <D.22838>:
  {
    guint32 * divisor_is_zero;

    divisor_is_zero = code;
    D.27000 = ins->sreg2;
    D.27413 = D.27000 << 21;
    D.27422 = D.27413 | 335544320;
    D.27423 = (unsigned int) D.27422;
    MEM[(guint32 *)code] = D.27423;
    code = code + 4;
    MEM[(guint32 *)code] = 2099237;
    code = code + 4;
    code = mips_emit_exc_by_name (code, "DivideByZeroException");
    D.27418 = cfg->bb_exit;
    D.27418 = cfg->bb_exit;
    D.27419 = D.27418->max_offset;
    D.27420 = D.27419 + 16;
    D.27418->max_offset = D.27420;
    code.91 = (unsigned int) code;
    mips_patch (divisor_is_zero, code.91);
    D.26998 = ins->sreg1;
    D.26999 = D.26998 << 21;
    D.27000 = ins->sreg2;
    D.27001 = D.27000 << 16;
    D.27002 = D.26999 | D.27001;
    D.27431 = D.27002 | 27;
    D.27432 = (unsigned int) D.27431;
    MEM[(guint32 *)code] = D.27432;
    code = code + 4;
    D.26945 = ins->opcode;
    if (D.26945 == 569) goto <D.27433>; else goto <D.27434>;
    <D.27433>:
    D.26964 = ins->dreg;
    D.27005 = D.26964 << 11;
    D.27006 = D.27005 | 18;
    D.27007 = (unsigned int) D.27006;
    MEM[(guint32 *)code] = D.27007;
    code = code + 4;
    goto <D.27435>;
    <D.27434>:
    D.26964 = ins->dreg;
    D.27005 = D.26964 << 11;
    D.27429 = D.27005 | 16;
    D.27430 = (unsigned int) D.27429;
    MEM[(guint32 *)code] = D.27430;
    code = code + 4;
    <D.27435>:
    goto <D.22782>;
  }
  <D.22840>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-mips.c", 3713);
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-mips.c", 3722);
  <D.22841>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-mips.c", 3725);
  <D.22842>:
  D.26998 = ins->sreg1;
  D.26999 = D.26998 << 21;
  D.27000 = ins->sreg2;
  D.27001 = D.27000 << 16;
  D.27002 = D.26999 | D.27001;
  D.26964 = ins->dreg;
  D.27005 = D.26964 << 11;
  D.27334 = D.27002 | D.27005;
  D.27436 = D.27334 | 37;
  D.27437 = (unsigned int) D.27436;
  MEM[(guint32 *)code] = D.27437;
  code = code + 4;
  goto <D.22782>;
  <D.22843>:
  <D.22844>:
  D.27014 = ins->data.op[1].const_val;
  D.27019 = (unsigned int) D.27014;
  D.27397 = D.27019 & 4294901760;
  D.27398 = D.27397 != 0;
  D.27399 = (long int) D.27398;
  D.27400 = __builtin_expect (D.27399, 0);
  if (D.27400 != 0) goto <D.27438>; else goto <D.27439>;
  <D.27438>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 3731, "!(ins->inst_imm & 0xffff0000)");
  <D.27439>:
  D.26998 = ins->sreg1;
  D.26999 = D.26998 << 21;
  D.27440 = D.26999 | 872415232;
  D.26964 = ins->dreg;
  D.27155 = D.26964 << 16;
  D.27441 = D.27440 | D.27155;
  D.27014 = ins->data.op[1].const_val;
  D.27344 = D.27014 & 65535;
  D.27442 = D.27441 | D.27344;
  D.27443 = (unsigned int) D.27442;
  MEM[(guint32 *)code] = D.27443;
  code = code + 4;
  goto <D.22782>;
  <D.22845>:
  D.26998 = ins->sreg1;
  D.26999 = D.26998 << 21;
  D.27000 = ins->sreg2;
  D.27001 = D.27000 << 16;
  D.27002 = D.26999 | D.27001;
  D.26964 = ins->dreg;
  D.27005 = D.26964 << 11;
  D.27334 = D.27002 | D.27005;
  D.27444 = D.27334 | 38;
  D.27445 = (unsigned int) D.27444;
  MEM[(guint32 *)code] = D.27445;
  code = code + 4;
  goto <D.22782>;
  <D.22846>:
  <D.22847>:
  D.27014 = ins->data.op[1].const_val;
  D.27019 = (unsigned int) D.27014;
  D.27397 = D.27019 & 4294901760;
  D.27398 = D.27397 != 0;
  D.27399 = (long int) D.27398;
  D.27400 = __builtin_expect (D.27399, 0);
  if (D.27400 != 0) goto <D.27446>; else goto <D.27447>;
  <D.27446>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 3740, "!(ins->inst_imm & 0xffff0000)");
  <D.27447>:
  D.26998 = ins->sreg1;
  D.26999 = D.26998 << 21;
  D.27448 = D.26999 | 939524096;
  D.26964 = ins->dreg;
  D.27155 = D.26964 << 16;
  D.27449 = D.27448 | D.27155;
  D.27014 = ins->data.op[1].const_val;
  D.27344 = D.27014 & 65535;
  D.27450 = D.27449 | D.27344;
  D.27451 = (unsigned int) D.27450;
  MEM[(guint32 *)code] = D.27451;
  code = code + 4;
  goto <D.22782>;
  <D.22848>:
  D.27000 = ins->sreg2;
  D.27413 = D.27000 << 21;
  D.26998 = ins->sreg1;
  D.27142 = D.26998 << 16;
  D.27452 = D.27413 | D.27142;
  D.26964 = ins->dreg;
  D.27005 = D.26964 << 11;
  D.27453 = D.27452 | D.27005;
  D.27454 = D.27453 | 4;
  D.27455 = (unsigned int) D.27454;
  MEM[(guint32 *)code] = D.27455;
  code = code + 4;
  goto <D.22782>;
  <D.22849>:
  <D.22850>:
  D.26998 = ins->sreg1;
  D.27142 = D.26998 << 16;
  D.26964 = ins->dreg;
  D.27005 = D.26964 << 11;
  D.27456 = D.27142 | D.27005;
  D.27014 = ins->data.op[1].const_val;
  D.27457 = D.27014 & 31;
  D.27458 = D.27457 << 6;
  D.27459 = D.27456 | D.27458;
  D.27460 = (unsigned int) D.27459;
  MEM[(guint32 *)code] = D.27460;
  code = code + 4;
  goto <D.22782>;
  <D.22851>:
  D.27000 = ins->sreg2;
  D.27413 = D.27000 << 21;
  D.26998 = ins->sreg1;
  D.27142 = D.26998 << 16;
  D.27452 = D.27413 | D.27142;
  D.26964 = ins->dreg;
  D.27005 = D.26964 << 11;
  D.27453 = D.27452 | D.27005;
  D.27461 = D.27453 | 7;
  D.27462 = (unsigned int) D.27461;
  MEM[(guint32 *)code] = D.27462;
  code = code + 4;
  goto <D.22782>;
  <D.22852>:
  D.27000 = ins->sreg2;
  D.27413 = D.27000 << 21;
  D.26998 = ins->sreg1;
  D.27142 = D.26998 << 16;
  D.27452 = D.27413 | D.27142;
  D.26964 = ins->dreg;
  D.27005 = D.26964 << 11;
  D.27453 = D.27452 | D.27005;
  D.27463 = D.27453 | 23;
  D.27464 = (unsigned int) D.27463;
  MEM[(guint32 *)code] = D.27464;
  code = code + 4;
  goto <D.22782>;
  <D.22853>:
  <D.22854>:
  D.26998 = ins->sreg1;
  D.27142 = D.26998 << 16;
  D.26964 = ins->dreg;
  D.27005 = D.26964 << 11;
  D.27456 = D.27142 | D.27005;
  D.27014 = ins->data.op[1].const_val;
  D.27457 = D.27014 & 31;
  D.27458 = D.27457 << 6;
  D.27459 = D.27456 | D.27458;
  D.27465 = D.27459 | 3;
  D.27466 = (unsigned int) D.27465;
  MEM[(guint32 *)code] = D.27466;
  code = code + 4;
  goto <D.22782>;
  <D.22855>:
  D.26998 = ins->sreg1;
  D.27142 = D.26998 << 16;
  D.26964 = ins->dreg;
  D.27005 = D.26964 << 11;
  D.27456 = D.27142 | D.27005;
  D.27014 = ins->data.op[1].const_val;
  D.27467 = D.27014 & 63;
  D.27468 = D.27467 << 6;
  D.27469 = D.27456 | D.27468;
  D.27470 = D.27469 | 59;
  D.27471 = (unsigned int) D.27470;
  MEM[(guint32 *)code] = D.27471;
  code = code + 4;
  goto <D.22782>;
  <D.22856>:
  <D.22857>:
  D.26998 = ins->sreg1;
  D.27142 = D.26998 << 16;
  D.26964 = ins->dreg;
  D.27005 = D.26964 << 11;
  D.27456 = D.27142 | D.27005;
  D.27014 = ins->data.op[1].const_val;
  D.27457 = D.27014 & 31;
  D.27458 = D.27457 << 6;
  D.27459 = D.27456 | D.27458;
  D.27472 = D.27459 | 2;
  D.27473 = (unsigned int) D.27472;
  MEM[(guint32 *)code] = D.27473;
  code = code + 4;
  goto <D.22782>;
  <D.22858>:
  D.26998 = ins->sreg1;
  D.27142 = D.26998 << 16;
  D.26964 = ins->dreg;
  D.27005 = D.26964 << 11;
  D.27456 = D.27142 | D.27005;
  D.27014 = ins->data.op[1].const_val;
  D.27467 = D.27014 & 63;
  D.27468 = D.27467 << 6;
  D.27469 = D.27456 | D.27468;
  D.27474 = D.27469 | 58;
  D.27475 = (unsigned int) D.27474;
  MEM[(guint32 *)code] = D.27475;
  code = code + 4;
  goto <D.22782>;
  <D.22859>:
  D.27000 = ins->sreg2;
  D.27413 = D.27000 << 21;
  D.26998 = ins->sreg1;
  D.27142 = D.26998 << 16;
  D.27452 = D.27413 | D.27142;
  D.26964 = ins->dreg;
  D.27005 = D.26964 << 11;
  D.27453 = D.27452 | D.27005;
  D.27476 = D.27453 | 6;
  D.27477 = (unsigned int) D.27476;
  MEM[(guint32 *)code] = D.27477;
  code = code + 4;
  goto <D.22782>;
  <D.22860>:
  D.27000 = ins->sreg2;
  D.27413 = D.27000 << 21;
  D.26998 = ins->sreg1;
  D.27142 = D.26998 << 16;
  D.27452 = D.27413 | D.27142;
  D.26964 = ins->dreg;
  D.27005 = D.26964 << 11;
  D.27453 = D.27452 | D.27005;
  D.27478 = D.27453 | 22;
  D.27479 = (unsigned int) D.27478;
  MEM[(guint32 *)code] = D.27479;
  code = code + 4;
  goto <D.22782>;
  <D.22861>:
  <D.22862>:
  D.26998 = ins->sreg1;
  D.27142 = D.26998 << 16;
  D.26964 = ins->dreg;
  D.27005 = D.26964 << 11;
  D.27456 = D.27142 | D.27005;
  D.27480 = D.27456 | 39;
  D.27481 = (unsigned int) D.27480;
  MEM[(guint32 *)code] = D.27481;
  code = code + 4;
  goto <D.22782>;
  <D.22863>:
  D.26998 = ins->sreg1;
  D.27142 = D.26998 << 16;
  D.26964 = ins->dreg;
  D.27005 = D.26964 << 11;
  D.27456 = D.27142 | D.27005;
  D.27482 = D.27456 | 35;
  D.27483 = (unsigned int) D.27482;
  MEM[(guint32 *)code] = D.27483;
  code = code + 4;
  goto <D.22782>;
  <D.22864>:
  D.26998 = ins->sreg1;
  D.27142 = D.26998 << 16;
  D.26964 = ins->dreg;
  D.27005 = D.26964 << 11;
  D.27456 = D.27142 | D.27005;
  D.27484 = D.27456 | 47;
  D.27485 = (unsigned int) D.27484;
  MEM[(guint32 *)code] = D.27485;
  code = code + 4;
  goto <D.22782>;
  <D.22865>:
  D.26998 = ins->sreg1;
  D.26999 = D.26998 << 21;
  D.27000 = ins->sreg2;
  D.27001 = D.27000 << 16;
  D.27002 = D.26999 | D.27001;
  D.27003 = D.27002 | 24;
  D.27004 = (unsigned int) D.27003;
  MEM[(guint32 *)code] = D.27004;
  code = code + 4;
  D.26964 = ins->dreg;
  D.27005 = D.26964 << 11;
  D.27006 = D.27005 | 18;
  D.27007 = (unsigned int) D.27006;
  MEM[(guint32 *)code] = D.27007;
  code = code + 4;
  MEM[(guint32 *)code] = 2099237;
  code = code + 4;
  MEM[(guint32 *)code] = 2099237;
  code = code + 4;
  goto <D.22782>;
  <D.22866>:
  {
    guint32 * patch;

    D.26998 = ins->sreg1;
    D.26999 = D.26998 << 21;
    D.27000 = ins->sreg2;
    D.27001 = D.27000 << 16;
    D.27002 = D.26999 | D.27001;
    D.27003 = D.27002 | 24;
    D.27004 = (unsigned int) D.27003;
    MEM[(guint32 *)code] = D.27004;
    code = code + 4;
    D.26964 = ins->dreg;
    D.27005 = D.26964 << 11;
    D.27006 = D.27005 | 18;
    D.27007 = (unsigned int) D.27006;
    MEM[(guint32 *)code] = D.27007;
    code = code + 4;
    MEM[(guint32 *)code] = 2064;
    code = code + 4;
    MEM[(guint32 *)code] = 2099237;
    code = code + 4;
    MEM[(guint32 *)code] = 2099237;
    code = code + 4;
    D.26964 = ins->dreg;
    D.27155 = D.26964 << 16;
    D.27486 = D.27155 | 51139;
    D.27487 = (unsigned int) D.27486;
    MEM[(guint32 *)code] = D.27487;
    code = code + 4;
    patch = code;
    MEM[(guint32 *)code] = 318832640;
    code = code + 4;
    MEM[(guint32 *)code] = 2099237;
    code = code + 4;
    code = mips_emit_exc_by_name (code, "OverflowException");
    D.27418 = cfg->bb_exit;
    D.27418 = cfg->bb_exit;
    D.27419 = D.27418->max_offset;
    D.27420 = D.27419 + 16;
    D.27418->max_offset = D.27420;
    code.91 = (unsigned int) code;
    mips_patch (patch, code.91);
    goto <D.22782>;
  }
  <D.22868>:
  {
    guint32 * patch;

    D.26998 = ins->sreg1;
    D.26999 = D.26998 << 21;
    D.27000 = ins->sreg2;
    D.27001 = D.27000 << 16;
    D.27002 = D.26999 | D.27001;
    D.27003 = D.27002 | 24;
    D.27004 = (unsigned int) D.27003;
    MEM[(guint32 *)code] = D.27004;
    code = code + 4;
    D.26964 = ins->dreg;
    D.27005 = D.26964 << 11;
    D.27006 = D.27005 | 18;
    D.27007 = (unsigned int) D.27006;
    MEM[(guint32 *)code] = D.27007;
    code = code + 4;
    MEM[(guint32 *)code] = 2064;
    code = code + 4;
    MEM[(guint32 *)code] = 2099237;
    code = code + 4;
    MEM[(guint32 *)code] = 2099237;
    code = code + 4;
    patch = code;
    MEM[(guint32 *)code] = 270532608;
    code = code + 4;
    MEM[(guint32 *)code] = 2099237;
    code = code + 4;
    code = mips_emit_exc_by_name (code, "OverflowException");
    D.27418 = cfg->bb_exit;
    D.27418 = cfg->bb_exit;
    D.27419 = D.27418->max_offset;
    D.27420 = D.27419 + 16;
    D.27418->max_offset = D.27420;
    code.91 = (unsigned int) code;
    mips_patch (patch, code.91);
    goto <D.22782>;
  }
  <D.22870>:
  D.27035 = ins->data.op[0].const_val;
  D.27036 = (short int) D.27035;
  D.27037 = (int) D.27036;
  D.27035 = ins->data.op[0].const_val;
  if (D.27037 != D.27035) goto <D.27488>; else goto <D.27489>;
  <D.27488>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27049 = D.27048 & 32768;
  if (D.27049 != 0) goto <D.27490>; else goto <D.27491>;
  <D.27490>:
  D.26964 = ins->dreg;
  D.27155 = D.26964 << 16;
  D.27492 = (unsigned int) D.27155;
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27052 = D.27048 >> 16;
  D.27053 = D.27052 + 1;
  D.27054 = D.27053 & 65535;
  D.27493 = D.27492 | D.27054;
  D.27494 = D.27493 | 1006632960;
  MEM[(guint32 *)code] = D.27494;
  code = code + 4;
  goto <D.27495>;
  <D.27491>:
  D.26964 = ins->dreg;
  D.27155 = D.26964 << 16;
  D.27492 = (unsigned int) D.27155;
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27052 = D.27048 >> 16;
  D.27496 = D.27492 | D.27052;
  D.27497 = D.27496 | 1006632960;
  MEM[(guint32 *)code] = D.27497;
  code = code + 4;
  <D.27495>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27058 = D.27048 & 65535;
  if (D.27058 != 0) goto <D.27498>; else goto <D.27499>;
  <D.27498>:
  D.26964 = ins->dreg;
  D.27040 = D.26964 << 21;
  D.27500 = D.27040 | 603979776;
  D.26964 = ins->dreg;
  D.27155 = D.26964 << 16;
  D.27501 = D.27500 | D.27155;
  D.27502 = (unsigned int) D.27501;
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27058 = D.27048 & 65535;
  D.27503 = D.27502 | D.27058;
  MEM[(guint32 *)code] = D.27503;
  code = code + 4;
  <D.27499>:
  goto <D.27504>;
  <D.27489>:
  D.26964 = ins->dreg;
  D.27155 = D.26964 << 16;
  D.27492 = (unsigned int) D.27155;
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27058 = D.27048 & 65535;
  D.27505 = D.27492 | D.27058;
  D.27506 = D.27505 | 603979776;
  MEM[(guint32 *)code] = D.27506;
  code = code + 4;
  <D.27504>:
  goto <D.22782>;
  <D.22871>:
  offset.92 = (int) offset;
  D.27508 = ins->data.op[1].src;
  D.27509 = (<unnamed type>) D.27508;
  D.27510 = ins->data.op[0].p;
  mono_add_patch_info (cfg, offset.92, D.27509, D.27510);
  if (0 != 0) goto <D.27511>; else goto <D.27512>;
  <D.27511>:
  D.26964 = ins->dreg;
  D.27155 = D.26964 << 16;
  D.27492 = (unsigned int) D.27155;
  D.27513 = D.27492 | 1006632961;
  MEM[(guint32 *)code] = D.27513;
  code = code + 4;
  goto <D.27514>;
  <D.27512>:
  D.26964 = ins->dreg;
  D.27155 = D.26964 << 16;
  D.27515 = D.27155 | 1006632960;
  D.27516 = (unsigned int) D.27515;
  MEM[(guint32 *)code] = D.27516;
  code = code + 4;
  <D.27514>:
  D.26964 = ins->dreg;
  D.27040 = D.26964 << 21;
  D.27500 = D.27040 | 603979776;
  D.26964 = ins->dreg;
  D.27155 = D.26964 << 16;
  D.27501 = D.27500 | D.27155;
  D.27502 = (unsigned int) D.27501;
  MEM[(guint32 *)code] = D.27502;
  code = code + 4;
  goto <D.22782>;
  <D.22872>:
  D.26998 = ins->sreg1;
  D.27142 = D.26998 << 16;
  D.27517 = D.27142 | 1149239296;
  D.26964 = ins->dreg;
  D.27005 = D.26964 << 11;
  D.27518 = D.27517 | D.27005;
  D.27519 = (unsigned int) D.27518;
  MEM[(guint32 *)code] = D.27519;
  code = code + 4;
  goto <D.22782>;
  <D.22873>:
  D.26998 = ins->sreg1;
  D.27142 = D.26998 << 16;
  D.27517 = D.27142 | 1149239296;
  D.26964 = ins->dreg;
  D.27005 = D.26964 << 11;
  D.27518 = D.27517 | D.27005;
  D.27519 = (unsigned int) D.27518;
  MEM[(guint32 *)code] = D.27519;
  code = code + 4;
  D.27000 = ins->sreg2;
  D.27001 = D.27000 << 16;
  D.27520 = D.27001 | 1149239296;
  D.26964 = ins->dreg;
  D.27008 = D.26964 + 1;
  D.27009 = D.27008 << 11;
  D.27521 = D.27520 | D.27009;
  D.27522 = (unsigned int) D.27521;
  MEM[(guint32 *)code] = D.27522;
  code = code + 4;
  goto <D.22782>;
  <D.22874>:
  D.26964 = ins->dreg;
  D.27155 = D.26964 << 16;
  D.27523 = D.27155 | 1140850688;
  D.26998 = ins->sreg1;
  D.27524 = D.26998 << 11;
  D.27525 = D.27523 | D.27524;
  D.27526 = (unsigned int) D.27525;
  MEM[(guint32 *)code] = D.27526;
  code = code + 4;
  goto <D.22782>;
  <D.22875>:
  D.26998 = ins->sreg1;
  D.27524 = D.26998 << 11;
  D.27527 = D.27524 | 1142947840;
  D.26964 = ins->dreg;
  D.27528 = D.26964 << 6;
  D.27529 = D.27527 | D.27528;
  D.27530 = (unsigned int) D.27529;
  MEM[(guint32 *)code] = D.27530;
  code = code + 4;
  goto <D.22782>;
  <D.22876>:
  D.26964 = ins->dreg;
  D.27155 = D.26964 << 16;
  D.27523 = D.27155 | 1140850688;
  D.26998 = ins->sreg1;
  ls_word_idx.93 = ls_word_idx;
  D.27532 = D.26998 + ls_word_idx.93;
  D.27533 = D.27532 << 11;
  D.27534 = D.27523 | D.27533;
  D.27535 = (unsigned int) D.27534;
  MEM[(guint32 *)code] = D.27535;
  code = code + 4;
  D.26964 = ins->dreg;
  D.27008 = D.26964 + 1;
  D.27536 = D.27008 << 16;
  D.27537 = D.27536 | 1140850688;
  D.26998 = ins->sreg1;
  ms_word_idx.94 = ms_word_idx;
  D.27539 = D.26998 + ms_word_idx.94;
  D.27540 = D.27539 << 11;
  D.27541 = D.27537 | D.27540;
  D.27542 = (unsigned int) D.27541;
  MEM[(guint32 *)code] = D.27542;
  code = code + 4;
  goto <D.22782>;
  <D.22877>:
  <D.22878>:
  <D.22879>:
  D.26964 = ins->dreg;
  D.26998 = ins->sreg1;
  if (D.26964 != D.26998) goto <D.27543>; else goto <D.27544>;
  <D.27543>:
  D.26998 = ins->sreg1;
  D.26999 = D.26998 << 21;
  D.26964 = ins->dreg;
  D.27005 = D.26964 << 11;
  D.27545 = D.26999 | D.27005;
  D.27546 = D.27545 | 33;
  D.27547 = (unsigned int) D.27546;
  MEM[(guint32 *)code] = D.27547;
  code = code + 4;
  <D.27544>:
  goto <D.22782>;
  <D.22880>:
  {
    int lsreg;
    int msreg;

    ls_word_idx.93 = ls_word_idx;
    lsreg = ls_word_idx.93 + 2;
    ms_word_idx.94 = ms_word_idx;
    msreg = ms_word_idx.94 + 2;
    D.26998 = ins->sreg1;
    if (D.26998 == msreg) goto <D.27548>; else goto <D.27549>;
    <D.27548>:
    D.26998 = ins->sreg1;
    if (D.26998 != 1) goto <D.27550>; else goto <D.27551>;
    <D.27550>:
    D.26998 = ins->sreg1;
    D.26999 = D.26998 << 21;
    D.27552 = D.26999 | 2081;
    D.27553 = (unsigned int) D.27552;
    MEM[(guint32 *)code] = D.27553;
    code = code + 4;
    <D.27551>:
    D.27000 = ins->sreg2;
    if (D.27000 != msreg) goto <D.27554>; else goto <D.27555>;
    <D.27554>:
    D.27000 = ins->sreg2;
    D.27413 = D.27000 << 21;
    D.27556 = msreg << 11;
    D.27557 = D.27413 | D.27556;
    D.27558 = D.27557 | 33;
    D.27559 = (unsigned int) D.27558;
    MEM[(guint32 *)code] = D.27559;
    code = code + 4;
    <D.27555>:
    D.27560 = lsreg << 11;
    D.27561 = D.27560 | 2097185;
    D.27562 = (unsigned int) D.27561;
    MEM[(guint32 *)code] = D.27562;
    code = code + 4;
    goto <D.27563>;
    <D.27549>:
    D.27000 = ins->sreg2;
    if (D.27000 != msreg) goto <D.27564>; else goto <D.27565>;
    <D.27564>:
    D.27000 = ins->sreg2;
    D.27413 = D.27000 << 21;
    D.27556 = msreg << 11;
    D.27557 = D.27413 | D.27556;
    D.27558 = D.27557 | 33;
    D.27559 = (unsigned int) D.27558;
    MEM[(guint32 *)code] = D.27559;
    code = code + 4;
    <D.27565>:
    D.26998 = ins->sreg1;
    if (D.26998 != lsreg) goto <D.27566>; else goto <D.27567>;
    <D.27566>:
    D.26998 = ins->sreg1;
    D.26999 = D.26998 << 21;
    D.27560 = lsreg << 11;
    D.27568 = D.26999 | D.27560;
    D.27569 = D.27568 | 33;
    D.27570 = (unsigned int) D.27569;
    MEM[(guint32 *)code] = D.27570;
    code = code + 4;
    <D.27567>:
    <D.27563>:
    goto <D.22782>;
  }
  <D.22883>:
  D.26964 = ins->dreg;
  D.26998 = ins->sreg1;
  if (D.26964 != D.26998) goto <D.27571>; else goto <D.27572>;
  <D.27571>:
  D.26998 = ins->sreg1;
  D.27524 = D.26998 << 11;
  D.27573 = D.27524 | 1176502272;
  D.26964 = ins->dreg;
  D.27528 = D.26964 << 6;
  D.27574 = D.27573 | D.27528;
  D.27575 = D.27574 | 6;
  D.27576 = (unsigned int) D.27575;
  MEM[(guint32 *)code] = D.27576;
  code = code + 4;
  <D.27572>:
  goto <D.22782>;
  <D.22884>:
  D.26998 = ins->sreg1;
  D.27524 = D.26998 << 11;
  D.27573 = D.27524 | 1176502272;
  D.26964 = ins->dreg;
  D.27528 = D.26964 << 6;
  D.27574 = D.27573 | D.27528;
  D.27577 = D.27574 | 32;
  D.27578 = (unsigned int) D.27577;
  MEM[(guint32 *)code] = D.27578;
  code = code + 4;
  goto <D.22782>;
  <D.22885>:
  D.26964 = ins->dreg;
  D.26998 = ins->sreg1;
  if (D.26964 != D.26998) goto <D.27579>; else goto <D.27580>;
  <D.27579>:
  D.26998 = ins->sreg1;
  D.27524 = D.26998 << 11;
  D.27573 = D.27524 | 1176502272;
  D.26964 = ins->dreg;
  D.27528 = D.26964 << 6;
  D.27574 = D.27573 | D.27528;
  D.27575 = D.27574 | 6;
  D.27576 = (unsigned int) D.27575;
  MEM[(guint32 *)code] = D.27576;
  code = code + 4;
  <D.27580>:
  goto <D.22782>;
  <D.22886>:
  code = emit_load_volatile_arguments (cfg, code);
  code = mono_arch_emit_epilog_sub (cfg, code);
  code.86 = (int) code;
  D.26935 = cfg->native_code;
  D.26943 = (int) D.26935;
  D.26944 = code.86 - D.26943;
  D.27510 = ins->data.op[0].p;
  mono_add_patch_info (cfg, D.26944, 4, D.27510);
  if (0 != 0) goto <D.27581>; else goto <D.27582>;
  <D.27581>:
  MEM[(guint32 *)code] = 1008271361;
  code = code + 4;
  goto <D.27583>;
  <D.27582>:
  MEM[(guint32 *)code] = 1008271360;
  code = code + 4;
  <D.27583>:
  MEM[(guint32 *)code] = 658046976;
  code = code + 4;
  MEM[(guint32 *)code] = 52428808;
  code = code + 4;
  MEM[(guint32 *)code] = 2099237;
  code = code + 4;
  goto <D.22782>;
  <D.22887>:
  D.26998 = ins->sreg1;
  D.26999 = D.26998 << 21;
  D.27237 = D.26999 | -1946157056;
  D.27584 = (unsigned int) D.27237;
  MEM[(guint32 *)code] = D.27584;
  code = code + 4;
  goto <D.22782>;
  <D.22888>:
  D.27585 = cfg->sig_cookie;
  D.27586 = (short int) D.27585;
  D.27587 = (int) D.27586;
  D.27585 = cfg->sig_cookie;
  D.27588 = D.27587 != D.27585;
  D.27589 = (long int) D.27588;
  D.27590 = __builtin_expect (D.27589, 0);
  if (D.27590 != 0) goto <D.27591>; else goto <D.27592>;
  <D.27591>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 3942, "mips_is_imm16 (cfg->sig_cookie)");
  <D.27592>:
  D.27593 = cfg->frame_reg;
  D.27594 = D.27593 << 21;
  D.27585 = cfg->sig_cookie;
  D.27595 = (unsigned int) D.27585;
  D.27596 = D.27595 & 65535;
  D.27597 = D.27594 | D.27596;
  D.27598 = D.27597 | 2348875776;
  MEM[(guint32 *)code] = D.27598;
  code = code + 4;
  D.26998 = ins->sreg1;
  D.26999 = D.26998 << 21;
  D.27599 = D.26999 | -1409220608;
  D.27600 = (unsigned int) D.27599;
  MEM[(guint32 *)code] = D.27600;
  code = code + 4;
  goto <D.22782>;
  <D.22889>:
  <D.22890>:
  <D.22891>:
  <D.22892>:
  <D.22893>:
  <D.22894>:
  <D.22895>:
  <D.22896>:
  <D.22897>:
  <D.22898>:
  <D.22899>:
  <D.22900>:
  <D.22901>:
  <D.22902>:
  <D.22903>:
  <D.22904>:
  <D.22905>:
  <D.22906>:
  call = ins;
  D.26945 = ins->opcode;
  D.26946 = (int) D.26945;
  switch (D.26946) <default: <D.27635>, case 343: <D.22911>, case 344: <D.22918>, case 345: <D.22924>, case 346: <D.22912>, case 347: <D.22919>, case 348: <D.22925>, case 349: <D.22907>, case 350: <D.22914>, case 351: <D.22920>, case 352: <D.22908>, case 353: <D.22915>, case 354: <D.22921>, case 355: <D.22909>, case 356: <D.22916>, case 357: <D.22922>, case 358: <D.22910>, case 359: <D.22917>, case 360: <D.22923>>
  <D.22907>:
  <D.22908>:
  <D.22909>:
  <D.22910>:
  <D.22911>:
  <D.22912>:
  D.26972 = ins->flags;
  D.26973 = (int) D.26972;
  D.26974 = D.26973 & 1;
  if (D.26974 != 0) goto <D.27601>; else goto <D.27602>;
  <D.27601>:
  offset.92 = (int) offset;
  D.27603 = call->method;
  mono_add_patch_info (cfg, offset.92, 3, D.27603);
  D.27603 = call->method;
  D.27604 = (unsigned int) D.27603;
  D.27605 = D.27604 & 32768;
  if (D.27605 != 0) goto <D.27606>; else goto <D.27607>;
  <D.27606>:
  D.27603 = call->method;
  D.27604 = (unsigned int) D.27603;
  D.27608 = D.27604 >> 16;
  D.27609 = D.27608 + 1;
  D.27610 = D.27609 & 65535;
  D.27611 = D.27610 | 1008271360;
  MEM[(guint32 *)code] = D.27611;
  code = code + 4;
  goto <D.27612>;
  <D.27607>:
  D.27603 = call->method;
  D.27604 = (unsigned int) D.27603;
  D.27608 = D.27604 >> 16;
  D.27613 = D.27608 | 1008271360;
  MEM[(guint32 *)code] = D.27613;
  code = code + 4;
  <D.27612>:
  D.27603 = call->method;
  D.27604 = (unsigned int) D.27603;
  D.27614 = D.27604 & 65535;
  D.27615 = D.27614 | 658046976;
  MEM[(guint32 *)code] = D.27615;
  code = code + 4;
  goto <D.27616>;
  <D.27602>:
  offset.92 = (int) offset;
  D.27617 = call->fptr;
  mono_add_patch_info (cfg, offset.92, 1, D.27617);
  D.27617 = call->fptr;
  D.27618 = (unsigned int) D.27617;
  D.27619 = D.27618 & 32768;
  if (D.27619 != 0) goto <D.27620>; else goto <D.27621>;
  <D.27620>:
  D.27617 = call->fptr;
  D.27618 = (unsigned int) D.27617;
  D.27622 = D.27618 >> 16;
  D.27623 = D.27622 + 1;
  D.27624 = D.27623 & 65535;
  D.27625 = D.27624 | 1008271360;
  MEM[(guint32 *)code] = D.27625;
  code = code + 4;
  goto <D.27626>;
  <D.27621>:
  D.27617 = call->fptr;
  D.27618 = (unsigned int) D.27617;
  D.27622 = D.27618 >> 16;
  D.27627 = D.27622 | 1008271360;
  MEM[(guint32 *)code] = D.27627;
  code = code + 4;
  <D.27626>:
  D.27617 = call->fptr;
  D.27618 = (unsigned int) D.27617;
  D.27628 = D.27618 & 65535;
  D.27629 = D.27628 | 658046976;
  MEM[(guint32 *)code] = D.27629;
  code = code + 4;
  <D.27616>:
  MEM[(guint32 *)code] = 52492297;
  code = code + 4;
  MEM[(guint32 *)code] = 2099237;
  code = code + 4;
  goto <D.22913>;
  <D.22914>:
  <D.22915>:
  <D.22916>:
  <D.22917>:
  <D.22918>:
  <D.22919>:
  D.26998 = ins->sreg1;
  D.26999 = D.26998 << 21;
  D.27630 = D.26999 | 51233;
  D.27631 = (unsigned int) D.27630;
  MEM[(guint32 *)code] = D.27631;
  code = code + 4;
  MEM[(guint32 *)code] = 52492297;
  code = code + 4;
  MEM[(guint32 *)code] = 2099237;
  code = code + 4;
  goto <D.22913>;
  <D.22920>:
  <D.22921>:
  <D.22922>:
  <D.22923>:
  <D.22924>:
  <D.22925>:
  D.26998 = ins->sreg1;
  D.26999 = D.26998 << 21;
  D.27632 = D.26999 | -1944518656;
  D.27035 = ins->data.op[0].const_val;
  D.27042 = D.27035 & 65535;
  D.27633 = D.27632 | D.27042;
  D.27634 = (unsigned int) D.27633;
  MEM[(guint32 *)code] = D.27634;
  code = code + 4;
  MEM[(guint32 *)code] = 52492297;
  code = code + 4;
  MEM[(guint32 *)code] = 2099237;
  code = code + 4;
  goto <D.22913>;
  <D.27635>:
  <D.22913>:
  D.26945 = ins->opcode;
  D.26946 = (int) D.26945;
  switch (D.26946) <default: <D.22930>, case 349: <D.22926>, case 350: <D.22927>, case 351: <D.22928>>
  <D.22926>:
  <D.22927>:
  <D.22928>:
  D.27636 = call->signature;
  D.27637 = D.27636->ret;
  D.27638 = D.27637->type;
  if (D.27638 == 12) goto <D.27639>; else goto <D.27640>;
  <D.27639>:
  MEM[(guint32 *)code] = 1174405153;
  code = code + 4;
  <D.27640>:
  goto <D.22929>;
  <D.22930>:
  goto <D.22929>;
  <D.22929>:
  goto <D.22782>;
  <D.22931>:
  {
    int area_offset;

    D.27641 = cfg->param_area;
    area_offset = (int) D.27641;
    D.26998 = ins->sreg1;
    D.26999 = D.26998 << 21;
    D.27642 = D.26999 | 604045343;
    D.27643 = (unsigned int) D.27642;
    MEM[(guint32 *)code] = D.27643;
    code = code + 4;
    MEM[(guint32 *)code] = 605618144;
    code = code + 4;
    MEM[(guint32 *)code] = 3672100;
    code = code + 4;
    MEM[(guint32 *)code] = 60942371;
    code = code + 4;
    D.27644 = (short int) area_offset;
    D.27645 = (int) D.27644;
    D.27646 = D.27645 != area_offset;
    D.27647 = (long int) D.27646;
    D.27648 = __builtin_expect (D.27647, 0);
    if (D.27648 != 0) goto <D.27649>; else goto <D.27650>;
    <D.27649>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 4028, "mips_is_imm16 (area_offset)");
    <D.27650>:
    D.26964 = ins->dreg;
    D.27155 = D.26964 << 16;
    D.27651 = D.27155 | 664797184;
    D.27652 = area_offset & 65535;
    D.27653 = D.27651 | D.27652;
    D.27654 = (unsigned int) D.27653;
    MEM[(guint32 *)code] = D.27654;
    code = code + 4;
    D.26972 = ins->flags;
    D.26973 = (int) D.26972;
    D.26974 = D.26973 & 1;
    if (D.26974 != 0) goto <D.27655>; else goto <D.27656>;
    <D.27655>:
    {
      guint32 * buf;

      buf = code;
      MEM[(guint32 *)code] = 270532608;
      code = code + 4;
      MEM[(guint32 *)code] = 2099237;
      code = code + 4;
      D.26964 = ins->dreg;
      D.27040 = D.26964 << 21;
      D.27657 = D.27040 | 49185;
      D.27658 = (unsigned int) D.27657;
      MEM[(guint32 *)code] = D.27658;
      code = code + 4;
      MEM[(guint32 *)code] = 2734686208;
      code = code + 4;
      MEM[(guint32 *)code] = 606207999;
      code = code + 4;
      MEM[(guint32 *)code] = 337707005;
      code = code + 4;
      MEM[(guint32 *)code] = 655884289;
      code = code + 4;
      code.91 = (unsigned int) code;
      mips_patch (buf, code.91);
    }
    <D.27656>:
    goto <D.22782>;
  }
  <D.22934>:
  {
    void * addr;

    addr = mono_arch_get_throw_exception (0B, 0);
    D.26998 = ins->sreg1;
    D.26999 = D.26998 << 21;
    D.27659 = D.26999 | 8225;
    D.27660 = (unsigned int) D.27659;
    MEM[(guint32 *)code] = D.27660;
    code = code + 4;
    {
      guint32 _target;

      _target = (guint32) addr;
      if (1 != 0) goto <D.27661>; else goto <D.27662>;
      <D.27661>:
      D.27663 = (short int) _target;
      D.27664 = (int) D.27663;
      _target.95 = (int) _target;
      if (D.27664 != _target.95) goto <D.27666>; else goto <D.27667>;
      <D.27666>:
      D.27668 = _target & 32768;
      if (D.27668 != 0) goto <D.27669>; else goto <D.27670>;
      <D.27669>:
      D.27671 = _target >> 16;
      D.27672 = D.27671 + 1;
      D.27673 = D.27672 & 65535;
      D.27674 = D.27673 | 1008271360;
      MEM[(guint32 *)code] = D.27674;
      code = code + 4;
      goto <D.27675>;
      <D.27670>:
      D.27671 = _target >> 16;
      D.27676 = D.27671 | 1008271360;
      MEM[(guint32 *)code] = D.27676;
      code = code + 4;
      <D.27675>:
      D.27677 = _target & 65535;
      if (D.27677 != 0) goto <D.27678>; else goto <D.27679>;
      <D.27678>:
      D.27677 = _target & 65535;
      D.27680 = D.27677 | 658046976;
      MEM[(guint32 *)code] = D.27680;
      code = code + 4;
      <D.27679>:
      goto <D.27681>;
      <D.27667>:
      D.27677 = _target & 65535;
      D.27682 = D.27677 | 605618176;
      MEM[(guint32 *)code] = D.27682;
      code = code + 4;
      <D.27681>:
      MEM[(guint32 *)code] = 52492297;
      code = code + 4;
      goto <D.27683>;
      <D.27662>:
      D.27684 = _target >> 2;
      D.27685 = D.27684 & 67108863;
      D.27686 = D.27685 | 201326592;
      MEM[(guint32 *)code] = D.27686;
      code = code + 4;
      <D.27683>:
      MEM[(guint32 *)code] = 2099237;
      code = code + 4;
    }
    MEM[(guint32 *)code] = 16141;
    code = code + 4;
    goto <D.22782>;
  }
  <D.22937>:
  {
    void * addr;

    addr = mono_arch_get_rethrow_exception (0B, 0);
    D.26998 = ins->sreg1;
    D.26999 = D.26998 << 21;
    D.27659 = D.26999 | 8225;
    D.27660 = (unsigned int) D.27659;
    MEM[(guint32 *)code] = D.27660;
    code = code + 4;
    {
      guint32 _target;

      _target = (guint32) addr;
      if (1 != 0) goto <D.27687>; else goto <D.27688>;
      <D.27687>:
      D.27689 = (short int) _target;
      D.27690 = (int) D.27689;
      _target.96 = (int) _target;
      if (D.27690 != _target.96) goto <D.27692>; else goto <D.27693>;
      <D.27692>:
      D.27694 = _target & 32768;
      if (D.27694 != 0) goto <D.27695>; else goto <D.27696>;
      <D.27695>:
      D.27697 = _target >> 16;
      D.27698 = D.27697 + 1;
      D.27699 = D.27698 & 65535;
      D.27700 = D.27699 | 1008271360;
      MEM[(guint32 *)code] = D.27700;
      code = code + 4;
      goto <D.27701>;
      <D.27696>:
      D.27697 = _target >> 16;
      D.27702 = D.27697 | 1008271360;
      MEM[(guint32 *)code] = D.27702;
      code = code + 4;
      <D.27701>:
      D.27703 = _target & 65535;
      if (D.27703 != 0) goto <D.27704>; else goto <D.27705>;
      <D.27704>:
      D.27703 = _target & 65535;
      D.27706 = D.27703 | 658046976;
      MEM[(guint32 *)code] = D.27706;
      code = code + 4;
      <D.27705>:
      goto <D.27707>;
      <D.27693>:
      D.27703 = _target & 65535;
      D.27708 = D.27703 | 605618176;
      MEM[(guint32 *)code] = D.27708;
      code = code + 4;
      <D.27707>:
      MEM[(guint32 *)code] = 52492297;
      code = code + 4;
      goto <D.27709>;
      <D.27688>:
      D.27710 = _target >> 2;
      D.27711 = D.27710 & 67108863;
      D.27712 = D.27711 | 201326592;
      MEM[(guint32 *)code] = D.27712;
      code = code + 4;
      <D.27709>:
      MEM[(guint32 *)code] = 2099237;
      code = code + 4;
    }
    MEM[(guint32 *)code] = 16077;
    code = code + 4;
    goto <D.22782>;
  }
  <D.22940>:
  {
    struct MonoInst * spvar;

    D.27713 = bb->region;
    D.27714 = (int) D.27713;
    spvar = mono_find_spvar_for_region (cfg, D.27714);
    D.27715 = spvar->sreg1;
    D.27716 = D.27715 == 29;
    D.27717 = (long int) D.27716;
    D.27718 = __builtin_expect (D.27717, 0);
    if (D.27718 != 0) goto <D.27719>; else goto <D.27720>;
    <D.27719>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 4073, "spvar->inst_basereg != mips_sp");
    <D.27720>:
    code = emit_reserve_param_area (cfg, code);
    D.27721 = spvar->data.op[0].const_val;
    D.27722 = (short int) D.27721;
    D.27723 = (int) D.27722;
    D.27721 = spvar->data.op[0].const_val;
    if (D.27723 == D.27721) goto <D.27724>; else goto <D.27725>;
    <D.27724>:
    D.27715 = spvar->sreg1;
    D.27726 = D.27715 << 21;
    D.27727 = D.27726 | -1407254528;
    D.27721 = spvar->data.op[0].const_val;
    D.27728 = D.27721 & 65535;
    D.27729 = D.27727 | D.27728;
    D.27730 = (unsigned int) D.27729;
    MEM[(guint32 *)code] = D.27730;
    code = code + 4;
    goto <D.27731>;
    <D.27725>:
    D.27721 = spvar->data.op[0].const_val;
    D.27722 = (short int) D.27721;
    D.27723 = (int) D.27722;
    D.27721 = spvar->data.op[0].const_val;
    if (D.27723 != D.27721) goto <D.27732>; else goto <D.27733>;
    <D.27732>:
    D.27721 = spvar->data.op[0].const_val;
    D.27734 = (unsigned int) D.27721;
    D.27735 = D.27734 & 32768;
    if (D.27735 != 0) goto <D.27736>; else goto <D.27737>;
    <D.27736>:
    D.27721 = spvar->data.op[0].const_val;
    D.27734 = (unsigned int) D.27721;
    D.27738 = D.27734 >> 16;
    D.27739 = D.27738 + 1;
    D.27740 = D.27739 & 65535;
    D.27741 = D.27740 | 1006698496;
    MEM[(guint32 *)code] = D.27741;
    code = code + 4;
    goto <D.27742>;
    <D.27737>:
    D.27721 = spvar->data.op[0].const_val;
    D.27734 = (unsigned int) D.27721;
    D.27738 = D.27734 >> 16;
    D.27743 = D.27738 | 1006698496;
    MEM[(guint32 *)code] = D.27743;
    code = code + 4;
    <D.27742>:
    D.27721 = spvar->data.op[0].const_val;
    D.27734 = (unsigned int) D.27721;
    D.27744 = D.27734 & 65535;
    if (D.27744 != 0) goto <D.27745>; else goto <D.27746>;
    <D.27745>:
    D.27721 = spvar->data.op[0].const_val;
    D.27734 = (unsigned int) D.27721;
    D.27744 = D.27734 & 65535;
    D.27747 = D.27744 | 606142464;
    MEM[(guint32 *)code] = D.27747;
    code = code + 4;
    <D.27746>:
    goto <D.27748>;
    <D.27733>:
    D.27721 = spvar->data.op[0].const_val;
    D.27734 = (unsigned int) D.27721;
    D.27744 = D.27734 & 65535;
    D.27749 = D.27744 | 604045312;
    MEM[(guint32 *)code] = D.27749;
    code = code + 4;
    <D.27748>:
    D.27715 = spvar->sreg1;
    D.27750 = D.27715 << 16;
    D.27751 = D.27750 | 2099233;
    D.27752 = (unsigned int) D.27751;
    MEM[(guint32 *)code] = D.27752;
    code = code + 4;
    MEM[(guint32 *)code] = 2889809920;
    code = code + 4;
    <D.27731>:
    goto <D.22782>;
  }
  <D.22942>:
  {
    struct MonoInst * spvar;

    D.27713 = bb->region;
    D.27714 = (int) D.27713;
    spvar = mono_find_spvar_for_region (cfg, D.27714);
    D.27753 = spvar->sreg1;
    D.27754 = D.27753 == 29;
    D.27755 = (long int) D.27754;
    D.27756 = __builtin_expect (D.27755, 0);
    if (D.27756 != 0) goto <D.27757>; else goto <D.27758>;
    <D.27757>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 4087, "spvar->inst_basereg != mips_sp");
    <D.27758>:
    code = emit_unreserve_param_area (cfg, code);
    D.26998 = ins->sreg1;
    if (D.26998 != 2) goto <D.27759>; else goto <D.27760>;
    <D.27759>:
    D.26998 = ins->sreg1;
    D.26999 = D.26998 << 21;
    D.27761 = D.26999 | 4129;
    D.27762 = (unsigned int) D.27761;
    MEM[(guint32 *)code] = D.27762;
    code = code + 4;
    <D.27760>:
    D.27763 = spvar->data.op[0].const_val;
    D.27764 = (short int) D.27763;
    D.27765 = (int) D.27764;
    D.27763 = spvar->data.op[0].const_val;
    if (D.27765 == D.27763) goto <D.27766>; else goto <D.27767>;
    <D.27766>:
    D.27753 = spvar->sreg1;
    D.27768 = D.27753 << 21;
    D.27769 = D.27768 | -1944125440;
    D.27763 = spvar->data.op[0].const_val;
    D.27770 = D.27763 & 65535;
    D.27771 = D.27769 | D.27770;
    D.27772 = (unsigned int) D.27771;
    MEM[(guint32 *)code] = D.27772;
    code = code + 4;
    goto <D.27773>;
    <D.27767>:
    D.27763 = spvar->data.op[0].const_val;
    D.27764 = (short int) D.27763;
    D.27765 = (int) D.27764;
    D.27763 = spvar->data.op[0].const_val;
    if (D.27765 != D.27763) goto <D.27774>; else goto <D.27775>;
    <D.27774>:
    D.27763 = spvar->data.op[0].const_val;
    D.27776 = (unsigned int) D.27763;
    D.27777 = D.27776 & 32768;
    if (D.27777 != 0) goto <D.27778>; else goto <D.27779>;
    <D.27778>:
    D.27763 = spvar->data.op[0].const_val;
    D.27776 = (unsigned int) D.27763;
    D.27780 = D.27776 >> 16;
    D.27781 = D.27780 + 1;
    D.27782 = D.27781 & 65535;
    D.27783 = D.27782 | 1006698496;
    MEM[(guint32 *)code] = D.27783;
    code = code + 4;
    goto <D.27784>;
    <D.27779>:
    D.27763 = spvar->data.op[0].const_val;
    D.27776 = (unsigned int) D.27763;
    D.27780 = D.27776 >> 16;
    D.27785 = D.27780 | 1006698496;
    MEM[(guint32 *)code] = D.27785;
    code = code + 4;
    <D.27784>:
    D.27763 = spvar->data.op[0].const_val;
    D.27776 = (unsigned int) D.27763;
    D.27786 = D.27776 & 65535;
    if (D.27786 != 0) goto <D.27787>; else goto <D.27788>;
    <D.27787>:
    D.27763 = spvar->data.op[0].const_val;
    D.27776 = (unsigned int) D.27763;
    D.27786 = D.27776 & 65535;
    D.27789 = D.27786 | 606142464;
    MEM[(guint32 *)code] = D.27789;
    code = code + 4;
    <D.27788>:
    goto <D.27790>;
    <D.27775>:
    D.27763 = spvar->data.op[0].const_val;
    D.27776 = (unsigned int) D.27763;
    D.27786 = D.27776 & 65535;
    D.27791 = D.27786 | 604045312;
    MEM[(guint32 *)code] = D.27791;
    code = code + 4;
    <D.27790>:
    D.27753 = spvar->sreg1;
    D.27792 = D.27753 << 16;
    D.27793 = D.27792 | 2099233;
    D.27794 = (unsigned int) D.27793;
    MEM[(guint32 *)code] = D.27794;
    code = code + 4;
    MEM[(guint32 *)code] = 2352939008;
    code = code + 4;
    <D.27773>:
    MEM[(guint32 *)code] = 65011720;
    code = code + 4;
    MEM[(guint32 *)code] = 2099237;
    code = code + 4;
    goto <D.22782>;
  }
  <D.22944>:
  {
    struct MonoInst * spvar;

    D.27713 = bb->region;
    D.27714 = (int) D.27713;
    spvar = mono_find_spvar_for_region (cfg, D.27714);
    D.27795 = spvar->sreg1;
    D.27796 = D.27795 == 29;
    D.27797 = (long int) D.27796;
    D.27798 = __builtin_expect (D.27797, 0);
    if (D.27798 != 0) goto <D.27799>; else goto <D.27800>;
    <D.27799>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 4105, "spvar->inst_basereg != mips_sp");
    <D.27800>:
    code = emit_unreserve_param_area (cfg, code);
    D.27795 = spvar->sreg1;
    D.27801 = D.27795 << 21;
    D.27802 = D.27801 | -1944518656;
    D.27803 = spvar->data.op[0].const_val;
    D.27804 = D.27803 & 65535;
    D.27805 = D.27802 | D.27804;
    D.27806 = (unsigned int) D.27805;
    MEM[(guint32 *)code] = D.27806;
    code = code + 4;
    MEM[(guint32 *)code] = 52492297;
    code = code + 4;
    MEM[(guint32 *)code] = 2099237;
    code = code + 4;
    goto <D.22782>;
  }
  <D.22946>:
  offset.92 = (int) offset;
  D.27807 = ins->data.op[0].target_block;
  mono_add_patch_info (cfg, offset.92, 0, D.27807);
  MEM[(guint32 *)code] = 1008271360;
  code = code + 4;
  MEM[(guint32 *)code] = 658046976;
  code = code + 4;
  MEM[(guint32 *)code] = 52492297;
  code = code + 4;
  MEM[(guint32 *)code] = 2099237;
  code = code + 4;
  D.27808 = ins->data.op[1].exception_clause;
  mono_cfg_add_try_hole (cfg, D.27808, code, bb);
  goto <D.22782>;
  <D.22947>:
  code.86 = (int) code;
  D.26935 = cfg->native_code;
  D.26943 = (int) D.26935;
  D.26944 = code.86 - D.26943;
  ins->data.op[0].const_val = D.26944;
  goto <D.22782>;
  <D.22948>:
  offset.92 = (int) offset;
  D.27807 = ins->data.op[0].target_block;
  mono_add_patch_info (cfg, offset.92, 0, D.27807);
  D.27809 = cfg->arch.long_branch;
  if (D.27809 != 0) goto <D.27810>; else goto <D.27811>;
  <D.27810>:
  MEM[(guint32 *)code] = 1006698496;
  code = code + 4;
  MEM[(guint32 *)code] = 606142464;
  code = code + 4;
  MEM[(guint32 *)code] = 2097160;
  code = code + 4;
  MEM[(guint32 *)code] = 2099237;
  code = code + 4;
  goto <D.27812>;
  <D.27811>:
  MEM[(guint32 *)code] = 268435456;
  code = code + 4;
  MEM[(guint32 *)code] = 2099237;
  code = code + 4;
  <D.27812>:
  goto <D.22782>;
  <D.22949>:
  D.26998 = ins->sreg1;
  D.26999 = D.26998 << 21;
  D.27813 = D.26999 | 8;
  D.27814 = (unsigned int) D.27813;
  MEM[(guint32 *)code] = D.27814;
  code = code + 4;
  MEM[(guint32 *)code] = 2099237;
  code = code + 4;
  goto <D.22782>;
  <D.22950>:
  {
    int i;

    D.27815 = ins->klass;
    D.27816 = (int) D.27815;
    D.27817 = D.27816 * 4;
    max_len = D.27817 + max_len;
    D.26953 = cfg->code_size;
    max_len.87 = (unsigned int) max_len;
    D.26955 = D.26953 - max_len.87;
    D.26956 = D.26955 + 4294967280;
    if (D.26956 < offset) goto <D.27818>; else goto <D.27819>;
    <D.27818>:
    D.26953 = cfg->code_size;
    max_len.87 = (unsigned int) max_len;
    D.27820 = D.26953 + max_len.87;
    cfg->code_size = D.27820;
    D.26953 = cfg->code_size;
    D.26959 = D.26953 * 2;
    cfg->code_size = D.26959;
    D.26935 = cfg->native_code;
    D.26953 = cfg->code_size;
    D.27821 = monoeg_realloc (D.26935, D.26953);
    cfg->native_code = D.27821;
    D.26935 = cfg->native_code;
    code = D.26935 + offset;
    <D.27819>:
    D.26998 = ins->sreg1;
    D.27822 = D.26998 == -1;
    D.27823 = (long int) D.27822;
    D.27824 = __builtin_expect (D.27823, 0);
    if (D.27824 != 0) goto <D.27825>; else goto <D.27826>;
    <D.27825>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 4151, "ins->sreg1 != -1");
    <D.27826>:
    D.26998 = ins->sreg1;
    D.27142 = D.26998 << 16;
    D.27827 = D.27142 | 2176;
    D.27828 = (unsigned int) D.27827;
    MEM[(guint32 *)code] = D.27828;
    code = code + 4;
    if (1 != 0) goto <D.27829>; else goto <D.27830>;
    <D.27829>:
    MEM[(guint32 *)code] = 65060897;
    code = code + 4;
    <D.27830>:
    MEM[(guint32 *)code] = 68222977;
    code = code + 4;
    MEM[(guint32 *)code] = 2099237;
    code = code + 4;
    MEM[(guint32 *)code] = 65128481;
    code = code + 4;
    if (1 != 0) goto <D.27831>; else goto <D.27832>;
    <D.27831>:
    MEM[(guint32 *)code] = 50395169;
    code = code + 4;
    MEM[(guint32 *)code] = 2402877460;
    code = code + 4;
    goto <D.27833>;
    <D.27832>:
    MEM[(guint32 *)code] = 2402877456;
    code = code + 4;
    <D.27833>:
    MEM[(guint32 *)code] = 52477961;
    code = code + 4;
    MEM[(guint32 *)code] = 2099237;
    code = code + 4;
    i = 0;
    goto <D.22953>;
    <D.22952>:
    MEM[(guint32 *)code] = 4278124286;
    code = code + 4;
    i = i + 1;
    <D.22953>:
    D.27815 = ins->klass;
    D.27816 = (int) D.27815;
    if (D.27816 > i) goto <D.22952>; else goto <D.22954>;
    <D.22954>:
    goto <D.22782>;
  }
  <D.22955>:
  <D.22956>:
  D.26964 = ins->dreg;
  D.27155 = D.26964 << 16;
  D.27834 = D.27155 | 603979777;
  D.27835 = (unsigned int) D.27834;
  MEM[(guint32 *)code] = D.27835;
  code = code + 4;
  MEM[(guint32 *)code] = 270532610;
  code = code + 4;
  MEM[(guint32 *)code] = 2099237;
  code = code + 4;
  D.26964 = ins->dreg;
  D.27005 = D.26964 << 11;
  D.27836 = D.27005 | 33;
  D.27837 = (unsigned int) D.27836;
  MEM[(guint32 *)code] = D.27837;
  code = code + 4;
  goto <D.22782>;
  <D.22957>:
  <D.22958>:
  <D.22959>:
  <D.22960>:
  D.26964 = ins->dreg;
  D.27155 = D.26964 << 16;
  D.27834 = D.27155 | 603979777;
  D.27835 = (unsigned int) D.27834;
  MEM[(guint32 *)code] = D.27835;
  code = code + 4;
  MEM[(guint32 *)code] = 69206018;
  code = code + 4;
  MEM[(guint32 *)code] = 2099237;
  code = code + 4;
  D.26964 = ins->dreg;
  D.27005 = D.26964 << 11;
  D.27836 = D.27005 | 33;
  D.27837 = (unsigned int) D.27836;
  MEM[(guint32 *)code] = D.27837;
  code = code + 4;
  goto <D.22782>;
  <D.22961>:
  <D.22962>:
  <D.22963>:
  <D.22964>:
  D.26964 = ins->dreg;
  D.27155 = D.26964 << 16;
  D.27834 = D.27155 | 603979777;
  D.27835 = (unsigned int) D.27834;
  MEM[(guint32 *)code] = D.27835;
  code = code + 4;
  MEM[(guint32 *)code] = 471859202;
  code = code + 4;
  MEM[(guint32 *)code] = 2099237;
  code = code + 4;
  D.26964 = ins->dreg;
  D.27005 = D.26964 << 11;
  D.27836 = D.27005 | 33;
  D.27837 = (unsigned int) D.27836;
  MEM[(guint32 *)code] = D.27837;
  code = code + 4;
  goto <D.22782>;
  <D.22965>:
  <D.22966>:
  <D.22967>:
  <D.22968>:
  <D.22969>:
  <D.22970>:
  <D.22971>:
  <D.22972>:
  <D.22973>:
  <D.22974>:
  <D.22975>:
  <D.22976>:
  <D.22977>:
  <D.22978>:
  <D.22979>:
  <D.22980>:
  <D.22981>:
  <D.22982>:
  <D.22983>:
  <D.22984>:
  <D.22985>:
  <D.22986>:
  <D.22987>:
  <D.22988>:
  <D.22989>:
  <D.22990>:
  <D.22991>:
  <D.22992>:
  {
    guint32 * skip;
    guint32 * throw;

    D.26945 = ins->opcode;
    D.26946 = (int) D.26945;
    switch (D.26946) <default: <D.23003>, case 872: <D.22995>, case 874: <D.22999>, case 876: <D.23001>, case 877: <D.22997>, case 879: <D.23000>, case 880: <D.22998>, case 881: <D.23002>>
    <D.22995>:
    throw = code;
    D.26998 = ins->sreg1;
    D.26999 = D.26998 << 21;
    D.27838 = D.26999 | 268435456;
    D.27000 = ins->sreg2;
    D.27001 = D.27000 << 16;
    D.27839 = D.27838 | D.27001;
    D.27840 = (unsigned int) D.27839;
    MEM[(guint32 *)code] = D.27840;
    code = code + 4;
    MEM[(guint32 *)code] = 2099237;
    code = code + 4;
    goto <D.22996>;
    <D.22997>:
    throw = code;
    D.26998 = ins->sreg1;
    D.26999 = D.26998 << 21;
    D.27841 = D.26999 | 335544320;
    D.27000 = ins->sreg2;
    D.27001 = D.27000 << 16;
    D.27842 = D.27841 | D.27001;
    D.27843 = (unsigned int) D.27842;
    MEM[(guint32 *)code] = D.27843;
    code = code + 4;
    MEM[(guint32 *)code] = 2099237;
    code = code + 4;
    goto <D.22996>;
    <D.22998>:
    D.27000 = ins->sreg2;
    D.27413 = D.27000 << 21;
    D.26998 = ins->sreg1;
    D.27142 = D.26998 << 16;
    D.27452 = D.27413 | D.27142;
    D.27844 = D.27452 | 2091;
    D.27845 = (unsigned int) D.27844;
    MEM[(guint32 *)code] = D.27845;
    code = code + 4;
    throw = code;
    MEM[(guint32 *)code] = 270532608;
    code = code + 4;
    MEM[(guint32 *)code] = 2099237;
    code = code + 4;
    goto <D.22996>;
    <D.22999>:
    D.27000 = ins->sreg2;
    D.27413 = D.27000 << 21;
    D.26998 = ins->sreg1;
    D.27142 = D.26998 << 16;
    D.27452 = D.27413 | D.27142;
    D.27846 = D.27452 | 2090;
    D.27847 = (unsigned int) D.27846;
    MEM[(guint32 *)code] = D.27847;
    code = code + 4;
    throw = code;
    MEM[(guint32 *)code] = 337641472;
    code = code + 4;
    MEM[(guint32 *)code] = 2099237;
    code = code + 4;
    goto <D.22996>;
    <D.23000>:
    D.27000 = ins->sreg2;
    D.27413 = D.27000 << 21;
    D.26998 = ins->sreg1;
    D.27142 = D.26998 << 16;
    D.27452 = D.27413 | D.27142;
    D.27844 = D.27452 | 2091;
    D.27845 = (unsigned int) D.27844;
    MEM[(guint32 *)code] = D.27845;
    code = code + 4;
    throw = code;
    MEM[(guint32 *)code] = 337641472;
    code = code + 4;
    MEM[(guint32 *)code] = 2099237;
    code = code + 4;
    goto <D.22996>;
    <D.23001>:
    D.26998 = ins->sreg1;
    D.26999 = D.26998 << 21;
    D.27000 = ins->sreg2;
    D.27001 = D.27000 << 16;
    D.27002 = D.26999 | D.27001;
    D.27848 = D.27002 | 2090;
    D.27849 = (unsigned int) D.27848;
    MEM[(guint32 *)code] = D.27849;
    code = code + 4;
    throw = code;
    MEM[(guint32 *)code] = 337641472;
    code = code + 4;
    MEM[(guint32 *)code] = 2099237;
    code = code + 4;
    goto <D.22996>;
    <D.23002>:
    D.26998 = ins->sreg1;
    D.26999 = D.26998 << 21;
    D.27000 = ins->sreg2;
    D.27001 = D.27000 << 16;
    D.27002 = D.26999 | D.27001;
    D.27850 = D.27002 | 2091;
    D.27851 = (unsigned int) D.27850;
    MEM[(guint32 *)code] = D.27851;
    code = code + 4;
    throw = code;
    MEM[(guint32 *)code] = 337641472;
    code = code + 4;
    MEM[(guint32 *)code] = 2099237;
    code = code + 4;
    goto <D.22996>;
    <D.23003>:
    D.26945 = ins->opcode;
    D.26946 = (int) D.26945;
    D.27852 = mono_inst_name (D.26946);
    monoeg_g_log (0B, 16, "NYI conditional exception %s\n", D.27852);
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-mips.c", 4290);
    <D.22996>:
    skip = code;
    MEM[(guint32 *)code] = 268435456;
    code = code + 4;
    MEM[(guint32 *)code] = 2099237;
    code = code + 4;
    code.91 = (unsigned int) code;
    mips_patch (throw, code.91);
    D.27853 = ins->data.op[1].p;
    code = mips_emit_exc_by_name (code, D.27853);
    code.91 = (unsigned int) code;
    mips_patch (skip, code.91);
    D.27418 = cfg->bb_exit;
    D.27418 = cfg->bb_exit;
    D.27419 = D.27418->max_offset;
    D.27854 = D.27419 + 24;
    D.27418->max_offset = D.27854;
    goto <D.22782>;
  }
  <D.23004>:
  <D.23005>:
  <D.23006>:
  <D.23007>:
  <D.23008>:
  <D.23009>:
  D.26945 = ins->opcode;
  D.26946 = (int) D.26945;
  code = mips_emit_cond_branch (cfg, code, D.26946, ins);
  goto <D.22782>;
  <D.23010>:
  D.27510 = ins->data.op[0].p;
  D.27855 = (int) D.27510;
  D.27856 = (short int) D.27855;
  D.27857 = (int) D.27856;
  D.27510 = ins->data.op[0].p;
  D.27855 = (int) D.27510;
  if (D.27857 != D.27855) goto <D.27858>; else goto <D.27859>;
  <D.27858>:
  D.27510 = ins->data.op[0].p;
  D.27860 = (unsigned int) D.27510;
  D.27861 = D.27860 & 32768;
  if (D.27861 != 0) goto <D.27862>; else goto <D.27863>;
  <D.27862>:
  D.27510 = ins->data.op[0].p;
  D.27860 = (unsigned int) D.27510;
  D.27864 = D.27860 >> 16;
  D.27865 = D.27864 + 1;
  D.27866 = D.27865 & 65535;
  D.27867 = D.27866 | 1006698496;
  MEM[(guint32 *)code] = D.27867;
  code = code + 4;
  goto <D.27868>;
  <D.27863>:
  D.27510 = ins->data.op[0].p;
  D.27860 = (unsigned int) D.27510;
  D.27864 = D.27860 >> 16;
  D.27869 = D.27864 | 1006698496;
  MEM[(guint32 *)code] = D.27869;
  code = code + 4;
  <D.27868>:
  D.27510 = ins->data.op[0].p;
  D.27860 = (unsigned int) D.27510;
  D.27870 = D.27860 & 65535;
  if (D.27870 != 0) goto <D.27871>; else goto <D.27872>;
  <D.27871>:
  D.27510 = ins->data.op[0].p;
  D.27860 = (unsigned int) D.27510;
  D.27870 = D.27860 & 65535;
  D.27873 = D.27870 | 606142464;
  MEM[(guint32 *)code] = D.27873;
  code = code + 4;
  <D.27872>:
  goto <D.27874>;
  <D.27859>:
  D.27510 = ins->data.op[0].p;
  D.27860 = (unsigned int) D.27510;
  D.27870 = D.27860 & 65535;
  D.27875 = D.27870 | 604045312;
  MEM[(guint32 *)code] = D.27875;
  code = code + 4;
  <D.27874>:
  D.26964 = ins->dreg;
  D.27155 = D.26964 << 16;
  D.27876 = D.27155 | -1004535808;
  ls_word_offset.97 = ls_word_offset;
  D.27878 = ls_word_offset.97 & 65535;
  D.27879 = D.27876 | D.27878;
  D.27880 = (unsigned int) D.27879;
  MEM[(guint32 *)code] = D.27880;
  code = code + 4;
  D.26964 = ins->dreg;
  D.27008 = D.26964 + 1;
  D.27536 = D.27008 << 16;
  D.27881 = D.27536 | -1004535808;
  ms_word_offset.98 = ms_word_offset;
  D.27883 = ms_word_offset.98 & 65535;
  D.27884 = D.27881 | D.27883;
  D.27885 = (unsigned int) D.27884;
  MEM[(guint32 *)code] = D.27885;
  code = code + 4;
  goto <D.22782>;
  <D.23011>:
  D.27510 = ins->data.op[0].p;
  D.27860 = (unsigned int) D.27510;
  D.27861 = D.27860 & 32768;
  if (D.27861 != 0) goto <D.27886>; else goto <D.27887>;
  <D.27886>:
  D.27510 = ins->data.op[0].p;
  D.27860 = (unsigned int) D.27510;
  D.27864 = D.27860 >> 16;
  D.27865 = D.27864 + 1;
  D.27866 = D.27865 & 65535;
  D.27867 = D.27866 | 1006698496;
  MEM[(guint32 *)code] = D.27867;
  code = code + 4;
  goto <D.27888>;
  <D.27887>:
  D.27510 = ins->data.op[0].p;
  D.27860 = (unsigned int) D.27510;
  D.27864 = D.27860 >> 16;
  D.27869 = D.27864 | 1006698496;
  MEM[(guint32 *)code] = D.27869;
  code = code + 4;
  <D.27888>:
  D.26964 = ins->dreg;
  D.27155 = D.26964 << 16;
  D.27492 = (unsigned int) D.27155;
  D.27510 = ins->data.op[0].p;
  D.27860 = (unsigned int) D.27510;
  D.27870 = D.27860 & 65535;
  D.27889 = D.27492 | D.27870;
  D.27890 = D.27889 | 3290431488;
  MEM[(guint32 *)code] = D.27890;
  code = code + 4;
  D.26964 = ins->dreg;
  D.27005 = D.26964 << 11;
  D.27891 = D.27005 | 1174405120;
  D.26964 = ins->dreg;
  D.27528 = D.26964 << 6;
  D.27892 = D.27891 | D.27528;
  D.27893 = D.27892 | 33;
  D.27894 = (unsigned int) D.27893;
  MEM[(guint32 *)code] = D.27894;
  code = code + 4;
  goto <D.22782>;
  <D.23012>:
  D.27035 = ins->data.op[0].const_val;
  D.27036 = (short int) D.27035;
  D.27037 = (int) D.27036;
  D.27035 = ins->data.op[0].const_val;
  if (D.27037 == D.27035) goto <D.27895>; else goto <D.27896>;
  <D.27895>:
  D.26964 = ins->dreg;
  D.27040 = D.26964 << 21;
  D.27897 = D.27040 | -469762048;
  D.26998 = ins->sreg1;
  D.27142 = D.26998 << 16;
  D.27898 = D.27897 | D.27142;
  D.27035 = ins->data.op[0].const_val;
  ls_word_offset.97 = ls_word_offset;
  D.27899 = D.27035 + ls_word_offset.97;
  D.27900 = D.27899 & 65535;
  D.27901 = D.27898 | D.27900;
  D.27902 = (unsigned int) D.27901;
  MEM[(guint32 *)code] = D.27902;
  code = code + 4;
  D.26964 = ins->dreg;
  D.27040 = D.26964 << 21;
  D.27897 = D.27040 | -469762048;
  D.26998 = ins->sreg1;
  D.27903 = D.26998 + 1;
  D.27904 = D.27903 << 16;
  D.27905 = D.27897 | D.27904;
  D.27035 = ins->data.op[0].const_val;
  ms_word_offset.98 = ms_word_offset;
  D.27906 = D.27035 + ms_word_offset.98;
  D.27907 = D.27906 & 65535;
  D.27908 = D.27905 | D.27907;
  D.27909 = (unsigned int) D.27908;
  MEM[(guint32 *)code] = D.27909;
  code = code + 4;
  goto <D.27910>;
  <D.27896>:
  D.27035 = ins->data.op[0].const_val;
  D.27036 = (short int) D.27035;
  D.27037 = (int) D.27036;
  D.27035 = ins->data.op[0].const_val;
  if (D.27037 != D.27035) goto <D.27911>; else goto <D.27912>;
  <D.27911>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27049 = D.27048 & 32768;
  if (D.27049 != 0) goto <D.27913>; else goto <D.27914>;
  <D.27913>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27052 = D.27048 >> 16;
  D.27053 = D.27052 + 1;
  D.27054 = D.27053 & 65535;
  D.27055 = D.27054 | 1006698496;
  MEM[(guint32 *)code] = D.27055;
  code = code + 4;
  goto <D.27915>;
  <D.27914>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27052 = D.27048 >> 16;
  D.27057 = D.27052 | 1006698496;
  MEM[(guint32 *)code] = D.27057;
  code = code + 4;
  <D.27915>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27058 = D.27048 & 65535;
  if (D.27058 != 0) goto <D.27916>; else goto <D.27917>;
  <D.27916>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27058 = D.27048 & 65535;
  D.27061 = D.27058 | 606142464;
  MEM[(guint32 *)code] = D.27061;
  code = code + 4;
  <D.27917>:
  goto <D.27918>;
  <D.27912>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27058 = D.27048 & 65535;
  D.27063 = D.27058 | 604045312;
  MEM[(guint32 *)code] = D.27063;
  code = code + 4;
  <D.27918>:
  D.26964 = ins->dreg;
  D.27155 = D.26964 << 16;
  D.27156 = D.27155 | 2099233;
  D.27157 = (unsigned int) D.27156;
  MEM[(guint32 *)code] = D.27157;
  code = code + 4;
  D.26998 = ins->sreg1;
  D.27142 = D.26998 << 16;
  D.27919 = D.27142 | -467664896;
  ls_word_offset.97 = ls_word_offset;
  D.27878 = ls_word_offset.97 & 65535;
  D.27920 = D.27919 | D.27878;
  D.27921 = (unsigned int) D.27920;
  MEM[(guint32 *)code] = D.27921;
  code = code + 4;
  D.26998 = ins->sreg1;
  D.27903 = D.26998 + 1;
  D.27904 = D.27903 << 16;
  D.27922 = D.27904 | -467664896;
  ms_word_offset.98 = ms_word_offset;
  D.27883 = ms_word_offset.98 & 65535;
  D.27923 = D.27922 | D.27883;
  D.27924 = (unsigned int) D.27923;
  MEM[(guint32 *)code] = D.27924;
  code = code + 4;
  <D.27910>:
  goto <D.22782>;
  <D.23013>:
  D.27035 = ins->data.op[0].const_val;
  D.27036 = (short int) D.27035;
  D.27037 = (int) D.27036;
  D.27035 = ins->data.op[0].const_val;
  if (D.27037 == D.27035) goto <D.27925>; else goto <D.27926>;
  <D.27925>:
  D.26998 = ins->sreg1;
  D.26999 = D.26998 << 21;
  D.27927 = D.26999 | -1006632960;
  D.26964 = ins->dreg;
  D.27155 = D.26964 << 16;
  D.27928 = D.27927 | D.27155;
  D.27035 = ins->data.op[0].const_val;
  ls_word_offset.97 = ls_word_offset;
  D.27899 = D.27035 + ls_word_offset.97;
  D.27900 = D.27899 & 65535;
  D.27929 = D.27928 | D.27900;
  D.27930 = (unsigned int) D.27929;
  MEM[(guint32 *)code] = D.27930;
  code = code + 4;
  D.26998 = ins->sreg1;
  D.26999 = D.26998 << 21;
  D.27927 = D.26999 | -1006632960;
  D.26964 = ins->dreg;
  D.27008 = D.26964 + 1;
  D.27536 = D.27008 << 16;
  D.27931 = D.27927 | D.27536;
  D.27035 = ins->data.op[0].const_val;
  ms_word_offset.98 = ms_word_offset;
  D.27906 = D.27035 + ms_word_offset.98;
  D.27907 = D.27906 & 65535;
  D.27932 = D.27931 | D.27907;
  D.27933 = (unsigned int) D.27932;
  MEM[(guint32 *)code] = D.27933;
  code = code + 4;
  goto <D.27934>;
  <D.27926>:
  D.27035 = ins->data.op[0].const_val;
  D.27036 = (short int) D.27035;
  D.27037 = (int) D.27036;
  D.27035 = ins->data.op[0].const_val;
  if (D.27037 != D.27035) goto <D.27935>; else goto <D.27936>;
  <D.27935>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27049 = D.27048 & 32768;
  if (D.27049 != 0) goto <D.27937>; else goto <D.27938>;
  <D.27937>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27052 = D.27048 >> 16;
  D.27053 = D.27052 + 1;
  D.27054 = D.27053 & 65535;
  D.27055 = D.27054 | 1006698496;
  MEM[(guint32 *)code] = D.27055;
  code = code + 4;
  goto <D.27939>;
  <D.27938>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27052 = D.27048 >> 16;
  D.27057 = D.27052 | 1006698496;
  MEM[(guint32 *)code] = D.27057;
  code = code + 4;
  <D.27939>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27058 = D.27048 & 65535;
  if (D.27058 != 0) goto <D.27940>; else goto <D.27941>;
  <D.27940>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27058 = D.27048 & 65535;
  D.27061 = D.27058 | 606142464;
  MEM[(guint32 *)code] = D.27061;
  code = code + 4;
  <D.27941>:
  goto <D.27942>;
  <D.27936>:
  D.27035 = ins->data.op[0].const_val;
  D.27048 = (unsigned int) D.27035;
  D.27058 = D.27048 & 65535;
  D.27063 = D.27058 | 604045312;
  MEM[(guint32 *)code] = D.27063;
  code = code + 4;
  <D.27942>:
  D.26998 = ins->sreg1;
  D.27142 = D.26998 << 16;
  D.27226 = D.27142 | 2099233;
  D.27227 = (unsigned int) D.27226;
  MEM[(guint32 *)code] = D.27227;
  code = code + 4;
  D.26964 = ins->dreg;
  D.27155 = D.26964 << 16;
  D.27876 = D.27155 | -1004535808;
  ls_word_offset.97 = ls_word_offset;
  D.27878 = ls_word_offset.97 & 65535;
  D.27879 = D.27876 | D.27878;
  D.27880 = (unsigned int) D.27879;
  MEM[(guint32 *)code] = D.27880;
  code = code + 4;
  D.26964 = ins->dreg;
  D.27008 = D.26964 + 1;
  D.27536 = D.27008 << 16;
  D.27881 = D.27536 | -1004535808;
  ms_word_offset.98 = ms_word_offset;
  D.27883 = ms_word_offset.98 & 65535;
  D.27884 = D.27881 | D.27883;
  D.27885 = (unsigned int) D.27884;
  MEM[(guint32 *)code] = D.27885;
  code = code + 4;
  <D.27934>:
  goto <D.22782>;
  <D.23014>:
  D.27035 = ins->data.op[0].const_val;
  D.27036 = (short int) D.27035;
  D.27037 = (int) D.27036;
  D.27035 = ins->data.op[0].const_val;
  D.27943 = D.27037 != D.27035;
  D.27944 = (long int) D.27943;
  D.27945 = __builtin_expect (D.27944, 0);
  if (D.27945 != 0) goto <D.27946>; else goto <D.27947>;
  <D.27946>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 4365, "mips_is_imm16 (ins->inst_offset)");
  <D.27947>:
  D.26998 = ins->sreg1;
  D.27524 = D.26998 << 11;
  D.27948 = D.27524 | 1176503456;
  D.27949 = (unsigned int) D.27948;
  MEM[(guint32 *)code] = D.27949;
  code = code + 4;
  D.26964 = ins->dreg;
  D.27040 = D.26964 << 21;
  D.27950 = D.27040 | -468582400;
  D.27035 = ins->data.op[0].const_val;
  D.27042 = D.27035 & 65535;
  D.27951 = D.27950 | D.27042;
  D.27952 = (unsigned int) D.27951;
  MEM[(guint32 *)code] = D.27952;
  code = code + 4;
  goto <D.22782>;
  <D.23015>:
  D.27035 = ins->data.op[0].const_val;
  D.27036 = (short int) D.27035;
  D.27037 = (int) D.27036;
  D.27035 = ins->data.op[0].const_val;
  D.27943 = D.27037 != D.27035;
  D.27944 = (long int) D.27943;
  D.27945 = __builtin_expect (D.27944, 0);
  if (D.27945 != 0) goto <D.27953>; else goto <D.27954>;
  <D.27953>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 4375, "mips_is_imm16 (ins->inst_offset)");
  <D.27954>:
  D.26998 = ins->sreg1;
  D.26999 = D.26998 << 21;
  D.27927 = D.26999 | -1006632960;
  D.26964 = ins->dreg;
  D.27155 = D.26964 << 16;
  D.27928 = D.27927 | D.27155;
  D.27035 = ins->data.op[0].const_val;
  D.27042 = D.27035 & 65535;
  D.27955 = D.27928 | D.27042;
  D.27956 = (unsigned int) D.27955;
  MEM[(guint32 *)code] = D.27956;
  code = code + 4;
  goto <D.22782>;
  <D.23016>:
  D.27035 = ins->data.op[0].const_val;
  D.27036 = (short int) D.27035;
  D.27037 = (int) D.27036;
  D.27035 = ins->data.op[0].const_val;
  D.27943 = D.27037 != D.27035;
  D.27944 = (long int) D.27943;
  D.27945 = __builtin_expect (D.27944, 0);
  if (D.27945 != 0) goto <D.27957>; else goto <D.27958>;
  <D.27957>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 4379, "mips_is_imm16 (ins->inst_offset)");
  <D.27958>:
  D.26998 = ins->sreg1;
  D.26999 = D.26998 << 21;
  D.27927 = D.26999 | -1006632960;
  D.26964 = ins->dreg;
  D.27155 = D.26964 << 16;
  D.27928 = D.27927 | D.27155;
  D.27035 = ins->data.op[0].const_val;
  D.27042 = D.27035 & 65535;
  D.27955 = D.27928 | D.27042;
  D.27956 = (unsigned int) D.27955;
  MEM[(guint32 *)code] = D.27956;
  code = code + 4;
  D.26964 = ins->dreg;
  D.27005 = D.26964 << 11;
  D.27891 = D.27005 | 1174405120;
  D.26964 = ins->dreg;
  D.27528 = D.26964 << 6;
  D.27892 = D.27891 | D.27528;
  D.27893 = D.27892 | 33;
  D.27894 = (unsigned int) D.27893;
  MEM[(guint32 *)code] = D.27894;
  code = code + 4;
  goto <D.22782>;
  <D.23017>:
  D.26998 = ins->sreg1;
  D.26999 = D.26998 << 21;
  D.27000 = ins->sreg2;
  D.27001 = D.27000 << 16;
  D.27002 = D.26999 | D.27001;
  D.27959 = D.27002 | 2081;
  D.27960 = (unsigned int) D.27959;
  MEM[(guint32 *)code] = D.27960;
  code = code + 4;
  D.26964 = ins->dreg;
  D.27155 = D.26964 << 16;
  D.27876 = D.27155 | -1004535808;
  D.27961 = (unsigned int) D.27876;
  MEM[(guint32 *)code] = D.27961;
  code = code + 4;
  goto <D.22782>;
  <D.23018>:
  D.26998 = ins->sreg1;
  D.26999 = D.26998 << 21;
  D.27000 = ins->sreg2;
  D.27001 = D.27000 << 16;
  D.27002 = D.26999 | D.27001;
  D.27959 = D.27002 | 2081;
  D.27960 = (unsigned int) D.27959;
  MEM[(guint32 *)code] = D.27960;
  code = code + 4;
  D.26964 = ins->dreg;
  D.27155 = D.26964 << 16;
  D.27876 = D.27155 | -1004535808;
  ls_word_offset.97 = ls_word_offset;
  D.27878 = ls_word_offset.97 & 65535;
  D.27879 = D.27876 | D.27878;
  D.27880 = (unsigned int) D.27879;
  MEM[(guint32 *)code] = D.27880;
  code = code + 4;
  D.26964 = ins->dreg;
  D.27008 = D.26964 + 1;
  D.27536 = D.27008 << 16;
  D.27881 = D.27536 | -1004535808;
  ms_word_offset.98 = ms_word_offset;
  D.27883 = ms_word_offset.98 & 65535;
  D.27884 = D.27881 | D.27883;
  D.27885 = (unsigned int) D.27884;
  MEM[(guint32 *)code] = D.27885;
  code = code + 4;
  goto <D.22782>;
  <D.23019>:
  D.26964 = ins->dreg;
  D.27040 = D.26964 << 21;
  D.27000 = ins->sreg2;
  D.27001 = D.27000 << 16;
  D.27962 = D.27040 | D.27001;
  D.27963 = D.27962 | 2081;
  D.27964 = (unsigned int) D.27963;
  MEM[(guint32 *)code] = D.27964;
  code = code + 4;
  D.26998 = ins->sreg1;
  D.27524 = D.26998 << 11;
  D.27948 = D.27524 | 1176503456;
  D.27949 = (unsigned int) D.27948;
  MEM[(guint32 *)code] = D.27949;
  code = code + 4;
  MEM[(guint32 *)code] = 3828482048;
  code = code + 4;
  goto <D.22782>;
  <D.23020>:
  D.26964 = ins->dreg;
  D.27040 = D.26964 << 21;
  D.27000 = ins->sreg2;
  D.27001 = D.27000 << 16;
  D.27962 = D.27040 | D.27001;
  D.27963 = D.27962 | 2081;
  D.27964 = (unsigned int) D.27963;
  MEM[(guint32 *)code] = D.27964;
  code = code + 4;
  D.26998 = ins->sreg1;
  D.27142 = D.26998 << 16;
  D.27919 = D.27142 | -467664896;
  ls_word_offset.97 = ls_word_offset;
  D.27878 = ls_word_offset.97 & 65535;
  D.27920 = D.27919 | D.27878;
  D.27921 = (unsigned int) D.27920;
  MEM[(guint32 *)code] = D.27921;
  code = code + 4;
  D.26998 = ins->sreg1;
  D.27903 = D.26998 + 1;
  D.27904 = D.27903 << 16;
  D.27922 = D.27904 | -467664896;
  ms_word_offset.98 = ms_word_offset;
  D.27883 = ms_word_offset.98 & 65535;
  D.27923 = D.27922 | D.27883;
  D.27924 = (unsigned int) D.27923;
  MEM[(guint32 *)code] = D.27924;
  code = code + 4;
  goto <D.22782>;
  <D.23021>:
  {
    static const guint64 adjust_val = 4751297606875873280;

    D.26998 = ins->sreg1;
    D.27142 = D.26998 << 16;
    D.27965 = D.27142 | 1149276160;
    D.27966 = (unsigned int) D.27965;
    MEM[(guint32 *)code] = D.27966;
    code = code + 4;
    D.26998 = ins->sreg1;
    D.26999 = D.26998 << 21;
    D.27967 = D.26999 | 67174405;
    D.27968 = (unsigned int) D.27967;
    MEM[(guint32 *)code] = D.27968;
    code = code + 4;
    D.26964 = ins->dreg;
    D.27528 = D.26964 << 6;
    D.27969 = D.27528 | 1182830625;
    D.27970 = (unsigned int) D.27969;
    MEM[(guint32 *)code] = D.27970;
    code = code + 4;
    adjust_val.99 = (unsigned int) &adjust_val;
    D.27972 = adjust_val.99 & 32768;
    if (D.27972 != 0) goto <D.27973>; else goto <D.27974>;
    <D.27973>:
    adjust_val.99 = (unsigned int) &adjust_val;
    D.27975 = adjust_val.99 >> 16;
    D.27976 = D.27975 + 1;
    D.27977 = D.27976 & 65535;
    D.27978 = D.27977 | 1006698496;
    MEM[(guint32 *)code] = D.27978;
    code = code + 4;
    goto <D.27979>;
    <D.27974>:
    adjust_val.99 = (unsigned int) &adjust_val;
    D.27975 = adjust_val.99 >> 16;
    D.27980 = D.27975 | 1006698496;
    MEM[(guint32 *)code] = D.27980;
    code = code + 4;
    <D.27979>:
    adjust_val.99 = (unsigned int) &adjust_val;
    D.27981 = adjust_val.99 & 65535;
    D.27982 = D.27981 | 606142464;
    MEM[(guint32 *)code] = D.27982;
    code = code + 4;
    MEM[(guint32 *)code] = 3560046592;
    code = code + 4;
    D.26964 = ins->dreg;
    D.27005 = D.26964 << 11;
    D.27983 = D.27005 | 1177681920;
    D.26964 = ins->dreg;
    D.27528 = D.26964 << 6;
    D.27984 = D.27983 | D.27528;
    D.27985 = (unsigned int) D.27984;
    MEM[(guint32 *)code] = D.27985;
    code = code + 4;
    goto <D.22782>;
  }
  <D.23023>:
  D.26998 = ins->sreg1;
  D.27142 = D.26998 << 16;
  D.27965 = D.27142 | 1149276160;
  D.27966 = (unsigned int) D.27965;
  MEM[(guint32 *)code] = D.27966;
  code = code + 4;
  D.26964 = ins->dreg;
  D.27528 = D.26964 << 6;
  D.27986 = D.27528 | 1182830624;
  D.27987 = (unsigned int) D.27986;
  MEM[(guint32 *)code] = D.27987;
  code = code + 4;
  D.26964 = ins->dreg;
  D.27005 = D.26964 << 11;
  D.27891 = D.27005 | 1174405120;
  D.26964 = ins->dreg;
  D.27528 = D.26964 << 6;
  D.27892 = D.27891 | D.27528;
  D.27893 = D.27892 | 33;
  D.27894 = (unsigned int) D.27893;
  MEM[(guint32 *)code] = D.27894;
  code = code + 4;
  goto <D.22782>;
  <D.23024>:
  D.26998 = ins->sreg1;
  D.27142 = D.26998 << 16;
  D.27965 = D.27142 | 1149276160;
  D.27966 = (unsigned int) D.27965;
  MEM[(guint32 *)code] = D.27966;
  code = code + 4;
  D.26964 = ins->dreg;
  D.27528 = D.26964 << 6;
  D.27969 = D.27528 | 1182830625;
  D.27970 = (unsigned int) D.27969;
  MEM[(guint32 *)code] = D.27970;
  code = code + 4;
  goto <D.22782>;
  <D.23025>:
  D.26964 = ins->dreg;
  D.26998 = ins->sreg1;
  code = emit_float_to_int (cfg, code, D.26964, D.26998, 1, 1);
  goto <D.22782>;
  <D.23026>:
  D.26964 = ins->dreg;
  D.26998 = ins->sreg1;
  code = emit_float_to_int (cfg, code, D.26964, D.26998, 1, 0);
  goto <D.22782>;
  <D.23027>:
  D.26964 = ins->dreg;
  D.26998 = ins->sreg1;
  code = emit_float_to_int (cfg, code, D.26964, D.26998, 2, 1);
  goto <D.22782>;
  <D.23028>:
  D.26964 = ins->dreg;
  D.26998 = ins->sreg1;
  code = emit_float_to_int (cfg, code, D.26964, D.26998, 2, 0);
  goto <D.22782>;
  <D.23029>:
  <D.23030>:
  D.26964 = ins->dreg;
  D.26998 = ins->sreg1;
  code = emit_float_to_int (cfg, code, D.26964, D.26998, 4, 1);
  goto <D.22782>;
  <D.23031>:
  <D.23032>:
  D.26964 = ins->dreg;
  D.26998 = ins->sreg1;
  code = emit_float_to_int (cfg, code, D.26964, D.26998, 4, 0);
  goto <D.22782>;
  <D.23033>:
  D.26998 = ins->sreg1;
  D.27524 = D.26998 << 11;
  D.27573 = D.27524 | 1176502272;
  D.26964 = ins->dreg;
  D.27528 = D.26964 << 6;
  D.27574 = D.27573 | D.27528;
  D.27988 = D.27574 | 4;
  D.27989 = (unsigned int) D.27988;
  MEM[(guint32 *)code] = D.27989;
  code = code + 4;
  goto <D.22782>;
  <D.23034>:
  D.27000 = ins->sreg2;
  D.27001 = D.27000 << 16;
  D.27990 = D.27001 | 1176502272;
  D.26998 = ins->sreg1;
  D.27524 = D.26998 << 11;
  D.27991 = D.27990 | D.27524;
  D.26964 = ins->dreg;
  D.27528 = D.26964 << 6;
  D.27992 = D.27991 | D.27528;
  D.27993 = (unsigned int) D.27992;
  MEM[(guint32 *)code] = D.27993;
  code = code + 4;
  goto <D.22782>;
  <D.23035>:
  D.27000 = ins->sreg2;
  D.27001 = D.27000 << 16;
  D.27990 = D.27001 | 1176502272;
  D.26998 = ins->sreg1;
  D.27524 = D.26998 << 11;
  D.27991 = D.27990 | D.27524;
  D.26964 = ins->dreg;
  D.27528 = D.26964 << 6;
  D.27992 = D.27991 | D.27528;
  D.27994 = D.27992 | 1;
  D.27995 = (unsigned int) D.27994;
  MEM[(guint32 *)code] = D.27995;
  code = code + 4;
  goto <D.22782>;
  <D.23036>:
  D.27000 = ins->sreg2;
  D.27001 = D.27000 << 16;
  D.27990 = D.27001 | 1176502272;
  D.26998 = ins->sreg1;
  D.27524 = D.26998 << 11;
  D.27991 = D.27990 | D.27524;
  D.26964 = ins->dreg;
  D.27528 = D.26964 << 6;
  D.27992 = D.27991 | D.27528;
  D.27996 = D.27992 | 2;
  D.27997 = (unsigned int) D.27996;
  MEM[(guint32 *)code] = D.27997;
  code = code + 4;
  goto <D.22782>;
  <D.23037>:
  D.27000 = ins->sreg2;
  D.27001 = D.27000 << 16;
  D.27990 = D.27001 | 1176502272;
  D.26998 = ins->sreg1;
  D.27524 = D.26998 << 11;
  D.27991 = D.27990 | D.27524;
  D.26964 = ins->dreg;
  D.27528 = D.26964 << 6;
  D.27992 = D.27991 | D.27528;
  D.27998 = D.27992 | 3;
  D.27999 = (unsigned int) D.27998;
  MEM[(guint32 *)code] = D.27999;
  code = code + 4;
  goto <D.22782>;
  <D.23038>:
  D.26998 = ins->sreg1;
  D.27524 = D.26998 << 11;
  D.27573 = D.27524 | 1176502272;
  D.26964 = ins->dreg;
  D.27528 = D.26964 << 6;
  D.27574 = D.27573 | D.27528;
  D.28000 = D.27574 | 7;
  D.28001 = (unsigned int) D.28000;
  MEM[(guint32 *)code] = D.28001;
  code = code + 4;
  goto <D.22782>;
  <D.23039>:
  D.27000 = ins->sreg2;
  D.27001 = D.27000 << 16;
  D.27990 = D.27001 | 1176502272;
  D.26998 = ins->sreg1;
  D.27524 = D.26998 << 11;
  D.27991 = D.27990 | D.27524;
  D.28002 = D.27991 | 50;
  D.28003 = (unsigned int) D.28002;
  MEM[(guint32 *)code] = D.28003;
  code = code + 4;
  D.26964 = ins->dreg;
  D.27155 = D.26964 << 16;
  D.27834 = D.27155 | 603979777;
  D.27835 = (unsigned int) D.27834;
  MEM[(guint32 *)code] = D.27835;
  code = code + 4;
  MEM[(guint32 *)code] = 1157693442;
  code = code + 4;
  MEM[(guint32 *)code] = 2099237;
  code = code + 4;
  D.26964 = ins->dreg;
  D.27005 = D.26964 << 11;
  D.27836 = D.27005 | 33;
  D.27837 = (unsigned int) D.27836;
  MEM[(guint32 *)code] = D.27837;
  code = code + 4;
  goto <D.22782>;
  <D.23040>:
  D.27000 = ins->sreg2;
  D.27001 = D.27000 << 16;
  D.27990 = D.27001 | 1176502272;
  D.26998 = ins->sreg1;
  D.27524 = D.26998 << 11;
  D.27991 = D.27990 | D.27524;
  D.28004 = D.27991 | 60;
  D.28005 = (unsigned int) D.28004;
  MEM[(guint32 *)code] = D.28005;
  code = code + 4;
  D.26964 = ins->dreg;
  D.27155 = D.26964 << 16;
  D.27834 = D.27155 | 603979777;
  D.27835 = (unsigned int) D.27834;
  MEM[(guint32 *)code] = D.27835;
  code = code + 4;
  MEM[(guint32 *)code] = 1157693442;
  code = code + 4;
  MEM[(guint32 *)code] = 2099237;
  code = code + 4;
  D.26964 = ins->dreg;
  D.27005 = D.26964 << 11;
  D.27836 = D.27005 | 33;
  D.27837 = (unsigned int) D.27836;
  MEM[(guint32 *)code] = D.27837;
  code = code + 4;
  goto <D.22782>;
  <D.23041>:
  D.27000 = ins->sreg2;
  D.27001 = D.27000 << 16;
  D.27990 = D.27001 | 1176502272;
  D.26998 = ins->sreg1;
  D.27524 = D.26998 << 11;
  D.27991 = D.27990 | D.27524;
  D.28006 = D.27991 | 53;
  D.28007 = (unsigned int) D.28006;
  MEM[(guint32 *)code] = D.28007;
  code = code + 4;
  D.26964 = ins->dreg;
  D.27155 = D.26964 << 16;
  D.27834 = D.27155 | 603979777;
  D.27835 = (unsigned int) D.27834;
  MEM[(guint32 *)code] = D.27835;
  code = code + 4;
  MEM[(guint32 *)code] = 1157693442;
  code = code + 4;
  MEM[(guint32 *)code] = 2099237;
  code = code + 4;
  D.26964 = ins->dreg;
  D.27005 = D.26964 << 11;
  D.27836 = D.27005 | 33;
  D.27837 = (unsigned int) D.27836;
  MEM[(guint32 *)code] = D.27837;
  code = code + 4;
  goto <D.22782>;
  <D.23042>:
  D.27000 = ins->sreg2;
  D.27001 = D.27000 << 16;
  D.27990 = D.27001 | 1176502272;
  D.26998 = ins->sreg1;
  D.27524 = D.26998 << 11;
  D.27991 = D.27990 | D.27524;
  D.28008 = D.27991 | 55;
  D.28009 = (unsigned int) D.28008;
  MEM[(guint32 *)code] = D.28009;
  code = code + 4;
  D.26964 = ins->dreg;
  D.27005 = D.26964 << 11;
  D.27836 = D.27005 | 33;
  D.27837 = (unsigned int) D.27836;
  MEM[(guint32 *)code] = D.27837;
  code = code + 4;
  MEM[(guint32 *)code] = 1157693442;
  code = code + 4;
  MEM[(guint32 *)code] = 2099237;
  code = code + 4;
  D.26964 = ins->dreg;
  D.27155 = D.26964 << 16;
  D.27834 = D.27155 | 603979777;
  D.27835 = (unsigned int) D.27834;
  MEM[(guint32 *)code] = D.27835;
  code = code + 4;
  goto <D.22782>;
  <D.23043>:
  D.27000 = ins->sreg2;
  D.27001 = D.27000 << 16;
  D.27990 = D.27001 | 1176502272;
  D.26998 = ins->sreg1;
  D.27524 = D.26998 << 11;
  D.27991 = D.27990 | D.27524;
  D.28010 = D.27991 | 54;
  D.28011 = (unsigned int) D.28010;
  MEM[(guint32 *)code] = D.28011;
  code = code + 4;
  D.26964 = ins->dreg;
  D.27005 = D.26964 << 11;
  D.27836 = D.27005 | 33;
  D.27837 = (unsigned int) D.27836;
  MEM[(guint32 *)code] = D.27837;
  code = code + 4;
  MEM[(guint32 *)code] = 1157693442;
  code = code + 4;
  MEM[(guint32 *)code] = 2099237;
  code = code + 4;
  D.26964 = ins->dreg;
  D.27155 = D.26964 << 16;
  D.27834 = D.27155 | 603979777;
  D.27835 = (unsigned int) D.27834;
  MEM[(guint32 *)code] = D.27835;
  code = code + 4;
  goto <D.22782>;
  <D.23044>:
  <D.23045>:
  <D.23046>:
  <D.23047>:
  <D.23048>:
  <D.23049>:
  <D.23050>:
  <D.23051>:
  <D.23052>:
  <D.23053>:
  {
    int cond;
    gboolean is_true;
    gboolean is_ordered;
    guint32 * buf;

    cond = 0;
    is_true = 1;
    is_ordered = 0;
    buf = 0B;
    D.26945 = ins->opcode;
    D.26946 = (int) D.26945;
    switch (D.26946) <default: <D.23069>, case 849: <D.23058>, case 850: <D.23065>, case 851: <D.23066>, case 852: <D.23063>, case 853: <D.23064>, case 854: <D.23067>, case 855: <D.23068>, case 856: <D.23061>, case 857: <D.23062>, case 858: <D.23060>>
    <D.23058>:
    cond = 2;
    is_true = 1;
    goto <D.23059>;
    <D.23060>:
    cond = 2;
    is_true = 0;
    goto <D.23059>;
    <D.23061>:
    cond = 12;
    is_true = 1;
    is_ordered = 1;
    goto <D.23059>;
    <D.23062>:
    cond = 5;
    is_true = 1;
    goto <D.23059>;
    <D.23063>:
    cond = 14;
    is_true = 0;
    is_ordered = 1;
    goto <D.23059>;
    <D.23064>:
    cond = 6;
    is_true = 0;
    goto <D.23059>;
    <D.23065>:
    cond = 12;
    is_true = 0;
    is_ordered = 1;
    goto <D.23059>;
    <D.23066>:
    cond = 4;
    is_true = 0;
    goto <D.23059>;
    <D.23067>:
    cond = 6;
    is_true = 1;
    is_ordered = 1;
    goto <D.23059>;
    <D.23068>:
    cond = 7;
    is_true = 1;
    goto <D.23059>;
    <D.23069>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-mips.c", 4576);
    <D.23059>:
    if (is_ordered != 0) goto <D.28012>; else goto <D.28013>;
    <D.28012>:
    D.27000 = ins->sreg2;
    D.27001 = D.27000 << 16;
    D.27990 = D.27001 | 1176502272;
    D.26998 = ins->sreg1;
    D.27524 = D.26998 << 11;
    D.27991 = D.27990 | D.27524;
    D.28014 = D.27991 | 49;
    D.28015 = (unsigned int) D.28014;
    MEM[(guint32 *)code] = D.28015;
    code = code + 4;
    MEM[(guint32 *)code] = 2099237;
    code = code + 4;
    buf = code;
    MEM[(guint32 *)code] = 1157693440;
    code = code + 4;
    MEM[(guint32 *)code] = 2099237;
    code = code + 4;
    <D.28013>:
    D.27000 = ins->sreg2;
    D.27001 = D.27000 << 16;
    D.27990 = D.27001 | 1176502272;
    D.26998 = ins->sreg1;
    D.27524 = D.26998 << 11;
    D.27991 = D.27990 | D.27524;
    D.28016 = cond | 48;
    D.28017 = D.27991 | D.28016;
    D.28018 = (unsigned int) D.28017;
    MEM[(guint32 *)code] = D.28018;
    code = code + 4;
    MEM[(guint32 *)code] = 2099237;
    code = code + 4;
    code.86 = (int) code;
    D.26935 = cfg->native_code;
    D.26943 = (int) D.26935;
    D.26944 = code.86 - D.26943;
    D.28019 = ins->data.op[1].many_blocks;
    D.28020 = *D.28019;
    mono_add_patch_info (cfg, D.26944, 0, D.28020);
    if (is_true != 0) goto <D.28021>; else goto <D.28022>;
    <D.28021>:
    MEM[(guint32 *)code] = 1157693440;
    code = code + 4;
    goto <D.28023>;
    <D.28022>:
    MEM[(guint32 *)code] = 1157627904;
    code = code + 4;
    <D.28023>:
    MEM[(guint32 *)code] = 2099237;
    code = code + 4;
    if (is_ordered != 0) goto <D.28024>; else goto <D.28025>;
    <D.28024>:
    code.91 = (unsigned int) code;
    mips_patch (buf, code.91);
    <D.28025>:
    goto <D.22782>;
  }
  <D.23070>:
  {
    guint32 * branch_patch;

    D.26998 = ins->sreg1;
    D.27903 = D.26998 + 1;
    D.28026 = D.27903 << 11;
    D.28027 = D.28026 | 1140916224;
    D.28028 = (unsigned int) D.28027;
    MEM[(guint32 *)code] = D.28028;
    code = code + 4;
    MEM[(guint32 *)code] = 68866;
    code = code + 4;
    MEM[(guint32 *)code] = 807471103;
    code = code + 4;
    MEM[(guint32 *)code] = 606205953;
    code = code + 4;
    branch_patch = code;
    MEM[(guint32 *)code] = 337641472;
    code = code + 4;
    MEM[(guint32 *)code] = 2099237;
    code = code + 4;
    code = mips_emit_exc_by_name (code, "ArithmeticException");
    D.27418 = cfg->bb_exit;
    D.27418 = cfg->bb_exit;
    D.27419 = D.27418->max_offset;
    D.27420 = D.27419 + 16;
    D.27418->max_offset = D.27420;
    code.91 = (unsigned int) code;
    mips_patch (branch_patch, code.91);
    D.26998 = ins->sreg1;
    D.27524 = D.26998 << 11;
    D.27573 = D.27524 | 1176502272;
    D.26964 = ins->dreg;
    D.27528 = D.26964 << 6;
    D.27574 = D.27573 | D.27528;
    D.27575 = D.27574 | 6;
    D.27576 = (unsigned int) D.27575;
    MEM[(guint32 *)code] = D.27576;
    code = code + 4;
    goto <D.22782>;
  }
  <D.23072>:
  offset.92 = (int) offset;
  D.27014 = ins->data.op[1].const_val;
  D.28029 = (<unnamed type>) D.27014;
  D.27510 = ins->data.op[0].p;
  mono_add_patch_info (cfg, offset.92, D.28029, D.27510);
  if (0 != 0) goto <D.28030>; else goto <D.28031>;
  <D.28030>:
  D.26964 = ins->dreg;
  D.27155 = D.26964 << 16;
  D.27492 = (unsigned int) D.27155;
  D.28032 = D.27492 | 1006636816;
  MEM[(guint32 *)code] = D.28032;
  code = code + 4;
  goto <D.28033>;
  <D.28031>:
  D.26964 = ins->dreg;
  D.27155 = D.26964 << 16;
  D.27492 = (unsigned int) D.27155;
  D.28034 = D.27492 | 1006636815;
  MEM[(guint32 *)code] = D.28034;
  code = code + 4;
  <D.28033>:
  D.26964 = ins->dreg;
  D.27040 = D.26964 << 21;
  D.27500 = D.27040 | 603979776;
  D.26964 = ins->dreg;
  D.27155 = D.26964 << 16;
  D.27501 = D.27500 | D.27155;
  D.27502 = (unsigned int) D.27501;
  D.28035 = D.27502 | 3855;
  MEM[(guint32 *)code] = D.28035;
  code = code + 4;
  goto <D.22782>;
  <D.23073>:
  D.26945 = ins->opcode;
  D.26946 = (int) D.26945;
  D.28036 = mono_inst_name (D.26946);
  monoeg_g_log (0B, 16, "unknown opcode %s in %s()\n", D.28036, &__FUNCTION__);
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-mips.c", 4626);
  <D.22782>:
  D.28037 = cfg->opt;
  D.28038 = D.28037 & 2;
  if (D.28038 != 0) goto <D.28039>; else goto <D.28040>;
  <D.28039>:
  code.86 = (int) code;
  D.26935 = cfg->native_code;
  D.26943 = (int) D.26935;
  D.26944 = code.86 - D.26943;
  D.28041 = (unsigned int) D.26944;
  D.28042 = D.28041 - offset;
  max_len.87 = (unsigned int) max_len;
  if (D.28042 > max_len.87) goto <D.28043>; else goto <D.28044>;
  <D.28043>:
  D.26945 = ins->opcode;
  D.26946 = (int) D.26945;
  D.28045 = mono_inst_name (D.26946);
  code.86 = (int) code;
  D.26935 = cfg->native_code;
  D.26943 = (int) D.26935;
  D.26944 = code.86 - D.26943;
  D.28041 = (unsigned int) D.26944;
  D.28042 = D.28041 - offset;
  monoeg_g_log (0B, 16, "wrong maximal instruction length of instruction %s (expected %d, got %d)", D.28045, max_len, D.28042);
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-mips.c", 4632);
  <D.28044>:
  <D.28040>:
  cpos = cpos + max_len;
  last_ins = ins;
  last_offset = offset;
  ins = ins->next;
  <D.23076>:
  if (ins != 0B) goto <D.23075>; else goto <D.23077>;
  <D.23077>:
  code.86 = (int) code;
  D.26935 = cfg->native_code;
  D.26943 = (int) D.26935;
  D.26944 = code.86 - D.26943;
  D.28041 = (unsigned int) D.26944;
  cfg->code_len = D.28041;
}


emit_load_volatile_arguments (struct MonoCompile * cfg, guint8 * code)
{
  void * D.28049;
  struct MonoGenericSharingContext * D.28052;
  struct MonoMemPool * D.28053;
  struct CallInfo * D.28054;
  unsigned int D.28055;
  int D.28058;
  int D.28059;
  int D.28060;
  unsigned char D.28061;
  int D.28062;
  int D.28063;
  int D.28064;
  int D.28065;
  int D.28066;
  int D.28067;
  unsigned int D.28068;
  sizetype i.100;
  struct MonoInst * * D.28070;
  unsigned int i.101;
  unsigned int D.28072;
  struct MonoInst * * D.28073;
  short unsigned int D.28074;
  <unnamed type> D.28077;
  int D.28080;
  int D.28081;
  unsigned char D.28082;
  int D.28083;
  int D.28084;
  int D.28085;
  int D.28086;
  unsigned int D.28087;
  short int D.28097;
  int D.28098;
  _Bool D.28099;
  long int D.28100;
  long int D.28101;
  <unnamed-unsigned:4> D.28104;
  int D.28105;
  int D.28106;
  int D.28107;
  int D.28108;
  int D.28109;
  unsigned int D.28110;
  int D.28111;
  int D.28112;
  int D.28113;
  unsigned int D.28114;
  int D.28115;
  int D.28116;
  unsigned int D.28117;
  int ls_word_offset.102;
  int D.28119;
  int D.28120;
  int D.28121;
  unsigned int D.28122;
  int D.28123;
  int D.28124;
  int D.28125;
  int ms_word_offset.103;
  int D.28127;
  int D.28128;
  int D.28129;
  unsigned int D.28130;
  unsigned int D.28139;
  unsigned int D.28140;
  int D.28143;
  int D.28144;
  int D.28145;
  unsigned int D.28146;
  int D.28147;
  int D.28148;
  unsigned int D.28149;
  int D.28153;
  unsigned int D.28154;
  unsigned short D.28161;
  unsigned short D.28162;
  unsigned short D.28163;
  unsigned short D.28164;
  short int D.28165;
  int D.28166;
  unsigned int D.28167;
  unsigned int D.28168;
  unsigned int D.28169;
  unsigned int D.28170;
  int D.28171;
  _Bool D.28172;
  long int D.28173;
  long int D.28174;
  int D.28177;
  int D.28178;
  int D.28179;
  int D.28180;
  int D.28181;
  unsigned int D.28182;
  short unsigned int D.28189;
  int D.28190;
  <unnamed-unsigned:1> D.28191;
  int D.28192;
  int D.28193;
  guint8 * D.28194;
  struct MonoMethod * method;
  struct MonoMethodSignature * sig;
  struct MonoInst * inst;
  struct CallInfo * cinfo;
  int i;

  method = cfg->method;
  sig = mono_method_signature (method);
  D.28049 = cfg->arch.cinfo;
  if (D.28049 == 0B) goto <D.28050>; else goto <D.28051>;
  <D.28050>:
  D.28052 = cfg->generic_sharing_context;
  D.28053 = cfg->mempool;
  D.28054 = get_call_info (D.28052, D.28053, sig);
  cfg->arch.cinfo = D.28054;
  <D.28051>:
  cinfo = cfg->arch.cinfo;
  D.28055 = cinfo->struct_ret;
  if (D.28055 != 0) goto <D.28056>; else goto <D.28057>;
  <D.28056>:
  {
    struct ArgInfo * ainfo;

    ainfo = &cinfo->ret;
    inst = cfg->vret_addr;
    D.28058 = inst->sreg1;
    D.28059 = D.28058 << 21;
    D.28060 = D.28059 | -1946157056;
    D.28061 = ainfo->reg;
    D.28062 = (int) D.28061;
    D.28063 = D.28062 << 16;
    D.28064 = D.28060 | D.28063;
    D.28065 = inst->data.op[0].const_val;
    D.28066 = D.28065 & 65535;
    D.28067 = D.28064 | D.28066;
    D.28068 = (unsigned int) D.28067;
    MEM[(guint32 *)code] = D.28068;
    code = code + 4;
  }
  <D.28057>:
  i = 0;
  goto <D.22751>;
  <D.22750>:
  {
    struct ArgInfo * ainfo;

    i.100 = (sizetype) i;
    ainfo = &cinfo->args[i.100];
    D.28070 = cfg->args;
    i.101 = (unsigned int) i;
    D.28072 = i.101 * 4;
    D.28073 = D.28070 + D.28072;
    inst = *D.28073;
    D.28074 = inst->opcode;
    if (D.28074 == 366) goto <D.28075>; else goto <D.28076>;
    <D.28075>:
    D.28077 = ainfo->storage;
    if (D.28077 == 0) goto <D.28078>; else goto <D.28079>;
    <D.28078>:
    D.28080 = inst->dreg;
    D.28081 = D.28080 << 21;
    D.28082 = ainfo->reg;
    D.28083 = (int) D.28082;
    D.28084 = D.28083 << 11;
    D.28085 = D.28081 | D.28084;
    D.28086 = D.28085 | 33;
    D.28087 = (unsigned int) D.28086;
    MEM[(guint32 *)code] = D.28087;
    code = code + 4;
    goto <D.28088>;
    <D.28079>:
    D.28077 = ainfo->storage;
    if (D.28077 == 2) goto <D.28089>; else goto <D.28090>;
    <D.28089>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-mips.c", 3222);
    <D.28090>:
    D.28077 = ainfo->storage;
    if (D.28077 == 1) goto <D.28091>; else goto <D.28092>;
    <D.28091>:
    goto <D.28093>;
    <D.28092>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-mips.c", 3226);
    <D.28093>:
    <D.28088>:
    goto <D.28094>;
    <D.28076>:
    D.28077 = ainfo->storage;
    if (D.28077 == 0) goto <D.28095>; else goto <D.28096>;
    <D.28095>:
    D.28065 = inst->data.op[0].const_val;
    D.28097 = (short int) D.28065;
    D.28098 = (int) D.28097;
    D.28065 = inst->data.op[0].const_val;
    D.28099 = D.28098 != D.28065;
    D.28100 = (long int) D.28099;
    D.28101 = __builtin_expect (D.28100, 0);
    if (D.28101 != 0) goto <D.28102>; else goto <D.28103>;
    <D.28102>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 3229, "mips_is_imm16 (inst->inst_offset)");
    <D.28103>:
    D.28104 = ainfo->size;
    D.28105 = (int) D.28104;
    switch (D.28105) <default: <D.22744>, case 0: <D.22741>, case 1: <D.22738>, case 2: <D.22740>, case 4: <D.22742>, case 8: <D.22743>>
    <D.22738>:
    D.28058 = inst->sreg1;
    D.28059 = D.28058 << 21;
    D.28106 = D.28059 | -2147483648;
    D.28082 = ainfo->reg;
    D.28083 = (int) D.28082;
    D.28107 = D.28083 << 16;
    D.28108 = D.28106 | D.28107;
    D.28065 = inst->data.op[0].const_val;
    D.28066 = D.28065 & 65535;
    D.28109 = D.28108 | D.28066;
    D.28110 = (unsigned int) D.28109;
    MEM[(guint32 *)code] = D.28110;
    code = code + 4;
    goto <D.22739>;
    <D.22740>:
    D.28058 = inst->sreg1;
    D.28059 = D.28058 << 21;
    D.28111 = D.28059 | -2080374784;
    D.28082 = ainfo->reg;
    D.28083 = (int) D.28082;
    D.28107 = D.28083 << 16;
    D.28112 = D.28111 | D.28107;
    D.28065 = inst->data.op[0].const_val;
    D.28066 = D.28065 & 65535;
    D.28113 = D.28112 | D.28066;
    D.28114 = (unsigned int) D.28113;
    MEM[(guint32 *)code] = D.28114;
    code = code + 4;
    goto <D.22739>;
    <D.22741>:
    <D.22742>:
    D.28058 = inst->sreg1;
    D.28059 = D.28058 << 21;
    D.28060 = D.28059 | -1946157056;
    D.28082 = ainfo->reg;
    D.28083 = (int) D.28082;
    D.28107 = D.28083 << 16;
    D.28115 = D.28060 | D.28107;
    D.28065 = inst->data.op[0].const_val;
    D.28066 = D.28065 & 65535;
    D.28116 = D.28115 | D.28066;
    D.28117 = (unsigned int) D.28116;
    MEM[(guint32 *)code] = D.28117;
    code = code + 4;
    goto <D.22739>;
    <D.22743>:
    D.28058 = inst->sreg1;
    D.28059 = D.28058 << 21;
    D.28060 = D.28059 | -1946157056;
    D.28082 = ainfo->reg;
    D.28083 = (int) D.28082;
    D.28107 = D.28083 << 16;
    D.28115 = D.28060 | D.28107;
    D.28065 = inst->data.op[0].const_val;
    ls_word_offset.102 = ls_word_offset;
    D.28119 = D.28065 + ls_word_offset.102;
    D.28120 = D.28119 & 65535;
    D.28121 = D.28115 | D.28120;
    D.28122 = (unsigned int) D.28121;
    MEM[(guint32 *)code] = D.28122;
    code = code + 4;
    D.28058 = inst->sreg1;
    D.28059 = D.28058 << 21;
    D.28060 = D.28059 | -1946157056;
    D.28082 = ainfo->reg;
    D.28083 = (int) D.28082;
    D.28123 = D.28083 + 1;
    D.28124 = D.28123 << 16;
    D.28125 = D.28060 | D.28124;
    D.28065 = inst->data.op[0].const_val;
    ms_word_offset.103 = ms_word_offset;
    D.28127 = D.28065 + ms_word_offset.103;
    D.28128 = D.28127 & 65535;
    D.28129 = D.28125 | D.28128;
    D.28130 = (unsigned int) D.28129;
    MEM[(guint32 *)code] = D.28130;
    code = code + 4;
    goto <D.22739>;
    <D.22744>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-mips.c", 3246);
    <D.22739>:
    goto <D.28131>;
    <D.28096>:
    D.28077 = ainfo->storage;
    if (D.28077 == 1) goto <D.28132>; else goto <D.28133>;
    <D.28132>:
    goto <D.28134>;
    <D.28133>:
    D.28077 = ainfo->storage;
    if (D.28077 == 2) goto <D.28135>; else goto <D.28136>;
    <D.28135>:
    D.28065 = inst->data.op[0].const_val;
    D.28097 = (short int) D.28065;
    D.28098 = (int) D.28097;
    D.28065 = inst->data.op[0].const_val;
    D.28099 = D.28098 != D.28065;
    D.28100 = (long int) D.28099;
    D.28101 = __builtin_expect (D.28100, 0);
    if (D.28101 != 0) goto <D.28137>; else goto <D.28138>;
    <D.28137>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 3252, "mips_is_imm16 (inst->inst_offset)");
    <D.28138>:
    D.28139 = BIT_FIELD_REF <*ainfo, 32, 96>;
    D.28140 = D.28139 & 15;
    if (D.28140 == 8) goto <D.28141>; else goto <D.28142>;
    <D.28141>:
    D.28058 = inst->sreg1;
    D.28059 = D.28058 << 21;
    D.28143 = D.28059 | -1006632960;
    D.28082 = ainfo->reg;
    D.28083 = (int) D.28082;
    D.28107 = D.28083 << 16;
    D.28144 = D.28143 | D.28107;
    D.28065 = inst->data.op[0].const_val;
    ls_word_offset.102 = ls_word_offset;
    D.28119 = D.28065 + ls_word_offset.102;
    D.28120 = D.28119 & 65535;
    D.28145 = D.28144 | D.28120;
    D.28146 = (unsigned int) D.28145;
    MEM[(guint32 *)code] = D.28146;
    code = code + 4;
    D.28058 = inst->sreg1;
    D.28059 = D.28058 << 21;
    D.28143 = D.28059 | -1006632960;
    D.28082 = ainfo->reg;
    D.28083 = (int) D.28082;
    D.28123 = D.28083 + 1;
    D.28124 = D.28123 << 16;
    D.28147 = D.28143 | D.28124;
    D.28065 = inst->data.op[0].const_val;
    ms_word_offset.103 = ms_word_offset;
    D.28127 = D.28065 + ms_word_offset.103;
    D.28128 = D.28127 & 65535;
    D.28148 = D.28147 | D.28128;
    D.28149 = (unsigned int) D.28148;
    MEM[(guint32 *)code] = D.28149;
    code = code + 4;
    goto <D.28150>;
    <D.28142>:
    D.28139 = BIT_FIELD_REF <*ainfo, 32, 96>;
    D.28140 = D.28139 & 15;
    if (D.28140 == 4) goto <D.28151>; else goto <D.28152>;
    <D.28151>:
    D.28058 = inst->sreg1;
    D.28059 = D.28058 << 21;
    D.28143 = D.28059 | -1006632960;
    D.28082 = ainfo->reg;
    D.28083 = (int) D.28082;
    D.28107 = D.28083 << 16;
    D.28144 = D.28143 | D.28107;
    D.28065 = inst->data.op[0].const_val;
    D.28066 = D.28065 & 65535;
    D.28153 = D.28144 | D.28066;
    D.28154 = (unsigned int) D.28153;
    MEM[(guint32 *)code] = D.28154;
    code = code + 4;
    goto <D.28155>;
    <D.28152>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-mips.c", 3264);
    <D.28155>:
    <D.28150>:
    goto <D.28156>;
    <D.28136>:
    D.28077 = ainfo->storage;
    if (D.28077 == 3) goto <D.28157>; else goto <D.28158>;
    <D.28157>:
    {
      int i;
      int doffset;

      doffset = inst->data.op[0].const_val;
      D.28065 = inst->data.op[0].const_val;
      D.28097 = (short int) D.28065;
      D.28098 = (int) D.28097;
      D.28065 = inst->data.op[0].const_val;
      D.28099 = D.28098 != D.28065;
      D.28100 = (long int) D.28099;
      D.28101 = __builtin_expect (D.28100, 0);
      if (D.28101 != 0) goto <D.28159>; else goto <D.28160>;
      <D.28159>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 3269, "mips_is_imm16 (inst->inst_offset)");
      <D.28160>:
      D.28065 = inst->data.op[0].const_val;
      D.28161 = (unsigned short) D.28065;
      D.28104 = ainfo->size;
      D.28162 = (unsigned short) D.28104;
      D.28163 = D.28162 * 4;
      D.28164 = D.28161 + D.28163;
      D.28165 = (short int) D.28164;
      D.28166 = (int) D.28165;
      D.28065 = inst->data.op[0].const_val;
      D.28167 = (unsigned int) D.28065;
      D.28104 = ainfo->size;
      D.28168 = (unsigned int) D.28104;
      D.28169 = D.28168 * 4;
      D.28170 = D.28167 + D.28169;
      D.28171 = (int) D.28170;
      D.28172 = D.28166 != D.28171;
      D.28173 = (long int) D.28172;
      D.28174 = __builtin_expect (D.28173, 0);
      if (D.28174 != 0) goto <D.28175>; else goto <D.28176>;
      <D.28175>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 3270, "mips_is_imm16 (inst->inst_offset + ainfo->size * sizeof (gpointer))");
      <D.28176>:
      i = 0;
      goto <D.22748>;
      <D.22747>:
      D.28058 = inst->sreg1;
      D.28059 = D.28058 << 21;
      D.28060 = D.28059 | -1946157056;
      D.28082 = ainfo->reg;
      D.28083 = (int) D.28082;
      D.28177 = D.28083 + i;
      D.28178 = D.28177 << 16;
      D.28179 = D.28060 | D.28178;
      D.28180 = doffset & 65535;
      D.28181 = D.28179 | D.28180;
      D.28182 = (unsigned int) D.28181;
      MEM[(guint32 *)code] = D.28182;
      code = code + 4;
      doffset = doffset + 4;
      i = i + 1;
      <D.22748>:
      D.28104 = ainfo->size;
      D.28105 = (int) D.28104;
      if (D.28105 > i) goto <D.22747>; else goto <D.22749>;
      <D.22749>:
    }
    goto <D.28183>;
    <D.28158>:
    D.28077 = ainfo->storage;
    if (D.28077 == 4) goto <D.28184>; else goto <D.28185>;
    <D.28184>:
    D.28065 = inst->data.op[0].const_val;
    D.28097 = (short int) D.28065;
    D.28098 = (int) D.28097;
    D.28065 = inst->data.op[0].const_val;
    D.28099 = D.28098 != D.28065;
    D.28100 = (long int) D.28099;
    D.28101 = __builtin_expect (D.28100, 0);
    if (D.28101 != 0) goto <D.28186>; else goto <D.28187>;
    <D.28186>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 3276, "mips_is_imm16 (inst->inst_offset)");
    <D.28187>:
    D.28058 = inst->sreg1;
    D.28059 = D.28058 << 21;
    D.28060 = D.28059 | -1946157056;
    D.28082 = ainfo->reg;
    D.28083 = (int) D.28082;
    D.28107 = D.28083 << 16;
    D.28115 = D.28060 | D.28107;
    D.28065 = inst->data.op[0].const_val;
    D.28066 = D.28065 & 65535;
    D.28116 = D.28115 | D.28066;
    D.28117 = (unsigned int) D.28116;
    MEM[(guint32 *)code] = D.28117;
    code = code + 4;
    goto <D.28188>;
    <D.28185>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-mips.c", 3279);
    <D.28188>:
    <D.28183>:
    <D.28156>:
    <D.28134>:
    <D.28131>:
    <D.28094>:
  }
  i = i + 1;
  <D.22751>:
  D.28189 = sig->param_count;
  D.28190 = (int) D.28189;
  D.28191 = sig->hasthis;
  D.28192 = (int) D.28191;
  D.28193 = D.28190 + D.28192;
  if (D.28193 > i) goto <D.22750>; else goto <D.22752>;
  <D.22752>:
  D.28194 = code;
  return D.28194;
}


emit_reserve_param_area (struct MonoCompile * cfg, guint8 * code)
{
  unsigned int D.28196;
  guint8 * D.28199;
  int size;

  D.28196 = cfg->param_area;
  size = (int) D.28196;
  size = size + 7;
  size = size & -8;
  if (size == 0) goto <D.28197>; else goto <D.28198>;
  <D.28197>:
  D.28199 = code;
  return D.28199;
  <D.28198>:
  D.28199 = code;
  return D.28199;
}


emit_unreserve_param_area (struct MonoCompile * cfg, guint8 * code)
{
  unsigned int D.28201;
  guint8 * D.28204;
  int size;

  D.28201 = cfg->param_area;
  size = (int) D.28201;
  size = size + 7;
  size = size & -8;
  if (size == 0) goto <D.28202>; else goto <D.28203>;
  <D.28202>:
  D.28204 = code;
  return D.28204;
  <D.28203>:
  D.28204 = code;
  return D.28204;
}


emit_float_to_int (struct MonoCompile * cfg, guchar * code, int dreg, int sreg, int size, gboolean is_signed)
{
  int D.28206;
  int D.28207;
  unsigned int D.28208;
  int D.28209;
  int D.28210;
  unsigned int D.28211;
  int D.28216;
  int D.28217;
  int D.28218;
  int D.28219;
  unsigned int D.28220;
  int D.28224;
  int D.28225;
  int D.28226;
  unsigned int D.28227;
  int D.28228;
  unsigned int D.28229;
  int D.28233;
  unsigned int D.28234;
  int D.28235;
  unsigned int D.28236;
  int D.28240;
  unsigned int D.28241;
  guchar * D.28242;

  D.28206 = sreg << 11;
  D.28207 = D.28206 | 1176503437;
  D.28208 = (unsigned int) D.28207;
  MEM[(guint32 *)code] = D.28208;
  code = code + 4;
  D.28209 = dreg << 16;
  D.28210 = D.28209 | 1140887552;
  D.28211 = (unsigned int) D.28210;
  MEM[(guint32 *)code] = D.28211;
  code = code + 4;
  if (is_signed == 0) goto <D.28212>; else goto <D.28213>;
  <D.28212>:
  if (size == 1) goto <D.28214>; else goto <D.28215>;
  <D.28214>:
  D.28216 = dreg << 21;
  D.28217 = D.28216 | 805306368;
  D.28209 = dreg << 16;
  D.28218 = D.28217 | D.28209;
  D.28219 = D.28218 | 255;
  D.28220 = (unsigned int) D.28219;
  MEM[(guint32 *)code] = D.28220;
  code = code + 4;
  goto <D.28221>;
  <D.28215>:
  if (size == 2) goto <D.28222>; else goto <D.28223>;
  <D.28222>:
  D.28209 = dreg << 16;
  D.28224 = dreg << 11;
  D.28225 = D.28209 | D.28224;
  D.28226 = D.28225 | 1024;
  D.28227 = (unsigned int) D.28226;
  MEM[(guint32 *)code] = D.28227;
  code = code + 4;
  D.28209 = dreg << 16;
  D.28224 = dreg << 11;
  D.28225 = D.28209 | D.28224;
  D.28228 = D.28225 | 1026;
  D.28229 = (unsigned int) D.28228;
  MEM[(guint32 *)code] = D.28229;
  code = code + 4;
  <D.28223>:
  <D.28221>:
  goto <D.28230>;
  <D.28213>:
  if (size == 1) goto <D.28231>; else goto <D.28232>;
  <D.28231>:
  D.28209 = dreg << 16;
  D.28224 = dreg << 11;
  D.28225 = D.28209 | D.28224;
  D.28233 = D.28225 | 1536;
  D.28234 = (unsigned int) D.28233;
  MEM[(guint32 *)code] = D.28234;
  code = code + 4;
  D.28209 = dreg << 16;
  D.28224 = dreg << 11;
  D.28225 = D.28209 | D.28224;
  D.28235 = D.28225 | 1539;
  D.28236 = (unsigned int) D.28235;
  MEM[(guint32 *)code] = D.28236;
  code = code + 4;
  goto <D.28237>;
  <D.28232>:
  if (size == 2) goto <D.28238>; else goto <D.28239>;
  <D.28238>:
  D.28209 = dreg << 16;
  D.28224 = dreg << 11;
  D.28225 = D.28209 | D.28224;
  D.28226 = D.28225 | 1024;
  D.28227 = (unsigned int) D.28226;
  MEM[(guint32 *)code] = D.28227;
  code = code + 4;
  D.28209 = dreg << 16;
  D.28224 = dreg << 11;
  D.28225 = D.28209 | D.28224;
  D.28240 = D.28225 | 1027;
  D.28241 = (unsigned int) D.28240;
  MEM[(guint32 *)code] = D.28241;
  code = code + 4;
  <D.28239>:
  <D.28237>:
  <D.28230>:
  D.28242 = code;
  return D.28242;
}


mips_emit_exc_by_name (guint8 * code, const char * name)
{
  struct MonoImage * D.28244;
  _Bool D.28245;
  long int D.28246;
  long int D.28247;
  unsigned int D.28250;
  short int D.28251;
  int D.28252;
  int D.28253;
  unsigned int D.28256;
  unsigned int D.28259;
  unsigned int D.28260;
  unsigned int D.28261;
  unsigned int D.28262;
  unsigned int D.28264;
  unsigned int D.28265;
  unsigned int D.28268;
  unsigned int D.28270;
  short int D.28273;
  int D.28274;
  int _target.104;
  unsigned int D.28278;
  unsigned int D.28281;
  unsigned int D.28282;
  unsigned int D.28283;
  unsigned int D.28284;
  unsigned int D.28286;
  unsigned int D.28287;
  unsigned int D.28290;
  unsigned int D.28292;
  unsigned int D.28294;
  unsigned int D.28295;
  unsigned int D.28296;
  guint8 * D.28297;
  void * addr;
  struct MonoClass * exc_class;

  D.28244 = mono_defaults.corlib;
  exc_class = mono_class_from_name (D.28244, "System", name);
  D.28245 = exc_class == 0B;
  D.28246 = (long int) D.28245;
  D.28247 = __builtin_expect (D.28246, 0);
  if (D.28247 != 0) goto <D.28248>; else goto <D.28249>;
  <D.28248>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 224, "exc_class");
  <D.28249>:
  D.28250 = exc_class->type_token;
  D.28251 = (short int) D.28250;
  D.28252 = (int) D.28251;
  D.28250 = exc_class->type_token;
  D.28253 = (int) D.28250;
  if (D.28252 != D.28253) goto <D.28254>; else goto <D.28255>;
  <D.28254>:
  D.28250 = exc_class->type_token;
  D.28256 = D.28250 & 32768;
  if (D.28256 != 0) goto <D.28257>; else goto <D.28258>;
  <D.28257>:
  D.28250 = exc_class->type_token;
  D.28259 = D.28250 >> 16;
  D.28260 = D.28259 + 1;
  D.28261 = D.28260 & 65535;
  D.28262 = D.28261 | 1006895104;
  MEM[(guint32 *)code] = D.28262;
  code = code + 4;
  goto <D.28263>;
  <D.28258>:
  D.28250 = exc_class->type_token;
  D.28259 = D.28250 >> 16;
  D.28264 = D.28259 | 1006895104;
  MEM[(guint32 *)code] = D.28264;
  code = code + 4;
  <D.28263>:
  D.28250 = exc_class->type_token;
  D.28265 = D.28250 & 65535;
  if (D.28265 != 0) goto <D.28266>; else goto <D.28267>;
  <D.28266>:
  D.28250 = exc_class->type_token;
  D.28265 = D.28250 & 65535;
  D.28268 = D.28265 | 612630528;
  MEM[(guint32 *)code] = D.28268;
  code = code + 4;
  <D.28267>:
  goto <D.28269>;
  <D.28255>:
  D.28250 = exc_class->type_token;
  D.28265 = D.28250 & 65535;
  D.28270 = D.28265 | 604241920;
  MEM[(guint32 *)code] = D.28270;
  code = code + 4;
  <D.28269>:
  addr = mono_get_throw_corlib_exception ();
  {
    guint32 _target;

    _target = (guint32) addr;
    if (1 != 0) goto <D.28271>; else goto <D.28272>;
    <D.28271>:
    D.28273 = (short int) _target;
    D.28274 = (int) D.28273;
    _target.104 = (int) _target;
    if (D.28274 != _target.104) goto <D.28276>; else goto <D.28277>;
    <D.28276>:
    D.28278 = _target & 32768;
    if (D.28278 != 0) goto <D.28279>; else goto <D.28280>;
    <D.28279>:
    D.28281 = _target >> 16;
    D.28282 = D.28281 + 1;
    D.28283 = D.28282 & 65535;
    D.28284 = D.28283 | 1008271360;
    MEM[(guint32 *)code] = D.28284;
    code = code + 4;
    goto <D.28285>;
    <D.28280>:
    D.28281 = _target >> 16;
    D.28286 = D.28281 | 1008271360;
    MEM[(guint32 *)code] = D.28286;
    code = code + 4;
    <D.28285>:
    D.28287 = _target & 65535;
    if (D.28287 != 0) goto <D.28288>; else goto <D.28289>;
    <D.28288>:
    D.28287 = _target & 65535;
    D.28290 = D.28287 | 658046976;
    MEM[(guint32 *)code] = D.28290;
    code = code + 4;
    <D.28289>:
    goto <D.28291>;
    <D.28277>:
    D.28287 = _target & 65535;
    D.28292 = D.28287 | 605618176;
    MEM[(guint32 *)code] = D.28292;
    code = code + 4;
    <D.28291>:
    MEM[(guint32 *)code] = 52492297;
    code = code + 4;
    goto <D.28293>;
    <D.28272>:
    D.28294 = _target >> 2;
    D.28295 = D.28294 & 67108863;
    D.28296 = D.28295 | 201326592;
    MEM[(guint32 *)code] = D.28296;
    code = code + 4;
    <D.28293>:
    MEM[(guint32 *)code] = 2099237;
    code = code + 4;
  }
  D.28297 = code;
  return D.28297;
}


mono_arch_register_lowlevel_calls ()
{

}


mono_arch_patch_code (struct MonoMethod * method, struct MonoDomain * domain, guint8 * code, struct MonoJumpInfo * ji, struct MonoCodeManager * dyn_code_mp, gboolean run_cctors)
{
  int D.28299;
  sizetype D.28300;
  <unnamed type> D.28301;
  unsigned int ip.105;
  struct MonoJumpInfoBBTable * D.28303;
  unsigned int table.106;
  unsigned int i.107;
  unsigned int D.28306;
  void * * D.28307;
  struct MonoBasicBlock * * D.28308;
  struct MonoBasicBlock * * D.28309;
  struct MonoBasicBlock * D.28310;
  sizetype D.28311;
  void * D.28312;
  int D.28313;
  unsigned int target.108;
  struct MonoJumpInfo * patch_info;

  patch_info = ji;
  goto <D.23116>;
  <D.23115>:
  {
    unsigned char * ip;
    const unsigned char * target;

    D.28299 = patch_info->ip.i;
    D.28300 = (sizetype) D.28299;
    ip = code + D.28300;
    target = 0B;
    D.28301 = patch_info->type;
    switch (D.28301) <default: <D.23113>, case 6: <D.23100>, case 8: <D.23094>, case 11: <D.23101>, case 12: <D.23102>, case 13: <D.23103>, case 14: <D.23104>, case 16: <D.23106>, case 17: <D.23107>, case 18: <D.23109>, case 19: <D.23108>, case 20: <D.23110>, case 21: <D.23111>, case 22: <D.23092>, case 23: <D.23105>, case 51: <D.23112>>
    <D.23092>:
    ip.105 = (unsigned int) ip;
    patch_lui_addiu (ip, ip.105);
    // predicted unlikely by continue predictor.
    goto <D.23093>;
    <D.23094>:
    {
      void * * table;
      int i;

      D.28303 = patch_info->data.table;
      table = D.28303->table;
      table.106 = (unsigned int) table;
      patch_lui_addiu (ip, table.106);
      i = 0;
      goto <D.23098>;
      <D.23097>:
      i.107 = (unsigned int) i;
      D.28306 = i.107 * 4;
      D.28307 = table + D.28306;
      D.28303 = patch_info->data.table;
      D.28308 = D.28303->table;
      i.107 = (unsigned int) i;
      D.28306 = i.107 * 4;
      D.28309 = D.28308 + D.28306;
      D.28310 = *D.28309;
      D.28311 = (sizetype) D.28310;
      D.28312 = code + D.28311;
      *D.28307 = D.28312;
      i = i + 1;
      <D.23098>:
      D.28303 = patch_info->data.table;
      D.28313 = D.28303->table_size;
      if (D.28313 > i) goto <D.23097>; else goto <D.23099>;
      <D.23099>:
      // predicted unlikely by continue predictor.
      goto <D.23093>;
    }
    <D.23100>:
    <D.23101>:
    <D.23102>:
    <D.23103>:
    <D.23104>:
    <D.23105>:
    <D.23106>:
    <D.23107>:
    <D.23108>:
    <D.23109>:
    <D.23110>:
    <D.23111>:
    target = mono_resolve_patch_target (method, domain, code, patch_info, run_cctors);
    target.108 = (unsigned int) target;
    patch_lui_addiu (ip, target.108);
    // predicted unlikely by continue predictor.
    goto <D.23093>;
    <D.23112>:
    // predicted unlikely by continue predictor.
    goto <D.23093>;
    <D.23113>:
    target = mono_resolve_patch_target (method, domain, code, patch_info, run_cctors);
    target.108 = (unsigned int) target;
    mips_patch (ip, target.108);
    goto <D.23114>;
    <D.23114>:
  }
  <D.23093>:
  patch_info = patch_info->next;
  <D.23116>:
  if (patch_info != 0B) goto <D.23115>; else goto <D.23117>;
  <D.23117>:
}


mono_arch_instrument_prolog (struct MonoCompile * cfg, void * func, void * p, gboolean enable_arguments)
{
  unsigned int D.28315;
  int D.28316;
  int D.28317;
  unsigned int D.28318;
  int D.28319;
  int D.28320;
  int D.28321;
  unsigned int D.28322;
  int D.28323;
  int D.28324;
  int D.28325;
  unsigned int D.28326;
  int D.28327;
  int D.28328;
  int D.28329;
  unsigned int D.28330;
  struct MonoMethod * D.28331;
  int D.28332;
  short int D.28333;
  int D.28334;
  unsigned int D.28337;
  unsigned int D.28338;
  unsigned int D.28341;
  unsigned int D.28342;
  unsigned int D.28343;
  unsigned int D.28344;
  unsigned int D.28346;
  unsigned int D.28347;
  unsigned int D.28350;
  unsigned int D.28352;
  int D.28353;
  unsigned int D.28354;
  short int D.28357;
  int D.28358;
  int _target.109;
  unsigned int D.28362;
  unsigned int D.28365;
  unsigned int D.28366;
  unsigned int D.28367;
  unsigned int D.28368;
  unsigned int D.28370;
  unsigned int D.28371;
  unsigned int D.28374;
  unsigned int D.28376;
  unsigned int D.28378;
  unsigned int D.28379;
  unsigned int D.28380;
  int D.28381;
  unsigned int D.28382;
  int D.28383;
  unsigned int D.28384;
  int D.28385;
  unsigned int D.28386;
  int D.28387;
  unsigned int D.28388;
  void * D.28389;
  guchar * code;
  int offset;

  code = p;
  D.28315 = cfg->arch.tracing_offset;
  offset = (int) D.28315;
  MEM[(guint32 *)code] = 2099237;
  code = code + 4;
  MEM[(guint32 *)code] = 2099237;
  code = code + 4;
  MEM[(guint32 *)code] = 2099237;
  code = code + 4;
  D.28316 = offset & 65535;
  D.28317 = D.28316 | -1348206592;
  D.28318 = (unsigned int) D.28317;
  MEM[(guint32 *)code] = D.28318;
  code = code + 4;
  D.28319 = offset + 4;
  D.28320 = D.28319 & 65535;
  D.28321 = D.28320 | -1348141056;
  D.28322 = (unsigned int) D.28321;
  MEM[(guint32 *)code] = D.28322;
  code = code + 4;
  D.28323 = offset + 8;
  D.28324 = D.28323 & 65535;
  D.28325 = D.28324 | -1348075520;
  D.28326 = (unsigned int) D.28325;
  MEM[(guint32 *)code] = D.28326;
  code = code + 4;
  D.28327 = offset + 12;
  D.28328 = D.28327 & 65535;
  D.28329 = D.28328 | -1348009984;
  D.28330 = (unsigned int) D.28329;
  MEM[(guint32 *)code] = D.28330;
  code = code + 4;
  D.28331 = cfg->method;
  D.28332 = (int) D.28331;
  D.28333 = (short int) D.28332;
  D.28334 = (int) D.28333;
  D.28331 = cfg->method;
  D.28332 = (int) D.28331;
  if (D.28334 != D.28332) goto <D.28335>; else goto <D.28336>;
  <D.28335>:
  D.28331 = cfg->method;
  D.28337 = (unsigned int) D.28331;
  D.28338 = D.28337 & 32768;
  if (D.28338 != 0) goto <D.28339>; else goto <D.28340>;
  <D.28339>:
  D.28331 = cfg->method;
  D.28337 = (unsigned int) D.28331;
  D.28341 = D.28337 >> 16;
  D.28342 = D.28341 + 1;
  D.28343 = D.28342 & 65535;
  D.28344 = D.28343 | 1006895104;
  MEM[(guint32 *)code] = D.28344;
  code = code + 4;
  goto <D.28345>;
  <D.28340>:
  D.28331 = cfg->method;
  D.28337 = (unsigned int) D.28331;
  D.28341 = D.28337 >> 16;
  D.28346 = D.28341 | 1006895104;
  MEM[(guint32 *)code] = D.28346;
  code = code + 4;
  <D.28345>:
  D.28331 = cfg->method;
  D.28337 = (unsigned int) D.28331;
  D.28347 = D.28337 & 65535;
  if (D.28347 != 0) goto <D.28348>; else goto <D.28349>;
  <D.28348>:
  D.28331 = cfg->method;
  D.28337 = (unsigned int) D.28331;
  D.28347 = D.28337 & 65535;
  D.28350 = D.28347 | 612630528;
  MEM[(guint32 *)code] = D.28350;
  code = code + 4;
  <D.28349>:
  goto <D.28351>;
  <D.28336>:
  D.28331 = cfg->method;
  D.28337 = (unsigned int) D.28331;
  D.28347 = D.28337 & 65535;
  D.28352 = D.28347 | 604241920;
  MEM[(guint32 *)code] = D.28352;
  code = code + 4;
  <D.28351>:
  D.28316 = offset & 65535;
  D.28353 = D.28316 | 665124864;
  D.28354 = (unsigned int) D.28353;
  MEM[(guint32 *)code] = D.28354;
  code = code + 4;
  {
    guint32 _target;

    _target = (guint32) func;
    if (1 != 0) goto <D.28355>; else goto <D.28356>;
    <D.28355>:
    D.28357 = (short int) _target;
    D.28358 = (int) D.28357;
    _target.109 = (int) _target;
    if (D.28358 != _target.109) goto <D.28360>; else goto <D.28361>;
    <D.28360>:
    D.28362 = _target & 32768;
    if (D.28362 != 0) goto <D.28363>; else goto <D.28364>;
    <D.28363>:
    D.28365 = _target >> 16;
    D.28366 = D.28365 + 1;
    D.28367 = D.28366 & 65535;
    D.28368 = D.28367 | 1008271360;
    MEM[(guint32 *)code] = D.28368;
    code = code + 4;
    goto <D.28369>;
    <D.28364>:
    D.28365 = _target >> 16;
    D.28370 = D.28365 | 1008271360;
    MEM[(guint32 *)code] = D.28370;
    code = code + 4;
    <D.28369>:
    D.28371 = _target & 65535;
    if (D.28371 != 0) goto <D.28372>; else goto <D.28373>;
    <D.28372>:
    D.28371 = _target & 65535;
    D.28374 = D.28371 | 658046976;
    MEM[(guint32 *)code] = D.28374;
    code = code + 4;
    <D.28373>:
    goto <D.28375>;
    <D.28361>:
    D.28371 = _target & 65535;
    D.28376 = D.28371 | 605618176;
    MEM[(guint32 *)code] = D.28376;
    code = code + 4;
    <D.28375>:
    MEM[(guint32 *)code] = 52492297;
    code = code + 4;
    goto <D.28377>;
    <D.28356>:
    D.28378 = _target >> 2;
    D.28379 = D.28378 & 67108863;
    D.28380 = D.28379 | 201326592;
    MEM[(guint32 *)code] = D.28380;
    code = code + 4;
    <D.28377>:
    MEM[(guint32 *)code] = 2099237;
    code = code + 4;
  }
  MEM[(guint32 *)code] = 2099237;
  code = code + 4;
  D.28316 = offset & 65535;
  D.28381 = D.28316 | -1885077504;
  D.28382 = (unsigned int) D.28381;
  MEM[(guint32 *)code] = D.28382;
  code = code + 4;
  D.28319 = offset + 4;
  D.28320 = D.28319 & 65535;
  D.28383 = D.28320 | -1885011968;
  D.28384 = (unsigned int) D.28383;
  MEM[(guint32 *)code] = D.28384;
  code = code + 4;
  D.28323 = offset + 8;
  D.28324 = D.28323 & 65535;
  D.28385 = D.28324 | -1884946432;
  D.28386 = (unsigned int) D.28385;
  MEM[(guint32 *)code] = D.28386;
  code = code + 4;
  D.28327 = offset + 12;
  D.28328 = D.28327 & 65535;
  D.28387 = D.28328 | -1884880896;
  D.28388 = (unsigned int) D.28387;
  MEM[(guint32 *)code] = D.28388;
  code = code + 4;
  MEM[(guint32 *)code] = 2099237;
  code = code + 4;
  MEM[(guint32 *)code] = 2099237;
  code = code + 4;
  MEM[(guint32 *)code] = 2099237;
  code = code + 4;
  D.28389 = code;
  return D.28389;
}


mips_adjust_stackframe (struct MonoCompile * cfg)
{
  int D.28391;
  unsigned int D.28392;
  unsigned int D.28393;
  int D.28396;
  int D.28397;
  int D.28398;
  unsigned int D.28399;
  unsigned int D.28400;
  unsigned int D.28403;
  unsigned int D.28404;
  struct MonoMethod * D.28407;
  struct MonoType * D.28410;
  int D.28413;
  struct MonoInst * D.28416;
  int D.28417;
  int D.28418;
  struct MonoInst * * D.28419;
  unsigned int i.110;
  unsigned int D.28421;
  struct MonoInst * * D.28422;
  int D.28423;
  int D.28424;
  short unsigned int D.28425;
  int D.28426;
  <unnamed-unsigned:1> D.28427;
  int D.28428;
  int D.28429;
  int D.28432;
  short unsigned int D.28437;
  short unsigned int D.28438;
  int D.28440;
  unsigned int D.28441;
  unsigned int D.28442;
  int D.28444;
  short unsigned int D.28445;
  int D.28448;
  unsigned int D.28449;
  unsigned int D.28450;
  unsigned int D.28456;
  unsigned int D.28457;
  int D.28462;
  int D.28465;
  int D.28471;
  int D.28472;
  _Bool D.28475;
  long int D.28476;
  long int D.28477;
  int D.28482;
  int D.28485;
  struct MonoBasicBlock * bb;
  int delta;
  int threshold;
  int i;
  struct MonoMethodSignature * sig;
  int ra_offset;

  D.28391 = cfg->stack_offset;
  D.28392 = (unsigned int) D.28391;
  D.28393 = cfg->arch.local_alloc_offset;
  if (D.28392 == D.28393) goto <D.28394>; else goto <D.28395>;
  <D.28394>:
  return;
  <D.28395>:
  D.28391 = cfg->stack_offset;
  D.28396 = D.28391 + 4;
  cfg->stack_offset = D.28396;
  D.28391 = cfg->stack_offset;
  D.28397 = D.28391 + 15;
  D.28398 = D.28397 & -16;
  cfg->stack_offset = D.28398;
  D.28391 = cfg->stack_offset;
  D.28392 = (unsigned int) D.28391;
  D.28393 = cfg->arch.local_alloc_offset;
  D.28399 = D.28392 - D.28393;
  delta = (int) D.28399;
  D.28400 = cfg->verbose_level;
  if (D.28400 > 2) goto <D.28401>; else goto <D.28402>;
  <D.28401>:
  monoeg_g_print ("mips_adjust_stackframe:\n");
  D.28393 = cfg->arch.local_alloc_offset;
  D.28391 = cfg->stack_offset;
  monoeg_g_print ("\tspillvars allocated 0x%x -> 0x%x\n", D.28393, D.28391);
  <D.28402>:
  D.28393 = cfg->arch.local_alloc_offset;
  threshold = (int) D.28393;
  D.28391 = cfg->stack_offset;
  D.28403 = (unsigned int) D.28391;
  D.28404 = D.28403 + 4294967292;
  ra_offset = (int) D.28404;
  D.28400 = cfg->verbose_level;
  if (D.28400 > 2) goto <D.28405>; else goto <D.28406>;
  <D.28405>:
  monoeg_g_print ("\tra_offset %d/0x%x delta %d/0x%x\n", ra_offset, ra_offset, delta, delta);
  <D.28406>:
  D.28407 = cfg->method;
  sig = mono_method_signature (D.28407);
  if (sig != 0B) goto <D.28408>; else goto <D.28409>;
  <D.28408>:
  D.28410 = sig->ret;
  if (D.28410 != 0B) goto <D.28411>; else goto <D.28412>;
  <D.28411>:
  D.28410 = sig->ret;
  D.28413 = mono_type_is_struct (D.28410);
  if (D.28413 != 0) goto <D.28414>; else goto <D.28415>;
  <D.28414>:
  D.28416 = cfg->vret_addr;
  D.28416 = cfg->vret_addr;
  D.28417 = D.28416->data.op[0].const_val;
  D.28418 = D.28417 + delta;
  D.28416->data.op[0].const_val = D.28418;
  <D.28415>:
  <D.28412>:
  <D.28409>:
  i = 0;
  goto <D.23138>;
  <D.23137>:
  {
    struct MonoInst * inst;

    D.28419 = cfg->args;
    i.110 = (unsigned int) i;
    D.28421 = i.110 * 4;
    D.28422 = D.28419 + D.28421;
    inst = *D.28422;
    D.28423 = inst->data.op[0].const_val;
    D.28424 = D.28423 + delta;
    inst->data.op[0].const_val = D.28424;
  }
  i = i + 1;
  <D.23138>:
  D.28425 = sig->param_count;
  D.28426 = (int) D.28425;
  D.28427 = sig->hasthis;
  D.28428 = (int) D.28427;
  D.28429 = D.28426 + D.28428;
  if (D.28429 > i) goto <D.23137>; else goto <D.23139>;
  <D.23139>:
  bb = cfg->bb_entry;
  goto <D.23157>;
  <D.23156>:
  {
    int ins_cnt;
    struct MonoInst * ins;

    ins_cnt = 0;
    D.28400 = cfg->verbose_level;
    if (D.28400 > 2) goto <D.28430>; else goto <D.28431>;
    <D.28430>:
    D.28432 = bb->block_num;
    monoeg_g_print ("BASIC BLOCK %d:\n", D.28432);
    <D.28431>:
    ins = bb->code;
    goto <D.23154>;
    <D.23153>:
    {
      int adj_c0;
      int adj_imm;

      adj_c0 = 0;
      adj_imm = 0;
      D.28400 = cfg->verbose_level;
      if (D.28400 > 2) goto <D.28433>; else goto <D.28434>;
      <D.28433>:
      mono_print_ins_index (ins_cnt, ins);
      <D.28434>:
      D.28437 = ins->opcode;
      D.28438 = D.28437 + 65148;
      if (D.28438 <= 11) goto <D.28439>; else goto <D.28435>;
      <D.28439>:
      D.28440 = ins->sreg1;
      D.28441 = (unsigned int) D.28440;
      D.28442 = D.28441 + 4294967267;
      if (D.28442 <= 1) goto <D.28443>; else goto <D.28435>;
      <D.28443>:
      D.28437 = ins->opcode;
      D.28444 = (int) D.28437;
      switch (D.28444) <default: <D.23147>, case 395: <D.23144>, case 397: <D.23145>>
      <D.23144>:
      <D.23145>:
      adj_c0 = 8;
      goto <D.23146>;
      <D.23147>:
      adj_c0 = 4;
      goto <D.23146>;
      <D.23146>:
      goto <D.28436>;
      <D.28435>:
      D.28437 = ins->opcode;
      D.28445 = D.28437 + 65162;
      if (D.28445 <= 13) goto <D.28446>; else goto <D.28447>;
      <D.28446>:
      D.28448 = ins->dreg;
      D.28449 = (unsigned int) D.28448;
      D.28450 = D.28449 + 4294967267;
      if (D.28450 <= 1) goto <D.28451>; else goto <D.28452>;
      <D.28451>:
      D.28437 = ins->opcode;
      D.28444 = (int) D.28437;
      switch (D.28444) <default: <D.23152>, case 378: <D.23148>, case 380: <D.23149>, case 385: <D.23150>>
      <D.23148>:
      <D.23149>:
      <D.23150>:
      adj_c0 = 8;
      goto <D.23151>;
      <D.23152>:
      adj_c0 = 4;
      goto <D.23151>;
      <D.23151>:
      <D.28452>:
      <D.28447>:
      <D.28436>:
      D.28437 = ins->opcode;
      if (D.28437 == 429) goto <D.28453>; else goto <D.28455>;
      <D.28455>:
      D.28437 = ins->opcode;
      if (D.28437 == 625) goto <D.28453>; else goto <D.28454>;
      <D.28453>:
      D.28440 = ins->sreg1;
      D.28456 = (unsigned int) D.28440;
      D.28457 = cfg->frame_reg;
      if (D.28456 == D.28457) goto <D.28458>; else goto <D.28459>;
      <D.28458>:
      adj_imm = 1;
      <D.28459>:
      <D.28454>:
      if (adj_c0 != 0) goto <D.28460>; else goto <D.28461>;
      <D.28460>:
      D.28462 = ins->data.op[0].const_val;
      if (D.28462 >= threshold) goto <D.28463>; else goto <D.28464>;
      <D.28463>:
      D.28462 = ins->data.op[0].const_val;
      D.28465 = D.28462 + delta;
      ins->data.op[0].const_val = D.28465;
      D.28400 = cfg->verbose_level;
      if (D.28400 > 2) goto <D.28466>; else goto <D.28467>;
      <D.28466>:
      monoeg_g_print ("adj");
      mono_print_ins_index (ins_cnt, ins);
      <D.28467>:
      goto <D.28468>;
      <D.28464>:
      D.28462 = ins->data.op[0].const_val;
      if (D.28462 < 0) goto <D.28469>; else goto <D.28470>;
      <D.28469>:
      D.28462 = ins->data.op[0].const_val;
      D.28471 = -D.28462;
      D.28472 = D.28471 - adj_c0;
      ins->data.op[0].const_val = D.28472;
      D.28400 = cfg->verbose_level;
      if (D.28400 > 2) goto <D.28473>; else goto <D.28474>;
      <D.28473>:
      monoeg_g_print ("spill");
      mono_print_ins_index (ins_cnt, ins);
      <D.28474>:
      <D.28470>:
      <D.28468>:
      D.28462 = ins->data.op[0].const_val;
      D.28475 = D.28462 == ra_offset;
      D.28476 = (long int) D.28475;
      D.28477 = __builtin_expect (D.28476, 0);
      if (D.28477 != 0) goto <D.28478>; else goto <D.28479>;
      <D.28478>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 4872, "ins->inst_c0 != ra_offset");
      <D.28479>:
      <D.28461>:
      if (adj_imm != 0) goto <D.28480>; else goto <D.28481>;
      <D.28480>:
      D.28482 = ins->data.op[1].const_val;
      if (D.28482 >= threshold) goto <D.28483>; else goto <D.28484>;
      <D.28483>:
      D.28482 = ins->data.op[1].const_val;
      D.28485 = D.28482 + delta;
      ins->data.op[1].const_val = D.28485;
      D.28400 = cfg->verbose_level;
      if (D.28400 > 2) goto <D.28486>; else goto <D.28487>;
      <D.28486>:
      monoeg_g_print ("adj");
      mono_print_ins_index (ins_cnt, ins);
      <D.28487>:
      <D.28484>:
      D.28462 = ins->data.op[0].const_val;
      D.28475 = D.28462 == ra_offset;
      D.28476 = (long int) D.28475;
      D.28477 = __builtin_expect (D.28476, 0);
      if (D.28477 != 0) goto <D.28488>; else goto <D.28489>;
      <D.28488>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 4882, "ins->inst_c0 != ra_offset");
      <D.28489>:
      <D.28481>:
      ins_cnt = ins_cnt + 1;
    }
    ins = ins->next;
    <D.23154>:
    if (ins != 0B) goto <D.23153>; else goto <D.23155>;
    <D.23155>:
  }
  bb = bb->next_bb;
  <D.23157>:
  if (bb != 0B) goto <D.23156>; else goto <D.23158>;
  <D.23158>:
}


mono_arch_emit_prolog (struct MonoCompile * cfg)
{
  struct MonoTraceSpec * mono_jit_trace_calls.111;
  int D.28494;
  unsigned int D.28499;
  unsigned int D.28500;
  short unsigned int D.28501;
  int D.28502;
  int D.28503;
  int D.28504;
  unsigned int D.28505;
  unsigned int D.28506;
  void * D.28507;
  unsigned int D.28508;
  unsigned int D.28509;
  short unsigned int D.28512;
  int D.28513;
  int D.28514;
  short unsigned int D.28515;
  sizetype D.28516;
  sizetype D.28517;
  guint8 * D.28518;
  unsigned char D.28519;
  int D.28520;
  int code.112;
  unsigned char * D.28524;
  int D.28525;
  int D.28526;
  unsigned int alloc_size.113;
  unsigned int D.28528;
  unsigned short D.28533;
  unsigned short D.28534;
  short int D.28535;
  int D.28536;
  int D.28537;
  _Bool D.28538;
  long int D.28539;
  long int D.28540;
  int D.28543;
  int D.28544;
  unsigned int D.28545;
  unsigned int alloc_size.114;
  unsigned int D.28549;
  short int D.28550;
  int D.28551;
  int D.28554;
  int D.28555;
  unsigned int D.28556;
  int D.28558;
  unsigned int D.28559;
  unsigned int alloc2_size.115;
  unsigned int D.28561;
  int D.28564;
  unsigned int D.28565;
  unsigned int D.28566;
  unsigned int D.28569;
  unsigned int D.28570;
  int D.28571;
  _Bool D.28572;
  long int D.28573;
  long int D.28574;
  short int D.28577;
  int D.28578;
  _Bool D.28579;
  long int D.28580;
  long int D.28581;
  int D.28584;
  int D.28585;
  int D.28586;
  int D.28587;
  unsigned int D.28588;
  int D.28589;
  unsigned int D.28590;
  unsigned int D.28591;
  sizetype i.116;
  sizetype D.28595;
  void * D.28596;
  unsigned int D.28597;
  unsigned int D.28598;
  short int D.28599;
  int D.28600;
  _Bool D.28601;
  long int D.28602;
  long int D.28603;
  unsigned int D.28606;
  unsigned int D.28607;
  int D.28610;
  int D.28611;
  unsigned int D.28612;
  unsigned int D.28613;
  unsigned int D.28616;
  unsigned int D.28617;
  int D.28618;
  sizetype D.28621;
  void * D.28622;
  unsigned int D.28623;
  unsigned int D.28624;
  short int D.28625;
  int D.28626;
  _Bool D.28627;
  long int D.28628;
  long int D.28629;
  unsigned int D.28632;
  unsigned int offset.117;
  unsigned int D.28634;
  unsigned int D.28635;
  unsigned int D.28636;
  struct MonoInst * D.28637;
  short unsigned int D.28640;
  _Bool D.28641;
  long int D.28642;
  long int D.28643;
  int D.28646;
  short int D.28647;
  int D.28648;
  _Bool D.28649;
  long int D.28650;
  long int D.28651;
  int D.28654;
  int D.28655;
  int D.28656;
  int D.28657;
  int D.28658;
  unsigned int D.28659;
  void * D.28660;
  struct MonoGenericSharingContext * D.28663;
  struct MonoMemPool * D.28664;
  struct CallInfo * D.28665;
  struct MonoType * D.28666;
  int D.28667;
  short unsigned int D.28670;
  unsigned char D.28673;
  int D.28674;
  int D.28675;
  int D.28676;
  int D.28677;
  int D.28678;
  int D.28679;
  unsigned int D.28680;
  int D.28682;
  short int D.28683;
  int D.28684;
  int D.28687;
  int D.28688;
  int D.28689;
  int D.28690;
  int D.28691;
  int D.28692;
  int D.28693;
  unsigned int D.28694;
  unsigned int D.28698;
  unsigned int D.28699;
  unsigned int D.28702;
  unsigned int D.28703;
  unsigned int D.28704;
  unsigned int D.28705;
  unsigned int D.28707;
  unsigned int D.28708;
  unsigned int D.28711;
  unsigned int D.28713;
  int D.28714;
  int D.28715;
  unsigned int D.28716;
  int D.28717;
  unsigned int D.28718;
  unsigned int D.28719;
  unsigned int D.28720;
  int D.28723;
  <unnamed type> D.28724;
  _Bool D.28725;
  long int D.28726;
  long int D.28727;
  short int D.28730;
  int D.28731;
  _Bool D.28732;
  long int D.28733;
  long int D.28734;
  unsigned int D.28737;
  unsigned int offset.118;
  unsigned int D.28739;
  unsigned int D.28740;
  unsigned int D.28741;
  int D.28742;
  int D.28743;
  unsigned int D.28744;
  unsigned int D.28745;
  unsigned int D.28746;
  unsigned int D.28747;
  struct MonoInst * * D.28748;
  unsigned int pos.119;
  unsigned int D.28750;
  struct MonoInst * * D.28751;
  unsigned int D.28752;
  <unnamed type> D.28755;
  unsigned char D.28760;
  int D.28761;
  int D.28762;
  int D.28763;
  int D.28764;
  unsigned int D.28765;
  int D.28771;
  unsigned int D.28772;
  unsigned int D.28773;
  short int D.28774;
  int D.28775;
  _Bool D.28776;
  long int D.28777;
  long int D.28778;
  int D.28781;
  int D.28782;
  int D.28783;
  int D.28784;
  unsigned int D.28785;
  const char * D.28789;
  unsigned int D.28795;
  _Bool D.28796;
  long int D.28797;
  long int D.28798;
  short int D.28801;
  int D.28802;
  _Bool D.28803;
  long int D.28804;
  long int D.28805;
  <unnamed-unsigned:4> D.28808;
  int D.28809;
  int D.28810;
  int D.28811;
  int D.28812;
  int D.28813;
  int D.28814;
  unsigned int D.28815;
  int D.28816;
  int D.28817;
  int D.28818;
  unsigned int D.28819;
  int D.28820;
  int D.28821;
  unsigned int D.28822;
  int ls_word_offset.120;
  int D.28824;
  int D.28825;
  int D.28826;
  unsigned int D.28827;
  int D.28828;
  int D.28829;
  int D.28830;
  int ms_word_offset.121;
  int D.28832;
  int D.28833;
  int D.28834;
  unsigned int D.28835;
  _Bool D.28839;
  long int D.28840;
  long int D.28841;
  int D.28844;
  int D.28845;
  unsigned int D.28846;
  int D.28847;
  int D.28848;
  unsigned int D.28849;
  int D.28850;
  int D.28851;
  unsigned int D.28852;
  unsigned short D.28858;
  unsigned short D.28859;
  short int D.28860;
  int D.28861;
  int D.28862;
  _Bool D.28863;
  long int D.28864;
  long int D.28865;
  unsigned int D.28868;
  unsigned int D.28869;
  int D.28872;
  int D.28873;
  int D.28874;
  int D.28875;
  int D.28876;
  unsigned int D.28877;
  int D.28878;
  int D.28879;
  int D.28880;
  int D.28881;
  unsigned int D.28882;
  int D.28886;
  unsigned int D.28887;
  unsigned short D.28894;
  unsigned short D.28895;
  unsigned short D.28896;
  short int D.28897;
  int D.28898;
  unsigned int D.28899;
  unsigned int D.28900;
  unsigned int D.28901;
  int D.28902;
  _Bool D.28903;
  long int D.28904;
  long int D.28905;
  short int D.28908;
  int D.28909;
  _Bool D.28910;
  long int D.28911;
  long int D.28912;
  int D.28915;
  int D.28916;
  int D.28917;
  int D.28918;
  int D.28919;
  unsigned int D.28920;
  short unsigned int D.28926;
  unsigned int D.28927;
  unsigned int D.28928;
  int D.28929;
  <unnamed-unsigned:1> D.28931;
  int D.28932;
  int D.28933;
  unsigned int D.28944;
  unsigned int D.28945;
  unsigned int D.28946;
  int lmf_pthread_key.122;
  short int D.28952;
  int D.28953;
  _Bool D.28954;
  long int D.28955;
  long int D.28956;
  int D.28959;
  int D.28960;
  unsigned int D.28961;
  short int D.28965;
  int D.28966;
  int _target.123;
  unsigned int D.28970;
  unsigned int D.28973;
  unsigned int D.28974;
  unsigned int D.28975;
  unsigned int D.28976;
  unsigned int D.28978;
  unsigned int D.28979;
  unsigned int D.28982;
  unsigned int D.28984;
  unsigned int D.28986;
  unsigned int D.28987;
  unsigned int D.28988;
  unsigned short D.28989;
  unsigned short D.28990;
  short int D.28991;
  int D.28992;
  unsigned int D.28993;
  int D.28994;
  _Bool D.28995;
  long int D.28996;
  long int D.28997;
  unsigned int D.29000;
  unsigned int D.29001;
  short int D.29002;
  int D.29003;
  int lmf_offset.124;
  _Bool D.29005;
  long int D.29006;
  long int D.29007;
  unsigned int D.29010;
  unsigned int D.29011;
  short int D.29012;
  int D.29013;
  _Bool D.29014;
  long int D.29015;
  long int D.29016;
  unsigned int D.29019;
  int method.125;
  short int D.29021;
  int D.29022;
  unsigned int method.126;
  unsigned int D.29026;
  unsigned int D.29029;
  unsigned int D.29030;
  unsigned int D.29031;
  unsigned int D.29032;
  unsigned int D.29034;
  unsigned int D.29035;
  unsigned int D.29038;
  unsigned int D.29040;
  unsigned short D.29041;
  short int D.29042;
  int D.29043;
  unsigned int D.29044;
  int D.29045;
  _Bool D.29046;
  long int D.29047;
  long int D.29048;
  unsigned int D.29051;
  unsigned int D.29052;
  unsigned int D.29061;
  unsigned int D.29062;
  unsigned int D.29063;
  unsigned short D.29066;
  unsigned short D.29067;
  short int D.29068;
  int D.29069;
  int D.29070;
  int D.29073;
  int D.29074;
  unsigned int D.29075;
  unsigned int D.29079;
  unsigned int D.29080;
  unsigned int D.29083;
  unsigned int D.29084;
  unsigned int D.29085;
  unsigned int D.29086;
  unsigned int D.29088;
  unsigned int D.29089;
  unsigned int D.29092;
  unsigned int D.29094;
  int D.29100;
  unsigned int D.29101;
  unsigned int D.29102;
  unsigned int D.29103;
  _Bool D.29104;
  long int D.29105;
  long int D.29106;
  guint8 * D.29109;
  struct MonoMethod * method;
  struct MonoMethodSignature * sig;
  struct MonoInst * inst;
  int alloc_size;
  int pos;
  int i;
  int max_offset;
  int alloc2_size;
  guint8 * code;
  struct CallInfo * cinfo;
  int tracing;
  guint32 iregs_to_save;
  guint32 lmf_offset;
  int cfa_offset;
  struct MonoBasicBlock * bb;

  method = cfg->method;
  alloc2_size = 0;
  tracing = 0;
  iregs_to_save = 0;
  lmf_offset = cfg->arch.lmf_offset;
  cfa_offset = 0;
  mono_jit_trace_calls.111 = mono_jit_trace_calls;
  if (mono_jit_trace_calls.111 != 0B) goto <D.28492>; else goto <D.28493>;
  <D.28492>:
  D.28494 = mono_trace_eval (method);
  if (D.28494 != 0) goto <D.28495>; else goto <D.28496>;
  <D.28495>:
  tracing = 1;
  <D.28496>:
  <D.28493>:
  if (tracing != 0) goto <D.28497>; else goto <D.28498>;
  <D.28497>:
  D.28499 = cfg->flags;
  D.28500 = D.28499 | 2;
  cfg->flags = D.28500;
  <D.28498>:
  sig = mono_method_signature (method);
  D.28501 = sig->param_count;
  D.28502 = (int) D.28501;
  D.28503 = D.28502 * 20;
  D.28504 = D.28503 + 768;
  D.28505 = (unsigned int) D.28504;
  cfg->code_size = D.28505;
  D.28506 = cfg->code_size;
  D.28507 = monoeg_malloc (D.28506);
  cfg->native_code = D.28507;
  code = cfg->native_code;
  max_offset = 0;
  bb = cfg->bb_entry;
  goto <D.23182>;
  <D.23181>:
  {
    struct MonoInst * ins;

    ins = bb->code;
    bb->max_offset = max_offset;
    D.28508 = cfg->prof_options;
    D.28509 = D.28508 & 8192;
    if (D.28509 != 0) goto <D.28510>; else goto <D.28511>;
    <D.28510>:
    max_offset = max_offset + 6;
    <D.28511>:
    ins = bb->code;
    goto <D.23179>;
    <D.23178>:
    D.28512 = ins->opcode;
    D.28513 = (int) D.28512;
    D.28514 = D.28513 + -313;
    D.28515 = mips_desc_idx[D.28514];
    D.28516 = (sizetype) D.28515;
    D.28517 = D.28516 + 4;
    D.28518 = &mips_desc + D.28517;
    D.28519 = *D.28518;
    D.28520 = (int) D.28519;
    max_offset = D.28520 + max_offset;
    ins = ins->next;
    <D.23179>:
    if (ins != 0B) goto <D.23178>; else goto <D.23180>;
    <D.23180>:
  }
  bb = bb->next_bb;
  <D.23182>:
  if (bb != 0B) goto <D.23181>; else goto <D.23183>;
  <D.23183>:
  if (max_offset > 65535) goto <D.28521>; else goto <D.28522>;
  <D.28521>:
  cfg->arch.long_branch = 1;
  <D.28522>:
  mips_adjust_stackframe (cfg);
  cfa_offset = 0;
  code.112 = (int) code;
  D.28524 = cfg->native_code;
  D.28525 = (int) D.28524;
  D.28526 = code.112 - D.28525;
  mono_emit_unwind_op (cfg, D.28526, 12, 29, cfa_offset);
  cfg->cfa_reg = 29;
  cfg->cfa_offset = cfa_offset;
  alloc_size = cfg->stack_offset;
  alloc_size.113 = (unsigned int) alloc_size;
  cfg->stack_usage = alloc_size.113;
  D.28528 = cfg->used_int_regs;
  iregs_to_save = D.28528 & 1090453504;
  if (alloc_size > 31744) goto <D.28529>; else goto <D.28530>;
  <D.28529>:
  alloc2_size = alloc_size + -1024;
  alloc_size = 1024;
  <D.28530>:
  if (alloc_size != 0) goto <D.28531>; else goto <D.28532>;
  <D.28531>:
  D.28533 = (unsigned short) alloc_size;
  D.28534 = -D.28533;
  D.28535 = (short int) D.28534;
  D.28536 = (int) D.28535;
  D.28537 = -alloc_size;
  D.28538 = D.28536 != D.28537;
  D.28539 = (long int) D.28538;
  D.28540 = __builtin_expect (D.28539, 0);
  if (D.28540 != 0) goto <D.28541>; else goto <D.28542>;
  <D.28541>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 4996, "mips_is_imm16 (-alloc_size)");
  <D.28542>:
  D.28537 = -alloc_size;
  D.28543 = D.28537 & 65535;
  D.28544 = D.28543 | 666697728;
  D.28545 = (unsigned int) D.28544;
  MEM[(guint32 *)code] = D.28545;
  code = code + 4;
  cfa_offset = alloc_size;
  code.112 = (int) code;
  D.28524 = cfg->native_code;
  D.28525 = (int) D.28524;
  D.28526 = code.112 - D.28525;
  mono_emit_unwind_op (cfg, D.28526, 14, 0, cfa_offset);
  cfg->cfa_offset = cfa_offset;
  <D.28532>:
  if (1 != 0) goto <D.28546>; else goto <D.28547>;
  <D.28546>:
  {
    int offset;

    alloc_size.114 = (unsigned int) alloc_size;
    D.28549 = alloc_size.114 + 4294967292;
    offset = (int) D.28549;
    D.28550 = (short int) offset;
    D.28551 = (int) D.28550;
    if (D.28551 == offset) goto <D.28552>; else goto <D.28553>;
    <D.28552>:
    D.28554 = offset & 65535;
    D.28555 = D.28554 | -1346437120;
    D.28556 = (unsigned int) D.28555;
    MEM[(guint32 *)code] = D.28556;
    code = code + 4;
    goto <D.28557>;
    <D.28553>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-mips.c", 5007);
    <D.28557>:
    code.112 = (int) code;
    D.28524 = cfg->native_code;
    D.28525 = (int) D.28524;
    D.28526 = code.112 - D.28525;
    D.28558 = offset - cfa_offset;
    mono_emit_unwind_op (cfg, D.28526, 128, 31, D.28558);
  }
  <D.28547>:
  D.28559 = cfg->arch.iregs_offset;
  alloc2_size.115 = (unsigned int) alloc2_size;
  D.28561 = D.28559 - alloc2_size.115;
  pos = (int) D.28561;
  if (iregs_to_save != 0) goto <D.28562>; else goto <D.28563>;
  <D.28562>:
  i = 31;
  goto <D.23186>;
  <D.23185>:
  D.28564 = 1 << i;
  D.28565 = (unsigned int) D.28564;
  D.28566 = D.28565 & iregs_to_save;
  if (D.28566 != 0) goto <D.28567>; else goto <D.28568>;
  <D.28567>:
  D.28569 = cfg->stack_usage;
  D.28570 = D.28569 + 4294967292;
  D.28571 = (int) D.28570;
  D.28572 = D.28571 <= pos;
  D.28573 = (long int) D.28572;
  D.28574 = __builtin_expect (D.28573, 0);
  if (D.28574 != 0) goto <D.28575>; else goto <D.28576>;
  <D.28575>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 5020, "pos < (int)(cfg->stack_usage - sizeof(gpointer))");
  <D.28576>:
  D.28577 = (short int) pos;
  D.28578 = (int) D.28577;
  D.28579 = D.28578 != pos;
  D.28580 = (long int) D.28579;
  D.28581 = __builtin_expect (D.28580, 0);
  if (D.28581 != 0) goto <D.28582>; else goto <D.28583>;
  <D.28582>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 5021, "mips_is_imm16(pos)");
  <D.28583>:
  D.28584 = i << 16;
  D.28585 = D.28584 | -1348468736;
  D.28586 = pos & 65535;
  D.28587 = D.28585 | D.28586;
  D.28588 = (unsigned int) D.28587;
  MEM[(guint32 *)code] = D.28588;
  code = code + 4;
  code.112 = (int) code;
  D.28524 = cfg->native_code;
  D.28525 = (int) D.28524;
  D.28526 = code.112 - D.28525;
  D.28589 = pos - cfa_offset;
  mono_emit_unwind_op (cfg, D.28526, 128, i, D.28589);
  pos = pos + 4;
  <D.28568>:
  i = i + -1;
  <D.23186>:
  if (i >= 0) goto <D.23185>; else goto <D.23187>;
  <D.23187>:
  <D.28563>:
  D.28590 = BIT_FIELD_REF <*method, 32, 160>;
  D.28591 = D.28590 & 256;
  if (D.28591 != 0) goto <D.28592>; else goto <D.28593>;
  <D.28592>:
  i = 31;
  goto <D.23190>;
  <D.23189>:
  {
    int offset;

    i.116 = (sizetype) i;
    D.28595 = i.116 * 4;
    D.28596 = 16B + D.28595;
    D.28597 = (unsigned int) D.28596;
    D.28598 = D.28597 + lmf_offset;
    offset = (int) D.28598;
    D.28599 = (short int) offset;
    D.28600 = (int) D.28599;
    D.28601 = D.28600 != offset;
    D.28602 = (long int) D.28601;
    D.28603 = __builtin_expect (D.28602, 0);
    if (D.28603 != 0) goto <D.28604>; else goto <D.28605>;
    <D.28604>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 5035, "mips_is_imm16(offset)");
    <D.28605>:
    D.28564 = 1 << i;
    D.28606 = (unsigned int) D.28564;
    D.28607 = D.28606 & 4294901760;
    if (D.28607 != 0) goto <D.28608>; else goto <D.28609>;
    <D.28608>:
    D.28584 = i << 16;
    D.28585 = D.28584 | -1348468736;
    D.28610 = offset & 65535;
    D.28611 = D.28585 | D.28610;
    D.28612 = (unsigned int) D.28611;
    MEM[(guint32 *)code] = D.28612;
    code = code + 4;
    <D.28609>:
  }
  i = i + -1;
  <D.23190>:
  if (i >= 0) goto <D.23189>; else goto <D.23191>;
  <D.23191>:
  <D.28593>:
  D.28613 = cfg->frame_reg;
  if (D.28613 != 29) goto <D.28614>; else goto <D.28615>;
  <D.28614>:
  D.28613 = cfg->frame_reg;
  D.28616 = D.28613 << 11;
  D.28617 = D.28616 | 60817441;
  MEM[(guint32 *)code] = D.28617;
  code = code + 4;
  code.112 = (int) code;
  D.28524 = cfg->native_code;
  D.28525 = (int) D.28524;
  D.28526 = code.112 - D.28525;
  D.28613 = cfg->frame_reg;
  D.28618 = (int) D.28613;
  mono_emit_unwind_op (cfg, D.28526, 12, D.28618, cfa_offset);
  D.28613 = cfg->frame_reg;
  D.28618 = (int) D.28613;
  cfg->cfa_reg = D.28618;
  cfg->cfa_offset = cfa_offset;
  D.28590 = BIT_FIELD_REF <*method, 32, 160>;
  D.28591 = D.28590 & 256;
  if (D.28591 != 0) goto <D.28619>; else goto <D.28620>;
  <D.28619>:
  {
    int offset;

    D.28613 = cfg->frame_reg;
    D.28621 = D.28613 * 4;
    D.28622 = 16B + D.28621;
    D.28623 = (unsigned int) D.28622;
    D.28624 = D.28623 + lmf_offset;
    offset = (int) D.28624;
    D.28625 = (short int) offset;
    D.28626 = (int) D.28625;
    D.28627 = D.28626 != offset;
    D.28628 = (long int) D.28627;
    D.28629 = __builtin_expect (D.28628, 0);
    if (D.28629 != 0) goto <D.28630>; else goto <D.28631>;
    <D.28630>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 5069, "mips_is_imm16(offset)");
    <D.28631>:
    D.28613 = cfg->frame_reg;
    D.28632 = D.28613 << 16;
    offset.117 = (unsigned int) offset;
    D.28634 = offset.117 & 65535;
    D.28635 = D.28632 | D.28634;
    D.28636 = D.28635 | 2946498560;
    MEM[(guint32 *)code] = D.28636;
    code = code + 4;
  }
  <D.28620>:
  <D.28615>:
  D.28637 = cfg->rgctx_var;
  if (D.28637 != 0B) goto <D.28638>; else goto <D.28639>;
  <D.28638>:
  {
    struct MonoInst * ins;

    ins = cfg->rgctx_var;
    D.28640 = ins->opcode;
    D.28641 = D.28640 != 367;
    D.28642 = (long int) D.28641;
    D.28643 = __builtin_expect (D.28642, 0);
    if (D.28643 != 0) goto <D.28644>; else goto <D.28645>;
    <D.28644>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 5078, "ins->opcode == OP_REGOFFSET");
    <D.28645>:
    D.28646 = ins->data.op[0].const_val;
    D.28647 = (short int) D.28646;
    D.28648 = (int) D.28647;
    D.28646 = ins->data.op[0].const_val;
    D.28649 = D.28648 != D.28646;
    D.28650 = (long int) D.28649;
    D.28651 = __builtin_expect (D.28650, 0);
    if (D.28651 != 0) goto <D.28652>; else goto <D.28653>;
    <D.28652>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 5080, "mips_is_imm16 (ins->inst_offset)");
    <D.28653>:
    D.28654 = ins->sreg1;
    D.28655 = D.28654 << 21;
    D.28656 = D.28655 | -1408761856;
    D.28646 = ins->data.op[0].const_val;
    D.28657 = D.28646 & 65535;
    D.28658 = D.28656 | D.28657;
    D.28659 = (unsigned int) D.28658;
    MEM[(guint32 *)code] = D.28659;
    code = code + 4;
  }
  <D.28639>:
  pos = 0;
  D.28660 = cfg->arch.cinfo;
  if (D.28660 == 0B) goto <D.28661>; else goto <D.28662>;
  <D.28661>:
  D.28663 = cfg->generic_sharing_context;
  D.28664 = cfg->mempool;
  D.28665 = get_call_info (D.28663, D.28664, sig);
  cfg->arch.cinfo = D.28665;
  <D.28662>:
  cinfo = cfg->arch.cinfo;
  D.28666 = sig->ret;
  D.28667 = mono_type_is_struct (D.28666);
  if (D.28667 != 0) goto <D.28668>; else goto <D.28669>;
  <D.28668>:
  {
    struct ArgInfo * ainfo;

    ainfo = &cinfo->ret;
    inst = cfg->vret_addr;
    D.28670 = inst->opcode;
    if (D.28670 == 366) goto <D.28671>; else goto <D.28672>;
    <D.28671>:
    D.28673 = ainfo->reg;
    D.28674 = (int) D.28673;
    D.28675 = D.28674 << 21;
    D.28676 = inst->dreg;
    D.28677 = D.28676 << 11;
    D.28678 = D.28675 | D.28677;
    D.28679 = D.28678 | 33;
    D.28680 = (unsigned int) D.28679;
    MEM[(guint32 *)code] = D.28680;
    code = code + 4;
    goto <D.28681>;
    <D.28672>:
    D.28682 = inst->data.op[0].const_val;
    D.28683 = (short int) D.28682;
    D.28684 = (int) D.28683;
    D.28682 = inst->data.op[0].const_val;
    if (D.28684 == D.28682) goto <D.28685>; else goto <D.28686>;
    <D.28685>:
    D.28687 = inst->sreg1;
    D.28688 = D.28687 << 21;
    D.28689 = D.28688 | -1409286144;
    D.28673 = ainfo->reg;
    D.28674 = (int) D.28673;
    D.28690 = D.28674 << 16;
    D.28691 = D.28689 | D.28690;
    D.28682 = inst->data.op[0].const_val;
    D.28692 = D.28682 & 65535;
    D.28693 = D.28691 | D.28692;
    D.28694 = (unsigned int) D.28693;
    MEM[(guint32 *)code] = D.28694;
    code = code + 4;
    goto <D.28695>;
    <D.28686>:
    D.28682 = inst->data.op[0].const_val;
    D.28683 = (short int) D.28682;
    D.28684 = (int) D.28683;
    D.28682 = inst->data.op[0].const_val;
    if (D.28684 != D.28682) goto <D.28696>; else goto <D.28697>;
    <D.28696>:
    D.28682 = inst->data.op[0].const_val;
    D.28698 = (unsigned int) D.28682;
    D.28699 = D.28698 & 32768;
    if (D.28699 != 0) goto <D.28700>; else goto <D.28701>;
    <D.28700>:
    D.28682 = inst->data.op[0].const_val;
    D.28698 = (unsigned int) D.28682;
    D.28702 = D.28698 >> 16;
    D.28703 = D.28702 + 1;
    D.28704 = D.28703 & 65535;
    D.28705 = D.28704 | 1006698496;
    MEM[(guint32 *)code] = D.28705;
    code = code + 4;
    goto <D.28706>;
    <D.28701>:
    D.28682 = inst->data.op[0].const_val;
    D.28698 = (unsigned int) D.28682;
    D.28702 = D.28698 >> 16;
    D.28707 = D.28702 | 1006698496;
    MEM[(guint32 *)code] = D.28707;
    code = code + 4;
    <D.28706>:
    D.28682 = inst->data.op[0].const_val;
    D.28698 = (unsigned int) D.28682;
    D.28708 = D.28698 & 65535;
    if (D.28708 != 0) goto <D.28709>; else goto <D.28710>;
    <D.28709>:
    D.28682 = inst->data.op[0].const_val;
    D.28698 = (unsigned int) D.28682;
    D.28708 = D.28698 & 65535;
    D.28711 = D.28708 | 606142464;
    MEM[(guint32 *)code] = D.28711;
    code = code + 4;
    <D.28710>:
    goto <D.28712>;
    <D.28697>:
    D.28682 = inst->data.op[0].const_val;
    D.28698 = (unsigned int) D.28682;
    D.28708 = D.28698 & 65535;
    D.28713 = D.28708 | 604045312;
    MEM[(guint32 *)code] = D.28713;
    code = code + 4;
    <D.28712>:
    D.28687 = inst->sreg1;
    D.28714 = D.28687 << 16;
    D.28715 = D.28714 | 2099233;
    D.28716 = (unsigned int) D.28715;
    MEM[(guint32 *)code] = D.28716;
    code = code + 4;
    D.28673 = ainfo->reg;
    D.28674 = (int) D.28673;
    D.28690 = D.28674 << 16;
    D.28717 = D.28690 | -1407188992;
    D.28718 = (unsigned int) D.28717;
    MEM[(guint32 *)code] = D.28718;
    code = code + 4;
    <D.28695>:
    <D.28681>:
  }
  <D.28669>:
  D.28719 = BIT_FIELD_REF <*sig, 32, 64>;
  D.28720 = D.28719 & 4128768;
  if (D.28720 == 327680) goto <D.28721>; else goto <D.28722>;
  <D.28721>:
  {
    struct ArgInfo * cookie;
    int offset;

    cookie = &cinfo->sig_cookie;
    D.28723 = cookie->offset;
    offset = D.28723 + alloc_size;
    D.28724 = cookie->storage;
    D.28725 = D.28724 != 1;
    D.28726 = (long int) D.28725;
    D.28727 = __builtin_expect (D.28726, 0);
    if (D.28727 != 0) goto <D.28728>; else goto <D.28729>;
    <D.28728>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 5110, "cookie->storage == ArgOnStack");
    <D.28729>:
    D.28730 = (short int) offset;
    D.28731 = (int) D.28730;
    D.28732 = D.28731 != offset;
    D.28733 = (long int) D.28732;
    D.28734 = __builtin_expect (D.28733, 0);
    if (D.28734 != 0) goto <D.28735>; else goto <D.28736>;
    <D.28735>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 5112, "mips_is_imm16(offset)");
    <D.28736>:
    D.28613 = cfg->frame_reg;
    D.28737 = D.28613 << 21;
    offset.118 = (unsigned int) offset;
    D.28739 = offset.118 & 65535;
    D.28740 = D.28737 | D.28739;
    D.28741 = D.28740 | 536936448;
    MEM[(guint32 *)code] = D.28741;
    code = code + 4;
    D.28613 = cfg->frame_reg;
    D.28737 = D.28613 << 21;
    D.28742 = cfg->sig_cookie;
    D.28743 = D.28742 - alloc2_size;
    D.28744 = (unsigned int) D.28743;
    D.28745 = D.28744 & 65535;
    D.28746 = D.28737 | D.28745;
    D.28747 = D.28746 | 2885746688;
    MEM[(guint32 *)code] = D.28747;
    code = code + 4;
  }
  <D.28722>:
  i = 0;
  goto <D.23220>;
  <D.23219>:
  {
    struct ArgInfo * ainfo;

    i.116 = (sizetype) i;
    ainfo = &cinfo->args[i.116];
    D.28748 = cfg->args;
    pos.119 = (unsigned int) pos;
    D.28750 = pos.119 * 4;
    D.28751 = D.28748 + D.28750;
    inst = *D.28751;
    D.28752 = cfg->verbose_level;
    if (D.28752 > 2) goto <D.28753>; else goto <D.28754>;
    <D.28753>:
    D.28755 = ainfo->storage;
    monoeg_g_print ("Saving argument %d (type: %d)\n", i, D.28755);
    <D.28754>:
    D.28670 = inst->opcode;
    if (D.28670 == 366) goto <D.28756>; else goto <D.28757>;
    <D.28756>:
    D.28755 = ainfo->storage;
    if (D.28755 == 0) goto <D.28758>; else goto <D.28759>;
    <D.28758>:
    D.28760 = ainfo->reg;
    D.28761 = (int) D.28760;
    D.28762 = D.28761 << 21;
    D.28676 = inst->dreg;
    D.28677 = D.28676 << 11;
    D.28763 = D.28762 | D.28677;
    D.28764 = D.28763 | 33;
    D.28765 = (unsigned int) D.28764;
    MEM[(guint32 *)code] = D.28765;
    code = code + 4;
    goto <D.28766>;
    <D.28759>:
    D.28755 = ainfo->storage;
    if (D.28755 == 2) goto <D.28767>; else goto <D.28768>;
    <D.28767>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-mips.c", 5129);
    <D.28768>:
    D.28755 = ainfo->storage;
    if (D.28755 == 1) goto <D.28769>; else goto <D.28770>;
    <D.28769>:
    {
      int offset;

      D.28569 = cfg->stack_usage;
      D.28771 = ainfo->offset;
      D.28772 = (unsigned int) D.28771;
      D.28773 = D.28569 + D.28772;
      offset = (int) D.28773;
      D.28774 = (short int) offset;
      D.28775 = (int) D.28774;
      D.28776 = D.28775 != offset;
      D.28777 = (long int) D.28776;
      D.28778 = __builtin_expect (D.28777, 0);
      if (D.28778 != 0) goto <D.28779>; else goto <D.28780>;
      <D.28779>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 5136, "mips_is_imm16(offset)");
      <D.28780>:
      D.28676 = inst->dreg;
      D.28781 = D.28676 << 16;
      D.28782 = D.28781 | -1885339648;
      D.28783 = offset & 65535;
      D.28784 = D.28782 | D.28783;
      D.28785 = (unsigned int) D.28784;
      MEM[(guint32 *)code] = D.28785;
      code = code + 4;
    }
    goto <D.28786>;
    <D.28770>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-mips.c", 5139);
    <D.28786>:
    <D.28766>:
    D.28752 = cfg->verbose_level;
    if (D.28752 > 2) goto <D.28787>; else goto <D.28788>;
    <D.28787>:
    D.28676 = inst->dreg;
    D.28789 = mono_arch_regname (D.28676);
    monoeg_g_print ("Argument %d assigned to register %s\n", pos, D.28789);
    <D.28788>:
    goto <D.28790>;
    <D.28757>:
    D.28755 = ainfo->storage;
    if (D.28755 == 0) goto <D.28791>; else goto <D.28792>;
    <D.28791>:
    {
      int basereg_offset;

      D.28752 = cfg->verbose_level;
      if (D.28752 > 2) goto <D.28793>; else goto <D.28794>;
      <D.28793>:
      D.28682 = inst->data.op[0].const_val;
      monoeg_g_print ("stack slot at %d of %d+%d\n", D.28682, alloc_size, alloc2_size);
      <D.28794>:
      D.28687 = inst->sreg1;
      D.28795 = (unsigned int) D.28687;
      D.28613 = cfg->frame_reg;
      D.28796 = D.28795 != D.28613;
      D.28797 = (long int) D.28796;
      D.28798 = __builtin_expect (D.28797, 0);
      if (D.28798 != 0) goto <D.28799>; else goto <D.28800>;
      <D.28799>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 5152, "inst->inst_basereg == cfg->frame_reg");
      <D.28800>:
      D.28682 = inst->data.op[0].const_val;
      basereg_offset = D.28682 - alloc2_size;
      D.28801 = (short int) basereg_offset;
      D.28802 = (int) D.28801;
      D.28803 = D.28802 != basereg_offset;
      D.28804 = (long int) D.28803;
      D.28805 = __builtin_expect (D.28804, 0);
      if (D.28805 != 0) goto <D.28806>; else goto <D.28807>;
      <D.28806>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 5154, "mips_is_imm16 (basereg_offset)");
      <D.28807>:
      D.28808 = ainfo->size;
      D.28809 = (int) D.28808;
      switch (D.28809) <default: <D.23206>, case 0: <D.23203>, case 1: <D.23200>, case 2: <D.23202>, case 4: <D.23204>, case 8: <D.23205>>
      <D.23200>:
      D.28687 = inst->sreg1;
      D.28688 = D.28687 << 21;
      D.28810 = D.28688 | -1610612736;
      D.28760 = ainfo->reg;
      D.28761 = (int) D.28760;
      D.28811 = D.28761 << 16;
      D.28812 = D.28810 | D.28811;
      D.28813 = basereg_offset & 65535;
      D.28814 = D.28812 | D.28813;
      D.28815 = (unsigned int) D.28814;
      MEM[(guint32 *)code] = D.28815;
      code = code + 4;
      goto <D.23201>;
      <D.23202>:
      D.28687 = inst->sreg1;
      D.28688 = D.28687 << 21;
      D.28816 = D.28688 | -1543503872;
      D.28760 = ainfo->reg;
      D.28761 = (int) D.28760;
      D.28811 = D.28761 << 16;
      D.28817 = D.28816 | D.28811;
      D.28813 = basereg_offset & 65535;
      D.28818 = D.28817 | D.28813;
      D.28819 = (unsigned int) D.28818;
      MEM[(guint32 *)code] = D.28819;
      code = code + 4;
      goto <D.23201>;
      <D.23203>:
      <D.23204>:
      D.28687 = inst->sreg1;
      D.28688 = D.28687 << 21;
      D.28689 = D.28688 | -1409286144;
      D.28760 = ainfo->reg;
      D.28761 = (int) D.28760;
      D.28811 = D.28761 << 16;
      D.28820 = D.28689 | D.28811;
      D.28813 = basereg_offset & 65535;
      D.28821 = D.28820 | D.28813;
      D.28822 = (unsigned int) D.28821;
      MEM[(guint32 *)code] = D.28822;
      code = code + 4;
      goto <D.23201>;
      <D.23205>:
      D.28687 = inst->sreg1;
      D.28688 = D.28687 << 21;
      D.28689 = D.28688 | -1409286144;
      D.28760 = ainfo->reg;
      D.28761 = (int) D.28760;
      D.28811 = D.28761 << 16;
      D.28820 = D.28689 | D.28811;
      ls_word_offset.120 = ls_word_offset;
      D.28824 = basereg_offset + ls_word_offset.120;
      D.28825 = D.28824 & 65535;
      D.28826 = D.28820 | D.28825;
      D.28827 = (unsigned int) D.28826;
      MEM[(guint32 *)code] = D.28827;
      code = code + 4;
      D.28687 = inst->sreg1;
      D.28688 = D.28687 << 21;
      D.28689 = D.28688 | -1409286144;
      D.28760 = ainfo->reg;
      D.28761 = (int) D.28760;
      D.28828 = D.28761 + 1;
      D.28829 = D.28828 << 16;
      D.28830 = D.28689 | D.28829;
      ms_word_offset.121 = ms_word_offset;
      D.28832 = basereg_offset + ms_word_offset.121;
      D.28833 = D.28832 & 65535;
      D.28834 = D.28830 | D.28833;
      D.28835 = (unsigned int) D.28834;
      MEM[(guint32 *)code] = D.28835;
      code = code + 4;
      goto <D.23201>;
      <D.23206>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-mips.c", 5175);
      <D.23201>:
    }
    goto <D.28836>;
    <D.28792>:
    D.28755 = ainfo->storage;
    if (D.28755 == 1) goto <D.28837>; else goto <D.28838>;
    <D.28837>:
    D.28682 = inst->data.op[0].const_val;
    D.28683 = (short int) D.28682;
    D.28684 = (int) D.28683;
    D.28682 = inst->data.op[0].const_val;
    D.28839 = D.28684 != D.28682;
    D.28840 = (long int) D.28839;
    D.28841 = __builtin_expect (D.28840, 0);
    if (D.28841 != 0) goto <D.28842>; else goto <D.28843>;
    <D.28842>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 5184, "mips_is_imm16 (inst->inst_offset)");
    <D.28843>:
    D.28808 = ainfo->size;
    D.28809 = (int) D.28808;
    switch (D.28809) <default: <D.23213>, case 0: <D.23210>, case 1: <D.23207>, case 2: <D.23209>, case 4: <D.23211>, case 8: <D.23212>>
    <D.23207>:
    D.28687 = inst->sreg1;
    D.28688 = D.28687 << 21;
    D.28844 = D.28688 | -1946091520;
    D.28682 = inst->data.op[0].const_val;
    D.28692 = D.28682 & 65535;
    D.28845 = D.28844 | D.28692;
    D.28846 = (unsigned int) D.28845;
    MEM[(guint32 *)code] = D.28846;
    code = code + 4;
    D.28687 = inst->sreg1;
    D.28688 = D.28687 << 21;
    D.28847 = D.28688 | -1610547200;
    D.28682 = inst->data.op[0].const_val;
    D.28692 = D.28682 & 65535;
    D.28848 = D.28847 | D.28692;
    D.28849 = (unsigned int) D.28848;
    MEM[(guint32 *)code] = D.28849;
    code = code + 4;
    goto <D.23208>;
    <D.23209>:
    D.28687 = inst->sreg1;
    D.28688 = D.28687 << 21;
    D.28844 = D.28688 | -1946091520;
    D.28682 = inst->data.op[0].const_val;
    D.28692 = D.28682 & 65535;
    D.28845 = D.28844 | D.28692;
    D.28846 = (unsigned int) D.28845;
    MEM[(guint32 *)code] = D.28846;
    code = code + 4;
    D.28687 = inst->sreg1;
    D.28688 = D.28687 << 21;
    D.28850 = D.28688 | -1543438336;
    D.28682 = inst->data.op[0].const_val;
    D.28692 = D.28682 & 65535;
    D.28851 = D.28850 | D.28692;
    D.28852 = (unsigned int) D.28851;
    MEM[(guint32 *)code] = D.28852;
    code = code + 4;
    goto <D.23208>;
    <D.23210>:
    <D.23211>:
    <D.23212>:
    goto <D.23208>;
    <D.23213>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-mips.c", 5199);
    <D.23208>:
    goto <D.28853>;
    <D.28838>:
    D.28755 = ainfo->storage;
    if (D.28755 == 2) goto <D.28854>; else goto <D.28855>;
    <D.28854>:
    D.28682 = inst->data.op[0].const_val;
    D.28683 = (short int) D.28682;
    D.28684 = (int) D.28683;
    D.28682 = inst->data.op[0].const_val;
    D.28839 = D.28684 != D.28682;
    D.28840 = (long int) D.28839;
    D.28841 = __builtin_expect (D.28840, 0);
    if (D.28841 != 0) goto <D.28856>; else goto <D.28857>;
    <D.28856>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 5202, "mips_is_imm16 (inst->inst_offset)");
    <D.28857>:
    D.28682 = inst->data.op[0].const_val;
    D.28858 = (unsigned short) D.28682;
    D.28859 = D.28858 + 4;
    D.28860 = (short int) D.28859;
    D.28861 = (int) D.28860;
    D.28682 = inst->data.op[0].const_val;
    D.28862 = D.28682 + 4;
    D.28863 = D.28861 != D.28862;
    D.28864 = (long int) D.28863;
    D.28865 = __builtin_expect (D.28864, 0);
    if (D.28865 != 0) goto <D.28866>; else goto <D.28867>;
    <D.28866>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 5203, "mips_is_imm16 (inst->inst_offset+4)");
    <D.28867>:
    D.28868 = BIT_FIELD_REF <*ainfo, 32, 96>;
    D.28869 = D.28868 & 15;
    if (D.28869 == 8) goto <D.28870>; else goto <D.28871>;
    <D.28870>:
    D.28687 = inst->sreg1;
    D.28688 = D.28687 << 21;
    D.28872 = D.28688 | -469762048;
    D.28760 = ainfo->reg;
    D.28761 = (int) D.28760;
    D.28811 = D.28761 << 16;
    D.28873 = D.28872 | D.28811;
    D.28682 = inst->data.op[0].const_val;
    ls_word_offset.120 = ls_word_offset;
    D.28874 = D.28682 + ls_word_offset.120;
    D.28875 = D.28874 & 65535;
    D.28876 = D.28873 | D.28875;
    D.28877 = (unsigned int) D.28876;
    MEM[(guint32 *)code] = D.28877;
    code = code + 4;
    D.28687 = inst->sreg1;
    D.28688 = D.28687 << 21;
    D.28872 = D.28688 | -469762048;
    D.28760 = ainfo->reg;
    D.28761 = (int) D.28760;
    D.28828 = D.28761 + 1;
    D.28829 = D.28828 << 16;
    D.28878 = D.28872 | D.28829;
    D.28682 = inst->data.op[0].const_val;
    ms_word_offset.121 = ms_word_offset;
    D.28879 = D.28682 + ms_word_offset.121;
    D.28880 = D.28879 & 65535;
    D.28881 = D.28878 | D.28880;
    D.28882 = (unsigned int) D.28881;
    MEM[(guint32 *)code] = D.28882;
    code = code + 4;
    goto <D.28883>;
    <D.28871>:
    D.28868 = BIT_FIELD_REF <*ainfo, 32, 96>;
    D.28869 = D.28868 & 15;
    if (D.28869 == 4) goto <D.28884>; else goto <D.28885>;
    <D.28884>:
    D.28687 = inst->sreg1;
    D.28688 = D.28687 << 21;
    D.28872 = D.28688 | -469762048;
    D.28760 = ainfo->reg;
    D.28761 = (int) D.28760;
    D.28811 = D.28761 << 16;
    D.28873 = D.28872 | D.28811;
    D.28682 = inst->data.op[0].const_val;
    D.28692 = D.28682 & 65535;
    D.28886 = D.28873 | D.28692;
    D.28887 = (unsigned int) D.28886;
    MEM[(guint32 *)code] = D.28887;
    code = code + 4;
    goto <D.28888>;
    <D.28885>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-mips.c", 5215);
    <D.28888>:
    <D.28883>:
    goto <D.28889>;
    <D.28855>:
    D.28755 = ainfo->storage;
    if (D.28755 == 3) goto <D.28890>; else goto <D.28891>;
    <D.28890>:
    {
      int i;
      int doffset;

      doffset = inst->data.op[0].const_val;
      D.28682 = inst->data.op[0].const_val;
      D.28683 = (short int) D.28682;
      D.28684 = (int) D.28683;
      D.28682 = inst->data.op[0].const_val;
      D.28839 = D.28684 != D.28682;
      D.28840 = (long int) D.28839;
      D.28841 = __builtin_expect (D.28840, 0);
      if (D.28841 != 0) goto <D.28892>; else goto <D.28893>;
      <D.28892>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 5220, "mips_is_imm16 (inst->inst_offset)");
      <D.28893>:
      D.28682 = inst->data.op[0].const_val;
      D.28858 = (unsigned short) D.28682;
      D.28808 = ainfo->size;
      D.28894 = (unsigned short) D.28808;
      D.28895 = D.28894 * 4;
      D.28896 = D.28858 + D.28895;
      D.28897 = (short int) D.28896;
      D.28898 = (int) D.28897;
      D.28682 = inst->data.op[0].const_val;
      D.28698 = (unsigned int) D.28682;
      D.28808 = ainfo->size;
      D.28899 = (unsigned int) D.28808;
      D.28900 = D.28899 * 4;
      D.28901 = D.28698 + D.28900;
      D.28902 = (int) D.28901;
      D.28903 = D.28898 != D.28902;
      D.28904 = (long int) D.28903;
      D.28905 = __builtin_expect (D.28904, 0);
      if (D.28905 != 0) goto <D.28906>; else goto <D.28907>;
      <D.28906>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 5221, "mips_is_imm16 (inst->inst_offset + ainfo->size * sizeof (gpointer))");
      <D.28907>:
      i = 0;
      goto <D.23217>;
      <D.23216>:
      D.28908 = (short int) doffset;
      D.28909 = (int) D.28908;
      D.28910 = D.28909 != doffset;
      D.28911 = (long int) D.28910;
      D.28912 = __builtin_expect (D.28911, 0);
      if (D.28912 != 0) goto <D.28913>; else goto <D.28914>;
      <D.28913>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 5224, "mips_is_imm16(doffset)");
      <D.28914>:
      D.28687 = inst->sreg1;
      D.28688 = D.28687 << 21;
      D.28689 = D.28688 | -1409286144;
      D.28760 = ainfo->reg;
      D.28761 = (int) D.28760;
      D.28915 = D.28761 + i;
      D.28916 = D.28915 << 16;
      D.28917 = D.28689 | D.28916;
      D.28918 = doffset & 65535;
      D.28919 = D.28917 | D.28918;
      D.28920 = (unsigned int) D.28919;
      MEM[(guint32 *)code] = D.28920;
      code = code + 4;
      doffset = doffset + 4;
      i = i + 1;
      <D.23217>:
      D.28808 = ainfo->size;
      D.28809 = (int) D.28808;
      if (D.28809 > i) goto <D.23216>; else goto <D.23218>;
      <D.23218>:
    }
    goto <D.28921>;
    <D.28891>:
    D.28755 = ainfo->storage;
    if (D.28755 == 4) goto <D.28922>; else goto <D.28923>;
    <D.28922>:
    D.28682 = inst->data.op[0].const_val;
    D.28683 = (short int) D.28682;
    D.28684 = (int) D.28683;
    D.28682 = inst->data.op[0].const_val;
    D.28839 = D.28684 != D.28682;
    D.28840 = (long int) D.28839;
    D.28841 = __builtin_expect (D.28840, 0);
    if (D.28841 != 0) goto <D.28924>; else goto <D.28925>;
    <D.28924>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 5229, "mips_is_imm16 (inst->inst_offset)");
    <D.28925>:
    D.28926 = ainfo->vtsize;
    D.28927 = (unsigned int) D.28926;
    D.28928 = D.28927 * 4;
    D.28929 = (int) D.28928;
    D.28687 = inst->sreg1;
    D.28682 = inst->data.op[0].const_val;
    D.28760 = ainfo->reg;
    D.28761 = (int) D.28760;
    code = emit_memcpy (code, D.28929, D.28687, D.28682, D.28761, 0);
    goto <D.28930>;
    <D.28923>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-mips.c", 5233);
    <D.28930>:
    <D.28921>:
    <D.28889>:
    <D.28853>:
    <D.28836>:
    <D.28790>:
    pos = pos + 1;
  }
  i = i + 1;
  <D.23220>:
  D.28501 = sig->param_count;
  D.28502 = (int) D.28501;
  D.28931 = sig->hasthis;
  D.28932 = (int) D.28931;
  D.28933 = D.28502 + D.28932;
  if (D.28933 > i) goto <D.23219>; else goto <D.23221>;
  <D.23221>:
  D.28590 = BIT_FIELD_REF <*method, 32, 160>;
  D.28591 = D.28590 & 256;
  if (D.28591 != 0) goto <D.28934>; else goto <D.28935>;
  <D.28934>:
  if (1 != 0) goto <D.28936>; else goto <D.28937>;
  <D.28936>:
  if (1 != 0) goto <D.28938>; else goto <D.28939>;
  <D.28938>:
  MEM[(guint32 *)code] = 1006740902;
  code = code + 4;
  goto <D.28940>;
  <D.28939>:
  MEM[(guint32 *)code] = 1006740901;
  code = code + 4;
  <D.28940>:
  if (1 != 0) goto <D.28941>; else goto <D.28942>;
  <D.28941>:
  MEM[(guint32 *)code] = 606184869;
  code = code + 4;
  <D.28942>:
  goto <D.28943>;
  <D.28937>:
  MEM[(guint32 *)code] = 604087717;
  code = code + 4;
  <D.28943>:
  D.28944 = lmf_offset + 272;
  D.28945 = D.28944 & 65535;
  D.28946 = D.28945 | 2946564096;
  MEM[(guint32 *)code] = D.28946;
  code = code + 4;
  lmf_pthread_key.122 = lmf_pthread_key;
  if (lmf_pthread_key.122 != -1) goto <D.28948>; else goto <D.28949>;
  <D.28948>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-mips.c", 5243);
  if (1 != 0) goto <D.28950>; else goto <D.28951>;
  <D.28950>:
  {
    int offset;

    offset = 8;
    D.28952 = (short int) offset;
    D.28953 = (int) D.28952;
    D.28954 = D.28953 != offset;
    D.28955 = (long int) D.28954;
    D.28956 = __builtin_expect (D.28955, 0);
    if (D.28956 != 0) goto <D.28957>; else goto <D.28958>;
    <D.28957>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 5249, "mips_is_imm16(offset)");
    <D.28958>:
    D.28959 = offset & 65535;
    D.28960 = D.28959 | 654573568;
    D.28961 = (unsigned int) D.28960;
    MEM[(guint32 *)code] = D.28961;
    code = code + 4;
  }
  <D.28951>:
  goto <D.28962>;
  <D.28949>:
  {
    guint32 _target;

    _target = (guint32) mono_get_lmf_addr;
    if (1 != 0) goto <D.28963>; else goto <D.28964>;
    <D.28963>:
    D.28965 = (short int) _target;
    D.28966 = (int) D.28965;
    _target.123 = (int) _target;
    if (D.28966 != _target.123) goto <D.28968>; else goto <D.28969>;
    <D.28968>:
    D.28970 = _target & 32768;
    if (D.28970 != 0) goto <D.28971>; else goto <D.28972>;
    <D.28971>:
    D.28973 = _target >> 16;
    D.28974 = D.28973 + 1;
    D.28975 = D.28974 & 65535;
    D.28976 = D.28975 | 1008271360;
    MEM[(guint32 *)code] = D.28976;
    code = code + 4;
    goto <D.28977>;
    <D.28972>:
    D.28973 = _target >> 16;
    D.28978 = D.28973 | 1008271360;
    MEM[(guint32 *)code] = D.28978;
    code = code + 4;
    <D.28977>:
    D.28979 = _target & 65535;
    if (D.28979 != 0) goto <D.28980>; else goto <D.28981>;
    <D.28980>:
    D.28979 = _target & 65535;
    D.28982 = D.28979 | 658046976;
    MEM[(guint32 *)code] = D.28982;
    code = code + 4;
    <D.28981>:
    goto <D.28983>;
    <D.28969>:
    D.28979 = _target & 65535;
    D.28984 = D.28979 | 605618176;
    MEM[(guint32 *)code] = D.28984;
    code = code + 4;
    <D.28983>:
    MEM[(guint32 *)code] = 52492297;
    code = code + 4;
    goto <D.28985>;
    <D.28964>:
    D.28986 = _target >> 2;
    D.28987 = D.28986 & 67108863;
    D.28988 = D.28987 | 201326592;
    MEM[(guint32 *)code] = D.28988;
    code = code + 4;
    <D.28985>:
    MEM[(guint32 *)code] = 2099237;
    code = code + 4;
  }
  <D.28962>:
  D.28989 = (unsigned short) lmf_offset;
  D.28990 = D.28989 + 4;
  D.28991 = (short int) D.28990;
  D.28992 = (int) D.28991;
  D.28993 = lmf_offset + 4;
  D.28994 = (int) D.28993;
  D.28995 = D.28992 != D.28994;
  D.28996 = (long int) D.28995;
  D.28997 = __builtin_expect (D.28996, 0);
  if (D.28997 != 0) goto <D.28998>; else goto <D.28999>;
  <D.28998>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 5258, "mips_is_imm16(lmf_offset + G_STRUCT_OFFSET(MonoLMF, lmf_addr))");
  <D.28999>:
  D.28993 = lmf_offset + 4;
  D.29000 = D.28993 & 65535;
  D.29001 = D.29000 | 2946629632;
  MEM[(guint32 *)code] = D.29001;
  code = code + 4;
  MEM[(guint32 *)code] = 2353070080;
  code = code + 4;
  D.29002 = (short int) lmf_offset;
  D.29003 = (int) D.29002;
  lmf_offset.124 = (int) lmf_offset;
  D.29005 = D.29003 != lmf_offset.124;
  D.29006 = (long int) D.29005;
  D.29007 = __builtin_expect (D.29006, 0);
  if (D.29007 != 0) goto <D.29008>; else goto <D.29009>;
  <D.29008>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 5262, "mips_is_imm16(lmf_offset + G_STRUCT_OFFSET(MonoLMF, previous_lmf))");
  <D.29009>:
  D.29010 = lmf_offset & 65535;
  D.29011 = D.29010 | 2946564096;
  MEM[(guint32 *)code] = D.29011;
  code = code + 4;
  D.29012 = (short int) lmf_offset;
  D.29013 = (int) D.29012;
  lmf_offset.124 = (int) lmf_offset;
  D.29014 = D.29013 != lmf_offset.124;
  D.29015 = (long int) D.29014;
  D.29016 = __builtin_expect (D.29015, 0);
  if (D.29016 != 0) goto <D.29017>; else goto <D.29018>;
  <D.29017>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 5265, "mips_is_imm16(lmf_offset)");
  <D.29018>:
  D.29010 = lmf_offset & 65535;
  D.29019 = D.29010 | 664862720;
  MEM[(guint32 *)code] = D.29019;
  code = code + 4;
  MEM[(guint32 *)code] = 2889940992;
  code = code + 4;
  method.125 = (int) method;
  D.29021 = (short int) method.125;
  D.29022 = (int) D.29021;
  method.125 = (int) method;
  if (D.29022 != method.125) goto <D.29023>; else goto <D.29024>;
  <D.29023>:
  method.126 = (unsigned int) method;
  D.29026 = method.126 & 32768;
  if (D.29026 != 0) goto <D.29027>; else goto <D.29028>;
  <D.29027>:
  method.126 = (unsigned int) method;
  D.29029 = method.126 >> 16;
  D.29030 = D.29029 + 1;
  D.29031 = D.29030 & 65535;
  D.29032 = D.29031 | 1006698496;
  MEM[(guint32 *)code] = D.29032;
  code = code + 4;
  goto <D.29033>;
  <D.29028>:
  method.126 = (unsigned int) method;
  D.29029 = method.126 >> 16;
  D.29034 = D.29029 | 1006698496;
  MEM[(guint32 *)code] = D.29034;
  code = code + 4;
  <D.29033>:
  method.126 = (unsigned int) method;
  D.29035 = method.126 & 65535;
  if (D.29035 != 0) goto <D.29036>; else goto <D.29037>;
  <D.29036>:
  method.126 = (unsigned int) method;
  D.29035 = method.126 & 65535;
  D.29038 = D.29035 | 606142464;
  MEM[(guint32 *)code] = D.29038;
  code = code + 4;
  <D.29037>:
  goto <D.29039>;
  <D.29024>:
  method.126 = (unsigned int) method;
  D.29035 = method.126 & 65535;
  D.29040 = D.29035 | 604045312;
  MEM[(guint32 *)code] = D.29040;
  code = code + 4;
  <D.29039>:
  D.28989 = (unsigned short) lmf_offset;
  D.29041 = D.28989 + 8;
  D.29042 = (short int) D.29041;
  D.29043 = (int) D.29042;
  D.29044 = lmf_offset + 8;
  D.29045 = (int) D.29044;
  D.29046 = D.29043 != D.29045;
  D.29047 = (long int) D.29046;
  D.29048 = __builtin_expect (D.29047, 0);
  if (D.29048 != 0) goto <D.29049>; else goto <D.29050>;
  <D.29049>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 5271, "mips_is_imm16(lmf_offset + G_STRUCT_OFFSET(MonoLMF, method))");
  <D.29050>:
  D.29044 = lmf_offset + 8;
  D.29051 = D.29044 & 65535;
  D.29052 = D.29051 | 2946564096;
  MEM[(guint32 *)code] = D.29052;
  code = code + 4;
  code.112 = (int) code;
  D.28524 = cfg->native_code;
  D.28525 = (int) D.28524;
  D.28526 = code.112 - D.28525;
  mono_add_patch_info (cfg, D.28526, 22, 0B);
  if (1 != 0) goto <D.29053>; else goto <D.29054>;
  <D.29053>:
  if (0 != 0) goto <D.29055>; else goto <D.29056>;
  <D.29055>:
  MEM[(guint32 *)code] = 1006698754;
  code = code + 4;
  goto <D.29057>;
  <D.29056>:
  MEM[(guint32 *)code] = 1006698753;
  code = code + 4;
  <D.29057>:
  if (1 != 0) goto <D.29058>; else goto <D.29059>;
  <D.29058>:
  MEM[(guint32 *)code] = 606142721;
  code = code + 4;
  <D.29059>:
  goto <D.29060>;
  <D.29054>:
  MEM[(guint32 *)code] = 604045569;
  code = code + 4;
  <D.29060>:
  D.29061 = lmf_offset + 12;
  D.29062 = D.29061 & 65535;
  D.29063 = D.29062 | 2946564096;
  MEM[(guint32 *)code] = D.29063;
  code = code + 4;
  <D.28935>:
  if (alloc2_size != 0) goto <D.29064>; else goto <D.29065>;
  <D.29064>:
  D.29066 = (unsigned short) alloc2_size;
  D.29067 = -D.29066;
  D.29068 = (short int) D.29067;
  D.29069 = (int) D.29068;
  D.29070 = -alloc2_size;
  if (D.29069 == D.29070) goto <D.29071>; else goto <D.29072>;
  <D.29071>:
  D.29070 = -alloc2_size;
  D.29073 = D.29070 << 16;
  D.29074 = D.29073 | 60876833;
  D.29075 = (unsigned int) D.29074;
  MEM[(guint32 *)code] = D.29075;
  code = code + 4;
  goto <D.29076>;
  <D.29072>:
  D.29066 = (unsigned short) alloc2_size;
  D.29067 = -D.29066;
  D.29068 = (short int) D.29067;
  D.29069 = (int) D.29068;
  D.29070 = -alloc2_size;
  if (D.29069 != D.29070) goto <D.29077>; else goto <D.29078>;
  <D.29077>:
  D.29070 = -alloc2_size;
  D.29079 = (unsigned int) D.29070;
  D.29080 = D.29079 & 32768;
  if (D.29080 != 0) goto <D.29081>; else goto <D.29082>;
  <D.29081>:
  D.29070 = -alloc2_size;
  D.29079 = (unsigned int) D.29070;
  D.29083 = D.29079 >> 16;
  D.29084 = D.29083 + 1;
  D.29085 = D.29084 & 65535;
  D.29086 = D.29085 | 1006698496;
  MEM[(guint32 *)code] = D.29086;
  code = code + 4;
  goto <D.29087>;
  <D.29082>:
  D.29070 = -alloc2_size;
  D.29079 = (unsigned int) D.29070;
  D.29083 = D.29079 >> 16;
  D.29088 = D.29083 | 1006698496;
  MEM[(guint32 *)code] = D.29088;
  code = code + 4;
  <D.29087>:
  D.29070 = -alloc2_size;
  D.29079 = (unsigned int) D.29070;
  D.29089 = D.29079 & 65535;
  if (D.29089 != 0) goto <D.29090>; else goto <D.29091>;
  <D.29090>:
  D.29070 = -alloc2_size;
  D.29079 = (unsigned int) D.29070;
  D.29089 = D.29079 & 65535;
  D.29092 = D.29089 | 606142464;
  MEM[(guint32 *)code] = D.29092;
  code = code + 4;
  <D.29091>:
  goto <D.29093>;
  <D.29078>:
  D.29070 = -alloc2_size;
  D.29079 = (unsigned int) D.29070;
  D.29089 = D.29079 & 65535;
  D.29094 = D.29089 | 604045312;
  MEM[(guint32 *)code] = D.29094;
  code = code + 4;
  <D.29093>:
  MEM[(guint32 *)code] = 60942369;
  code = code + 4;
  <D.29076>:
  alloc_size = alloc_size + alloc2_size;
  cfa_offset = cfa_offset + alloc2_size;
  D.28613 = cfg->frame_reg;
  if (D.28613 != 29) goto <D.29095>; else goto <D.29096>;
  <D.29095>:
  D.28613 = cfg->frame_reg;
  D.28616 = D.28613 << 11;
  D.28617 = D.28616 | 60817441;
  MEM[(guint32 *)code] = D.28617;
  code = code + 4;
  goto <D.29097>;
  <D.29096>:
  code.112 = (int) code;
  D.28524 = cfg->native_code;
  D.28525 = (int) D.28524;
  D.28526 = code.112 - D.28525;
  mono_emit_unwind_op (cfg, D.28526, 14, 0, cfa_offset);
  cfg->cfa_offset = cfa_offset;
  <D.29097>:
  <D.29065>:
  if (tracing != 0) goto <D.29098>; else goto <D.29099>;
  <D.29098>:
  D.29100 = cfg->stack_offset;
  D.29101 = (unsigned int) D.29100;
  cfg->arch.tracing_offset = D.29101;
  code = mono_arch_instrument_prolog (cfg, mono_trace_enter_method, code, 1);
  <D.29099>:
  code.112 = (int) code;
  D.28524 = cfg->native_code;
  D.28525 = (int) D.28524;
  D.28526 = code.112 - D.28525;
  D.29102 = (unsigned int) D.28526;
  cfg->code_len = D.29102;
  D.29103 = cfg->code_len;
  D.28506 = cfg->code_size;
  D.29104 = D.29103 >= D.28506;
  D.29105 = (long int) D.29104;
  D.29106 = __builtin_expect (D.29105, 0);
  if (D.29106 != 0) goto <D.29107>; else goto <D.29108>;
  <D.29107>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 5307, "cfg->code_len < cfg->code_size");
  <D.29108>:
  D.29109 = code;
  return D.29109;
}


emit_memcpy (guint8 * code, int size, int dreg, int doffset, int sreg, int soffset)
{
  int D.29113;
  int D.29114;
  int D.29115;
  int D.29116;
  unsigned int D.29117;
  int D.29118;
  int D.29119;
  int D.29120;
  int D.29121;
  unsigned int D.29122;
  guint8 * D.29123;

  goto <D.21777>;
  <D.21776>:
  D.29113 = sreg << 21;
  D.29114 = D.29113 | -1946091520;
  D.29115 = soffset & 65535;
  D.29116 = D.29114 | D.29115;
  D.29117 = (unsigned int) D.29116;
  MEM[(guint32 *)code] = D.29117;
  code = code + 4;
  D.29118 = dreg << 21;
  D.29119 = D.29118 | -1409220608;
  D.29120 = doffset & 65535;
  D.29121 = D.29119 | D.29120;
  D.29122 = (unsigned int) D.29121;
  MEM[(guint32 *)code] = D.29122;
  code = code + 4;
  size = size + -4;
  soffset = soffset + 4;
  doffset = doffset + 4;
  <D.21777>:
  if (size > 0) goto <D.21776>; else goto <D.21778>;
  <D.21778>:
  D.29123 = code;
  return D.29123;
}


mono_arch_instrument_epilog_full (struct MonoCompile * cfg, void * func, void * p, gboolean enable_arguments, gboolean preserve_argument_registers)
{
  struct MonoGenericSharingContext * D.29125;
  struct MonoMethodSignature * D.29126;
  struct MonoType * D.29127;
  struct MonoType * D.29128;
  unsigned char D.29129;
  int D.29130;
  _Bool D.29131;
  long int D.29132;
  long int D.29133;
  int code.127;
  unsigned char * D.29137;
  int D.29138;
  unsigned int offset.128;
  unsigned int D.29140;
  unsigned int D.29141;
  unsigned int D.29144;
  void * D.29145;
  sizetype offset.129;
  int D.23252;
  int iftmp.130;
  int D.23248;
  const char[6] * D.29152;
  unsigned char D.29153;
  int D.29154;
  unsigned char D.29155;
  int D.29156;
  const unsigned char * D.29161;
  unsigned char D.29162;
  int D.29163;
  const unsigned char * D.29164;
  unsigned char D.29165;
  int D.29166;
  const unsigned char * D.29171;
  unsigned char D.29172;
  int D.29173;
  const unsigned char * D.29174;
  unsigned char D.29175;
  int D.29176;
  const unsigned char * D.29181;
  unsigned char D.29182;
  int D.29183;
  const unsigned char * D.29184;
  unsigned char D.29185;
  int D.29186;
  const char * D.29188;
  struct MonoClass * D.29190;
  struct MonoClass * D.29191;
  short int D.29193;
  int D.29194;
  _Bool D.29195;
  long int D.29196;
  long int D.29197;
  int D.29200;
  int D.29201;
  unsigned int D.29202;
  unsigned short D.29203;
  unsigned short D.29204;
  short int D.29205;
  int D.29206;
  int D.29207;
  _Bool D.29208;
  long int D.29209;
  long int D.29210;
  int D.29213;
  int D.29214;
  unsigned int D.29215;
  int D.29220;
  unsigned int D.29221;
  int D.29222;
  unsigned int D.29223;
  int D.29224;
  unsigned int D.29225;
  int D.29228;
  unsigned int D.29229;
  struct MonoMethod * D.29230;
  int D.29231;
  short int D.29232;
  int D.29233;
  unsigned int D.29236;
  unsigned int D.29237;
  unsigned int D.29240;
  unsigned int D.29241;
  unsigned int D.29242;
  unsigned int D.29243;
  unsigned int D.29245;
  unsigned int D.29246;
  unsigned int D.29249;
  unsigned int D.29251;
  short int D.29254;
  int D.29255;
  int _target.131;
  unsigned int D.29259;
  unsigned int D.29262;
  unsigned int D.29263;
  unsigned int D.29264;
  unsigned int D.29265;
  unsigned int D.29267;
  unsigned int D.29268;
  unsigned int D.29271;
  unsigned int D.29273;
  unsigned int D.29275;
  unsigned int D.29276;
  unsigned int D.29277;
  int D.29278;
  unsigned int D.29279;
  int D.29282;
  unsigned int D.29283;
  int D.29284;
  unsigned int D.29285;
  void * D.29286;
  guchar * code;
  int save_mode;
  int offset;
  struct MonoMethod * method;
  int rtype;
  int save_offset;

  code = p;
  save_mode = 0;
  method = cfg->method;
  D.29125 = cfg->generic_sharing_context;
  D.29126 = mono_method_signature (method);
  D.29127 = D.29126->ret;
  D.29128 = mini_type_get_underlying_type (D.29125, D.29127);
  D.29129 = D.29128->type;
  rtype = (int) D.29129;
  save_offset = 16;
  D.29130 = save_offset & 15;
  D.29131 = D.29130 != 0;
  D.29132 = (long int) D.29131;
  D.29133 = __builtin_expect (D.29132, 0);
  if (D.29133 != 0) goto <D.29134>; else goto <D.29135>;
  <D.29134>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 5330, "(save_offset & (MIPS_STACK_ALIGNMENT-1)) == 0");
  <D.29135>:
  code.127 = (int) code;
  D.29137 = cfg->native_code;
  D.29138 = (int) D.29137;
  offset = code.127 - D.29138;
  offset.128 = (unsigned int) offset;
  D.29140 = cfg->code_size;
  D.29141 = D.29140 + 4294967232;
  if (offset.128 > D.29141) goto <D.29142>; else goto <D.29143>;
  <D.29142>:
  D.29140 = cfg->code_size;
  D.29144 = D.29140 * 2;
  cfg->code_size = D.29144;
  D.29137 = cfg->native_code;
  D.29140 = cfg->code_size;
  D.29145 = monoeg_realloc (D.29137, D.29140);
  cfg->native_code = D.29145;
  D.29137 = cfg->native_code;
  offset.129 = (sizetype) offset;
  code = D.29137 + offset.129;
  <D.29143>:
  MEM[(guint32 *)code] = 2099237;
  code = code + 4;
  MEM[(guint32 *)code] = 2099237;
  code = code + 4;
  switch (rtype) <default: <D.23259>, case 1: <D.23243>, case 10: <D.23257>, case 11: <D.23258>, case 12: <D.23254>, case 13: <D.23255>, case 17: <D.23256>>
  <D.23243>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 5;
    if (__s1_len <= 3) goto <D.29150>; else goto <D.29151>;
    <D.29150>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = method->name;
      D.29152 = ".ctor";
      D.29153 = MEM[(const unsigned char *)D.29152];
      D.29154 = (int) D.29153;
      D.29155 = *__s2;
      D.29156 = (int) D.29155;
      __result = D.29154 - D.29156;
      {
        if (__s1_len != 0) goto <D.29157>; else goto <D.29158>;
        <D.29157>:
        if (__result == 0) goto <D.29159>; else goto <D.29160>;
        <D.29159>:
        D.29161 = &MEM[(void *)".ctor" + 1B];
        D.29162 = *D.29161;
        D.29163 = (int) D.29162;
        D.29164 = __s2 + 1;
        D.29165 = *D.29164;
        D.29166 = (int) D.29165;
        __result = D.29163 - D.29166;
        if (__s1_len > 1) goto <D.29167>; else goto <D.29168>;
        <D.29167>:
        if (__result == 0) goto <D.29169>; else goto <D.29170>;
        <D.29169>:
        D.29171 = &MEM[(void *)".ctor" + 2B];
        D.29172 = *D.29171;
        D.29173 = (int) D.29172;
        D.29174 = __s2 + 2;
        D.29175 = *D.29174;
        D.29176 = (int) D.29175;
        __result = D.29173 - D.29176;
        if (__s1_len > 2) goto <D.29177>; else goto <D.29178>;
        <D.29177>:
        if (__result == 0) goto <D.29179>; else goto <D.29180>;
        <D.29179>:
        D.29181 = &MEM[(void *)".ctor" + 3B];
        D.29182 = *D.29181;
        D.29183 = (int) D.29182;
        D.29184 = __s2 + 3;
        D.29185 = *D.29184;
        D.29186 = (int) D.29185;
        __result = D.29183 - D.29186;
        <D.29180>:
        <D.29178>:
        <D.29170>:
        <D.29168>:
        <D.29160>:
        <D.29158>:
      }
      D.23248 = __result;
    }
    iftmp.130 = D.23248;
    goto <D.29187>;
    <D.29151>:
    D.29188 = method->name;
    iftmp.130 = __builtin_strcmp (".ctor", D.29188);
    <D.29187>:
    D.23252 = iftmp.130;
  }
  if (D.23252 != 0) goto <D.29189>; else goto <D.29147>;
  <D.29189>:
  D.29190 = method->klass;
  D.29191 = mono_defaults.string_class;
  if (D.29190 == D.29191) goto <D.29192>; else goto <D.29147>;
  <D.29192>:
  save_mode = 2;
  goto <D.29148>;
  <D.29147>:
  save_mode = 0;
  <D.29148>:
  goto <D.23253>;
  <D.23254>:
  <D.23255>:
  save_mode = 4;
  goto <D.23253>;
  <D.23256>:
  save_mode = 1;
  goto <D.23253>;
  <D.23257>:
  <D.23258>:
  save_mode = 3;
  goto <D.23253>;
  <D.23259>:
  save_mode = 2;
  goto <D.23253>;
  <D.23253>:
  MEM[(guint32 *)code] = 666763232;
  code = code + 4;
  D.29193 = (short int) save_offset;
  D.29194 = (int) D.29193;
  D.29195 = D.29194 != save_offset;
  D.29196 = (long int) D.29195;
  D.29197 = __builtin_expect (D.29196, 0);
  if (D.29197 != 0) goto <D.29198>; else goto <D.29199>;
  <D.29198>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 5370, "mips_is_imm16(save_offset)");
  <D.29199>:
  switch (save_mode) <default: <D.23266>, case 0: <D.23265>, case 1: <D.23264>, case 2: <D.23262>, case 3: <D.23260>, case 4: <D.23263>>
  <D.23260>:
  D.29200 = save_offset & 65535;
  D.29201 = D.29200 | -1348337664;
  D.29202 = (unsigned int) D.29201;
  MEM[(guint32 *)code] = D.29202;
  code = code + 4;
  D.29203 = (unsigned short) save_offset;
  D.29204 = D.29203 + 4;
  D.29205 = (short int) D.29204;
  D.29206 = (int) D.29205;
  D.29207 = save_offset + 4;
  D.29208 = D.29206 != D.29207;
  D.29209 = (long int) D.29208;
  D.29210 = __builtin_expect (D.29209, 0);
  if (D.29210 != 0) goto <D.29211>; else goto <D.29212>;
  <D.29211>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 5374, "mips_is_imm16(save_offset + SIZEOF_REGISTER)");
  <D.29212>:
  D.29207 = save_offset + 4;
  D.29213 = D.29207 & 65535;
  D.29214 = D.29213 | -1348272128;
  D.29215 = (unsigned int) D.29214;
  MEM[(guint32 *)code] = D.29215;
  code = code + 4;
  if (enable_arguments != 0) goto <D.29216>; else goto <D.29217>;
  <D.29216>:
  MEM[(guint32 *)code] = 4204577;
  code = code + 4;
  MEM[(guint32 *)code] = 6303777;
  code = code + 4;
  <D.29217>:
  goto <D.23261>;
  <D.23262>:
  D.29200 = save_offset & 65535;
  D.29201 = D.29200 | -1348337664;
  D.29202 = (unsigned int) D.29201;
  MEM[(guint32 *)code] = D.29202;
  code = code + 4;
  if (enable_arguments != 0) goto <D.29218>; else goto <D.29219>;
  <D.29218>:
  MEM[(guint32 *)code] = 4204577;
  code = code + 4;
  <D.29219>:
  goto <D.23261>;
  <D.23263>:
  D.29200 = save_offset & 65535;
  D.29220 = D.29200 | -140509184;
  D.29221 = (unsigned int) D.29220;
  MEM[(guint32 *)code] = D.29221;
  code = code + 4;
  D.29200 = save_offset & 65535;
  D.29222 = D.29200 | -676593664;
  D.29223 = (unsigned int) D.29222;
  MEM[(guint32 *)code] = D.29223;
  code = code + 4;
  D.29200 = save_offset & 65535;
  D.29224 = D.29200 | -1885077504;
  D.29225 = (unsigned int) D.29224;
  MEM[(guint32 *)code] = D.29225;
  code = code + 4;
  D.29203 = (unsigned short) save_offset;
  D.29204 = D.29203 + 4;
  D.29205 = (short int) D.29204;
  D.29206 = (int) D.29205;
  D.29207 = save_offset + 4;
  D.29208 = D.29206 != D.29207;
  D.29209 = (long int) D.29208;
  D.29210 = __builtin_expect (D.29209, 0);
  if (D.29210 != 0) goto <D.29226>; else goto <D.29227>;
  <D.29226>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 5391, "mips_is_imm16(save_offset + SIZEOF_REGISTER)");
  <D.29227>:
  D.29207 = save_offset + 4;
  D.29213 = D.29207 & 65535;
  D.29228 = D.29213 | -1885011968;
  D.29229 = (unsigned int) D.29228;
  MEM[(guint32 *)code] = D.29229;
  code = code + 4;
  goto <D.23261>;
  <D.23264>:
  <D.23265>:
  <D.23266>:
  goto <D.23261>;
  <D.23261>:
  D.29230 = cfg->method;
  D.29231 = (int) D.29230;
  D.29232 = (short int) D.29231;
  D.29233 = (int) D.29232;
  D.29230 = cfg->method;
  D.29231 = (int) D.29230;
  if (D.29233 != D.29231) goto <D.29234>; else goto <D.29235>;
  <D.29234>:
  D.29230 = cfg->method;
  D.29236 = (unsigned int) D.29230;
  D.29237 = D.29236 & 32768;
  if (D.29237 != 0) goto <D.29238>; else goto <D.29239>;
  <D.29238>:
  D.29230 = cfg->method;
  D.29236 = (unsigned int) D.29230;
  D.29240 = D.29236 >> 16;
  D.29241 = D.29240 + 1;
  D.29242 = D.29241 & 65535;
  D.29243 = D.29242 | 1006895104;
  MEM[(guint32 *)code] = D.29243;
  code = code + 4;
  goto <D.29244>;
  <D.29239>:
  D.29230 = cfg->method;
  D.29236 = (unsigned int) D.29230;
  D.29240 = D.29236 >> 16;
  D.29245 = D.29240 | 1006895104;
  MEM[(guint32 *)code] = D.29245;
  code = code + 4;
  <D.29244>:
  D.29230 = cfg->method;
  D.29236 = (unsigned int) D.29230;
  D.29246 = D.29236 & 65535;
  if (D.29246 != 0) goto <D.29247>; else goto <D.29248>;
  <D.29247>:
  D.29230 = cfg->method;
  D.29236 = (unsigned int) D.29230;
  D.29246 = D.29236 & 65535;
  D.29249 = D.29246 | 612630528;
  MEM[(guint32 *)code] = D.29249;
  code = code + 4;
  <D.29248>:
  goto <D.29250>;
  <D.29235>:
  D.29230 = cfg->method;
  D.29236 = (unsigned int) D.29230;
  D.29246 = D.29236 & 65535;
  D.29251 = D.29246 | 604241920;
  MEM[(guint32 *)code] = D.29251;
  code = code + 4;
  <D.29250>:
  {
    guint32 _target;

    _target = (guint32) func;
    if (1 != 0) goto <D.29252>; else goto <D.29253>;
    <D.29252>:
    D.29254 = (short int) _target;
    D.29255 = (int) D.29254;
    _target.131 = (int) _target;
    if (D.29255 != _target.131) goto <D.29257>; else goto <D.29258>;
    <D.29257>:
    D.29259 = _target & 32768;
    if (D.29259 != 0) goto <D.29260>; else goto <D.29261>;
    <D.29260>:
    D.29262 = _target >> 16;
    D.29263 = D.29262 + 1;
    D.29264 = D.29263 & 65535;
    D.29265 = D.29264 | 1008271360;
    MEM[(guint32 *)code] = D.29265;
    code = code + 4;
    goto <D.29266>;
    <D.29261>:
    D.29262 = _target >> 16;
    D.29267 = D.29262 | 1008271360;
    MEM[(guint32 *)code] = D.29267;
    code = code + 4;
    <D.29266>:
    D.29268 = _target & 65535;
    if (D.29268 != 0) goto <D.29269>; else goto <D.29270>;
    <D.29269>:
    D.29268 = _target & 65535;
    D.29271 = D.29268 | 658046976;
    MEM[(guint32 *)code] = D.29271;
    code = code + 4;
    <D.29270>:
    goto <D.29272>;
    <D.29258>:
    D.29268 = _target & 65535;
    D.29273 = D.29268 | 605618176;
    MEM[(guint32 *)code] = D.29273;
    code = code + 4;
    <D.29272>:
    MEM[(guint32 *)code] = 52492297;
    code = code + 4;
    goto <D.29274>;
    <D.29253>:
    D.29275 = _target >> 2;
    D.29276 = D.29275 & 67108863;
    D.29277 = D.29276 | 201326592;
    MEM[(guint32 *)code] = D.29277;
    code = code + 4;
    <D.29274>:
    MEM[(guint32 *)code] = 2099237;
    code = code + 4;
  }
  switch (save_mode) <default: <D.23274>, case 0: <D.23273>, case 1: <D.23272>, case 2: <D.23270>, case 3: <D.23268>, case 4: <D.23271>>
  <D.23268>:
  D.29200 = save_offset & 65535;
  D.29278 = D.29200 | -1885208576;
  D.29279 = (unsigned int) D.29278;
  MEM[(guint32 *)code] = D.29279;
  code = code + 4;
  D.29203 = (unsigned short) save_offset;
  D.29204 = D.29203 + 4;
  D.29205 = (short int) D.29204;
  D.29206 = (int) D.29205;
  D.29207 = save_offset + 4;
  D.29208 = D.29206 != D.29207;
  D.29209 = (long int) D.29208;
  D.29210 = __builtin_expect (D.29209, 0);
  if (D.29210 != 0) goto <D.29280>; else goto <D.29281>;
  <D.29280>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 5405, "mips_is_imm16(save_offset + SIZEOF_REGISTER)");
  <D.29281>:
  D.29207 = save_offset + 4;
  D.29213 = D.29207 & 65535;
  D.29282 = D.29213 | -1885143040;
  D.29283 = (unsigned int) D.29282;
  MEM[(guint32 *)code] = D.29283;
  code = code + 4;
  goto <D.23269>;
  <D.23270>:
  D.29200 = save_offset & 65535;
  D.29278 = D.29200 | -1885208576;
  D.29279 = (unsigned int) D.29278;
  MEM[(guint32 *)code] = D.29279;
  code = code + 4;
  goto <D.23269>;
  <D.23271>:
  D.29200 = save_offset & 65535;
  D.29284 = D.29200 | -677380096;
  D.29285 = (unsigned int) D.29284;
  MEM[(guint32 *)code] = D.29285;
  code = code + 4;
  goto <D.23269>;
  <D.23272>:
  <D.23273>:
  <D.23274>:
  goto <D.23269>;
  <D.23269>:
  MEM[(guint32 *)code] = 666697760;
  code = code + 4;
  MEM[(guint32 *)code] = 2099237;
  code = code + 4;
  MEM[(guint32 *)code] = 2099237;
  code = code + 4;
  D.29286 = code;
  return D.29286;
}


mono_arch_emit_epilog_sub (struct MonoCompile * cfg, guint8 * code)
{
  struct MonoMethod * D.29290;
  unsigned int D.29291;
  unsigned int D.29292;
  struct MonoTraceSpec * mono_jit_trace_calls.132;
  unsigned int D.29298;
  unsigned int D.29299;
  int code.133;
  unsigned char * D.29305;
  int D.29306;
  unsigned int D.29307;
  unsigned int D.29308;
  void * D.29309;
  int D.29310;
  int D.29311;
  unsigned int D.29312;
  unsigned int max_epilog_size.134;
  unsigned int D.29314;
  unsigned int D.29315;
  sizetype pos.135;
  int D.29322;
  unsigned int D.29325;
  unsigned int D.29328;
  unsigned int D.29329;
  unsigned int D.29330;
  unsigned int D.29333;
  short int D.29334;
  int D.29335;
  unsigned int alloc2_size.136;
  unsigned int D.29339;
  unsigned int D.29342;
  unsigned int D.29343;
  unsigned int D.29344;
  unsigned int D.29345;
  unsigned int D.29347;
  unsigned int D.29348;
  unsigned int D.29351;
  unsigned int D.29353;
  unsigned int D.29354;
  unsigned int alloc2_size.137;
  unsigned int D.29356;
  unsigned int D.29357;
  int D.29360;
  unsigned int D.29361;
  unsigned int D.29362;
  short int D.29365;
  int D.29366;
  _Bool D.29367;
  long int D.29368;
  long int D.29369;
  int D.29372;
  int D.29373;
  int D.29374;
  int D.29375;
  unsigned int D.29376;
  unsigned int D.29377;
  unsigned int D.29378;
  unsigned int D.29381;
  short int D.29382;
  int D.29383;
  _Bool D.29384;
  long int D.29385;
  long int D.29386;
  unsigned int lmf_offset.138;
  unsigned int D.29390;
  unsigned int D.29391;
  unsigned short D.29392;
  unsigned short D.29393;
  short int D.29394;
  int D.29395;
  unsigned int D.29396;
  int D.29397;
  _Bool D.29398;
  long int D.29399;
  long int D.29400;
  unsigned int D.29403;
  unsigned int D.29404;
  unsigned short D.29407;
  unsigned short D.29408;
  unsigned short D.29409;
  unsigned short D.29410;
  short int D.29411;
  int D.29412;
  unsigned int alloc2_size.139;
  unsigned int D.29414;
  unsigned int D.29415;
  int D.29416;
  _Bool D.29417;
  long int D.29418;
  long int D.29419;
  unsigned int D.29422;
  unsigned int D.29423;
  short int D.29424;
  int D.29425;
  int D.29426;
  _Bool D.29427;
  long int D.29428;
  long int D.29429;
  unsigned int D.29432;
  unsigned int D.29433;
  int D.29434;
  unsigned int D.29435;
  _Bool D.29436;
  long int D.29437;
  long int D.29438;
  guint8 * D.29441;
  struct MonoMethod * method;
  int pos;
  int i;
  int max_epilog_size;
  int alloc2_size;
  guint32 iregs_to_restore;

  method = cfg->method;
  pos = 0;
  max_epilog_size = 96;
  alloc2_size = 0;
  D.29290 = cfg->method;
  D.29291 = BIT_FIELD_REF <*D.29290, 32, 160>;
  D.29292 = D.29291 & 256;
  if (D.29292 != 0) goto <D.29293>; else goto <D.29294>;
  <D.29293>:
  max_epilog_size = max_epilog_size + 128;
  <D.29294>:
  mono_jit_trace_calls.132 = mono_jit_trace_calls;
  if (mono_jit_trace_calls.132 != 0B) goto <D.29296>; else goto <D.29297>;
  <D.29296>:
  max_epilog_size = max_epilog_size + 50;
  <D.29297>:
  D.29298 = cfg->prof_options;
  D.29299 = D.29298 & 4096;
  if (D.29299 != 0) goto <D.29300>; else goto <D.29301>;
  <D.29300>:
  max_epilog_size = max_epilog_size + 50;
  <D.29301>:
  if (code != 0B) goto <D.29302>; else goto <D.29303>;
  <D.29302>:
  code.133 = (int) code;
  D.29305 = cfg->native_code;
  D.29306 = (int) D.29305;
  pos = code.133 - D.29306;
  <D.29303>:
  goto <D.23286>;
  <D.23285>:
  D.29307 = cfg->code_size;
  D.29308 = D.29307 * 2;
  cfg->code_size = D.29308;
  D.29305 = cfg->native_code;
  D.29307 = cfg->code_size;
  D.29309 = monoeg_realloc (D.29305, D.29307);
  cfg->native_code = D.29309;
  D.29310 = cfg->stat_code_reallocs;
  D.29311 = D.29310 + 1;
  cfg->stat_code_reallocs = D.29311;
  <D.23286>:
  D.29312 = cfg->code_len;
  max_epilog_size.134 = (unsigned int) max_epilog_size;
  D.29314 = D.29312 + max_epilog_size.134;
  D.29307 = cfg->code_size;
  D.29315 = D.29307 + 4294967280;
  if (D.29314 > D.29315) goto <D.23285>; else goto <D.23287>;
  <D.23287>:
  if (code != 0B) goto <D.29316>; else goto <D.29317>;
  <D.29316>:
  D.29305 = cfg->native_code;
  pos.135 = (sizetype) pos;
  code = D.29305 + pos.135;
  goto <D.29319>;
  <D.29317>:
  D.29305 = cfg->native_code;
  D.29312 = cfg->code_len;
  code = D.29305 + D.29312;
  <D.29319>:
  mono_jit_trace_calls.132 = mono_jit_trace_calls;
  if (mono_jit_trace_calls.132 != 0B) goto <D.29320>; else goto <D.29321>;
  <D.29320>:
  D.29322 = mono_trace_eval (method);
  if (D.29322 != 0) goto <D.29323>; else goto <D.29324>;
  <D.29323>:
  code = mono_arch_instrument_epilog (cfg, mono_trace_leave_method, code, 1);
  <D.29324>:
  <D.29321>:
  D.29325 = cfg->frame_reg;
  if (D.29325 != 29) goto <D.29326>; else goto <D.29327>;
  <D.29326>:
  D.29325 = cfg->frame_reg;
  D.29328 = D.29325 << 21;
  D.29329 = D.29328 | 59425;
  MEM[(guint32 *)code] = D.29329;
  code = code + 4;
  <D.29327>:
  D.29330 = cfg->stack_usage;
  if (D.29330 > 31744) goto <D.29331>; else goto <D.29332>;
  <D.29331>:
  D.29330 = cfg->stack_usage;
  D.29333 = D.29330 + 4294966272;
  alloc2_size = (int) D.29333;
  D.29334 = (short int) alloc2_size;
  D.29335 = (int) D.29334;
  if (D.29335 != alloc2_size) goto <D.29336>; else goto <D.29337>;
  <D.29336>:
  alloc2_size.136 = (unsigned int) alloc2_size;
  D.29339 = alloc2_size.136 & 32768;
  if (D.29339 != 0) goto <D.29340>; else goto <D.29341>;
  <D.29340>:
  alloc2_size.136 = (unsigned int) alloc2_size;
  D.29342 = alloc2_size.136 >> 16;
  D.29343 = D.29342 + 1;
  D.29344 = D.29343 & 65535;
  D.29345 = D.29344 | 1006698496;
  MEM[(guint32 *)code] = D.29345;
  code = code + 4;
  goto <D.29346>;
  <D.29341>:
  alloc2_size.136 = (unsigned int) alloc2_size;
  D.29342 = alloc2_size.136 >> 16;
  D.29347 = D.29342 | 1006698496;
  MEM[(guint32 *)code] = D.29347;
  code = code + 4;
  <D.29346>:
  alloc2_size.136 = (unsigned int) alloc2_size;
  D.29348 = alloc2_size.136 & 65535;
  if (D.29348 != 0) goto <D.29349>; else goto <D.29350>;
  <D.29349>:
  alloc2_size.136 = (unsigned int) alloc2_size;
  D.29348 = alloc2_size.136 & 65535;
  D.29351 = D.29348 | 606142464;
  MEM[(guint32 *)code] = D.29351;
  code = code + 4;
  <D.29350>:
  goto <D.29352>;
  <D.29337>:
  alloc2_size.136 = (unsigned int) alloc2_size;
  D.29348 = alloc2_size.136 & 65535;
  D.29353 = D.29348 | 604045312;
  MEM[(guint32 *)code] = D.29353;
  code = code + 4;
  <D.29352>:
  MEM[(guint32 *)code] = 60942369;
  code = code + 4;
  <D.29332>:
  D.29354 = cfg->arch.iregs_offset;
  alloc2_size.137 = (unsigned int) alloc2_size;
  D.29356 = D.29354 - alloc2_size.137;
  pos = (int) D.29356;
  D.29357 = cfg->used_int_regs;
  iregs_to_restore = D.29357 & 1090453504;
  if (iregs_to_restore != 0) goto <D.29358>; else goto <D.29359>;
  <D.29358>:
  i = 31;
  goto <D.23289>;
  <D.23288>:
  D.29360 = 1 << i;
  D.29361 = (unsigned int) D.29360;
  D.29362 = D.29361 & iregs_to_restore;
  if (D.29362 != 0) goto <D.29363>; else goto <D.29364>;
  <D.29363>:
  D.29365 = (short int) pos;
  D.29366 = (int) D.29365;
  D.29367 = D.29366 != pos;
  D.29368 = (long int) D.29367;
  D.29369 = __builtin_expect (D.29368, 0);
  if (D.29369 != 0) goto <D.29370>; else goto <D.29371>;
  <D.29370>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 5480, "mips_is_imm16(pos)");
  <D.29371>:
  D.29372 = i << 16;
  D.29373 = D.29372 | -1885339648;
  D.29374 = pos & 65535;
  D.29375 = D.29373 | D.29374;
  D.29376 = (unsigned int) D.29375;
  MEM[(guint32 *)code] = D.29376;
  code = code + 4;
  pos = pos + 4;
  <D.29364>:
  i = i + -1;
  <D.23289>:
  if (i >= 0) goto <D.23288>; else goto <D.23290>;
  <D.23290>:
  <D.29359>:
  D.29377 = BIT_FIELD_REF <*method, 32, 160>;
  D.29378 = D.29377 & 256;
  if (D.29378 != 0) goto <D.29379>; else goto <D.29380>;
  <D.29379>:
  {
    int lmf_offset;

    D.29381 = cfg->arch.lmf_offset;
    lmf_offset = (int) D.29381;
    D.29382 = (short int) lmf_offset;
    D.29383 = (int) D.29382;
    D.29384 = D.29383 != lmf_offset;
    D.29385 = (long int) D.29384;
    D.29386 = __builtin_expect (D.29385, 0);
    if (D.29386 != 0) goto <D.29387>; else goto <D.29388>;
    <D.29387>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 5511, "mips_is_imm16(lmf_offset + G_STRUCT_OFFSET(MonoLMF, previous_lmf))");
    <D.29388>:
    lmf_offset.138 = (unsigned int) lmf_offset;
    D.29390 = lmf_offset.138 & 65535;
    D.29391 = D.29390 | 2411200512;
    MEM[(guint32 *)code] = D.29391;
    code = code + 4;
    D.29392 = (unsigned short) lmf_offset;
    D.29393 = D.29392 + 4;
    D.29394 = (short int) D.29393;
    D.29395 = (int) D.29394;
    lmf_offset.138 = (unsigned int) lmf_offset;
    D.29396 = lmf_offset.138 + 4;
    D.29397 = (int) D.29396;
    D.29398 = D.29395 != D.29397;
    D.29399 = (long int) D.29398;
    D.29400 = __builtin_expect (D.29399, 0);
    if (D.29400 != 0) goto <D.29401>; else goto <D.29402>;
    <D.29401>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 5514, "mips_is_imm16(lmf_offset + G_STRUCT_OFFSET(MonoLMF, lmf_addr))");
    <D.29402>:
    lmf_offset.138 = (unsigned int) lmf_offset;
    D.29396 = lmf_offset.138 + 4;
    D.29403 = D.29396 & 65535;
    D.29404 = D.29403 | 2410217472;
    MEM[(guint32 *)code] = D.29404;
    code = code + 4;
    MEM[(guint32 *)code] = 2906128384;
    code = code + 4;
  }
  <D.29380>:
  if (1 != 0) goto <D.29405>; else goto <D.29406>;
  <D.29405>:
  D.29330 = cfg->stack_usage;
  D.29407 = (unsigned short) D.29330;
  D.29408 = (unsigned short) alloc2_size;
  D.29409 = D.29407 - D.29408;
  D.29410 = D.29409 + 65532;
  D.29411 = (short int) D.29410;
  D.29412 = (int) D.29411;
  D.29330 = cfg->stack_usage;
  alloc2_size.139 = (unsigned int) alloc2_size;
  D.29414 = D.29330 - alloc2_size.139;
  D.29415 = D.29414 + 4294967292;
  D.29416 = (int) D.29415;
  D.29417 = D.29412 != D.29416;
  D.29418 = (long int) D.29417;
  D.29419 = __builtin_expect (D.29418, 0);
  if (D.29419 != 0) goto <D.29420>; else goto <D.29421>;
  <D.29420>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 5526, "mips_is_imm16(cfg->stack_usage - alloc2_size + MIPS_RET_ADDR_OFFSET)");
  <D.29421>:
  D.29330 = cfg->stack_usage;
  alloc2_size.139 = (unsigned int) alloc2_size;
  D.29414 = D.29330 - alloc2_size.139;
  D.29415 = D.29414 + 4294967292;
  D.29422 = D.29415 & 65535;
  D.29423 = D.29422 | 2411659264;
  MEM[(guint32 *)code] = D.29423;
  code = code + 4;
  <D.29406>:
  D.29330 = cfg->stack_usage;
  D.29407 = (unsigned short) D.29330;
  D.29408 = (unsigned short) alloc2_size;
  D.29409 = D.29407 - D.29408;
  D.29424 = (short int) D.29409;
  D.29425 = (int) D.29424;
  D.29330 = cfg->stack_usage;
  alloc2_size.139 = (unsigned int) alloc2_size;
  D.29414 = D.29330 - alloc2_size.139;
  D.29426 = (int) D.29414;
  D.29427 = D.29425 != D.29426;
  D.29428 = (long int) D.29427;
  D.29429 = __builtin_expect (D.29428, 0);
  if (D.29429 != 0) goto <D.29430>; else goto <D.29431>;
  <D.29430>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 5530, "mips_is_imm16(cfg->stack_usage - alloc2_size)");
  <D.29431>:
  D.29330 = cfg->stack_usage;
  alloc2_size.139 = (unsigned int) alloc2_size;
  D.29414 = D.29330 - alloc2_size.139;
  D.29432 = D.29414 & 65535;
  D.29433 = D.29432 | 666697728;
  MEM[(guint32 *)code] = D.29433;
  code = code + 4;
  code.133 = (int) code;
  D.29305 = cfg->native_code;
  D.29306 = (int) D.29305;
  D.29434 = code.133 - D.29306;
  D.29435 = (unsigned int) D.29434;
  cfg->code_len = D.29435;
  D.29312 = cfg->code_len;
  D.29307 = cfg->code_size;
  D.29436 = D.29312 >= D.29307;
  D.29437 = (long int) D.29436;
  D.29438 = __builtin_expect (D.29437, 0);
  if (D.29438 != 0) goto <D.29439>; else goto <D.29440>;
  <D.29439>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 5537, "cfg->code_len < cfg->code_size");
  <D.29440>:
  D.29441 = code;
  return D.29441;
}


mono_arch_emit_epilog (struct MonoCompile * cfg)
{
  int code.140;
  unsigned char * D.29444;
  int D.29445;
  int D.29446;
  unsigned int D.29447;
  unsigned int D.29448;
  unsigned int D.29449;
  _Bool D.29450;
  long int D.29451;
  long int D.29452;
  guint8 * code;

  code = mono_arch_emit_epilog_sub (cfg, 0B);
  MEM[(guint32 *)code] = 65011720;
  code = code + 4;
  MEM[(guint32 *)code] = 2099237;
  code = code + 4;
  code.140 = (int) code;
  D.29444 = cfg->native_code;
  D.29445 = (int) D.29444;
  D.29446 = code.140 - D.29445;
  D.29447 = (unsigned int) D.29446;
  cfg->code_len = D.29447;
  D.29448 = cfg->code_len;
  D.29449 = cfg->code_size;
  D.29450 = D.29448 >= D.29449;
  D.29451 = (long int) D.29450;
  D.29452 = __builtin_expect (D.29451, 0);
  if (D.29452 != 0) goto <D.29453>; else goto <D.29454>;
  <D.29453>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 5553, "cfg->code_len < cfg->code_size");
  <D.29454>:
}


mono_arch_emit_exceptions (struct MonoCompile * cfg)
{

}


mono_arch_finish_init ()
{
  setup_tls_access ();
}


setup_tls_access ()
{
  int tls_mode.141;
  const gchar * D.29458;
  int lmf_pthread_key.142;
  int ptk.143;
  int monothread_key.144;
  guint32 ptk;

  tls_mode.141 = tls_mode;
  if (tls_mode.141 == 1) goto <D.29456>; else goto <D.29457>;
  <D.29456>:
  return;
  <D.29457>:
  D.29458 = monoeg_g_getenv ("MONO_NO_TLS");
  if (D.29458 != 0B) goto <D.29459>; else goto <D.29460>;
  <D.29459>:
  tls_mode = 1;
  return;
  <D.29460>:
  tls_mode.141 = tls_mode;
  if (tls_mode.141 == 0) goto <D.29461>; else goto <D.29462>;
  <D.29461>:
  tls_mode = 1;
  return;
  <D.29462>:
  lmf_pthread_key.142 = lmf_pthread_key;
  if (lmf_pthread_key.142 == -1) goto <D.29464>; else goto <D.29465>;
  <D.29464>:
  ptk = mono_jit_tls_id;
  if (ptk <= 1023) goto <D.29466>; else goto <D.29467>;
  <D.29466>:
  ptk.143 = (int) ptk;
  lmf_pthread_key = ptk.143;
  <D.29467>:
  <D.29465>:
  monothread_key.144 = monothread_key;
  if (monothread_key.144 == -1) goto <D.29470>; else goto <D.29471>;
  <D.29470>:
  ptk = mono_thread_get_tls_key ();
  if (ptk <= 1023) goto <D.29472>; else goto <D.29473>;
  <D.29472>:
  ptk.143 = (int) ptk;
  monothread_key = ptk.143;
  goto <D.29474>;
  <D.29473>:
  <D.29474>:
  <D.29471>:
}


mono_arch_free_jit_tls_data (struct MonoJitTlsData * tls)
{

}


mono_arch_emit_this_vret_args (struct MonoCompile * cfg, struct MonoCallInst * inst, int this_reg, int this_type, int vt_reg)
{
  struct MonoMemPool * D.29480;
  int D.29481;
  struct MonoInst * D.29482;
  int D.29483;
  int D.29484;
  const unsigned char * D.29485;
  unsigned char D.29486;
  unsigned int D.29487;
  int D.29488;
  struct MonoBasicBlock * D.29489;
  int D.29490;
  int D.29493;
  struct MonoInst * D.29494;
  int D.29495;
  int D.29496;
  unsigned int D.29497;
  int D.29498;
  int D.29499;
  int this_dreg;

  this_dreg = 4;
  if (vt_reg != -1) goto <D.29476>; else goto <D.29477>;
  <D.29476>:
  this_dreg = 5;
  <D.29477>:
  if (this_reg != -1) goto <D.29478>; else goto <D.29479>;
  <D.29478>:
  {
    struct MonoInst * this;

    D.29480 = cfg->mempool;
    this = mono_mempool_alloc (D.29480, 56);
    this->data.op[1].const_val = 0;
    D.29481 = this->data.op[1].const_val;
    this->data.op[0].const_val = D.29481;
    this->prev = 0B;
    D.29482 = this->prev;
    this->next = D.29482;
    this->opcode = 424;
    this->flags = 0;
    this->type = 0;
    this->dreg = -1;
    this->sreg3 = -1;
    D.29483 = this->sreg3;
    this->sreg2 = D.29483;
    D.29484 = this->sreg2;
    this->sreg1 = D.29484;
    D.29485 = cfg->ip;
    this->cil_code = D.29485;
    D.29486 = (unsigned char) this_type;
    this->type = D.29486;
    this->sreg1 = this_reg;
    D.29487 = mono_alloc_ireg (cfg);
    D.29488 = (int) D.29487;
    this->dreg = D.29488;
    D.29489 = cfg->cbb;
    mono_bblock_add_inst (D.29489, this);
    D.29490 = this->dreg;
    mono_call_inst_add_outarg_reg (cfg, inst, D.29490, this_dreg, 0);
  }
  <D.29479>:
  if (vt_reg != -1) goto <D.29491>; else goto <D.29492>;
  <D.29491>:
  {
    struct MonoInst * vtarg;

    D.29480 = cfg->mempool;
    vtarg = mono_mempool_alloc (D.29480, 56);
    vtarg->data.op[1].const_val = 0;
    D.29493 = vtarg->data.op[1].const_val;
    vtarg->data.op[0].const_val = D.29493;
    vtarg->prev = 0B;
    D.29494 = vtarg->prev;
    vtarg->next = D.29494;
    vtarg->opcode = 424;
    vtarg->flags = 0;
    vtarg->type = 0;
    vtarg->dreg = -1;
    vtarg->sreg3 = -1;
    D.29495 = vtarg->sreg3;
    vtarg->sreg2 = D.29495;
    D.29496 = vtarg->sreg2;
    vtarg->sreg1 = D.29496;
    D.29485 = cfg->ip;
    vtarg->cil_code = D.29485;
    vtarg->type = 5;
    vtarg->sreg1 = vt_reg;
    D.29497 = mono_alloc_ireg (cfg);
    D.29498 = (int) D.29497;
    vtarg->dreg = D.29498;
    D.29489 = cfg->cbb;
    mono_bblock_add_inst (D.29489, vtarg);
    D.29499 = vtarg->dreg;
    mono_call_inst_add_outarg_reg (cfg, inst, D.29499, 4, 0);
  }
  <D.29492>:
}


mono_arch_get_inst_for_method (struct MonoCompile * cfg, struct MonoMethod * cmethod, struct MonoMethodSignature * fsig, struct MonoInst * * args)
{
  struct MonoInst * D.29500;
  struct MonoInst * ins;

  ins = 0B;
  D.29500 = ins;
  return D.29500;
}


mono_arch_emit_inst_for_method (struct MonoCompile * cfg, struct MonoMethod * cmethod, struct MonoMethodSignature * fsig, struct MonoInst * * args)
{
  struct MonoInst * D.29502;

  D.29502 = 0B;
  return D.29502;
}


mono_arch_print_tree (struct MonoInst * tree, int arity)
{
  gboolean D.29504;

  D.29504 = 0;
  return D.29504;
}


mono_arch_context_get_int_reg (struct MonoContext * ctx, int reg)
{
  mgreg_t D.29506;

  D.29506 = ctx->sc_regs[reg];
  return D.29506;
}


mono_arch_build_imt_thunk (struct MonoVTable * vtable, struct MonoDomain * domain, struct MonoIMTCheckItem * * imt_entries, int count, void * fail_tramp)
{
  unsigned int i.145;
  unsigned int D.29509;
  struct MonoIMTCheckItem * * D.29510;
  unsigned char D.29511;
  int D.29514;
  unsigned char D.29517;
  unsigned char D.29518;
  unsigned char D.29519;
  unsigned char D.29522;
  unsigned char D.29524;
  unsigned char D.29528;
  unsigned char D.29532;
  unsigned char D.29534;
  unsigned int D.29535;
  unsigned int D.29536;
  struct MonoIMTCheckItem * * D.29537;
  struct MonoIMTCheckItem * D.29538;
  int D.29539;
  void * * D.29543;
  int D.29544;
  short int D.29545;
  int D.29546;
  int D.29547;
  unsigned int D.29550;
  unsigned int D.29551;
  unsigned int D.29554;
  unsigned int D.29555;
  unsigned int D.29556;
  unsigned int D.29557;
  unsigned int D.29559;
  unsigned int D.29560;
  unsigned int D.29563;
  unsigned int D.29565;
  unsigned char D.29566;
  int D.29569;
  void * D.29572;
  int D.29573;
  short int D.29574;
  int D.29575;
  int D.29576;
  unsigned int D.29579;
  unsigned int D.29580;
  unsigned int D.29583;
  unsigned int D.29584;
  unsigned int D.29585;
  unsigned int D.29586;
  unsigned int D.29588;
  unsigned int D.29589;
  unsigned int D.29592;
  unsigned int D.29594;
  unsigned char D.29595;
  void * D.29598;
  int D.29599;
  short int D.29600;
  int D.29601;
  unsigned int D.29604;
  unsigned int D.29605;
  unsigned int D.29608;
  unsigned int D.29609;
  unsigned int D.29610;
  unsigned int D.29611;
  unsigned int D.29613;
  unsigned int D.29614;
  unsigned int D.29617;
  unsigned int D.29619;
  int D.29621;
  unsigned int D.29622;
  unsigned int D.29623;
  unsigned int D.29624;
  unsigned int D.29625;
  _Bool D.29648;
  long int D.29649;
  long int D.29650;
  void * * D.29653;
  int D.29654;
  short int D.29655;
  int D.29656;
  unsigned int D.29659;
  unsigned int D.29660;
  unsigned int D.29663;
  unsigned int D.29664;
  unsigned int D.29665;
  unsigned int D.29666;
  unsigned int D.29668;
  unsigned int D.29669;
  unsigned int D.29672;
  unsigned int D.29674;
  unsigned int code.146;
  int fail_tramp.147;
  short int D.29677;
  int D.29678;
  unsigned int fail_tramp.148;
  unsigned int D.29682;
  unsigned int D.29685;
  unsigned int D.29686;
  unsigned int D.29687;
  unsigned int D.29688;
  unsigned int D.29690;
  unsigned int D.29691;
  unsigned int D.29694;
  unsigned int D.29696;
  guint8 * D.29707;
  int D.29710;
  unsigned int D.29713;
  unsigned int D.29714;
  struct MonoIMTCheckItem * * D.29715;
  struct MonoIMTCheckItem * D.29716;
  guint8 * D.29717;
  unsigned int D.29718;
  long unsigned int D.29721;
  int code.149;
  int start.150;
  int D.29724;
  long unsigned int D.29725;
  long unsigned int D.29726;
  _Bool D.29727;
  long int D.29728;
  long int D.29729;
  void * D.29732;
  int i;
  int size;
  guint8 * code;
  guint8 * start;
  guint8 * patch;

  size = 0;
  i = 0;
  goto <D.23354>;
  <D.23353>:
  {
    struct MonoIMTCheckItem * item;

    i.145 = (unsigned int) i;
    D.29509 = i.145 * 4;
    D.29510 = imt_entries + D.29509;
    item = *D.29510;
    D.29511 = item->is_equals;
    if (D.29511 != 0) goto <D.29512>; else goto <D.29513>;
    <D.29512>:
    D.29514 = item->check_target_idx;
    if (D.29514 != 0) goto <D.29515>; else goto <D.29516>;
    <D.29515>:
    D.29517 = item->chunk_size;
    D.29518 = D.29517 + 24;
    item->chunk_size = D.29518;
    D.29519 = item->has_target_code;
    if (D.29519 != 0) goto <D.29520>; else goto <D.29521>;
    <D.29520>:
    D.29517 = item->chunk_size;
    D.29522 = D.29517 + 8;
    item->chunk_size = D.29522;
    goto <D.29523>;
    <D.29521>:
    D.29517 = item->chunk_size;
    D.29524 = D.29517 + 4;
    item->chunk_size = D.29524;
    <D.29523>:
    goto <D.29525>;
    <D.29516>:
    if (fail_tramp != 0B) goto <D.29526>; else goto <D.29527>;
    <D.29526>:
    D.29517 = item->chunk_size;
    D.29528 = D.29517 + 52;
    item->chunk_size = D.29528;
    D.29519 = item->has_target_code;
    if (D.29519 == 0) goto <D.29529>; else goto <D.29530>;
    <D.29529>:
    D.29517 = item->chunk_size;
    D.29524 = D.29517 + 4;
    item->chunk_size = D.29524;
    <D.29530>:
    goto <D.29531>;
    <D.29527>:
    D.29517 = item->chunk_size;
    D.29532 = D.29517 + 12;
    item->chunk_size = D.29532;
    <D.29531>:
    <D.29525>:
    goto <D.29533>;
    <D.29513>:
    D.29517 = item->chunk_size;
    D.29534 = D.29517 + 20;
    item->chunk_size = D.29534;
    D.29514 = item->check_target_idx;
    D.29535 = (unsigned int) D.29514;
    D.29536 = D.29535 * 4;
    D.29537 = imt_entries + D.29536;
    D.29538 = *D.29537;
    D.29538->compare_done = 1;
    <D.29533>:
    D.29517 = item->chunk_size;
    D.29539 = (int) D.29517;
    size = D.29539 + size;
  }
  i = i + 1;
  <D.23354>:
  if (i < count) goto <D.23353>; else goto <D.23355>;
  <D.23355>:
  size = size + 8;
  if (fail_tramp != 0B) goto <D.29540>; else goto <D.29541>;
  <D.29540>:
  code = mono_method_alloc_generic_virtual_thunk (domain, size);
  goto <D.29542>;
  <D.29541>:
  code = mono_domain_code_reserve (domain, size);
  <D.29542>:
  start = code;
  D.29543 = &vtable->vtable[0];
  D.29544 = (int) D.29543;
  D.29545 = (short int) D.29544;
  D.29546 = (int) D.29545;
  D.29543 = &vtable->vtable[0];
  D.29547 = (int) D.29543;
  if (D.29546 != D.29547) goto <D.29548>; else goto <D.29549>;
  <D.29548>:
  D.29543 = &vtable->vtable[0];
  D.29550 = (unsigned int) D.29543;
  D.29551 = D.29550 & 32768;
  if (D.29551 != 0) goto <D.29552>; else goto <D.29553>;
  <D.29552>:
  D.29543 = &vtable->vtable[0];
  D.29550 = (unsigned int) D.29543;
  D.29554 = D.29550 >> 16;
  D.29555 = D.29554 + 1;
  D.29556 = D.29555 & 65535;
  D.29557 = D.29556 | 1007616000;
  MEM[(guint32 *)code] = D.29557;
  code = code + 4;
  goto <D.29558>;
  <D.29553>:
  D.29543 = &vtable->vtable[0];
  D.29550 = (unsigned int) D.29543;
  D.29554 = D.29550 >> 16;
  D.29559 = D.29554 | 1007616000;
  MEM[(guint32 *)code] = D.29559;
  code = code + 4;
  <D.29558>:
  D.29543 = &vtable->vtable[0];
  D.29550 = (unsigned int) D.29543;
  D.29560 = D.29550 & 65535;
  if (D.29560 != 0) goto <D.29561>; else goto <D.29562>;
  <D.29561>:
  D.29543 = &vtable->vtable[0];
  D.29550 = (unsigned int) D.29543;
  D.29560 = D.29550 & 65535;
  D.29563 = D.29560 | 636420096;
  MEM[(guint32 *)code] = D.29563;
  code = code + 4;
  <D.29562>:
  goto <D.29564>;
  <D.29549>:
  D.29543 = &vtable->vtable[0];
  D.29550 = (unsigned int) D.29543;
  D.29560 = D.29550 & 65535;
  D.29565 = D.29560 | 604962816;
  MEM[(guint32 *)code] = D.29565;
  code = code + 4;
  <D.29564>:
  i = 0;
  goto <D.23358>;
  <D.23357>:
  {
    struct MonoIMTCheckItem * item;

    i.145 = (unsigned int) i;
    D.29509 = i.145 * 4;
    D.29510 = imt_entries + D.29509;
    item = *D.29510;
    item->code_target = code;
    D.29566 = item->is_equals;
    if (D.29566 != 0) goto <D.29567>; else goto <D.29568>;
    <D.29567>:
    D.29569 = item->check_target_idx;
    if (D.29569 != 0) goto <D.29570>; else goto <D.29571>;
    <D.29570>:
    D.29572 = item->key;
    D.29573 = (int) D.29572;
    D.29574 = (short int) D.29573;
    D.29575 = (int) D.29574;
    D.29572 = item->key;
    D.29576 = (int) D.29572;
    if (D.29575 != D.29576) goto <D.29577>; else goto <D.29578>;
    <D.29577>:
    D.29572 = item->key;
    D.29579 = (unsigned int) D.29572;
    D.29580 = D.29579 & 32768;
    if (D.29580 != 0) goto <D.29581>; else goto <D.29582>;
    <D.29581>:
    D.29572 = item->key;
    D.29579 = (unsigned int) D.29572;
    D.29583 = D.29579 >> 16;
    D.29584 = D.29583 + 1;
    D.29585 = D.29584 & 65535;
    D.29586 = D.29585 | 1008205824;
    MEM[(guint32 *)code] = D.29586;
    code = code + 4;
    goto <D.29587>;
    <D.29582>:
    D.29572 = item->key;
    D.29579 = (unsigned int) D.29572;
    D.29583 = D.29579 >> 16;
    D.29588 = D.29583 | 1008205824;
    MEM[(guint32 *)code] = D.29588;
    code = code + 4;
    <D.29587>:
    D.29572 = item->key;
    D.29579 = (unsigned int) D.29572;
    D.29589 = D.29579 & 65535;
    if (D.29589 != 0) goto <D.29590>; else goto <D.29591>;
    <D.29590>:
    D.29572 = item->key;
    D.29579 = (unsigned int) D.29572;
    D.29589 = D.29579 & 65535;
    D.29592 = D.29589 | 655884288;
    MEM[(guint32 *)code] = D.29592;
    code = code + 4;
    <D.29591>:
    goto <D.29593>;
    <D.29578>:
    D.29572 = item->key;
    D.29579 = (unsigned int) D.29572;
    D.29589 = D.29579 & 65535;
    D.29594 = D.29589 | 605552640;
    MEM[(guint32 *)code] = D.29594;
    code = code + 4;
    <D.29593>:
    item->jmp_code = code;
    MEM[(guint32 *)code] = 386400256;
    code = code + 4;
    MEM[(guint32 *)code] = 2099237;
    code = code + 4;
    D.29595 = item->has_target_code;
    if (D.29595 != 0) goto <D.29596>; else goto <D.29597>;
    <D.29596>:
    D.29598 = item->value.target_code;
    D.29599 = (int) D.29598;
    D.29600 = (short int) D.29599;
    D.29601 = (int) D.29600;
    D.29598 = item->value.target_code;
    D.29599 = (int) D.29598;
    if (D.29601 != D.29599) goto <D.29602>; else goto <D.29603>;
    <D.29602>:
    D.29598 = item->value.target_code;
    D.29604 = (unsigned int) D.29598;
    D.29605 = D.29604 & 32768;
    if (D.29605 != 0) goto <D.29606>; else goto <D.29607>;
    <D.29606>:
    D.29598 = item->value.target_code;
    D.29604 = (unsigned int) D.29598;
    D.29608 = D.29604 >> 16;
    D.29609 = D.29608 + 1;
    D.29610 = D.29609 & 65535;
    D.29611 = D.29610 | 1008271360;
    MEM[(guint32 *)code] = D.29611;
    code = code + 4;
    goto <D.29612>;
    <D.29607>:
    D.29598 = item->value.target_code;
    D.29604 = (unsigned int) D.29598;
    D.29608 = D.29604 >> 16;
    D.29613 = D.29608 | 1008271360;
    MEM[(guint32 *)code] = D.29613;
    code = code + 4;
    <D.29612>:
    D.29598 = item->value.target_code;
    D.29604 = (unsigned int) D.29598;
    D.29614 = D.29604 & 65535;
    if (D.29614 != 0) goto <D.29615>; else goto <D.29616>;
    <D.29615>:
    D.29598 = item->value.target_code;
    D.29604 = (unsigned int) D.29598;
    D.29614 = D.29604 & 65535;
    D.29617 = D.29614 | 658046976;
    MEM[(guint32 *)code] = D.29617;
    code = code + 4;
    <D.29616>:
    goto <D.29618>;
    <D.29603>:
    D.29598 = item->value.target_code;
    D.29604 = (unsigned int) D.29598;
    D.29614 = D.29604 & 65535;
    D.29619 = D.29614 | 605618176;
    MEM[(guint32 *)code] = D.29619;
    code = code + 4;
    <D.29618>:
    goto <D.29620>;
    <D.29597>:
    D.29621 = item->value.vtable_slot;
    D.29622 = (unsigned int) D.29621;
    D.29623 = D.29622 * 4;
    D.29624 = D.29623 & 65535;
    D.29625 = D.29624 | 2381905920;
    MEM[(guint32 *)code] = D.29625;
    code = code + 4;
    <D.29620>:
    MEM[(guint32 *)code] = 52428808;
    code = code + 4;
    MEM[(guint32 *)code] = 2099237;
    code = code + 4;
    goto <D.29626>;
    <D.29571>:
    if (fail_tramp != 0B) goto <D.29627>; else goto <D.29628>;
    <D.29627>:
    D.29572 = item->key;
    D.29573 = (int) D.29572;
    D.29574 = (short int) D.29573;
    D.29575 = (int) D.29574;
    D.29572 = item->key;
    D.29576 = (int) D.29572;
    if (D.29575 != D.29576) goto <D.29629>; else goto <D.29630>;
    <D.29629>:
    D.29572 = item->key;
    D.29579 = (unsigned int) D.29572;
    D.29580 = D.29579 & 32768;
    if (D.29580 != 0) goto <D.29631>; else goto <D.29632>;
    <D.29631>:
    D.29572 = item->key;
    D.29579 = (unsigned int) D.29572;
    D.29583 = D.29579 >> 16;
    D.29584 = D.29583 + 1;
    D.29585 = D.29584 & 65535;
    D.29586 = D.29585 | 1008205824;
    MEM[(guint32 *)code] = D.29586;
    code = code + 4;
    goto <D.29633>;
    <D.29632>:
    D.29572 = item->key;
    D.29579 = (unsigned int) D.29572;
    D.29583 = D.29579 >> 16;
    D.29588 = D.29583 | 1008205824;
    MEM[(guint32 *)code] = D.29588;
    code = code + 4;
    <D.29633>:
    D.29572 = item->key;
    D.29579 = (unsigned int) D.29572;
    D.29589 = D.29579 & 65535;
    if (D.29589 != 0) goto <D.29634>; else goto <D.29635>;
    <D.29634>:
    D.29572 = item->key;
    D.29579 = (unsigned int) D.29572;
    D.29589 = D.29579 & 65535;
    D.29592 = D.29589 | 655884288;
    MEM[(guint32 *)code] = D.29592;
    code = code + 4;
    <D.29635>:
    goto <D.29636>;
    <D.29630>:
    D.29572 = item->key;
    D.29579 = (unsigned int) D.29572;
    D.29589 = D.29579 & 65535;
    D.29594 = D.29589 | 605552640;
    MEM[(guint32 *)code] = D.29594;
    code = code + 4;
    <D.29636>:
    patch = code;
    MEM[(guint32 *)code] = 386400256;
    code = code + 4;
    MEM[(guint32 *)code] = 2099237;
    code = code + 4;
    D.29595 = item->has_target_code;
    if (D.29595 != 0) goto <D.29637>; else goto <D.29638>;
    <D.29637>:
    D.29598 = item->value.target_code;
    D.29599 = (int) D.29598;
    D.29600 = (short int) D.29599;
    D.29601 = (int) D.29600;
    D.29598 = item->value.target_code;
    D.29599 = (int) D.29598;
    if (D.29601 != D.29599) goto <D.29639>; else goto <D.29640>;
    <D.29639>:
    D.29598 = item->value.target_code;
    D.29604 = (unsigned int) D.29598;
    D.29605 = D.29604 & 32768;
    if (D.29605 != 0) goto <D.29641>; else goto <D.29642>;
    <D.29641>:
    D.29598 = item->value.target_code;
    D.29604 = (unsigned int) D.29598;
    D.29608 = D.29604 >> 16;
    D.29609 = D.29608 + 1;
    D.29610 = D.29609 & 65535;
    D.29611 = D.29610 | 1008271360;
    MEM[(guint32 *)code] = D.29611;
    code = code + 4;
    goto <D.29643>;
    <D.29642>:
    D.29598 = item->value.target_code;
    D.29604 = (unsigned int) D.29598;
    D.29608 = D.29604 >> 16;
    D.29613 = D.29608 | 1008271360;
    MEM[(guint32 *)code] = D.29613;
    code = code + 4;
    <D.29643>:
    D.29598 = item->value.target_code;
    D.29604 = (unsigned int) D.29598;
    D.29614 = D.29604 & 65535;
    if (D.29614 != 0) goto <D.29644>; else goto <D.29645>;
    <D.29644>:
    D.29598 = item->value.target_code;
    D.29604 = (unsigned int) D.29598;
    D.29614 = D.29604 & 65535;
    D.29617 = D.29614 | 658046976;
    MEM[(guint32 *)code] = D.29617;
    code = code + 4;
    <D.29645>:
    goto <D.29646>;
    <D.29640>:
    D.29598 = item->value.target_code;
    D.29604 = (unsigned int) D.29598;
    D.29614 = D.29604 & 65535;
    D.29619 = D.29614 | 605618176;
    MEM[(guint32 *)code] = D.29619;
    code = code + 4;
    <D.29646>:
    goto <D.29647>;
    <D.29638>:
    D.29648 = vtable == 0B;
    D.29649 = (long int) D.29648;
    D.29650 = __builtin_expect (D.29649, 0);
    if (D.29650 != 0) goto <D.29651>; else goto <D.29652>;
    <D.29651>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 5942, "vtable");
    <D.29652>:
    D.29621 = item->value.vtable_slot;
    D.29653 = &vtable->vtable[D.29621];
    D.29654 = (int) D.29653;
    D.29655 = (short int) D.29654;
    D.29656 = (int) D.29655;
    D.29621 = item->value.vtable_slot;
    D.29653 = &vtable->vtable[D.29621];
    D.29654 = (int) D.29653;
    if (D.29656 != D.29654) goto <D.29657>; else goto <D.29658>;
    <D.29657>:
    D.29621 = item->value.vtable_slot;
    D.29653 = &vtable->vtable[D.29621];
    D.29659 = (unsigned int) D.29653;
    D.29660 = D.29659 & 32768;
    if (D.29660 != 0) goto <D.29661>; else goto <D.29662>;
    <D.29661>:
    D.29621 = item->value.vtable_slot;
    D.29653 = &vtable->vtable[D.29621];
    D.29659 = (unsigned int) D.29653;
    D.29663 = D.29659 >> 16;
    D.29664 = D.29663 + 1;
    D.29665 = D.29664 & 65535;
    D.29666 = D.29665 | 1006698496;
    MEM[(guint32 *)code] = D.29666;
    code = code + 4;
    goto <D.29667>;
    <D.29662>:
    D.29621 = item->value.vtable_slot;
    D.29653 = &vtable->vtable[D.29621];
    D.29659 = (unsigned int) D.29653;
    D.29663 = D.29659 >> 16;
    D.29668 = D.29663 | 1006698496;
    MEM[(guint32 *)code] = D.29668;
    code = code + 4;
    <D.29667>:
    D.29621 = item->value.vtable_slot;
    D.29653 = &vtable->vtable[D.29621];
    D.29659 = (unsigned int) D.29653;
    D.29669 = D.29659 & 65535;
    if (D.29669 != 0) goto <D.29670>; else goto <D.29671>;
    <D.29670>:
    D.29621 = item->value.vtable_slot;
    D.29653 = &vtable->vtable[D.29621];
    D.29659 = (unsigned int) D.29653;
    D.29669 = D.29659 & 65535;
    D.29672 = D.29669 | 606142464;
    MEM[(guint32 *)code] = D.29672;
    code = code + 4;
    <D.29671>:
    goto <D.29673>;
    <D.29658>:
    D.29621 = item->value.vtable_slot;
    D.29653 = &vtable->vtable[D.29621];
    D.29659 = (unsigned int) D.29653;
    D.29669 = D.29659 & 65535;
    D.29674 = D.29669 | 604045312;
    MEM[(guint32 *)code] = D.29674;
    code = code + 4;
    <D.29673>:
    MEM[(guint32 *)code] = 2352545792;
    code = code + 4;
    <D.29647>:
    MEM[(guint32 *)code] = 52428808;
    code = code + 4;
    MEM[(guint32 *)code] = 2099237;
    code = code + 4;
    code.146 = (unsigned int) code;
    mips_patch (patch, code.146);
    fail_tramp.147 = (int) fail_tramp;
    D.29677 = (short int) fail_tramp.147;
    D.29678 = (int) D.29677;
    fail_tramp.147 = (int) fail_tramp;
    if (D.29678 != fail_tramp.147) goto <D.29679>; else goto <D.29680>;
    <D.29679>:
    fail_tramp.148 = (unsigned int) fail_tramp;
    D.29682 = fail_tramp.148 & 32768;
    if (D.29682 != 0) goto <D.29683>; else goto <D.29684>;
    <D.29683>:
    fail_tramp.148 = (unsigned int) fail_tramp;
    D.29685 = fail_tramp.148 >> 16;
    D.29686 = D.29685 + 1;
    D.29687 = D.29686 & 65535;
    D.29688 = D.29687 | 1008271360;
    MEM[(guint32 *)code] = D.29688;
    code = code + 4;
    goto <D.29689>;
    <D.29684>:
    fail_tramp.148 = (unsigned int) fail_tramp;
    D.29685 = fail_tramp.148 >> 16;
    D.29690 = D.29685 | 1008271360;
    MEM[(guint32 *)code] = D.29690;
    code = code + 4;
    <D.29689>:
    fail_tramp.148 = (unsigned int) fail_tramp;
    D.29691 = fail_tramp.148 & 65535;
    if (D.29691 != 0) goto <D.29692>; else goto <D.29693>;
    <D.29692>:
    fail_tramp.148 = (unsigned int) fail_tramp;
    D.29691 = fail_tramp.148 & 65535;
    D.29694 = D.29691 | 658046976;
    MEM[(guint32 *)code] = D.29694;
    code = code + 4;
    <D.29693>:
    goto <D.29695>;
    <D.29680>:
    fail_tramp.148 = (unsigned int) fail_tramp;
    D.29691 = fail_tramp.148 & 65535;
    D.29696 = D.29691 | 605618176;
    MEM[(guint32 *)code] = D.29696;
    code = code + 4;
    <D.29695>:
    MEM[(guint32 *)code] = 52428808;
    code = code + 4;
    MEM[(guint32 *)code] = 2099237;
    code = code + 4;
    goto <D.29697>;
    <D.29628>:
    D.29621 = item->value.vtable_slot;
    D.29622 = (unsigned int) D.29621;
    D.29623 = D.29622 * 4;
    D.29624 = D.29623 & 65535;
    D.29625 = D.29624 | 2381905920;
    MEM[(guint32 *)code] = D.29625;
    code = code + 4;
    MEM[(guint32 *)code] = 52428808;
    code = code + 4;
    MEM[(guint32 *)code] = 2099237;
    code = code + 4;
    <D.29697>:
    <D.29626>:
    goto <D.29698>;
    <D.29568>:
    D.29572 = item->key;
    D.29573 = (int) D.29572;
    D.29574 = (short int) D.29573;
    D.29575 = (int) D.29574;
    D.29572 = item->key;
    D.29576 = (int) D.29572;
    if (D.29575 != D.29576) goto <D.29699>; else goto <D.29700>;
    <D.29699>:
    D.29572 = item->key;
    D.29579 = (unsigned int) D.29572;
    D.29580 = D.29579 & 32768;
    if (D.29580 != 0) goto <D.29701>; else goto <D.29702>;
    <D.29701>:
    D.29572 = item->key;
    D.29579 = (unsigned int) D.29572;
    D.29583 = D.29579 >> 16;
    D.29584 = D.29583 + 1;
    D.29585 = D.29584 & 65535;
    D.29586 = D.29585 | 1008205824;
    MEM[(guint32 *)code] = D.29586;
    code = code + 4;
    goto <D.29703>;
    <D.29702>:
    D.29572 = item->key;
    D.29579 = (unsigned int) D.29572;
    D.29583 = D.29579 >> 16;
    D.29588 = D.29583 | 1008205824;
    MEM[(guint32 *)code] = D.29588;
    code = code + 4;
    <D.29703>:
    D.29572 = item->key;
    D.29579 = (unsigned int) D.29572;
    D.29589 = D.29579 & 65535;
    if (D.29589 != 0) goto <D.29704>; else goto <D.29705>;
    <D.29704>:
    D.29572 = item->key;
    D.29579 = (unsigned int) D.29572;
    D.29589 = D.29579 & 65535;
    D.29592 = D.29589 | 655884288;
    MEM[(guint32 *)code] = D.29592;
    code = code + 4;
    <D.29705>:
    goto <D.29706>;
    <D.29700>:
    D.29572 = item->key;
    D.29579 = (unsigned int) D.29572;
    D.29589 = D.29579 & 65535;
    D.29594 = D.29589 | 605552640;
    MEM[(guint32 *)code] = D.29594;
    code = code + 4;
    <D.29706>:
    MEM[(guint32 *)code] = 18399274;
    code = code + 4;
    item->jmp_code = code;
    MEM[(guint32 *)code] = 318767104;
    code = code + 4;
    MEM[(guint32 *)code] = 2099237;
    code = code + 4;
    <D.29698>:
  }
  i = i + 1;
  <D.23358>:
  if (i < count) goto <D.23357>; else goto <D.23359>;
  <D.23359>:
  i = 0;
  goto <D.23362>;
  <D.23361>:
  {
    struct MonoIMTCheckItem * item;

    i.145 = (unsigned int) i;
    D.29509 = i.145 * 4;
    D.29510 = imt_entries + D.29509;
    item = *D.29510;
    D.29707 = item->jmp_code;
    if (D.29707 != 0B) goto <D.29708>; else goto <D.29709>;
    <D.29708>:
    D.29710 = item->check_target_idx;
    if (D.29710 != 0) goto <D.29711>; else goto <D.29712>;
    <D.29711>:
    D.29707 = item->jmp_code;
    D.29710 = item->check_target_idx;
    D.29713 = (unsigned int) D.29710;
    D.29714 = D.29713 * 4;
    D.29715 = imt_entries + D.29714;
    D.29716 = *D.29715;
    D.29717 = D.29716->code_target;
    D.29718 = (unsigned int) D.29717;
    mips_patch (D.29707, D.29718);
    <D.29712>:
    <D.29709>:
  }
  i = i + 1;
  <D.23362>:
  if (i < count) goto <D.23361>; else goto <D.23363>;
  <D.23363>:
  if (fail_tramp == 0B) goto <D.29719>; else goto <D.29720>;
  <D.29719>:
  D.29721 = mono_stats.imt_thunks_size;
  code.149 = (int) code;
  start.150 = (int) start;
  D.29724 = code.149 - start.150;
  D.29725 = (long unsigned int) D.29724;
  D.29726 = D.29721 + D.29725;
  mono_stats.imt_thunks_size = D.29726;
  <D.29720>:
  code.149 = (int) code;
  start.150 = (int) start;
  D.29724 = code.149 - start.150;
  D.29727 = D.29724 > size;
  D.29728 = (long int) D.29727;
  D.29729 = __builtin_expect (D.29728, 0);
  if (D.29729 != 0) goto <D.29730>; else goto <D.29731>;
  <D.29730>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-mips.c", 5992, "code - start <= size");
  <D.29731>:
  mono_arch_flush_icache (start, size);
  D.29732 = start;
  return D.29732;
}


mono_arch_find_imt_method (mgreg_t * regs, guint8 * code)
{
  struct MonoMethod * D.29734;
  mgreg_t * D.29735;
  int D.29736;

  D.29735 = regs + 32;
  D.29736 = *D.29735;
  D.29734 = (struct MonoMethod *) D.29736;
  return D.29734;
}


mono_arch_find_static_call_vtable (mgreg_t * regs, guint8 * code)
{
  struct MonoVTable * D.29738;
  mgreg_t * D.29739;
  int D.29740;

  D.29739 = regs + 32;
  D.29740 = *D.29739;
  D.29738 = (struct MonoVTable *) D.29740;
  return D.29738;
}


mono_arch_set_breakpoint (struct MonoJitInfo * ji, guint8 * ip)
{
  void * bp_trigger_page.151;
  short int D.29743;
  int D.29744;
  int addr.152;
  unsigned int D.29748;
  unsigned int D.29751;
  unsigned int D.29752;
  unsigned int D.29753;
  unsigned int D.29754;
  unsigned int D.29756;
  unsigned int D.29757;
  unsigned int D.29760;
  unsigned int D.29762;
  int code.153;
  int ip.154;
  int D.29765;
  guint8 * code;
  guint32 addr;

  code = ip;
  bp_trigger_page.151 = bp_trigger_page;
  addr = (guint32) bp_trigger_page.151;
  D.29743 = (short int) addr;
  D.29744 = (int) D.29743;
  addr.152 = (int) addr;
  if (D.29744 != addr.152) goto <D.29746>; else goto <D.29747>;
  <D.29746>:
  D.29748 = addr & 32768;
  if (D.29748 != 0) goto <D.29749>; else goto <D.29750>;
  <D.29749>:
  D.29751 = addr >> 16;
  D.29752 = D.29751 + 1;
  D.29753 = D.29752 & 65535;
  D.29754 = D.29753 | 1008271360;
  MEM[(guint32 *)code] = D.29754;
  code = code + 4;
  goto <D.29755>;
  <D.29750>:
  D.29751 = addr >> 16;
  D.29756 = D.29751 | 1008271360;
  MEM[(guint32 *)code] = D.29756;
  code = code + 4;
  <D.29755>:
  D.29757 = addr & 65535;
  if (D.29757 != 0) goto <D.29758>; else goto <D.29759>;
  <D.29758>:
  D.29757 = addr & 65535;
  D.29760 = D.29757 | 658046976;
  MEM[(guint32 *)code] = D.29760;
  code = code + 4;
  <D.29759>:
  goto <D.29761>;
  <D.29747>:
  D.29757 = addr & 65535;
  D.29762 = D.29757 | 605618176;
  MEM[(guint32 *)code] = D.29762;
  code = code + 4;
  <D.29761>:
  MEM[(guint32 *)code] = 2402877440;
  code = code + 4;
  code.153 = (int) code;
  ip.154 = (int) ip;
  D.29765 = code.153 - ip.154;
  mono_arch_flush_icache (ip, D.29765);
}


mono_arch_clear_breakpoint (struct MonoJitInfo * ji, guint8 * ip)
{
  int code.155;
  int ip.156;
  int D.29768;
  guint8 * code;

  code = ip;
  MEM[(guint32 *)code] = 2099237;
  code = code + 4;
  MEM[(guint32 *)code] = 2099237;
  code = code + 4;
  MEM[(guint32 *)code] = 2099237;
  code = code + 4;
  code.155 = (int) code;
  ip.156 = (int) ip;
  D.29768 = code.155 - ip.156;
  mono_arch_flush_icache (ip, D.29768);
}


mono_arch_start_single_stepping ()
{
  void * ss_trigger_page.157;
  int D.29770;
  unsigned int D.29771;

  ss_trigger_page.157 = ss_trigger_page;
  D.29770 = mono_pagesize ();
  D.29771 = (unsigned int) D.29770;
  mono_mprotect (ss_trigger_page.157, D.29771, 0);
}


mono_arch_stop_single_stepping ()
{
  void * ss_trigger_page.158;
  int D.29773;
  unsigned int D.29774;

  ss_trigger_page.158 = ss_trigger_page;
  D.29773 = mono_pagesize ();
  D.29774 = (unsigned int) D.29773;
  mono_mprotect (ss_trigger_page.158, D.29774, 1);
}


mono_arch_is_single_step_event (void * info, void * sigctx)
{
  void * D.29776;
  void * ss_trigger_page.159;
  guint8 * D.29779;
  gboolean D.29781;
  struct siginfo_t * sinfo;

  sinfo = info;
  D.29776 = sinfo->_sifields._sigfault.si_addr;
  ss_trigger_page.159 = ss_trigger_page;
  if (D.29776 >= ss_trigger_page.159) goto <D.29778>; else goto <D.29775>;
  <D.29778>:
  D.29776 = sinfo->_sifields._sigfault.si_addr;
  ss_trigger_page.159 = ss_trigger_page;
  D.29779 = ss_trigger_page.159 + 128;
  if (D.29776 <= D.29779) goto <D.29780>; else goto <D.29775>;
  <D.29780>:
  D.29781 = 1;
  return D.29781;
  <D.29775>:
  D.29781 = 0;
  return D.29781;
}


mono_arch_is_breakpoint_event (void * info, void * sigctx)
{
  void * D.29784;
  void * bp_trigger_page.160;
  guint8 * D.29787;
  gboolean D.29789;
  struct siginfo_t * sinfo;

  sinfo = info;
  D.29784 = sinfo->_sifields._sigfault.si_addr;
  bp_trigger_page.160 = bp_trigger_page;
  if (D.29784 >= bp_trigger_page.160) goto <D.29786>; else goto <D.29783>;
  <D.29786>:
  D.29784 = sinfo->_sifields._sigfault.si_addr;
  bp_trigger_page.160 = bp_trigger_page;
  D.29787 = bp_trigger_page.160 + 128;
  if (D.29784 <= D.29787) goto <D.29788>; else goto <D.29783>;
  <D.29788>:
  D.29789 = 1;
  return D.29789;
  <D.29783>:
  D.29789 = 0;
  return D.29789;
}


mono_arch_skip_breakpoint (struct MonoContext * ctx, struct MonoJitInfo * ji)
{
  int D.29791;
  sizetype D.29792;
  sizetype D.29793;
  int D.29794;

  D.29791 = ctx->sc_pc;
  D.29792 = (sizetype) D.29791;
  D.29793 = D.29792 + 4;
  D.29794 = (int) D.29793;
  ctx->sc_pc = D.29794;
}


mono_arch_skip_single_step (struct MonoContext * ctx)
{
  int D.29795;
  sizetype D.29796;
  sizetype D.29797;
  int D.29798;

  D.29795 = ctx->sc_pc;
  D.29796 = (sizetype) D.29795;
  D.29797 = D.29796 + 4;
  D.29798 = (int) D.29797;
  ctx->sc_pc = D.29798;
}


mono_arch_get_seq_point_info (struct MonoDomain * domain, guint8 * code)
{
  void * D.29799;

  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-mips.c", 6131);
  D.29799 = 0B;
  return D.29799;
}


mono_arch_init_lmf_ext (struct MonoLMFExt * ext, void * prev_lmf)
{
  void * D.29801;
  int D.29802;
  int D.29803;
  void * D.29804;
  int ext.161;

  ext->lmf.previous_lmf = prev_lmf;
  D.29801 = ext->lmf.previous_lmf;
  D.29802 = (int) D.29801;
  D.29803 = D.29802 | 2;
  D.29804 = (void *) D.29803;
  ext->lmf.previous_lmf = D.29804;
  ext.161 = (int) ext;
  ext->lmf.iregs[29] = ext.161;
}